LCOV - code coverage report
Current view: top level - gcc - sese.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 144 215 67.0 %
Date: 2020-03-28 11:57:23 Functions: 16 22 72.7 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Single entry single exit control flow regions.
       2                 :            :    Copyright (C) 2008-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Jan Sjodin <jan.sjodin@amd.com> and
       4                 :            :    Sebastian Pop <sebastian.pop@amd.com>.
       5                 :            : 
       6                 :            : This file is part of GCC.
       7                 :            : 
       8                 :            : GCC is free software; you can redistribute it and/or modify
       9                 :            : it under the terms of the GNU General Public License as published by
      10                 :            : the Free Software Foundation; either version 3, or (at your option)
      11                 :            : any later version.
      12                 :            : 
      13                 :            : GCC is distributed in the hope that it will be useful,
      14                 :            : but WITHOUT ANY WARRANTY; without even the implied warranty of
      15                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16                 :            : GNU General Public License for more details.
      17                 :            : 
      18                 :            : You should have received a copy of the GNU General Public License
      19                 :            : along with GCC; see the file COPYING3.  If not see
      20                 :            : <http://www.gnu.org/licenses/>.  */
      21                 :            : 
      22                 :            : #include "config.h"
      23                 :            : #include "system.h"
      24                 :            : #include "coretypes.h"
      25                 :            : #include "backend.h"
      26                 :            : #include "tree.h"
      27                 :            : #include "gimple.h"
      28                 :            : #include "cfghooks.h"
      29                 :            : #include "tree-pass.h"
      30                 :            : #include "ssa.h"
      31                 :            : #include "tree-pretty-print.h"
      32                 :            : #include "fold-const.h"
      33                 :            : #include "gimplify.h"
      34                 :            : #include "gimple-iterator.h"
      35                 :            : #include "gimple-pretty-print.h"
      36                 :            : #include "gimplify-me.h"
      37                 :            : #include "tree-cfg.h"
      38                 :            : #include "tree-ssa-loop.h"
      39                 :            : #include "tree-into-ssa.h"
      40                 :            : #include "cfgloop.h"
      41                 :            : #include "tree-data-ref.h"
      42                 :            : #include "tree-scalar-evolution.h"
      43                 :            : #include "tree-ssa-propagate.h"
      44                 :            : #include "cfganal.h"
      45                 :            : #include "sese.h"
      46                 :            : 
      47                 :            : /* For a USE in BB, if BB is outside REGION, mark the USE in the
      48                 :            :    LIVEOUTS set.  */
      49                 :            : 
      50                 :            : static void
      51                 :       2609 : sese_build_liveouts_use (sese_info_p region, bitmap liveouts, basic_block bb,
      52                 :            :                          tree use)
      53                 :            : {
      54                 :       2609 :   gcc_assert (!bb_in_sese_p (bb, region->region));
      55                 :       2609 :   if (TREE_CODE (use) != SSA_NAME)
      56                 :            :     return;
      57                 :            : 
      58                 :       2341 :   basic_block def_bb = gimple_bb (SSA_NAME_DEF_STMT (use));
      59                 :            : 
      60                 :       2341 :   if (!def_bb || !bb_in_sese_p (def_bb, region->region))
      61                 :       2284 :     return;
      62                 :            : 
      63                 :         57 :   unsigned ver = SSA_NAME_VERSION (use);
      64                 :         57 :   bitmap_set_bit (liveouts, ver);
      65                 :            : }
      66                 :            : 
      67                 :            : /* Marks for rewrite all the SSA_NAMES defined in REGION and that are
      68                 :            :    used in BB that is outside of the REGION.  */
      69                 :            : 
      70                 :            : static void
      71                 :       1258 : sese_build_liveouts_bb (sese_info_p region, basic_block bb)
      72                 :            : {
      73                 :       1258 :   ssa_op_iter iter;
      74                 :       1258 :   use_operand_p use_p;
      75                 :            : 
      76                 :       1779 :   for (gphi_iterator bsi = gsi_start_phis (bb); !gsi_end_p (bsi);
      77                 :        521 :        gsi_next (&bsi))
      78                 :       1137 :     FOR_EACH_PHI_ARG (use_p, bsi.phi (), iter, SSA_OP_USE)
      79                 :        616 :       sese_build_liveouts_use (region, region->liveout,
      80                 :            :                                bb, USE_FROM_PTR (use_p));
      81                 :            : 
      82                 :       4669 :   for (gimple_stmt_iterator bsi = gsi_start_bb (bb); !gsi_end_p (bsi);
      83                 :       2153 :        gsi_next (&bsi))
      84                 :            :     {
      85                 :       2153 :       gimple *stmt = gsi_stmt (bsi);
      86                 :            : 
      87                 :       2153 :       bitmap liveouts = region->liveout;
      88                 :       2153 :       if (is_gimple_debug (stmt))
      89                 :         50 :         liveouts = region->debug_liveout;
      90                 :            : 
      91                 :       4146 :       FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
      92                 :       1993 :         sese_build_liveouts_use (region, liveouts, bb, USE_FROM_PTR (use_p));
      93                 :            :     }
      94                 :       1258 : }
      95                 :            : 
      96                 :            : /* Reset debug stmts that reference SSA_NAMES defined in REGION that
      97                 :            :    are not marked as liveouts.  */
      98                 :            : 
      99                 :            : static void
     100                 :          4 : sese_reset_debug_liveouts (sese_info_p region)
     101                 :            : {
     102                 :          4 :   bitmap_iterator bi;
     103                 :          4 :   unsigned i;
     104                 :          4 :   EXECUTE_IF_AND_COMPL_IN_BITMAP (region->debug_liveout, region->liveout,
     105                 :            :                                   0, i, bi)
     106                 :            :     {
     107                 :          0 :       tree name = ssa_name (i);
     108                 :          0 :       auto_vec<gimple *, 4> stmts;
     109                 :          0 :       gimple *use_stmt;
     110                 :          0 :       imm_use_iterator use_iter;
     111                 :          0 :       FOR_EACH_IMM_USE_STMT (use_stmt, use_iter, name)
     112                 :            :         {
     113                 :          0 :           if (! is_gimple_debug (use_stmt)
     114                 :          0 :               || bb_in_sese_p (gimple_bb (use_stmt), region->region))
     115                 :          0 :             continue;
     116                 :          0 :           stmts.safe_push (use_stmt);
     117                 :            :         }
     118                 :          0 :       while (!stmts.is_empty ())
     119                 :            :         {
     120                 :          0 :           gimple *stmt = stmts.pop ();
     121                 :          0 :           gimple_debug_bind_reset_value (stmt);
     122                 :          0 :           update_stmt (stmt);
     123                 :            :         }
     124                 :            :     }
     125                 :          4 : }
     126                 :            : 
     127                 :            : /* Build the LIVEOUTS of REGION: the set of variables defined inside
     128                 :            :    and used outside the REGION.  */
     129                 :            : 
     130                 :            : void
     131                 :        182 : sese_build_liveouts (sese_info_p region)
     132                 :            : {
     133                 :        182 :   basic_block bb;
     134                 :            : 
     135                 :        182 :   gcc_assert (region->liveout == NULL
     136                 :            :               && region->debug_liveout == NULL);
     137                 :            : 
     138                 :        182 :   region->liveout = BITMAP_ALLOC (NULL);
     139                 :        182 :   region->debug_liveout = BITMAP_ALLOC (NULL);
     140                 :            : 
     141                 :            :   /* FIXME: We could start iterating form the successor of sese.  */
     142                 :       3224 :   FOR_EACH_BB_FN (bb, cfun)
     143                 :       3042 :     if (!bb_in_sese_p (bb, region->region))
     144                 :       1258 :       sese_build_liveouts_bb (region, bb);
     145                 :        182 : }
     146                 :            : 
     147                 :            : /* Builds a new SESE region from edges ENTRY and EXIT.  */
     148                 :            : 
     149                 :            : sese_info_p
     150                 :        182 : new_sese_info (edge entry, edge exit)
     151                 :            : {
     152                 :        182 :   sese_info_p region = XNEW (class sese_info_t);
     153                 :            : 
     154                 :        182 :   region->region.entry = entry;
     155                 :        182 :   region->region.exit = exit;
     156                 :        182 :   region->liveout = NULL;
     157                 :        182 :   region->debug_liveout = NULL;
     158                 :        182 :   region->params.create (3);
     159                 :        182 :   region->rename_map = new hash_map <tree, tree>;
     160                 :        182 :   region->bbs.create (3);
     161                 :            : 
     162                 :        182 :   return region;
     163                 :            : }
     164                 :            : 
     165                 :            : /* Deletes REGION.  */
     166                 :            : 
     167                 :            : void
     168                 :        182 : free_sese_info (sese_info_p region)
     169                 :            : {
     170                 :        182 :   region->params.release ();
     171                 :        182 :   BITMAP_FREE (region->liveout);
     172                 :        182 :   BITMAP_FREE (region->debug_liveout);
     173                 :            : 
     174                 :        364 :   delete region->rename_map;
     175                 :        182 :   region->rename_map = NULL;
     176                 :        182 :   region->bbs.release ();
     177                 :            : 
     178                 :        182 :   XDELETE (region);
     179                 :        182 : }
     180                 :            : 
     181                 :            : /* Add exit phis for USE on EXIT.  */
     182                 :            : 
     183                 :            : static void
     184                 :         43 : sese_add_exit_phis_edge (basic_block exit, tree use, edge false_e, edge true_e)
     185                 :            : {
     186                 :         43 :   gphi *phi = create_phi_node (NULL_TREE, exit);
     187                 :         43 :   create_new_def_for (use, phi, gimple_phi_result_ptr (phi));
     188                 :         43 :   add_phi_arg (phi, use, false_e, UNKNOWN_LOCATION);
     189                 :         43 :   add_phi_arg (phi, use, true_e, UNKNOWN_LOCATION);
     190                 :         43 :   update_stmt (phi);
     191                 :         43 : }
     192                 :            : 
     193                 :            : /* Insert in the block BB phi nodes for variables defined in REGION
     194                 :            :    and used outside the REGION.  The code generation moves REGION in
     195                 :            :    the else clause of an "if (1)" and generates code in the then
     196                 :            :    clause that is at this point empty:
     197                 :            : 
     198                 :            :    | if (1)
     199                 :            :    |   empty;
     200                 :            :    | else
     201                 :            :    |   REGION;
     202                 :            : */
     203                 :            : 
     204                 :            : void
     205                 :        139 : sese_insert_phis_for_liveouts (sese_info_p region, basic_block bb,
     206                 :            :                                edge false_e, edge true_e)
     207                 :            : {
     208                 :        139 :   if (MAY_HAVE_DEBUG_BIND_STMTS)
     209                 :          4 :     sese_reset_debug_liveouts (region);
     210                 :            : 
     211                 :        139 :   unsigned i;
     212                 :        139 :   bitmap_iterator bi;
     213                 :        182 :   EXECUTE_IF_SET_IN_BITMAP (region->liveout, 0, i, bi)
     214                 :         86 :     if (!virtual_operand_p (ssa_name (i)))
     215                 :         43 :       sese_add_exit_phis_edge (bb, ssa_name (i), false_e, true_e);
     216                 :        139 : }
     217                 :            : 
     218                 :            : /* Returns the outermost loop in SCOP that contains BB.  */
     219                 :            : 
     220                 :            : class loop *
     221                 :          0 : outermost_loop_in_sese_1 (sese_l &region, basic_block bb)
     222                 :            : {
     223                 :          0 :   class loop *nest;
     224                 :            : 
     225                 :          0 :   nest = bb->loop_father;
     226                 :          0 :   while (loop_outer (nest)
     227                 :          0 :          && loop_in_sese_p (loop_outer (nest), region))
     228                 :          0 :     nest = loop_outer (nest);
     229                 :            : 
     230                 :          0 :   return nest;
     231                 :            : }
     232                 :            : 
     233                 :            : /* Same as outermost_loop_in_sese_1, returns the outermost loop
     234                 :            :    containing BB in REGION, but makes sure that the returned loop
     235                 :            :    belongs to the REGION, and so this returns the first loop in the
     236                 :            :    REGION when the loop containing BB does not belong to REGION.  */
     237                 :            : 
     238                 :            : loop_p
     239                 :          0 : outermost_loop_in_sese (sese_l &region, basic_block bb)
     240                 :            : {
     241                 :          0 :   loop_p nest = outermost_loop_in_sese_1 (region, bb);
     242                 :            : 
     243                 :          0 :   if (loop_in_sese_p (nest, region))
     244                 :            :     return nest;
     245                 :            : 
     246                 :            :   /* When the basic block BB does not belong to a loop in the region,
     247                 :            :      return the first loop in the region.  */
     248                 :          0 :   nest = nest->inner;
     249                 :          0 :   while (nest)
     250                 :          0 :     if (loop_in_sese_p (nest, region))
     251                 :            :       break;
     252                 :            :     else
     253                 :          0 :       nest = nest->next;
     254                 :            : 
     255                 :          0 :   gcc_assert (nest);
     256                 :            :   return nest;
     257                 :            : }
     258                 :            : 
     259                 :            : /* Returns the first successor edge of BB with EDGE_TRUE_VALUE flag set.  */
     260                 :            : 
     261                 :            : edge
     262                 :        179 : get_true_edge_from_guard_bb (basic_block bb)
     263                 :            : {
     264                 :        179 :   edge e;
     265                 :        179 :   edge_iterator ei;
     266                 :            : 
     267                 :        179 :   FOR_EACH_EDGE (e, ei, bb->succs)
     268                 :        179 :     if (e->flags & EDGE_TRUE_VALUE)
     269                 :        179 :       return e;
     270                 :            : 
     271                 :          0 :   gcc_unreachable ();
     272                 :            :   return NULL;
     273                 :            : }
     274                 :            : 
     275                 :            : /* Returns the first successor edge of BB with EDGE_TRUE_VALUE flag cleared.  */
     276                 :            : 
     277                 :            : edge
     278                 :         30 : get_false_edge_from_guard_bb (basic_block bb)
     279                 :            : {
     280                 :         30 :   edge e;
     281                 :         30 :   edge_iterator ei;
     282                 :            : 
     283                 :         60 :   FOR_EACH_EDGE (e, ei, bb->succs)
     284                 :         60 :     if (!(e->flags & EDGE_TRUE_VALUE))
     285                 :         30 :       return e;
     286                 :            : 
     287                 :          0 :   gcc_unreachable ();
     288                 :            :   return NULL;
     289                 :            : }
     290                 :            : 
     291                 :            : /* Moves REGION in a condition expression:
     292                 :            :    | if (1)
     293                 :            :    |   ;
     294                 :            :    | else
     295                 :            :    |   REGION;
     296                 :            : */
     297                 :            : 
     298                 :            : ifsese
     299                 :        141 : move_sese_in_condition (sese_info_p region)
     300                 :            : {
     301                 :        141 :   basic_block region_entry_dest = region->region.entry->dest;
     302                 :        141 :   basic_block pred_block = split_edge (region->region.entry);
     303                 :        141 :   basic_block merge_block = split_edge (region->region.exit);
     304                 :            : 
     305                 :        141 :   edge true_edge = make_edge (pred_block, merge_block, EDGE_TRUE_VALUE);
     306                 :        141 :   edge false_edge = find_edge (pred_block, region_entry_dest);
     307                 :        141 :   false_edge->flags &= ~EDGE_FALLTHRU;
     308                 :        141 :   false_edge->flags |= EDGE_FALSE_VALUE;
     309                 :        141 :   gimple_stmt_iterator gsi = gsi_last_bb (pred_block);
     310                 :        141 :   gcond *cond = gimple_build_cond (NE_EXPR, integer_one_node, integer_zero_node,
     311                 :            :                                    NULL_TREE, NULL_TREE);
     312                 :        141 :   gsi_insert_after (&gsi, cond, GSI_CONTINUE_LINKING);
     313                 :        141 :   if (dom_info_available_p (CDI_DOMINATORS))
     314                 :        141 :     set_immediate_dominator (CDI_DOMINATORS, merge_block, pred_block);
     315                 :            : 
     316                 :        141 :   ifsese if_region = XNEW (ifsese_s);
     317                 :        141 :   if_region->region = XCNEW (sese_info_t);
     318                 :        141 :   if_region->true_region = XCNEW (sese_info_t);
     319                 :        141 :   if_region->false_region = XCNEW (sese_info_t);
     320                 :        141 :   if_region->region->region.entry = single_pred_edge (pred_block);
     321                 :        141 :   if_region->region->region.exit = single_succ_edge (merge_block);
     322                 :        141 :   if_region->false_region->region.entry = false_edge;
     323                 :        141 :   if_region->false_region->region.exit = region->region.exit;
     324                 :        141 :   if_region->true_region->region.entry = true_edge;
     325                 :        282 :   if_region->true_region->region.exit
     326                 :        141 :     = single_succ_edge (split_edge (true_edge));
     327                 :            : 
     328                 :        141 :   region->region = if_region->false_region->region;
     329                 :            : 
     330                 :        141 :   return if_region;
     331                 :            : }
     332                 :            : 
     333                 :            : /* Replaces the condition of the IF_REGION with CONDITION:
     334                 :            :    | if (CONDITION)
     335                 :            :    |   true_region;
     336                 :            :    | else
     337                 :            :    |   false_region;
     338                 :            : */
     339                 :            : 
     340                 :            : void
     341                 :          0 : set_ifsese_condition (ifsese if_region, tree condition)
     342                 :            : {
     343                 :          0 :   sese_info_p region = if_region->region;
     344                 :          0 :   edge entry = region->region.entry;
     345                 :          0 :   basic_block bb = entry->dest;
     346                 :          0 :   gimple *last = last_stmt (bb);
     347                 :          0 :   gimple_stmt_iterator gsi = gsi_last_bb (bb);
     348                 :          0 :   gcond *cond_stmt;
     349                 :            : 
     350                 :          0 :   gcc_assert (gimple_code (last) == GIMPLE_COND);
     351                 :            : 
     352                 :          0 :   gsi_remove (&gsi, true);
     353                 :          0 :   gsi = gsi_last_bb (bb);
     354                 :          0 :   condition = force_gimple_operand_gsi (&gsi, condition, true, NULL,
     355                 :            :                                         false, GSI_NEW_STMT);
     356                 :          0 :   cond_stmt = gimple_build_cond_from_tree (condition, NULL_TREE, NULL_TREE);
     357                 :          0 :   gsi = gsi_last_bb (bb);
     358                 :          0 :   gsi_insert_after (&gsi, cond_stmt, GSI_NEW_STMT);
     359                 :          0 : }
     360                 :            : 
     361                 :            : /* Return true when T is defined outside REGION or when no definitions are
     362                 :            :    variant in REGION.  When HAS_VDEFS is a valid pointer, sets HAS_VDEFS to true
     363                 :            :    when T depends on memory that may change in REGION.  */
     364                 :            : 
     365                 :            : bool
     366                 :          0 : invariant_in_sese_p_rec (tree t, const sese_l &region, bool *has_vdefs)
     367                 :            : {
     368                 :          0 :   if (!defined_in_sese_p (t, region))
     369                 :            :     return true;
     370                 :            : 
     371                 :          0 :   gimple *stmt = SSA_NAME_DEF_STMT (t);
     372                 :            : 
     373                 :          0 :   if (gimple_code (stmt) == GIMPLE_PHI
     374                 :          0 :       || gimple_code (stmt) == GIMPLE_CALL)
     375                 :            :     return false;
     376                 :            : 
     377                 :            :   /* VDEF is variant when it is in the region.  */
     378                 :          0 :   if (gimple_vdef (stmt))
     379                 :            :     {
     380                 :          0 :       if (has_vdefs)
     381                 :          0 :         *has_vdefs = true;
     382                 :          0 :       return false;
     383                 :            :     }
     384                 :            : 
     385                 :            :   /* A VUSE may or may not be variant following the VDEFs.  */
     386                 :          0 :   if (tree vuse = gimple_vuse (stmt))
     387                 :          0 :     return invariant_in_sese_p_rec (vuse, region, has_vdefs);
     388                 :            : 
     389                 :          0 :   ssa_op_iter iter;
     390                 :          0 :   use_operand_p use_p;
     391                 :          0 :   FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
     392                 :            :     {
     393                 :          0 :       tree use = USE_FROM_PTR (use_p);
     394                 :            : 
     395                 :          0 :       if (!defined_in_sese_p (use, region))
     396                 :          0 :         continue;
     397                 :            : 
     398                 :          0 :       if (!invariant_in_sese_p_rec (use, region, has_vdefs))
     399                 :            :         return false;
     400                 :            :     }
     401                 :            : 
     402                 :            :   return true;
     403                 :            : }
     404                 :            : 
     405                 :            : /* Return true when DEF can be analyzed in REGION by the scalar
     406                 :            :    evolution analyzer.  */
     407                 :            : 
     408                 :            : bool
     409                 :      30145 : scev_analyzable_p (tree def, sese_l &region)
     410                 :            : {
     411                 :      30145 :   loop_p loop;
     412                 :      30145 :   tree scev;
     413                 :      30145 :   tree type = TREE_TYPE (def);
     414                 :            : 
     415                 :            :   /* When Graphite generates code for a scev, the code generator
     416                 :            :      expresses the scev in function of a single induction variable.
     417                 :            :      This is unsafe for floating point computations, as it may replace
     418                 :            :      a floating point sum reduction with a multiplication.  The
     419                 :            :      following test returns false for non integer types to avoid such
     420                 :            :      problems.  */
     421                 :      30145 :   if (!INTEGRAL_TYPE_P (type)
     422                 :       6340 :       && !POINTER_TYPE_P (type))
     423                 :            :     return false;
     424                 :            : 
     425                 :      25483 :   loop = loop_containing_stmt (SSA_NAME_DEF_STMT (def));
     426                 :      25483 :   scev = scalar_evolution_in_region (region, loop, def);
     427                 :            : 
     428                 :      25483 :   return (!chrec_contains_undetermined (scev)
     429                 :      20175 :           && (TREE_CODE (scev) != SSA_NAME
     430                 :       1307 :               || !defined_in_sese_p (scev, region))
     431                 :      20175 :           && scev_is_linear_expression (scev)
     432                 :      45384 :           && (! loop
     433                 :      19243 :               || ! loop_in_sese_p (loop, region)
     434                 :      18524 :               || ! chrec_contains_symbols_defined_in_loop (scev, loop->num)));
     435                 :            : }
     436                 :            : 
     437                 :            : /* Returns the scalar evolution of T in REGION.  Every variable that
     438                 :            :    is not defined in the REGION is considered a parameter.  */
     439                 :            : 
     440                 :            : tree
     441                 :      32425 : scalar_evolution_in_region (const sese_l &region, loop_p loop, tree t)
     442                 :            : {
     443                 :            :   /* SCOP parameters.  */
     444                 :      32425 :   if (TREE_CODE (t) == SSA_NAME
     445                 :      32425 :       && !defined_in_sese_p (t, region))
     446                 :            :     return t;
     447                 :            : 
     448                 :      30046 :   if (!loop_in_sese_p (loop, region))
     449                 :        361 :     loop = NULL;
     450                 :            : 
     451                 :      30046 :   return instantiate_scev (region.entry, loop,
     452                 :      30046 :                            analyze_scalar_evolution (loop, t));
     453                 :            : }
     454                 :            : 
     455                 :            : /* Return true if BB is empty, contains only DEBUG_INSNs.  */
     456                 :            : 
     457                 :            : bool
     458                 :       1585 : sese_trivially_empty_bb_p (basic_block bb)
     459                 :            : {         
     460                 :       1585 :   gimple_stmt_iterator gsi;
     461                 :            : 
     462                 :       3170 :   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     463                 :          0 :     if (!is_gimple_debug (gsi_stmt (gsi))
     464                 :          0 :         && gimple_code (gsi_stmt (gsi)) != GIMPLE_LABEL)
     465                 :            :       return false;
     466                 :            : 
     467                 :            :   return true;
     468                 :            : }
     469                 :            : 
     470                 :            : /* Pretty print edge E to FILE.  */
     471                 :            : 
     472                 :            : void
     473                 :       1366 : print_edge (FILE *file, const_edge e)
     474                 :            : {
     475                 :       1366 :   fprintf (file, "edge (bb_%d, bb_%d)", e->src->index, e->dest->index);
     476                 :       1366 : }
     477                 :            : 
     478                 :            : /* Pretty print sese S to FILE.  */
     479                 :            : 
     480                 :            : void
     481                 :        683 : print_sese (FILE *file, const sese_l &s)
     482                 :            : {
     483                 :        683 :   fprintf (file, "(entry_"); print_edge (file, s.entry);
     484                 :        683 :   fprintf (file, ", exit_"); print_edge (file, s.exit);
     485                 :        683 :   fprintf (file, ")\n");
     486                 :        683 : }
     487                 :            : 
     488                 :            : /* Pretty print edge E to STDERR.  */
     489                 :            : 
     490                 :            : DEBUG_FUNCTION void
     491                 :          0 : debug_edge (const_edge e)
     492                 :            : {
     493                 :          0 :   print_edge (stderr, e);
     494                 :          0 : }
     495                 :            : 
     496                 :            : /* Pretty print sese S to STDERR.  */
     497                 :            : 
     498                 :            : DEBUG_FUNCTION void
     499                 :          0 : debug_sese (const sese_l &s)
     500                 :            : {
     501                 :          0 :   print_sese (stderr, s);
     502                 :          0 : }

Generated by: LCOV version 1.0

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