LCOV - code coverage report
Current view: top level - gcc - tree-cfg.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 81.9 % 5018 4111
Test Date: 2024-11-02 13:25:42 Functions: 88.5 % 209 185
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Control flow functions for trees.
       2                 :             :    Copyright (C) 2001-2024 Free Software Foundation, Inc.
       3                 :             :    Contributed by Diego Novillo <dnovillo@redhat.com>
       4                 :             : 
       5                 :             : This file is part of GCC.
       6                 :             : 
       7                 :             : GCC is free software; you can redistribute it and/or modify
       8                 :             : it under the terms of the GNU General Public License as published by
       9                 :             : the Free Software Foundation; either version 3, or (at your option)
      10                 :             : any later version.
      11                 :             : 
      12                 :             : GCC is distributed in the hope that it will be useful,
      13                 :             : but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :             : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15                 :             : GNU General Public License for more details.
      16                 :             : 
      17                 :             : You should have received a copy of the GNU General Public License
      18                 :             : along with GCC; see the file COPYING3.  If not see
      19                 :             : <http://www.gnu.org/licenses/>.  */
      20                 :             : 
      21                 :             : #define INCLUDE_MEMORY
      22                 :             : #include "config.h"
      23                 :             : #include "system.h"
      24                 :             : #include "coretypes.h"
      25                 :             : #include "backend.h"
      26                 :             : #include "target.h"
      27                 :             : #include "rtl.h"
      28                 :             : #include "tree.h"
      29                 :             : #include "gimple.h"
      30                 :             : #include "cfghooks.h"
      31                 :             : #include "tree-pass.h"
      32                 :             : #include "ssa.h"
      33                 :             : #include "cgraph.h"
      34                 :             : #include "gimple-pretty-print.h"
      35                 :             : #include "diagnostic-core.h"
      36                 :             : #include "fold-const.h"
      37                 :             : #include "trans-mem.h"
      38                 :             : #include "stor-layout.h"
      39                 :             : #include "print-tree.h"
      40                 :             : #include "cfganal.h"
      41                 :             : #include "gimple-iterator.h"
      42                 :             : #include "gimple-fold.h"
      43                 :             : #include "tree-eh.h"
      44                 :             : #include "gimplify-me.h"
      45                 :             : #include "gimple-walk.h"
      46                 :             : #include "tree-cfg.h"
      47                 :             : #include "tree-ssa-loop-manip.h"
      48                 :             : #include "tree-ssa-loop-niter.h"
      49                 :             : #include "tree-into-ssa.h"
      50                 :             : #include "tree-dfa.h"
      51                 :             : #include "tree-ssa.h"
      52                 :             : #include "except.h"
      53                 :             : #include "cfgloop.h"
      54                 :             : #include "tree-ssa-propagate.h"
      55                 :             : #include "value-prof.h"
      56                 :             : #include "tree-inline.h"
      57                 :             : #include "tree-ssa-live.h"
      58                 :             : #include "tree-ssa-dce.h"
      59                 :             : #include "omp-general.h"
      60                 :             : #include "omp-expand.h"
      61                 :             : #include "tree-cfgcleanup.h"
      62                 :             : #include "gimplify.h"
      63                 :             : #include "attribs.h"
      64                 :             : #include "selftest.h"
      65                 :             : #include "opts.h"
      66                 :             : #include "asan.h"
      67                 :             : #include "profile.h"
      68                 :             : #include "sreal.h"
      69                 :             : 
      70                 :             : /* This file contains functions for building the Control Flow Graph (CFG)
      71                 :             :    for a function tree.  */
      72                 :             : 
      73                 :             : /* Local declarations.  */
      74                 :             : 
      75                 :             : /* Initial capacity for the basic block array.  */
      76                 :             : static const int initial_cfg_capacity = 20;
      77                 :             : 
      78                 :             : /* This hash table allows us to efficiently lookup all CASE_LABEL_EXPRs
      79                 :             :    which use a particular edge.  The CASE_LABEL_EXPRs are chained together
      80                 :             :    via their CASE_CHAIN field, which we clear after we're done with the
      81                 :             :    hash table to prevent problems with duplication of GIMPLE_SWITCHes.
      82                 :             : 
      83                 :             :    Access to this list of CASE_LABEL_EXPRs allows us to efficiently
      84                 :             :    update the case vector in response to edge redirections.
      85                 :             : 
      86                 :             :    Right now this table is set up and torn down at key points in the
      87                 :             :    compilation process.  It would be nice if we could make the table
      88                 :             :    more persistent.  The key is getting notification of changes to
      89                 :             :    the CFG (particularly edge removal, creation and redirection).  */
      90                 :             : 
      91                 :             : static hash_map<edge, tree> *edge_to_cases;
      92                 :             : 
      93                 :             : /* If we record edge_to_cases, this bitmap will hold indexes
      94                 :             :    of basic blocks that end in a GIMPLE_SWITCH which we touched
      95                 :             :    due to edge manipulations.  */
      96                 :             : 
      97                 :             : static bitmap touched_switch_bbs;
      98                 :             : 
      99                 :             : /* OpenMP region idxs for blocks during cfg pass.  */
     100                 :             : static vec<int> bb_to_omp_idx;
     101                 :             : 
     102                 :             : /* CFG statistics.  */
     103                 :             : struct cfg_stats_d
     104                 :             : {
     105                 :             :   long num_merged_labels;
     106                 :             : };
     107                 :             : 
     108                 :             : static struct cfg_stats_d cfg_stats;
     109                 :             : 
     110                 :             : /* Data to pass to replace_block_vars_by_duplicates_1.  */
     111                 :             : struct replace_decls_d
     112                 :             : {
     113                 :             :   hash_map<tree, tree> *vars_map;
     114                 :             :   tree to_context;
     115                 :             : };
     116                 :             : 
     117                 :             : /* Hash table to store last discriminator assigned for each locus.  */
     118                 :             : struct locus_discrim_map
     119                 :             : {
     120                 :             :   int location_line;
     121                 :             :   int discriminator;
     122                 :             : };
     123                 :             : 
     124                 :             : /* Hashtable helpers.  */
     125                 :             : 
     126                 :             : struct locus_discrim_hasher : free_ptr_hash <locus_discrim_map>
     127                 :             : {
     128                 :             :   static inline hashval_t hash (const locus_discrim_map *);
     129                 :             :   static inline bool equal (const locus_discrim_map *,
     130                 :             :                             const locus_discrim_map *);
     131                 :             : };
     132                 :             : 
     133                 :             : /* Trivial hash function for a location_t.  ITEM is a pointer to
     134                 :             :    a hash table entry that maps a location_t to a discriminator.  */
     135                 :             : 
     136                 :             : inline hashval_t
     137                 :    79423499 : locus_discrim_hasher::hash (const locus_discrim_map *item)
     138                 :             : {
     139                 :    79423499 :   return item->location_line;
     140                 :             : }
     141                 :             : 
     142                 :             : /* Equality function for the locus-to-discriminator map.  A and B
     143                 :             :    point to the two hash table entries to compare.  */
     144                 :             : 
     145                 :             : inline bool
     146                 :    87758257 : locus_discrim_hasher::equal (const locus_discrim_map *a,
     147                 :             :                              const locus_discrim_map *b)
     148                 :             : {
     149                 :    87758257 :   return a->location_line == b->location_line;
     150                 :             : }
     151                 :             : 
     152                 :             : static hash_table<locus_discrim_hasher> *discriminator_per_locus;
     153                 :             : 
     154                 :             : /* Basic blocks and flowgraphs.  */
     155                 :             : static void make_blocks (gimple_seq);
     156                 :             : 
     157                 :             : /* Edges.  */
     158                 :             : static void make_edges (void);
     159                 :             : static void assign_discriminators (void);
     160                 :             : static void make_cond_expr_edges (basic_block);
     161                 :             : static void make_gimple_switch_edges (gswitch *, basic_block);
     162                 :             : static bool make_goto_expr_edges (basic_block);
     163                 :             : static void make_gimple_asm_edges (basic_block);
     164                 :             : static edge gimple_redirect_edge_and_branch (edge, basic_block);
     165                 :             : static edge gimple_try_redirect_by_replacing_jump (edge, basic_block);
     166                 :             : 
     167                 :             : /* Various helpers.  */
     168                 :             : static inline bool stmt_starts_bb_p (gimple *, gimple *);
     169                 :             : static bool gimple_verify_flow_info (void);
     170                 :             : static void gimple_make_forwarder_block (edge);
     171                 :             : static gimple *first_non_label_stmt (basic_block);
     172                 :             : static bool verify_gimple_transaction (gtransaction *);
     173                 :             : static bool call_can_make_abnormal_goto (gimple *);
     174                 :             : 
     175                 :             : /* Flowgraph optimization and cleanup.  */
     176                 :             : static void gimple_merge_blocks (basic_block, basic_block);
     177                 :             : static bool gimple_can_merge_blocks_p (basic_block, basic_block);
     178                 :             : static void remove_bb (basic_block);
     179                 :             : static edge find_taken_edge_computed_goto (basic_block, tree);
     180                 :             : static edge find_taken_edge_cond_expr (const gcond *, tree);
     181                 :             : 
     182                 :             : void
     183                 :     3049276 : init_empty_tree_cfg_for_function (struct function *fn)
     184                 :             : {
     185                 :             :   /* Initialize the basic block array.  */
     186                 :     3049276 :   init_flow (fn);
     187                 :     3049276 :   profile_status_for_fn (fn) = PROFILE_ABSENT;
     188                 :     3049276 :   n_basic_blocks_for_fn (fn) = NUM_FIXED_BLOCKS;
     189                 :     3049276 :   last_basic_block_for_fn (fn) = NUM_FIXED_BLOCKS;
     190                 :     3049276 :   vec_safe_grow_cleared (basic_block_info_for_fn (fn),
     191                 :             :                          initial_cfg_capacity, true);
     192                 :             : 
     193                 :             :   /* Build a mapping of labels to their associated blocks.  */
     194                 :     3049276 :   vec_safe_grow_cleared (label_to_block_map_for_fn (fn),
     195                 :             :                          initial_cfg_capacity, true);
     196                 :             : 
     197                 :     3049276 :   SET_BASIC_BLOCK_FOR_FN (fn, ENTRY_BLOCK, ENTRY_BLOCK_PTR_FOR_FN (fn));
     198                 :     3049276 :   SET_BASIC_BLOCK_FOR_FN (fn, EXIT_BLOCK, EXIT_BLOCK_PTR_FOR_FN (fn));
     199                 :             : 
     200                 :     3049276 :   ENTRY_BLOCK_PTR_FOR_FN (fn)->next_bb
     201                 :     3049276 :     = EXIT_BLOCK_PTR_FOR_FN (fn);
     202                 :     3049276 :   EXIT_BLOCK_PTR_FOR_FN (fn)->prev_bb
     203                 :     3049276 :     = ENTRY_BLOCK_PTR_FOR_FN (fn);
     204                 :     3049276 : }
     205                 :             : 
     206                 :             : void
     207                 :     2967673 : init_empty_tree_cfg (void)
     208                 :             : {
     209                 :     2967673 :   init_empty_tree_cfg_for_function (cfun);
     210                 :     2967673 : }
     211                 :             : 
     212                 :             : /*---------------------------------------------------------------------------
     213                 :             :                               Create basic blocks
     214                 :             : ---------------------------------------------------------------------------*/
     215                 :             : 
     216                 :             : /* Entry point to the CFG builder for trees.  SEQ is the sequence of
     217                 :             :    statements to be added to the flowgraph.  */
     218                 :             : 
     219                 :             : static void
     220                 :     2702497 : build_gimple_cfg (gimple_seq seq)
     221                 :             : {
     222                 :             :   /* Register specific gimple functions.  */
     223                 :     2702497 :   gimple_register_cfg_hooks ();
     224                 :             : 
     225                 :     2702497 :   memset ((void *) &cfg_stats, 0, sizeof (cfg_stats));
     226                 :             : 
     227                 :     2702497 :   init_empty_tree_cfg ();
     228                 :             : 
     229                 :     2702497 :   make_blocks (seq);
     230                 :             : 
     231                 :             :   /* Make sure there is always at least one block, even if it's empty.  */
     232                 :     2702497 :   if (n_basic_blocks_for_fn (cfun) == NUM_FIXED_BLOCKS)
     233                 :           0 :     create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun));
     234                 :             : 
     235                 :             :   /* Adjust the size of the array.  */
     236                 :     2702497 :   if (basic_block_info_for_fn (cfun)->length ()
     237                 :     2702497 :       < (size_t) n_basic_blocks_for_fn (cfun))
     238                 :           0 :     vec_safe_grow_cleared (basic_block_info_for_fn (cfun),
     239                 :             :                            n_basic_blocks_for_fn (cfun));
     240                 :             : 
     241                 :             :   /* To speed up statement iterator walks, we first purge dead labels.  */
     242                 :     2702497 :   cleanup_dead_labels ();
     243                 :             : 
     244                 :             :   /* Group case nodes to reduce the number of edges.
     245                 :             :      We do this after cleaning up dead labels because otherwise we miss
     246                 :             :      a lot of obvious case merging opportunities.  */
     247                 :     2702497 :   group_case_labels ();
     248                 :             : 
     249                 :             :   /* Create the edges of the flowgraph.  */
     250                 :     2702497 :   discriminator_per_locus = new hash_table<locus_discrim_hasher> (13);
     251                 :     2702497 :   make_edges ();
     252                 :     2702497 :   assign_discriminators ();
     253                 :     2702497 :   cleanup_dead_labels ();
     254                 :     2702497 :   delete discriminator_per_locus;
     255                 :     2702497 :   discriminator_per_locus = NULL;
     256                 :     2702497 : }
     257                 :             : 
     258                 :             : /* Look for ANNOTATE calls with loop annotation kind in BB; if found, remove
     259                 :             :    them and propagate the information to LOOP.  We assume that the annotations
     260                 :             :    come immediately before the condition in BB, if any.  */
     261                 :             : 
     262                 :             : static void
     263                 :     1463131 : replace_loop_annotate_in_block (basic_block bb, class loop *loop)
     264                 :             : {
     265                 :     1463131 :   gimple_stmt_iterator gsi = gsi_last_bb (bb);
     266                 :     1463131 :   gimple *stmt = gsi_stmt (gsi);
     267                 :             : 
     268                 :     1463131 :   if (!(stmt && gimple_code (stmt) == GIMPLE_COND))
     269                 :      564043 :     return;
     270                 :             : 
     271                 :      909002 :   for (gsi_prev_nondebug (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
     272                 :             :     {
     273                 :      500162 :       stmt = gsi_stmt (gsi);
     274                 :      500162 :       if (gimple_code (stmt) != GIMPLE_CALL)
     275                 :             :         break;
     276                 :       58379 :       if (!gimple_call_internal_p (stmt)
     277                 :       58379 :           || gimple_call_internal_fn (stmt) != IFN_ANNOTATE)
     278                 :             :         break;
     279                 :             : 
     280                 :        4957 :       switch ((annot_expr_kind) tree_to_shwi (gimple_call_arg (stmt, 1)))
     281                 :             :         {
     282                 :         245 :         case annot_expr_ivdep_kind:
     283                 :         245 :           loop->safelen = INT_MAX;
     284                 :         245 :           break;
     285                 :        2048 :         case annot_expr_unroll_kind:
     286                 :        2048 :           loop->unroll
     287                 :        2048 :             = (unsigned short) tree_to_shwi (gimple_call_arg (stmt, 2));
     288                 :        2048 :           cfun->has_unroll = true;
     289                 :        2048 :           break;
     290                 :        2597 :         case annot_expr_no_vector_kind:
     291                 :        2597 :           loop->dont_vectorize = true;
     292                 :        2597 :           break;
     293                 :           3 :         case annot_expr_vector_kind:
     294                 :           3 :           loop->force_vectorize = true;
     295                 :           3 :           cfun->has_force_vectorize_loops = true;
     296                 :           3 :           break;
     297                 :           0 :         case annot_expr_parallel_kind:
     298                 :           0 :           loop->can_be_parallel = true;
     299                 :           0 :           loop->safelen = INT_MAX;
     300                 :           0 :           break;
     301                 :          64 :         case annot_expr_maybe_infinite_kind:
     302                 :          64 :           loop->finite_p = false;
     303                 :          64 :           break;
     304                 :           0 :         default:
     305                 :           0 :           gcc_unreachable ();
     306                 :             :         }
     307                 :             : 
     308                 :        4957 :       stmt = gimple_build_assign (gimple_call_lhs (stmt),
     309                 :             :                                   gimple_call_arg (stmt, 0));
     310                 :        4957 :       gsi_replace (&gsi, stmt, true);
     311                 :             :     }
     312                 :             : }
     313                 :             : 
     314                 :             : /* Look for ANNOTATE calls with loop annotation kind; if found, remove
     315                 :             :    them and propagate the information to the loop.  We assume that the
     316                 :             :    annotations come immediately before the condition of the loop.  */
     317                 :             : 
     318                 :             : static void
     319                 :     2702497 : replace_loop_annotate (void)
     320                 :             : {
     321                 :     2702497 :   basic_block bb;
     322                 :     2702497 :   gimple_stmt_iterator gsi;
     323                 :     2702497 :   gimple *stmt;
     324                 :             : 
     325                 :     8664873 :   for (auto loop : loops_list (cfun, 0))
     326                 :             :     {
     327                 :             :       /* Push the global flag_finite_loops state down to individual loops.  */
     328                 :      557382 :       loop->finite_p = flag_finite_loops;
     329                 :             : 
     330                 :             :       /* Check all exit source blocks for annotations.  */
     331                 :     3126749 :       for (auto e : get_loop_exit_edges (loop))
     332                 :     2020513 :         replace_loop_annotate_in_block (e->src, loop);
     333                 :     2702497 :     }
     334                 :             : 
     335                 :             :   /* Remove IFN_ANNOTATE.  Safeguard for the case loop->latch == NULL.  */
     336                 :    19164915 :   FOR_EACH_BB_FN (bb, cfun)
     337                 :             :     {
     338                 :   157598466 :       for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
     339                 :             :         {
     340                 :    62336815 :           stmt = gsi_stmt (gsi);
     341                 :    62336815 :           if (gimple_code (stmt) != GIMPLE_CALL)
     342                 :    52848131 :             continue;
     343                 :     9488684 :           if (!gimple_call_internal_p (stmt)
     344                 :     9488684 :               || gimple_call_internal_fn (stmt) != IFN_ANNOTATE)
     345                 :     9488684 :             continue;
     346                 :             : 
     347                 :           0 :           switch ((annot_expr_kind) tree_to_shwi (gimple_call_arg (stmt, 1)))
     348                 :             :             {
     349                 :           0 :             case annot_expr_ivdep_kind:
     350                 :           0 :             case annot_expr_unroll_kind:
     351                 :           0 :             case annot_expr_no_vector_kind:
     352                 :           0 :             case annot_expr_vector_kind:
     353                 :           0 :             case annot_expr_parallel_kind:
     354                 :           0 :             case annot_expr_maybe_infinite_kind:
     355                 :           0 :               break;
     356                 :           0 :             default:
     357                 :           0 :               gcc_unreachable ();
     358                 :             :             }
     359                 :             : 
     360                 :           0 :           warning_at (gimple_location (stmt), 0, "ignoring loop annotation");
     361                 :           0 :           stmt = gimple_build_assign (gimple_call_lhs (stmt),
     362                 :             :                                       gimple_call_arg (stmt, 0));
     363                 :           0 :           gsi_replace (&gsi, stmt, true);
     364                 :             :         }
     365                 :             :     }
     366                 :     2702497 : }
     367                 :             : 
     368                 :             : static unsigned int
     369                 :     2702497 : execute_build_cfg (void)
     370                 :             : {
     371                 :     2702497 :   gimple_seq body = gimple_body (current_function_decl);
     372                 :             : 
     373                 :     2702497 :   build_gimple_cfg (body);
     374                 :     2702497 :   gimple_set_body (current_function_decl, NULL);
     375                 :     2702497 :   if (dump_file && (dump_flags & TDF_DETAILS))
     376                 :             :     {
     377                 :           2 :       fprintf (dump_file, "Scope blocks:\n");
     378                 :           2 :       dump_scope_blocks (dump_file, dump_flags);
     379                 :             :     }
     380                 :     2702497 :   cleanup_tree_cfg ();
     381                 :             : 
     382                 :     2702497 :   bb_to_omp_idx.release ();
     383                 :             : 
     384                 :     2702497 :   loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
     385                 :     2702497 :   replace_loop_annotate ();
     386                 :     2702497 :   return 0;
     387                 :             : }
     388                 :             : 
     389                 :             : namespace {
     390                 :             : 
     391                 :             : const pass_data pass_data_build_cfg =
     392                 :             : {
     393                 :             :   GIMPLE_PASS, /* type */
     394                 :             :   "cfg", /* name */
     395                 :             :   OPTGROUP_NONE, /* optinfo_flags */
     396                 :             :   TV_TREE_CFG, /* tv_id */
     397                 :             :   PROP_gimple_leh, /* properties_required */
     398                 :             :   ( PROP_cfg | PROP_loops ), /* properties_provided */
     399                 :             :   0, /* properties_destroyed */
     400                 :             :   0, /* todo_flags_start */
     401                 :             :   0, /* todo_flags_finish */
     402                 :             : };
     403                 :             : 
     404                 :             : class pass_build_cfg : public gimple_opt_pass
     405                 :             : {
     406                 :             : public:
     407                 :      271162 :   pass_build_cfg (gcc::context *ctxt)
     408                 :      542324 :     : gimple_opt_pass (pass_data_build_cfg, ctxt)
     409                 :             :   {}
     410                 :             : 
     411                 :             :   /* opt_pass methods: */
     412                 :     2702497 :   unsigned int execute (function *) final override
     413                 :             :   {
     414                 :     2702497 :     return execute_build_cfg ();
     415                 :             :   }
     416                 :             : 
     417                 :             : }; // class pass_build_cfg
     418                 :             : 
     419                 :             : } // anon namespace
     420                 :             : 
     421                 :             : gimple_opt_pass *
     422                 :      271162 : make_pass_build_cfg (gcc::context *ctxt)
     423                 :             : {
     424                 :      271162 :   return new pass_build_cfg (ctxt);
     425                 :             : }
     426                 :             : 
     427                 :             : 
     428                 :             : /* Return true if T is a computed goto.  */
     429                 :             : 
     430                 :             : bool
     431                 :   561420610 : computed_goto_p (gimple *t)
     432                 :             : {
     433                 :   561420610 :   return (gimple_code (t) == GIMPLE_GOTO
     434                 :   561420610 :           && TREE_CODE (gimple_goto_dest (t)) != LABEL_DECL);
     435                 :             : }
     436                 :             : 
     437                 :             : /* Returns true if the sequence of statements STMTS only contains
     438                 :             :    a call to __builtin_unreachable ().  */
     439                 :             : 
     440                 :             : bool
     441                 :     3340577 : gimple_seq_unreachable_p (gimple_seq stmts)
     442                 :             : {
     443                 :     3340577 :   if (stmts == NULL
     444                 :             :       /* Return false if -fsanitize=unreachable, we don't want to
     445                 :             :          optimize away those calls, but rather turn them into
     446                 :             :          __ubsan_handle_builtin_unreachable () or __builtin_trap ()
     447                 :             :          later.  */
     448                 :     3340577 :       || sanitize_flags_p (SANITIZE_UNREACHABLE))
     449                 :        3134 :     return false;
     450                 :             : 
     451                 :     3337443 :   gimple_stmt_iterator gsi = gsi_last (stmts);
     452                 :             : 
     453                 :     3337443 :   if (!gimple_call_builtin_p (gsi_stmt (gsi), BUILT_IN_UNREACHABLE))
     454                 :             :     return false;
     455                 :             : 
     456                 :      434508 :   for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
     457                 :             :     {
     458                 :       12081 :       gimple *stmt = gsi_stmt (gsi);
     459                 :       12081 :       if (gimple_code (stmt) != GIMPLE_LABEL
     460                 :        6525 :           && !is_gimple_debug (stmt)
     461                 :       13031 :           && !gimple_clobber_p (stmt))
     462                 :             :       return false;
     463                 :             :     }
     464                 :             :   return true;
     465                 :             : }
     466                 :             : 
     467                 :             : /* Returns true for edge E where e->src ends with a GIMPLE_COND and
     468                 :             :    the other edge points to a bb with just __builtin_unreachable ().
     469                 :             :    I.e. return true for C->M edge in:
     470                 :             :    <bb C>:
     471                 :             :    ...
     472                 :             :    if (something)
     473                 :             :      goto <bb N>;
     474                 :             :    else
     475                 :             :      goto <bb M>;
     476                 :             :    <bb N>:
     477                 :             :    __builtin_unreachable ();
     478                 :             :    <bb M>:  */
     479                 :             : 
     480                 :             : bool
     481                 :    10900146 : assert_unreachable_fallthru_edge_p (edge e)
     482                 :             : {
     483                 :    10900146 :   basic_block pred_bb = e->src;
     484                 :    31185492 :   if (safe_is_a <gcond *> (*gsi_last_bb (pred_bb)))
     485                 :             :     {
     486                 :    10900146 :       basic_block other_bb = EDGE_SUCC (pred_bb, 0)->dest;
     487                 :    10900146 :       if (other_bb == e->dest)
     488                 :     5784515 :         other_bb = EDGE_SUCC (pred_bb, 1)->dest;
     489                 :    10900146 :       if (EDGE_COUNT (other_bb->succs) == 0)
     490                 :     3029892 :         return gimple_seq_unreachable_p (bb_seq (other_bb));
     491                 :             :     }
     492                 :             :   return false;
     493                 :             : }
     494                 :             : 
     495                 :             : 
     496                 :             : /* Initialize GF_CALL_CTRL_ALTERING flag, which indicates the call
     497                 :             :    could alter control flow except via eh. We initialize the flag at
     498                 :             :    CFG build time and only ever clear it later.  */
     499                 :             : 
     500                 :             : static void
     501                 :    10100616 : gimple_call_initialize_ctrl_altering (gimple *stmt)
     502                 :             : {
     503                 :    10100616 :   int flags = gimple_call_flags (stmt);
     504                 :             : 
     505                 :             :   /* A call alters control flow if it can make an abnormal goto.  */
     506                 :    10100616 :   if (call_can_make_abnormal_goto (stmt)
     507                 :             :       /* A call also alters control flow if it does not return.  */
     508                 :    10093907 :       || flags & ECF_NORETURN
     509                 :             :       /* TM ending statements have backedges out of the transaction.
     510                 :             :          Return true so we split the basic block containing them.
     511                 :             :          Note that the TM_BUILTIN test is merely an optimization.  */
     512                 :     8603254 :       || ((flags & ECF_TM_BUILTIN)
     513                 :         985 :           && is_tm_ending_fndecl (gimple_call_fndecl (stmt)))
     514                 :             :       /* BUILT_IN_RETURN call is same as return statement.  */
     515                 :     8602276 :       || gimple_call_builtin_p (stmt, BUILT_IN_RETURN)
     516                 :             :       /* IFN_UNIQUE should be the last insn, to make checking for it
     517                 :             :          as cheap as possible.  */
     518                 :    18702892 :       || (gimple_call_internal_p (stmt)
     519                 :      318860 :           && gimple_call_internal_unique_p (stmt)))
     520                 :     1569808 :     gimple_call_set_ctrl_altering (stmt, true);
     521                 :             :   else
     522                 :     8530808 :     gimple_call_set_ctrl_altering (stmt, false);
     523                 :    10100616 : }
     524                 :             : 
     525                 :             : 
     526                 :             : /* Insert SEQ after BB and build a flowgraph.  */
     527                 :             : 
     528                 :             : static basic_block
     529                 :     2754198 : make_blocks_1 (gimple_seq seq, basic_block bb)
     530                 :             : {
     531                 :     2754198 :   gimple_stmt_iterator i = gsi_start (seq);
     532                 :     2754198 :   gimple *stmt = NULL;
     533                 :     2754198 :   gimple *prev_stmt = NULL;
     534                 :     2754198 :   bool start_new_block = true;
     535                 :     2754198 :   bool first_stmt_of_seq = true;
     536                 :             : 
     537                 :    88263147 :   while (!gsi_end_p (i))
     538                 :             :     {
     539                 :             :       /* PREV_STMT should only be set to a debug stmt if the debug
     540                 :             :          stmt is before nondebug stmts.  Once stmt reaches a nondebug
     541                 :             :          nonlabel, prev_stmt will be set to it, so that
     542                 :             :          stmt_starts_bb_p will know to start a new block if a label is
     543                 :             :          found.  However, if stmt was a label after debug stmts only,
     544                 :             :          keep the label in prev_stmt even if we find further debug
     545                 :             :          stmts, for there may be other labels after them, and they
     546                 :             :          should land in the same block.  */
     547                 :    85508949 :       if (!prev_stmt || !stmt || !is_gimple_debug (stmt))
     548                 :             :         prev_stmt = stmt;
     549                 :    85508949 :       stmt = gsi_stmt (i);
     550                 :             : 
     551                 :    85508949 :       if (stmt && is_gimple_call (stmt))
     552                 :    10100616 :         gimple_call_initialize_ctrl_altering (stmt);
     553                 :             : 
     554                 :             :       /* If the statement starts a new basic block or if we have determined
     555                 :             :          in a previous pass that we need to create a new block for STMT, do
     556                 :             :          so now.  */
     557                 :    85508949 :       if (start_new_block || stmt_starts_bb_p (stmt, prev_stmt))
     558                 :             :         {
     559                 :    20184207 :           if (!first_stmt_of_seq)
     560                 :    17430009 :             gsi_split_seq_before (&i, &seq);
     561                 :    20184207 :           bb = create_basic_block (seq, bb);
     562                 :    20184207 :           start_new_block = false;
     563                 :    20184207 :           prev_stmt = NULL;
     564                 :             :         }
     565                 :             : 
     566                 :             :       /* Now add STMT to BB and create the subgraphs for special statement
     567                 :             :          codes.  */
     568                 :    85508949 :       gimple_set_bb (stmt, bb);
     569                 :             : 
     570                 :             :       /* If STMT is a basic block terminator, set START_NEW_BLOCK for the
     571                 :             :          next iteration.  */
     572                 :    85508949 :       if (stmt_ends_bb_p (stmt))
     573                 :             :         {
     574                 :             :           /* If the stmt can make abnormal goto use a new temporary
     575                 :             :              for the assignment to the LHS.  This makes sure the old value
     576                 :             :              of the LHS is available on the abnormal edge.  Otherwise
     577                 :             :              we will end up with overlapping life-ranges for abnormal
     578                 :             :              SSA names.  */
     579                 :    18373191 :           if (gimple_has_lhs (stmt)
     580                 :     1545494 :               && stmt_can_make_abnormal_goto (stmt)
     581                 :     3181191 :               && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt))))
     582                 :             :             {
     583                 :        2356 :               tree lhs = gimple_get_lhs (stmt);
     584                 :        2356 :               tree tmp = create_tmp_var (TREE_TYPE (lhs));
     585                 :        2356 :               gimple *s = gimple_build_assign (lhs, tmp);
     586                 :        2356 :               gimple_set_location (s, gimple_location (stmt));
     587                 :        2356 :               gimple_set_block (s, gimple_block (stmt));
     588                 :        2356 :               gimple_set_lhs (stmt, tmp);
     589                 :        2356 :               gsi_insert_after (&i, s, GSI_SAME_STMT);
     590                 :             :             }
     591                 :             :           start_new_block = true;
     592                 :             :         }
     593                 :             : 
     594                 :    85508949 :       gsi_next (&i);
     595                 :    85508949 :       first_stmt_of_seq = false;
     596                 :             :     }
     597                 :     2754198 :   return bb;
     598                 :             : }
     599                 :             : 
     600                 :             : /* Build a flowgraph for the sequence of stmts SEQ.  */
     601                 :             : 
     602                 :             : static void
     603                 :     2702497 : make_blocks (gimple_seq seq)
     604                 :             : {
     605                 :             :   /* Look for debug markers right before labels, and move the debug
     606                 :             :      stmts after the labels.  Accepting labels among debug markers
     607                 :             :      adds no value, just complexity; if we wanted to annotate labels
     608                 :             :      with view numbers (so sequencing among markers would matter) or
     609                 :             :      somesuch, we're probably better off still moving the labels, but
     610                 :             :      adding other debug annotations in their original positions or
     611                 :             :      emitting nonbind or bind markers associated with the labels in
     612                 :             :      the original position of the labels.
     613                 :             : 
     614                 :             :      Moving labels would probably be simpler, but we can't do that:
     615                 :             :      moving labels assigns label ids to them, and doing so because of
     616                 :             :      debug markers makes for -fcompare-debug and possibly even codegen
     617                 :             :      differences.  So, we have to move the debug stmts instead.  To
     618                 :             :      that end, we scan SEQ backwards, marking the position of the
     619                 :             :      latest (earliest we find) label, and moving debug stmts that are
     620                 :             :      not separated from it by nondebug nonlabel stmts after the
     621                 :             :      label.  */
     622                 :     2702497 :   if (MAY_HAVE_DEBUG_MARKER_STMTS)
     623                 :             :     {
     624                 :     1659624 :       gimple_stmt_iterator label = gsi_none ();
     625                 :             : 
     626                 :    96070970 :       for (gimple_stmt_iterator i = gsi_last (seq); !gsi_end_p (i); gsi_prev (&i))
     627                 :             :         {
     628                 :    46375861 :           gimple *stmt = gsi_stmt (i);
     629                 :             : 
     630                 :             :           /* If this is the first label we encounter (latest in SEQ)
     631                 :             :              before nondebug stmts, record its position.  */
     632                 :    46375861 :           if (is_a <glabel *> (stmt))
     633                 :             :             {
     634                 :     8549134 :               if (gsi_end_p (label))
     635                 :     7936736 :                 label = i;
     636                 :     8549134 :               continue;
     637                 :             :             }
     638                 :             : 
     639                 :             :           /* Without a recorded label position to move debug stmts to,
     640                 :             :              there's nothing to do.  */
     641                 :    37826727 :           if (gsi_end_p (label))
     642                 :    29870921 :             continue;
     643                 :             : 
     644                 :             :           /* Move the debug stmt at I after LABEL.  */
     645                 :     7955806 :           if (is_gimple_debug (stmt))
     646                 :             :             {
     647                 :       23127 :               gcc_assert (gimple_debug_nonbind_marker_p (stmt));
     648                 :             :               /* As STMT is removed, I advances to the stmt after
     649                 :             :                  STMT, so the gsi_prev in the for "increment"
     650                 :             :                  expression gets us to the stmt we're to visit after
     651                 :             :                  STMT.  LABEL, however, would advance to the moved
     652                 :             :                  stmt if we passed it to gsi_move_after, so pass it a
     653                 :             :                  copy instead, so as to keep LABEL pointing to the
     654                 :             :                  LABEL.  */
     655                 :       23127 :               gimple_stmt_iterator copy = label;
     656                 :       23127 :               gsi_move_after (&i, &copy);
     657                 :       23127 :               continue;
     658                 :       23127 :             }
     659                 :             : 
     660                 :             :           /* There aren't any (more?) debug stmts before label, so
     661                 :             :              there isn't anything else to move after it.  */
     662                 :             :           label = gsi_none ();
     663                 :             :         }
     664                 :             :     }
     665                 :             : 
     666                 :     2702497 :   make_blocks_1 (seq, ENTRY_BLOCK_PTR_FOR_FN (cfun));
     667                 :     2702497 : }
     668                 :             : 
     669                 :             : /* Create and return a new empty basic block after bb AFTER.  */
     670                 :             : 
     671                 :             : static basic_block
     672                 :    63259219 : create_bb (void *h, void *e, basic_block after)
     673                 :             : {
     674                 :    63259219 :   basic_block bb;
     675                 :             : 
     676                 :    63259219 :   gcc_assert (!e);
     677                 :             : 
     678                 :             :   /* Create and initialize a new basic block.  Since alloc_block uses
     679                 :             :      GC allocation that clears memory to allocate a basic block, we do
     680                 :             :      not have to clear the newly allocated basic block here.  */
     681                 :    63259219 :   bb = alloc_block ();
     682                 :             : 
     683                 :    63259219 :   bb->index = last_basic_block_for_fn (cfun);
     684                 :    63259219 :   bb->flags = BB_NEW;
     685                 :    63259219 :   set_bb_seq (bb, h ? (gimple_seq) h : NULL);
     686                 :             : 
     687                 :             :   /* Add the new block to the linked list of blocks.  */
     688                 :    63259219 :   link_block (bb, after);
     689                 :             : 
     690                 :             :   /* Grow the basic block array if needed.  */
     691                 :    63259219 :   if ((size_t) last_basic_block_for_fn (cfun)
     692                 :    63259219 :       == basic_block_info_for_fn (cfun)->length ())
     693                 :    18485134 :     vec_safe_grow_cleared (basic_block_info_for_fn (cfun),
     694                 :    18485134 :                            last_basic_block_for_fn (cfun) + 1);
     695                 :             : 
     696                 :             :   /* Add the newly created block to the array.  */
     697                 :    63259219 :   SET_BASIC_BLOCK_FOR_FN (cfun, last_basic_block_for_fn (cfun), bb);
     698                 :             : 
     699                 :    63259219 :   n_basic_blocks_for_fn (cfun)++;
     700                 :    63259219 :   last_basic_block_for_fn (cfun)++;
     701                 :             : 
     702                 :    63259219 :   return bb;
     703                 :             : }
     704                 :             : 
     705                 :             : 
     706                 :             : /*---------------------------------------------------------------------------
     707                 :             :                                  Edge creation
     708                 :             : ---------------------------------------------------------------------------*/
     709                 :             : 
     710                 :             : /* If basic block BB has an abnormal edge to a basic block
     711                 :             :    containing IFN_ABNORMAL_DISPATCHER internal call, return
     712                 :             :    that the dispatcher's basic block, otherwise return NULL.  */
     713                 :             : 
     714                 :             : basic_block
     715                 :         431 : get_abnormal_succ_dispatcher (basic_block bb)
     716                 :             : {
     717                 :         431 :   edge e;
     718                 :         431 :   edge_iterator ei;
     719                 :             : 
     720                 :         848 :   FOR_EACH_EDGE (e, ei, bb->succs)
     721                 :         632 :     if ((e->flags & (EDGE_ABNORMAL | EDGE_EH)) == EDGE_ABNORMAL)
     722                 :             :       {
     723                 :         215 :         gimple_stmt_iterator gsi
     724                 :         215 :           = gsi_start_nondebug_after_labels_bb (e->dest);
     725                 :         215 :         gimple *g = gsi_stmt (gsi);
     726                 :         215 :         if (g && gimple_call_internal_p (g, IFN_ABNORMAL_DISPATCHER))
     727                 :         215 :           return e->dest;
     728                 :             :       }
     729                 :             :   return NULL;
     730                 :             : }
     731                 :             : 
     732                 :             : /* Helper function for make_edges.  Create a basic block with
     733                 :             :    with ABNORMAL_DISPATCHER internal call in it if needed, and
     734                 :             :    create abnormal edges from BBS to it and from it to FOR_BB
     735                 :             :    if COMPUTED_GOTO is false, otherwise factor the computed gotos.  */
     736                 :             : 
     737                 :             : static void
     738                 :        5025 : handle_abnormal_edges (basic_block *dispatcher_bbs, basic_block for_bb,
     739                 :             :                        auto_vec<basic_block> *bbs, bool computed_goto)
     740                 :             : {
     741                 :        5025 :   basic_block *dispatcher = dispatcher_bbs + (computed_goto ? 1 : 0);
     742                 :        5025 :   unsigned int idx = 0;
     743                 :        5025 :   basic_block bb;
     744                 :        5025 :   bool inner = false;
     745                 :             : 
     746                 :        5025 :   if (!bb_to_omp_idx.is_empty ())
     747                 :             :     {
     748                 :          11 :       dispatcher = dispatcher_bbs + 2 * bb_to_omp_idx[for_bb->index];
     749                 :          11 :       if (bb_to_omp_idx[for_bb->index] != 0)
     750                 :           6 :         inner = true;
     751                 :             :     }
     752                 :             : 
     753                 :             :   /* If the dispatcher has been created already, then there are basic
     754                 :             :      blocks with abnormal edges to it, so just make a new edge to
     755                 :             :      for_bb.  */
     756                 :        5025 :   if (*dispatcher == NULL)
     757                 :             :     {
     758                 :             :       /* Check if there are any basic blocks that need to have
     759                 :             :          abnormal edges to this dispatcher.  If there are none, return
     760                 :             :          early.  */
     761                 :        3288 :       if (bb_to_omp_idx.is_empty ())
     762                 :             :         {
     763                 :        3277 :           if (bbs->is_empty ())
     764                 :        5025 :             return;
     765                 :             :         }
     766                 :             :       else
     767                 :             :         {
     768                 :          18 :           FOR_EACH_VEC_ELT (*bbs, idx, bb)
     769                 :          18 :             if (bb_to_omp_idx[bb->index] == bb_to_omp_idx[for_bb->index])
     770                 :             :               break;
     771                 :          11 :           if (bb == NULL)
     772                 :             :             return;
     773                 :             :         }
     774                 :             : 
     775                 :             :       /* Create the dispatcher bb.  */
     776                 :        2476 :       *dispatcher = create_basic_block (NULL, for_bb);
     777                 :        2476 :       if (computed_goto)
     778                 :             :         {
     779                 :             :           /* Factor computed gotos into a common computed goto site.  Also
     780                 :             :              record the location of that site so that we can un-factor the
     781                 :             :              gotos after we have converted back to normal form.  */
     782                 :         534 :           gimple_stmt_iterator gsi = gsi_start_bb (*dispatcher);
     783                 :             : 
     784                 :             :           /* Create the destination of the factored goto.  Each original
     785                 :             :              computed goto will put its desired destination into this
     786                 :             :              variable and jump to the label we create immediately below.  */
     787                 :         534 :           tree var = create_tmp_var (ptr_type_node, "gotovar");
     788                 :             : 
     789                 :             :           /* Build a label for the new block which will contain the
     790                 :             :              factored computed goto.  */
     791                 :         534 :           tree factored_label_decl
     792                 :         534 :             = create_artificial_label (UNKNOWN_LOCATION);
     793                 :         534 :           gimple *factored_computed_goto_label
     794                 :         534 :             = gimple_build_label (factored_label_decl);
     795                 :         534 :           gsi_insert_after (&gsi, factored_computed_goto_label, GSI_NEW_STMT);
     796                 :             : 
     797                 :             :           /* Build our new computed goto.  */
     798                 :         534 :           gimple *factored_computed_goto = gimple_build_goto (var);
     799                 :         534 :           gsi_insert_after (&gsi, factored_computed_goto, GSI_NEW_STMT);
     800                 :             : 
     801                 :        2072 :           FOR_EACH_VEC_ELT (*bbs, idx, bb)
     802                 :             :             {
     803                 :        1004 :               if (!bb_to_omp_idx.is_empty ()
     804                 :           0 :                   && bb_to_omp_idx[bb->index] != bb_to_omp_idx[for_bb->index])
     805                 :           0 :                 continue;
     806                 :             : 
     807                 :        1004 :               gsi = gsi_last_bb (bb);
     808                 :        1004 :               gimple *last = gsi_stmt (gsi);
     809                 :             : 
     810                 :        1004 :               gcc_assert (computed_goto_p (last));
     811                 :             : 
     812                 :             :               /* Copy the original computed goto's destination into VAR.  */
     813                 :        1004 :               gimple *assignment
     814                 :        1004 :                 = gimple_build_assign (var, gimple_goto_dest (last));
     815                 :        1004 :               gsi_insert_before (&gsi, assignment, GSI_SAME_STMT);
     816                 :             : 
     817                 :        1004 :               edge e = make_edge (bb, *dispatcher, EDGE_FALLTHRU);
     818                 :        1004 :               e->goto_locus = gimple_location (last);
     819                 :        1004 :               gsi_remove (&gsi, true);
     820                 :             :             }
     821                 :             :         }
     822                 :             :       else
     823                 :             :         {
     824                 :        1942 :           tree arg = inner ? boolean_true_node : boolean_false_node;
     825                 :        1942 :           gcall *g = gimple_build_call_internal (IFN_ABNORMAL_DISPATCHER,
     826                 :             :                                                  1, arg);
     827                 :        1942 :           gimple_call_set_ctrl_altering (g, true);
     828                 :        1942 :           gimple_stmt_iterator gsi = gsi_after_labels (*dispatcher);
     829                 :        1942 :           gsi_insert_after (&gsi, g, GSI_NEW_STMT);
     830                 :             : 
     831                 :             :           /* Create predecessor edges of the dispatcher.  */
     832                 :       12543 :           FOR_EACH_VEC_ELT (*bbs, idx, bb)
     833                 :             :             {
     834                 :        6717 :               if (!bb_to_omp_idx.is_empty ()
     835                 :          44 :                   && bb_to_omp_idx[bb->index] != bb_to_omp_idx[for_bb->index])
     836                 :          20 :                 continue;
     837                 :        6697 :               make_edge (bb, *dispatcher, EDGE_ABNORMAL);
     838                 :             :             }
     839                 :             :         }
     840                 :             :     }
     841                 :             : 
     842                 :        4213 :   make_edge (*dispatcher, for_bb, EDGE_ABNORMAL);
     843                 :             : }
     844                 :             : 
     845                 :             : /* Creates outgoing edges for BB.  Returns 1 when it ends with an
     846                 :             :    computed goto, returns 2 when it ends with a statement that
     847                 :             :    might return to this function via an nonlocal goto, otherwise
     848                 :             :    return 0.  Updates *PCUR_REGION with the OMP region this BB is in.  */
     849                 :             : 
     850                 :             : static int
     851                 :    20184207 : make_edges_bb (basic_block bb, struct omp_region **pcur_region, int *pomp_index)
     852                 :             : {
     853                 :    20184207 :   gimple *last = *gsi_last_bb (bb);
     854                 :    20184207 :   bool fallthru = false;
     855                 :    20184207 :   int ret = 0;
     856                 :             : 
     857                 :    20184207 :   if (!last)
     858                 :             :     return ret;
     859                 :             : 
     860                 :    20184207 :   switch (gimple_code (last))
     861                 :             :     {
     862                 :     5645173 :     case GIMPLE_GOTO:
     863                 :     5645173 :       if (make_goto_expr_edges (bb))
     864                 :    20184207 :         ret = 1;
     865                 :             :       fallthru = false;
     866                 :             :       break;
     867                 :     2691767 :     case GIMPLE_RETURN:
     868                 :     2691767 :       {
     869                 :     2691767 :         edge e = make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
     870                 :     2691767 :         e->goto_locus = gimple_location (last);
     871                 :     2691767 :         fallthru = false;
     872                 :             :       }
     873                 :     2691767 :       break;
     874                 :     5084965 :     case GIMPLE_COND:
     875                 :     5084965 :       make_cond_expr_edges (bb);
     876                 :     5084965 :       fallthru = false;
     877                 :     5084965 :       break;
     878                 :       51802 :     case GIMPLE_SWITCH:
     879                 :       51802 :       make_gimple_switch_edges (as_a <gswitch *> (last), bb);
     880                 :       51802 :       fallthru = false;
     881                 :       51802 :       break;
     882                 :      782140 :     case GIMPLE_RESX:
     883                 :      782140 :       make_eh_edge (last);
     884                 :      782140 :       fallthru = false;
     885                 :      782140 :       break;
     886                 :       40719 :     case GIMPLE_EH_DISPATCH:
     887                 :       40719 :       fallthru = make_eh_dispatch_edges (as_a <geh_dispatch *> (last));
     888                 :       40719 :       break;
     889                 :             : 
     890                 :     3507584 :     case GIMPLE_CALL:
     891                 :             :       /* If this function receives a nonlocal goto, then we need to
     892                 :             :          make edges from this call site to all the nonlocal goto
     893                 :             :          handlers.  */
     894                 :     3507584 :       if (stmt_can_make_abnormal_goto (last))
     895                 :        6709 :         ret = 2;
     896                 :             : 
     897                 :             :       /* If this statement has reachable exception handlers, then
     898                 :             :          create abnormal edges to them.  */
     899                 :     3507584 :       make_eh_edge (last);
     900                 :             : 
     901                 :             :       /* BUILTIN_RETURN is really a return statement.  */
     902                 :     3507584 :       if (gimple_call_builtin_p (last, BUILT_IN_RETURN))
     903                 :             :         {
     904                 :         367 :           make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
     905                 :         367 :           fallthru = false;
     906                 :             :         }
     907                 :             :       /* Some calls are known not to return.  */
     908                 :             :       else
     909                 :     3507217 :         fallthru = !gimple_call_noreturn_p (last);
     910                 :             :       break;
     911                 :             : 
     912                 :     2084945 :     case GIMPLE_ASSIGN:
     913                 :             :       /* A GIMPLE_ASSIGN may throw internally and thus be considered
     914                 :             :          control-altering.  */
     915                 :     2084945 :       if (is_ctrl_altering_stmt (last))
     916                 :      618356 :         make_eh_edge (last);
     917                 :             :       fallthru = true;
     918                 :             :       break;
     919                 :             : 
     920                 :        2189 :     case GIMPLE_ASM:
     921                 :        2189 :       make_gimple_asm_edges (bb);
     922                 :        2189 :       fallthru = true;
     923                 :        2189 :       break;
     924                 :             : 
     925                 :      278634 :     CASE_GIMPLE_OMP:
     926                 :      278634 :       fallthru = omp_make_gimple_edges (bb, pcur_region, pomp_index);
     927                 :      278634 :       break;
     928                 :             : 
     929                 :         411 :     case GIMPLE_TRANSACTION:
     930                 :         411 :       {
     931                 :         411 :         gtransaction *txn = as_a <gtransaction *> (last);
     932                 :         411 :         tree label1 = gimple_transaction_label_norm (txn);
     933                 :         411 :         tree label2 = gimple_transaction_label_uninst (txn);
     934                 :             : 
     935                 :         411 :         if (label1)
     936                 :         401 :           make_edge (bb, label_to_block (cfun, label1), EDGE_FALLTHRU);
     937                 :         411 :         if (label2)
     938                 :         397 :           make_edge (bb, label_to_block (cfun, label2),
     939                 :         397 :                      EDGE_TM_UNINSTRUMENTED | (label1 ? 0 : EDGE_FALLTHRU));
     940                 :             : 
     941                 :         411 :         tree label3 = gimple_transaction_label_over (txn);
     942                 :         411 :         if (gimple_transaction_subcode (txn)
     943                 :             :             & (GTMA_HAVE_ABORT | GTMA_IS_OUTER))
     944                 :          65 :           make_edge (bb, label_to_block (cfun, label3), EDGE_TM_ABORT);
     945                 :             : 
     946                 :             :         fallthru = false;
     947                 :             :       }
     948                 :             :       break;
     949                 :             : 
     950                 :       13878 :     default:
     951                 :       13878 :       gcc_assert (!stmt_ends_bb_p (last));
     952                 :             :       fallthru = true;
     953                 :             :       break;
     954                 :             :     }
     955                 :             : 
     956                 :    12439800 :   if (fallthru)
     957                 :     4352433 :     make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
     958                 :             : 
     959                 :             :   return ret;
     960                 :             : }
     961                 :             : 
     962                 :             : /* Join all the blocks in the flowgraph.  */
     963                 :             : 
     964                 :             : static void
     965                 :     2702497 : make_edges (void)
     966                 :             : {
     967                 :     2702497 :   basic_block bb;
     968                 :     2702497 :   struct omp_region *cur_region = NULL;
     969                 :     2702497 :   auto_vec<basic_block> ab_edge_goto;
     970                 :     2702497 :   auto_vec<basic_block> ab_edge_call;
     971                 :     2702497 :   int cur_omp_region_idx = 0;
     972                 :             : 
     973                 :             :   /* Create an edge from entry to the first block with executable
     974                 :             :      statements in it.  */
     975                 :     2702497 :   make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun),
     976                 :     2702497 :              BASIC_BLOCK_FOR_FN (cfun, NUM_FIXED_BLOCKS),
     977                 :             :              EDGE_FALLTHRU);
     978                 :             : 
     979                 :             :   /* Traverse the basic block array placing edges.  */
     980                 :    22749687 :   FOR_EACH_BB_FN (bb, cfun)
     981                 :             :     {
     982                 :    20047190 :       int mer;
     983                 :             : 
     984                 :    20047190 :       if (!bb_to_omp_idx.is_empty ())
     985                 :      675958 :         bb_to_omp_idx[bb->index] = cur_omp_region_idx;
     986                 :             : 
     987                 :    20047190 :       mer = make_edges_bb (bb, &cur_region, &cur_omp_region_idx);
     988                 :    20047190 :       if (mer == 1)
     989                 :        1081 :         ab_edge_goto.safe_push (bb);
     990                 :    20046109 :       else if (mer == 2)
     991                 :        6709 :         ab_edge_call.safe_push (bb);
     992                 :             : 
     993                 :    20550367 :       if (cur_region && bb_to_omp_idx.is_empty ())
     994                 :       21020 :         bb_to_omp_idx.safe_grow_cleared (n_basic_blocks_for_fn (cfun), true);
     995                 :             :     }
     996                 :             : 
     997                 :             :   /* Computed gotos are hell to deal with, especially if there are
     998                 :             :      lots of them with a large number of destinations.  So we factor
     999                 :             :      them to a common computed goto location before we build the
    1000                 :             :      edge list.  After we convert back to normal form, we will un-factor
    1001                 :             :      the computed gotos since factoring introduces an unwanted jump.
    1002                 :             :      For non-local gotos and abnormal edges from calls to calls that return
    1003                 :             :      twice or forced labels, factor the abnormal edges too, by having all
    1004                 :             :      abnormal edges from the calls go to a common artificial basic block
    1005                 :             :      with ABNORMAL_DISPATCHER internal call and abnormal edges from that
    1006                 :             :      basic block to all forced labels and calls returning twice.
    1007                 :             :      We do this per-OpenMP structured block, because those regions
    1008                 :             :      are guaranteed to be single entry single exit by the standard,
    1009                 :             :      so it is not allowed to enter or exit such regions abnormally this way,
    1010                 :             :      thus all computed gotos, non-local gotos and setjmp/longjmp calls
    1011                 :             :      must not transfer control across SESE region boundaries.  */
    1012                 :     2702497 :   if (!ab_edge_goto.is_empty () || !ab_edge_call.is_empty ())
    1013                 :             :     {
    1014                 :        2512 :       gimple_stmt_iterator gsi;
    1015                 :        2512 :       basic_block dispatcher_bb_array[2] = { NULL, NULL };
    1016                 :        2512 :       basic_block *dispatcher_bbs = dispatcher_bb_array;
    1017                 :        2512 :       int count = n_basic_blocks_for_fn (cfun);
    1018                 :             : 
    1019                 :        2512 :       if (!bb_to_omp_idx.is_empty ())
    1020                 :           9 :         dispatcher_bbs = XCNEWVEC (basic_block, 2 * count);
    1021                 :             : 
    1022                 :       29138 :       FOR_EACH_BB_FN (bb, cfun)
    1023                 :             :         {
    1024                 :       67641 :           for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    1025                 :             :             {
    1026                 :       39459 :               glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (gsi));
    1027                 :       14865 :               tree target;
    1028                 :             : 
    1029                 :       14865 :               if (!label_stmt)
    1030                 :             :                 break;
    1031                 :             : 
    1032                 :       14865 :               target = gimple_label_label (label_stmt);
    1033                 :             : 
    1034                 :             :               /* Make an edge to every label block that has been marked as a
    1035                 :             :                  potential target for a computed goto or a non-local goto.  */
    1036                 :       14865 :               if (FORCED_LABEL (target))
    1037                 :        2365 :                 handle_abnormal_edges (dispatcher_bbs, bb, &ab_edge_goto,
    1038                 :             :                                        true);
    1039                 :       14865 :               if (DECL_NONLOCAL (target))
    1040                 :             :                 {
    1041                 :         476 :                   handle_abnormal_edges (dispatcher_bbs, bb, &ab_edge_call,
    1042                 :             :                                          false);
    1043                 :         476 :                   break;
    1044                 :             :                 }
    1045                 :             :             }
    1046                 :             : 
    1047                 :       26626 :           if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi)))
    1048                 :        2182 :             gsi_next_nondebug (&gsi);
    1049                 :       26626 :           if (!gsi_end_p (gsi))
    1050                 :             :             {
    1051                 :             :               /* Make an edge to every setjmp-like call.  */
    1052                 :       24943 :               gimple *call_stmt = gsi_stmt (gsi);
    1053                 :       24943 :               if (is_gimple_call (call_stmt)
    1054                 :       24943 :                   && ((gimple_call_flags (call_stmt) & ECF_RETURNS_TWICE)
    1055                 :        7849 :                       || gimple_call_builtin_p (call_stmt,
    1056                 :             :                                                 BUILT_IN_SETJMP_RECEIVER)))
    1057                 :        2184 :                 handle_abnormal_edges (dispatcher_bbs, bb, &ab_edge_call,
    1058                 :             :                                        false);
    1059                 :             :             }
    1060                 :             :         }
    1061                 :             : 
    1062                 :        2521 :       if (!bb_to_omp_idx.is_empty ())
    1063                 :           9 :         XDELETE (dispatcher_bbs);
    1064                 :             :     }
    1065                 :             : 
    1066                 :     2702497 :   omp_free_regions ();
    1067                 :     2702497 : }
    1068                 :             : 
    1069                 :             : /* Add SEQ after GSI.  Start new bb after GSI, and created further bbs as
    1070                 :             :    needed.  Returns true if new bbs were created.
    1071                 :             :    Note: This is transitional code, and should not be used for new code.  We
    1072                 :             :    should be able to get rid of this by rewriting all target va-arg
    1073                 :             :    gimplification hooks to use an interface gimple_build_cond_value as described
    1074                 :             :    in https://gcc.gnu.org/ml/gcc-patches/2015-02/msg01194.html.  */
    1075                 :             : 
    1076                 :             : bool
    1077                 :       51701 : gimple_find_sub_bbs (gimple_seq seq, gimple_stmt_iterator *gsi)
    1078                 :             : {
    1079                 :       51701 :   gimple *stmt = gsi_stmt (*gsi);
    1080                 :       51701 :   basic_block bb = gimple_bb (stmt);
    1081                 :       51701 :   basic_block lastbb, afterbb;
    1082                 :       51701 :   int old_num_bbs = n_basic_blocks_for_fn (cfun);
    1083                 :       51701 :   edge e;
    1084                 :       51701 :   lastbb = make_blocks_1 (seq, bb);
    1085                 :       51701 :   if (old_num_bbs == n_basic_blocks_for_fn (cfun))
    1086                 :             :     return false;
    1087                 :       51701 :   e = split_block (bb, stmt);
    1088                 :             :   /* Move e->dest to come after the new basic blocks.  */
    1089                 :       51701 :   afterbb = e->dest;
    1090                 :       51701 :   unlink_block (afterbb);
    1091                 :       51701 :   link_block (afterbb, lastbb);
    1092                 :       51701 :   redirect_edge_succ (e, bb->next_bb);
    1093                 :       51701 :   bb = bb->next_bb;
    1094                 :      188718 :   while (bb != afterbb)
    1095                 :             :     {
    1096                 :      137017 :       struct omp_region *cur_region = NULL;
    1097                 :      137017 :       profile_count cnt = profile_count::zero ();
    1098                 :      137017 :       bool all = true;
    1099                 :             : 
    1100                 :      137017 :       int cur_omp_region_idx = 0;
    1101                 :      137017 :       int mer = make_edges_bb (bb, &cur_region, &cur_omp_region_idx);
    1102                 :      137017 :       gcc_assert (!mer && !cur_region);
    1103                 :      137017 :       add_bb_to_loop (bb, afterbb->loop_father);
    1104                 :             : 
    1105                 :      137017 :       edge e;
    1106                 :      137017 :       edge_iterator ei;
    1107                 :      302723 :       FOR_EACH_EDGE (e, ei, bb->preds)
    1108                 :             :         {
    1109                 :      165706 :           if (e->count ().initialized_p ())
    1110                 :       20989 :             cnt += e->count ();
    1111                 :             :           else
    1112                 :             :             all = false;
    1113                 :             :         }
    1114                 :      137017 :       tree_guess_outgoing_edge_probabilities (bb);
    1115                 :      137017 :       if (all || profile_status_for_fn (cfun) == PROFILE_READ)
    1116                 :       16858 :         bb->count = cnt;
    1117                 :             : 
    1118                 :      137017 :       bb = bb->next_bb;
    1119                 :             :     }
    1120                 :             :   return true;
    1121                 :             : }
    1122                 :             : 
    1123                 :             : /* Find the next available discriminator value for LOCUS.  The
    1124                 :             :    discriminator distinguishes among several basic blocks that
    1125                 :             :    share a common locus, allowing for more accurate sample-based
    1126                 :             :    profiling.  */
    1127                 :             : 
    1128                 :             : static int
    1129                 :    22357496 : next_discriminator_for_locus (int line)
    1130                 :             : {
    1131                 :    22357496 :   struct locus_discrim_map item;
    1132                 :    22357496 :   struct locus_discrim_map **slot;
    1133                 :             : 
    1134                 :    22357496 :   item.location_line = line;
    1135                 :    22357496 :   item.discriminator = 0;
    1136                 :    22357496 :   slot = discriminator_per_locus->find_slot_with_hash (&item, line, INSERT);
    1137                 :    22357496 :   gcc_assert (slot);
    1138                 :    22357496 :   if (*slot == HTAB_EMPTY_ENTRY)
    1139                 :             :     {
    1140                 :    11610941 :       *slot = XNEW (struct locus_discrim_map);
    1141                 :    11610941 :       gcc_assert (*slot);
    1142                 :    11610941 :       (*slot)->location_line = line;
    1143                 :    11610941 :       (*slot)->discriminator = 0;
    1144                 :             :     }
    1145                 :    22357496 :   (*slot)->discriminator++;
    1146                 :    22357496 :   return (*slot)->discriminator;
    1147                 :             : }
    1148                 :             : 
    1149                 :             : /* Return TRUE if LOCUS1 and LOCUS2 refer to the same source line.  */
    1150                 :             : 
    1151                 :             : static bool
    1152                 :   131568715 : same_line_p (location_t locus1, expanded_location *from, location_t locus2)
    1153                 :             : {
    1154                 :   131568715 :   expanded_location to;
    1155                 :             : 
    1156                 :   131568715 :   if (locus1 == locus2)
    1157                 :             :     return true;
    1158                 :             : 
    1159                 :   106118404 :   to = expand_location (locus2);
    1160                 :             : 
    1161                 :   106118404 :   if (from->line != to.line)
    1162                 :             :     return false;
    1163                 :    54808415 :   if (from->file == to.file)
    1164                 :             :     return true;
    1165                 :      745805 :   return (from->file != NULL
    1166                 :      507233 :           && to.file != NULL
    1167                 :      746726 :           && filename_cmp (from->file, to.file) == 0);
    1168                 :             : }
    1169                 :             : 
    1170                 :             : /* Assign a unique discriminator value to all statements in block bb that
    1171                 :             :    have the same line number as locus. */
    1172                 :             : 
    1173                 :             : static void
    1174                 :    12255047 : assign_discriminator (location_t locus, basic_block bb)
    1175                 :             : {
    1176                 :    12255047 :   gimple_stmt_iterator gsi;
    1177                 :    12255047 :   int discriminator;
    1178                 :             : 
    1179                 :    12255047 :   if (locus == UNKNOWN_LOCATION)
    1180                 :           0 :     return;
    1181                 :             : 
    1182                 :    12255047 :   expanded_location locus_e = expand_location (locus);
    1183                 :             : 
    1184                 :    12255047 :   discriminator = next_discriminator_for_locus (locus_e.line);
    1185                 :             : 
    1186                 :    70596763 :   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    1187                 :             :     {
    1188                 :    46086669 :       gimple *stmt = gsi_stmt (gsi);
    1189                 :    46086669 :       location_t stmt_locus = gimple_location (stmt);
    1190                 :    46086669 :       if (same_line_p (locus, &locus_e, stmt_locus))
    1191                 :    62186171 :         gimple_set_location (stmt,
    1192                 :             :             location_with_discriminator (stmt_locus, discriminator));
    1193                 :             :     }
    1194                 :             : }
    1195                 :             : 
    1196                 :             : /* Assign discriminators to statement locations.  */
    1197                 :             : 
    1198                 :             : static void
    1199                 :     2702497 : assign_discriminators (void)
    1200                 :             : {
    1201                 :     2702497 :   basic_block bb;
    1202                 :             : 
    1203                 :    22752163 :   FOR_EACH_BB_FN (bb, cfun)
    1204                 :             :     {
    1205                 :    20049666 :       edge e;
    1206                 :    20049666 :       edge_iterator ei;
    1207                 :    20049666 :       gimple_stmt_iterator gsi;
    1208                 :    20049666 :       location_t curr_locus = UNKNOWN_LOCATION;
    1209                 :    20049666 :       expanded_location curr_locus_e = {};
    1210                 :    20049666 :       int curr_discr = 0;
    1211                 :             : 
    1212                 :             :       /* Traverse the basic block, if two function calls within a basic block
    1213                 :             :         are mapped to the same line, assign a new discriminator because a call
    1214                 :             :         stmt could be a split point of a basic block.  */
    1215                 :   117193938 :       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    1216                 :             :         {
    1217                 :    77094606 :           gimple *stmt = gsi_stmt (gsi);
    1218                 :             : 
    1219                 :             :           /* Don't allow debug stmts to affect discriminators, but
    1220                 :             :              allow them to take discriminators when they're on the
    1221                 :             :              same line as the preceding nondebug stmt.  */
    1222                 :    77094606 :           if (is_gimple_debug (stmt))
    1223                 :             :             {
    1224                 :     2631474 :               if (curr_locus != UNKNOWN_LOCATION
    1225                 :     2631474 :                   && same_line_p (curr_locus, &curr_locus_e,
    1226                 :             :                                   gimple_location (stmt)))
    1227                 :             :                 {
    1228                 :      287328 :                   location_t loc = gimple_location (stmt);
    1229                 :      287328 :                   location_t dloc = location_with_discriminator (loc,
    1230                 :             :                                                                  curr_discr);
    1231                 :      574656 :                   gimple_set_location (stmt, dloc);
    1232                 :             :                 }
    1233                 :     2631474 :               continue;
    1234                 :     2631474 :             }
    1235                 :    74463132 :           if (curr_locus == UNKNOWN_LOCATION)
    1236                 :             :             {
    1237                 :    22892850 :               curr_locus = gimple_location (stmt);
    1238                 :    22892850 :               curr_locus_e = expand_location (curr_locus);
    1239                 :             :             }
    1240                 :    51570282 :           else if (!same_line_p (curr_locus, &curr_locus_e, gimple_location (stmt)))
    1241                 :             :             {
    1242                 :    15789075 :               curr_locus = gimple_location (stmt);
    1243                 :    15789075 :               curr_locus_e = expand_location (curr_locus);
    1244                 :    15789075 :               curr_discr = 0;
    1245                 :             :             }
    1246                 :    35781207 :           else if (curr_discr != 0)
    1247                 :             :             {
    1248                 :     7479845 :               location_t loc = gimple_location (stmt);
    1249                 :     7479845 :               location_t dloc = location_with_discriminator (loc, curr_discr);
    1250                 :    14958032 :               gimple_set_location (stmt, dloc);
    1251                 :             :             }
    1252                 :             :           /* Allocate a new discriminator for CALL stmt.  */
    1253                 :    74463132 :           if (gimple_code (stmt) == GIMPLE_CALL)
    1254                 :    10102449 :             curr_discr = next_discriminator_for_locus (curr_locus);
    1255                 :             :         }
    1256                 :             : 
    1257                 :    20049666 :       gimple *last = last_nondebug_stmt (bb);
    1258                 :    20049666 :       location_t locus = last ? gimple_location (last) : UNKNOWN_LOCATION;
    1259                 :    19837155 :       if (locus == UNKNOWN_LOCATION)
    1260                 :     1472498 :         continue;
    1261                 :             : 
    1262                 :    18577168 :       expanded_location locus_e = expand_location (locus);
    1263                 :             : 
    1264                 :    43482659 :       FOR_EACH_EDGE (e, ei, bb->succs)
    1265                 :             :         {
    1266                 :    24905491 :           gimple *first = first_non_label_stmt (e->dest);
    1267                 :    24905491 :           gimple *last = last_nondebug_stmt (e->dest);
    1268                 :             : 
    1269                 :    24905491 :           gimple *stmt_on_same_line = NULL;
    1270                 :    24905491 :           if (first && same_line_p (locus, &locus_e,
    1271                 :             :                                      gimple_location (first)))
    1272                 :             :             stmt_on_same_line = first;
    1273                 :    12897507 :           else if (last && same_line_p (locus, &locus_e,
    1274                 :             :                                         gimple_location (last)))
    1275                 :             :             stmt_on_same_line = last;
    1276                 :             : 
    1277                 :    12255047 :           if (stmt_on_same_line)
    1278                 :             :             {
    1279                 :    12255047 :               if (has_discriminator (gimple_location (stmt_on_same_line))
    1280                 :    12255047 :                   && !has_discriminator (locus))
    1281                 :      270046 :                 assign_discriminator (locus, bb);
    1282                 :             :               else
    1283                 :    11985001 :                 assign_discriminator (locus, e->dest);
    1284                 :             :             }
    1285                 :             :         }
    1286                 :             :     }
    1287                 :     2702497 : }
    1288                 :             : 
    1289                 :             : /* Create the edges for a GIMPLE_COND starting at block BB.  */
    1290                 :             : 
    1291                 :             : static void
    1292                 :     5084965 : make_cond_expr_edges (basic_block bb)
    1293                 :             : {
    1294                 :    10169930 :   gcond *entry = as_a <gcond *> (*gsi_last_bb (bb));
    1295                 :     5084965 :   gimple *then_stmt, *else_stmt;
    1296                 :     5084965 :   basic_block then_bb, else_bb;
    1297                 :     5084965 :   tree then_label, else_label;
    1298                 :     5084965 :   edge e;
    1299                 :             : 
    1300                 :     5084965 :   gcc_assert (entry);
    1301                 :             : 
    1302                 :             :   /* Entry basic blocks for each component.  */
    1303                 :     5084965 :   then_label = gimple_cond_true_label (entry);
    1304                 :     5084965 :   else_label = gimple_cond_false_label (entry);
    1305                 :     5084965 :   then_bb = label_to_block (cfun, then_label);
    1306                 :     5084965 :   else_bb = label_to_block (cfun, else_label);
    1307                 :     5084965 :   then_stmt = first_stmt (then_bb);
    1308                 :     5084965 :   else_stmt = first_stmt (else_bb);
    1309                 :             : 
    1310                 :     5084965 :   e = make_edge (bb, then_bb, EDGE_TRUE_VALUE);
    1311                 :     5084965 :   e->goto_locus = gimple_location (then_stmt);
    1312                 :     5084965 :   e = make_edge (bb, else_bb, EDGE_FALSE_VALUE);
    1313                 :     5084965 :   if (e)
    1314                 :     5080784 :     e->goto_locus = gimple_location (else_stmt);
    1315                 :             : 
    1316                 :             :   /* We do not need the labels anymore.  */
    1317                 :     5084965 :   gimple_cond_set_true_label (entry, NULL_TREE);
    1318                 :     5084965 :   gimple_cond_set_false_label (entry, NULL_TREE);
    1319                 :     5084965 : }
    1320                 :             : 
    1321                 :             : 
    1322                 :             : /* Called for each element in the hash table (P) as we delete the
    1323                 :             :    edge to cases hash table.
    1324                 :             : 
    1325                 :             :    Clear all the CASE_CHAINs to prevent problems with copying of
    1326                 :             :    SWITCH_EXPRs and structure sharing rules, then free the hash table
    1327                 :             :    element.  */
    1328                 :             : 
    1329                 :             : bool
    1330                 :     1043968 : edge_to_cases_cleanup (edge const &, tree const &value, void *)
    1331                 :             : {
    1332                 :     1043968 :   tree t, next;
    1333                 :             : 
    1334                 :     2254742 :   for (t = value; t; t = next)
    1335                 :             :     {
    1336                 :     1210774 :       next = CASE_CHAIN (t);
    1337                 :     1210774 :       CASE_CHAIN (t) = NULL;
    1338                 :             :     }
    1339                 :             : 
    1340                 :     1043968 :   return true;
    1341                 :             : }
    1342                 :             : 
    1343                 :             : /* Start recording information mapping edges to case labels.  */
    1344                 :             : 
    1345                 :             : void
    1346                 :    31124269 : start_recording_case_labels (void)
    1347                 :             : {
    1348                 :    31124269 :   gcc_assert (edge_to_cases == NULL);
    1349                 :    31124269 :   edge_to_cases = new hash_map<edge, tree>;
    1350                 :    31124269 :   touched_switch_bbs = BITMAP_ALLOC (NULL);
    1351                 :    31124269 : }
    1352                 :             : 
    1353                 :             : /* Return nonzero if we are recording information for case labels.  */
    1354                 :             : 
    1355                 :             : static bool
    1356                 :      378123 : recording_case_labels_p (void)
    1357                 :             : {
    1358                 :      378123 :   return (edge_to_cases != NULL);
    1359                 :             : }
    1360                 :             : 
    1361                 :             : /* Stop recording information mapping edges to case labels and
    1362                 :             :    remove any information we have recorded.  */
    1363                 :             : void
    1364                 :    31124269 : end_recording_case_labels (void)
    1365                 :             : {
    1366                 :    31124269 :   bitmap_iterator bi;
    1367                 :    31124269 :   unsigned i;
    1368                 :    32168237 :   edge_to_cases->traverse<void *, edge_to_cases_cleanup> (NULL);
    1369                 :    62248538 :   delete edge_to_cases;
    1370                 :    31124269 :   edge_to_cases = NULL;
    1371                 :    31270674 :   EXECUTE_IF_SET_IN_BITMAP (touched_switch_bbs, 0, i, bi)
    1372                 :             :     {
    1373                 :      146405 :       basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
    1374                 :      146405 :       if (bb)
    1375                 :             :         {
    1376                 :      435549 :           if (gswitch *stmt = safe_dyn_cast <gswitch *> (*gsi_last_bb (bb)))
    1377                 :      144372 :             group_case_labels_stmt (stmt);
    1378                 :             :         }
    1379                 :             :     }
    1380                 :    31124269 :   BITMAP_FREE (touched_switch_bbs);
    1381                 :    31124269 : }
    1382                 :             : 
    1383                 :             : /* If we are inside a {start,end}_recording_cases block, then return
    1384                 :             :    a chain of CASE_LABEL_EXPRs from T which reference E.
    1385                 :             : 
    1386                 :             :    Otherwise return NULL.  */
    1387                 :             : 
    1388                 :             : tree
    1389                 :      378123 : get_cases_for_edge (edge e, gswitch *t)
    1390                 :             : {
    1391                 :      378123 :   tree *slot;
    1392                 :      378123 :   size_t i, n;
    1393                 :             : 
    1394                 :             :   /* If we are not recording cases, then we do not have CASE_LABEL_EXPR
    1395                 :             :      chains available.  Return NULL so the caller can detect this case.  */
    1396                 :      378123 :   if (!recording_case_labels_p ())
    1397                 :             :     return NULL;
    1398                 :             : 
    1399                 :      332965 :   slot = edge_to_cases->get (e);
    1400                 :      332965 :   if (slot)
    1401                 :      186590 :     return *slot;
    1402                 :             : 
    1403                 :             :   /* If we did not find E in the hash table, then this must be the first
    1404                 :             :      time we have been queried for information about E & T.  Add all the
    1405                 :             :      elements from T to the hash table then perform the query again.  */
    1406                 :             : 
    1407                 :      146375 :   n = gimple_switch_num_labels (t);
    1408                 :     1348298 :   for (i = 0; i < n; i++)
    1409                 :             :     {
    1410                 :     1201923 :       tree elt = gimple_switch_label (t, i);
    1411                 :     1201923 :       tree lab = CASE_LABEL (elt);
    1412                 :     1201923 :       basic_block label_bb = label_to_block (cfun, lab);
    1413                 :     1201923 :       edge this_edge = find_edge (e->src, label_bb);
    1414                 :             : 
    1415                 :             :       /* Add it to the chain of CASE_LABEL_EXPRs referencing E, or create
    1416                 :             :          a new chain.  */
    1417                 :     1201923 :       tree &s = edge_to_cases->get_or_insert (this_edge);
    1418                 :     1201923 :       CASE_CHAIN (elt) = s;
    1419                 :     1201923 :       s = elt;
    1420                 :             :     }
    1421                 :             : 
    1422                 :      146375 :   return *edge_to_cases->get (e);
    1423                 :             : }
    1424                 :             : 
    1425                 :             : /* Create the edges for a GIMPLE_SWITCH starting at block BB.  */
    1426                 :             : 
    1427                 :             : static void
    1428                 :       51802 : make_gimple_switch_edges (gswitch *entry, basic_block bb)
    1429                 :             : {
    1430                 :       51802 :   size_t i, n;
    1431                 :             : 
    1432                 :       51802 :   n = gimple_switch_num_labels (entry);
    1433                 :             : 
    1434                 :      377720 :   for (i = 0; i < n; ++i)
    1435                 :             :     {
    1436                 :      325918 :       basic_block label_bb = gimple_switch_label_bb (cfun, entry, i);
    1437                 :      325918 :       make_edge (bb, label_bb, 0);
    1438                 :             :     }
    1439                 :       51802 : }
    1440                 :             : 
    1441                 :             : 
    1442                 :             : /* Return the basic block holding label DEST.  */
    1443                 :             : 
    1444                 :             : basic_block
    1445                 :   458851288 : label_to_block (struct function *ifun, tree dest)
    1446                 :             : {
    1447                 :   458851288 :   int uid = LABEL_DECL_UID (dest);
    1448                 :             : 
    1449                 :             :   /* We would die hard when faced by an undefined label.  Emit a label to
    1450                 :             :      the very first basic block.  This will hopefully make even the dataflow
    1451                 :             :      and undefined variable warnings quite right.  */
    1452                 :   458851288 :   if (seen_error () && uid < 0)
    1453                 :             :     {
    1454                 :          97 :       gimple_stmt_iterator gsi =
    1455                 :          97 :         gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun, NUM_FIXED_BLOCKS));
    1456                 :          97 :       gimple *stmt;
    1457                 :             : 
    1458                 :          97 :       stmt = gimple_build_label (dest);
    1459                 :          97 :       gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
    1460                 :          97 :       uid = LABEL_DECL_UID (dest);
    1461                 :             :     }
    1462                 :   458851288 :   if (vec_safe_length (ifun->cfg->x_label_to_block_map) <= (unsigned int) uid)
    1463                 :             :     return NULL;
    1464                 :   458851288 :   return (*ifun->cfg->x_label_to_block_map)[uid];
    1465                 :             : }
    1466                 :             : 
    1467                 :             : /* Create edges for a goto statement at block BB.  Returns true
    1468                 :             :    if abnormal edges should be created.  */
    1469                 :             : 
    1470                 :             : static bool
    1471                 :     5645173 : make_goto_expr_edges (basic_block bb)
    1472                 :             : {
    1473                 :     5645173 :   gimple_stmt_iterator last = gsi_last_bb (bb);
    1474                 :     5645173 :   gimple *goto_t = gsi_stmt (last);
    1475                 :             : 
    1476                 :             :   /* A simple GOTO creates normal edges.  */
    1477                 :     5645173 :   if (simple_goto_p (goto_t))
    1478                 :             :     {
    1479                 :     5644092 :       tree dest = gimple_goto_dest (goto_t);
    1480                 :     5644092 :       basic_block label_bb = label_to_block (cfun, dest);
    1481                 :     5644092 :       edge e = make_edge (bb, label_bb, EDGE_FALLTHRU);
    1482                 :     5644092 :       e->goto_locus = gimple_location (goto_t);
    1483                 :     5644092 :       gsi_remove (&last, true);
    1484                 :     5644092 :       return false;
    1485                 :             :     }
    1486                 :             : 
    1487                 :             :   /* A computed GOTO creates abnormal edges.  */
    1488                 :             :   return true;
    1489                 :             : }
    1490                 :             : 
    1491                 :             : /* Create edges for an asm statement with labels at block BB.  */
    1492                 :             : 
    1493                 :             : static void
    1494                 :        2189 : make_gimple_asm_edges (basic_block bb)
    1495                 :             : {
    1496                 :        4378 :   gasm *stmt = as_a <gasm *> (*gsi_last_bb (bb));
    1497                 :        2189 :   int i, n = gimple_asm_nlabels (stmt);
    1498                 :             : 
    1499                 :        2952 :   for (i = 0; i < n; ++i)
    1500                 :             :     {
    1501                 :         763 :       tree label = TREE_VALUE (gimple_asm_label_op (stmt, i));
    1502                 :         763 :       basic_block label_bb = label_to_block (cfun, label);
    1503                 :         763 :       make_edge (bb, label_bb, 0);
    1504                 :             :     }
    1505                 :        2189 : }
    1506                 :             : 
    1507                 :             : /*---------------------------------------------------------------------------
    1508                 :             :                                Flowgraph analysis
    1509                 :             : ---------------------------------------------------------------------------*/
    1510                 :             : 
    1511                 :             : /* Cleanup useless labels in basic blocks.  This is something we wish
    1512                 :             :    to do early because it allows us to group case labels before creating
    1513                 :             :    the edges for the CFG, and it speeds up block statement iterators in
    1514                 :             :    all passes later on.
    1515                 :             :    We rerun this pass after CFG is created, to get rid of the labels that
    1516                 :             :    are no longer referenced.  After then we do not run it any more, since
    1517                 :             :    (almost) no new labels should be created.  */
    1518                 :             : 
    1519                 :             : /* A map from basic block index to the leading label of that block.  */
    1520                 :             : struct label_record
    1521                 :             : {
    1522                 :             :   /* The label.  */
    1523                 :             :   tree label;
    1524                 :             : 
    1525                 :             :   /* True if the label is referenced from somewhere.  */
    1526                 :             :   bool used;
    1527                 :             : };
    1528                 :             : 
    1529                 :             : /* Given LABEL return the first label in the same basic block.  */
    1530                 :             : 
    1531                 :             : static tree
    1532                 :    19062007 : main_block_label (tree label, label_record *label_for_bb)
    1533                 :             : {
    1534                 :    19062007 :   basic_block bb = label_to_block (cfun, label);
    1535                 :    19062007 :   tree main_label = label_for_bb[bb->index].label;
    1536                 :             : 
    1537                 :             :   /* label_to_block possibly inserted undefined label into the chain.  */
    1538                 :    19062007 :   if (!main_label)
    1539                 :             :     {
    1540                 :          88 :       label_for_bb[bb->index].label = label;
    1541                 :          88 :       main_label = label;
    1542                 :             :     }
    1543                 :             : 
    1544                 :    19062007 :   label_for_bb[bb->index].used = true;
    1545                 :    19062007 :   return main_label;
    1546                 :             : }
    1547                 :             : 
    1548                 :             : /* Clean up redundant labels within the exception tree.  */
    1549                 :             : 
    1550                 :             : static void
    1551                 :     6817450 : cleanup_dead_labels_eh (label_record *label_for_bb)
    1552                 :             : {
    1553                 :     6817450 :   eh_landing_pad lp;
    1554                 :     6817450 :   eh_region r;
    1555                 :     6817450 :   tree lab;
    1556                 :     6817450 :   int i;
    1557                 :             : 
    1558                 :     6817450 :   if (cfun->eh == NULL)
    1559                 :     6817450 :     return;
    1560                 :             : 
    1561                 :     9914350 :   for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i)
    1562                 :     3096900 :     if (lp && lp->post_landing_pad)
    1563                 :             :       {
    1564                 :     1765406 :         lab = main_block_label (lp->post_landing_pad, label_for_bb);
    1565                 :     1765406 :         if (lab != lp->post_landing_pad)
    1566                 :             :           {
    1567                 :           0 :             EH_LANDING_PAD_NR (lp->post_landing_pad) = 0;
    1568                 :           0 :             lp->post_landing_pad = lab;
    1569                 :           0 :             EH_LANDING_PAD_NR (lab) = lp->index;
    1570                 :             :           }
    1571                 :             :       }
    1572                 :             : 
    1573                 :    11680192 :   FOR_ALL_EH_REGION (r)
    1574                 :     4862742 :     switch (r->type)
    1575                 :             :       {
    1576                 :             :       case ERT_CLEANUP:
    1577                 :             :       case ERT_MUST_NOT_THROW:
    1578                 :             :         break;
    1579                 :             : 
    1580                 :      127661 :       case ERT_TRY:
    1581                 :      127661 :         {
    1582                 :      127661 :           eh_catch c;
    1583                 :      254883 :           for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
    1584                 :             :             {
    1585                 :      127222 :               lab = c->label;
    1586                 :      127222 :               if (lab)
    1587                 :       85650 :                 c->label = main_block_label (lab, label_for_bb);
    1588                 :             :             }
    1589                 :             :         }
    1590                 :             :         break;
    1591                 :             : 
    1592                 :       10662 :       case ERT_ALLOWED_EXCEPTIONS:
    1593                 :       10662 :         lab = r->u.allowed.label;
    1594                 :       10662 :         if (lab)
    1595                 :        1116 :           r->u.allowed.label = main_block_label (lab, label_for_bb);
    1596                 :             :         break;
    1597                 :             :       }
    1598                 :             : }
    1599                 :             : 
    1600                 :             : 
    1601                 :             : /* Cleanup redundant labels.  This is a three-step process:
    1602                 :             :      1) Find the leading label for each block.
    1603                 :             :      2) Redirect all references to labels to the leading labels.
    1604                 :             :      3) Cleanup all useless labels.  */
    1605                 :             : 
    1606                 :             : void
    1607                 :     6817450 : cleanup_dead_labels (void)
    1608                 :             : {
    1609                 :     6817450 :   basic_block bb;
    1610                 :     6817450 :   label_record *label_for_bb = XCNEWVEC (struct label_record,
    1611                 :             :                                          last_basic_block_for_fn (cfun));
    1612                 :             : 
    1613                 :             :   /* Find a suitable label for each block.  We use the first user-defined
    1614                 :             :      label if there is one, or otherwise just the first label we see.  */
    1615                 :    58744277 :   FOR_EACH_BB_FN (bb, cfun)
    1616                 :             :     {
    1617                 :    51926827 :       gimple_stmt_iterator i;
    1618                 :             : 
    1619                 :   135673634 :       for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
    1620                 :             :         {
    1621                 :    82487353 :           tree label;
    1622                 :    83754667 :           glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (i));
    1623                 :             : 
    1624                 :    31827840 :           if (!label_stmt)
    1625                 :             :             break;
    1626                 :             : 
    1627                 :    31827840 :           label = gimple_label_label (label_stmt);
    1628                 :             : 
    1629                 :             :           /* If we have not yet seen a label for the current block,
    1630                 :             :              remember this one and see if there are more labels.  */
    1631                 :    31827840 :           if (!label_for_bb[bb->index].label)
    1632                 :             :             {
    1633                 :    29723657 :               label_for_bb[bb->index].label = label;
    1634                 :    29723657 :               continue;
    1635                 :             :             }
    1636                 :             : 
    1637                 :             :           /* If we did see a label for the current block already, but it
    1638                 :             :              is an artificially created label, replace it if the current
    1639                 :             :              label is a user defined label.  */
    1640                 :     2104183 :           if (!DECL_ARTIFICIAL (label)
    1641                 :     2104183 :               && DECL_ARTIFICIAL (label_for_bb[bb->index].label))
    1642                 :             :             {
    1643                 :        7860 :               label_for_bb[bb->index].label = label;
    1644                 :        7860 :               break;
    1645                 :             :             }
    1646                 :             :         }
    1647                 :             :     }
    1648                 :             : 
    1649                 :             :   /* Now redirect all jumps/branches to the selected label.
    1650                 :             :      First do so for each block ending in a control statement.  */
    1651                 :    58744277 :   FOR_EACH_BB_FN (bb, cfun)
    1652                 :             :     {
    1653                 :    51926827 :       gimple *stmt = *gsi_last_bb (bb);
    1654                 :    51926827 :       tree label, new_label;
    1655                 :             : 
    1656                 :    51926827 :       if (!stmt)
    1657                 :      518633 :         continue;
    1658                 :             : 
    1659                 :    51408194 :       switch (gimple_code (stmt))
    1660                 :             :         {
    1661                 :    15356748 :         case GIMPLE_COND:
    1662                 :    15356748 :           {
    1663                 :    15356748 :             gcond *cond_stmt = as_a <gcond *> (stmt);
    1664                 :    15356748 :             label = gimple_cond_true_label (cond_stmt);
    1665                 :    15356748 :             if (label)
    1666                 :             :               {
    1667                 :     5056276 :                 new_label = main_block_label (label, label_for_bb);
    1668                 :     5056276 :                 if (new_label != label)
    1669                 :        8630 :                   gimple_cond_set_true_label (cond_stmt, new_label);
    1670                 :             :               }
    1671                 :             : 
    1672                 :    15356748 :             label = gimple_cond_false_label (cond_stmt);
    1673                 :    15356748 :             if (label)
    1674                 :             :               {
    1675                 :     5056276 :                 new_label = main_block_label (label, label_for_bb);
    1676                 :     5056276 :                 if (new_label != label)
    1677                 :       97312 :                   gimple_cond_set_false_label (cond_stmt, new_label);
    1678                 :             :               }
    1679                 :             :           }
    1680                 :             :           break;
    1681                 :             : 
    1682                 :      110039 :         case GIMPLE_SWITCH:
    1683                 :      110039 :           {
    1684                 :      110039 :             gswitch *switch_stmt = as_a <gswitch *> (stmt);
    1685                 :      110039 :             size_t i, n = gimple_switch_num_labels (switch_stmt);
    1686                 :             : 
    1687                 :             :             /* Replace all destination labels.  */
    1688                 :     1586883 :             for (i = 0; i < n; ++i)
    1689                 :             :               {
    1690                 :     1476844 :                 tree case_label = gimple_switch_label (switch_stmt, i);
    1691                 :     1476844 :                 label = CASE_LABEL (case_label);
    1692                 :     1476844 :                 new_label = main_block_label (label, label_for_bb);
    1693                 :     1476844 :                 if (new_label != label)
    1694                 :      790839 :                   CASE_LABEL (case_label) = new_label;
    1695                 :             :               }
    1696                 :             :             break;
    1697                 :             :           }
    1698                 :             : 
    1699                 :        7564 :         case GIMPLE_ASM:
    1700                 :        7564 :           {
    1701                 :        7564 :             gasm *asm_stmt = as_a <gasm *> (stmt);
    1702                 :        7564 :             int i, n = gimple_asm_nlabels (asm_stmt);
    1703                 :             : 
    1704                 :        9810 :             for (i = 0; i < n; ++i)
    1705                 :             :               {
    1706                 :        2246 :                 tree cons = gimple_asm_label_op (asm_stmt, i);
    1707                 :        2246 :                 tree label = main_block_label (TREE_VALUE (cons), label_for_bb);
    1708                 :        2246 :                 TREE_VALUE (cons) = label;
    1709                 :             :               }
    1710                 :             :             break;
    1711                 :             :           }
    1712                 :             : 
    1713                 :             :         /* We have to handle gotos until they're removed, and we don't
    1714                 :             :            remove them until after we've created the CFG edges.  */
    1715                 :     5617872 :         case GIMPLE_GOTO:
    1716                 :     5617872 :           if (!computed_goto_p (stmt))
    1717                 :             :             {
    1718                 :     5615783 :               ggoto *goto_stmt = as_a <ggoto *> (stmt);
    1719                 :     5615783 :               label = gimple_goto_dest (goto_stmt);
    1720                 :     5615783 :               new_label = main_block_label (label, label_for_bb);
    1721                 :     5615783 :               if (new_label != label)
    1722                 :     1007201 :                 gimple_goto_set_dest (goto_stmt, new_label);
    1723                 :             :             }
    1724                 :             :           break;
    1725                 :             : 
    1726                 :         822 :         case GIMPLE_TRANSACTION:
    1727                 :         822 :           {
    1728                 :         822 :             gtransaction *txn = as_a <gtransaction *> (stmt);
    1729                 :             : 
    1730                 :         822 :             label = gimple_transaction_label_norm (txn);
    1731                 :         822 :             if (label)
    1732                 :             :               {
    1733                 :         802 :                 new_label = main_block_label (label, label_for_bb);
    1734                 :         802 :                 if (new_label != label)
    1735                 :           0 :                   gimple_transaction_set_label_norm (txn, new_label);
    1736                 :             :               }
    1737                 :             : 
    1738                 :         822 :             label = gimple_transaction_label_uninst (txn);
    1739                 :         822 :             if (label)
    1740                 :             :               {
    1741                 :         794 :                 new_label = main_block_label (label, label_for_bb);
    1742                 :         794 :                 if (new_label != label)
    1743                 :           0 :                   gimple_transaction_set_label_uninst (txn, new_label);
    1744                 :             :               }
    1745                 :             : 
    1746                 :         822 :             label = gimple_transaction_label_over (txn);
    1747                 :         822 :             if (label)
    1748                 :             :               {
    1749                 :         814 :                 new_label = main_block_label (label, label_for_bb);
    1750                 :         814 :                 if (new_label != label)
    1751                 :           7 :                   gimple_transaction_set_label_over (txn, new_label);
    1752                 :             :               }
    1753                 :             :           }
    1754                 :             :           break;
    1755                 :             : 
    1756                 :             :         default:
    1757                 :             :           break;
    1758                 :             :       }
    1759                 :             :     }
    1760                 :             : 
    1761                 :             :   /* Do the same for the exception region tree labels.  */
    1762                 :     6817450 :   cleanup_dead_labels_eh (label_for_bb);
    1763                 :             : 
    1764                 :             :   /* Finally, purge dead labels.  All user-defined labels and labels that
    1765                 :             :      can be the target of non-local gotos and labels which have their
    1766                 :             :      address taken are preserved.  */
    1767                 :    58744277 :   FOR_EACH_BB_FN (bb, cfun)
    1768                 :             :     {
    1769                 :    51926827 :       gimple_stmt_iterator i;
    1770                 :    51926827 :       tree label_for_this_bb = label_for_bb[bb->index].label;
    1771                 :             : 
    1772                 :    51926827 :       if (!label_for_this_bb)
    1773                 :    22203082 :         continue;
    1774                 :             : 
    1775                 :             :       /* If the main label of the block is unused, we may still remove it.  */
    1776                 :    29723745 :       if (!label_for_bb[bb->index].used)
    1777                 :    13918304 :         label_for_this_bb = NULL;
    1778                 :             : 
    1779                 :    91275427 :       for (i = gsi_start_bb (bb); !gsi_end_p (i); )
    1780                 :             :         {
    1781                 :    60810418 :           tree label;
    1782                 :    61551682 :           glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (i));
    1783                 :             : 
    1784                 :    31827937 :           if (!label_stmt)
    1785                 :             :             break;
    1786                 :             : 
    1787                 :    31827937 :           label = gimple_label_label (label_stmt);
    1788                 :             : 
    1789                 :    31827937 :           if (label == label_for_this_bb
    1790                 :    16022496 :               || !DECL_ARTIFICIAL (label)
    1791                 :    15400103 :               || DECL_NONLOCAL (label)
    1792                 :    47226587 :               || FORCED_LABEL (label))
    1793                 :    16452657 :             gsi_next (&i);
    1794                 :             :           else
    1795                 :             :             {
    1796                 :    15375280 :               gcc_checking_assert (EH_LANDING_PAD_NR (label) == 0);
    1797                 :    15375280 :               gsi_remove (&i, true);
    1798                 :             :             }
    1799                 :             :         }
    1800                 :             :     }
    1801                 :             : 
    1802                 :     6817450 :   free (label_for_bb);
    1803                 :     6817450 : }
    1804                 :             : 
    1805                 :             : /* Scan the sorted vector of cases in STMT (a GIMPLE_SWITCH) and combine
    1806                 :             :    the ones jumping to the same label.
    1807                 :             :    Eg. three separate entries 1: 2: 3: become one entry 1..3:  */
    1808                 :             : 
    1809                 :             : bool
    1810                 :      256355 : group_case_labels_stmt (gswitch *stmt)
    1811                 :             : {
    1812                 :      256355 :   int old_size = gimple_switch_num_labels (stmt);
    1813                 :      256355 :   int i, next_index, new_size;
    1814                 :      256355 :   basic_block default_bb = NULL;
    1815                 :      256355 :   hash_set<tree> *removed_labels = NULL;
    1816                 :             : 
    1817                 :      256355 :   default_bb = gimple_switch_default_bb (cfun, stmt);
    1818                 :             : 
    1819                 :             :   /* Look for possible opportunities to merge cases.  */
    1820                 :      256355 :   new_size = i = 1;
    1821                 :     2199320 :   while (i < old_size)
    1822                 :             :     {
    1823                 :     1686610 :       tree base_case, base_high;
    1824                 :     1686610 :       basic_block base_bb;
    1825                 :             : 
    1826                 :     1686610 :       base_case = gimple_switch_label (stmt, i);
    1827                 :             : 
    1828                 :     1686610 :       gcc_assert (base_case);
    1829                 :     1686610 :       base_bb = label_to_block (cfun, CASE_LABEL (base_case));
    1830                 :             : 
    1831                 :             :       /* Discard cases that have the same destination as the default case or
    1832                 :             :          whose destination blocks have already been removed as unreachable.  */
    1833                 :     1690792 :       if (base_bb == NULL
    1834                 :     1686610 :           || base_bb == default_bb
    1835                 :     1686610 :           || (removed_labels
    1836                 :           0 :               && removed_labels->contains (CASE_LABEL (base_case))))
    1837                 :             :         {
    1838                 :        4182 :           i++;
    1839                 :        4182 :           continue;
    1840                 :             :         }
    1841                 :             : 
    1842                 :     1682428 :       base_high = CASE_HIGH (base_case)
    1843                 :     3364856 :           ? CASE_HIGH (base_case)
    1844                 :     1572620 :           : CASE_LOW (base_case);
    1845                 :     1682428 :       next_index = i + 1;
    1846                 :             : 
    1847                 :             :       /* Try to merge case labels.  Break out when we reach the end
    1848                 :             :          of the label vector or when we cannot merge the next case
    1849                 :             :          label with the current one.  */
    1850                 :     2431273 :       while (next_index < old_size)
    1851                 :             :         {
    1852                 :     2176574 :           tree merge_case = gimple_switch_label (stmt, next_index);
    1853                 :     2176574 :           basic_block merge_bb = label_to_block (cfun, CASE_LABEL (merge_case));
    1854                 :     2176574 :           wide_int bhp1 = wi::to_wide (base_high) + 1;
    1855                 :             : 
    1856                 :             :           /* Merge the cases if they jump to the same place,
    1857                 :             :              and their ranges are consecutive.  */
    1858                 :     2176574 :           if (merge_bb == base_bb
    1859                 :      844900 :               && (removed_labels == NULL
    1860                 :           0 :                   || !removed_labels->contains (CASE_LABEL (merge_case)))
    1861                 :     3021474 :               && wi::to_wide (CASE_LOW (merge_case)) == bhp1)
    1862                 :             :             {
    1863                 :      748845 :               base_high
    1864                 :      748845 :                 = (CASE_HIGH (merge_case)
    1865                 :      748845 :                    ? CASE_HIGH (merge_case) : CASE_LOW (merge_case));
    1866                 :      748845 :               CASE_HIGH (base_case) = base_high;
    1867                 :      748845 :               next_index++;
    1868                 :             :             }
    1869                 :             :           else
    1870                 :             :             break;
    1871                 :     2176574 :         }
    1872                 :             : 
    1873                 :             :       /* Discard cases that have an unreachable destination block.  */
    1874                 :     1692478 :       if (EDGE_COUNT (base_bb->succs) == 0
    1875                 :      291821 :           && gimple_seq_unreachable_p (bb_seq (base_bb))
    1876                 :             :           /* Don't optimize this if __builtin_unreachable () is the
    1877                 :             :              implicitly added one by the C++ FE too early, before
    1878                 :             :              -Wreturn-type can be diagnosed.  We'll optimize it later
    1879                 :             :              during switchconv pass or any other cfg cleanup.  */
    1880                 :     1401830 :           && (gimple_in_ssa_p (cfun)
    1881                 :        1157 :               || (LOCATION_LOCUS (gimple_location (last_nondebug_stmt (base_bb)))
    1882                 :             :                   != BUILTINS_LOCATION)))
    1883                 :             :         {
    1884                 :        1172 :           edge base_edge = find_edge (gimple_bb (stmt), base_bb);
    1885                 :        1172 :           if (base_edge != NULL)
    1886                 :             :             {
    1887                 :          30 :               for (gimple_stmt_iterator gsi = gsi_start_bb (base_bb);
    1888                 :          30 :                    !gsi_end_p (gsi); gsi_next (&gsi))
    1889                 :          30 :                 if (glabel *stmt = dyn_cast <glabel *> (gsi_stmt (gsi)))
    1890                 :             :                   {
    1891                 :          15 :                     if (FORCED_LABEL (gimple_label_label (stmt))
    1892                 :          15 :                         || DECL_NONLOCAL (gimple_label_label (stmt)))
    1893                 :             :                       {
    1894                 :             :                         /* Forced/non-local labels aren't going to be removed,
    1895                 :             :                            but they will be moved to some neighbouring basic
    1896                 :             :                            block. If some later case label refers to one of
    1897                 :             :                            those labels, we should throw that case away rather
    1898                 :             :                            than keeping it around and refering to some random
    1899                 :             :                            other basic block without an edge to it.  */
    1900                 :           0 :                         if (removed_labels == NULL)
    1901                 :           0 :                           removed_labels = new hash_set<tree>;
    1902                 :           0 :                         removed_labels->add (gimple_label_label (stmt));
    1903                 :             :                       }
    1904                 :             :                   }
    1905                 :             :                 else
    1906                 :             :                   break;
    1907                 :          15 :               remove_edge_and_dominated_blocks (base_edge);
    1908                 :             :             }
    1909                 :        1172 :           i = next_index;
    1910                 :        1172 :           continue;
    1911                 :        1172 :         }
    1912                 :             : 
    1913                 :     1681256 :       if (new_size < i)
    1914                 :       82710 :         gimple_switch_set_label (stmt, new_size,
    1915                 :             :                                  gimple_switch_label (stmt, i));
    1916                 :     1681256 :       i = next_index;
    1917                 :     1681256 :       new_size++;
    1918                 :             :     }
    1919                 :             : 
    1920                 :      256355 :   gcc_assert (new_size <= old_size);
    1921                 :             : 
    1922                 :      256355 :   if (new_size < old_size)
    1923                 :       19478 :     gimple_switch_set_num_labels (stmt, new_size);
    1924                 :             : 
    1925                 :      256355 :   delete removed_labels;
    1926                 :      256355 :   return new_size < old_size;
    1927                 :             : }
    1928                 :             : 
    1929                 :             : /* Look for blocks ending in a multiway branch (a GIMPLE_SWITCH),
    1930                 :             :    and scan the sorted vector of cases.  Combine the ones jumping to the
    1931                 :             :    same label.  */
    1932                 :             : 
    1933                 :             : bool
    1934                 :     4114953 : group_case_labels (void)
    1935                 :             : {
    1936                 :     4114953 :   basic_block bb;
    1937                 :     4114953 :   bool changed = false;
    1938                 :             : 
    1939                 :    35992114 :   FOR_EACH_BB_FN (bb, cfun)
    1940                 :             :     {
    1941                 :    95253795 :       if (gswitch *stmt = safe_dyn_cast <gswitch *> (*gsi_last_bb (bb)))
    1942                 :       58237 :         changed |= group_case_labels_stmt (stmt);
    1943                 :             :     }
    1944                 :             : 
    1945                 :     4114953 :   return changed;
    1946                 :             : }
    1947                 :             : 
    1948                 :             : /* Checks whether we can merge block B into block A.  */
    1949                 :             : 
    1950                 :             : static bool
    1951                 :   399168020 : gimple_can_merge_blocks_p (basic_block a, basic_block b)
    1952                 :             : {
    1953                 :   399168020 :   gimple *stmt;
    1954                 :             : 
    1955                 :   571577890 :   if (!single_succ_p (a))
    1956                 :             :     return false;
    1957                 :             : 
    1958                 :   193993840 :   if (single_succ_edge (a)->flags & EDGE_COMPLEX)
    1959                 :             :     return false;
    1960                 :             : 
    1961                 :   182187627 :   if (single_succ (a) != b)
    1962                 :             :     return false;
    1963                 :             : 
    1964                 :   463602544 :   if (!single_pred_p (b))
    1965                 :             :     return false;
    1966                 :             : 
    1967                 :    86018494 :   if (a == ENTRY_BLOCK_PTR_FOR_FN (cfun)
    1968                 :    53576511 :       || b == EXIT_BLOCK_PTR_FOR_FN (cfun))
    1969                 :             :     return false;
    1970                 :             : 
    1971                 :             :   /* If A ends by a statement causing exceptions or something similar, we
    1972                 :             :      cannot merge the blocks.  */
    1973                 :    25819133 :   stmt = *gsi_last_bb (a);
    1974                 :    25819133 :   if (stmt && stmt_ends_bb_p (stmt))
    1975                 :             :     return false;
    1976                 :             : 
    1977                 :             :   /* Examine the labels at the beginning of B.  */
    1978                 :    48249414 :   for (gimple_stmt_iterator gsi = gsi_start_bb (b); !gsi_end_p (gsi);
    1979                 :      162210 :        gsi_next (&gsi))
    1980                 :             :     {
    1981                 :    22871719 :       tree lab;
    1982                 :    22871719 :       glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (gsi));
    1983                 :     1807958 :       if (!label_stmt)
    1984                 :             :         break;
    1985                 :     1807958 :       lab = gimple_label_label (label_stmt);
    1986                 :             : 
    1987                 :             :       /* Do not remove user forced labels or for -O0 any user labels.  */
    1988                 :     1850643 :       if (!DECL_ARTIFICIAL (lab) && (!optimize || FORCED_LABEL (lab)))
    1989                 :   377584050 :         return false;
    1990                 :             :     }
    1991                 :             : 
    1992                 :             :   /* Protect simple loop latches.  We only want to avoid merging
    1993                 :             :      the latch with the loop header or with a block in another
    1994                 :             :      loop in this case.  */
    1995                 :    22397854 :   if (current_loops
    1996                 :    20010088 :       && b->loop_father->latch == b
    1997                 :      346922 :       && loops_state_satisfies_p (LOOPS_HAVE_SIMPLE_LATCHES)
    1998                 :    22428784 :       && (b->loop_father->header == a
    1999                 :       19436 :           || b->loop_father != a->loop_father))
    2000                 :             :     return false;
    2001                 :             : 
    2002                 :             :   /* It must be possible to eliminate all phi nodes in B.  If ssa form
    2003                 :             :      is not up-to-date and a name-mapping is registered, we cannot eliminate
    2004                 :             :      any phis.  Symbols marked for renaming are never a problem though.  */
    2005                 :    27795038 :   for (gphi_iterator gsi = gsi_start_phis (b); !gsi_end_p (gsi);
    2006                 :     5408822 :        gsi_next (&gsi))
    2007                 :             :     {
    2008                 :     5408822 :       gphi *phi = gsi.phi ();
    2009                 :             :       /* Technically only new names matter.  */
    2010                 :     5408822 :       if (name_registered_for_update_p (PHI_RESULT (phi)))
    2011                 :           0 :         return false;
    2012                 :             :     }
    2013                 :             : 
    2014                 :             :   /* When not optimizing, don't merge if we'd lose goto_locus.  */
    2015                 :    22386216 :   if (!optimize
    2016                 :    22386216 :       && single_succ_edge (a)->goto_locus != UNKNOWN_LOCATION)
    2017                 :             :     {
    2018                 :      835053 :       location_t goto_locus = single_succ_edge (a)->goto_locus;
    2019                 :      835053 :       gimple_stmt_iterator prev, next;
    2020                 :      835053 :       prev = gsi_last_nondebug_bb (a);
    2021                 :      835053 :       next = gsi_after_labels (b);
    2022                 :      835053 :       if (!gsi_end_p (next) && is_gimple_debug (gsi_stmt (next)))
    2023                 :           6 :         gsi_next_nondebug (&next);
    2024                 :      835053 :       if ((gsi_end_p (prev)
    2025                 :      725558 :            || gimple_location (gsi_stmt (prev)) != goto_locus)
    2026                 :     1540025 :           && (gsi_end_p (next)
    2027                 :      768977 :               || gimple_location (gsi_stmt (next)) != goto_locus))
    2028                 :      802246 :         return false;
    2029                 :             :     }
    2030                 :             : 
    2031                 :             :   return true;
    2032                 :             : }
    2033                 :             : 
    2034                 :             : /* Replaces all uses of NAME by VAL.  */
    2035                 :             : 
    2036                 :             : void
    2037                 :     3315575 : replace_uses_by (tree name, tree val)
    2038                 :             : {
    2039                 :     3315575 :   imm_use_iterator imm_iter;
    2040                 :     3315575 :   use_operand_p use;
    2041                 :     3315575 :   gimple *stmt;
    2042                 :     3315575 :   edge e;
    2043                 :             : 
    2044                 :     9152752 :   FOR_EACH_IMM_USE_STMT (stmt, imm_iter, name)
    2045                 :             :     {
    2046                 :             :       /* Mark the block if we change the last stmt in it.  */
    2047                 :     5837177 :       if (cfgcleanup_altered_bbs
    2048                 :     5837177 :           && stmt_ends_bb_p (stmt))
    2049                 :      726238 :         bitmap_set_bit (cfgcleanup_altered_bbs, gimple_bb (stmt)->index);
    2050                 :             : 
    2051                 :    17815247 :       FOR_EACH_IMM_USE_ON_STMT (use, imm_iter)
    2052                 :             :         {
    2053                 :     5989035 :           replace_exp (use, val);
    2054                 :             : 
    2055                 :     5989035 :           if (gimple_code (stmt) == GIMPLE_PHI)
    2056                 :             :             {
    2057                 :     2227508 :               e = gimple_phi_arg_edge (as_a <gphi *> (stmt),
    2058                 :     2227508 :                                        PHI_ARG_INDEX_FROM_USE (use));
    2059                 :     2227508 :               if (e->flags & EDGE_ABNORMAL
    2060                 :     2227508 :                   && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val))
    2061                 :             :                 {
    2062                 :             :                   /* This can only occur for virtual operands, since
    2063                 :             :                      for the real ones SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
    2064                 :             :                      would prevent replacement.  */
    2065                 :           0 :                   gcc_checking_assert (virtual_operand_p (name));
    2066                 :           0 :                   SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val) = 1;
    2067                 :             :                 }
    2068                 :             :             }
    2069                 :             :         }
    2070                 :             : 
    2071                 :     5837177 :       if (gimple_code (stmt) != GIMPLE_PHI)
    2072                 :             :         {
    2073                 :     3754701 :           gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
    2074                 :     3754701 :           gimple *orig_stmt = stmt;
    2075                 :     3754701 :           size_t i;
    2076                 :             : 
    2077                 :             :           /* FIXME.  It shouldn't be required to keep TREE_CONSTANT
    2078                 :             :              on ADDR_EXPRs up-to-date on GIMPLE.  Propagation will
    2079                 :             :              only change sth from non-invariant to invariant, and only
    2080                 :             :              when propagating constants.  */
    2081                 :     3754701 :           if (is_gimple_min_invariant (val))
    2082                 :     1605227 :             for (i = 0; i < gimple_num_ops (stmt); i++)
    2083                 :             :               {
    2084                 :     1163977 :                 tree op = gimple_op (stmt, i);
    2085                 :             :                 /* Operands may be empty here.  For example, the labels
    2086                 :             :                    of a GIMPLE_COND are nulled out following the creation
    2087                 :             :                    of the corresponding CFG edges.  */
    2088                 :     1163977 :                 if (op && TREE_CODE (op) == ADDR_EXPR)
    2089                 :       57782 :                   recompute_tree_invariant_for_addr_expr (op);
    2090                 :             :               }
    2091                 :             : 
    2092                 :     3754701 :           if (fold_stmt (&gsi))
    2093                 :      604135 :             stmt = gsi_stmt (gsi);
    2094                 :             : 
    2095                 :     3754701 :           if (maybe_clean_or_replace_eh_stmt (orig_stmt, stmt))
    2096                 :         114 :             gimple_purge_dead_eh_edges (gimple_bb (stmt));
    2097                 :             : 
    2098                 :     3754701 :           update_stmt (stmt);
    2099                 :             :         }
    2100                 :     3315575 :     }
    2101                 :             : 
    2102                 :     3315575 :   gcc_checking_assert (has_zero_uses (name));
    2103                 :             : 
    2104                 :             :   /* Also update the trees stored in loop structures.  */
    2105                 :     3315575 :   if (current_loops)
    2106                 :             :     {
    2107                 :    81184684 :       for (auto loop : loops_list (cfun, 0))
    2108                 :    74553534 :           substitute_in_loop_info (loop, name, val);
    2109                 :             :     }
    2110                 :     3315575 : }
    2111                 :             : 
    2112                 :             : /* Merge block B into block A.  */
    2113                 :             : 
    2114                 :             : static void
    2115                 :    13543376 : gimple_merge_blocks (basic_block a, basic_block b)
    2116                 :             : {
    2117                 :    13543376 :   gimple_stmt_iterator last, gsi;
    2118                 :    13543376 :   gphi_iterator psi;
    2119                 :             : 
    2120                 :    13543376 :   if (dump_file)
    2121                 :       18222 :     fprintf (dump_file, "Merging blocks %d and %d\n", a->index, b->index);
    2122                 :             : 
    2123                 :             :   /* Remove all single-valued PHI nodes from block B of the form
    2124                 :             :      V_i = PHI <V_j> by propagating V_j to all the uses of V_i.  */
    2125                 :    13543376 :   gsi = gsi_last_bb (a);
    2126                 :    17384842 :   for (psi = gsi_start_phis (b); !gsi_end_p (psi); )
    2127                 :             :     {
    2128                 :     3841466 :       gimple *phi = gsi_stmt (psi);
    2129                 :     3841466 :       tree def = gimple_phi_result (phi), use = gimple_phi_arg_def (phi, 0);
    2130                 :     3841466 :       gimple *copy;
    2131                 :     3841466 :       bool may_replace_uses = (virtual_operand_p (def)
    2132                 :     3841466 :                                || may_propagate_copy (def, use));
    2133                 :             : 
    2134                 :             :       /* In case we maintain loop closed ssa form, do not propagate arguments
    2135                 :             :          of loop exit phi nodes.  */
    2136                 :     3841466 :       if (current_loops
    2137                 :     3841466 :           && loops_state_satisfies_p (LOOP_CLOSED_SSA)
    2138                 :      562413 :           && !virtual_operand_p (def)
    2139                 :      395856 :           && TREE_CODE (use) == SSA_NAME
    2140                 :     4138718 :           && a->loop_father != b->loop_father)
    2141                 :             :         may_replace_uses = false;
    2142                 :             : 
    2143                 :     3840868 :       if (!may_replace_uses)
    2144                 :             :         {
    2145                 :        1650 :           gcc_assert (!virtual_operand_p (def));
    2146                 :             : 
    2147                 :             :           /* Note that just emitting the copies is fine -- there is no problem
    2148                 :             :              with ordering of phi nodes.  This is because A is the single
    2149                 :             :              predecessor of B, therefore results of the phi nodes cannot
    2150                 :             :              appear as arguments of the phi nodes.  */
    2151                 :         825 :           copy = gimple_build_assign (def, use);
    2152                 :         825 :           gsi_insert_after (&gsi, copy, GSI_NEW_STMT);
    2153                 :         825 :           remove_phi_node (&psi, false);
    2154                 :             :         }
    2155                 :             :       else
    2156                 :             :         {
    2157                 :             :           /* If we deal with a PHI for virtual operands, we can simply
    2158                 :             :              propagate these without fussing with folding or updating
    2159                 :             :              the stmt.  */
    2160                 :     7681282 :           if (virtual_operand_p (def))
    2161                 :             :             {
    2162                 :     1548042 :               imm_use_iterator iter;
    2163                 :     1548042 :               use_operand_p use_p;
    2164                 :     1548042 :               gimple *stmt;
    2165                 :             : 
    2166                 :     4393113 :               FOR_EACH_IMM_USE_STMT (stmt, iter, def)
    2167                 :     8586389 :                 FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
    2168                 :     4418701 :                   SET_USE (use_p, use);
    2169                 :             : 
    2170                 :     1548042 :               if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def))
    2171                 :         270 :                 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use) = 1;
    2172                 :             :             }
    2173                 :             :           else
    2174                 :     2292599 :             replace_uses_by (def, use);
    2175                 :             : 
    2176                 :     3840641 :           remove_phi_node (&psi, true);
    2177                 :             :         }
    2178                 :             :     }
    2179                 :             : 
    2180                 :             :   /* Ensure that B follows A.  */
    2181                 :    13543376 :   move_block_after (b, a);
    2182                 :             : 
    2183                 :    13543376 :   gcc_assert (single_succ_edge (a)->flags & EDGE_FALLTHRU);
    2184                 :    27086752 :   gcc_assert (!*gsi_last_bb (a)
    2185                 :             :               || !stmt_ends_bb_p (*gsi_last_bb (a)));
    2186                 :             : 
    2187                 :             :   /* Remove labels from B and set gimple_bb to A for other statements.  */
    2188                 :   103807343 :   for (gsi = gsi_start_bb (b); !gsi_end_p (gsi);)
    2189                 :             :     {
    2190                 :    76720591 :       gimple *stmt = gsi_stmt (gsi);
    2191                 :    76720591 :       if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
    2192                 :             :         {
    2193                 :      106189 :           tree label = gimple_label_label (label_stmt);
    2194                 :      106189 :           int lp_nr;
    2195                 :             : 
    2196                 :      106189 :           gsi_remove (&gsi, false);
    2197                 :             : 
    2198                 :             :           /* Now that we can thread computed gotos, we might have
    2199                 :             :              a situation where we have a forced label in block B
    2200                 :             :              However, the label at the start of block B might still be
    2201                 :             :              used in other ways (think about the runtime checking for
    2202                 :             :              Fortran assigned gotos).  So we cannot just delete the
    2203                 :             :              label.  Instead we move the label to the start of block A.  */
    2204                 :      106189 :           if (FORCED_LABEL (label))
    2205                 :             :             {
    2206                 :        3180 :               gimple_stmt_iterator dest_gsi = gsi_start_bb (a);
    2207                 :        3180 :               tree first_label = NULL_TREE;
    2208                 :        3180 :               if (!gsi_end_p (dest_gsi))
    2209                 :        3166 :                 if (glabel *first_label_stmt
    2210                 :        3166 :                     = dyn_cast <glabel *> (gsi_stmt (dest_gsi)))
    2211                 :        2688 :                   first_label = gimple_label_label (first_label_stmt);
    2212                 :        2688 :               if (first_label
    2213                 :        2688 :                   && (DECL_NONLOCAL (first_label)
    2214                 :        2688 :                       || EH_LANDING_PAD_NR (first_label) != 0))
    2215                 :           3 :                 gsi_insert_after (&dest_gsi, stmt, GSI_NEW_STMT);
    2216                 :             :               else
    2217                 :        3177 :                 gsi_insert_before (&dest_gsi, stmt, GSI_NEW_STMT);
    2218                 :             :             }
    2219                 :             :           /* Other user labels keep around in a form of a debug stmt.  */
    2220                 :      103009 :           else if (!DECL_ARTIFICIAL (label) && MAY_HAVE_DEBUG_BIND_STMTS)
    2221                 :             :             {
    2222                 :        7803 :               gimple *dbg = gimple_build_debug_bind (label,
    2223                 :             :                                                      integer_zero_node,
    2224                 :             :                                                      stmt);
    2225                 :        7803 :               gimple_debug_bind_reset_value (dbg);
    2226                 :        7803 :               gsi_insert_before (&gsi, dbg, GSI_SAME_STMT);
    2227                 :             :             }
    2228                 :             : 
    2229                 :      106189 :           lp_nr = EH_LANDING_PAD_NR (label);
    2230                 :      106189 :           if (lp_nr)
    2231                 :             :             {
    2232                 :       10132 :               eh_landing_pad lp = get_eh_landing_pad_from_number (lp_nr);
    2233                 :       10132 :               lp->post_landing_pad = NULL;
    2234                 :             :             }
    2235                 :             :         }
    2236                 :             :       else
    2237                 :             :         {
    2238                 :    76614402 :           gimple_set_bb (stmt, a);
    2239                 :    76614402 :           gsi_next (&gsi);
    2240                 :             :         }
    2241                 :             :     }
    2242                 :             : 
    2243                 :             :   /* When merging two BBs, if their counts are different, the larger count
    2244                 :             :      is selected as the new bb count. This is to handle inconsistent
    2245                 :             :      profiles.  */
    2246                 :    13543376 :   if (a->loop_father == b->loop_father)
    2247                 :             :     {
    2248                 :    13480011 :       a->count = a->count.merge (b->count);
    2249                 :             :     }
    2250                 :             : 
    2251                 :             :   /* Merge the sequences.  */
    2252                 :    13543376 :   last = gsi_last_bb (a);
    2253                 :    27086752 :   gsi_insert_seq_after (&last, bb_seq (b), GSI_NEW_STMT);
    2254                 :    13543376 :   set_bb_seq (b, NULL);
    2255                 :             : 
    2256                 :    13543376 :   if (cfgcleanup_altered_bbs)
    2257                 :    13520533 :     bitmap_set_bit (cfgcleanup_altered_bbs, a->index);
    2258                 :    13543376 : }
    2259                 :             : 
    2260                 :             : 
    2261                 :             : /* Return the one of two successors of BB that is not reachable by a
    2262                 :             :    complex edge, if there is one.  Else, return BB.  We use
    2263                 :             :    this in optimizations that use post-dominators for their heuristics,
    2264                 :             :    to catch the cases in C++ where function calls are involved.  */
    2265                 :             : 
    2266                 :             : basic_block
    2267                 :           6 : single_noncomplex_succ (basic_block bb)
    2268                 :             : {
    2269                 :           6 :   edge e0, e1;
    2270                 :           6 :   if (EDGE_COUNT (bb->succs) != 2)
    2271                 :             :     return bb;
    2272                 :             : 
    2273                 :           6 :   e0 = EDGE_SUCC (bb, 0);
    2274                 :           6 :   e1 = EDGE_SUCC (bb, 1);
    2275                 :           6 :   if (e0->flags & EDGE_COMPLEX)
    2276                 :           6 :     return e1->dest;
    2277                 :           0 :   if (e1->flags & EDGE_COMPLEX)
    2278                 :           0 :     return e0->dest;
    2279                 :             : 
    2280                 :             :   return bb;
    2281                 :             : }
    2282                 :             : 
    2283                 :             : /* T is CALL_EXPR.  Set current_function_calls_* flags.  */
    2284                 :             : 
    2285                 :             : void
    2286                 :    49418807 : notice_special_calls (gcall *call)
    2287                 :             : {
    2288                 :    49418807 :   int flags = gimple_call_flags (call);
    2289                 :             : 
    2290                 :    49418807 :   if (flags & ECF_MAY_BE_ALLOCA)
    2291                 :      142617 :     cfun->calls_alloca = true;
    2292                 :    49418807 :   if (flags & ECF_RETURNS_TWICE)
    2293                 :        7081 :     cfun->calls_setjmp = true;
    2294                 :    49418807 :   if (gimple_call_must_tail_p (call))
    2295                 :          99 :     cfun->has_musttail = true;
    2296                 :    49418807 : }
    2297                 :             : 
    2298                 :             : 
    2299                 :             : /* Clear flags set by notice_special_calls.  Used by dead code removal
    2300                 :             :    to update the flags.  */
    2301                 :             : 
    2302                 :             : void
    2303                 :     7691664 : clear_special_calls (void)
    2304                 :             : {
    2305                 :     7691664 :   cfun->calls_alloca = false;
    2306                 :     7691664 :   cfun->calls_setjmp = false;
    2307                 :     7691664 :   cfun->has_musttail = false;
    2308                 :     7691664 : }
    2309                 :             : 
    2310                 :             : /* Remove PHI nodes associated with basic block BB and all edges out of BB.  */
    2311                 :             : 
    2312                 :             : static void
    2313                 :    33355329 : remove_phi_nodes_and_edges_for_unreachable_block (basic_block bb)
    2314                 :             : {
    2315                 :             :   /* Since this block is no longer reachable, we can just delete all
    2316                 :             :      of its PHI nodes.  */
    2317                 :    33355329 :   remove_phi_nodes (bb);
    2318                 :             : 
    2319                 :             :   /* Remove edges to BB's successors.  */
    2320                 :    98171878 :   while (EDGE_COUNT (bb->succs) > 0)
    2321                 :    31461220 :     remove_edge (EDGE_SUCC (bb, 0));
    2322                 :    33355329 : }
    2323                 :             : 
    2324                 :             : 
    2325                 :             : /* Remove statements of basic block BB.  */
    2326                 :             : 
    2327                 :             : static void
    2328                 :    33355329 : remove_bb (basic_block bb)
    2329                 :             : {
    2330                 :    33355329 :   gimple_stmt_iterator i;
    2331                 :             : 
    2332                 :    33355329 :   if (dump_file)
    2333                 :             :     {
    2334                 :       39678 :       fprintf (dump_file, "Removing basic block %d\n", bb->index);
    2335                 :       39678 :       if (dump_flags & TDF_DETAILS)
    2336                 :             :         {
    2337                 :       27037 :           dump_bb (dump_file, bb, 0, TDF_BLOCKS);
    2338                 :       27037 :           fprintf (dump_file, "\n");
    2339                 :             :         }
    2340                 :             :     }
    2341                 :             : 
    2342                 :    33355329 :   if (current_loops)
    2343                 :             :     {
    2344                 :    31584450 :       class loop *loop = bb->loop_father;
    2345                 :             : 
    2346                 :             :       /* If a loop gets removed, clean up the information associated
    2347                 :             :          with it.  */
    2348                 :    31584450 :       if (loop->latch == bb
    2349                 :    31402024 :           || loop->header == bb)
    2350                 :      219068 :         free_numbers_of_iterations_estimates (loop);
    2351                 :             :     }
    2352                 :             : 
    2353                 :             :   /* Remove all the instructions in the block.  */
    2354                 :    33355329 :   if (bb_seq (bb) != NULL)
    2355                 :             :     {
    2356                 :             :       /* Walk backwards so as to get a chance to substitute all
    2357                 :             :          released DEFs into debug stmts.  See
    2358                 :             :          eliminate_unnecessary_stmts() in tree-ssa-dce.cc for more
    2359                 :             :          details.  */
    2360                 :     5961070 :       for (i = gsi_last_bb (bb); !gsi_end_p (i);)
    2361                 :             :         {
    2362                 :    16006640 :           gimple *stmt = gsi_stmt (i);
    2363                 :    16006640 :           glabel *label_stmt = dyn_cast <glabel *> (stmt);
    2364                 :     1994228 :           if (label_stmt
    2365                 :     1994228 :               && (FORCED_LABEL (gimple_label_label (label_stmt))
    2366                 :     1991852 :                   || DECL_NONLOCAL (gimple_label_label (label_stmt))))
    2367                 :             :             {
    2368                 :        2378 :               basic_block new_bb;
    2369                 :        2378 :               gimple_stmt_iterator new_gsi;
    2370                 :             : 
    2371                 :             :               /* A non-reachable non-local label may still be referenced.
    2372                 :             :                  But it no longer needs to carry the extra semantics of
    2373                 :             :                  non-locality.  */
    2374                 :        2378 :               if (DECL_NONLOCAL (gimple_label_label (label_stmt)))
    2375                 :             :                 {
    2376                 :           2 :                   DECL_NONLOCAL (gimple_label_label (label_stmt)) = 0;
    2377                 :           2 :                   FORCED_LABEL (gimple_label_label (label_stmt)) = 1;
    2378                 :             :                 }
    2379                 :             : 
    2380                 :        2378 :               new_bb = bb->prev_bb;
    2381                 :             :               /* Don't move any labels into ENTRY block.  */
    2382                 :        2378 :               if (new_bb == ENTRY_BLOCK_PTR_FOR_FN (cfun))
    2383                 :             :                 {
    2384                 :           0 :                   new_bb = single_succ (new_bb);
    2385                 :           0 :                   gcc_assert (new_bb != bb);
    2386                 :             :                 }
    2387                 :        2378 :               if ((unsigned) bb->index < bb_to_omp_idx.length ()
    2388                 :           8 :                   && ((unsigned) new_bb->index >= bb_to_omp_idx.length ()
    2389                 :           8 :                       || (bb_to_omp_idx[bb->index]
    2390                 :           8 :                           != bb_to_omp_idx[new_bb->index])))
    2391                 :             :                 {
    2392                 :             :                   /* During cfg pass make sure to put orphaned labels
    2393                 :             :                      into the right OMP region.  */
    2394                 :             :                   unsigned int i;
    2395                 :             :                   int idx;
    2396                 :          24 :                   new_bb = NULL;
    2397                 :          24 :                   FOR_EACH_VEC_ELT (bb_to_omp_idx, i, idx)
    2398                 :          24 :                     if (i >= NUM_FIXED_BLOCKS
    2399                 :           8 :                         && idx == bb_to_omp_idx[bb->index]
    2400                 :          32 :                         && i != (unsigned) bb->index)
    2401                 :             :                       {
    2402                 :           8 :                         new_bb = BASIC_BLOCK_FOR_FN (cfun, i);
    2403                 :           8 :                         break;
    2404                 :             :                       }
    2405                 :           8 :                   if (new_bb == NULL)
    2406                 :             :                     {
    2407                 :           0 :                       new_bb = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun));
    2408                 :           0 :                       gcc_assert (new_bb != bb);
    2409                 :             :                     }
    2410                 :             :                 }
    2411                 :        2378 :               new_gsi = gsi_after_labels (new_bb);
    2412                 :        2378 :               gsi_remove (&i, false);
    2413                 :        2378 :               gsi_insert_before (&new_gsi, stmt, GSI_NEW_STMT);
    2414                 :             :             }
    2415                 :             :           else
    2416                 :             :             {
    2417                 :             :               /* Release SSA definitions.  */
    2418                 :    16004262 :               release_defs (stmt);
    2419                 :    16004262 :               gsi_remove (&i, true);
    2420                 :             :             }
    2421                 :             : 
    2422                 :    16006640 :           if (gsi_end_p (i))
    2423                 :    32013280 :             i = gsi_last_bb (bb);
    2424                 :             :           else
    2425                 :    21967710 :             gsi_prev (&i);
    2426                 :             :         }
    2427                 :             :     }
    2428                 :             : 
    2429                 :    33355329 :   if ((unsigned) bb->index < bb_to_omp_idx.length ())
    2430                 :       22112 :     bb_to_omp_idx[bb->index] = -1;
    2431                 :    33355329 :   remove_phi_nodes_and_edges_for_unreachable_block (bb);
    2432                 :    33355329 :   bb->il.gimple.seq = NULL;
    2433                 :    33355329 :   bb->il.gimple.phi_nodes = NULL;
    2434                 :    33355329 : }
    2435                 :             : 
    2436                 :             : 
    2437                 :             : /* Given a basic block BB and a value VAL for use in the final statement
    2438                 :             :    of the block (if a GIMPLE_COND, GIMPLE_SWITCH, or computed goto), return
    2439                 :             :    the edge that will be taken out of the block.
    2440                 :             :    If VAL is NULL_TREE, then the current value of the final statement's
    2441                 :             :    predicate or index is used.
    2442                 :             :    If the value does not match a unique edge, NULL is returned.  */
    2443                 :             : 
    2444                 :             : edge
    2445                 :   223184934 : find_taken_edge (basic_block bb, tree val)
    2446                 :             : {
    2447                 :   223184934 :   gimple *stmt;
    2448                 :             : 
    2449                 :   223184934 :   stmt = *gsi_last_bb (bb);
    2450                 :             : 
    2451                 :             :   /* Handle ENTRY and EXIT.  */
    2452                 :   223184934 :   if (!stmt)
    2453                 :             :     ;
    2454                 :             : 
    2455                 :   219910883 :   else if (gimple_code (stmt) == GIMPLE_COND)
    2456                 :   178800207 :     return find_taken_edge_cond_expr (as_a <gcond *> (stmt), val);
    2457                 :             : 
    2458                 :    41110676 :   else if (gimple_code (stmt) == GIMPLE_SWITCH)
    2459                 :      994886 :     return find_taken_edge_switch_expr (as_a <gswitch *> (stmt), val);
    2460                 :             : 
    2461                 :    40115790 :   else if (computed_goto_p (stmt))
    2462                 :             :     {
    2463                 :             :       /* Only optimize if the argument is a label, if the argument is
    2464                 :             :          not a label then we cannot construct a proper CFG.
    2465                 :             : 
    2466                 :             :          It may be the case that we only need to allow the LABEL_REF to
    2467                 :             :          appear inside an ADDR_EXPR, but we also allow the LABEL_REF to
    2468                 :             :          appear inside a LABEL_EXPR just to be safe.  */
    2469                 :        2816 :       if (val
    2470                 :        1538 :           && (TREE_CODE (val) == ADDR_EXPR || TREE_CODE (val) == LABEL_EXPR)
    2471                 :        3062 :           && TREE_CODE (TREE_OPERAND (val, 0)) == LABEL_DECL)
    2472                 :         182 :         return find_taken_edge_computed_goto (bb, TREE_OPERAND (val, 0));
    2473                 :             :     }
    2474                 :             : 
    2475                 :             :   /* Otherwise we only know the taken successor edge if it's unique.  */
    2476                 :    43389659 :   return single_succ_p (bb) ? single_succ_edge (bb) : NULL;
    2477                 :             : }
    2478                 :             : 
    2479                 :             : /* Given a constant value VAL and the entry block BB to a GOTO_EXPR
    2480                 :             :    statement, determine which of the outgoing edges will be taken out of the
    2481                 :             :    block.  Return NULL if either edge may be taken.  */
    2482                 :             : 
    2483                 :             : static edge
    2484                 :         182 : find_taken_edge_computed_goto (basic_block bb, tree val)
    2485                 :             : {
    2486                 :         182 :   basic_block dest;
    2487                 :         182 :   edge e = NULL;
    2488                 :             : 
    2489                 :         182 :   dest = label_to_block (cfun, val);
    2490                 :         182 :   if (dest)
    2491                 :         178 :     e = find_edge (bb, dest);
    2492                 :             : 
    2493                 :             :   /* It's possible for find_edge to return NULL here on invalid code
    2494                 :             :      that abuses the labels-as-values extension (e.g. code that attempts to
    2495                 :             :      jump *between* functions via stored labels-as-values; PR 84136).
    2496                 :             :      If so, then we simply return that NULL for the edge.
    2497                 :             :      We don't currently have a way of detecting such invalid code, so we
    2498                 :             :      can't assert that it was the case when a NULL edge occurs here.  */
    2499                 :             : 
    2500                 :         182 :   return e;
    2501                 :             : }
    2502                 :             : 
    2503                 :             : /* Given COND_STMT and a constant value VAL for use as the predicate,
    2504                 :             :    determine which of the two edges will be taken out of
    2505                 :             :    the statement's block.  Return NULL if either edge may be taken.
    2506                 :             :    If VAL is NULL_TREE, then the current value of COND_STMT's predicate
    2507                 :             :    is used.  */
    2508                 :             : 
    2509                 :             : static edge
    2510                 :   178800207 : find_taken_edge_cond_expr (const gcond *cond_stmt, tree val)
    2511                 :             : {
    2512                 :   178800207 :   edge true_edge, false_edge;
    2513                 :             : 
    2514                 :   178800207 :   if (val == NULL_TREE)
    2515                 :             :     {
    2516                 :             :       /* Use the current value of the predicate.  */
    2517                 :   166567138 :       if (gimple_cond_true_p (cond_stmt))
    2518                 :       60225 :         val = integer_one_node;
    2519                 :   166506913 :       else if (gimple_cond_false_p (cond_stmt))
    2520                 :      141238 :         val = integer_zero_node;
    2521                 :             :       else
    2522                 :             :         return NULL;
    2523                 :             :     }
    2524                 :    12233069 :   else if (TREE_CODE (val) != INTEGER_CST)
    2525                 :             :     return NULL;
    2526                 :             : 
    2527                 :    11109365 :   extract_true_false_edges_from_block (gimple_bb (cond_stmt),
    2528                 :             :                                        &true_edge, &false_edge);
    2529                 :             : 
    2530                 :    11109365 :   return (integer_zerop (val) ? false_edge : true_edge);
    2531                 :             : }
    2532                 :             : 
    2533                 :             : /* Given SWITCH_STMT and an INTEGER_CST VAL for use as the index, determine
    2534                 :             :    which edge will be taken out of the statement's block.  Return NULL if any
    2535                 :             :    edge may be taken.
    2536                 :             :    If VAL is NULL_TREE, then the current value of SWITCH_STMT's index
    2537                 :             :    is used.  */
    2538                 :             : 
    2539                 :             : edge
    2540                 :      994890 : find_taken_edge_switch_expr (const gswitch *switch_stmt, tree val)
    2541                 :             : {
    2542                 :      994890 :   basic_block dest_bb;
    2543                 :      994890 :   edge e;
    2544                 :      994890 :   tree taken_case;
    2545                 :             : 
    2546                 :      994890 :   if (gimple_switch_num_labels (switch_stmt) == 1)
    2547                 :           1 :     taken_case = gimple_switch_default_label (switch_stmt);
    2548                 :             :   else
    2549                 :             :     {
    2550                 :      994889 :       if (val == NULL_TREE)
    2551                 :      140032 :         val = gimple_switch_index (switch_stmt);
    2552                 :      994889 :       if (TREE_CODE (val) != INTEGER_CST)
    2553                 :             :         return NULL;
    2554                 :             :       else
    2555                 :       22593 :         taken_case = find_case_label_for_value (switch_stmt, val);
    2556                 :             :     }
    2557                 :       22594 :   dest_bb = label_to_block (cfun, CASE_LABEL (taken_case));
    2558                 :             : 
    2559                 :       22594 :   e = find_edge (gimple_bb (switch_stmt), dest_bb);
    2560                 :       22594 :   gcc_assert (e);
    2561                 :             :   return e;
    2562                 :             : }
    2563                 :             : 
    2564                 :             : 
    2565                 :             : /* Return the CASE_LABEL_EXPR that SWITCH_STMT will take for VAL.
    2566                 :             :    We can make optimal use here of the fact that the case labels are
    2567                 :             :    sorted: We can do a binary search for a case matching VAL.  */
    2568                 :             : 
    2569                 :             : tree
    2570                 :       22593 : find_case_label_for_value (const gswitch *switch_stmt, tree val)
    2571                 :             : {
    2572                 :       22593 :   size_t low, high, n = gimple_switch_num_labels (switch_stmt);
    2573                 :       22593 :   tree default_case = gimple_switch_default_label (switch_stmt);
    2574                 :             : 
    2575                 :       46646 :   for (low = 0, high = n; high - low > 1; )
    2576                 :             :     {
    2577                 :       43946 :       size_t i = (high + low) / 2;
    2578                 :       43946 :       tree t = gimple_switch_label (switch_stmt, i);
    2579                 :       43946 :       int cmp;
    2580                 :             : 
    2581                 :             :       /* Cache the result of comparing CASE_LOW and val.  */
    2582                 :       43946 :       cmp = tree_int_cst_compare (CASE_LOW (t), val);
    2583                 :             : 
    2584                 :       43946 :       if (cmp > 0)
    2585                 :             :         high = i;
    2586                 :             :       else
    2587                 :       32363 :         low = i;
    2588                 :             : 
    2589                 :       43946 :       if (CASE_HIGH (t) == NULL)
    2590                 :             :         {
    2591                 :             :           /* A singe-valued case label.  */
    2592                 :       42958 :           if (cmp == 0)
    2593                 :             :             return t;
    2594                 :             :         }
    2595                 :             :       else
    2596                 :             :         {
    2597                 :             :           /* A case range.  We can only handle integer ranges.  */
    2598                 :         988 :           if (cmp <= 0 && tree_int_cst_compare (CASE_HIGH (t), val) >= 0)
    2599                 :             :             return t;
    2600                 :             :         }
    2601                 :             :     }
    2602                 :             : 
    2603                 :             :   return default_case;
    2604                 :             : }
    2605                 :             : 
    2606                 :             : 
    2607                 :             : /* Dump a basic block on stderr.  */
    2608                 :             : 
    2609                 :             : void
    2610                 :           0 : gimple_debug_bb (basic_block bb)
    2611                 :             : {
    2612                 :           0 :   dump_bb (stderr, bb, 0, TDF_VOPS|TDF_MEMSYMS|TDF_BLOCKS);
    2613                 :           0 : }
    2614                 :             : 
    2615                 :             : 
    2616                 :             : /* Dump basic block with index N on stderr.  */
    2617                 :             : 
    2618                 :             : basic_block
    2619                 :           0 : gimple_debug_bb_n (int n)
    2620                 :             : {
    2621                 :           0 :   gimple_debug_bb (BASIC_BLOCK_FOR_FN (cfun, n));
    2622                 :           0 :   return BASIC_BLOCK_FOR_FN (cfun, n);
    2623                 :             : }
    2624                 :             : 
    2625                 :             : 
    2626                 :             : /* Dump the CFG on stderr.
    2627                 :             : 
    2628                 :             :    FLAGS are the same used by the tree dumping functions
    2629                 :             :    (see TDF_* in dumpfile.h).  */
    2630                 :             : 
    2631                 :             : void
    2632                 :           0 : gimple_debug_cfg (dump_flags_t flags)
    2633                 :             : {
    2634                 :           0 :   gimple_dump_cfg (stderr, flags);
    2635                 :           0 : }
    2636                 :             : 
    2637                 :             : 
    2638                 :             : /* Dump the program showing basic block boundaries on the given FILE.
    2639                 :             : 
    2640                 :             :    FLAGS are the same used by the tree dumping functions (see TDF_* in
    2641                 :             :    tree.h).  */
    2642                 :             : 
    2643                 :             : void
    2644                 :         126 : gimple_dump_cfg (FILE *file, dump_flags_t flags)
    2645                 :             : {
    2646                 :         126 :   if (flags & TDF_DETAILS)
    2647                 :             :     {
    2648                 :           2 :       dump_function_header (file, current_function_decl, flags);
    2649                 :           2 :       fprintf (file, ";; \n%d basic blocks, %d edges, last basic block %d.\n\n",
    2650                 :             :                n_basic_blocks_for_fn (cfun), n_edges_for_fn (cfun),
    2651                 :           2 :                last_basic_block_for_fn (cfun));
    2652                 :             : 
    2653                 :           2 :       brief_dump_cfg (file, flags);
    2654                 :           2 :       fprintf (file, "\n");
    2655                 :             :     }
    2656                 :             : 
    2657                 :         126 :   if (flags & TDF_STATS)
    2658                 :          23 :     dump_cfg_stats (file);
    2659                 :             : 
    2660                 :         126 :   dump_function_to_file (current_function_decl, file, flags | TDF_BLOCKS);
    2661                 :         126 : }
    2662                 :             : 
    2663                 :             : 
    2664                 :             : /* Dump CFG statistics on FILE.  */
    2665                 :             : 
    2666                 :             : void
    2667                 :          23 : dump_cfg_stats (FILE *file)
    2668                 :             : {
    2669                 :          23 :   static long max_num_merged_labels = 0;
    2670                 :          23 :   unsigned long size, total = 0;
    2671                 :          23 :   long num_edges;
    2672                 :          23 :   basic_block bb;
    2673                 :          23 :   const char * const fmt_str   = "%-30s%-13s%12s\n";
    2674                 :          23 :   const char * const fmt_str_1 = "%-30s%13d" PRsa (11) "\n";
    2675                 :          23 :   const char * const fmt_str_2 = "%-30s%13ld" PRsa (11) "\n";
    2676                 :          23 :   const char * const fmt_str_3 = "%-43s" PRsa (11) "\n";
    2677                 :          23 :   const char *funcname = current_function_name ();
    2678                 :             : 
    2679                 :          23 :   fprintf (file, "\nCFG Statistics for %s\n\n", funcname);
    2680                 :             : 
    2681                 :          23 :   fprintf (file, "---------------------------------------------------------\n");
    2682                 :          23 :   fprintf (file, fmt_str, "", "  Number of  ", "Memory");
    2683                 :          23 :   fprintf (file, fmt_str, "", "  instances  ", "used ");
    2684                 :          23 :   fprintf (file, "---------------------------------------------------------\n");
    2685                 :             : 
    2686                 :          23 :   size = n_basic_blocks_for_fn (cfun) * sizeof (struct basic_block_def);
    2687                 :          23 :   total += size;
    2688                 :          23 :   fprintf (file, fmt_str_1, "Basic blocks", n_basic_blocks_for_fn (cfun),
    2689                 :           0 :            SIZE_AMOUNT (size));
    2690                 :             : 
    2691                 :          23 :   num_edges = 0;
    2692                 :          57 :   FOR_EACH_BB_FN (bb, cfun)
    2693                 :          68 :     num_edges += EDGE_COUNT (bb->succs);
    2694                 :          23 :   size = num_edges * sizeof (class edge_def);
    2695                 :          23 :   total += size;
    2696                 :          23 :   fprintf (file, fmt_str_2, "Edges", num_edges, SIZE_AMOUNT (size));
    2697                 :             : 
    2698                 :          23 :   fprintf (file, "---------------------------------------------------------\n");
    2699                 :          23 :   fprintf (file, fmt_str_3, "Total memory used by CFG data",
    2700                 :           0 :            SIZE_AMOUNT (total));
    2701                 :          23 :   fprintf (file, "---------------------------------------------------------\n");
    2702                 :          23 :   fprintf (file, "\n");
    2703                 :             : 
    2704                 :          23 :   if (cfg_stats.num_merged_labels > max_num_merged_labels)
    2705                 :           0 :     max_num_merged_labels = cfg_stats.num_merged_labels;
    2706                 :             : 
    2707                 :          23 :   fprintf (file, "Coalesced label blocks: %ld (Max so far: %ld)\n",
    2708                 :             :            cfg_stats.num_merged_labels, max_num_merged_labels);
    2709                 :             : 
    2710                 :          23 :   fprintf (file, "\n");
    2711                 :          23 : }
    2712                 :             : 
    2713                 :             : 
    2714                 :             : /* Dump CFG statistics on stderr.  Keep extern so that it's always
    2715                 :             :    linked in the final executable.  */
    2716                 :             : 
    2717                 :             : DEBUG_FUNCTION void
    2718                 :           0 : debug_cfg_stats (void)
    2719                 :             : {
    2720                 :           0 :   dump_cfg_stats (stderr);
    2721                 :           0 : }
    2722                 :             : 
    2723                 :             : /*---------------------------------------------------------------------------
    2724                 :             :                              Miscellaneous helpers
    2725                 :             : ---------------------------------------------------------------------------*/
    2726                 :             : 
    2727                 :             : /* Return true if T, a GIMPLE_CALL, can make an abnormal transfer of control
    2728                 :             :    flow.  Transfers of control flow associated with EH are excluded.  */
    2729                 :             : 
    2730                 :             : static bool
    2731                 :   128006348 : call_can_make_abnormal_goto (gimple *t)
    2732                 :             : {
    2733                 :             :   /* If the function has no non-local labels, then a call cannot make an
    2734                 :             :      abnormal transfer of control.  */
    2735                 :   128006348 :   if (!cfun->has_nonlocal_label
    2736                 :   128006348 :       && !cfun->calls_setjmp)
    2737                 :             :    return false;
    2738                 :             : 
    2739                 :             :   /* Likewise if the call has no side effects.  */
    2740                 :      212387 :   if (!gimple_has_side_effects (t))
    2741                 :             :     return false;
    2742                 :             : 
    2743                 :             :   /* Likewise if the called function is leaf.  */
    2744                 :      205097 :   if (gimple_call_flags (t) & ECF_LEAF)
    2745                 :             :     return false;
    2746                 :             : 
    2747                 :             :   return true;
    2748                 :             : }
    2749                 :             : 
    2750                 :             : 
    2751                 :             : /* Return true if T can make an abnormal transfer of control flow.
    2752                 :             :    Transfers of control flow associated with EH are excluded.  */
    2753                 :             : 
    2754                 :             : bool
    2755                 :   515685674 : stmt_can_make_abnormal_goto (gimple *t)
    2756                 :             : {
    2757                 :   515685674 :   if (computed_goto_p (t))
    2758                 :             :     return true;
    2759                 :   515681847 :   if (is_gimple_call (t))
    2760                 :   117905732 :     return call_can_make_abnormal_goto (t);
    2761                 :             :   return false;
    2762                 :             : }
    2763                 :             : 
    2764                 :             : 
    2765                 :             : /* Return true if T represents a stmt that always transfers control.  */
    2766                 :             : 
    2767                 :             : bool
    2768                 : 14725153479 : is_ctrl_stmt (gimple *t)
    2769                 :             : {
    2770                 : 14725153479 :   switch (gimple_code (t))
    2771                 :             :     {
    2772                 :             :     case GIMPLE_COND:
    2773                 :             :     case GIMPLE_SWITCH:
    2774                 :             :     case GIMPLE_GOTO:
    2775                 :             :     case GIMPLE_RETURN:
    2776                 :             :     case GIMPLE_RESX:
    2777                 :             :       return true;
    2778                 : 12716882264 :     default:
    2779                 : 12716882264 :       return false;
    2780                 :             :     }
    2781                 :             : }
    2782                 :             : 
    2783                 :             : 
    2784                 :             : /* Return true if T is a statement that may alter the flow of control
    2785                 :             :    (e.g., a call to a non-returning function).  */
    2786                 :             : 
    2787                 :             : bool
    2788                 : 12147917742 : is_ctrl_altering_stmt (gimple *t)
    2789                 :             : {
    2790                 : 12147917742 :   gcc_assert (t);
    2791                 :             : 
    2792                 : 12147917742 :   switch (gimple_code (t))
    2793                 :             :     {
    2794                 :  1021515748 :     case GIMPLE_CALL:
    2795                 :             :       /* Per stmt call flag indicates whether the call could alter
    2796                 :             :          controlflow.  */
    2797                 :  1021515748 :       if (gimple_call_ctrl_altering_p (t))
    2798                 :             :         return true;
    2799                 :             :       break;
    2800                 :             : 
    2801                 :             :     case GIMPLE_EH_DISPATCH:
    2802                 :             :       /* EH_DISPATCH branches to the individual catch handlers at
    2803                 :             :          this level of a try or allowed-exceptions region.  It can
    2804                 :             :          fallthru to the next statement as well.  */
    2805                 :             :       return true;
    2806                 :             : 
    2807                 :    14138878 :     case GIMPLE_ASM:
    2808                 :    14138878 :       if (gimple_asm_nlabels (as_a <gasm *> (t)) > 0)
    2809                 :             :         return true;
    2810                 :             :       break;
    2811                 :             : 
    2812                 :             :     CASE_GIMPLE_OMP:
    2813                 :             :       /* OpenMP directives alter control flow.  */
    2814                 :             :       return true;
    2815                 :             : 
    2816                 :             :     case GIMPLE_TRANSACTION:
    2817                 :             :       /* A transaction start alters control flow.  */
    2818                 :             :       return true;
    2819                 :             : 
    2820                 :             :     default:
    2821                 :             :       break;
    2822                 :             :     }
    2823                 :             : 
    2824                 :             :   /* If a statement can throw, it alters control flow.  */
    2825                 : 12001334521 :   return stmt_can_throw_internal (cfun, t);
    2826                 :             : }
    2827                 :             : 
    2828                 :             : 
    2829                 :             : /* Return true if T is a simple local goto.  */
    2830                 :             : 
    2831                 :             : bool
    2832                 :     5696813 : simple_goto_p (gimple *t)
    2833                 :             : {
    2834                 :     5696813 :   return (gimple_code (t) == GIMPLE_GOTO
    2835                 :     5696813 :           && TREE_CODE (gimple_goto_dest (t)) == LABEL_DECL);
    2836                 :             : }
    2837                 :             : 
    2838                 :             : 
    2839                 :             : /* Return true if STMT should start a new basic block.  PREV_STMT is
    2840                 :             :    the statement preceding STMT.  It is used when STMT is a label or a
    2841                 :             :    case label.  Labels should only start a new basic block if their
    2842                 :             :    previous statement wasn't a label.  Otherwise, sequence of labels
    2843                 :             :    would generate unnecessary basic blocks that only contain a single
    2844                 :             :    label.  */
    2845                 :             : 
    2846                 :             : static inline bool
    2847                 :    67084069 : stmt_starts_bb_p (gimple *stmt, gimple *prev_stmt)
    2848                 :             : {
    2849                 :    67084069 :   if (stmt == NULL)
    2850                 :             :     return false;
    2851                 :             : 
    2852                 :             :   /* PREV_STMT is only set to a debug stmt if the debug stmt is before
    2853                 :             :      any nondebug stmts in the block.  We don't want to start another
    2854                 :             :      block in this case: the debug stmt will already have started the
    2855                 :             :      one STMT would start if we weren't outputting debug stmts.  */
    2856                 :    67084069 :   if (prev_stmt && is_gimple_debug (prev_stmt))
    2857                 :             :     return false;
    2858                 :             : 
    2859                 :             :   /* Labels start a new basic block only if the preceding statement
    2860                 :             :      wasn't a label of the same type.  This prevents the creation of
    2861                 :             :      consecutive blocks that have nothing but a single label.  */
    2862                 :    66590743 :   if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
    2863                 :             :     {
    2864                 :             :       /* Nonlocal and computed GOTO targets always start a new block.  */
    2865                 :     3847020 :       if (DECL_NONLOCAL (gimple_label_label (label_stmt))
    2866                 :     3847020 :           || FORCED_LABEL (gimple_label_label (label_stmt)))
    2867                 :             :         return true;
    2868                 :             : 
    2869                 :     5593236 :       if (glabel *plabel = safe_dyn_cast <glabel *> (prev_stmt))
    2870                 :             :         {
    2871                 :     2097893 :           if (DECL_NONLOCAL (gimple_label_label (plabel))
    2872                 :     2097893 :               || !DECL_ARTIFICIAL (gimple_label_label (plabel)))
    2873                 :             :             return true;
    2874                 :             : 
    2875                 :     2088751 :           cfg_stats.num_merged_labels++;
    2876                 :     2088751 :           return false;
    2877                 :             :         }
    2878                 :             :       else
    2879                 :             :         return true;
    2880                 :             :     }
    2881                 :    62743723 :   else if (gimple_code (stmt) == GIMPLE_CALL)
    2882                 :             :     {
    2883                 :     8572153 :       if (gimple_call_flags (stmt) & ECF_RETURNS_TWICE)
    2884                 :             :         /* setjmp acts similar to a nonlocal GOTO target and thus should
    2885                 :             :            start a new block.  */
    2886                 :             :         return true;
    2887                 :     8571095 :       if (gimple_call_internal_p (stmt, IFN_PHI)
    2888                 :           0 :           && prev_stmt
    2889                 :           0 :           && gimple_code (prev_stmt) != GIMPLE_LABEL
    2890                 :     8571095 :           && (gimple_code (prev_stmt) != GIMPLE_CALL
    2891                 :           0 :               || ! gimple_call_internal_p (prev_stmt, IFN_PHI)))
    2892                 :             :         /* PHI nodes start a new block unless preceeded by a label
    2893                 :             :            or another PHI.  */
    2894                 :             :         return true;
    2895                 :             :     }
    2896                 :             : 
    2897                 :             :   return false;
    2898                 :             : }
    2899                 :             : 
    2900                 :             : 
    2901                 :             : /* Return true if T should end a basic block.  */
    2902                 :             : 
    2903                 :             : bool
    2904                 : 13013617630 : stmt_ends_bb_p (gimple *t)
    2905                 :             : {
    2906                 : 13013617630 :   return is_ctrl_stmt (t) || is_ctrl_altering_stmt (t);
    2907                 :             : }
    2908                 :             : 
    2909                 :             : /* Remove block annotations and other data structures.  */
    2910                 :             : 
    2911                 :             : void
    2912                 :     2947567 : delete_tree_cfg_annotations (struct function *fn)
    2913                 :             : {
    2914                 :     2947567 :   vec_free (label_to_block_map_for_fn (fn));
    2915                 :     2947567 : }
    2916                 :             : 
    2917                 :             : /* Return the virtual phi in BB.  */
    2918                 :             : 
    2919                 :             : gphi *
    2920                 :  2540720020 : get_virtual_phi (basic_block bb)
    2921                 :             : {
    2922                 :  2540720020 :   for (gphi_iterator gsi = gsi_start_phis (bb);
    2923                 :  3129095374 :        !gsi_end_p (gsi);
    2924                 :   588375354 :        gsi_next (&gsi))
    2925                 :             :     {
    2926                 :  1362852539 :       gphi *phi = gsi.phi ();
    2927                 :             : 
    2928                 :  2725705078 :       if (virtual_operand_p (PHI_RESULT (phi)))
    2929                 :   774477185 :         return phi;
    2930                 :             :     }
    2931                 :             : 
    2932                 :  1766242835 :   return NULL;
    2933                 :             : }
    2934                 :             : 
    2935                 :             : /* Return the first statement in basic block BB.  */
    2936                 :             : 
    2937                 :             : gimple *
    2938                 :    41504488 : first_stmt (basic_block bb)
    2939                 :             : {
    2940                 :    41504488 :   gimple_stmt_iterator i = gsi_start_bb (bb);
    2941                 :    41504488 :   gimple *stmt = NULL;
    2942                 :             : 
    2943                 :   119344427 :   while (!gsi_end_p (i) && is_gimple_debug ((stmt = gsi_stmt (i))))
    2944                 :             :     {
    2945                 :    77839939 :       gsi_next (&i);
    2946                 :    77839939 :       stmt = NULL;
    2947                 :             :     }
    2948                 :    41504488 :   return stmt;
    2949                 :             : }
    2950                 :             : 
    2951                 :             : /* Return the first non-label statement in basic block BB.  */
    2952                 :             : 
    2953                 :             : static gimple *
    2954                 :    24905491 : first_non_label_stmt (basic_block bb)
    2955                 :             : {
    2956                 :    24905491 :   gimple_stmt_iterator i = gsi_start_bb (bb);
    2957                 :    44960280 :   while (!gsi_end_p (i) && gimple_code (gsi_stmt (i)) == GIMPLE_LABEL)
    2958                 :    20054789 :     gsi_next (&i);
    2959                 :    24905491 :   return !gsi_end_p (i) ? gsi_stmt (i) : NULL;
    2960                 :             : }
    2961                 :             : 
    2962                 :             : /* Return the last statement in basic block BB.  */
    2963                 :             : 
    2964                 :             : gimple *
    2965                 :   199573147 : last_nondebug_stmt (basic_block bb)
    2966                 :             : {
    2967                 :   199573147 :   gimple_stmt_iterator i = gsi_last_bb (bb);
    2968                 :             :   gimple *stmt = NULL;
    2969                 :             : 
    2970                 :   213515494 :   while (!gsi_end_p (i) && is_gimple_debug ((stmt = gsi_stmt (i))))
    2971                 :             :     {
    2972                 :   277112671 :       gsi_prev (&i);
    2973                 :             :       stmt = NULL;
    2974                 :             :     }
    2975                 :   199573147 :   return stmt;
    2976                 :             : }
    2977                 :             : 
    2978                 :             : /* Return the last statement of an otherwise empty block.  Return NULL
    2979                 :             :    if the block is totally empty, or if it contains more than one
    2980                 :             :    statement.  */
    2981                 :             : 
    2982                 :             : gimple *
    2983                 :     9228176 : last_and_only_stmt (basic_block bb)
    2984                 :             : {
    2985                 :     9228176 :   gimple_stmt_iterator i = gsi_last_nondebug_bb (bb);
    2986                 :     9228176 :   gimple *last, *prev;
    2987                 :             : 
    2988                 :     9228176 :   if (gsi_end_p (i))
    2989                 :             :     return NULL;
    2990                 :             : 
    2991                 :     8495069 :   last = gsi_stmt (i);
    2992                 :     8495069 :   gsi_prev_nondebug (&i);
    2993                 :     8495069 :   if (gsi_end_p (i))
    2994                 :             :     return last;
    2995                 :             : 
    2996                 :             :   /* Empty statements should no longer appear in the instruction stream.
    2997                 :             :      Everything that might have appeared before should be deleted by
    2998                 :             :      remove_useless_stmts, and the optimizers should just gsi_remove
    2999                 :             :      instead of smashing with build_empty_stmt.
    3000                 :             : 
    3001                 :             :      Thus the only thing that should appear here in a block containing
    3002                 :             :      one executable statement is a label.  */
    3003                 :     6985620 :   prev = gsi_stmt (i);
    3004                 :     6985620 :   if (gimple_code (prev) == GIMPLE_LABEL)
    3005                 :             :     return last;
    3006                 :             :   else
    3007                 :             :     return NULL;
    3008                 :             : }
    3009                 :             : 
    3010                 :             : /* Returns the basic block after which the new basic block created
    3011                 :             :    by splitting edge EDGE_IN should be placed.  Tries to keep the new block
    3012                 :             :    near its "logical" location.  This is of most help to humans looking
    3013                 :             :    at debugging dumps.  */
    3014                 :             : 
    3015                 :             : basic_block
    3016                 :    24739999 : split_edge_bb_loc (edge edge_in)
    3017                 :             : {
    3018                 :    24739999 :   basic_block dest = edge_in->dest;
    3019                 :    24739999 :   basic_block dest_prev = dest->prev_bb;
    3020                 :             : 
    3021                 :    24739999 :   if (dest_prev)
    3022                 :             :     {
    3023                 :    24739999 :       edge e = find_edge (dest_prev, dest);
    3024                 :    24739999 :       if (e && !(e->flags & EDGE_COMPLEX))
    3025                 :    20860510 :         return edge_in->src;
    3026                 :             :     }
    3027                 :             :   return dest_prev;
    3028                 :             : }
    3029                 :             : 
    3030                 :             : /* Split a (typically critical) edge EDGE_IN.  Return the new block.
    3031                 :             :    Abort on abnormal edges.  */
    3032                 :             : 
    3033                 :             : static basic_block
    3034                 :    23243172 : gimple_split_edge (edge edge_in)
    3035                 :             : {
    3036                 :    23243172 :   basic_block new_bb, after_bb, dest;
    3037                 :    23243172 :   edge new_edge, e;
    3038                 :             : 
    3039                 :             :   /* Abnormal edges cannot be split.  */
    3040                 :    23243172 :   gcc_assert (!(edge_in->flags & EDGE_ABNORMAL));
    3041                 :             : 
    3042                 :    23243172 :   dest = edge_in->dest;
    3043                 :             : 
    3044                 :    23243172 :   after_bb = split_edge_bb_loc (edge_in);
    3045                 :             : 
    3046                 :    23243172 :   new_bb = create_empty_bb (after_bb);
    3047                 :    23243172 :   new_bb->count = edge_in->count ();
    3048                 :             : 
    3049                 :             :   /* We want to avoid re-allocating PHIs when we first
    3050                 :             :      add the fallthru edge from new_bb to dest but we also
    3051                 :             :      want to avoid changing PHI argument order when
    3052                 :             :      first redirecting edge_in away from dest.  The former
    3053                 :             :      avoids changing PHI argument order by adding them
    3054                 :             :      last and then the redirection swapping it back into
    3055                 :             :      place by means of unordered remove.
    3056                 :             :      So hack around things by temporarily removing all PHIs
    3057                 :             :      from the destination during the edge redirection and then
    3058                 :             :      making sure the edges stay in order.  */
    3059                 :    23243172 :   gimple_seq saved_phis = phi_nodes (dest);
    3060                 :    23243172 :   unsigned old_dest_idx = edge_in->dest_idx;
    3061                 :    23243172 :   set_phi_nodes (dest, NULL);
    3062                 :    23243172 :   new_edge = make_single_succ_edge (new_bb, dest, EDGE_FALLTHRU);
    3063                 :    23243172 :   e = redirect_edge_and_branch (edge_in, new_bb);
    3064                 :    23243172 :   gcc_assert (e == edge_in && new_edge->dest_idx == old_dest_idx);
    3065                 :             :   /* set_phi_nodes sets the BB of the PHI nodes, so do it manually here.  */
    3066                 :    23243172 :   dest->il.gimple.phi_nodes = saved_phis;
    3067                 :             : 
    3068                 :    23243172 :   return new_bb;
    3069                 :             : }
    3070                 :             : 
    3071                 :             : 
    3072                 :             : /* Verify properties of the address expression T whose base should be
    3073                 :             :    TREE_ADDRESSABLE if VERIFY_ADDRESSABLE is true.  */
    3074                 :             : 
    3075                 :             : static bool
    3076                 :   534286763 : verify_address (tree t, bool verify_addressable)
    3077                 :             : {
    3078                 :   534286763 :   bool old_constant;
    3079                 :   534286763 :   bool old_side_effects;
    3080                 :   534286763 :   bool new_constant;
    3081                 :   534286763 :   bool new_side_effects;
    3082                 :             : 
    3083                 :   534286763 :   old_constant = TREE_CONSTANT (t);
    3084                 :   534286763 :   old_side_effects = TREE_SIDE_EFFECTS (t);
    3085                 :             : 
    3086                 :   534286763 :   recompute_tree_invariant_for_addr_expr (t);
    3087                 :   534286763 :   new_side_effects = TREE_SIDE_EFFECTS (t);
    3088                 :   534286763 :   new_constant = TREE_CONSTANT (t);
    3089                 :             : 
    3090                 :   534286763 :   if (old_constant != new_constant)
    3091                 :             :     {
    3092                 :           0 :       error ("constant not recomputed when %<ADDR_EXPR%> changed");
    3093                 :           0 :       return true;
    3094                 :             :     }
    3095                 :   534286763 :   if (old_side_effects != new_side_effects)
    3096                 :             :     {
    3097                 :           0 :       error ("side effects not recomputed when %<ADDR_EXPR%> changed");
    3098                 :           0 :       return true;
    3099                 :             :     }
    3100                 :             : 
    3101                 :   534286763 :   tree base = TREE_OPERAND (t, 0);
    3102                 :   670288330 :   while (handled_component_p (base))
    3103                 :   136001567 :     base = TREE_OPERAND (base, 0);
    3104                 :             : 
    3105                 :   534286763 :   if (!(VAR_P (base)
    3106                 :             :         || TREE_CODE (base) == PARM_DECL
    3107                 :             :         || TREE_CODE (base) == RESULT_DECL))
    3108                 :             :     return false;
    3109                 :             : 
    3110                 :   383353224 :   if (verify_addressable && !TREE_ADDRESSABLE (base))
    3111                 :             :     {
    3112                 :           0 :       error ("address taken but %<TREE_ADDRESSABLE%> bit not set");
    3113                 :           0 :       return true;
    3114                 :             :     }
    3115                 :             : 
    3116                 :             :   return false;
    3117                 :             : }
    3118                 :             : 
    3119                 :             : 
    3120                 :             : /* Verify if EXPR is a valid GIMPLE reference expression.  If
    3121                 :             :    REQUIRE_LVALUE is true verifies it is an lvalue.  Returns true
    3122                 :             :    if there is an error, otherwise false.  */
    3123                 :             : 
    3124                 :             : static bool
    3125                 :  3448254245 : verify_types_in_gimple_reference (tree expr, bool require_lvalue)
    3126                 :             : {
    3127                 :  3448254245 :   const char *code_name = get_tree_code_name (TREE_CODE (expr));
    3128                 :             : 
    3129                 :  3448254245 :   if (TREE_CODE (expr) == REALPART_EXPR
    3130                 :  3448254245 :       || TREE_CODE (expr) == IMAGPART_EXPR
    3131                 :  3416042743 :       || TREE_CODE (expr) == BIT_FIELD_REF
    3132                 :  3403807132 :       || TREE_CODE (expr) == VIEW_CONVERT_EXPR)
    3133                 :             :     {
    3134                 :    86981074 :       tree op = TREE_OPERAND (expr, 0);
    3135                 :    86981074 :       if (TREE_CODE (expr) != VIEW_CONVERT_EXPR
    3136                 :    86981074 :           && !is_gimple_reg_type (TREE_TYPE (expr)))
    3137                 :             :         {
    3138                 :           0 :           error ("non-scalar %qs", code_name);
    3139                 :           0 :           return true;
    3140                 :             :         }
    3141                 :             : 
    3142                 :    86981074 :       if (TREE_CODE (expr) == BIT_FIELD_REF)
    3143                 :             :         {
    3144                 :    12235611 :           tree t1 = TREE_OPERAND (expr, 1);
    3145                 :    12235611 :           tree t2 = TREE_OPERAND (expr, 2);
    3146                 :    12235611 :           poly_uint64 size, bitpos;
    3147                 :    12235611 :           if (!poly_int_tree_p (t1, &size)
    3148                 :    12235611 :               || !poly_int_tree_p (t2, &bitpos)
    3149                 :    12235611 :               || !types_compatible_p (bitsizetype, TREE_TYPE (t1))
    3150                 :    24471222 :               || !types_compatible_p (bitsizetype, TREE_TYPE (t2)))
    3151                 :             :             {
    3152                 :           0 :               error ("invalid position or size operand to %qs", code_name);
    3153                 :           0 :               return true;
    3154                 :             :             }
    3155                 :    24432946 :           if (INTEGRAL_TYPE_P (TREE_TYPE (expr))
    3156                 :    22573161 :               && maybe_ne (TYPE_PRECISION (TREE_TYPE (expr)), size))
    3157                 :             :             {
    3158                 :           0 :               error ("integral result type precision does not match "
    3159                 :             :                      "field size of %qs", code_name);
    3160                 :           0 :               return true;
    3161                 :             :             }
    3162                 :    12235611 :           else if (!INTEGRAL_TYPE_P (TREE_TYPE (expr))
    3163                 :     1859785 :                    && TYPE_MODE (TREE_TYPE (expr)) != BLKmode
    3164                 :     3719312 :                    && maybe_ne (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr))),
    3165                 :             :                                 size))
    3166                 :             :             {
    3167                 :           0 :               error ("mode size of non-integral result does not "
    3168                 :             :                      "match field size of %qs",
    3169                 :             :                      code_name);
    3170                 :           0 :               return true;
    3171                 :             :             }
    3172                 :    24470518 :           if (INTEGRAL_TYPE_P (TREE_TYPE (op))
    3173                 :    12450974 :               && !type_has_mode_precision_p (TREE_TYPE (op)))
    3174                 :             :             {
    3175                 :           0 :               error ("%qs of non-mode-precision operand", code_name);
    3176                 :           0 :               return true;
    3177                 :             :             }
    3178                 :    12235611 :           if (!AGGREGATE_TYPE_P (TREE_TYPE (op))
    3179                 :    12235611 :               && maybe_gt (size + bitpos,
    3180                 :             :                            tree_to_poly_uint64 (TYPE_SIZE (TREE_TYPE (op)))))
    3181                 :             :             {
    3182                 :           0 :               error ("position plus size exceeds size of referenced object in "
    3183                 :             :                      "%qs", code_name);
    3184                 :           0 :               return true;
    3185                 :             :             }
    3186                 :             :         }
    3187                 :             : 
    3188                 :    86981074 :       if ((TREE_CODE (expr) == REALPART_EXPR
    3189                 :    86981074 :            || TREE_CODE (expr) == IMAGPART_EXPR)
    3190                 :   119192576 :           && !useless_type_conversion_p (TREE_TYPE (expr),
    3191                 :    32211502 :                                          TREE_TYPE (TREE_TYPE (op))))
    3192                 :             :         {
    3193                 :           0 :           error ("type mismatch in %qs reference", code_name);
    3194                 :           0 :           debug_generic_stmt (TREE_TYPE (expr));
    3195                 :           0 :           debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
    3196                 :           0 :           return true;
    3197                 :             :         }
    3198                 :             : 
    3199                 :    86981074 :       if (TREE_CODE (expr) == VIEW_CONVERT_EXPR)
    3200                 :             :         {
    3201                 :             :           /* For VIEW_CONVERT_EXPRs which are allowed here too, we only check
    3202                 :             :              that their operand is not a register an invariant when
    3203                 :             :              requiring an lvalue (this usually means there is a SRA or IPA-SRA
    3204                 :             :              bug).  Otherwise there is nothing to verify, gross mismatches at
    3205                 :             :              most invoke undefined behavior.  */
    3206                 :    42533961 :           if (require_lvalue
    3207                 :    42533961 :               && (is_gimple_reg (op) || is_gimple_min_invariant (op)))
    3208                 :             :             {
    3209                 :           0 :               error ("conversion of %qs on the left hand side of %qs",
    3210                 :           0 :                      get_tree_code_name (TREE_CODE (op)), code_name);
    3211                 :           0 :               debug_generic_stmt (expr);
    3212                 :           0 :               return true;
    3213                 :             :             }
    3214                 :    42533961 :           else if (is_gimple_reg (op)
    3215                 :    42533961 :                    && TYPE_SIZE (TREE_TYPE (expr)) != TYPE_SIZE (TREE_TYPE (op)))
    3216                 :             :             {
    3217                 :           0 :               error ("conversion of register to a different size in %qs",
    3218                 :             :                      code_name);
    3219                 :           0 :               debug_generic_stmt (expr);
    3220                 :           0 :               return true;
    3221                 :             :             }
    3222                 :             :         }
    3223                 :             : 
    3224                 :             :       expr = op;
    3225                 :             :     }
    3226                 :             : 
    3227                 :             :   bool require_non_reg = false;
    3228                 :  5684626183 :   while (handled_component_p (expr))
    3229                 :             :     {
    3230                 :  2236371938 :       require_non_reg = true;
    3231                 :  2236371938 :       code_name = get_tree_code_name (TREE_CODE (expr));
    3232                 :             : 
    3233                 :  2236371938 :       if (TREE_CODE (expr) == REALPART_EXPR
    3234                 :  2236371938 :           || TREE_CODE (expr) == IMAGPART_EXPR
    3235                 :  2236371938 :           || TREE_CODE (expr) == BIT_FIELD_REF)
    3236                 :             :         {
    3237                 :           0 :           error ("non-top-level %qs", code_name);
    3238                 :           0 :           return true;
    3239                 :             :         }
    3240                 :             : 
    3241                 :  2236371938 :       tree op = TREE_OPERAND (expr, 0);
    3242                 :             : 
    3243                 :  2236371938 :       if (TREE_CODE (expr) == ARRAY_REF
    3244                 :  2236371938 :           || TREE_CODE (expr) == ARRAY_RANGE_REF)
    3245                 :             :         {
    3246                 :   406524424 :           if (!is_gimple_val (TREE_OPERAND (expr, 1))
    3247                 :   406524424 :               || (TREE_OPERAND (expr, 2)
    3248                 :     2548407 :                   && !is_gimple_val (TREE_OPERAND (expr, 2)))
    3249                 :   813048848 :               || (TREE_OPERAND (expr, 3)
    3250                 :      626855 :                   && !is_gimple_val (TREE_OPERAND (expr, 3))))
    3251                 :             :             {
    3252                 :           0 :               error ("invalid operands to %qs", code_name);
    3253                 :           0 :               debug_generic_stmt (expr);
    3254                 :           0 :               return true;
    3255                 :             :             }
    3256                 :             :         }
    3257                 :             : 
    3258                 :             :       /* Verify if the reference array element types are compatible.  */
    3259                 :  2236371938 :       if (TREE_CODE (expr) == ARRAY_REF
    3260                 :  2642480081 :           && !useless_type_conversion_p (TREE_TYPE (expr),
    3261                 :   406108143 :                                          TREE_TYPE (TREE_TYPE (op))))
    3262                 :             :         {
    3263                 :           0 :           error ("type mismatch in %qs", code_name);
    3264                 :           0 :           debug_generic_stmt (TREE_TYPE (expr));
    3265                 :           0 :           debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
    3266                 :           0 :           return true;
    3267                 :             :         }
    3268                 :  2236371938 :       if (TREE_CODE (expr) == ARRAY_RANGE_REF
    3269                 :  2236788219 :           && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (expr)),
    3270                 :      416281 :                                          TREE_TYPE (TREE_TYPE (op))))
    3271                 :             :         {
    3272                 :           0 :           error ("type mismatch in %qs", code_name);
    3273                 :           0 :           debug_generic_stmt (TREE_TYPE (TREE_TYPE (expr)));
    3274                 :           0 :           debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
    3275                 :           0 :           return true;
    3276                 :             :         }
    3277                 :             : 
    3278                 :  2236371938 :       if (TREE_CODE (expr) == COMPONENT_REF)
    3279                 :             :         {
    3280                 :  1827567721 :           if (TREE_OPERAND (expr, 2)
    3281                 :  1827567721 :               && !is_gimple_val (TREE_OPERAND (expr, 2)))
    3282                 :             :             {
    3283                 :           0 :               error ("invalid %qs offset operator", code_name);
    3284                 :           0 :               return true;
    3285                 :             :             }
    3286                 :  1827567721 :           if (!useless_type_conversion_p (TREE_TYPE (expr),
    3287                 :  1827567721 :                                           TREE_TYPE (TREE_OPERAND (expr, 1))))
    3288                 :             :             {
    3289                 :           0 :               error ("type mismatch in %qs", code_name);
    3290                 :           0 :               debug_generic_stmt (TREE_TYPE (expr));
    3291                 :           0 :               debug_generic_stmt (TREE_TYPE (TREE_OPERAND (expr, 1)));
    3292                 :           0 :               return true;
    3293                 :             :             }
    3294                 :             :         }
    3295                 :             : 
    3296                 :             :       expr = op;
    3297                 :             :     }
    3298                 :             : 
    3299                 :  3448254245 :   code_name = get_tree_code_name (TREE_CODE (expr));
    3300                 :             : 
    3301                 :  3448254245 :   if (TREE_CODE (expr) == MEM_REF)
    3302                 :             :     {
    3303                 :  1138337317 :       if (!is_gimple_mem_ref_addr (TREE_OPERAND (expr, 0))
    3304                 :  1138337317 :           || (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR
    3305                 :   287735041 :               && verify_address (TREE_OPERAND (expr, 0), false)))
    3306                 :             :         {
    3307                 :           0 :           error ("invalid address operand in %qs", code_name);
    3308                 :           0 :           debug_generic_stmt (expr);
    3309                 :           0 :           return true;
    3310                 :             :         }
    3311                 :  1138337317 :       if (!poly_int_tree_p (TREE_OPERAND (expr, 1))
    3312                 :  1138337317 :           || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 1))))
    3313                 :             :         {
    3314                 :           0 :           error ("invalid offset operand in %qs", code_name);
    3315                 :           0 :           debug_generic_stmt (expr);
    3316                 :           0 :           return true;
    3317                 :             :         }
    3318                 :  1138337317 :       if (MR_DEPENDENCE_CLIQUE (expr) != 0
    3319                 :  1138337317 :           && MR_DEPENDENCE_CLIQUE (expr) > cfun->last_clique)
    3320                 :             :         {
    3321                 :           0 :           error ("invalid clique in %qs", code_name);
    3322                 :           0 :           debug_generic_stmt (expr);
    3323                 :           0 :           return true;
    3324                 :             :         }
    3325                 :             :     }
    3326                 :  2309916928 :   else if (TREE_CODE (expr) == TARGET_MEM_REF)
    3327                 :             :     {
    3328                 :    27725567 :       if (!TMR_BASE (expr)
    3329                 :    27725567 :           || !is_gimple_mem_ref_addr (TMR_BASE (expr))
    3330                 :    55451134 :           || (TREE_CODE (TMR_BASE (expr)) == ADDR_EXPR
    3331                 :     6439291 :               && verify_address (TMR_BASE (expr), false)))
    3332                 :             :         {
    3333                 :           0 :           error ("invalid address operand in %qs", code_name);
    3334                 :           0 :           return true;
    3335                 :             :         }
    3336                 :    27725567 :       if (!TMR_OFFSET (expr)
    3337                 :    27725567 :           || !poly_int_tree_p (TMR_OFFSET (expr))
    3338                 :    55451134 :           || !POINTER_TYPE_P (TREE_TYPE (TMR_OFFSET (expr))))
    3339                 :             :         {
    3340                 :           0 :           error ("invalid offset operand in %qs", code_name);
    3341                 :           0 :           debug_generic_stmt (expr);
    3342                 :           0 :           return true;
    3343                 :             :         }
    3344                 :    27725567 :       if (MR_DEPENDENCE_CLIQUE (expr) != 0
    3345                 :    27725567 :           && MR_DEPENDENCE_CLIQUE (expr) > cfun->last_clique)
    3346                 :             :         {
    3347                 :           0 :           error ("invalid clique in %qs", code_name);
    3348                 :           0 :           debug_generic_stmt (expr);
    3349                 :           0 :           return true;
    3350                 :             :         }
    3351                 :             :     }
    3352                 :  2282191361 :   else if (INDIRECT_REF_P (expr))
    3353                 :             :     {
    3354                 :           0 :       error ("%qs in gimple IL", code_name);
    3355                 :           0 :       debug_generic_stmt (expr);
    3356                 :           0 :       return true;
    3357                 :             :     }
    3358                 :  2282191361 :   else if (require_non_reg
    3359                 :  2282191361 :            && (is_gimple_reg (expr)
    3360                 :   894220118 :                || (is_gimple_min_invariant (expr)
    3361                 :             :                    /* STRING_CSTs are representatives of the string table
    3362                 :             :                       entry which lives in memory.  */
    3363                 :     8476036 :                    && TREE_CODE (expr) != STRING_CST)))
    3364                 :             :     {
    3365                 :           0 :       error ("%qs as base where non-register is required", code_name);
    3366                 :           0 :       debug_generic_stmt (expr);
    3367                 :           0 :       return true;
    3368                 :             :     }
    3369                 :             : 
    3370                 :  3448254245 :   if (!require_lvalue
    3371                 :  3448254245 :       && (is_gimple_reg (expr) || is_gimple_min_invariant (expr)))
    3372                 :  1085084291 :     return false;
    3373                 :             : 
    3374                 :  2363169954 :   if (TREE_CODE (expr) != SSA_NAME && is_gimple_id (expr))
    3375                 :             :     return false;
    3376                 :             : 
    3377                 :  1166062884 :   if (TREE_CODE (expr) != TARGET_MEM_REF
    3378                 :  1166062884 :       && TREE_CODE (expr) != MEM_REF)
    3379                 :             :     {
    3380                 :           0 :       error ("invalid expression for min lvalue");
    3381                 :           0 :       return true;
    3382                 :             :     }
    3383                 :             : 
    3384                 :             :   return false;
    3385                 :             : }
    3386                 :             : 
    3387                 :             : /* Returns true if there is one pointer type in TYPE_POINTER_TO (SRC_OBJ)
    3388                 :             :    list of pointer-to types that is trivially convertible to DEST.  */
    3389                 :             : 
    3390                 :             : static bool
    3391                 :         446 : one_pointer_to_useless_type_conversion_p (tree dest, tree src_obj)
    3392                 :             : {
    3393                 :         446 :   tree src;
    3394                 :             : 
    3395                 :         446 :   if (!TYPE_POINTER_TO (src_obj))
    3396                 :             :     return true;
    3397                 :             : 
    3398                 :         446 :   for (src = TYPE_POINTER_TO (src_obj); src; src = TYPE_NEXT_PTR_TO (src))
    3399                 :         446 :     if (useless_type_conversion_p (dest, src))
    3400                 :             :       return true;
    3401                 :             : 
    3402                 :             :   return false;
    3403                 :             : }
    3404                 :             : 
    3405                 :             : /* Return true if TYPE1 is a fixed-point type and if conversions to and
    3406                 :             :    from TYPE2 can be handled by FIXED_CONVERT_EXPR.  */
    3407                 :             : 
    3408                 :             : static bool
    3409                 :           0 : valid_fixed_convert_types_p (tree type1, tree type2)
    3410                 :             : {
    3411                 :           0 :   return (FIXED_POINT_TYPE_P (type1)
    3412                 :           0 :           && (INTEGRAL_TYPE_P (type2)
    3413                 :           0 :               || SCALAR_FLOAT_TYPE_P (type2)
    3414                 :           0 :               || FIXED_POINT_TYPE_P (type2)));
    3415                 :             : }
    3416                 :             : 
    3417                 :             : /* Verify the contents of a GIMPLE_CALL STMT.  Returns true when there
    3418                 :             :    is a problem, otherwise false.  */
    3419                 :             : 
    3420                 :             : static bool
    3421                 :   979315238 : verify_gimple_call (gcall *stmt)
    3422                 :             : {
    3423                 :   979315238 :   tree fn = gimple_call_fn (stmt);
    3424                 :   979315238 :   tree fntype, fndecl;
    3425                 :   979315238 :   unsigned i;
    3426                 :             : 
    3427                 :   979315238 :   if (gimple_call_internal_p (stmt))
    3428                 :             :     {
    3429                 :    28319430 :       if (fn)
    3430                 :             :         {
    3431                 :           0 :           error ("gimple call has two targets");
    3432                 :           0 :           debug_generic_stmt (fn);
    3433                 :           0 :           return true;
    3434                 :             :         }
    3435                 :             :     }
    3436                 :             :   else
    3437                 :             :     {
    3438                 :   950995808 :       if (!fn)
    3439                 :             :         {
    3440                 :           0 :           error ("gimple call has no target");
    3441                 :           0 :           return true;
    3442                 :             :         }
    3443                 :             :     }
    3444                 :             : 
    3445                 :   950995808 :   if (fn && !is_gimple_call_addr (fn))
    3446                 :             :     {
    3447                 :           0 :       error ("invalid function in gimple call");
    3448                 :           0 :       debug_generic_stmt (fn);
    3449                 :           0 :       return true;
    3450                 :             :     }
    3451                 :             : 
    3452                 :   979315238 :   if (fn
    3453                 :   979315238 :       && (!POINTER_TYPE_P (TREE_TYPE (fn))
    3454                 :   950995808 :           || (TREE_CODE (TREE_TYPE (TREE_TYPE (fn))) != FUNCTION_TYPE
    3455                 :   159346302 :               && TREE_CODE (TREE_TYPE (TREE_TYPE (fn))) != METHOD_TYPE)))
    3456                 :             :     {
    3457                 :           0 :       error ("non-function in gimple call");
    3458                 :           0 :       return true;
    3459                 :             :     }
    3460                 :             : 
    3461                 :   979315238 :    fndecl = gimple_call_fndecl (stmt);
    3462                 :   979315238 :    if (fndecl
    3463                 :   925448144 :        && TREE_CODE (fndecl) == FUNCTION_DECL
    3464                 :   925448144 :        && DECL_LOOPING_CONST_OR_PURE_P (fndecl)
    3465                 :     5756556 :        && !DECL_PURE_P (fndecl)
    3466                 :   979718269 :        && !TREE_READONLY (fndecl))
    3467                 :             :      {
    3468                 :           0 :        error ("invalid pure const state for function");
    3469                 :           0 :        return true;
    3470                 :             :      }
    3471                 :             : 
    3472                 :   979315238 :   tree lhs = gimple_call_lhs (stmt);
    3473                 :   979315238 :   if (lhs
    3474                 :   979315238 :       && (!is_gimple_reg (lhs)
    3475                 :    61579445 :           && (!is_gimple_lvalue (lhs)
    3476                 :    61579445 :               || verify_types_in_gimple_reference
    3477                 :    61579445 :                    (TREE_CODE (lhs) == WITH_SIZE_EXPR
    3478                 :           0 :                     ? TREE_OPERAND (lhs, 0) : lhs, true))))
    3479                 :             :     {
    3480                 :           0 :       error ("invalid LHS in gimple call");
    3481                 :           0 :       return true;
    3482                 :             :     }
    3483                 :             : 
    3484                 :   979315238 :   if (gimple_call_ctrl_altering_p (stmt)
    3485                 :   125976067 :       && gimple_call_noreturn_p (stmt)
    3486                 :  1101020614 :       && should_remove_lhs_p (lhs))
    3487                 :             :     {
    3488                 :           0 :       error ("LHS in %<noreturn%> call");
    3489                 :           0 :       return true;
    3490                 :             :     }
    3491                 :             : 
    3492                 :   979315238 :   fntype = gimple_call_fntype (stmt);
    3493                 :   979315238 :   if (fntype
    3494                 :   979315238 :       && lhs
    3495                 :   364233033 :       && !useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (fntype))
    3496                 :             :       /* ???  At least C++ misses conversions at assignments from
    3497                 :             :          void * call results.
    3498                 :             :          For now simply allow arbitrary pointer type conversions.  */
    3499                 :   979315238 :       && !(POINTER_TYPE_P (TREE_TYPE (lhs))
    3500                 :           0 :            && POINTER_TYPE_P (TREE_TYPE (fntype))))
    3501                 :             :     {
    3502                 :           0 :       error ("invalid conversion in gimple call");
    3503                 :           0 :       debug_generic_stmt (TREE_TYPE (lhs));
    3504                 :           0 :       debug_generic_stmt (TREE_TYPE (fntype));
    3505                 :           0 :       return true;
    3506                 :             :     }
    3507                 :             : 
    3508                 :   979315238 :   if (gimple_call_chain (stmt)
    3509                 :   979315238 :       && !is_gimple_val (gimple_call_chain (stmt)))
    3510                 :             :     {
    3511                 :           0 :       error ("invalid static chain in gimple call");
    3512                 :           0 :       debug_generic_stmt (gimple_call_chain (stmt));
    3513                 :           0 :       return true;
    3514                 :             :     }
    3515                 :             : 
    3516                 :             :   /* If there is a static chain argument, the call should either be
    3517                 :             :      indirect, or the decl should have DECL_STATIC_CHAIN set.  */
    3518                 :   979315238 :   if (gimple_call_chain (stmt)
    3519                 :     4910485 :       && fndecl
    3520                 :   980765883 :       && !DECL_STATIC_CHAIN (fndecl))
    3521                 :             :     {
    3522                 :           0 :       error ("static chain with function that doesn%'t use one");
    3523                 :           0 :       return true;
    3524                 :             :     }
    3525                 :             : 
    3526                 :   979315238 :   if (fndecl && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL))
    3527                 :             :     {
    3528                 :   221939484 :       switch (DECL_FUNCTION_CODE (fndecl))
    3529                 :             :         {
    3530                 :    13576879 :         case BUILT_IN_UNREACHABLE:
    3531                 :    13576879 :         case BUILT_IN_UNREACHABLE_TRAP:
    3532                 :    13576879 :         case BUILT_IN_TRAP:
    3533                 :    13576879 :           if (gimple_call_num_args (stmt) > 0)
    3534                 :             :             {
    3535                 :             :               /* Built-in unreachable with parameters might not be caught by
    3536                 :             :                  undefined behavior sanitizer.  Front-ends do check users do not
    3537                 :             :                  call them that way but we also produce calls to
    3538                 :             :                  __builtin_unreachable internally, for example when IPA figures
    3539                 :             :                  out a call cannot happen in a legal program.  In such cases,
    3540                 :             :                  we must make sure arguments are stripped off.  */
    3541                 :           0 :               error ("%<__builtin_unreachable%> or %<__builtin_trap%> call "
    3542                 :             :                      "with arguments");
    3543                 :           0 :               return true;
    3544                 :             :             }
    3545                 :             :           break;
    3546                 :             :         default:
    3547                 :             :           break;
    3548                 :             :         }
    3549                 :             :     }
    3550                 :             : 
    3551                 :             :   /* For a call to .DEFERRED_INIT,
    3552                 :             :      LHS = DEFERRED_INIT (SIZE of the DECL, INIT_TYPE, NAME of the DECL)
    3553                 :             :      we should guarantee that when the 1st argument is a constant, it should
    3554                 :             :      be the same as the size of the LHS.  */
    3555                 :             : 
    3556                 :   979315238 :   if (gimple_call_internal_p (stmt, IFN_DEFERRED_INIT))
    3557                 :             :     {
    3558                 :       42517 :       tree size_of_arg0 = gimple_call_arg (stmt, 0);
    3559                 :       42517 :       tree size_of_lhs = TYPE_SIZE_UNIT (TREE_TYPE (lhs));
    3560                 :             : 
    3561                 :       42517 :       if (TREE_CODE (lhs) == SSA_NAME)
    3562                 :       42517 :         lhs = SSA_NAME_VAR (lhs);
    3563                 :             : 
    3564                 :       42517 :       poly_uint64 size_from_arg0, size_from_lhs;
    3565                 :       42517 :       bool is_constant_size_arg0 = poly_int_tree_p (size_of_arg0,
    3566                 :             :                                                     &size_from_arg0);
    3567                 :       42517 :       bool is_constant_size_lhs = poly_int_tree_p (size_of_lhs,
    3568                 :             :                                                    &size_from_lhs);
    3569                 :       42517 :       if (is_constant_size_arg0 && is_constant_size_lhs)
    3570                 :       40198 :         if (maybe_ne (size_from_arg0, size_from_lhs))
    3571                 :             :           {
    3572                 :           0 :             error ("%<DEFERRED_INIT%> calls should have same "
    3573                 :             :                    "constant size for the first argument and LHS");
    3574                 :           0 :             return true;
    3575                 :             :           }
    3576                 :             :     }
    3577                 :             : 
    3578                 :             :   /* ???  The C frontend passes unpromoted arguments in case it
    3579                 :             :      didn't see a function declaration before the call.  So for now
    3580                 :             :      leave the call arguments mostly unverified.  Once we gimplify
    3581                 :             :      unit-at-a-time we have a chance to fix this.  */
    3582                 :  2930343293 :   for (i = 0; i < gimple_call_num_args (stmt); ++i)
    3583                 :             :     {
    3584                 :  1951028056 :       tree arg = gimple_call_arg (stmt, i);
    3585                 :  1951028056 :       if ((is_gimple_reg_type (TREE_TYPE (arg))
    3586                 :  1840704525 :            && !is_gimple_val (arg))
    3587                 :  3791732580 :           || (!is_gimple_reg_type (TREE_TYPE (arg))
    3588                 :   110323531 :               && !is_gimple_lvalue (arg)))
    3589                 :             :         {
    3590                 :           1 :           error ("invalid argument to gimple call");
    3591                 :           1 :           debug_generic_expr (arg);
    3592                 :           1 :           return true;
    3593                 :             :         }
    3594                 :  1951028055 :       if (!is_gimple_reg (arg))
    3595                 :             :         {
    3596                 :  1142853405 :           if (TREE_CODE (arg) == WITH_SIZE_EXPR)
    3597                 :       22108 :             arg = TREE_OPERAND (arg, 0);
    3598                 :  1142853405 :           if (verify_types_in_gimple_reference (arg, false))
    3599                 :             :             return true;
    3600                 :             :         }
    3601                 :             :     }
    3602                 :             : 
    3603                 :             :   return false;
    3604                 :             : }
    3605                 :             : 
    3606                 :             : /* Verifies the gimple comparison with the result type TYPE and
    3607                 :             :    the operands OP0 and OP1, comparison code is CODE.  */
    3608                 :             : 
    3609                 :             : static bool
    3610                 :   755647379 : verify_gimple_comparison (tree type, tree op0, tree op1, enum tree_code code)
    3611                 :             : {
    3612                 :   755647379 :   tree op0_type = TREE_TYPE (op0);
    3613                 :   755647379 :   tree op1_type = TREE_TYPE (op1);
    3614                 :             : 
    3615                 :   755647379 :   if (!is_gimple_val (op0) || !is_gimple_val (op1))
    3616                 :             :     {
    3617                 :           0 :       error ("invalid operands in gimple comparison");
    3618                 :           0 :       return true;
    3619                 :             :     }
    3620                 :             : 
    3621                 :             :   /* For comparisons we do not have the operations type as the
    3622                 :             :      effective type the comparison is carried out in.  Instead
    3623                 :             :      we require that either the first operand is trivially
    3624                 :             :      convertible into the second, or the other way around.  */
    3625                 :   755647379 :   if (!useless_type_conversion_p (op0_type, op1_type)
    3626                 :   755647379 :       && !useless_type_conversion_p (op1_type, op0_type))
    3627                 :             :     {
    3628                 :           0 :       error ("mismatching comparison operand types");
    3629                 :           0 :       debug_generic_expr (op0_type);
    3630                 :           0 :       debug_generic_expr (op1_type);
    3631                 :           0 :       return true;
    3632                 :             :     }
    3633                 :             : 
    3634                 :             :   /* The resulting type of a comparison may be an effective boolean type.  */
    3635                 :   755647379 :   if (INTEGRAL_TYPE_P (type)
    3636                 :   755647379 :       && (TREE_CODE (type) == BOOLEAN_TYPE
    3637                 :         682 :           || TYPE_PRECISION (type) == 1))
    3638                 :             :     {
    3639                 :   754407185 :       if ((VECTOR_TYPE_P (op0_type)
    3640                 :   754324519 :            || VECTOR_TYPE_P (op1_type))
    3641                 :       82666 :           && code != EQ_EXPR && code != NE_EXPR
    3642                 :           0 :           && !VECTOR_BOOLEAN_TYPE_P (op0_type)
    3643                 :   754407185 :           && !VECTOR_INTEGER_TYPE_P (op0_type))
    3644                 :             :         {
    3645                 :           0 :           error ("unsupported operation or type for vector comparison"
    3646                 :             :                  " returning a boolean");
    3647                 :           0 :           debug_generic_expr (op0_type);
    3648                 :           0 :           debug_generic_expr (op1_type);
    3649                 :           0 :           return true;
    3650                 :             :         }
    3651                 :             :     }
    3652                 :             :   /* Or a boolean vector type with the same element count
    3653                 :             :      as the comparison operand types.  */
    3654                 :     1240194 :   else if (VECTOR_TYPE_P (type)
    3655                 :     1240194 :            && TREE_CODE (TREE_TYPE (type)) == BOOLEAN_TYPE)
    3656                 :             :     {
    3657                 :     1240194 :       if (TREE_CODE (op0_type) != VECTOR_TYPE
    3658                 :     1240194 :           || TREE_CODE (op1_type) != VECTOR_TYPE)
    3659                 :             :         {
    3660                 :           0 :           error ("non-vector operands in vector comparison");
    3661                 :           0 :           debug_generic_expr (op0_type);
    3662                 :           0 :           debug_generic_expr (op1_type);
    3663                 :           0 :           return true;
    3664                 :             :         }
    3665                 :             : 
    3666                 :     1240194 :       if (maybe_ne (TYPE_VECTOR_SUBPARTS (type),
    3667                 :     2480388 :                     TYPE_VECTOR_SUBPARTS (op0_type)))
    3668                 :             :         {
    3669                 :           0 :           error ("invalid vector comparison resulting type");
    3670                 :           0 :           debug_generic_expr (type);
    3671                 :           0 :           return true;
    3672                 :             :         }
    3673                 :             :     }
    3674                 :             :   else
    3675                 :             :     {
    3676                 :           0 :       error ("bogus comparison result type");
    3677                 :           0 :       debug_generic_expr (type);
    3678                 :           0 :       return true;
    3679                 :             :     }
    3680                 :             : 
    3681                 :             :   return false;
    3682                 :             : }
    3683                 :             : 
    3684                 :             : /* Verify a gimple assignment statement STMT with an unary rhs.
    3685                 :             :    Returns true if anything is wrong.  */
    3686                 :             : 
    3687                 :             : static bool
    3688                 :   400258586 : verify_gimple_assign_unary (gassign *stmt)
    3689                 :             : {
    3690                 :   400258586 :   enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
    3691                 :   400258586 :   tree lhs = gimple_assign_lhs (stmt);
    3692                 :   400258586 :   tree lhs_type = TREE_TYPE (lhs);
    3693                 :   400258586 :   tree rhs1 = gimple_assign_rhs1 (stmt);
    3694                 :   400258586 :   tree rhs1_type = TREE_TYPE (rhs1);
    3695                 :             : 
    3696                 :   400258586 :   if (!is_gimple_reg (lhs))
    3697                 :             :     {
    3698                 :           0 :       error ("non-register as LHS of unary operation");
    3699                 :           0 :       return true;
    3700                 :             :     }
    3701                 :             : 
    3702                 :   400258586 :   if (!is_gimple_val (rhs1))
    3703                 :             :     {
    3704                 :           0 :       error ("invalid operand in unary operation");
    3705                 :           0 :       return true;
    3706                 :             :     }
    3707                 :             : 
    3708                 :   400258586 :   const char* const code_name = get_tree_code_name (rhs_code);
    3709                 :             : 
    3710                 :             :   /* First handle conversions.  */
    3711                 :   400258586 :   switch (rhs_code)
    3712                 :             :     {
    3713                 :   355660719 :     CASE_CONVERT:
    3714                 :   355660719 :       {
    3715                 :             :         /* Allow conversions between vectors with the same number of elements,
    3716                 :             :            provided that the conversion is OK for the element types too.  */
    3717                 :   355660719 :         if (VECTOR_TYPE_P (lhs_type)
    3718                 :      133382 :             && VECTOR_TYPE_P (rhs1_type)
    3719                 :   355794101 :             && known_eq (TYPE_VECTOR_SUBPARTS (lhs_type),
    3720                 :             :                          TYPE_VECTOR_SUBPARTS (rhs1_type)))
    3721                 :             :           {
    3722                 :      133382 :             lhs_type = TREE_TYPE (lhs_type);
    3723                 :      133382 :             rhs1_type = TREE_TYPE (rhs1_type);
    3724                 :             :           }
    3725                 :   355527337 :         else if (VECTOR_TYPE_P (lhs_type) || VECTOR_TYPE_P (rhs1_type))
    3726                 :             :           {
    3727                 :           0 :             error ("invalid vector types in nop conversion");
    3728                 :           0 :             debug_generic_expr (lhs_type);
    3729                 :           0 :             debug_generic_expr (rhs1_type);
    3730                 :           0 :             return true;
    3731                 :             :           }
    3732                 :             : 
    3733                 :             :         /* Allow conversions from pointer type to integral type only if
    3734                 :             :            there is no sign or zero extension involved.
    3735                 :             :            For targets were the precision of ptrofftype doesn't match that
    3736                 :             :            of pointers we allow conversions to types where
    3737                 :             :            POINTERS_EXTEND_UNSIGNED specifies how that works.  */
    3738                 :   355660719 :         if ((POINTER_TYPE_P (lhs_type)
    3739                 :    20978940 :              && INTEGRAL_TYPE_P (rhs1_type))
    3740                 :   359597485 :             || (POINTER_TYPE_P (rhs1_type)
    3741                 :    45269840 :                 && INTEGRAL_TYPE_P (lhs_type)
    3742                 :    41333074 :                 && (TYPE_PRECISION (rhs1_type) >= TYPE_PRECISION (lhs_type)
    3743                 :             : #if defined(POINTERS_EXTEND_UNSIGNED)
    3744                 :           0 :                     || (TYPE_MODE (rhs1_type) == ptr_mode
    3745                 :           0 :                         && (TYPE_PRECISION (lhs_type)
    3746                 :           0 :                               == BITS_PER_WORD /* word_mode */
    3747                 :           0 :                             || (TYPE_PRECISION (lhs_type)
    3748                 :           0 :                                   == GET_MODE_PRECISION (Pmode))))
    3749                 :             : #endif
    3750                 :             :                    )))
    3751                 :    58375248 :           return false;
    3752                 :             : 
    3753                 :             :         /* Allow conversion from integral to offset type and vice versa.  */
    3754                 :   297285471 :         if ((TREE_CODE (lhs_type) == OFFSET_TYPE
    3755                 :        7465 :              && INTEGRAL_TYPE_P (rhs1_type))
    3756                 :   297284308 :             || (INTEGRAL_TYPE_P (lhs_type)
    3757                 :   273744555 :                 && TREE_CODE (rhs1_type) == OFFSET_TYPE))
    3758                 :             :           return false;
    3759                 :             : 
    3760                 :             :         /* Otherwise assert we are converting between types of the
    3761                 :             :            same kind.  */
    3762                 :   297241608 :         if (INTEGRAL_TYPE_P (lhs_type) != INTEGRAL_TYPE_P (rhs1_type))
    3763                 :             :           {
    3764                 :           0 :             error ("invalid types in nop conversion");
    3765                 :           0 :             debug_generic_expr (lhs_type);
    3766                 :           0 :             debug_generic_expr (rhs1_type);
    3767                 :           0 :             return true;
    3768                 :             :           }
    3769                 :             : 
    3770                 :             :         return false;
    3771                 :             :       }
    3772                 :             : 
    3773                 :           0 :     case ADDR_SPACE_CONVERT_EXPR:
    3774                 :           0 :       {
    3775                 :           0 :         if (!POINTER_TYPE_P (rhs1_type) || !POINTER_TYPE_P (lhs_type)
    3776                 :           0 :             || (TYPE_ADDR_SPACE (TREE_TYPE (rhs1_type))
    3777                 :           0 :                 == TYPE_ADDR_SPACE (TREE_TYPE (lhs_type))))
    3778                 :             :           {
    3779                 :           0 :             error ("invalid types in address space conversion");
    3780                 :           0 :             debug_generic_expr (lhs_type);
    3781                 :           0 :             debug_generic_expr (rhs1_type);
    3782                 :           0 :             return true;
    3783                 :             :           }
    3784                 :             : 
    3785                 :             :         return false;
    3786                 :             :       }
    3787                 :             : 
    3788                 :           0 :     case FIXED_CONVERT_EXPR:
    3789                 :           0 :       {
    3790                 :           0 :         if (!valid_fixed_convert_types_p (lhs_type, rhs1_type)
    3791                 :   400258586 :             && !valid_fixed_convert_types_p (rhs1_type, lhs_type))
    3792                 :             :           {
    3793                 :           0 :             error ("invalid types in fixed-point conversion");
    3794                 :           0 :             debug_generic_expr (lhs_type);
    3795                 :           0 :             debug_generic_expr (rhs1_type);
    3796                 :           0 :             return true;
    3797                 :             :           }
    3798                 :             : 
    3799                 :             :         return false;
    3800                 :             :       }
    3801                 :             : 
    3802                 :    15951091 :     case FLOAT_EXPR:
    3803                 :    15951091 :       {
    3804                 :    15862443 :         if ((!INTEGRAL_TYPE_P (rhs1_type) || !SCALAR_FLOAT_TYPE_P (lhs_type))
    3805                 :    15951091 :             && (!VECTOR_INTEGER_TYPE_P (rhs1_type)
    3806                 :       88648 :                 || !VECTOR_FLOAT_TYPE_P (lhs_type)))
    3807                 :             :           {
    3808                 :           0 :             error ("invalid types in conversion to floating-point");
    3809                 :           0 :             debug_generic_expr (lhs_type);
    3810                 :           0 :             debug_generic_expr (rhs1_type);
    3811                 :           0 :             return true;
    3812                 :             :           }
    3813                 :             : 
    3814                 :             :         return false;
    3815                 :             :       }
    3816                 :             : 
    3817                 :     5053713 :     case FIX_TRUNC_EXPR:
    3818                 :     5053713 :       {
    3819                 :     5031420 :         if ((!INTEGRAL_TYPE_P (lhs_type) || !SCALAR_FLOAT_TYPE_P (rhs1_type))
    3820                 :     5053713 :             && (!VECTOR_INTEGER_TYPE_P (lhs_type)
    3821                 :       22293 :                 || !VECTOR_FLOAT_TYPE_P (rhs1_type)))
    3822                 :             :           {
    3823                 :           0 :             error ("invalid types in conversion to integer");
    3824                 :           0 :             debug_generic_expr (lhs_type);
    3825                 :           0 :             debug_generic_expr (rhs1_type);
    3826                 :           0 :             return true;
    3827                 :             :           }
    3828                 :             : 
    3829                 :             :         return false;
    3830                 :             :       }
    3831                 :             : 
    3832                 :      665863 :     case VEC_UNPACK_HI_EXPR:
    3833                 :      665863 :     case VEC_UNPACK_LO_EXPR:
    3834                 :      665863 :     case VEC_UNPACK_FLOAT_HI_EXPR:
    3835                 :      665863 :     case VEC_UNPACK_FLOAT_LO_EXPR:
    3836                 :      665863 :     case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
    3837                 :      665863 :     case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
    3838                 :      665863 :       if (TREE_CODE (rhs1_type) != VECTOR_TYPE
    3839                 :      665863 :           || TREE_CODE (lhs_type) != VECTOR_TYPE
    3840                 :      665863 :           || (!INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))
    3841                 :      122184 :               && !SCALAR_FLOAT_TYPE_P (TREE_TYPE (lhs_type)))
    3842                 :      665863 :           || (!INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
    3843                 :       38834 :               && !SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type)))
    3844                 :      665863 :           || ((rhs_code == VEC_UNPACK_HI_EXPR
    3845                 :      665863 :                || rhs_code == VEC_UNPACK_LO_EXPR)
    3846                 :     1156354 :               && (INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))
    3847                 :      578177 :                   != INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))))
    3848                 :      665863 :           || ((rhs_code == VEC_UNPACK_FLOAT_HI_EXPR
    3849                 :      665863 :                || rhs_code == VEC_UNPACK_FLOAT_LO_EXPR)
    3850                 :       85518 :               && (INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))
    3851                 :       85518 :                   || SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type))))
    3852                 :      665863 :           || ((rhs_code == VEC_UNPACK_FIX_TRUNC_HI_EXPR
    3853                 :      665863 :                || rhs_code == VEC_UNPACK_FIX_TRUNC_LO_EXPR)
    3854                 :        2168 :               && (INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
    3855                 :        2168 :                   || SCALAR_FLOAT_TYPE_P (TREE_TYPE (lhs_type))))
    3856                 :     1331726 :           || (maybe_ne (GET_MODE_SIZE (element_mode (lhs_type)),
    3857                 :     1331726 :                         2 * GET_MODE_SIZE (element_mode (rhs1_type)))
    3858                 :       46486 :               && (!VECTOR_BOOLEAN_TYPE_P (lhs_type)
    3859                 :       46486 :                   || !VECTOR_BOOLEAN_TYPE_P (rhs1_type)))
    3860                 :     1331726 :           || maybe_ne (2 * TYPE_VECTOR_SUBPARTS (lhs_type),
    3861                 :     1331726 :                        TYPE_VECTOR_SUBPARTS (rhs1_type)))
    3862                 :             :         {
    3863                 :           0 :           error ("type mismatch in %qs expression", code_name);
    3864                 :           0 :           debug_generic_expr (lhs_type);
    3865                 :           0 :           debug_generic_expr (rhs1_type);
    3866                 :           0 :           return true;
    3867                 :             :         }
    3868                 :             : 
    3869                 :             :       return false;
    3870                 :             : 
    3871                 :    22804624 :     case NEGATE_EXPR:
    3872                 :    22804624 :     case ABS_EXPR:
    3873                 :    22804624 :     case BIT_NOT_EXPR:
    3874                 :    22804624 :     case PAREN_EXPR:
    3875                 :    22804624 :     case CONJ_EXPR:
    3876                 :             :       /* Disallow pointer and offset types for many of the unary gimple. */
    3877                 :    22804624 :       if (POINTER_TYPE_P (lhs_type)
    3878                 :    22804624 :           || TREE_CODE (lhs_type) == OFFSET_TYPE)
    3879                 :             :         {
    3880                 :           0 :           error ("invalid types for %qs", code_name);
    3881                 :           0 :           debug_generic_expr (lhs_type);
    3882                 :           0 :           debug_generic_expr (rhs1_type);
    3883                 :           0 :           return true;
    3884                 :             :         }
    3885                 :    22804624 :       break;
    3886                 :             : 
    3887                 :      122576 :     case ABSU_EXPR:
    3888                 :       32013 :       if (!ANY_INTEGRAL_TYPE_P (lhs_type)
    3889                 :      122576 :           || !TYPE_UNSIGNED (lhs_type)
    3890                 :      122576 :           || !ANY_INTEGRAL_TYPE_P (rhs1_type)
    3891                 :      122576 :           || TYPE_UNSIGNED (rhs1_type)
    3892                 :      245152 :           || element_precision (lhs_type) != element_precision (rhs1_type))
    3893                 :             :         {
    3894                 :           0 :           error ("invalid types for %qs", code_name);
    3895                 :           0 :           debug_generic_expr (lhs_type);
    3896                 :           0 :           debug_generic_expr (rhs1_type);
    3897                 :           0 :           return true;
    3898                 :             :         }
    3899                 :             :       return false;
    3900                 :             : 
    3901                 :           0 :     case VEC_DUPLICATE_EXPR:
    3902                 :           0 :       if (TREE_CODE (lhs_type) != VECTOR_TYPE
    3903                 :           0 :           || !useless_type_conversion_p (TREE_TYPE (lhs_type), rhs1_type))
    3904                 :             :         {
    3905                 :           0 :           error ("%qs should be from a scalar to a like vector", code_name);
    3906                 :           0 :           debug_generic_expr (lhs_type);
    3907                 :           0 :           debug_generic_expr (rhs1_type);
    3908                 :           0 :           return true;
    3909                 :             :         }
    3910                 :             :       return false;
    3911                 :             : 
    3912                 :           0 :     default:
    3913                 :           0 :       gcc_unreachable ();
    3914                 :             :     }
    3915                 :             : 
    3916                 :             :   /* For the remaining codes assert there is no conversion involved.  */
    3917                 :    22804624 :   if (!useless_type_conversion_p (lhs_type, rhs1_type))
    3918                 :             :     {
    3919                 :           0 :       error ("non-trivial conversion in unary operation");
    3920                 :           0 :       debug_generic_expr (lhs_type);
    3921                 :           0 :       debug_generic_expr (rhs1_type);
    3922                 :           0 :       return true;
    3923                 :             :     }
    3924                 :             : 
    3925                 :             :   return false;
    3926                 :             : }
    3927                 :             : 
    3928                 :             : /* Verify a gimple assignment statement STMT with a binary rhs.
    3929                 :             :    Returns true if anything is wrong.  */
    3930                 :             : 
    3931                 :             : static bool
    3932                 :   934571260 : verify_gimple_assign_binary (gassign *stmt)
    3933                 :             : {
    3934                 :   934571260 :   enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
    3935                 :   934571260 :   tree lhs = gimple_assign_lhs (stmt);
    3936                 :   934571260 :   tree lhs_type = TREE_TYPE (lhs);
    3937                 :   934571260 :   tree rhs1 = gimple_assign_rhs1 (stmt);
    3938                 :   934571260 :   tree rhs1_type = TREE_TYPE (rhs1);
    3939                 :   934571260 :   tree rhs2 = gimple_assign_rhs2 (stmt);
    3940                 :   934571260 :   tree rhs2_type = TREE_TYPE (rhs2);
    3941                 :             : 
    3942                 :   934571260 :   if (!is_gimple_reg (lhs))
    3943                 :             :     {
    3944                 :           0 :       error ("non-register as LHS of binary operation");
    3945                 :           0 :       return true;
    3946                 :             :     }
    3947                 :             : 
    3948                 :   934571260 :   if (!is_gimple_val (rhs1)
    3949                 :   934571260 :       || !is_gimple_val (rhs2))
    3950                 :             :     {
    3951                 :           0 :       error ("invalid operands in binary operation");
    3952                 :           0 :       return true;
    3953                 :             :     }
    3954                 :             : 
    3955                 :   934571260 :   const char* const code_name = get_tree_code_name (rhs_code);
    3956                 :             : 
    3957                 :             :   /* First handle operations that involve different types.  */
    3958                 :   934571260 :   switch (rhs_code)
    3959                 :             :     {
    3960                 :     2192504 :     case COMPLEX_EXPR:
    3961                 :     2192504 :       {
    3962                 :     2192504 :         if (TREE_CODE (lhs_type) != COMPLEX_TYPE
    3963                 :     2192504 :             || !(INTEGRAL_TYPE_P (rhs1_type)
    3964                 :             :                  || SCALAR_FLOAT_TYPE_P (rhs1_type))
    3965                 :     2192504 :             || !(INTEGRAL_TYPE_P (rhs2_type)
    3966                 :             :                  || SCALAR_FLOAT_TYPE_P (rhs2_type)))
    3967                 :             :           {
    3968                 :           0 :             error ("type mismatch in %qs", code_name);
    3969                 :           0 :             debug_generic_expr (lhs_type);
    3970                 :           0 :             debug_generic_expr (rhs1_type);
    3971                 :           0 :             debug_generic_expr (rhs2_type);
    3972                 :           0 :             return true;
    3973                 :             :           }
    3974                 :             : 
    3975                 :             :         return false;
    3976                 :             :       }
    3977                 :             : 
    3978                 :    29621439 :     case LSHIFT_EXPR:
    3979                 :    29621439 :     case RSHIFT_EXPR:
    3980                 :    29621439 :     case LROTATE_EXPR:
    3981                 :    29621439 :     case RROTATE_EXPR:
    3982                 :    29621439 :       {
    3983                 :             :         /* Shifts and rotates are ok on integral types, fixed point
    3984                 :             :            types and integer vector types.  */
    3985                 :    29621439 :         if ((!INTEGRAL_TYPE_P (rhs1_type)
    3986                 :      497972 :              && !FIXED_POINT_TYPE_P (rhs1_type)
    3987                 :      497972 :              && ! (VECTOR_TYPE_P (rhs1_type)
    3988                 :      497972 :                   && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))))
    3989                 :    29621439 :             || (!INTEGRAL_TYPE_P (rhs2_type)
    3990                 :             :                 /* Vector shifts of vectors are also ok.  */
    3991                 :       93816 :                 && ! (VECTOR_TYPE_P (rhs1_type)
    3992                 :       93816 :                      && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
    3993                 :       93816 :                      && VECTOR_TYPE_P (rhs2_type)
    3994                 :       93816 :                      && INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type))))
    3995                 :    59242878 :             || !useless_type_conversion_p (lhs_type, rhs1_type))
    3996                 :             :           {
    3997                 :           0 :             error ("type mismatch in %qs", code_name);
    3998                 :           0 :             debug_generic_expr (lhs_type);
    3999                 :           0 :             debug_generic_expr (rhs1_type);
    4000                 :           0 :             debug_generic_expr (rhs2_type);
    4001                 :           0 :             return true;
    4002                 :             :           }
    4003                 :             : 
    4004                 :             :         return false;
    4005                 :             :       }
    4006                 :             : 
    4007                 :           0 :     case WIDEN_LSHIFT_EXPR:
    4008                 :           0 :       {
    4009                 :           0 :         if (!INTEGRAL_TYPE_P (lhs_type)
    4010                 :           0 :             || !INTEGRAL_TYPE_P (rhs1_type)
    4011                 :           0 :             || TREE_CODE (rhs2) != INTEGER_CST
    4012                 :           0 :             || (2 * TYPE_PRECISION (rhs1_type) > TYPE_PRECISION (lhs_type)))
    4013                 :             :           {
    4014                 :           0 :             error ("type mismatch in %qs", code_name);
    4015                 :           0 :             debug_generic_expr (lhs_type);
    4016                 :           0 :             debug_generic_expr (rhs1_type);
    4017                 :           0 :             debug_generic_expr (rhs2_type);
    4018                 :           0 :             return true;
    4019                 :             :           }
    4020                 :             : 
    4021                 :             :         return false;
    4022                 :             :       }
    4023                 :             : 
    4024                 :           0 :     case VEC_WIDEN_LSHIFT_HI_EXPR:
    4025                 :           0 :     case VEC_WIDEN_LSHIFT_LO_EXPR:
    4026                 :           0 :       {
    4027                 :           0 :         if (TREE_CODE (rhs1_type) != VECTOR_TYPE
    4028                 :           0 :             || TREE_CODE (lhs_type) != VECTOR_TYPE
    4029                 :           0 :             || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
    4030                 :           0 :             || !INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))
    4031                 :           0 :             || TREE_CODE (rhs2) != INTEGER_CST
    4032                 :           0 :             || (2 * TYPE_PRECISION (TREE_TYPE (rhs1_type))
    4033                 :           0 :                 > TYPE_PRECISION (TREE_TYPE (lhs_type))))
    4034                 :             :           {
    4035                 :           0 :             error ("type mismatch in %qs", code_name);
    4036                 :           0 :             debug_generic_expr (lhs_type);
    4037                 :           0 :             debug_generic_expr (rhs1_type);
    4038                 :           0 :             debug_generic_expr (rhs2_type);
    4039                 :           0 :             return true;
    4040                 :             :           }
    4041                 :             : 
    4042                 :             :         return false;
    4043                 :             :       }
    4044                 :             : 
    4045                 :   416677948 :     case PLUS_EXPR:
    4046                 :   416677948 :     case MINUS_EXPR:
    4047                 :   416677948 :       {
    4048                 :   416677948 :         tree lhs_etype = lhs_type;
    4049                 :   416677948 :         tree rhs1_etype = rhs1_type;
    4050                 :   416677948 :         tree rhs2_etype = rhs2_type;
    4051                 :   416677948 :         if (VECTOR_TYPE_P (lhs_type))
    4052                 :             :           {
    4053                 :     4340328 :             if (TREE_CODE (rhs1_type) != VECTOR_TYPE
    4054                 :     4340328 :                 || TREE_CODE (rhs2_type) != VECTOR_TYPE)
    4055                 :             :               {
    4056                 :           0 :                 error ("invalid non-vector operands to %qs", code_name);
    4057                 :           0 :                 return true;
    4058                 :             :               }
    4059                 :     4340328 :             lhs_etype = TREE_TYPE (lhs_type);
    4060                 :     4340328 :             rhs1_etype = TREE_TYPE (rhs1_type);
    4061                 :     4340328 :             rhs2_etype = TREE_TYPE (rhs2_type);
    4062                 :             :           }
    4063                 :   416677948 :         if (POINTER_TYPE_P (lhs_etype)
    4064                 :   416677948 :             || POINTER_TYPE_P (rhs1_etype)
    4065                 :   416677948 :             || POINTER_TYPE_P (rhs2_etype))
    4066                 :             :           {
    4067                 :           0 :             error ("invalid (pointer) operands %qs", code_name);
    4068                 :           0 :             return true;
    4069                 :             :           }
    4070                 :             : 
    4071                 :             :         /* Continue with generic binary expression handling.  */
    4072                 :             :         break;
    4073                 :             :       }
    4074                 :             : 
    4075                 :   141885950 :     case POINTER_PLUS_EXPR:
    4076                 :   141885950 :       {
    4077                 :   141885950 :         if (!POINTER_TYPE_P (rhs1_type)
    4078                 :   141885950 :             || !useless_type_conversion_p (lhs_type, rhs1_type)
    4079                 :   283771900 :             || !ptrofftype_p (rhs2_type))
    4080                 :             :           {
    4081                 :           0 :             error ("type mismatch in %qs", code_name);
    4082                 :           0 :             debug_generic_stmt (lhs_type);
    4083                 :           0 :             debug_generic_stmt (rhs1_type);
    4084                 :           0 :             debug_generic_stmt (rhs2_type);
    4085                 :           0 :             return true;
    4086                 :             :           }
    4087                 :             : 
    4088                 :             :         return false;
    4089                 :             :       }
    4090                 :             : 
    4091                 :    13128647 :     case POINTER_DIFF_EXPR:
    4092                 :    13128647 :       {
    4093                 :    13128647 :         if (!POINTER_TYPE_P (rhs1_type)
    4094                 :    13128647 :             || !POINTER_TYPE_P (rhs2_type)
    4095                 :             :             /* Because we special-case pointers to void we allow difference
    4096                 :             :                of arbitrary pointers with the same mode.  */
    4097                 :    13128647 :             || TYPE_MODE (rhs1_type) != TYPE_MODE (rhs2_type)
    4098                 :    13128647 :             || !INTEGRAL_TYPE_P (lhs_type)
    4099                 :    13128647 :             || TYPE_UNSIGNED (lhs_type)
    4100                 :    26257294 :             || TYPE_PRECISION (lhs_type) != TYPE_PRECISION (rhs1_type))
    4101                 :             :           {
    4102                 :           0 :             error ("type mismatch in %qs", code_name);
    4103                 :           0 :             debug_generic_stmt (lhs_type);
    4104                 :           0 :             debug_generic_stmt (rhs1_type);
    4105                 :           0 :             debug_generic_stmt (rhs2_type);
    4106                 :           0 :             return true;
    4107                 :             :           }
    4108                 :             : 
    4109                 :             :         return false;
    4110                 :             :       }
    4111                 :             : 
    4112                 :           0 :     case TRUTH_ANDIF_EXPR:
    4113                 :           0 :     case TRUTH_ORIF_EXPR:
    4114                 :           0 :     case TRUTH_AND_EXPR:
    4115                 :           0 :     case TRUTH_OR_EXPR:
    4116                 :           0 :     case TRUTH_XOR_EXPR:
    4117                 :             : 
    4118                 :           0 :       gcc_unreachable ();
    4119                 :             : 
    4120                 :    79388322 :     case LT_EXPR:
    4121                 :    79388322 :     case LE_EXPR:
    4122                 :    79388322 :     case GT_EXPR:
    4123                 :    79388322 :     case GE_EXPR:
    4124                 :    79388322 :     case EQ_EXPR:
    4125                 :    79388322 :     case NE_EXPR:
    4126                 :    79388322 :     case UNORDERED_EXPR:
    4127                 :    79388322 :     case ORDERED_EXPR:
    4128                 :    79388322 :     case UNLT_EXPR:
    4129                 :    79388322 :     case UNLE_EXPR:
    4130                 :    79388322 :     case UNGT_EXPR:
    4131                 :    79388322 :     case UNGE_EXPR:
    4132                 :    79388322 :     case UNEQ_EXPR:
    4133                 :    79388322 :     case LTGT_EXPR:
    4134                 :             :       /* Comparisons are also binary, but the result type is not
    4135                 :             :          connected to the operand types.  */
    4136                 :    79388322 :       return verify_gimple_comparison (lhs_type, rhs1, rhs2, rhs_code);
    4137                 :             : 
    4138                 :      129480 :     case WIDEN_MULT_EXPR:
    4139                 :      129480 :       if (TREE_CODE (lhs_type) != INTEGER_TYPE)
    4140                 :             :         return true;
    4141                 :      129480 :       return ((2 * TYPE_PRECISION (rhs1_type) > TYPE_PRECISION (lhs_type))
    4142                 :      129480 :               || (TYPE_PRECISION (rhs1_type) != TYPE_PRECISION (rhs2_type)));
    4143                 :             : 
    4144                 :           0 :     case WIDEN_SUM_EXPR:
    4145                 :           0 :       {
    4146                 :           0 :         if (((TREE_CODE (rhs1_type) != VECTOR_TYPE
    4147                 :           0 :               || TREE_CODE (lhs_type) != VECTOR_TYPE)
    4148                 :           0 :              && ((!INTEGRAL_TYPE_P (rhs1_type)
    4149                 :           0 :                   && !SCALAR_FLOAT_TYPE_P (rhs1_type))
    4150                 :           0 :                  || (!INTEGRAL_TYPE_P (lhs_type)
    4151                 :           0 :                      && !SCALAR_FLOAT_TYPE_P (lhs_type))))
    4152                 :           0 :             || !useless_type_conversion_p (lhs_type, rhs2_type)
    4153                 :           0 :             || maybe_lt (GET_MODE_SIZE (element_mode (rhs2_type)),
    4154                 :           0 :                          2 * GET_MODE_SIZE (element_mode (rhs1_type))))
    4155                 :             :           {
    4156                 :           0 :             error ("type mismatch in %qs", code_name);
    4157                 :           0 :             debug_generic_expr (lhs_type);
    4158                 :           0 :             debug_generic_expr (rhs1_type);
    4159                 :           0 :             debug_generic_expr (rhs2_type);
    4160                 :           0 :             return true;
    4161                 :             :           }
    4162                 :             :         return false;
    4163                 :             :       }
    4164                 :             : 
    4165                 :       35772 :     case VEC_WIDEN_MULT_HI_EXPR:
    4166                 :       35772 :     case VEC_WIDEN_MULT_LO_EXPR:
    4167                 :       35772 :     case VEC_WIDEN_MULT_EVEN_EXPR:
    4168                 :       35772 :     case VEC_WIDEN_MULT_ODD_EXPR:
    4169                 :       35772 :       {
    4170                 :       35772 :         if (TREE_CODE (rhs1_type) != VECTOR_TYPE
    4171                 :       35772 :             || TREE_CODE (lhs_type) != VECTOR_TYPE
    4172                 :       35772 :             || !types_compatible_p (rhs1_type, rhs2_type)
    4173                 :      107316 :             || maybe_ne (GET_MODE_SIZE (element_mode (lhs_type)),
    4174                 :       71544 :                          2 * GET_MODE_SIZE (element_mode (rhs1_type))))
    4175                 :             :           {
    4176                 :           0 :             error ("type mismatch in %qs", code_name);
    4177                 :           0 :             debug_generic_expr (lhs_type);
    4178                 :           0 :             debug_generic_expr (rhs1_type);
    4179                 :           0 :             debug_generic_expr (rhs2_type);
    4180                 :           0 :             return true;
    4181                 :             :           }
    4182                 :             :         return false;
    4183                 :             :       }
    4184                 :             : 
    4185                 :      411599 :     case VEC_PACK_TRUNC_EXPR:
    4186                 :             :       /* ???  We currently use VEC_PACK_TRUNC_EXPR to simply concat
    4187                 :             :          vector boolean types.  */
    4188                 :      411599 :       if (VECTOR_BOOLEAN_TYPE_P (lhs_type)
    4189                 :       41416 :           && VECTOR_BOOLEAN_TYPE_P (rhs1_type)
    4190                 :       41416 :           && types_compatible_p (rhs1_type, rhs2_type)
    4191                 :      823198 :           && known_eq (TYPE_VECTOR_SUBPARTS (lhs_type),
    4192                 :             :                        2 * TYPE_VECTOR_SUBPARTS (rhs1_type)))
    4193                 :       41416 :         return false;
    4194                 :             : 
    4195                 :             :       /* Fallthru.  */
    4196                 :      379957 :     case VEC_PACK_SAT_EXPR:
    4197                 :      379957 :     case VEC_PACK_FIX_TRUNC_EXPR:
    4198                 :      379957 :       {
    4199                 :      379957 :         if (TREE_CODE (rhs1_type) != VECTOR_TYPE
    4200                 :      379957 :             || TREE_CODE (lhs_type) != VECTOR_TYPE
    4201                 :      750140 :             || !((rhs_code == VEC_PACK_FIX_TRUNC_EXPR
    4202                 :        9774 :                   && SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type))
    4203                 :        9774 :                   && INTEGRAL_TYPE_P (TREE_TYPE (lhs_type)))
    4204                 :      370183 :                  || (INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
    4205                 :      370183 :                      == INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))))
    4206                 :      379957 :             || !types_compatible_p (rhs1_type, rhs2_type)
    4207                 :      759914 :             || maybe_ne (GET_MODE_SIZE (element_mode (rhs1_type)),
    4208                 :      759914 :                          2 * GET_MODE_SIZE (element_mode (lhs_type)))
    4209                 :      759914 :             || maybe_ne (2 * TYPE_VECTOR_SUBPARTS (rhs1_type),
    4210                 :      759914 :                          TYPE_VECTOR_SUBPARTS (lhs_type)))
    4211                 :             :           {
    4212                 :           0 :             error ("type mismatch in %qs", code_name);
    4213                 :           0 :             debug_generic_expr (lhs_type);
    4214                 :           0 :             debug_generic_expr (rhs1_type);
    4215                 :           0 :             debug_generic_expr (rhs2_type);
    4216                 :           0 :             return true;
    4217                 :             :           }
    4218                 :             : 
    4219                 :             :         return false;
    4220                 :             :       }
    4221                 :             : 
    4222                 :        1012 :     case VEC_PACK_FLOAT_EXPR:
    4223                 :        1012 :       if (TREE_CODE (rhs1_type) != VECTOR_TYPE
    4224                 :        1012 :           || TREE_CODE (lhs_type) != VECTOR_TYPE
    4225                 :        1012 :           || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
    4226                 :        1012 :           || !SCALAR_FLOAT_TYPE_P (TREE_TYPE (lhs_type))
    4227                 :        1012 :           || !types_compatible_p (rhs1_type, rhs2_type)
    4228                 :        2024 :           || maybe_ne (GET_MODE_SIZE (element_mode (rhs1_type)),
    4229                 :        2024 :                        2 * GET_MODE_SIZE (element_mode (lhs_type)))
    4230                 :        2024 :           || maybe_ne (2 * TYPE_VECTOR_SUBPARTS (rhs1_type),
    4231                 :        2024 :                        TYPE_VECTOR_SUBPARTS (lhs_type)))
    4232                 :             :         {
    4233                 :           0 :           error ("type mismatch in %qs", code_name);
    4234                 :           0 :           debug_generic_expr (lhs_type);
    4235                 :           0 :           debug_generic_expr (rhs1_type);
    4236                 :           0 :           debug_generic_expr (rhs2_type);
    4237                 :           0 :           return true;
    4238                 :             :         }
    4239                 :             : 
    4240                 :             :       return false;
    4241                 :             : 
    4242                 :   188980881 :     case MULT_EXPR:
    4243                 :   188980881 :     case MULT_HIGHPART_EXPR:
    4244                 :   188980881 :     case TRUNC_DIV_EXPR:
    4245                 :   188980881 :     case CEIL_DIV_EXPR:
    4246                 :   188980881 :     case FLOOR_DIV_EXPR:
    4247                 :   188980881 :     case ROUND_DIV_EXPR:
    4248                 :   188980881 :     case TRUNC_MOD_EXPR:
    4249                 :   188980881 :     case CEIL_MOD_EXPR:
    4250                 :   188980881 :     case FLOOR_MOD_EXPR:
    4251                 :   188980881 :     case ROUND_MOD_EXPR:
    4252                 :   188980881 :     case RDIV_EXPR:
    4253                 :   188980881 :     case EXACT_DIV_EXPR:
    4254                 :   188980881 :     case BIT_IOR_EXPR:
    4255                 :   188980881 :     case BIT_XOR_EXPR:
    4256                 :             :       /* Disallow pointer and offset types for many of the binary gimple. */
    4257                 :   188980881 :       if (POINTER_TYPE_P (lhs_type)
    4258                 :   188980881 :           || TREE_CODE (lhs_type) == OFFSET_TYPE)
    4259                 :             :         {
    4260                 :           0 :           error ("invalid types for %qs", code_name);
    4261                 :           0 :           debug_generic_expr (lhs_type);
    4262                 :           0 :           debug_generic_expr (rhs1_type);
    4263                 :           0 :           debug_generic_expr (rhs2_type);
    4264                 :           0 :           return true;
    4265                 :             :         }
    4266                 :             :       /* Continue with generic binary expression handling.  */
    4267                 :             :       break;
    4268                 :             : 
    4269                 :             :     case MIN_EXPR:
    4270                 :             :     case MAX_EXPR:
    4271                 :             :       /* Continue with generic binary expression handling.  */
    4272                 :             :       break;
    4273                 :             : 
    4274                 :    49451130 :     case BIT_AND_EXPR:
    4275                 :    49451130 :       if (POINTER_TYPE_P (lhs_type)
    4276                 :      173450 :           && TREE_CODE (rhs2) == INTEGER_CST)
    4277                 :             :         break;
    4278                 :             :       /* Disallow pointer and offset types for many of the binary gimple. */
    4279                 :    49277680 :       if (POINTER_TYPE_P (lhs_type)
    4280                 :    49277680 :           || TREE_CODE (lhs_type) == OFFSET_TYPE)
    4281                 :             :         {
    4282                 :           0 :           error ("invalid types for %qs", code_name);
    4283                 :           0 :           debug_generic_expr (lhs_type);
    4284                 :           0 :           debug_generic_expr (rhs1_type);
    4285                 :           0 :           debug_generic_expr (rhs2_type);
    4286                 :           0 :           return true;
    4287                 :             :         }
    4288                 :             :       /* Continue with generic binary expression handling.  */
    4289                 :             :       break;
    4290                 :             : 
    4291                 :           0 :     case VEC_SERIES_EXPR:
    4292                 :           0 :       if (!useless_type_conversion_p (rhs1_type, rhs2_type))
    4293                 :             :         {
    4294                 :           0 :           error ("type mismatch in %qs", code_name);
    4295                 :           0 :           debug_generic_expr (rhs1_type);
    4296                 :           0 :           debug_generic_expr (rhs2_type);
    4297                 :           0 :           return true;
    4298                 :             :         }
    4299                 :           0 :       if (TREE_CODE (lhs_type) != VECTOR_TYPE
    4300                 :           0 :           || !useless_type_conversion_p (TREE_TYPE (lhs_type), rhs1_type))
    4301                 :             :         {
    4302                 :           0 :           error ("vector type expected in %qs", code_name);
    4303                 :           0 :           debug_generic_expr (lhs_type);
    4304                 :           0 :           return true;
    4305                 :             :         }
    4306                 :             :       return false;
    4307                 :             : 
    4308                 :           0 :     default:
    4309                 :           0 :       gcc_unreachable ();
    4310                 :             :     }
    4311                 :             : 
    4312                 :   667766761 :   if (!useless_type_conversion_p (lhs_type, rhs1_type)
    4313                 :   667766761 :       || !useless_type_conversion_p (lhs_type, rhs2_type))
    4314                 :             :     {
    4315                 :           0 :       error ("type mismatch in binary expression");
    4316                 :           0 :       debug_generic_stmt (lhs_type);
    4317                 :           0 :       debug_generic_stmt (rhs1_type);
    4318                 :           0 :       debug_generic_stmt (rhs2_type);
    4319                 :           0 :       return true;
    4320                 :             :     }
    4321                 :             : 
    4322                 :             :   return false;
    4323                 :             : }
    4324                 :             : 
    4325                 :             : /* Verify a gimple assignment statement STMT with a ternary rhs.
    4326                 :             :    Returns true if anything is wrong.  */
    4327                 :             : 
    4328                 :             : static bool
    4329                 :     8548175 : verify_gimple_assign_ternary (gassign *stmt)
    4330                 :             : {
    4331                 :     8548175 :   enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
    4332                 :     8548175 :   tree lhs = gimple_assign_lhs (stmt);
    4333                 :     8548175 :   tree lhs_type = TREE_TYPE (lhs);
    4334                 :     8548175 :   tree rhs1 = gimple_assign_rhs1 (stmt);
    4335                 :     8548175 :   tree rhs1_type = TREE_TYPE (rhs1);
    4336                 :     8548175 :   tree rhs2 = gimple_assign_rhs2 (stmt);
    4337                 :     8548175 :   tree rhs2_type = TREE_TYPE (rhs2);
    4338                 :     8548175 :   tree rhs3 = gimple_assign_rhs3 (stmt);
    4339                 :     8548175 :   tree rhs3_type = TREE_TYPE (rhs3);
    4340                 :             : 
    4341                 :     8548175 :   if (!is_gimple_reg (lhs))
    4342                 :             :     {
    4343                 :           0 :       error ("non-register as LHS of ternary operation");
    4344                 :           0 :       return true;
    4345                 :             :     }
    4346                 :             : 
    4347                 :     8548175 :   if (!is_gimple_val (rhs1)
    4348                 :     8548175 :       || !is_gimple_val (rhs2)
    4349                 :    17096350 :       || !is_gimple_val (rhs3))
    4350                 :             :     {
    4351                 :           0 :       error ("invalid operands in ternary operation");
    4352                 :           0 :       return true;
    4353                 :             :     }
    4354                 :             : 
    4355                 :     8548175 :   const char* const code_name = get_tree_code_name (rhs_code);
    4356                 :             : 
    4357                 :             :   /* First handle operations that involve different types.  */
    4358                 :     8548175 :   switch (rhs_code)
    4359                 :             :     {
    4360                 :           0 :     case WIDEN_MULT_PLUS_EXPR:
    4361                 :           0 :     case WIDEN_MULT_MINUS_EXPR:
    4362                 :           0 :       if ((!INTEGRAL_TYPE_P (rhs1_type)
    4363                 :           0 :            && !FIXED_POINT_TYPE_P (rhs1_type))
    4364                 :           0 :           || !useless_type_conversion_p (rhs1_type, rhs2_type)
    4365                 :           0 :           || !useless_type_conversion_p (lhs_type, rhs3_type)
    4366                 :           0 :           || 2 * TYPE_PRECISION (rhs1_type) > TYPE_PRECISION (lhs_type)
    4367                 :           0 :           || TYPE_PRECISION (rhs1_type) != TYPE_PRECISION (rhs2_type))
    4368                 :             :         {
    4369                 :           0 :           error ("type mismatch in %qs", code_name);
    4370                 :           0 :           debug_generic_expr (lhs_type);
    4371                 :           0 :           debug_generic_expr (rhs1_type);
    4372                 :           0 :           debug_generic_expr (rhs2_type);
    4373                 :           0 :           debug_generic_expr (rhs3_type);
    4374                 :           0 :           return true;
    4375                 :             :         }
    4376                 :             :       break;
    4377                 :             : 
    4378                 :     1072828 :     case VEC_COND_EXPR:
    4379                 :     1072828 :       if (!VECTOR_BOOLEAN_TYPE_P (rhs1_type)
    4380                 :     2145656 :           || maybe_ne (TYPE_VECTOR_SUBPARTS (rhs1_type),
    4381                 :     2145656 :                        TYPE_VECTOR_SUBPARTS (lhs_type)))
    4382                 :             :         {
    4383                 :           0 :           error ("the first argument of a %qs must be of a "
    4384                 :             :                  "boolean vector type of the same number of elements "
    4385                 :             :                  "as the result", code_name);
    4386                 :           0 :           debug_generic_expr (lhs_type);
    4387                 :           0 :           debug_generic_expr (rhs1_type);
    4388                 :           0 :           return true;
    4389                 :             :         }
    4390                 :             :       /* Fallthrough.  */
    4391                 :     2104509 :     case COND_EXPR:
    4392                 :     2104509 :       if (!useless_type_conversion_p (lhs_type, rhs2_type)
    4393                 :     2104509 :           || !useless_type_conversion_p (lhs_type, rhs3_type))
    4394                 :             :         {
    4395                 :           0 :           error ("type mismatch in %qs", code_name);
    4396                 :           0 :           debug_generic_expr (lhs_type);
    4397                 :           0 :           debug_generic_expr (rhs2_type);
    4398                 :           0 :           debug_generic_expr (rhs3_type);
    4399                 :           0 :           return true;
    4400                 :             :         }
    4401                 :             :       break;
    4402                 :             : 
    4403                 :     6342809 :     case VEC_PERM_EXPR:
    4404                 :             :       /* If permute is constant, then we allow for lhs and rhs
    4405                 :             :          to have different vector types, provided:
    4406                 :             :          (1) lhs, rhs1, rhs2 have same element type.
    4407                 :             :          (2) rhs3 vector is constant and has integer element type.
    4408                 :             :          (3) len(lhs) == len(rhs3) && len(rhs1) == len(rhs2).  */
    4409                 :             : 
    4410                 :     6342809 :       if (TREE_CODE (lhs_type) != VECTOR_TYPE
    4411                 :     6342809 :           || TREE_CODE (rhs1_type) != VECTOR_TYPE
    4412                 :     6342809 :           || TREE_CODE (rhs2_type) != VECTOR_TYPE
    4413                 :     6342809 :           || TREE_CODE (rhs3_type) != VECTOR_TYPE)
    4414                 :             :         {
    4415                 :           0 :           error ("vector types expected in %qs", code_name);
    4416                 :           0 :           debug_generic_expr (lhs_type);
    4417                 :           0 :           debug_generic_expr (rhs1_type);
    4418                 :           0 :           debug_generic_expr (rhs2_type);
    4419                 :           0 :           debug_generic_expr (rhs3_type);
    4420                 :           0 :           return true;
    4421                 :             :         }
    4422                 :             : 
    4423                 :             :       /* If rhs3 is constant, we allow lhs, rhs1 and rhs2 to be different vector types,
    4424                 :             :          as long as lhs, rhs1 and rhs2 have same element type.  */
    4425                 :     6342809 :       if (TREE_CONSTANT (rhs3)
    4426                 :     6342809 :           ? (!useless_type_conversion_p (TREE_TYPE (lhs_type), TREE_TYPE (rhs1_type))
    4427                 :     6229930 :              || !useless_type_conversion_p (TREE_TYPE (lhs_type), TREE_TYPE (rhs2_type)))
    4428                 :      112879 :           : (!useless_type_conversion_p (lhs_type, rhs1_type)
    4429                 :      112879 :              || !useless_type_conversion_p (lhs_type, rhs2_type)))
    4430                 :             :         {
    4431                 :           0 :             error ("type mismatch in %qs", code_name);
    4432                 :           0 :             debug_generic_expr (lhs_type);
    4433                 :           0 :             debug_generic_expr (rhs1_type);
    4434                 :           0 :             debug_generic_expr (rhs2_type);
    4435                 :           0 :             debug_generic_expr (rhs3_type);
    4436                 :           0 :             return true;
    4437                 :             :         }
    4438                 :             : 
    4439                 :             :       /* If rhs3 is constant, relax the check len(rhs2) == len(rhs3).  */
    4440                 :     6342809 :       if (maybe_ne (TYPE_VECTOR_SUBPARTS (rhs1_type),
    4441                 :     6342809 :                     TYPE_VECTOR_SUBPARTS (rhs2_type))
    4442                 :     6342809 :           || (!TREE_CONSTANT(rhs3)
    4443                 :      112879 :               && maybe_ne (TYPE_VECTOR_SUBPARTS (rhs2_type),
    4444                 :      112879 :                            TYPE_VECTOR_SUBPARTS (rhs3_type)))
    4445                 :    12685618 :           || maybe_ne (TYPE_VECTOR_SUBPARTS (rhs3_type),
    4446                 :     6342809 :                        TYPE_VECTOR_SUBPARTS (lhs_type)))
    4447                 :             :         {
    4448                 :           0 :           error ("vectors with different element number found in %qs",
    4449                 :             :                  code_name);
    4450                 :           0 :           debug_generic_expr (lhs_type);
    4451                 :           0 :           debug_generic_expr (rhs1_type);
    4452                 :           0 :           debug_generic_expr (rhs2_type);
    4453                 :           0 :           debug_generic_expr (rhs3_type);
    4454                 :           0 :           return true;
    4455                 :             :         }
    4456                 :             : 
    4457                 :     6342809 :       if (TREE_CODE (TREE_TYPE (rhs3_type)) != INTEGER_TYPE
    4458                 :     6342809 :           || (TREE_CODE (rhs3) != VECTOR_CST
    4459                 :      112879 :               && (GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE
    4460                 :             :                                     (TREE_TYPE (rhs3_type)))
    4461                 :     6455688 :                   != GET_MODE_BITSIZE (SCALAR_TYPE_MODE
    4462                 :             :                                        (TREE_TYPE (rhs1_type))))))
    4463                 :             :         {
    4464                 :           0 :           error ("invalid mask type in %qs", code_name);
    4465                 :           0 :           debug_generic_expr (lhs_type);
    4466                 :           0 :           debug_generic_expr (rhs1_type);
    4467                 :           0 :           debug_generic_expr (rhs2_type);
    4468                 :           0 :           debug_generic_expr (rhs3_type);
    4469                 :           0 :           return true;
    4470                 :             :         }
    4471                 :             : 
    4472                 :             :       return false;
    4473                 :             : 
    4474                 :        4510 :     case SAD_EXPR:
    4475                 :        4510 :       if (!useless_type_conversion_p (rhs1_type, rhs2_type)
    4476                 :        4510 :           || !useless_type_conversion_p (lhs_type, rhs3_type)
    4477                 :        9020 :           || 2 * GET_MODE_UNIT_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type)))
    4478                 :        9020 :                > GET_MODE_UNIT_BITSIZE (TYPE_MODE (TREE_TYPE (lhs_type))))
    4479                 :             :         {
    4480                 :           0 :           error ("type mismatch in %qs", code_name);
    4481                 :           0 :           debug_generic_expr (lhs_type);
    4482                 :           0 :           debug_generic_expr (rhs1_type);
    4483                 :           0 :           debug_generic_expr (rhs2_type);
    4484                 :           0 :           debug_generic_expr (rhs3_type);
    4485                 :           0 :           return true;
    4486                 :             :         }
    4487                 :             : 
    4488                 :        4510 :       if (TREE_CODE (rhs1_type) != VECTOR_TYPE
    4489                 :        4510 :           || TREE_CODE (rhs2_type) != VECTOR_TYPE
    4490                 :        4510 :           || TREE_CODE (rhs3_type) != VECTOR_TYPE)
    4491                 :             :         {
    4492                 :           0 :           error ("vector types expected in %qs", code_name);
    4493                 :           0 :           debug_generic_expr (lhs_type);
    4494                 :           0 :           debug_generic_expr (rhs1_type);
    4495                 :           0 :           debug_generic_expr (rhs2_type);
    4496                 :           0 :           debug_generic_expr (rhs3_type);
    4497                 :           0 :           return true;
    4498                 :             :         }
    4499                 :             : 
    4500                 :             :       return false;
    4501                 :             : 
    4502                 :       86965 :     case BIT_INSERT_EXPR:
    4503                 :       86965 :       if (! useless_type_conversion_p (lhs_type, rhs1_type))
    4504                 :             :         {
    4505                 :           0 :           error ("type mismatch in %qs", code_name);
    4506                 :           0 :           debug_generic_expr (lhs_type);
    4507                 :           0 :           debug_generic_expr (rhs1_type);
    4508                 :           0 :           return true;
    4509                 :             :         }
    4510                 :       86965 :       if (! ((INTEGRAL_TYPE_P (rhs1_type)
    4511                 :        3263 :               && INTEGRAL_TYPE_P (rhs2_type))
    4512                 :             :              /* Vector element insert.  */
    4513                 :       83702 :              || (VECTOR_TYPE_P (rhs1_type)
    4514                 :       83702 :                  && types_compatible_p (TREE_TYPE (rhs1_type), rhs2_type))
    4515                 :             :              /* Aligned sub-vector insert.  */
    4516                 :        4290 :              || (VECTOR_TYPE_P (rhs1_type)
    4517                 :        4290 :                  && VECTOR_TYPE_P (rhs2_type)
    4518                 :        4290 :                  && types_compatible_p (TREE_TYPE (rhs1_type),
    4519                 :        4290 :                                         TREE_TYPE (rhs2_type))
    4520                 :        4290 :                  && multiple_p (TYPE_VECTOR_SUBPARTS (rhs1_type),
    4521                 :        4290 :                                 TYPE_VECTOR_SUBPARTS (rhs2_type))
    4522                 :        4290 :                  && multiple_p (wi::to_poly_offset (rhs3),
    4523                 :        4290 :                                 wi::to_poly_offset (TYPE_SIZE (rhs2_type))))))
    4524                 :             :         {
    4525                 :           0 :           error ("not allowed type combination in %qs", code_name);
    4526                 :           0 :           debug_generic_expr (rhs1_type);
    4527                 :           0 :           debug_generic_expr (rhs2_type);
    4528                 :           0 :           return true;
    4529                 :             :         }
    4530                 :       86965 :       if (! tree_fits_uhwi_p (rhs3)
    4531                 :       86965 :           || ! types_compatible_p (bitsizetype, TREE_TYPE (rhs3))
    4532                 :      173930 :           || ! tree_fits_uhwi_p (TYPE_SIZE (rhs2_type)))
    4533                 :             :         {
    4534                 :           0 :           error ("invalid position or size in %qs", code_name);
    4535                 :           0 :           return true;
    4536                 :             :         }
    4537                 :       86965 :       if (INTEGRAL_TYPE_P (rhs1_type)
    4538                 :       86965 :           && !type_has_mode_precision_p (rhs1_type))
    4539                 :             :         {
    4540                 :           0 :           error ("%qs into non-mode-precision operand", code_name);
    4541                 :           0 :           return true;
    4542                 :             :         }
    4543                 :       86965 :       if (INTEGRAL_TYPE_P (rhs1_type))
    4544                 :             :         {
    4545                 :        3263 :           unsigned HOST_WIDE_INT bitpos = tree_to_uhwi (rhs3);
    4546                 :        3263 :           if (bitpos >= TYPE_PRECISION (rhs1_type)
    4547                 :        3263 :               || (bitpos + TYPE_PRECISION (rhs2_type)
    4548                 :        3263 :                   > TYPE_PRECISION (rhs1_type)))
    4549                 :             :             {
    4550                 :           0 :               error ("insertion out of range in %qs", code_name);
    4551                 :           0 :               return true;
    4552                 :             :             }
    4553                 :             :         }
    4554                 :       83702 :       else if (VECTOR_TYPE_P (rhs1_type))
    4555                 :             :         {
    4556                 :       83702 :           unsigned HOST_WIDE_INT bitpos = tree_to_uhwi (rhs3);
    4557                 :       83702 :           unsigned HOST_WIDE_INT bitsize = tree_to_uhwi (TYPE_SIZE (rhs2_type));
    4558                 :       83702 :           if (bitpos % bitsize != 0)
    4559                 :             :             {
    4560                 :           0 :               error ("%qs not at element boundary", code_name);
    4561                 :           0 :               return true;
    4562                 :             :             }
    4563                 :             :         }
    4564                 :             :       return false;
    4565                 :             : 
    4566                 :        9382 :     case DOT_PROD_EXPR:
    4567                 :        9382 :       {
    4568                 :        9382 :         if (((TREE_CODE (rhs1_type) != VECTOR_TYPE
    4569                 :        9382 :               || TREE_CODE (lhs_type) != VECTOR_TYPE)
    4570                 :           0 :              && ((!INTEGRAL_TYPE_P (rhs1_type)
    4571                 :           0 :                   && !SCALAR_FLOAT_TYPE_P (rhs1_type))
    4572                 :           0 :                  || (!INTEGRAL_TYPE_P (lhs_type)
    4573                 :           0 :                      && !SCALAR_FLOAT_TYPE_P (lhs_type))))
    4574                 :             :             /* rhs1_type and rhs2_type may differ in sign.  */
    4575                 :        9382 :             || !tree_nop_conversion_p (rhs1_type, rhs2_type)
    4576                 :        9382 :             || !useless_type_conversion_p (lhs_type, rhs3_type)
    4577                 :       28146 :             || maybe_lt (GET_MODE_SIZE (element_mode (rhs3_type)),
    4578                 :       18764 :                          2 * GET_MODE_SIZE (element_mode (rhs1_type))))
    4579                 :             :           {
    4580                 :           0 :             error ("type mismatch in %qs", code_name);
    4581                 :           0 :             debug_generic_expr (lhs_type);
    4582                 :           0 :             debug_generic_expr (rhs1_type);
    4583                 :           0 :             debug_generic_expr (rhs2_type);
    4584                 :           0 :             return true;
    4585                 :             :           }
    4586                 :             :         return false;
    4587                 :             :       }
    4588                 :             : 
    4589                 :             :     case REALIGN_LOAD_EXPR:
    4590                 :             :       /* FIXME.  */
    4591                 :             :       return false;
    4592                 :             : 
    4593                 :           0 :     default:
    4594                 :           0 :       gcc_unreachable ();
    4595                 :             :     }
    4596                 :             :   return false;
    4597                 :             : }
    4598                 :             : 
    4599                 :             : /* Verify a gimple assignment statement STMT with a single rhs.
    4600                 :             :    Returns true if anything is wrong.  */
    4601                 :             : 
    4602                 :             : static bool
    4603                 :  2883482528 : verify_gimple_assign_single (gassign *stmt)
    4604                 :             : {
    4605                 :  2883482528 :   enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
    4606                 :  2883482528 :   tree lhs = gimple_assign_lhs (stmt);
    4607                 :  2883482528 :   tree lhs_type = TREE_TYPE (lhs);
    4608                 :  2883482528 :   tree rhs1 = gimple_assign_rhs1 (stmt);
    4609                 :  2883482528 :   tree rhs1_type = TREE_TYPE (rhs1);
    4610                 :  2883482528 :   bool res = false;
    4611                 :             : 
    4612                 :  2883482528 :   const char* const code_name = get_tree_code_name (rhs_code);
    4613                 :             : 
    4614                 :  2883482528 :   if (!useless_type_conversion_p (lhs_type, rhs1_type))
    4615                 :             :     {
    4616                 :           6 :       error ("non-trivial conversion in %qs", code_name);
    4617                 :           6 :       debug_generic_expr (lhs_type);
    4618                 :           6 :       debug_generic_expr (rhs1_type);
    4619                 :           6 :       return true;
    4620                 :             :     }
    4621                 :             : 
    4622                 :  2883482522 :   if (gimple_clobber_p (stmt)
    4623                 :  2883482522 :       && !(DECL_P (lhs) || TREE_CODE (lhs) == MEM_REF))
    4624                 :             :     {
    4625                 :           0 :       error ("%qs LHS in clobber statement",
    4626                 :             :              get_tree_code_name (TREE_CODE (lhs)));
    4627                 :           0 :       debug_generic_expr (lhs);
    4628                 :           0 :       return true;
    4629                 :             :     }
    4630                 :             : 
    4631                 :  2883482522 :   if (TREE_CODE (lhs) == WITH_SIZE_EXPR)
    4632                 :             :     {
    4633                 :           0 :       error ("%qs LHS in assignment statement",
    4634                 :             :              get_tree_code_name (TREE_CODE (lhs)));
    4635                 :           0 :       debug_generic_expr (lhs);
    4636                 :           0 :       return true;
    4637                 :             :     }
    4638                 :             : 
    4639                 :  2883482522 :   if (handled_component_p (lhs)
    4640                 :  2115733879 :       || TREE_CODE (lhs) == MEM_REF
    4641                 :  1877840090 :       || TREE_CODE (lhs) == TARGET_MEM_REF)
    4642                 :  1013953456 :     res |= verify_types_in_gimple_reference (lhs, true);
    4643                 :             : 
    4644                 :             :   /* Special codes we cannot handle via their class.  */
    4645                 :  2883482522 :   switch (rhs_code)
    4646                 :             :     {
    4647                 :   240112431 :     case ADDR_EXPR:
    4648                 :   240112431 :       {
    4649                 :   240112431 :         tree op = TREE_OPERAND (rhs1, 0);
    4650                 :   240112431 :         if (!is_gimple_addressable (op))
    4651                 :             :           {
    4652                 :           0 :             error ("invalid operand in %qs", code_name);
    4653                 :           0 :             return true;
    4654                 :             :           }
    4655                 :             : 
    4656                 :             :         /* Technically there is no longer a need for matching types, but
    4657                 :             :            gimple hygiene asks for this check.  In LTO we can end up
    4658                 :             :            combining incompatible units and thus end up with addresses
    4659                 :             :            of globals that change their type to a common one.  */
    4660                 :   240112431 :         if (!in_lto_p
    4661                 :   239707272 :             && !types_compatible_p (TREE_TYPE (op),
    4662                 :   239707272 :                                     TREE_TYPE (TREE_TYPE (rhs1)))
    4663                 :   240112877 :             && !one_pointer_to_useless_type_conversion_p (TREE_TYPE (rhs1),
    4664                 :         446 :                                                           TREE_TYPE (op)))
    4665                 :             :           {
    4666                 :           0 :             error ("type mismatch in %qs", code_name);
    4667                 :           0 :             debug_generic_stmt (TREE_TYPE (rhs1));
    4668                 :           0 :             debug_generic_stmt (TREE_TYPE (op));
    4669                 :           0 :             return true;
    4670                 :             :           }
    4671                 :             : 
    4672                 :   240112431 :         return (verify_address (rhs1, true)
    4673                 :   240112431 :                 || verify_types_in_gimple_reference (op, true));
    4674                 :             :       }
    4675                 :             : 
    4676                 :             :     /* tcc_reference  */
    4677                 :           0 :     case INDIRECT_REF:
    4678                 :           0 :       error ("%qs in gimple IL", code_name);
    4679                 :           0 :       return true;
    4680                 :             : 
    4681                 :          45 :     case WITH_SIZE_EXPR:
    4682                 :          45 :       if (!is_gimple_val (TREE_OPERAND (rhs1, 1)))
    4683                 :             :         {
    4684                 :           0 :           error ("invalid %qs size argument in load", code_name);
    4685                 :           0 :           debug_generic_stmt (lhs);
    4686                 :           0 :           debug_generic_stmt (rhs1);
    4687                 :           0 :           return true;
    4688                 :             :         }
    4689                 :          45 :       rhs1 = TREE_OPERAND (rhs1, 0);
    4690                 :             :       /* Fallthru.  */
    4691                 :   989755508 :     case COMPONENT_REF:
    4692                 :   989755508 :     case BIT_FIELD_REF:
    4693                 :   989755508 :     case ARRAY_REF:
    4694                 :   989755508 :     case ARRAY_RANGE_REF:
    4695                 :   989755508 :     case VIEW_CONVERT_EXPR:
    4696                 :   989755508 :     case REALPART_EXPR:
    4697                 :   989755508 :     case IMAGPART_EXPR:
    4698                 :   989755508 :     case TARGET_MEM_REF:
    4699                 :   989755508 :     case MEM_REF:
    4700                 :   989755508 :       if (!is_gimple_reg (lhs)
    4701                 :   989755508 :           && is_gimple_reg_type (TREE_TYPE (lhs)))
    4702                 :             :         {
    4703                 :           0 :           error ("invalid RHS for gimple memory store: %qs", code_name);
    4704                 :           0 :           debug_generic_stmt (lhs);
    4705                 :           0 :           debug_generic_stmt (rhs1);
    4706                 :           0 :           return true;
    4707                 :             :         }
    4708                 :   989755508 :       return res || verify_types_in_gimple_reference (rhs1, false);
    4709                 :             : 
    4710                 :             :     /* tcc_constant  */
    4711                 :             :     case SSA_NAME:
    4712                 :             :     case INTEGER_CST:
    4713                 :             :     case REAL_CST:
    4714                 :             :     case FIXED_CST:
    4715                 :             :     case COMPLEX_CST:
    4716                 :             :     case VECTOR_CST:
    4717                 :             :     case STRING_CST:
    4718                 :             :       return res;
    4719                 :             : 
    4720                 :             :     /* tcc_declaration  */
    4721                 :             :     case CONST_DECL:
    4722                 :             :       return res;
    4723                 :   306612006 :     case VAR_DECL:
    4724                 :   306612006 :     case PARM_DECL:
    4725                 :   306612006 :       if (!is_gimple_reg (lhs)
    4726                 :    82824649 :           && !is_gimple_reg (rhs1)
    4727                 :   378570150 :           && is_gimple_reg_type (TREE_TYPE (lhs)))
    4728                 :             :         {
    4729                 :           0 :           error ("invalid RHS for gimple memory store: %qs", code_name);
    4730                 :           0 :           debug_generic_stmt (lhs);
    4731                 :           0 :           debug_generic_stmt (rhs1);
    4732                 :           0 :           return true;
    4733                 :             :         }
    4734                 :             :       return res;
    4735                 :             : 
    4736                 :   311299526 :     case CONSTRUCTOR:
    4737                 :   311299526 :       if (VECTOR_TYPE_P (rhs1_type))
    4738                 :             :         {
    4739                 :     7901371 :           unsigned int i;
    4740                 :     7901371 :           tree elt_i, elt_v, elt_t = NULL_TREE;
    4741                 :             : 
    4742                 :  1660907329 :           if (CONSTRUCTOR_NELTS (rhs1) == 0)
    4743                 :             :             return res;
    4744                 :             :           /* For vector CONSTRUCTORs we require that either it is empty
    4745                 :             :              CONSTRUCTOR, or it is a CONSTRUCTOR of smaller vector elements
    4746                 :             :              (then the element count must be correct to cover the whole
    4747                 :             :              outer vector and index must be NULL on all elements, or it is
    4748                 :             :              a CONSTRUCTOR of scalar elements, where we as an exception allow
    4749                 :             :              smaller number of elements (assuming zero filling) and
    4750                 :             :              consecutive indexes as compared to NULL indexes (such
    4751                 :             :              CONSTRUCTORs can appear in the IL from FEs).  */
    4752                 :    35126525 :           FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (rhs1), i, elt_i, elt_v)
    4753                 :             :             {
    4754                 :    27833779 :               if (elt_t == NULL_TREE)
    4755                 :             :                 {
    4756                 :     7292746 :                   elt_t = TREE_TYPE (elt_v);
    4757                 :     7292746 :                   if (VECTOR_TYPE_P (elt_t))
    4758                 :             :                     {
    4759                 :       77331 :                       tree elt_t = TREE_TYPE (elt_v);
    4760                 :       77331 :                       if (!useless_type_conversion_p (TREE_TYPE (rhs1_type),
    4761                 :       77331 :                                                       TREE_TYPE (elt_t)))
    4762                 :             :                         {
    4763                 :           0 :                           error ("incorrect type of vector %qs elements",
    4764                 :             :                                  code_name);
    4765                 :           0 :                           debug_generic_stmt (rhs1);
    4766                 :           0 :                           return true;
    4767                 :             :                         }
    4768                 :      154662 :                       else if (maybe_ne (CONSTRUCTOR_NELTS (rhs1)
    4769                 :      154662 :                                          * TYPE_VECTOR_SUBPARTS (elt_t),
    4770                 :      154662 :                                          TYPE_VECTOR_SUBPARTS (rhs1_type)))
    4771                 :             :                         {
    4772                 :           0 :                           error ("incorrect number of vector %qs elements",
    4773                 :             :                                  code_name);
    4774                 :           0 :                           debug_generic_stmt (rhs1);
    4775                 :           0 :                           return true;
    4776                 :             :                         }
    4777                 :             :                     }
    4778                 :     7215415 :                   else if (!useless_type_conversion_p (TREE_TYPE (rhs1_type),
    4779                 :             :                                                        elt_t))
    4780                 :             :                     {
    4781                 :           0 :                       error ("incorrect type of vector %qs elements",
    4782                 :             :                              code_name);
    4783                 :           0 :                       debug_generic_stmt (rhs1);
    4784                 :           0 :                       return true;
    4785                 :             :                     }
    4786                 :    14430830 :                   else if (maybe_gt (CONSTRUCTOR_NELTS (rhs1),
    4787                 :             :                                      TYPE_VECTOR_SUBPARTS (rhs1_type)))
    4788                 :             :                     {
    4789                 :           0 :                       error ("incorrect number of vector %qs elements",
    4790                 :             :                              code_name);
    4791                 :           0 :                       debug_generic_stmt (rhs1);
    4792                 :           0 :                       return true;
    4793                 :             :                     }
    4794                 :             :                 }
    4795                 :    20541033 :               else if (!useless_type_conversion_p (elt_t, TREE_TYPE (elt_v)))
    4796                 :             :                 {
    4797                 :           0 :                   error ("incorrect type of vector CONSTRUCTOR elements");
    4798                 :           0 :                   debug_generic_stmt (rhs1);
    4799                 :           0 :                   return true;
    4800                 :             :                 }
    4801                 :    27833779 :               if (elt_i != NULL_TREE
    4802                 :    27833779 :                   && (VECTOR_TYPE_P (elt_t)
    4803                 :     5816918 :                       || TREE_CODE (elt_i) != INTEGER_CST
    4804                 :     5816918 :                       || compare_tree_int (elt_i, i) != 0))
    4805                 :             :                 {
    4806                 :           0 :                   error ("vector %qs with non-NULL element index",
    4807                 :             :                          code_name);
    4808                 :           0 :                   debug_generic_stmt (rhs1);
    4809                 :           0 :                   return true;
    4810                 :             :                 }
    4811                 :    27833779 :               if (!is_gimple_val (elt_v))
    4812                 :             :                 {
    4813                 :           0 :                   error ("vector %qs element is not a GIMPLE value",
    4814                 :             :                          code_name);
    4815                 :           0 :                   debug_generic_stmt (rhs1);
    4816                 :           0 :                   return true;
    4817                 :             :                 }
    4818                 :             :             }
    4819                 :             :         }
    4820                 :   303398155 :       else if (CONSTRUCTOR_NELTS (rhs1) != 0)
    4821                 :             :         {
    4822                 :           0 :           error ("non-vector %qs with elements", code_name);
    4823                 :           0 :           debug_generic_stmt (rhs1);
    4824                 :           0 :           return true;
    4825                 :             :         }
    4826                 :             :       return res;
    4827                 :             : 
    4828                 :             :     case OBJ_TYPE_REF:
    4829                 :             :       /* FIXME.  */
    4830                 :             :       return res;
    4831                 :             : 
    4832                 :             :     default:;
    4833                 :             :     }
    4834                 :             : 
    4835                 :             :   return res;
    4836                 :             : }
    4837                 :             : 
    4838                 :             : /* Verify the contents of a GIMPLE_ASSIGN STMT.  Returns true when there
    4839                 :             :    is a problem, otherwise false.  */
    4840                 :             : 
    4841                 :             : static bool
    4842                 :  4226860549 : verify_gimple_assign (gassign *stmt)
    4843                 :             : {
    4844                 :  4226860549 :   if (gimple_assign_nontemporal_move_p (stmt))
    4845                 :             :     {
    4846                 :         612 :       tree lhs = gimple_assign_lhs (stmt);
    4847                 :         612 :       if (is_gimple_reg (lhs))
    4848                 :             :         {
    4849                 :           0 :           error ("nontemporal store lhs cannot be a gimple register");
    4850                 :           0 :           debug_generic_stmt (lhs);
    4851                 :           0 :           return true;
    4852                 :             :         }
    4853                 :             :     }
    4854                 :             : 
    4855                 :  4226860549 :   switch (gimple_assign_rhs_class (stmt))
    4856                 :             :     {
    4857                 :  2883482528 :     case GIMPLE_SINGLE_RHS:
    4858                 :  2883482528 :       return verify_gimple_assign_single (stmt);
    4859                 :             : 
    4860                 :   400258586 :     case GIMPLE_UNARY_RHS:
    4861                 :   400258586 :       return verify_gimple_assign_unary (stmt);
    4862                 :             : 
    4863                 :   934571260 :     case GIMPLE_BINARY_RHS:
    4864                 :   934571260 :       return verify_gimple_assign_binary (stmt);
    4865                 :             : 
    4866                 :     8548175 :     case GIMPLE_TERNARY_RHS:
    4867                 :     8548175 :       return verify_gimple_assign_ternary (stmt);
    4868                 :             : 
    4869                 :           0 :     default:
    4870                 :           0 :       gcc_unreachable ();
    4871                 :             :     }
    4872                 :             : }
    4873                 :             : 
    4874                 :             : /* Verify the contents of a GIMPLE_RETURN STMT.  Returns true when there
    4875                 :             :    is a problem, otherwise false.  */
    4876                 :             : 
    4877                 :             : static bool
    4878                 :   238392664 : verify_gimple_return (greturn *stmt)
    4879                 :             : {
    4880                 :   238392664 :   tree op = gimple_return_retval (stmt);
    4881                 :   238392664 :   tree restype = TREE_TYPE (TREE_TYPE (cfun->decl));
    4882                 :             : 
    4883                 :             :   /* We cannot test for present return values as we do not fix up missing
    4884                 :             :      return values from the original source.  */
    4885                 :   238392664 :   if (op == NULL)
    4886                 :             :     return false;
    4887                 :             : 
    4888                 :   133131929 :   if (!is_gimple_val (op)
    4889                 :   133131929 :       && TREE_CODE (op) != RESULT_DECL)
    4890                 :             :     {
    4891                 :           0 :       error ("invalid operand in return statement");
    4892                 :           0 :       debug_generic_stmt (op);
    4893                 :           0 :       return true;
    4894                 :             :     }
    4895                 :             : 
    4896                 :   133131929 :   if ((TREE_CODE (op) == RESULT_DECL
    4897                 :     9443731 :        && DECL_BY_REFERENCE (op))
    4898                 :   142050435 :       || (TREE_CODE (op) == SSA_NAME
    4899                 :    80552171 :           && SSA_NAME_VAR (op)
    4900                 :    12824083 :           && TREE_CODE (SSA_NAME_VAR (op)) == RESULT_DECL
    4901                 :     2162898 :           && DECL_BY_REFERENCE (SSA_NAME_VAR (op))))
    4902                 :     2688017 :     op = TREE_TYPE (op);
    4903                 :             : 
    4904                 :   133131929 :   if (!useless_type_conversion_p (restype, TREE_TYPE (op)))
    4905                 :             :     {
    4906                 :           0 :       error ("invalid conversion in return statement");
    4907                 :           0 :       debug_generic_stmt (restype);
    4908                 :           0 :       debug_generic_stmt (TREE_TYPE (op));
    4909                 :           0 :       return true;
    4910                 :             :     }
    4911                 :             : 
    4912                 :             :   return false;
    4913                 :             : }
    4914                 :             : 
    4915                 :             : 
    4916                 :             : /* Verify the contents of a GIMPLE_GOTO STMT.  Returns true when there
    4917                 :             :    is a problem, otherwise false.  */
    4918                 :             : 
    4919                 :             : static bool
    4920                 :    21989910 : verify_gimple_goto (ggoto *stmt)
    4921                 :             : {
    4922                 :    21989910 :   tree dest = gimple_goto_dest (stmt);
    4923                 :             : 
    4924                 :             :   /* ???  We have two canonical forms of direct goto destinations, a
    4925                 :             :      bare LABEL_DECL and an ADDR_EXPR of a LABEL_DECL.  */
    4926                 :    21989910 :   if (TREE_CODE (dest) != LABEL_DECL
    4927                 :    21989910 :       && (!is_gimple_val (dest)
    4928                 :       57992 :           || !POINTER_TYPE_P (TREE_TYPE (dest))))
    4929                 :             :     {
    4930                 :           0 :       error ("goto destination is neither a label nor a pointer");
    4931                 :           0 :       return true;
    4932                 :             :     }
    4933                 :             : 
    4934                 :             :   return false;
    4935                 :             : }
    4936                 :             : 
    4937                 :             : /* Verify the contents of a GIMPLE_SWITCH STMT.  Returns true when there
    4938                 :             :    is a problem, otherwise false.  */
    4939                 :             : 
    4940                 :             : static bool
    4941                 :     4360426 : verify_gimple_switch (gswitch *stmt)
    4942                 :             : {
    4943                 :     4360426 :   unsigned int i, n;
    4944                 :     4360426 :   tree elt, prev_upper_bound = NULL_TREE;
    4945                 :     4360426 :   tree index_type, elt_type = NULL_TREE;
    4946                 :             : 
    4947                 :     4360426 :   if (!is_gimple_val (gimple_switch_index (stmt)))
    4948                 :             :     {
    4949                 :           0 :       error ("invalid operand to switch statement");
    4950                 :           0 :       debug_generic_stmt (gimple_switch_index (stmt));
    4951                 :           0 :       return true;
    4952                 :             :     }
    4953                 :             : 
    4954                 :     4360426 :   index_type = TREE_TYPE (gimple_switch_index (stmt));
    4955                 :     4360426 :   if (! INTEGRAL_TYPE_P (index_type))
    4956                 :             :     {
    4957                 :           0 :       error ("non-integral type switch statement");
    4958                 :           0 :       debug_generic_expr (index_type);
    4959                 :           0 :       return true;
    4960                 :             :     }
    4961                 :             : 
    4962                 :     4360426 :   elt = gimple_switch_label (stmt, 0);
    4963                 :     4360426 :   if (CASE_LOW (elt) != NULL_TREE
    4964                 :     4360426 :       || CASE_HIGH (elt) != NULL_TREE
    4965                 :     8720852 :       || CASE_CHAIN (elt) != NULL_TREE)
    4966                 :             :     {
    4967                 :           0 :       error ("invalid default case label in switch statement");
    4968                 :           0 :       debug_generic_expr (elt);
    4969                 :           0 :       return true;
    4970                 :             :     }
    4971                 :             : 
    4972                 :     4360426 :   n = gimple_switch_num_labels (stmt);
    4973                 :    39272676 :   for (i = 1; i < n; i++)
    4974                 :             :     {
    4975                 :    30551824 :       elt = gimple_switch_label (stmt, i);
    4976                 :             : 
    4977                 :    30551824 :       if (CASE_CHAIN (elt))
    4978                 :             :         {
    4979                 :           0 :           error ("invalid %<CASE_CHAIN%>");
    4980                 :           0 :           debug_generic_expr (elt);
    4981                 :           0 :           return true;
    4982                 :             :         }
    4983                 :    30551824 :       if (! CASE_LOW (elt))
    4984                 :             :         {
    4985                 :           0 :           error ("invalid case label in switch statement");
    4986                 :           0 :           debug_generic_expr (elt);
    4987                 :           0 :           return true;
    4988                 :             :         }
    4989                 :    30551824 :       if (CASE_HIGH (elt)
    4990                 :    30551824 :           && ! tree_int_cst_lt (CASE_LOW (elt), CASE_HIGH (elt)))
    4991                 :             :         {
    4992                 :           0 :           error ("invalid case range in switch statement");
    4993                 :           0 :           debug_generic_expr (elt);
    4994                 :           0 :           return true;
    4995                 :             :         }
    4996                 :             : 
    4997                 :    30551824 :       if (! elt_type)
    4998                 :             :         {
    4999                 :     4357740 :           elt_type = TREE_TYPE (CASE_LOW (elt));
    5000                 :     4357740 :           if (TYPE_PRECISION (index_type) < TYPE_PRECISION (elt_type))
    5001                 :             :             {
    5002                 :           0 :               error ("type precision mismatch in switch statement");
    5003                 :           0 :               return true;
    5004                 :             :             }
    5005                 :             :         }
    5006                 :    30551824 :       if (TREE_TYPE (CASE_LOW (elt)) != elt_type
    5007                 :    30551824 :           || (CASE_HIGH (elt) && TREE_TYPE (CASE_HIGH (elt)) != elt_type))
    5008                 :             :         {
    5009                 :           0 :           error ("type mismatch for case label in switch statement");
    5010                 :           0 :           debug_generic_expr (elt);
    5011                 :           0 :           return true;
    5012                 :             :         }
    5013                 :             : 
    5014                 :    30551824 :       if (prev_upper_bound)
    5015                 :             :         {
    5016                 :    26194084 :           if (! tree_int_cst_lt (prev_upper_bound, CASE_LOW (elt)))
    5017                 :             :             {
    5018                 :           0 :               error ("case labels not sorted in switch statement");
    5019                 :           0 :               return true;
    5020                 :             :             }
    5021                 :             :         }
    5022                 :             : 
    5023                 :    30551824 :       prev_upper_bound = CASE_HIGH (elt);
    5024                 :    30551824 :       if (! prev_upper_bound)
    5025                 :    28225494 :         prev_upper_bound = CASE_LOW (elt);
    5026                 :             :     }
    5027                 :             : 
    5028                 :             :   return false;
    5029                 :             : }
    5030                 :             : 
    5031                 :             : /* Verify a gimple debug statement STMT.
    5032                 :             :    Returns true if anything is wrong.  */
    5033                 :             : 
    5034                 :             : static bool
    5035                 :           0 : verify_gimple_debug (gimple *stmt ATTRIBUTE_UNUSED)
    5036                 :             : {
    5037                 :             :   /* There isn't much that could be wrong in a gimple debug stmt.  A
    5038                 :             :      gimple debug bind stmt, for example, maps a tree, that's usually
    5039                 :             :      a VAR_DECL or a PARM_DECL, but that could also be some scalarized
    5040                 :             :      component or member of an aggregate type, to another tree, that
    5041                 :             :      can be an arbitrary expression.  These stmts expand into debug
    5042                 :             :      insns, and are converted to debug notes by var-tracking.cc.  */
    5043                 :           0 :   return false;
    5044                 :             : }
    5045                 :             : 
    5046                 :             : /* Verify a gimple label statement STMT.
    5047                 :             :    Returns true if anything is wrong.  */
    5048                 :             : 
    5049                 :             : static bool
    5050                 :   210893904 : verify_gimple_label (glabel *stmt)
    5051                 :             : {
    5052                 :   210893904 :   tree decl = gimple_label_label (stmt);
    5053                 :   210893904 :   int uid;
    5054                 :   210893904 :   bool err = false;
    5055                 :             : 
    5056                 :   210893904 :   if (TREE_CODE (decl) != LABEL_DECL)
    5057                 :             :     return true;
    5058                 :   421731053 :   if (!DECL_NONLOCAL (decl) && !FORCED_LABEL (decl)
    5059                 :   418620038 :       && DECL_CONTEXT (decl) != current_function_decl)
    5060                 :             :     {
    5061                 :           0 :       error ("label context is not the current function declaration");
    5062                 :           0 :       err |= true;
    5063                 :             :     }
    5064                 :             : 
    5065                 :   210893904 :   uid = LABEL_DECL_UID (decl);
    5066                 :   210893904 :   if (cfun->cfg
    5067                 :   210893904 :       && (uid == -1
    5068                 :   134392555 :           || (*label_to_block_map_for_fn (cfun))[uid] != gimple_bb (stmt)))
    5069                 :             :     {
    5070                 :           0 :       error ("incorrect entry in %<label_to_block_map%>");
    5071                 :           0 :       err |= true;
    5072                 :             :     }
    5073                 :             : 
    5074                 :   210893904 :   uid = EH_LANDING_PAD_NR (decl);
    5075                 :   210893904 :   if (uid)
    5076                 :             :     {
    5077                 :    77061797 :       eh_landing_pad lp = get_eh_landing_pad_from_number (uid);
    5078                 :    77061797 :       if (decl != lp->post_landing_pad)
    5079                 :             :         {
    5080                 :           0 :           error ("incorrect setting of landing pad number");
    5081                 :           0 :           err |= true;
    5082                 :             :         }
    5083                 :             :     }
    5084                 :             : 
    5085                 :             :   return err;
    5086                 :             : }
    5087                 :             : 
    5088                 :             : /* Verify a gimple cond statement STMT.
    5089                 :             :    Returns true if anything is wrong.  */
    5090                 :             : 
    5091                 :             : static bool
    5092                 :   676259057 : verify_gimple_cond (gcond *stmt)
    5093                 :             : {
    5094                 :   676259057 :   if (TREE_CODE_CLASS (gimple_cond_code (stmt)) != tcc_comparison)
    5095                 :             :     {
    5096                 :           0 :       error ("invalid comparison code in gimple cond");
    5097                 :           0 :       return true;
    5098                 :             :     }
    5099                 :   676259057 :   if (!(!gimple_cond_true_label (stmt)
    5100                 :    26238432 :         || TREE_CODE (gimple_cond_true_label (stmt)) == LABEL_DECL)
    5101                 :   702497489 :       || !(!gimple_cond_false_label (stmt)
    5102                 :    26238432 :            || TREE_CODE (gimple_cond_false_label (stmt)) == LABEL_DECL))
    5103                 :             :     {
    5104                 :           0 :       error ("invalid labels in gimple cond");
    5105                 :           0 :       return true;
    5106                 :             :     }
    5107                 :             : 
    5108                 :   676259057 :   return verify_gimple_comparison (boolean_type_node,
    5109                 :             :                                    gimple_cond_lhs (stmt),
    5110                 :             :                                    gimple_cond_rhs (stmt),
    5111                 :   676259057 :                                    gimple_cond_code (stmt));
    5112                 :             : }
    5113                 :             : 
    5114                 :             : /* Verify the GIMPLE statement STMT.  Returns true if there is an
    5115                 :             :    error, otherwise false.  */
    5116                 :             : 
    5117                 :             : static bool
    5118                 : 11599819276 : verify_gimple_stmt (gimple *stmt)
    5119                 :             : {
    5120                 : 11599819276 :   switch (gimple_code (stmt))
    5121                 :             :     {
    5122                 :  4226860549 :     case GIMPLE_ASSIGN:
    5123                 :  4226860549 :       return verify_gimple_assign (as_a <gassign *> (stmt));
    5124                 :             : 
    5125                 :   210893904 :     case GIMPLE_LABEL:
    5126                 :   210893904 :       return verify_gimple_label (as_a <glabel *> (stmt));
    5127                 :             : 
    5128                 :   979315238 :     case GIMPLE_CALL:
    5129                 :   979315238 :       return verify_gimple_call (as_a <gcall *> (stmt));
    5130                 :             : 
    5131                 :   676259057 :     case GIMPLE_COND:
    5132                 :   676259057 :       return verify_gimple_cond (as_a <gcond *> (stmt));
    5133                 :             : 
    5134                 :    21989910 :     case GIMPLE_GOTO:
    5135                 :    21989910 :       return verify_gimple_goto (as_a <ggoto *> (stmt));
    5136                 :             : 
    5137                 :     4360426 :     case GIMPLE_SWITCH:
    5138                 :     4360426 :       return verify_gimple_switch (as_a <gswitch *> (stmt));
    5139                 :             : 
    5140                 :   238392664 :     case GIMPLE_RETURN:
    5141                 :   238392664 :       return verify_gimple_return (as_a <greturn *> (stmt));
    5142                 :             : 
    5143                 :             :     case GIMPLE_ASM:
    5144                 :             :       return false;
    5145                 :             : 
    5146                 :       30883 :     case GIMPLE_TRANSACTION:
    5147                 :       30883 :       return verify_gimple_transaction (as_a <gtransaction *> (stmt));
    5148                 :             : 
    5149                 :             :     /* Tuples that do not have tree operands.  */
    5150                 :             :     case GIMPLE_NOP:
    5151                 :             :     case GIMPLE_PREDICT:
    5152                 :             :     case GIMPLE_RESX:
    5153                 :             :     case GIMPLE_EH_DISPATCH:
    5154                 :             :     case GIMPLE_EH_MUST_NOT_THROW:
    5155                 :             :       return false;
    5156                 :             : 
    5157                 :             :     CASE_GIMPLE_OMP:
    5158                 :             :       /* OpenMP directives are validated by the FE and never operated
    5159                 :             :          on by the optimizers.  Furthermore, GIMPLE_OMP_FOR may contain
    5160                 :             :          non-gimple expressions when the main index variable has had
    5161                 :             :          its address taken.  This does not affect the loop itself
    5162                 :             :          because the header of an GIMPLE_OMP_FOR is merely used to determine
    5163                 :             :          how to setup the parallel iteration.  */
    5164                 :             :       return false;
    5165                 :             : 
    5166                 :             :     case GIMPLE_ASSUME:
    5167                 :             :       return false;
    5168                 :             : 
    5169                 :             :     case GIMPLE_DEBUG:
    5170                 :             :       return verify_gimple_debug (stmt);
    5171                 :             : 
    5172                 :           0 :     default:
    5173                 :           0 :       gcc_unreachable ();
    5174                 :             :     }
    5175                 :             : }
    5176                 :             : 
    5177                 :             : /* Verify the contents of a GIMPLE_PHI.  Returns true if there is a problem,
    5178                 :             :    and false otherwise.  */
    5179                 :             : 
    5180                 :             : static bool
    5181                 :   614051544 : verify_gimple_phi (gphi *phi)
    5182                 :             : {
    5183                 :   614051544 :   bool err = false;
    5184                 :   614051544 :   unsigned i;
    5185                 :   614051544 :   tree phi_result = gimple_phi_result (phi);
    5186                 :   614051544 :   bool virtual_p;
    5187                 :             : 
    5188                 :   614051544 :   if (!phi_result)
    5189                 :             :     {
    5190                 :           0 :       error ("invalid %<PHI%> result");
    5191                 :           0 :       return true;
    5192                 :             :     }
    5193                 :             : 
    5194                 :   614051544 :   virtual_p = virtual_operand_p (phi_result);
    5195                 :   614051544 :   if (TREE_CODE (phi_result) != SSA_NAME
    5196                 :   614051544 :       || (virtual_p
    5197                 :   295306608 :           && SSA_NAME_VAR (phi_result) != gimple_vop (cfun)))
    5198                 :             :     {
    5199                 :           0 :       error ("invalid %<PHI%> result");
    5200                 :           0 :       err = true;
    5201                 :             :     }
    5202                 :             : 
    5203                 :  2138565261 :   for (i = 0; i < gimple_phi_num_args (phi); i++)
    5204                 :             :     {
    5205                 :  1524513717 :       tree t = gimple_phi_arg_def (phi, i);
    5206                 :             : 
    5207                 :  1524513717 :       if (!t)
    5208                 :             :         {
    5209                 :           0 :           error ("missing %<PHI%> def");
    5210                 :           0 :           err |= true;
    5211                 :           0 :           continue;
    5212                 :             :         }
    5213                 :             :       /* Addressable variables do have SSA_NAMEs but they
    5214                 :             :          are not considered gimple values.  */
    5215                 :  1524513717 :       else if ((TREE_CODE (t) == SSA_NAME
    5216                 :  1324528162 :                 && virtual_p != virtual_operand_p (t))
    5217                 :  1524513717 :                || (virtual_p
    5218                 :   767353634 :                    && (TREE_CODE (t) != SSA_NAME
    5219                 :   767353634 :                        || SSA_NAME_VAR (t) != gimple_vop (cfun)))
    5220                 :  1524513717 :                || (!virtual_p
    5221                 :   757160083 :                    && !is_gimple_val (t)))
    5222                 :             :         {
    5223                 :           0 :           error ("invalid %<PHI%> argument");
    5224                 :           0 :           debug_generic_expr (t);
    5225                 :           0 :           err |= true;
    5226                 :             :         }
    5227                 :             : #ifdef ENABLE_TYPES_CHECKING
    5228                 :  1524513717 :       if (!useless_type_conversion_p (TREE_TYPE (phi_result), TREE_TYPE (t)))
    5229                 :             :         {
    5230                 :           0 :           error ("incompatible types in %<PHI%> argument %u", i);
    5231                 :           0 :           debug_generic_stmt (TREE_TYPE (phi_result));
    5232                 :           0 :           debug_generic_stmt (TREE_TYPE (t));
    5233                 :           0 :           err |= true;
    5234                 :             :         }
    5235                 :             : #endif
    5236                 :             :     }
    5237                 :             : 
    5238                 :             :   return err;
    5239                 :             : }
    5240                 :             : 
    5241                 :             : /* Verify the GIMPLE statements inside the sequence STMTS.  */
    5242                 :             : 
    5243                 :             : static bool
    5244                 :    50566010 : verify_gimple_in_seq_2 (gimple_seq stmts)
    5245                 :             : {
    5246                 :    50566010 :   gimple_stmt_iterator ittr;
    5247                 :    50566010 :   bool err = false;
    5248                 :             : 
    5249                 :   484016586 :   for (ittr = gsi_start (stmts); !gsi_end_p (ittr); gsi_next (&ittr))
    5250                 :             :     {
    5251                 :   433450576 :       gimple *stmt = gsi_stmt (ittr);
    5252                 :             : 
    5253                 :   433450576 :       switch (gimple_code (stmt))
    5254                 :             :         {
    5255                 :    14355881 :         case GIMPLE_BIND:
    5256                 :    14355881 :           err |= verify_gimple_in_seq_2 (
    5257                 :    14355881 :                    gimple_bind_body (as_a <gbind *> (stmt)));
    5258                 :    14355881 :           break;
    5259                 :             : 
    5260                 :    10396397 :         case GIMPLE_TRY:
    5261                 :    10396397 :           err |= verify_gimple_in_seq_2 (gimple_try_eval (stmt));
    5262                 :    10396397 :           err |= verify_gimple_in_seq_2 (gimple_try_cleanup (stmt));
    5263                 :    10396397 :           break;
    5264                 :             : 
    5265                 :       25590 :         case GIMPLE_EH_FILTER:
    5266                 :       25590 :           err |= verify_gimple_in_seq_2 (gimple_eh_filter_failure (stmt));
    5267                 :       25590 :           break;
    5268                 :             : 
    5269                 :        1298 :         case GIMPLE_EH_ELSE:
    5270                 :        1298 :           {
    5271                 :        1298 :             geh_else *eh_else = as_a <geh_else *> (stmt);
    5272                 :        1298 :             err |= verify_gimple_in_seq_2 (gimple_eh_else_n_body (eh_else));
    5273                 :        1298 :             err |= verify_gimple_in_seq_2 (gimple_eh_else_e_body (eh_else));
    5274                 :             :           }
    5275                 :        1298 :           break;
    5276                 :             : 
    5277                 :      169389 :         case GIMPLE_CATCH:
    5278                 :      169389 :           err |= verify_gimple_in_seq_2 (gimple_catch_handler (
    5279                 :      169389 :                                            as_a <gcatch *> (stmt)));
    5280                 :      169389 :           break;
    5281                 :             : 
    5282                 :         330 :         case GIMPLE_ASSUME:
    5283                 :         330 :           err |= verify_gimple_in_seq_2 (gimple_assume_body (stmt));
    5284                 :         330 :           break;
    5285                 :             : 
    5286                 :        2974 :         case GIMPLE_TRANSACTION:
    5287                 :        2974 :           err |= verify_gimple_transaction (as_a <gtransaction *> (stmt));
    5288                 :        2974 :           break;
    5289                 :             : 
    5290                 :   408498717 :         default:
    5291                 :   408498717 :           {
    5292                 :   408498717 :             bool err2 = verify_gimple_stmt (stmt);
    5293                 :   408498717 :             if (err2)
    5294                 :           7 :               debug_gimple_stmt (stmt);
    5295                 :   408498717 :             err |= err2;
    5296                 :             :           }
    5297                 :             :         }
    5298                 :             :     }
    5299                 :             : 
    5300                 :    50566010 :   return err;
    5301                 :             : }
    5302                 :             : 
    5303                 :             : /* Verify the contents of a GIMPLE_TRANSACTION.  Returns true if there
    5304                 :             :    is a problem, otherwise false.  */
    5305                 :             : 
    5306                 :             : static bool
    5307                 :       33857 : verify_gimple_transaction (gtransaction *stmt)
    5308                 :             : {
    5309                 :       33857 :   tree lab;
    5310                 :             : 
    5311                 :       33857 :   lab = gimple_transaction_label_norm (stmt);
    5312                 :       33857 :   if (lab != NULL && TREE_CODE (lab) != LABEL_DECL)
    5313                 :             :     return true;
    5314                 :       33857 :   lab = gimple_transaction_label_uninst (stmt);
    5315                 :       33857 :   if (lab != NULL && TREE_CODE (lab) != LABEL_DECL)
    5316                 :             :     return true;
    5317                 :       33857 :   lab = gimple_transaction_label_over (stmt);
    5318                 :       33857 :   if (lab != NULL && TREE_CODE (lab) != LABEL_DECL)
    5319                 :             :     return true;
    5320                 :             : 
    5321                 :       33857 :   return verify_gimple_in_seq_2 (gimple_transaction_body (stmt));
    5322                 :             : }
    5323                 :             : 
    5324                 :             : 
    5325                 :             : /* Verify the GIMPLE statements inside the statement list STMTS.  */
    5326                 :             : 
    5327                 :             : DEBUG_FUNCTION bool
    5328                 :    15185573 : verify_gimple_in_seq (gimple_seq stmts, bool ice)
    5329                 :             : {
    5330                 :    15185573 :   timevar_push (TV_TREE_STMT_VERIFY);
    5331                 :    15185573 :   bool res = verify_gimple_in_seq_2 (stmts);
    5332                 :    15185573 :   if (res && ice)
    5333                 :           6 :     internal_error ("%<verify_gimple%> failed");
    5334                 :    15185567 :   timevar_pop (TV_TREE_STMT_VERIFY);
    5335                 :    15185567 :   return res;
    5336                 :             : }
    5337                 :             : 
    5338                 :             : /* Return true when the T can be shared.  */
    5339                 :             : 
    5340                 :             : static bool
    5341                 : 28869580777 : tree_node_can_be_shared (tree t)
    5342                 :             : {
    5343                 : 28869580777 :   if (IS_TYPE_OR_DECL_P (t)
    5344                 : 20594908119 :       || TREE_CODE (t) == SSA_NAME
    5345                 : 10671534227 :       || TREE_CODE (t) == IDENTIFIER_NODE
    5346                 : 10671534051 :       || TREE_CODE (t) == CASE_LABEL_EXPR
    5347                 : 39511760761 :       || is_gimple_min_invariant (t))
    5348                 : 24618999793 :     return true;
    5349                 :             : 
    5350                 :  4250580984 :   if (t == error_mark_node)
    5351                 :             :     return true;
    5352                 :             : 
    5353                 :             :   return false;
    5354                 :             : }
    5355                 :             : 
    5356                 :             : /* Called via walk_tree.  Verify tree sharing.  */
    5357                 :             : 
    5358                 :             : static tree
    5359                 : 28869580777 : verify_node_sharing_1 (tree *tp, int *walk_subtrees, void *data)
    5360                 :             : {
    5361                 : 28869580777 :   hash_set<void *> *visited = (hash_set<void *> *) data;
    5362                 :             : 
    5363                 : 28869580777 :   if (tree_node_can_be_shared (*tp))
    5364                 :             :     {
    5365                 : 24618999793 :       *walk_subtrees = false;
    5366                 : 24618999793 :       return NULL;
    5367                 :             :     }
    5368                 :             : 
    5369                 :  4250580984 :   if (visited->add (*tp))
    5370                 :           0 :     return *tp;
    5371                 :             : 
    5372                 :             :   return NULL;
    5373                 :             : }
    5374                 :             : 
    5375                 :             : /* Called via walk_gimple_stmt.  Verify tree sharing.  */
    5376                 :             : 
    5377                 :             : static tree
    5378                 : 27345067060 : verify_node_sharing (tree *tp, int *walk_subtrees, void *data)
    5379                 :             : {
    5380                 : 27345067060 :   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
    5381                 : 27345067060 :   return verify_node_sharing_1 (tp, walk_subtrees, wi->info);
    5382                 :             : }
    5383                 :             : 
    5384                 :             : static bool eh_error_found;
    5385                 :             : bool
    5386                 :   195868812 : verify_eh_throw_stmt_node (gimple *const &stmt, const int &,
    5387                 :             :                            hash_set<gimple *> *visited)
    5388                 :             : {
    5389                 :   195868812 :   if (!visited->contains (stmt))
    5390                 :             :     {
    5391                 :           0 :       error ("dead statement in EH table");
    5392                 :           0 :       debug_gimple_stmt (stmt);
    5393                 :           0 :       eh_error_found = true;
    5394                 :             :     }
    5395                 :   195868812 :   return true;
    5396                 :             : }
    5397                 :             : 
    5398                 :             : /* Verify if the location LOCs block is in BLOCKS.  */
    5399                 :             : 
    5400                 :             : static bool
    5401                 : 21187749331 : verify_location (hash_set<tree> *blocks, location_t loc)
    5402                 :             : {
    5403                 : 34870431069 :   tree block = LOCATION_BLOCK (loc);
    5404                 : 34870431069 :   if (block != NULL_TREE
    5405                 : 34870431069 :       && !blocks->contains (block))
    5406                 :             :     {
    5407                 :           0 :       error ("location references block not in block tree");
    5408                 :           0 :       return true;
    5409                 :             :     }
    5410                 : 34870431069 :   if (block != NULL_TREE)
    5411                 : 13682681738 :     return verify_location (blocks, BLOCK_SOURCE_LOCATION (block));
    5412                 :             :   return false;
    5413                 :             : }
    5414                 :             : 
    5415                 :             : /* Called via walk_tree.  Verify that expressions have no blocks.  */
    5416                 :             : 
    5417                 :             : static tree
    5418                 :  1405263710 : verify_expr_no_block (tree *tp, int *walk_subtrees, void *)
    5419                 :             : {
    5420                 :  1405263710 :   if (!EXPR_P (*tp))
    5421                 :             :     {
    5422                 :   865020531 :       *walk_subtrees = false;
    5423                 :   865020531 :       return NULL;
    5424                 :             :     }
    5425                 :             : 
    5426                 :  1945506889 :   location_t loc = EXPR_LOCATION (*tp);
    5427                 :   540243179 :   if (LOCATION_BLOCK (loc) != NULL)
    5428                 :           0 :     return *tp;
    5429                 :             : 
    5430                 :             :   return NULL;
    5431                 :             : }
    5432                 :             : 
    5433                 :             : /* Called via walk_tree.  Verify locations of expressions.  */
    5434                 :             : 
    5435                 :             : static tree
    5436                 : 32126655601 : verify_expr_location_1 (tree *tp, int *walk_subtrees, void *data)
    5437                 :             : {
    5438                 : 32126655601 :   hash_set<tree> *blocks = (hash_set<tree> *) data;
    5439                 : 32126655601 :   tree t = *tp;
    5440                 :             : 
    5441                 :             :   /* ???  This doesn't really belong here but there's no good place to
    5442                 :             :      stick this remainder of old verify_expr.  */
    5443                 :             :   /* ???  This barfs on debug stmts which contain binds to vars with
    5444                 :             :      different function context.  */
    5445                 :             : #if 0
    5446                 :             :   if (VAR_P (t)
    5447                 :             :       || TREE_CODE (t) == PARM_DECL
    5448                 :             :       || TREE_CODE (t) == RESULT_DECL)
    5449                 :             :     {
    5450                 :             :       tree context = decl_function_context (t);
    5451                 :             :       if (context != cfun->decl
    5452                 :             :           && !SCOPE_FILE_SCOPE_P (context)
    5453                 :             :           && !TREE_STATIC (t)
    5454                 :             :           && !DECL_EXTERNAL (t))
    5455                 :             :         {
    5456                 :             :           error ("local declaration from a different function");
    5457                 :             :           return t;
    5458                 :             :         }
    5459                 :             :     }
    5460                 :             : #endif
    5461                 :             : 
    5462                 : 32126655601 :   if (VAR_P (t) && DECL_HAS_DEBUG_EXPR_P (t))
    5463                 :             :     {
    5464                 :   388904885 :       tree x = DECL_DEBUG_EXPR (t);
    5465                 :   388904885 :       tree addr = walk_tree (&x, verify_expr_no_block, NULL, NULL);
    5466                 :   388904885 :       if (addr)
    5467                 :           0 :         return addr;
    5468                 :             :     }
    5469                 : 32126655601 :   if ((VAR_P (t)
    5470                 :             :        || TREE_CODE (t) == PARM_DECL
    5471                 :             :        || TREE_CODE (t) == RESULT_DECL)
    5472                 :  6747602254 :       && DECL_HAS_VALUE_EXPR_P (t))
    5473                 :             :     {
    5474                 :        1608 :       tree x = DECL_VALUE_EXPR (t);
    5475                 :        1608 :       tree addr = walk_tree (&x, verify_expr_no_block, NULL, NULL);
    5476                 :        1608 :       if (addr)
    5477                 :           0 :         return addr;
    5478                 :             :     }
    5479                 :             : 
    5480                 : 32126655601 :   if (!EXPR_P (t))
    5481                 :             :     {
    5482                 : 25287540963 :       *walk_subtrees = false;
    5483                 : 25287540963 :       return NULL;
    5484                 :             :     }
    5485                 :             : 
    5486                 :  6839114638 :   location_t loc = EXPR_LOCATION (t);
    5487                 :  6839114638 :   if (verify_location (blocks, loc))
    5488                 :             :     return t;
    5489                 :             : 
    5490                 :             :   return NULL;
    5491                 :             : }
    5492                 :             : 
    5493                 :             : /* Called via walk_gimple_op.  Verify locations of expressions.  */
    5494                 :             : 
    5495                 :             : static tree
    5496                 : 30576257289 : verify_expr_location (tree *tp, int *walk_subtrees, void *data)
    5497                 :             : {
    5498                 : 30576257289 :   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
    5499                 : 30576257289 :   return verify_expr_location_1 (tp, walk_subtrees, wi->info);
    5500                 :             : }
    5501                 :             : 
    5502                 :             : /* Insert all subblocks of BLOCK into BLOCKS and recurse.  */
    5503                 :             : 
    5504                 :             : static void
    5505                 :  2146585181 : collect_subblocks (hash_set<tree> *blocks, tree block)
    5506                 :             : {
    5507                 :  2146585181 :   tree t;
    5508                 :  4063903039 :   for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
    5509                 :             :     {
    5510                 :  1917317858 :       blocks->add (t);
    5511                 :  1917317858 :       collect_subblocks (blocks, t);
    5512                 :             :     }
    5513                 :  2146585181 : }
    5514                 :             : 
    5515                 :             : /* Disable warnings about missing quoting in GCC diagnostics for
    5516                 :             :    the verification errors.  Their format strings don't follow
    5517                 :             :    GCC diagnostic conventions and trigger an ICE in the end.  */
    5518                 :             : #if __GNUC__ >= 10
    5519                 :             : #  pragma GCC diagnostic push
    5520                 :             : #  pragma GCC diagnostic ignored "-Wformat-diag"
    5521                 :             : #endif
    5522                 :             : 
    5523                 :             : /* Verify the GIMPLE statements in the CFG of FN.  */
    5524                 :             : 
    5525                 :             : DEBUG_FUNCTION bool
    5526                 :   229267323 : verify_gimple_in_cfg (struct function *fn, bool verify_nothrow, bool ice)
    5527                 :             : {
    5528                 :   229267323 :   basic_block bb;
    5529                 :   229267323 :   bool err = false;
    5530                 :             : 
    5531                 :   229267323 :   timevar_push (TV_TREE_STMT_VERIFY);
    5532                 :   229267323 :   hash_set<void *> visited;
    5533                 :   229267323 :   hash_set<gimple *> visited_throwing_stmts;
    5534                 :             : 
    5535                 :             :   /* Collect all BLOCKs referenced by the BLOCK tree of FN.  */
    5536                 :   229267323 :   hash_set<tree> blocks;
    5537                 :   229267323 :   if (DECL_INITIAL (fn->decl))
    5538                 :             :     {
    5539                 :   229267323 :       blocks.add (DECL_INITIAL (fn->decl));
    5540                 :   229267323 :       collect_subblocks (&blocks, DECL_INITIAL (fn->decl));
    5541                 :             :     }
    5542                 :             : 
    5543                 :  2030423202 :   FOR_EACH_BB_FN (bb, fn)
    5544                 :             :     {
    5545                 :  1801155879 :       gimple_stmt_iterator gsi;
    5546                 :  1801155879 :       edge_iterator ei;
    5547                 :  1801155879 :       edge e;
    5548                 :             : 
    5549                 :  1801155879 :       for (gphi_iterator gpi = gsi_start_phis (bb);
    5550                 :  2415207423 :            !gsi_end_p (gpi);
    5551                 :   614051544 :            gsi_next (&gpi))
    5552                 :             :         {
    5553                 :   614051544 :           gphi *phi = gpi.phi ();
    5554                 :   614051544 :           bool err2 = false;
    5555                 :   614051544 :           unsigned i;
    5556                 :             : 
    5557                 :   614051544 :           if (gimple_bb (phi) != bb)
    5558                 :             :             {
    5559                 :           0 :               error ("gimple_bb (phi) is set to a wrong basic block");
    5560                 :           0 :               err2 = true;
    5561                 :             :             }
    5562                 :             : 
    5563                 :   614051544 :           err2 |= verify_gimple_phi (phi);
    5564                 :             : 
    5565                 :             :           /* Only PHI arguments have locations.  */
    5566                 :   614051544 :           if (gimple_location (phi) != UNKNOWN_LOCATION)
    5567                 :             :             {
    5568                 :           0 :               error ("PHI node with location");
    5569                 :           0 :               err2 = true;
    5570                 :             :             }
    5571                 :             : 
    5572                 :  2138565261 :           for (i = 0; i < gimple_phi_num_args (phi); i++)
    5573                 :             :             {
    5574                 :  1524513717 :               tree arg = gimple_phi_arg_def (phi, i);
    5575                 :  1524513717 :               tree addr = walk_tree (&arg, verify_node_sharing_1,
    5576                 :             :                                      &visited, NULL);
    5577                 :  1524513717 :               if (addr)
    5578                 :             :                 {
    5579                 :           0 :                   error ("incorrect sharing of tree nodes");
    5580                 :           0 :                   debug_generic_expr (addr);
    5581                 :           0 :                   err2 |= true;
    5582                 :             :                 }
    5583                 :  1524513717 :               location_t loc = gimple_phi_arg_location (phi, i);
    5584                 :  1524513717 :               if (virtual_operand_p (gimple_phi_result (phi))
    5585                 :  1524513717 :                   && loc != UNKNOWN_LOCATION)
    5586                 :             :                 {
    5587                 :           0 :                   error ("virtual PHI with argument locations");
    5588                 :           0 :                   err2 = true;
    5589                 :             :                 }
    5590                 :  1524513717 :               addr = walk_tree (&arg, verify_expr_location_1, &blocks, NULL);
    5591                 :  1524513717 :               if (addr)
    5592                 :             :                 {
    5593                 :           0 :                   debug_generic_expr (addr);
    5594                 :           0 :                   err2 = true;
    5595                 :             :                 }
    5596                 :  1524513717 :               err2 |= verify_location (&blocks, loc);
    5597                 :             :             }
    5598                 :             : 
    5599                 :   614051544 :           if (err2)
    5600                 :           0 :             debug_gimple_stmt (phi);
    5601                 :   614051544 :           err |= err2;
    5602                 :             :         }
    5603                 :             : 
    5604                 : 14793632317 :       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    5605                 :             :         {
    5606                 : 11191320559 :           gimple *stmt = gsi_stmt (gsi);
    5607                 : 11191320559 :           bool err2 = false;
    5608                 : 11191320559 :           struct walk_stmt_info wi;
    5609                 : 11191320559 :           tree addr;
    5610                 : 11191320559 :           int lp_nr;
    5611                 :             : 
    5612                 : 11191320559 :           if (gimple_bb (stmt) != bb)
    5613                 :             :             {
    5614                 :           0 :               error ("gimple_bb (stmt) is set to a wrong basic block");
    5615                 :           0 :               err2 = true;
    5616                 :             :             }
    5617                 :             : 
    5618                 : 11191320559 :           err2 |= verify_gimple_stmt (stmt);
    5619                 : 11191320559 :           err2 |= verify_location (&blocks, gimple_location (stmt));
    5620                 :             : 
    5621                 : 11191320559 :           memset (&wi, 0, sizeof (wi));
    5622                 : 11191320559 :           wi.info = (void *) &visited;
    5623                 : 11191320559 :           addr = walk_gimple_op (stmt, verify_node_sharing, &wi);
    5624                 : 11191320559 :           if (addr)
    5625                 :             :             {
    5626                 :           0 :               error ("incorrect sharing of tree nodes");
    5627                 :           0 :               debug_generic_expr (addr);
    5628                 :           0 :               err2 |= true;
    5629                 :             :             }
    5630                 :             : 
    5631                 : 11191320559 :           memset (&wi, 0, sizeof (wi));
    5632                 : 11191320559 :           wi.info = (void *) &blocks;
    5633                 : 11191320559 :           addr = walk_gimple_op (stmt, verify_expr_location, &wi);
    5634                 : 11191320559 :           if (addr)
    5635                 :             :             {
    5636                 :           0 :               debug_generic_expr (addr);
    5637                 :           0 :               err2 |= true;
    5638                 :             :             }
    5639                 :             : 
    5640                 :             :           /* If the statement is marked as part of an EH region, then it is
    5641                 :             :              expected that the statement could throw.  Verify that when we
    5642                 :             :              have optimizations that simplify statements such that we prove
    5643                 :             :              that they cannot throw, that we update other data structures
    5644                 :             :              to match.  */
    5645                 : 11191320559 :           lp_nr = lookup_stmt_eh_lp (stmt);
    5646                 : 11191320559 :           if (lp_nr != 0)
    5647                 :   195868812 :             visited_throwing_stmts.add (stmt);
    5648                 :   195868812 :           if (lp_nr > 0)
    5649                 :             :             {
    5650                 :   189226242 :               if (!stmt_could_throw_p (cfun, stmt))
    5651                 :             :                 {
    5652                 :          19 :                   if (verify_nothrow)
    5653                 :             :                     {
    5654                 :           0 :                       error ("statement marked for throw, but doesn%'t");
    5655                 :           0 :                       err2 |= true;
    5656                 :             :                     }
    5657                 :             :                 }
    5658                 :   189226223 :               else if (!gsi_one_before_end_p (gsi))
    5659                 :             :                 {
    5660                 :           0 :                   error ("statement marked for throw in middle of block");
    5661                 :           0 :                   err2 |= true;
    5662                 :             :                 }
    5663                 :             :             }
    5664                 :             : 
    5665                 : 11191320559 :           if (err2)
    5666                 :           0 :             debug_gimple_stmt (stmt);
    5667                 : 11191320559 :           err |= err2;
    5668                 :             :         }
    5669                 :             : 
    5670                 :  4301181445 :       FOR_EACH_EDGE (e, ei, bb->succs)
    5671                 :  2500025566 :         if (e->goto_locus != UNKNOWN_LOCATION)
    5672                 :  1632800417 :           err |= verify_location (&blocks, e->goto_locus);
    5673                 :             :     }
    5674                 :             : 
    5675                 :   229267323 :   hash_map<gimple *, int> *eh_table = get_eh_throw_stmt_table (cfun);
    5676                 :   229267323 :   eh_error_found = false;
    5677                 :   229267323 :   if (eh_table)
    5678                 :    32919338 :     eh_table->traverse<hash_set<gimple *> *, verify_eh_throw_stmt_node>
    5679                 :   228788150 :       (&visited_throwing_stmts);
    5680                 :             : 
    5681                 :   229267323 :   if (ice && (err || eh_error_found))
    5682                 :           0 :     internal_error ("verify_gimple failed");
    5683                 :             : 
    5684                 :   229267323 :   verify_histograms ();
    5685                 :   229267323 :   timevar_pop (TV_TREE_STMT_VERIFY);
    5686                 :             : 
    5687                 :   229267323 :   return (err || eh_error_found);
    5688                 :   229267323 : }
    5689                 :             : 
    5690                 :             : 
    5691                 :             : /* Verifies that the flow information is OK.  */
    5692                 :             : 
    5693                 :             : static bool
    5694                 :   220208379 : gimple_verify_flow_info (void)
    5695                 :             : {
    5696                 :   220208379 :   bool err = false;
    5697                 :   220208379 :   basic_block bb;
    5698                 :   220208379 :   gimple_stmt_iterator gsi;
    5699                 :   220208379 :   gimple *stmt;
    5700                 :   220208379 :   edge e;
    5701                 :   220208379 :   edge_iterator ei;
    5702                 :             : 
    5703                 :   220208379 :   if (ENTRY_BLOCK_PTR_FOR_FN (cfun)->il.gimple.seq
    5704                 :   220208379 :       || ENTRY_BLOCK_PTR_FOR_FN (cfun)->il.gimple.phi_nodes)
    5705                 :             :     {
    5706                 :           0 :       error ("ENTRY_BLOCK has IL associated with it");
    5707                 :           0 :       err = true;
    5708                 :             :     }
    5709                 :             : 
    5710                 :   220208379 :   if (EXIT_BLOCK_PTR_FOR_FN (cfun)->il.gimple.seq
    5711                 :   220208379 :       || EXIT_BLOCK_PTR_FOR_FN (cfun)->il.gimple.phi_nodes)
    5712                 :             :     {
    5713                 :           0 :       error ("EXIT_BLOCK has IL associated with it");
    5714                 :           0 :       err = true;
    5715                 :             :     }
    5716                 :             : 
    5717                 :   436541298 :   FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
    5718                 :   216332919 :     if (e->flags & EDGE_FALLTHRU)
    5719                 :             :       {
    5720                 :           0 :         error ("fallthru to exit from bb %d", e->src->index);
    5721                 :           0 :         err = true;
    5722                 :             :       }
    5723                 :   220208379 :   if (cfun->cfg->full_profile
    5724                 :   220208379 :       && !ENTRY_BLOCK_PTR_FOR_FN (cfun)->count.initialized_p ())
    5725                 :             :     {
    5726                 :           0 :       error ("entry block count not initialized");
    5727                 :           0 :       err = true;
    5728                 :             :     }
    5729                 :   220208379 :   if (cfun->cfg->full_profile
    5730                 :   220208379 :       && !EXIT_BLOCK_PTR_FOR_FN (cfun)->count.initialized_p ())
    5731                 :             :     {
    5732                 :           0 :       error ("exit block count not initialized");
    5733                 :           0 :       err = true;
    5734                 :             :     }
    5735                 :   220208379 :   if (cfun->cfg->full_profile
    5736                 :   333733442 :       && !single_succ_edge
    5737                 :   113525063 :               (ENTRY_BLOCK_PTR_FOR_FN (cfun))->probability.initialized_p ())
    5738                 :             :     {
    5739                 :           0 :       error ("probability of edge from entry block not initialized");
    5740                 :           0 :       err = true;
    5741                 :             :     }
    5742                 :             : 
    5743                 :             : 
    5744                 :  2067287520 :   FOR_EACH_BB_FN (bb, cfun)
    5745                 :             :     {
    5746                 :  1847079141 :       bool found_ctrl_stmt = false;
    5747                 :             : 
    5748                 :  1847079141 :       stmt = NULL;
    5749                 :             : 
    5750                 :  1847079141 :       if (cfun->cfg->full_profile)
    5751                 :             :         {
    5752                 :  1210057767 :           if (!bb->count.initialized_p ())
    5753                 :             :             {
    5754                 :           0 :               error ("count of bb %d not initialized", bb->index);
    5755                 :           0 :               err = true;
    5756                 :             :             }
    5757                 :  2919722587 :           FOR_EACH_EDGE (e, ei, bb->succs)
    5758                 :  1709664820 :             if (!e->probability.initialized_p ())
    5759                 :             :               {
    5760                 :           0 :                 error ("probability of edge %d->%d not initialized",
    5761                 :           0 :                        bb->index, e->dest->index);
    5762                 :           0 :                 err = true;
    5763                 :             :               }
    5764                 :             :         }
    5765                 :             : 
    5766                 :             :       /* Skip labels on the start of basic block.  */
    5767                 :  3836957578 :       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    5768                 :             :         {
    5769                 :  1833607698 :           tree label;
    5770                 :  1833607698 :           gimple *prev_stmt = stmt;
    5771                 :             : 
    5772                 :  1833607698 :           stmt = gsi_stmt (gsi);
    5773                 :             : 
    5774                 :  1833607698 :           if (gimple_code (stmt) != GIMPLE_LABEL)
    5775                 :             :             break;
    5776                 :             : 
    5777                 :   142799296 :           label = gimple_label_label (as_a <glabel *> (stmt));
    5778                 :   142799296 :           if (prev_stmt && DECL_NONLOCAL (label))
    5779                 :             :             {
    5780                 :           0 :               error ("nonlocal label %qD is not first in a sequence "
    5781                 :             :                      "of labels in bb %d", label, bb->index);
    5782                 :           0 :               err = true;
    5783                 :             :             }
    5784                 :             : 
    5785                 :   144738538 :           if (prev_stmt && EH_LANDING_PAD_NR (label) != 0)
    5786                 :             :             {
    5787                 :           0 :               error ("EH landing pad label %qD is not first in a sequence "
    5788                 :             :                      "of labels in bb %d", label, bb->index);
    5789                 :           0 :               err = true;
    5790                 :             :             }
    5791                 :             : 
    5792                 :   142799296 :           if (label_to_block (cfun, label) != bb)
    5793                 :             :             {
    5794                 :           0 :               error ("label %qD to block does not match in bb %d",
    5795                 :             :                      label, bb->index);
    5796                 :           0 :               err = true;
    5797                 :             :             }
    5798                 :             : 
    5799                 :   142799296 :           if (decl_function_context (label) != current_function_decl)
    5800                 :             :             {
    5801                 :           0 :               error ("label %qD has incorrect context in bb %d",
    5802                 :             :                      label, bb->index);
    5803                 :           0 :               err = true;
    5804                 :             :             }
    5805                 :             :         }
    5806                 :             : 
    5807                 :             :       /* Verify that body of basic block BB is free of control flow.  */
    5808                 :             :       bool seen_nondebug_stmt = false;
    5809                 : 13905407307 :       for (; !gsi_end_p (gsi); gsi_next (&gsi))
    5810                 :             :         {
    5811                 : 12058328166 :           gimple *stmt = gsi_stmt (gsi);
    5812                 :             : 
    5813                 :             :           /* Do NOT disregard debug stmts after found_ctrl_stmt.  */
    5814                 : 12058328166 :           if (found_ctrl_stmt)
    5815                 :             :             {
    5816                 :           0 :               error ("control flow in the middle of basic block %d",
    5817                 :             :                      bb->index);
    5818                 :           0 :               err = true;
    5819                 :             :             }
    5820                 :             : 
    5821                 : 12058328166 :           if (stmt_ends_bb_p (stmt))
    5822                 :  1235935887 :             found_ctrl_stmt = true;
    5823                 :             : 
    5824                 : 12058328166 :           if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
    5825                 :             :             {
    5826                 :           0 :               error ("label %qD in the middle of basic block %d",
    5827                 :             :                      gimple_label_label (label_stmt), bb->index);
    5828                 :           0 :               err = true;
    5829                 :             :             }
    5830                 :             : 
    5831                 :             :           /* Check that no statements appear between a returns_twice call
    5832                 :             :              and its associated abnormal edge.  */
    5833                 : 12058328166 :           if (gimple_code (stmt) == GIMPLE_CALL
    5834                 : 12058328166 :               && gimple_call_flags (stmt) & ECF_RETURNS_TWICE)
    5835                 :             :             {
    5836                 :      133048 :               bool misplaced = false;
    5837                 :             :               /* TM is an exception: it points abnormal edges just after the
    5838                 :             :                  call that starts a transaction, i.e. it must end the BB.  */
    5839                 :      133048 :               if (gimple_call_builtin_p (stmt, BUILT_IN_TM_START))
    5840                 :             :                 {
    5841                 :        3788 :                   if (single_succ_p (bb)
    5842                 :        2989 :                       && bb_has_abnormal_pred (single_succ (bb))
    5843                 :        6130 :                       && !gsi_one_nondebug_before_end_p (gsi))
    5844                 :             :                     {
    5845                 :           0 :                       error ("returns_twice call is not last in basic block "
    5846                 :             :                              "%d", bb->index);
    5847                 :           0 :                       misplaced = true;
    5848                 :             :                     }
    5849                 :             :                 }
    5850                 :             :               else
    5851                 :             :                 {
    5852                 :      129260 :                   if (seen_nondebug_stmt && bb_has_abnormal_pred (bb))
    5853                 :             :                     {
    5854                 :           0 :                       error ("returns_twice call is not first in basic block "
    5855                 :             :                              "%d", bb->index);
    5856                 :           0 :                       misplaced = true;
    5857                 :             :                     }
    5858                 :             :                 }
    5859                 :           0 :               if (misplaced)
    5860                 :             :                 {
    5861                 :           0 :                   print_gimple_stmt (stderr, stmt, 0, TDF_SLIM);
    5862                 :           0 :                   err = true;
    5863                 :             :                 }
    5864                 :             :             }
    5865                 : 12058328166 :           if (!is_gimple_debug (stmt))
    5866                 :  6084872134 :             seen_nondebug_stmt = true;
    5867                 :             :         }
    5868                 :             : 
    5869                 :  1847079141 :       gsi = gsi_last_nondebug_bb (bb);
    5870                 :  1847079141 :       if (gsi_end_p (gsi))
    5871                 :   125964143 :         continue;
    5872                 :             : 
    5873                 :  1721114998 :       stmt = gsi_stmt (gsi);
    5874                 :             : 
    5875                 :  1721114998 :       if (gimple_code (stmt) == GIMPLE_LABEL)
    5876                 :    44877215 :         continue;
    5877                 :             : 
    5878                 :  1676237783 :       if (verify_eh_edges (stmt))
    5879                 :           0 :         err = true;
    5880                 :             : 
    5881                 :  1676237783 :       if (is_ctrl_stmt (stmt))
    5882                 :             :         {
    5883                 :  2579405162 :           FOR_EACH_EDGE (e, ei, bb->succs)
    5884                 :  1632569051 :             if (e->flags & EDGE_FALLTHRU)
    5885                 :             :               {
    5886                 :           0 :                 error ("fallthru edge after a control statement in bb %d",
    5887                 :             :                        bb->index);
    5888                 :           0 :                 err = true;
    5889                 :             :               }
    5890                 :             :         }
    5891                 :             : 
    5892                 :  1676237783 :       if (gimple_code (stmt) != GIMPLE_COND)
    5893                 :             :         {
    5894                 :             :           /* Verify that there are no edges with EDGE_TRUE/FALSE_FLAG set
    5895                 :             :              after anything else but if statement.  */
    5896                 :  2045030918 :           FOR_EACH_EDGE (e, ei, bb->succs)
    5897                 :  1051049208 :             if (e->flags & (EDGE_TRUE_VALUE | EDGE_FALSE_VALUE))
    5898                 :             :               {
    5899                 :           0 :                 error ("true/false edge after a non-GIMPLE_COND in bb %d",
    5900                 :             :                        bb->index);
    5901                 :           0 :                 err = true;
    5902                 :             :               }
    5903                 :             :         }
    5904                 :             : 
    5905                 :  1676237783 :       switch (gimple_code (stmt))
    5906                 :             :         {
    5907                 :   682256073 :         case GIMPLE_COND:
    5908                 :   682256073 :           {
    5909                 :   682256073 :             edge true_edge;
    5910                 :   682256073 :             edge false_edge;
    5911                 :             : 
    5912                 :   682256073 :             extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
    5913                 :             : 
    5914                 :   682256073 :             if (!true_edge
    5915                 :   682256073 :                 || !false_edge
    5916                 :   682256073 :                 || !(true_edge->flags & EDGE_TRUE_VALUE)
    5917                 :   682256073 :                 || !(false_edge->flags & EDGE_FALSE_VALUE)
    5918                 :   682256073 :                 || (true_edge->flags & (EDGE_FALLTHRU | EDGE_ABNORMAL))
    5919                 :   682256073 :                 || (false_edge->flags & (EDGE_FALLTHRU | EDGE_ABNORMAL))
    5920                 :  1364512146 :                 || EDGE_COUNT (bb->succs) >= 3)
    5921                 :             :               {
    5922                 :           0 :                 error ("wrong outgoing edge flags at end of bb %d",
    5923                 :             :                        bb->index);
    5924                 :           0 :                 err = true;
    5925                 :             :               }
    5926                 :             :           }
    5927                 :   682256073 :           break;
    5928                 :             : 
    5929                 :       49748 :         case GIMPLE_GOTO:
    5930                 :       49748 :           if (simple_goto_p (stmt))
    5931                 :             :             {
    5932                 :           0 :               error ("explicit goto at end of bb %d", bb->index);
    5933                 :           0 :               err = true;
    5934                 :             :             }
    5935                 :             :           else
    5936                 :             :             {
    5937                 :             :               /* FIXME.  We should double check that the labels in the
    5938                 :             :                  destination blocks have their address taken.  */
    5939                 :      183004 :               FOR_EACH_EDGE (e, ei, bb->succs)
    5940                 :      133256 :                 if ((e->flags & (EDGE_FALLTHRU | EDGE_TRUE_VALUE
    5941                 :             :                                  | EDGE_FALSE_VALUE))
    5942                 :      133256 :                     || !(e->flags & EDGE_ABNORMAL))
    5943                 :             :                   {
    5944                 :           0 :                     error ("wrong outgoing edge flags at end of bb %d",
    5945                 :             :                            bb->index);
    5946                 :           0 :                     err = true;
    5947                 :             :                   }
    5948                 :             :             }
    5949                 :             :           break;
    5950                 :             : 
    5951                 :   358460531 :         case GIMPLE_CALL:
    5952                 :   358460531 :           if (!gimple_call_builtin_p (stmt, BUILT_IN_RETURN))
    5953                 :             :             break;
    5954                 :             :           /* fallthru */
    5955                 :   216330036 :         case GIMPLE_RETURN:
    5956                 :   216330036 :           if (!single_succ_p (bb)
    5957                 :   216330036 :               || (single_succ_edge (bb)->flags
    5958                 :   216330036 :                   & (EDGE_FALLTHRU | EDGE_ABNORMAL
    5959                 :             :                      | EDGE_TRUE_VALUE | EDGE_FALSE_VALUE)))
    5960                 :             :             {
    5961                 :           0 :               error ("wrong outgoing edge flags at end of bb %d", bb->index);
    5962                 :           0 :               err = true;
    5963                 :             :             }
    5964                 :   216330036 :           if (single_succ (bb) != EXIT_BLOCK_PTR_FOR_FN (cfun))
    5965                 :             :             {
    5966                 :           0 :               error ("return edge does not point to exit in bb %d",
    5967                 :             :                      bb->index);
    5968                 :           0 :               err = true;
    5969                 :             :             }
    5970                 :             :           break;
    5971                 :             : 
    5972                 :     3954702 :         case GIMPLE_SWITCH:
    5973                 :     3954702 :           {
    5974                 :     3954702 :             gswitch *switch_stmt = as_a <gswitch *> (stmt);
    5975                 :     3954702 :             tree prev;
    5976                 :     3954702 :             edge e;
    5977                 :     3954702 :             size_t i, n;
    5978                 :             : 
    5979                 :     3954702 :             n = gimple_switch_num_labels (switch_stmt);
    5980                 :             : 
    5981                 :             :             /* Mark all the destination basic blocks.  */
    5982                 :    32618537 :             for (i = 0; i < n; ++i)
    5983                 :             :               {
    5984                 :    28663835 :                 basic_block label_bb = gimple_switch_label_bb (cfun, switch_stmt, i);
    5985                 :    28663835 :                 gcc_assert (!label_bb->aux || label_bb->aux == (void *)1);
    5986                 :    28663835 :                 label_bb->aux = (void *)1;
    5987                 :             :               }
    5988                 :             : 
    5989                 :             :             /* Verify that the case labels are sorted.  */
    5990                 :     3954702 :             prev = gimple_switch_label (switch_stmt, 0);
    5991                 :    28663835 :             for (i = 1; i < n; ++i)
    5992                 :             :               {
    5993                 :    24709133 :                 tree c = gimple_switch_label (switch_stmt, i);
    5994                 :    24709133 :                 if (!CASE_LOW (c))
    5995                 :             :                   {
    5996                 :           0 :                     error ("found default case not at the start of "
    5997                 :             :                            "case vector");
    5998                 :           0 :                     err = true;
    5999                 :           0 :                     continue;
    6000                 :             :                   }
    6001                 :    24709133 :                 if (CASE_LOW (prev)
    6002                 :    24709133 :                     && !tree_int_cst_lt (CASE_LOW (prev), CASE_LOW (c)))
    6003                 :             :                   {
    6004                 :           0 :                     error ("case labels not sorted: ");
    6005                 :           0 :                     print_generic_expr (stderr, prev);
    6006                 :           0 :                     fprintf (stderr," is greater than ");
    6007                 :           0 :                     print_generic_expr (stderr, c);
    6008                 :           0 :                     fprintf (stderr," but comes before it.\n");
    6009                 :           0 :                     err = true;
    6010                 :             :                   }
    6011                 :             :                 prev = c;
    6012                 :             :               }
    6013                 :             :             /* VRP will remove the default case if it can prove it will
    6014                 :             :                never be executed.  So do not verify there always exists
    6015                 :             :                a default case here.  */
    6016                 :             : 
    6017                 :    28906537 :             FOR_EACH_EDGE (e, ei, bb->succs)
    6018                 :             :               {
    6019                 :    24951835 :                 if (!e->dest->aux)
    6020                 :             :                   {
    6021                 :           0 :                     error ("extra outgoing edge %d->%d",
    6022                 :             :                            bb->index, e->dest->index);
    6023                 :           0 :                     err = true;
    6024                 :             :                   }
    6025                 :             : 
    6026                 :    24951835 :                 e->dest->aux = (void *)2;
    6027                 :    24951835 :                 if ((e->flags & (EDGE_FALLTHRU | EDGE_ABNORMAL
    6028                 :             :                                  | EDGE_TRUE_VALUE | EDGE_FALSE_VALUE)))
    6029                 :             :                   {
    6030                 :           0 :                     error ("wrong outgoing edge flags at end of bb %d",
    6031                 :             :                            bb->index);
    6032                 :           0 :                     err = true;
    6033                 :             :                   }
    6034                 :             :               }
    6035                 :             : 
    6036                 :             :             /* Check that we have all of them.  */
    6037                 :    32618537 :             for (i = 0; i < n; ++i)
    6038                 :             :               {
    6039                 :    28663835 :                 basic_block label_bb = gimple_switch_label_bb (cfun,
    6040                 :             :                                                                switch_stmt, i);
    6041                 :             : 
    6042                 :    28663835 :                 if (label_bb->aux != (void *)2)
    6043                 :             :                   {
    6044                 :           0 :                     error ("missing edge %i->%i", bb->index, label_bb->index);
    6045                 :           0 :                     err = true;
    6046                 :             :                   }
    6047                 :             :               }
    6048                 :             : 
    6049                 :    28906537 :             FOR_EACH_EDGE (e, ei, bb->succs)
    6050                 :    24951835 :               e->dest->aux = (void *)0;
    6051                 :             :           }
    6052                 :     3954702 :           break;
    6053                 :             : 
    6054                 :     1832647 :         case GIMPLE_EH_DISPATCH:
    6055                 :     1832647 :           if (verify_eh_dispatch_edge (as_a <geh_dispatch *> (stmt)))
    6056                 :           0 :             err = true;
    6057                 :             :           break;
    6058                 :             : 
    6059                 :             :         default:
    6060                 :             :           break;
    6061                 :             :         }
    6062                 :             :     }
    6063                 :             : 
    6064                 :   220208379 :   if (dom_info_state (CDI_DOMINATORS) >= DOM_NO_FAST_QUERY)
    6065                 :   179941885 :     verify_dominators (CDI_DOMINATORS);
    6066                 :             : 
    6067                 :   220208379 :   return err;
    6068                 :             : }
    6069                 :             : 
    6070                 :             : #if __GNUC__ >= 10
    6071                 :             : #  pragma GCC diagnostic pop
    6072                 :             : #endif
    6073                 :             : 
    6074                 :             : /* Updates phi nodes after creating a forwarder block joined
    6075                 :             :    by edge FALLTHRU.  */
    6076                 :             : 
    6077                 :             : static void
    6078                 :      204224 : gimple_make_forwarder_block (edge fallthru)
    6079                 :             : {
    6080                 :      204224 :   edge e;
    6081                 :      204224 :   edge_iterator ei;
    6082                 :      204224 :   basic_block dummy, bb;
    6083                 :      204224 :   tree var;
    6084                 :      204224 :   gphi_iterator gsi;
    6085                 :      204224 :   bool forward_location_p;
    6086                 :             : 
    6087                 :      204224 :   dummy = fallthru->src;
    6088                 :      204224 :   bb = fallthru->dest;
    6089                 :             : 
    6090                 :      204224 :   if (single_pred_p (bb))
    6091                 :         142 :     return;
    6092                 :             : 
    6093                 :             :   /* We can forward location info if we have only one predecessor.  */
    6094                 :      204082 :   forward_location_p = single_pred_p (dummy);
    6095                 :             : 
    6096                 :             :   /* If we redirected a branch we must create new PHI nodes at the
    6097                 :             :      start of BB.  */
    6098                 :      711697 :   for (gsi = gsi_start_phis (dummy); !gsi_end_p (gsi); gsi_next (&gsi))
    6099                 :             :     {
    6100                 :      507615 :       gphi *phi, *new_phi;
    6101                 :             : 
    6102                 :      507615 :       phi = gsi.phi ();
    6103                 :      507615 :       var = gimple_phi_result (phi);
    6104                 :      507615 :       new_phi = create_phi_node (var, bb);
    6105                 :      507615 :       gimple_phi_set_result (phi, copy_ssa_name (var, phi));
    6106                 :      507669 :       add_phi_arg (new_phi, gimple_phi_result (phi), fallthru,
    6107                 :             :                    forward_location_p
    6108                 :          54 :                    ? gimple_phi_arg_location (phi, 0) : UNKNOWN_LOCATION);
    6109                 :             :     }
    6110                 :             : 
    6111                 :             :   /* Add the arguments we have stored on edges.  */
    6112                 :      620686 :   FOR_EACH_EDGE (e, ei, bb->preds)
    6113                 :             :     {
    6114                 :      416604 :       if (e == fallthru)
    6115                 :      204082 :         continue;
    6116                 :             : 
    6117                 :      212522 :       flush_pending_stmts (e);
    6118                 :             :     }
    6119                 :             : }
    6120                 :             : 
    6121                 :             : 
    6122                 :             : /* Return a non-special label in the head of basic block BLOCK.
    6123                 :             :    Create one if it doesn't exist.  */
    6124                 :             : 
    6125                 :             : tree
    6126                 :     6123925 : gimple_block_label (basic_block bb)
    6127                 :             : {
    6128                 :     6123925 :   gimple_stmt_iterator i, s = gsi_start_bb (bb);
    6129                 :     6123925 :   bool first = true;
    6130                 :     6123925 :   tree label;
    6131                 :     6123925 :   glabel *stmt;
    6132                 :             : 
    6133                 :     6123925 :   for (i = s; !gsi_end_p (i); first = false, gsi_next (&i))
    6134                 :             :     {
    6135                 :     4898802 :       stmt = dyn_cast <glabel *> (gsi_stmt (i));
    6136                 :     4809870 :       if (!stmt)
    6137                 :             :         break;
    6138                 :     4809870 :       label = gimple_label_label (stmt);
    6139                 :     4809870 :       if (!DECL_NONLOCAL (label))
    6140                 :             :         {
    6141                 :     4809870 :           if (!first)
    6142                 :           0 :             gsi_move_before (&i, &s);
    6143                 :     4809870 :           return label;
    6144                 :             :         }
    6145                 :             :     }
    6146                 :             : 
    6147                 :     1314055 :   label = create_artificial_label (UNKNOWN_LOCATION);
    6148                 :     1314055 :   stmt = gimple_build_label (label);
    6149                 :     1314055 :   gsi_insert_before (&s, stmt, GSI_NEW_STMT);
    6150                 :     1314055 :   return label;
    6151                 :             : }
    6152                 :             : 
    6153                 :             : 
    6154                 :             : /* Attempt to perform edge redirection by replacing a possibly complex
    6155                 :             :    jump instruction by a goto or by removing the jump completely.
    6156                 :             :    This can apply only if all edges now point to the same block.  The
    6157                 :             :    parameters and return values are equivalent to
    6158                 :             :    redirect_edge_and_branch.  */
    6159                 :             : 
    6160                 :             : static edge
    6161                 :    56357612 : gimple_try_redirect_by_replacing_jump (edge e, basic_block target)
    6162                 :             : {
    6163                 :    56357612 :   basic_block src = e->src;
    6164                 :    56357612 :   gimple_stmt_iterator i;
    6165                 :    56357612 :   gimple *stmt;
    6166                 :             : 
    6167                 :             :   /* We can replace or remove a complex jump only when we have exactly
    6168                 :             :      two edges.  */
    6169                 :   112411431 :   if (EDGE_COUNT (src->succs) != 2
    6170                 :             :       /* Verify that all targets will be TARGET.  Specifically, the
    6171                 :             :          edge that is not E must also go to TARGET.  */
    6172                 :    56357612 :       || EDGE_SUCC (src, EDGE_SUCC (src, 0) == e)->dest != target)
    6173                 :             :     return NULL;
    6174                 :             : 
    6175                 :      303823 :   i = gsi_last_bb (src);
    6176                 :      303823 :   if (gsi_end_p (i))
    6177                 :             :     return NULL;
    6178                 :             : 
    6179                 :      303823 :   stmt = gsi_stmt (i);
    6180                 :             : 
    6181                 :      303823 :   if (gimple_code (stmt) == GIMPLE_COND || gimple_code (stmt) == GIMPLE_SWITCH)
    6182                 :             :     {
    6183                 :      303793 :       gsi_remove (&i, true);
    6184                 :      303793 :       e = ssa_redirect_edge (e, target);
    6185                 :      303793 :       e->flags = EDGE_FALLTHRU;
    6186                 :      303793 :       return e;
    6187                 :             :     }
    6188                 :             : 
    6189                 :             :   return NULL;
    6190                 :             : }
    6191                 :             : 
    6192                 :             : 
    6193                 :             : /* Redirect E to DEST.  Return NULL on failure.  Otherwise, return the
    6194                 :             :    edge representing the redirected branch.  */
    6195                 :             : 
    6196                 :             : static edge
    6197                 :    57684315 : gimple_redirect_edge_and_branch (edge e, basic_block dest)
    6198                 :             : {
    6199                 :    57684315 :   basic_block bb = e->src;
    6200                 :    57684315 :   gimple_stmt_iterator gsi;
    6201                 :    57684315 :   edge ret;
    6202                 :    57684315 :   gimple *stmt;
    6203                 :             : 
    6204                 :    57684315 :   if (e->flags & EDGE_ABNORMAL)
    6205                 :             :     return NULL;
    6206                 :             : 
    6207                 :    57684315 :   if (e->dest == dest)
    6208                 :             :     return NULL;
    6209                 :             : 
    6210                 :    57661083 :   if (e->flags & EDGE_EH)
    6211                 :     1092291 :     return redirect_eh_edge (e, dest);
    6212                 :             : 
    6213                 :    56568792 :   if (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun))
    6214                 :             :     {
    6215                 :    56357612 :       ret = gimple_try_redirect_by_replacing_jump (e, dest);
    6216                 :    56357612 :       if (ret)
    6217                 :             :         return ret;
    6218                 :             :     }
    6219                 :             : 
    6220                 :    56264999 :   gsi = gsi_last_nondebug_bb (bb);
    6221                 :    56264999 :   stmt = gsi_end_p (gsi) ? NULL : gsi_stmt (gsi);
    6222                 :             : 
    6223                 :    56264999 :   switch (stmt ? gimple_code (stmt) : GIMPLE_ERROR_MARK)
    6224                 :             :     {
    6225                 :             :     case GIMPLE_COND:
    6226                 :             :       /* For COND_EXPR, we only need to redirect the edge.  */
    6227                 :             :       break;
    6228                 :             : 
    6229                 :           0 :     case GIMPLE_GOTO:
    6230                 :             :       /* No non-abnormal edges should lead from a non-simple goto, and
    6231                 :             :          simple ones should be represented implicitly.  */
    6232                 :           0 :       gcc_unreachable ();
    6233                 :             : 
    6234                 :      369249 :     case GIMPLE_SWITCH:
    6235                 :      369249 :       {
    6236                 :      369249 :         gswitch *switch_stmt = as_a <gswitch *> (stmt);
    6237                 :      369249 :         tree label = gimple_block_label (dest);
    6238                 :      369249 :         tree cases = get_cases_for_edge (e, switch_stmt);
    6239                 :             : 
    6240                 :             :         /* If we have a list of cases associated with E, then use it
    6241                 :             :            as it's a lot faster than walking the entire case vector.  */
    6242                 :      369249 :         if (cases)
    6243                 :             :           {
    6244                 :      324091 :             edge e2 = find_edge (e->src, dest);
    6245                 :      324091 :             tree last, first;
    6246                 :             : 
    6247                 :      324091 :             first = cases;
    6248                 :     1029481 :             while (cases)
    6249                 :             :               {
    6250                 :      381299 :                 last = cases;
    6251                 :      381299 :                 CASE_LABEL (cases) = label;
    6252                 :      381299 :                 cases = CASE_CHAIN (cases);
    6253                 :             :               }
    6254                 :             : 
    6255                 :             :             /* If there was already an edge in the CFG, then we need
    6256                 :             :                to move all the cases associated with E to E2.  */
    6257                 :      324091 :             if (e2)
    6258                 :             :               {
    6259                 :        8851 :                 tree cases2 = get_cases_for_edge (e2, switch_stmt);
    6260                 :             : 
    6261                 :        8851 :                 CASE_CHAIN (last) = CASE_CHAIN (cases2);
    6262                 :        8851 :                 CASE_CHAIN (cases2) = first;
    6263                 :             :               }
    6264                 :      324091 :             bitmap_set_bit (touched_switch_bbs, gimple_bb (stmt)->index);
    6265                 :             :           }
    6266                 :             :         else
    6267                 :             :           {
    6268                 :       45158 :             size_t i, n = gimple_switch_num_labels (switch_stmt);
    6269                 :             : 
    6270                 :     4570473 :             for (i = 0; i < n; i++)
    6271                 :             :               {
    6272                 :     4525315 :                 tree elt = gimple_switch_label (switch_stmt, i);
    6273                 :     4525315 :                 if (label_to_block (cfun, CASE_LABEL (elt)) == e->dest)
    6274                 :       51671 :                   CASE_LABEL (elt) = label;
    6275                 :             :               }
    6276                 :             :           }
    6277                 :             :       }
    6278                 :             :       break;
    6279                 :             : 
    6280                 :       10672 :     case GIMPLE_ASM:
    6281                 :       10672 :       {
    6282                 :       10672 :         gasm *asm_stmt = as_a <gasm *> (stmt);
    6283                 :       10672 :         int i, n = gimple_asm_nlabels (asm_stmt);
    6284                 :       10672 :         tree label = NULL;
    6285                 :             : 
    6286                 :       14060 :         for (i = 0; i < n; ++i)
    6287                 :             :           {
    6288                 :        3388 :             tree cons = gimple_asm_label_op (asm_stmt, i);
    6289                 :        3388 :             if (label_to_block (cfun, TREE_VALUE (cons)) == e->dest)
    6290                 :             :               {
    6291                 :        1654 :                 if (!label)
    6292                 :        1628 :                   label = gimple_block_label (dest);
    6293                 :        1654 :                 TREE_VALUE (cons) = label;
    6294                 :             :               }
    6295                 :             :           }
    6296                 :             : 
    6297                 :             :         /* If we didn't find any label matching the former edge in the
    6298                 :             :            asm labels, we must be redirecting the fallthrough
    6299                 :             :            edge.  */
    6300                 :       10672 :         gcc_assert (label || (e->flags & EDGE_FALLTHRU));
    6301                 :             :       }
    6302                 :             :       break;
    6303                 :             : 
    6304                 :         228 :     case GIMPLE_RETURN:
    6305                 :         228 :       gsi_remove (&gsi, true);
    6306                 :         228 :       e->flags |= EDGE_FALLTHRU;
    6307                 :         228 :       break;
    6308                 :             : 
    6309                 :             :     case GIMPLE_OMP_RETURN:
    6310                 :             :     case GIMPLE_OMP_CONTINUE:
    6311                 :             :     case GIMPLE_OMP_SECTIONS_SWITCH:
    6312                 :             :     case GIMPLE_OMP_FOR:
    6313                 :             :       /* The edges from OMP constructs can be simply redirected.  */
    6314                 :             :       break;
    6315                 :             : 
    6316                 :           0 :     case GIMPLE_EH_DISPATCH:
    6317                 :           0 :       if (!(e->flags & EDGE_FALLTHRU))
    6318                 :           0 :         redirect_eh_dispatch_edge (as_a <geh_dispatch *> (stmt), e, dest);
    6319                 :             :       break;
    6320                 :             : 
    6321                 :         348 :     case GIMPLE_TRANSACTION:
    6322                 :         348 :       if (e->flags & EDGE_TM_ABORT)
    6323                 :          81 :         gimple_transaction_set_label_over (as_a <gtransaction *> (stmt),
    6324                 :             :                                            gimple_block_label (dest));
    6325                 :         267 :       else if (e->flags & EDGE_TM_UNINSTRUMENTED)
    6326                 :         130 :         gimple_transaction_set_label_uninst (as_a <gtransaction *> (stmt),
    6327                 :             :                                              gimple_block_label (dest));
    6328                 :             :       else
    6329                 :         137 :         gimple_transaction_set_label_norm (as_a <gtransaction *> (stmt),
    6330                 :             :                                            gimple_block_label (dest));
    6331                 :             :       break;
    6332                 :             : 
    6333                 :     8187974 :     default:
    6334                 :             :       /* Otherwise it must be a fallthru edge, and we don't need to
    6335                 :             :          do anything besides redirecting it.  */
    6336                 :     8187974 :       gcc_assert (e->flags & EDGE_FALLTHRU);
    6337                 :             :       break;
    6338                 :             :     }
    6339                 :             : 
    6340                 :             :   /* Update/insert PHI nodes as necessary.  */
    6341                 :             : 
    6342                 :             :   /* Now update the edges in the CFG.  */
    6343                 :    56264999 :   e = ssa_redirect_edge (e, dest);
    6344                 :             : 
    6345                 :    56264999 :   return e;
    6346                 :             : }
    6347                 :             : 
    6348                 :             : /* Returns true if it is possible to remove edge E by redirecting
    6349                 :             :    it to the destination of the other edge from E->src.  */
    6350                 :             : 
    6351                 :             : static bool
    6352                 :      238454 : gimple_can_remove_branch_p (const_edge e)
    6353                 :             : {
    6354                 :      238454 :   if (e->flags & (EDGE_ABNORMAL | EDGE_EH))
    6355                 :           0 :     return false;
    6356                 :             : 
    6357                 :             :   return true;
    6358                 :             : }
    6359                 :             : 
    6360                 :             : /* Simple wrapper, as we can always redirect fallthru edges.  */
    6361                 :             : 
    6362                 :             : static basic_block
    6363                 :     2978726 : gimple_redirect_edge_and_branch_force (edge e, basic_block dest)
    6364                 :             : {
    6365                 :     2978726 :   e = gimple_redirect_edge_and_branch (e, dest);
    6366                 :     2978726 :   gcc_assert (e);
    6367                 :             : 
    6368                 :     2978726 :   return NULL;
    6369                 :             : }
    6370                 :             : 
    6371                 :             : 
    6372                 :             : /* Splits basic block BB after statement STMT (but at least after the
    6373                 :             :    labels).  If STMT is NULL, BB is split just after the labels.  */
    6374                 :             : 
    6375                 :             : static basic_block
    6376                 :     4982820 : gimple_split_block (basic_block bb, void *stmt)
    6377                 :             : {
    6378                 :     4982820 :   gimple_stmt_iterator gsi;
    6379                 :     4982820 :   gimple_stmt_iterator gsi_tgt;
    6380                 :     4982820 :   gimple_seq list;
    6381                 :     4982820 :   basic_block new_bb;
    6382                 :     4982820 :   edge e;
    6383                 :     4982820 :   edge_iterator ei;
    6384                 :             : 
    6385                 :     4982820 :   new_bb = create_empty_bb (bb);
    6386                 :             : 
    6387                 :             :   /* Redirect the outgoing edges.  */
    6388                 :     4982820 :   new_bb->succs = bb->succs;
    6389                 :     4982820 :   bb->succs = NULL;
    6390                 :    11596974 :   FOR_EACH_EDGE (e, ei, new_bb->succs)
    6391                 :     6614154 :     e->src = new_bb;
    6392                 :             : 
    6393                 :             :   /* Get a stmt iterator pointing to the first stmt to move.  */
    6394                 :     4982820 :   if (!stmt || gimple_code ((gimple *) stmt) == GIMPLE_LABEL)
    6395                 :     1417212 :     gsi = gsi_after_labels (bb);
    6396                 :             :   else
    6397                 :             :     {
    6398                 :     3565608 :       gsi = gsi_for_stmt ((gimple *) stmt);
    6399                 :     3565608 :       gsi_next (&gsi);
    6400                 :             :     }
    6401                 :             : 
    6402                 :             :   /* Move everything from GSI to the new basic block.  */
    6403                 :     4982820 :   if (gsi_end_p (gsi))
    6404                 :             :     return new_bb;
    6405                 :             : 
    6406                 :             :   /* Split the statement list - avoid re-creating new containers as this
    6407                 :             :      brings ugly quadratic memory consumption in the inliner.
    6408                 :             :      (We are still quadratic since we need to update stmt BB pointers,
    6409                 :             :      sadly.)  */
    6410                 :     4586473 :   gsi_split_seq_before (&gsi, &list);
    6411                 :     4586473 :   set_bb_seq (new_bb, list);
    6412                 :     4586473 :   for (gsi_tgt = gsi_start (list);
    6413                 :    26352213 :        !gsi_end_p (gsi_tgt); gsi_next (&gsi_tgt))
    6414                 :    21765740 :     gimple_set_bb (gsi_stmt (gsi_tgt), new_bb);
    6415                 :             : 
    6416                 :             :   return new_bb;
    6417                 :             : }
    6418                 :             : 
    6419                 :             : 
    6420                 :             : /* Moves basic block BB after block AFTER.  */
    6421                 :             : 
    6422                 :             : static bool
    6423                 :    18584348 : gimple_move_block_after (basic_block bb, basic_block after)
    6424                 :             : {
    6425                 :    18584348 :   if (bb->prev_bb == after)
    6426                 :             :     return true;
    6427                 :             : 
    6428                 :     4710401 :   unlink_block (bb);
    6429                 :     4710401 :   link_block (bb, after);
    6430                 :             : 
    6431                 :     4710401 :   return true;
    6432                 :             : }
    6433                 :             : 
    6434                 :             : 
    6435                 :             : /* Return TRUE if block BB has no executable statements, otherwise return
    6436                 :             :    FALSE.  */
    6437                 :             : 
    6438                 :             : static bool
    6439                 :    12042670 : gimple_empty_block_p (basic_block bb)
    6440                 :             : {
    6441                 :             :   /* BB must have no executable statements.  */
    6442                 :    12042670 :   gimple_stmt_iterator gsi = gsi_after_labels (bb);
    6443                 :    12042670 :   if (phi_nodes (bb))
    6444                 :             :     return false;
    6445                 :    14225463 :   while (!gsi_end_p (gsi))
    6446                 :             :     {
    6447                 :     5592168 :       gimple *stmt = gsi_stmt (gsi);
    6448                 :     5592168 :       if (is_gimple_debug (stmt))
    6449                 :             :         ;
    6450                 :     2615433 :       else if (gimple_code (stmt) == GIMPLE_NOP
    6451                 :     2615433 :                || gimple_code (stmt) == GIMPLE_PREDICT)
    6452                 :             :         ;
    6453                 :             :       else
    6454                 :             :         return false;
    6455                 :     3029604 :       gsi_next (&gsi);
    6456                 :             :     }
    6457                 :             :   return true;
    6458                 :             : }
    6459                 :             : 
    6460                 :             : 
    6461                 :             : /* Split a basic block if it ends with a conditional branch and if the
    6462                 :             :    other part of the block is not empty.  */
    6463                 :             : 
    6464                 :             : static basic_block
    6465                 :         567 : gimple_split_block_before_cond_jump (basic_block bb)
    6466                 :             : {
    6467                 :         567 :   gimple *last, *split_point;
    6468                 :         567 :   gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
    6469                 :         567 :   if (gsi_end_p (gsi))
    6470                 :             :     return NULL;
    6471                 :         567 :   last = gsi_stmt (gsi);
    6472                 :         567 :   if (gimple_code (last) != GIMPLE_COND
    6473                 :         567 :       && gimple_code (last) != GIMPLE_SWITCH)
    6474                 :             :     return NULL;
    6475                 :         567 :   gsi_prev (&gsi);
    6476                 :         567 :   split_point = gsi_stmt (gsi);
    6477                 :         567 :   return split_block (bb, split_point)->dest;
    6478                 :             : }
    6479                 :             : 
    6480                 :             : 
    6481                 :             : /* Return true if basic_block can be duplicated.  */
    6482                 :             : 
    6483                 :             : static bool
    6484                 :     7752746 : gimple_can_duplicate_bb_p (const_basic_block bb)
    6485                 :             : {
    6486                 :     7752746 :   gimple *last = last_nondebug_stmt (CONST_CAST_BB (bb));
    6487                 :             : 
    6488                 :             :   /* Do checks that can only fail for the last stmt, to minimize the work in the
    6489                 :             :      stmt loop.  */
    6490                 :     7752746 :   if (last) {
    6491                 :             :     /* A transaction is a single entry multiple exit region.  It
    6492                 :             :        must be duplicated in its entirety or not at all.  */
    6493                 :     6578340 :     if (gimple_code (last) == GIMPLE_TRANSACTION)
    6494                 :             :       return false;
    6495                 :             : 
    6496                 :             :     /* An IFN_UNIQUE call must be duplicated as part of its group,
    6497                 :             :        or not at all.  */
    6498                 :     6578339 :     if (is_gimple_call (last)
    6499                 :       59601 :         && gimple_call_internal_p (last)
    6500                 :     6578594 :         && gimple_call_internal_unique_p (last))
    6501                 :             :       return false;
    6502                 :             : 
    6503                 :             :     /* Prohibit duplication of returns_twice calls, otherwise associated
    6504                 :             :        abnormal edges also need to be duplicated properly.
    6505                 :             :        return_twice functions will always be the last statement.  */
    6506                 :     6578339 :     if (is_gimple_call (last)
    6507                 :     6578339 :         && (gimple_call_flags (last) & ECF_RETURNS_TWICE))
    6508                 :             :       return false;
    6509                 :             :   }
    6510                 :             : 
    6511                 :    15505388 :   for (gimple_stmt_iterator gsi = gsi_start_bb (CONST_CAST_BB (bb));
    6512                 :    47363668 :        !gsi_end_p (gsi); gsi_next (&gsi))
    6513                 :             :     {
    6514                 :    39610974 :       gimple *g = gsi_stmt (gsi);
    6515                 :             : 
    6516                 :             :       /* An IFN_GOMP_SIMT_ENTER_ALLOC/IFN_GOMP_SIMT_EXIT call must be
    6517                 :             :          duplicated as part of its group, or not at all.
    6518                 :             :          The IFN_GOMP_SIMT_VOTE_ANY and IFN_GOMP_SIMT_XCHG_* are part of such a
    6519                 :             :          group, so the same holds there.  */
    6520                 :    39610974 :       if (is_gimple_call (g)
    6521                 :    39610974 :           && (gimple_call_internal_p (g, IFN_GOMP_SIMT_ENTER_ALLOC)
    6522                 :      438310 :               || gimple_call_internal_p (g, IFN_GOMP_SIMT_EXIT)
    6523                 :      438310 :               || gimple_call_internal_p (g, IFN_GOMP_SIMT_VOTE_ANY)
    6524                 :      438310 :               || gimple_call_internal_p (g, IFN_GOMP_SIMT_XCHG_BFLY)
    6525                 :      438310 :               || gimple_call_internal_p (g, IFN_GOMP_SIMT_XCHG_IDX)))
    6526                 :          52 :         return false;
    6527                 :             :     }
    6528                 :             : 
    6529                 :             :   return true;
    6530                 :             : }
    6531                 :             : 
    6532                 :             : /* Create a duplicate of the basic block BB.  NOTE: This does not
    6533                 :             :    preserve SSA form.  */
    6534                 :             : 
    6535                 :             : static basic_block
    6536                 :     3195480 : gimple_duplicate_bb (basic_block bb, copy_bb_data *id)
    6537                 :             : {
    6538                 :     3195480 :   basic_block new_bb;
    6539                 :     3195480 :   gimple_stmt_iterator gsi_tgt;
    6540                 :             : 
    6541                 :     3195480 :   new_bb = create_empty_bb (EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb);
    6542                 :             : 
    6543                 :             :   /* Copy the PHI nodes.  We ignore PHI node arguments here because
    6544                 :             :      the incoming edges have not been setup yet.  */
    6545                 :     3195480 :   for (gphi_iterator gpi = gsi_start_phis (bb);
    6546                 :     7578639 :        !gsi_end_p (gpi);
    6547                 :     4383159 :        gsi_next (&gpi))
    6548                 :             :     {
    6549                 :     4383159 :       gphi *phi, *copy;
    6550                 :     4383159 :       phi = gpi.phi ();
    6551                 :     4383159 :       copy = create_phi_node (NULL_TREE, new_bb);
    6552                 :     4383159 :       create_new_def_for (gimple_phi_result (phi), copy,
    6553                 :             :                           gimple_phi_result_ptr (copy));
    6554                 :     4383159 :       gimple_set_uid (copy, gimple_uid (phi));
    6555                 :             :     }
    6556                 :             : 
    6557                 :     3195480 :   gsi_tgt = gsi_start_bb (new_bb);
    6558                 :     6390960 :   for (gimple_stmt_iterator gsi = gsi_start_bb (bb);
    6559                 :    18514443 :        !gsi_end_p (gsi);
    6560                 :    15318963 :        gsi_next (&gsi))
    6561                 :             :     {
    6562                 :    15318963 :       def_operand_p def_p;
    6563                 :    15318963 :       ssa_op_iter op_iter;
    6564                 :    15318963 :       tree lhs;
    6565                 :    15318963 :       gimple *stmt, *copy;
    6566                 :             : 
    6567                 :    15318963 :       stmt = gsi_stmt (gsi);
    6568                 :    15318963 :       if (gimple_code (stmt) == GIMPLE_LABEL)
    6569                 :       59511 :         continue;
    6570                 :             : 
    6571                 :             :       /* Don't duplicate label debug stmts.  */
    6572                 :    15260896 :       if (gimple_debug_bind_p (stmt)
    6573                 :     8420465 :           && TREE_CODE (gimple_debug_bind_get_var (stmt))
    6574                 :             :              == LABEL_DECL)
    6575                 :        1444 :         continue;
    6576                 :             : 
    6577                 :             :       /* Create a new copy of STMT and duplicate STMT's virtual
    6578                 :             :          operands.  */
    6579                 :    15259452 :       copy = gimple_copy (stmt);
    6580                 :    15259452 :       gsi_insert_after (&gsi_tgt, copy, GSI_NEW_STMT);
    6581                 :             : 
    6582                 :    15259452 :       maybe_duplicate_eh_stmt (copy, stmt);
    6583                 :    15259452 :       gimple_duplicate_stmt_histograms (cfun, copy, cfun, stmt);
    6584                 :             : 
    6585                 :             :       /* When copying around a stmt writing into a local non-user
    6586                 :             :          aggregate, make sure it won't share stack slot with other
    6587                 :             :          vars.  */
    6588                 :    15259452 :       lhs = gimple_get_lhs (stmt);
    6589                 :    15259452 :       if (lhs && TREE_CODE (lhs) != SSA_NAME)
    6590                 :             :         {
    6591                 :      641847 :           tree base = get_base_address (lhs);
    6592                 :      641847 :           if (base
    6593                 :      641847 :               && (VAR_P (base) || TREE_CODE (base) == RESULT_DECL)
    6594                 :      432862 :               && DECL_IGNORED_P (base)
    6595                 :      166276 :               && !TREE_STATIC (base)
    6596                 :      165074 :               && !DECL_EXTERNAL (base)
    6597                 :      806915 :               && (!VAR_P (base) || !DECL_HAS_VALUE_EXPR_P (base)))
    6598                 :      165068 :             DECL_NONSHAREABLE (base) = 1;
    6599                 :             :         }
    6600                 :             : 
    6601                 :             :       /* If requested remap dependence info of cliques brought in
    6602                 :             :          via inlining.  */
    6603                 :    15259452 :       if (id)
    6604                 :    42932948 :         for (unsigned i = 0; i < gimple_num_ops (copy); ++i)
    6605                 :             :           {
    6606                 :    30002981 :             tree op = gimple_op (copy, i);
    6607                 :    30002981 :             if (!op)
    6608                 :     7471116 :               continue;
    6609                 :    22531865 :             if (TREE_CODE (op) == ADDR_EXPR
    6610                 :    21774475 :                 || TREE_CODE (op) == WITH_SIZE_EXPR)
    6611                 :      757390 :               op = TREE_OPERAND (op, 0);
    6612                 :    24035706 :             while (handled_component_p (op))
    6613                 :     1503841 :               op = TREE_OPERAND (op, 0);
    6614                 :    22531865 :             if ((TREE_CODE (op) == MEM_REF
    6615                 :    22531865 :                  || TREE_CODE (op) == TARGET_MEM_REF)
    6616                 :      816475 :                 && MR_DEPENDENCE_CLIQUE (op) > 1
    6617                 :    22583640 :                 && MR_DEPENDENCE_CLIQUE (op) != bb->loop_father->owned_clique)
    6618                 :             :               {
    6619                 :       25572 :                 if (!id->dependence_map)
    6620                 :       10857 :                   id->dependence_map = new hash_map<dependence_hash,
    6621                 :             :                                                     unsigned short>;
    6622                 :       25572 :                 bool existed;
    6623                 :       25572 :                 unsigned short &newc = id->dependence_map->get_or_insert
    6624                 :       25572 :                     (MR_DEPENDENCE_CLIQUE (op), &existed);
    6625                 :       25572 :                 if (!existed)
    6626                 :             :                   {
    6627                 :       15587 :                     gcc_assert (MR_DEPENDENCE_CLIQUE (op) <= cfun->last_clique);
    6628                 :       31174 :                     newc = get_new_clique (cfun);
    6629                 :             :                   }
    6630                 :       25572 :                 MR_DEPENDENCE_CLIQUE (op) = newc;
    6631                 :             :               }
    6632                 :             :           }
    6633                 :             : 
    6634                 :             :       /* Create new names for all the definitions created by COPY and
    6635                 :             :          add replacement mappings for each new name.  */
    6636                 :    19565350 :       FOR_EACH_SSA_DEF_OPERAND (def_p, copy, op_iter, SSA_OP_ALL_DEFS)
    6637                 :     4305898 :         create_new_def_for (DEF_FROM_PTR (def_p), copy, def_p);
    6638                 :             :     }
    6639                 :             : 
    6640                 :     3195480 :   return new_bb;
    6641                 :             : }
    6642                 :             : 
    6643                 :             : /* Adds phi node arguments for edge E_COPY after basic block duplication.  */
    6644                 :             : 
    6645                 :             : static void
    6646                 :     4237601 : add_phi_args_after_copy_edge (edge e_copy)
    6647                 :             : {
    6648                 :     4237601 :   basic_block bb, bb_copy = e_copy->src, dest;
    6649                 :     4237601 :   edge e;
    6650                 :     4237601 :   edge_iterator ei;
    6651                 :     4237601 :   gphi *phi, *phi_copy;
    6652                 :     4237601 :   tree def;
    6653                 :     4237601 :   gphi_iterator psi, psi_copy;
    6654                 :             : 
    6655                 :     4237601 :   if (gimple_seq_empty_p (phi_nodes (e_copy->dest)))
    6656                 :     2684388 :     return;
    6657                 :             : 
    6658                 :     1553213 :   bb = bb_copy->flags & BB_DUPLICATED ? get_bb_original (bb_copy) : bb_copy;
    6659                 :             : 
    6660                 :     1553213 :   if (e_copy->dest->flags & BB_DUPLICATED)
    6661                 :      636749 :     dest = get_bb_original (e_copy->dest);
    6662                 :             :   else
    6663                 :             :     dest = e_copy->dest;
    6664                 :             : 
    6665                 :     1553213 :   e = find_edge (bb, dest);
    6666                 :     1553213 :   if (!e)
    6667                 :             :     {
    6668                 :             :       /* During loop unrolling the target of the latch edge is copied.
    6669                 :             :          In this case we are not looking for edge to dest, but to
    6670                 :             :          duplicated block whose original was dest.  */
    6671                 :         941 :       FOR_EACH_EDGE (e, ei, bb->succs)
    6672                 :             :         {
    6673                 :         941 :           if ((e->dest->flags & BB_DUPLICATED)
    6674                 :         941 :               && get_bb_original (e->dest) == dest)
    6675                 :             :             break;
    6676                 :             :         }
    6677                 :             : 
    6678                 :         941 :       gcc_assert (e != NULL);
    6679                 :             :     }
    6680                 :             : 
    6681                 :     1553213 :   for (psi = gsi_start_phis (e->dest),
    6682                 :     1553213 :        psi_copy = gsi_start_phis (e_copy->dest);
    6683                 :     4582410 :        !gsi_end_p (psi);
    6684                 :     3029197 :        gsi_next (&psi), gsi_next (&psi_copy))
    6685                 :             :     {
    6686                 :     3029197 :       phi = psi.phi ();
    6687                 :     3029197 :       phi_copy = psi_copy.phi ();
    6688                 :     3029197 :       def = PHI_ARG_DEF_FROM_EDGE (phi, e);
    6689                 :     3029197 :       add_phi_arg (phi_copy, def, e_copy,
    6690                 :             :                    gimple_phi_arg_location_from_edge (phi, e));
    6691                 :             :     }
    6692                 :             : }
    6693                 :             : 
    6694                 :             : 
    6695                 :             : /* Basic block BB_COPY was created by code duplication.  Add phi node
    6696                 :             :    arguments for edges going out of BB_COPY.  The blocks that were
    6697                 :             :    duplicated have BB_DUPLICATED set.  */
    6698                 :             : 
    6699                 :             : void
    6700                 :     2935368 : add_phi_args_after_copy_bb (basic_block bb_copy)
    6701                 :             : {
    6702                 :     2935368 :   edge e_copy;
    6703                 :     2935368 :   edge_iterator ei;
    6704                 :             : 
    6705                 :     7172945 :   FOR_EACH_EDGE (e_copy, ei, bb_copy->succs)
    6706                 :             :     {
    6707                 :     4237577 :       add_phi_args_after_copy_edge (e_copy);
    6708                 :             :     }
    6709                 :     2935368 : }
    6710                 :             : 
    6711                 :             : /* Blocks in REGION_COPY array of length N_REGION were created by
    6712                 :             :    duplication of basic blocks.  Add phi node arguments for edges
    6713                 :             :    going from these blocks.  If E_COPY is not NULL, also add
    6714                 :             :    phi node arguments for its destination.*/
    6715                 :             : 
    6716                 :             : void
    6717                 :     1542804 : add_phi_args_after_copy (basic_block *region_copy, unsigned n_region,
    6718                 :             :                          edge e_copy)
    6719                 :             : {
    6720                 :     1542804 :   unsigned i;
    6721                 :             : 
    6722                 :     3574110 :   for (i = 0; i < n_region; i++)
    6723                 :     2031306 :     region_copy[i]->flags |= BB_DUPLICATED;
    6724                 :             : 
    6725                 :     3574110 :   for (i = 0; i < n_region; i++)
    6726                 :     2031306 :     add_phi_args_after_copy_bb (region_copy[i]);
    6727                 :     1542804 :   if (e_copy)
    6728                 :          24 :     add_phi_args_after_copy_edge (e_copy);
    6729                 :             : 
    6730                 :     3574110 :   for (i = 0; i < n_region; i++)
    6731                 :     2031306 :     region_copy[i]->flags &= ~BB_DUPLICATED;
    6732                 :     1542804 : }
    6733                 :             : 
    6734                 :             : /* Duplicates a REGION (set of N_REGION basic blocks) with just a single
    6735                 :             :    important exit edge EXIT.  By important we mean that no SSA name defined
    6736                 :             :    inside region is live over the other exit edges of the region.  All entry
    6737                 :             :    edges to the region must go to ENTRY->dest.  The edge ENTRY is redirected
    6738                 :             :    to the duplicate of the region.  Dominance and loop information is
    6739                 :             :    updated if UPDATE_DOMINANCE is true, but not the SSA web.  If
    6740                 :             :    UPDATE_DOMINANCE is false then we assume that the caller will update the
    6741                 :             :    dominance information after calling this function.  The new basic
    6742                 :             :    blocks are stored to REGION_COPY in the same order as they had in REGION,
    6743                 :             :    provided that REGION_COPY is not NULL.
    6744                 :             :    The function returns false if it is unable to copy the region,
    6745                 :             :    true otherwise.
    6746                 :             : 
    6747                 :             :    It is callers responsibility to update profile.  */
    6748                 :             : 
    6749                 :             : bool
    6750                 :      496320 : gimple_duplicate_seme_region (edge entry, edge exit,
    6751                 :             :                               basic_block *region, unsigned n_region,
    6752                 :             :                               basic_block *region_copy,
    6753                 :             :                               bool update_dominance)
    6754                 :             : {
    6755                 :      496320 :   unsigned i;
    6756                 :      496320 :   bool free_region_copy = false, copying_header = false;
    6757                 :      496320 :   class loop *loop = entry->dest->loop_father;
    6758                 :      496320 :   edge exit_copy;
    6759                 :      496320 :   edge redirected;
    6760                 :             : 
    6761                 :      496320 :   if (!can_copy_bbs_p (region, n_region))
    6762                 :             :     return false;
    6763                 :             : 
    6764                 :             :   /* Some sanity checking.  Note that we do not check for all possible
    6765                 :             :      missuses of the functions.  I.e. if you ask to copy something weird,
    6766                 :             :      it will work, but the state of structures probably will not be
    6767                 :             :      correct.  */
    6768                 :      998857 :   for (i = 0; i < n_region; i++)
    6769                 :             :     {
    6770                 :             :       /* We do not handle subloops, i.e. all the blocks must belong to the
    6771                 :             :          same loop.  */
    6772                 :      502537 :       if (region[i]->loop_father != loop)
    6773                 :             :         return false;
    6774                 :             : 
    6775                 :      502537 :       if (region[i] != entry->dest
    6776                 :        6217 :           && region[i] == loop->header)
    6777                 :             :         return false;
    6778                 :             :     }
    6779                 :             : 
    6780                 :             :   /* In case the function is used for loop header copying (which is the primary
    6781                 :             :      use), ensure that EXIT and its copy will be new latch and entry edges.  */
    6782                 :      496320 :   if (loop->header == entry->dest)
    6783                 :             :     {
    6784                 :      496320 :       copying_header = true;
    6785                 :             : 
    6786                 :      496320 :       if (!dominated_by_p (CDI_DOMINATORS, loop->latch, exit->src))
    6787                 :             :         return false;
    6788                 :             : 
    6789                 :      998857 :       for (i = 0; i < n_region; i++)
    6790                 :      502537 :         if (region[i] != exit->src
    6791                 :      502537 :             && dominated_by_p (CDI_DOMINATORS, region[i], exit->src))
    6792                 :             :           return false;
    6793                 :             :     }
    6794                 :             : 
    6795                 :      496320 :   initialize_original_copy_tables ();
    6796                 :             : 
    6797                 :      496320 :   if (copying_header)
    6798                 :      496320 :     set_loop_copy (loop, loop_outer (loop));
    6799                 :             :   else
    6800                 :           0 :     set_loop_copy (loop, loop);
    6801                 :             : 
    6802                 :      496320 :   if (!region_copy)
    6803                 :             :     {
    6804                 :           0 :       region_copy = XNEWVEC (basic_block, n_region);
    6805                 :           0 :       free_region_copy = true;
    6806                 :             :     }
    6807                 :             : 
    6808                 :             :   /* Record blocks outside the region that are dominated by something
    6809                 :             :      inside.  */
    6810                 :      496320 :   auto_vec<basic_block> doms;
    6811                 :      496320 :   if (update_dominance)
    6812                 :      496320 :     doms = get_dominated_by_region (CDI_DOMINATORS, region, n_region);
    6813                 :             : 
    6814                 :      496320 :   copy_bbs (region, n_region, region_copy, &exit, 1, &exit_copy, loop,
    6815                 :             :             split_edge_bb_loc (entry), update_dominance);
    6816                 :             : 
    6817                 :      496320 :   if (copying_header)
    6818                 :             :     {
    6819                 :      496320 :       loop->header = exit->dest;
    6820                 :      496320 :       loop->latch = exit->src;
    6821                 :             :     }
    6822                 :             : 
    6823                 :             :   /* Redirect the entry and add the phi node arguments.  */
    6824                 :      496320 :   redirected = redirect_edge_and_branch (entry, get_bb_copy (entry->dest));
    6825                 :      496320 :   gcc_assert (redirected != NULL);
    6826                 :      496320 :   flush_pending_stmts (entry);
    6827                 :             : 
    6828                 :             :   /* Concerning updating of dominators:  We must recount dominators
    6829                 :             :      for entry block and its copy.  Anything that is outside of the
    6830                 :             :      region, but was dominated by something inside needs recounting as
    6831                 :             :      well.  */
    6832                 :      496320 :   if (update_dominance)
    6833                 :             :     {
    6834                 :      496320 :       set_immediate_dominator (CDI_DOMINATORS, entry->dest, entry->src);
    6835                 :      496320 :       doms.safe_push (get_bb_original (entry->dest));
    6836                 :      496320 :       iterate_fix_dominators (CDI_DOMINATORS, doms, false);
    6837                 :             :     }
    6838                 :             : 
    6839                 :             :   /* Add the other PHI node arguments.  */
    6840                 :      496320 :   add_phi_args_after_copy (region_copy, n_region, NULL);
    6841                 :             : 
    6842                 :      496320 :   if (free_region_copy)
    6843                 :           0 :     free (region_copy);
    6844                 :             : 
    6845                 :      496320 :   free_original_copy_tables ();
    6846                 :      496320 :   return true;
    6847                 :      496320 : }
    6848                 :             : 
    6849                 :             : /* Checks if BB is part of the region defined by N_REGION BBS.  */
    6850                 :             : static bool
    6851                 :           0 : bb_part_of_region_p (basic_block bb, basic_block* bbs, unsigned n_region)
    6852                 :             : {
    6853                 :           0 :   unsigned int n;
    6854                 :             : 
    6855                 :           0 :   for (n = 0; n < n_region; n++)
    6856                 :             :     {
    6857                 :           0 :      if (bb == bbs[n])
    6858                 :             :        return true;
    6859                 :             :     }
    6860                 :             :   return false;
    6861                 :             : }
    6862                 :             : 
    6863                 :             : 
    6864                 :             : /* For each PHI in BB, copy the argument associated with SRC_E to TGT_E.
    6865                 :             :    Assuming the argument exists, just does not have a value.  */
    6866                 :             : 
    6867                 :             : void
    6868                 :    27079725 : copy_phi_arg_into_existing_phi (edge src_e, edge tgt_e)
    6869                 :             : {
    6870                 :    27079725 :   int src_idx = src_e->dest_idx;
    6871                 :    27079725 :   int tgt_idx = tgt_e->dest_idx;
    6872                 :             : 
    6873                 :             :   /* Iterate over each PHI in e->dest.  */
    6874                 :    27079725 :   for (gphi_iterator gsi = gsi_start_phis (src_e->dest),
    6875                 :    27079725 :                            gsi2 = gsi_start_phis (tgt_e->dest);
    6876                 :    66127284 :        !gsi_end_p (gsi);
    6877                 :    39047559 :        gsi_next (&gsi), gsi_next (&gsi2))
    6878                 :             :     {
    6879                 :    39047559 :       gphi *src_phi = gsi.phi ();
    6880                 :    39047559 :       gphi *dest_phi = gsi2.phi ();
    6881                 :    39047559 :       tree val = gimple_phi_arg_def (src_phi, src_idx);
    6882                 :    39047559 :       location_t locus = gimple_phi_arg_location (src_phi, src_idx);
    6883                 :             : 
    6884                 :    39047559 :       SET_PHI_ARG_DEF (dest_phi, tgt_idx, val);
    6885                 :    39047559 :       gimple_phi_arg_set_location (dest_phi, tgt_idx, locus);
    6886                 :             :     }
    6887                 :    27079725 : }
    6888                 :             : 
    6889                 :             : /* Duplicates REGION consisting of N_REGION blocks.  The new blocks
    6890                 :             :    are stored to REGION_COPY in the same order in that they appear
    6891                 :             :    in REGION, if REGION_COPY is not NULL.  ENTRY is the entry to
    6892                 :             :    the region, EXIT an exit from it.  The condition guarding EXIT
    6893                 :             :    is moved to ENTRY.  Returns true if duplication succeeds, false
    6894                 :             :    otherwise.
    6895                 :             : 
    6896                 :             :    For example,
    6897                 :             : 
    6898                 :             :    some_code;
    6899                 :             :    if (cond)
    6900                 :             :      A;
    6901                 :             :    else
    6902                 :             :      B;
    6903                 :             : 
    6904                 :             :    is transformed to
    6905                 :             : 
    6906                 :             :    if (cond)
    6907                 :             :      {
    6908                 :             :        some_code;
    6909                 :             :        A;
    6910                 :             :      }
    6911                 :             :    else
    6912                 :             :      {
    6913                 :             :        some_code;
    6914                 :             :        B;
    6915                 :             :      }
    6916                 :             : */
    6917                 :             : 
    6918                 :             : bool
    6919                 :          24 : gimple_duplicate_sese_tail (edge entry, edge exit,
    6920                 :             :                           basic_block *region, unsigned n_region,
    6921                 :             :                           basic_block *region_copy)
    6922                 :             : {
    6923                 :          24 :   unsigned i;
    6924                 :          24 :   bool free_region_copy = false;
    6925                 :          24 :   class loop *loop = exit->dest->loop_father;
    6926                 :          24 :   class loop *orig_loop = entry->dest->loop_father;
    6927                 :          24 :   basic_block switch_bb, entry_bb, nentry_bb;
    6928                 :          24 :   profile_count total_count = profile_count::uninitialized (),
    6929                 :          24 :                 exit_count = profile_count::uninitialized ();
    6930                 :          24 :   edge exits[2], nexits[2], e;
    6931                 :          24 :   gimple_stmt_iterator gsi;
    6932                 :          24 :   edge sorig, snew;
    6933                 :          24 :   basic_block exit_bb;
    6934                 :          24 :   class loop *target, *aloop, *cloop;
    6935                 :             : 
    6936                 :          24 :   gcc_assert (EDGE_COUNT (exit->src->succs) == 2);
    6937                 :          24 :   exits[0] = exit;
    6938                 :          24 :   exits[1] = EDGE_SUCC (exit->src, EDGE_SUCC (exit->src, 0) == exit);
    6939                 :             : 
    6940                 :          24 :   if (!can_copy_bbs_p (region, n_region))
    6941                 :             :     return false;
    6942                 :             : 
    6943                 :          24 :   initialize_original_copy_tables ();
    6944                 :          24 :   set_loop_copy (orig_loop, loop);
    6945                 :             : 
    6946                 :          24 :   target= loop;
    6947                 :          24 :   for (aloop = orig_loop->inner; aloop; aloop = aloop->next)
    6948                 :             :     {
    6949                 :           0 :       if (bb_part_of_region_p (aloop->header, region, n_region))
    6950                 :             :         {
    6951                 :           0 :           cloop = duplicate_loop (aloop, target);
    6952                 :           0 :           duplicate_subloops (aloop, cloop);
    6953                 :             :         }
    6954                 :             :     }
    6955                 :             : 
    6956                 :          24 :   if (!region_copy)
    6957                 :             :     {
    6958                 :           0 :       region_copy = XNEWVEC (basic_block, n_region);
    6959                 :           0 :       free_region_copy = true;
    6960                 :             :     }
    6961                 :             : 
    6962                 :          24 :   gcc_assert (!need_ssa_update_p (cfun));
    6963                 :             : 
    6964                 :             :   /* Record blocks outside the region that are dominated by something
    6965                 :             :      inside.  */
    6966                 :          24 :   auto_vec<basic_block> doms = get_dominated_by_region (CDI_DOMINATORS, region,
    6967                 :          24 :                                                         n_region);
    6968                 :             : 
    6969                 :          24 :   total_count = exit->src->count;
    6970                 :          24 :   exit_count = exit->count ();
    6971                 :             :   /* Fix up corner cases, to avoid division by zero or creation of negative
    6972                 :             :      frequencies.  */
    6973                 :          24 :   if (exit_count > total_count)
    6974                 :           0 :     exit_count = total_count;
    6975                 :             : 
    6976                 :          24 :   copy_bbs (region, n_region, region_copy, exits, 2, nexits, orig_loop,
    6977                 :             :             split_edge_bb_loc (exit), true);
    6978                 :          24 :   if (total_count.initialized_p () && exit_count.initialized_p ())
    6979                 :             :     {
    6980                 :          24 :       scale_bbs_frequencies_profile_count (region, n_region,
    6981                 :             :                                            total_count - exit_count,
    6982                 :             :                                            total_count);
    6983                 :          24 :       scale_bbs_frequencies_profile_count (region_copy, n_region, exit_count,
    6984                 :             :                                            total_count);
    6985                 :             :     }
    6986                 :             : 
    6987                 :             :   /* Create the switch block, and put the exit condition to it.  */
    6988                 :          24 :   entry_bb = entry->dest;
    6989                 :          24 :   nentry_bb = get_bb_copy (entry_bb);
    6990                 :          24 :   if (!*gsi_last_bb (entry->src)
    6991                 :          24 :       || !stmt_ends_bb_p (*gsi_last_bb (entry->src)))
    6992                 :          24 :     switch_bb = entry->src;
    6993                 :             :   else
    6994                 :           0 :     switch_bb = split_edge (entry);
    6995                 :          24 :   set_immediate_dominator (CDI_DOMINATORS, nentry_bb, switch_bb);
    6996                 :             : 
    6997                 :          48 :   gcond *cond_stmt = as_a <gcond *> (*gsi_last_bb (exit->src));
    6998                 :          24 :   cond_stmt = as_a <gcond *> (gimple_copy (cond_stmt));
    6999                 :             : 
    7000                 :          24 :   gsi = gsi_last_bb (switch_bb);
    7001                 :          24 :   gsi_insert_after (&gsi, cond_stmt, GSI_NEW_STMT);
    7002                 :             : 
    7003                 :          24 :   sorig = single_succ_edge (switch_bb);
    7004                 :          24 :   sorig->flags = exits[1]->flags;
    7005                 :          24 :   sorig->probability = exits[1]->probability;
    7006                 :          24 :   snew = make_edge (switch_bb, nentry_bb, exits[0]->flags);
    7007                 :          24 :   snew->probability = exits[0]->probability;
    7008                 :             : 
    7009                 :             : 
    7010                 :             :   /* Register the new edge from SWITCH_BB in loop exit lists.  */
    7011                 :          24 :   rescan_loop_exit (snew, true, false);
    7012                 :             : 
    7013                 :             :   /* Add the PHI node arguments.  */
    7014                 :          24 :   add_phi_args_after_copy (region_copy, n_region, snew);
    7015                 :             : 
    7016                 :             :   /* Get rid of now superfluous conditions and associated edges (and phi node
    7017                 :             :      arguments).  */
    7018                 :          24 :   exit_bb = exit->dest;
    7019                 :             : 
    7020                 :          24 :   e = redirect_edge_and_branch (exits[0], exits[1]->dest);
    7021                 :          24 :   PENDING_STMT (e) = NULL;
    7022                 :             : 
    7023                 :             :   /* The latch of ORIG_LOOP was copied, and so was the backedge
    7024                 :             :      to the original header.  We redirect this backedge to EXIT_BB.  */
    7025                 :          50 :   for (i = 0; i < n_region; i++)
    7026                 :          26 :     if (get_bb_original (region_copy[i]) == orig_loop->latch)
    7027                 :             :       {
    7028                 :           0 :         gcc_assert (single_succ_edge (region_copy[i]));
    7029                 :           0 :         e = redirect_edge_and_branch (single_succ_edge (region_copy[i]), exit_bb);
    7030                 :           0 :         PENDING_STMT (e) = NULL;
    7031                 :           0 :         copy_phi_arg_into_existing_phi (nexits[0], e);
    7032                 :             :       }
    7033                 :          24 :   e = redirect_edge_and_branch (nexits[1], nexits[0]->dest);
    7034                 :          24 :   PENDING_STMT (e) = NULL;
    7035                 :             : 
    7036                 :             :   /* Anything that is outside of the region, but was dominated by something
    7037                 :             :      inside needs to update dominance info.  */
    7038                 :          24 :   iterate_fix_dominators (CDI_DOMINATORS, doms, false);
    7039                 :             : 
    7040                 :          24 :   if (free_region_copy)
    7041                 :           0 :     free (region_copy);
    7042                 :             : 
    7043                 :          24 :   free_original_copy_tables ();
    7044                 :          24 :   return true;
    7045                 :          24 : }
    7046                 :             : 
    7047                 :             : /* Add all the blocks dominated by ENTRY to the array BBS_P.  Stop
    7048                 :             :    adding blocks when the dominator traversal reaches EXIT.  This
    7049                 :             :    function silently assumes that ENTRY strictly dominates EXIT.  */
    7050                 :             : 
    7051                 :             : void
    7052                 :      555353 : gather_blocks_in_sese_region (basic_block entry, basic_block exit,
    7053                 :             :                               vec<basic_block> *bbs_p)
    7054                 :             : {
    7055                 :      555353 :   basic_block son;
    7056                 :             : 
    7057                 :      555353 :   for (son = first_dom_son (CDI_DOMINATORS, entry);
    7058                 :     1110596 :        son;
    7059                 :      555243 :        son = next_dom_son (CDI_DOMINATORS, son))
    7060                 :             :     {
    7061                 :      555243 :       bbs_p->safe_push (son);
    7062                 :      555243 :       if (son != exit)
    7063                 :      513804 :         gather_blocks_in_sese_region (son, exit, bbs_p);
    7064                 :             :     }
    7065                 :      555353 : }
    7066                 :             : 
    7067                 :             : /* Replaces *TP with a duplicate (belonging to function TO_CONTEXT).
    7068                 :             :    The duplicates are recorded in VARS_MAP.  */
    7069                 :             : 
    7070                 :             : static void
    7071                 :     4170811 : replace_by_duplicate_decl (tree *tp, hash_map<tree, tree> *vars_map,
    7072                 :             :                            tree to_context)
    7073                 :             : {
    7074                 :     4170811 :   tree t = *tp, new_t;
    7075                 :     4170811 :   struct function *f = DECL_STRUCT_FUNCTION (to_context);
    7076                 :             : 
    7077                 :     4170811 :   if (DECL_CONTEXT (t) == to_context)
    7078                 :       33068 :     return;
    7079                 :             : 
    7080                 :     4137743 :   bool existed;
    7081                 :     4137743 :   tree &loc = vars_map->get_or_insert (t, &existed);
    7082                 :             : 
    7083                 :     4137743 :   if (!existed)
    7084                 :             :     {
    7085                 :     1234369 :       if (SSA_VAR_P (t))
    7086                 :             :         {
    7087                 :     1223866 :           new_t = copy_var_decl (t, DECL_NAME (t), TREE_TYPE (t));
    7088                 :     1223866 :           add_local_decl (f, new_t);
    7089                 :             :         }
    7090                 :             :       else
    7091                 :             :         {
    7092                 :       10503 :           gcc_assert (TREE_CODE (t) == CONST_DECL);
    7093                 :       10503 :           new_t = copy_node (t);
    7094                 :             :         }
    7095                 :     1234369 :       DECL_CONTEXT (new_t) = to_context;
    7096                 :             : 
    7097                 :     1234369 :       loc = new_t;
    7098                 :             :     }
    7099                 :             :   else
    7100                 :     2903374 :     new_t = loc;
    7101                 :             : 
    7102                 :     4137743 :   *tp = new_t;
    7103                 :             : }
    7104                 :             : 
    7105                 :             : 
    7106                 :             : /* Creates an ssa name in TO_CONTEXT equivalent to NAME.
    7107                 :             :    VARS_MAP maps old ssa names and var_decls to the new ones.  */
    7108                 :             : 
    7109                 :             : static tree
    7110                 :       16090 : replace_ssa_name (tree name, hash_map<tree, tree> *vars_map,
    7111                 :             :                   tree to_context)
    7112                 :             : {
    7113                 :       16090 :   tree new_name;
    7114                 :             : 
    7115                 :       32180 :   gcc_assert (!virtual_operand_p (name));
    7116                 :             : 
    7117                 :       16090 :   tree *loc = vars_map->get (name);
    7118                 :             : 
    7119                 :       16090 :   if (!loc)
    7120                 :             :     {
    7121                 :        6841 :       tree decl = SSA_NAME_VAR (name);
    7122                 :        6841 :       if (decl)
    7123                 :             :         {
    7124                 :        1307 :           gcc_assert (!SSA_NAME_IS_DEFAULT_DEF (name));
    7125                 :        1307 :           replace_by_duplicate_decl (&decl, vars_map, to_context);
    7126                 :        1307 :           new_name = make_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context),
    7127                 :        1307 :                                        decl, SSA_NAME_DEF_STMT (name));
    7128                 :             :         }
    7129                 :             :       else
    7130                 :        5534 :         new_name = copy_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context),
    7131                 :        5534 :                                      name, SSA_NAME_DEF_STMT (name));
    7132                 :             : 
    7133                 :             :       /* Now that we've used the def stmt to define new_name, make sure it
    7134                 :             :          doesn't define name anymore.  */
    7135                 :        6841 :       SSA_NAME_DEF_STMT (name) = NULL;
    7136                 :             : 
    7137                 :        6841 :       vars_map->put (name, new_name);
    7138                 :             :     }
    7139                 :             :   else
    7140                 :        9249 :     new_name = *loc;
    7141                 :             : 
    7142                 :       16090 :   return new_name;
    7143                 :             : }
    7144                 :             : 
    7145                 :             : struct move_stmt_d
    7146                 :             : {
    7147                 :             :   tree orig_block;
    7148                 :             :   tree new_block;
    7149                 :             :   tree from_context;
    7150                 :             :   tree to_context;
    7151                 :             :   hash_map<tree, tree> *vars_map;
    7152                 :             :   htab_t new_label_map;
    7153                 :             :   hash_map<void *, void *> *eh_map;
    7154                 :             :   bool remap_decls_p;
    7155                 :             : };
    7156                 :             : 
    7157                 :             : /* Helper for move_block_to_fn.  Set TREE_BLOCK in every expression
    7158                 :             :    contained in *TP if it has been ORIG_BLOCK previously and change the
    7159                 :             :    DECL_CONTEXT of every local variable referenced in *TP.  */
    7160                 :             : 
    7161                 :             : static tree
    7162                 :     6794998 : move_stmt_op (tree *tp, int *walk_subtrees, void *data)
    7163                 :             : {
    7164                 :     6794998 :   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
    7165                 :     6794998 :   struct move_stmt_d *p = (struct move_stmt_d *) wi->info;
    7166                 :     6794998 :   tree t = *tp;
    7167                 :             : 
    7168                 :     6794998 :   if (EXPR_P (t))
    7169                 :             :     {
    7170                 :     1069965 :       tree block = TREE_BLOCK (t);
    7171                 :     1069965 :       if (block == NULL_TREE)
    7172                 :             :         ;
    7173                 :       28352 :       else if (block == p->orig_block
    7174                 :       26421 :                || p->orig_block == NULL_TREE)
    7175                 :             :         {
    7176                 :             :           /* tree_node_can_be_shared says we can share invariant
    7177                 :             :              addresses but unshare_expr copies them anyways.  Make sure
    7178                 :             :              to unshare before adjusting the block in place - we do not
    7179                 :             :              always see a copy here.  */
    7180                 :        1940 :           if (TREE_CODE (t) == ADDR_EXPR
    7181                 :        1940 :               && is_gimple_min_invariant (t))
    7182                 :        1931 :             *tp = t = unshare_expr (t);
    7183                 :        1940 :           TREE_SET_BLOCK (t, p->new_block);
    7184                 :             :         }
    7185                 :       26412 :       else if (flag_checking)
    7186                 :             :         {
    7187                 :       94193 :           while (block && TREE_CODE (block) == BLOCK && block != p->orig_block)
    7188                 :       67781 :             block = BLOCK_SUPERCONTEXT (block);
    7189                 :       26412 :           gcc_assert (block == p->orig_block);
    7190                 :             :         }
    7191                 :             :     }
    7192                 :     5725033 :   else if (DECL_P (t) || TREE_CODE (t) == SSA_NAME)
    7193                 :             :     {
    7194                 :     4217994 :       if (TREE_CODE (t) == SSA_NAME)
    7195                 :       14411 :         *tp = replace_ssa_name (t, p->vars_map, p->to_context);
    7196                 :     4203583 :       else if (TREE_CODE (t) == PARM_DECL
    7197                 :     4203583 :                && gimple_in_ssa_p (cfun))
    7198                 :         191 :         *tp = *(p->vars_map->get (t));
    7199                 :     4203392 :       else if (TREE_CODE (t) == LABEL_DECL)
    7200                 :             :         {
    7201                 :        2779 :           if (p->new_label_map)
    7202                 :             :             {
    7203                 :         440 :               struct tree_map in, *out;
    7204                 :         440 :               in.base.from = t;
    7205                 :         440 :               out = (struct tree_map *)
    7206                 :         440 :                 htab_find_with_hash (p->new_label_map, &in, DECL_UID (t));
    7207                 :         440 :               if (out)
    7208                 :           0 :                 *tp = t = out->to;
    7209                 :             :             }
    7210                 :             : 
    7211                 :             :           /* For FORCED_LABELs we can end up with references from other
    7212                 :             :              functions if some SESE regions are outlined.  It is UB to
    7213                 :             :              jump in between them, but they could be used just for printing
    7214                 :             :              addresses etc.  In that case, DECL_CONTEXT on the label should
    7215                 :             :              be the function containing the glabel stmt with that LABEL_DECL,
    7216                 :             :              rather than whatever function a reference to the label was seen
    7217                 :             :              last time.  */
    7218                 :        2779 :           if (!FORCED_LABEL (t) && !DECL_NONLOCAL (t))
    7219                 :        2772 :             DECL_CONTEXT (t) = p->to_context;
    7220                 :             :         }
    7221                 :     4200613 :       else if (p->remap_decls_p)
    7222                 :             :         {
    7223                 :             :           /* Replace T with its duplicate.  T should no longer appear in the
    7224                 :             :              parent function, so this looks wasteful; however, it may appear
    7225                 :             :              in referenced_vars, and more importantly, as virtual operands of
    7226                 :             :              statements, and in alias lists of other variables.  It would be
    7227                 :             :              quite difficult to expunge it from all those places.  ??? It might
    7228                 :             :              suffice to do this for addressable variables.  */
    7229                 :     3530726 :           if ((VAR_P (t) && !is_global_var (t))
    7230                 :     4240741 :               || TREE_CODE (t) == CONST_DECL)
    7231                 :     3500895 :             replace_by_duplicate_decl (tp, p->vars_map, p->to_context);
    7232                 :             :         }
    7233                 :     4217994 :       *walk_subtrees = 0;
    7234                 :     4217994 :     }
    7235                 :     1507039 :   else if (TYPE_P (t))
    7236                 :           0 :     *walk_subtrees = 0;
    7237                 :             : 
    7238                 :     6794998 :   return NULL_TREE;
    7239                 :             : }
    7240                 :             : 
    7241                 :             : /* Helper for move_stmt_r.  Given an EH region number for the source
    7242                 :             :    function, map that to the duplicate EH regio number in the dest.  */
    7243                 :             : 
    7244                 :             : static int
    7245                 :           0 : move_stmt_eh_region_nr (int old_nr, struct move_stmt_d *p)
    7246                 :             : {
    7247                 :           0 :   eh_region old_r, new_r;
    7248                 :             : 
    7249                 :           0 :   old_r = get_eh_region_from_number (old_nr);
    7250                 :           0 :   new_r = static_cast<eh_region> (*p->eh_map->get (old_r));
    7251                 :             : 
    7252                 :           0 :   return new_r->index;
    7253                 :             : }
    7254                 :             : 
    7255                 :             : /* Similar, but operate on INTEGER_CSTs.  */
    7256                 :             : 
    7257                 :             : static tree
    7258                 :           0 : move_stmt_eh_region_tree_nr (tree old_t_nr, struct move_stmt_d *p)
    7259                 :             : {
    7260                 :           0 :   int old_nr, new_nr;
    7261                 :             : 
    7262                 :           0 :   old_nr = tree_to_shwi (old_t_nr);
    7263                 :           0 :   new_nr = move_stmt_eh_region_nr (old_nr, p);
    7264                 :             : 
    7265                 :           0 :   return build_int_cst (integer_type_node, new_nr);
    7266                 :             : }
    7267                 :             : 
    7268                 :             : /* Like move_stmt_op, but for gimple statements.
    7269                 :             : 
    7270                 :             :    Helper for move_block_to_fn.  Set GIMPLE_BLOCK in every expression
    7271                 :             :    contained in the current statement in *GSI_P and change the
    7272                 :             :    DECL_CONTEXT of every local variable referenced in the current
    7273                 :             :    statement.  */
    7274                 :             : 
    7275                 :             : static tree
    7276                 :     1936254 : move_stmt_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
    7277                 :             :              struct walk_stmt_info *wi)
    7278                 :             : {
    7279                 :     1936254 :   struct move_stmt_d *p = (struct move_stmt_d *) wi->info;
    7280                 :     1936254 :   gimple *stmt = gsi_stmt (*gsi_p);
    7281                 :     1936254 :   tree block = gimple_block (stmt);
    7282                 :             : 
    7283                 :     1936254 :   if (block == p->orig_block
    7284                 :     1704002 :       || (p->orig_block == NULL_TREE
    7285                 :        1035 :           && block != NULL_TREE))
    7286                 :      233287 :     gimple_set_block (stmt, p->new_block);
    7287                 :             : 
    7288                 :     1936254 :   switch (gimple_code (stmt))
    7289                 :             :     {
    7290                 :      254491 :     case GIMPLE_CALL:
    7291                 :             :       /* Remap the region numbers for __builtin_eh_{pointer,filter}.  */
    7292                 :      254491 :       {
    7293                 :      254491 :         tree r, fndecl = gimple_call_fndecl (stmt);
    7294                 :      254491 :         if (fndecl && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL))
    7295                 :       93724 :           switch (DECL_FUNCTION_CODE (fndecl))
    7296                 :             :             {
    7297                 :           0 :             case BUILT_IN_EH_COPY_VALUES:
    7298                 :           0 :               r = gimple_call_arg (stmt, 1);
    7299                 :           0 :               r = move_stmt_eh_region_tree_nr (r, p);
    7300                 :           0 :               gimple_call_set_arg (stmt, 1, r);
    7301                 :             :               /* FALLTHRU */
    7302                 :             : 
    7303                 :           0 :             case BUILT_IN_EH_POINTER:
    7304                 :           0 :             case BUILT_IN_EH_FILTER:
    7305                 :           0 :               r = gimple_call_arg (stmt, 0);
    7306                 :           0 :               r = move_stmt_eh_region_tree_nr (r, p);
    7307                 :           0 :               gimple_call_set_arg (stmt, 0, r);
    7308                 :           0 :               break;
    7309                 :             : 
    7310                 :             :             default:
    7311                 :             :               break;
    7312                 :             :             }
    7313                 :             :       }
    7314                 :             :       break;
    7315                 :             : 
    7316                 :           0 :     case GIMPLE_RESX:
    7317                 :           0 :       {
    7318                 :           0 :         gresx *resx_stmt = as_a <gresx *> (stmt);
    7319                 :           0 :         int r = gimple_resx_region (resx_stmt);
    7320                 :           0 :         r = move_stmt_eh_region_nr (r, p);
    7321                 :           0 :         gimple_resx_set_region (resx_stmt, r);
    7322                 :             :       }
    7323                 :           0 :       break;
    7324                 :             : 
    7325                 :           0 :     case GIMPLE_EH_DISPATCH:
    7326                 :           0 :       {
    7327                 :           0 :         geh_dispatch *eh_dispatch_stmt = as_a <geh_dispatch *> (stmt);
    7328                 :           0 :         int r = gimple_eh_dispatch_region (eh_dispatch_stmt);
    7329                 :           0 :         r = move_stmt_eh_region_nr (r, p);
    7330                 :           0 :         gimple_eh_dispatch_set_region (eh_dispatch_stmt, r);
    7331                 :             :       }
    7332                 :           0 :       break;
    7333                 :             : 
    7334                 :             :     case GIMPLE_OMP_RETURN:
    7335                 :             :     case GIMPLE_OMP_CONTINUE:
    7336                 :             :       break;
    7337                 :             : 
    7338                 :        1393 :     case GIMPLE_LABEL:
    7339                 :        1393 :       {
    7340                 :             :         /* For FORCED_LABEL, move_stmt_op doesn't adjust DECL_CONTEXT,
    7341                 :             :            so that such labels can be referenced from other regions.
    7342                 :             :            Make sure to update it when seeing a GIMPLE_LABEL though,
    7343                 :             :            that is the owner of the label.  */
    7344                 :        1393 :         walk_gimple_op (stmt, move_stmt_op, wi);
    7345                 :        1393 :         *handled_ops_p = true;
    7346                 :        1393 :         tree label = gimple_label_label (as_a <glabel *> (stmt));
    7347                 :        1393 :         if (FORCED_LABEL (label) || DECL_NONLOCAL (label))
    7348                 :           5 :           DECL_CONTEXT (label) = p->to_context;
    7349                 :             :       }
    7350                 :             :       break;
    7351                 :             : 
    7352                 :     1680370 :     default:
    7353                 :     1680370 :       if (is_gimple_omp (stmt))
    7354                 :             :         {
    7355                 :             :           /* Do not remap variables inside OMP directives.  Variables
    7356                 :             :              referenced in clauses and directive header belong to the
    7357                 :             :              parent function and should not be moved into the child
    7358                 :             :              function.  */
    7359                 :           0 :           bool save_remap_decls_p = p->remap_decls_p;
    7360                 :           0 :           p->remap_decls_p = false;
    7361                 :           0 :           *handled_ops_p = true;
    7362                 :             : 
    7363                 :           0 :           walk_gimple_seq_mod (gimple_omp_body_ptr (stmt), move_stmt_r,
    7364                 :             :                                move_stmt_op, wi);
    7365                 :             : 
    7366                 :           0 :           p->remap_decls_p = save_remap_decls_p;
    7367                 :             :         }
    7368                 :             :       break;
    7369                 :             :     }
    7370                 :             : 
    7371                 :     1936254 :   return NULL_TREE;
    7372                 :             : }
    7373                 :             : 
    7374                 :             : /* Move basic block BB from function CFUN to function DEST_FN.  The
    7375                 :             :    block is moved out of the original linked list and placed after
    7376                 :             :    block AFTER in the new list.  Also, the block is removed from the
    7377                 :             :    original array of blocks and placed in DEST_FN's array of blocks.
    7378                 :             :    If UPDATE_EDGE_COUNT_P is true, the edge counts on both CFGs is
    7379                 :             :    updated to reflect the moved edges.
    7380                 :             : 
    7381                 :             :    The local variables are remapped to new instances, VARS_MAP is used
    7382                 :             :    to record the mapping.  */
    7383                 :             : 
    7384                 :             : static void
    7385                 :      594534 : move_block_to_fn (struct function *dest_cfun, basic_block bb,
    7386                 :             :                   basic_block after, bool update_edge_count_p,
    7387                 :             :                   struct move_stmt_d *d)
    7388                 :             : {
    7389                 :      594534 :   struct control_flow_graph *cfg;
    7390                 :      594534 :   edge_iterator ei;
    7391                 :      594534 :   edge e;
    7392                 :      594534 :   gimple_stmt_iterator si;
    7393                 :      594534 :   unsigned old_len;
    7394                 :             : 
    7395                 :             :   /* Remove BB from dominance structures.  */
    7396                 :      594534 :   delete_from_dominance_info (CDI_DOMINATORS, bb);
    7397                 :             : 
    7398                 :             :   /* Move BB from its current loop to the copy in the new function.  */
    7399                 :      594534 :   if (current_loops)
    7400                 :             :     {
    7401                 :      594534 :       class loop *new_loop = (class loop *)bb->loop_father->aux;
    7402                 :      594534 :       if (new_loop)
    7403                 :      341456 :         bb->loop_father = new_loop;
    7404                 :             :     }
    7405                 :             : 
    7406                 :             :   /* Link BB to the new linked list.  */
    7407                 :      594534 :   move_block_after (bb, after);
    7408                 :             : 
    7409                 :             :   /* Update the edge count in the corresponding flowgraphs.  */
    7410                 :      594534 :   if (update_edge_count_p)
    7411                 :     1276335 :     FOR_EACH_EDGE (e, ei, bb->succs)
    7412                 :             :       {
    7413                 :      722834 :         cfun->cfg->x_n_edges--;
    7414                 :      722834 :         dest_cfun->cfg->x_n_edges++;
    7415                 :             :       }
    7416                 :             : 
    7417                 :             :   /* Remove BB from the original basic block array.  */
    7418                 :      594534 :   (*cfun->cfg->x_basic_block_info)[bb->index] = NULL;
    7419                 :      594534 :   cfun->cfg->x_n_basic_blocks--;
    7420                 :             : 
    7421                 :             :   /* Grow DEST_CFUN's basic block array if needed.  */
    7422                 :      594534 :   cfg = dest_cfun->cfg;
    7423                 :      594534 :   cfg->x_n_basic_blocks++;
    7424                 :      594534 :   if (bb->index >= cfg->x_last_basic_block)
    7425                 :       41143 :     cfg->x_last_basic_block = bb->index + 1;
    7426                 :             : 
    7427                 :      594534 :   old_len = vec_safe_length (cfg->x_basic_block_info);
    7428                 :      594534 :   if ((unsigned) cfg->x_last_basic_block >= old_len)
    7429                 :       33383 :     vec_safe_grow_cleared (cfg->x_basic_block_info,
    7430                 :       33383 :                            cfg->x_last_basic_block + 1);
    7431                 :             : 
    7432                 :      594534 :   (*cfg->x_basic_block_info)[bb->index] = bb;
    7433                 :             : 
    7434                 :             :   /* Remap the variables in phi nodes.  */
    7435                 :      594534 :   for (gphi_iterator psi = gsi_start_phis (bb);
    7436                 :      595788 :        !gsi_end_p (psi); )
    7437                 :             :     {
    7438                 :        1254 :       gphi *phi = psi.phi ();
    7439                 :        1254 :       use_operand_p use;
    7440                 :        1254 :       tree op = PHI_RESULT (phi);
    7441                 :        1254 :       ssa_op_iter oi;
    7442                 :        1254 :       unsigned i;
    7443                 :             : 
    7444                 :        2508 :       if (virtual_operand_p (op))
    7445                 :             :         {
    7446                 :             :           /* Remove the phi nodes for virtual operands (alias analysis will be
    7447                 :             :              run for the new function, anyway).  But replace all uses that
    7448                 :             :              might be outside of the region we move.  */
    7449                 :         552 :           use_operand_p use_p;
    7450                 :         552 :           imm_use_iterator iter;
    7451                 :         552 :           gimple *use_stmt;
    7452                 :        1099 :           FOR_EACH_IMM_USE_STMT (use_stmt, iter, op)
    7453                 :        1641 :             FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
    7454                 :        1099 :               SET_USE (use_p, SSA_NAME_VAR (op));
    7455                 :         552 :           remove_phi_node (&psi, true);
    7456                 :         552 :           continue;
    7457                 :         552 :         }
    7458                 :             : 
    7459                 :         702 :       SET_PHI_RESULT (phi,
    7460                 :             :                       replace_ssa_name (op, d->vars_map, dest_cfun->decl));
    7461                 :        1850 :       FOR_EACH_PHI_ARG (use, phi, oi, SSA_OP_USE)
    7462                 :             :         {
    7463                 :        1148 :           op = USE_FROM_PTR (use);
    7464                 :        1148 :           if (TREE_CODE (op) == SSA_NAME)
    7465                 :         977 :             SET_USE (use, replace_ssa_name (op, d->vars_map, dest_cfun->decl));
    7466                 :             :         }
    7467                 :             : 
    7468                 :        1850 :       for (i = 0; i < EDGE_COUNT (bb->preds); i++)
    7469                 :             :         {
    7470                 :        1148 :           location_t locus = gimple_phi_arg_location (phi, i);
    7471                 :        1148 :           tree block = LOCATION_BLOCK (locus);
    7472                 :             :