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