Reword comments that mention ENTRY_BLOCK_PTR and EXIT_BLOCK_PTR macros

gcc/
2013-11-20  David Malcolm  <dmalcolm@redhat.com>

	* cfg.c (dump_edge_info): Remove redundant comment.
	* cfgcleanup.c (outgoing_edges_match): Reword reference to
	EXIT_BLOCK_PTR in comment.
	(try_optimize_cfg): Likewise.
	* cfgrtl.c (last_bb_in_partition): Likewise.
	* cgraph.c (cgraph_node_cannot_return): Likewise.
	* function.c (thread_prologue_and_epilogue_insns): Likewise.
	* graphite-scop-detection.c (scopdet_basic_block_info): Likewise.
	* ipa-split.c (consider_split): Likewise.
	* profile.c (find_spanning_tree): Likewise.
	* sched-int.h (common_sched_info_def.add_block): Likewise.
	* dominance.c (calc_dfs_tree_nonrec): Reword references in
	comments to now removed ENTRY_BLOCK_PTR and EXIT_BLOCK_PTR macros.
	* tree-cfgcleanup.c (cleanup_control_flow_bb): Reword references
	in comments to now removed ENTRY_BLOCK_PTR macro.
	(tree_forwarder_block_p): Reword reference in comment to
	EXIT_BLOCK_PTR.
	* tree-inline.c (copy_cfg_body): Reword references in comments to
	now removed ENTRY_BLOCK_PTR macro.
	* tree-ssa-propagate.c (ssa_prop_init): Likewise.
	* tree-scalar-evolution.h ( block_before_loop): Likewise.  Add
	a comma to the comment to clarify the meaning.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@205182 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 16ddef3a2c76a187e729b7de5c8502dbdc5c496d..98ac033b5903aad1f6aaec9e21ca321d819b9127 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,28 @@
+2013-11-20  David Malcolm  <dmalcolm@redhat.com>
+
+       * cfg.c (dump_edge_info): Remove redundant comment.
+       * cfgcleanup.c (outgoing_edges_match): Reword reference to
+       EXIT_BLOCK_PTR in comment.
+       (try_optimize_cfg): Likewise.
+       * cfgrtl.c (last_bb_in_partition): Likewise.
+       * cgraph.c (cgraph_node_cannot_return): Likewise.
+       * function.c (thread_prologue_and_epilogue_insns): Likewise.
+       * graphite-scop-detection.c (scopdet_basic_block_info): Likewise.
+       * ipa-split.c (consider_split): Likewise.
+       * profile.c (find_spanning_tree): Likewise.
+       * sched-int.h (common_sched_info_def.add_block): Likewise.
+       * dominance.c (calc_dfs_tree_nonrec): Reword references in
+       comments to now removed ENTRY_BLOCK_PTR and EXIT_BLOCK_PTR macros.
+       * tree-cfgcleanup.c (cleanup_control_flow_bb): Reword references
+       in comments to now removed ENTRY_BLOCK_PTR macro.
+       (tree_forwarder_block_p): Reword reference in comment to
+       EXIT_BLOCK_PTR.
+       * tree-inline.c (copy_cfg_body): Reword references in comments to
+       now removed ENTRY_BLOCK_PTR macro.
+       * tree-ssa-propagate.c (ssa_prop_init): Likewise.
+       * tree-scalar-evolution.h ( block_before_loop): Likewise.  Add
+       a comma to the comment to clarify the meaning.
+
 2013-11-20  Andrew MacLeod  <amacleod@redhat.com>
 
        * gimplify.h (gimplify_hasher : typed_free_remove, struct gimplify_ctx):

diff --git a/gcc/cfg.c b/gcc/cfg.c
index e35eee9a9bcd803b090822c89392c164c7915ec8..6bceca5ed26f14deda54d17ad82ed4f4b7dfa792 100644 (file)
--- a/gcc/cfg.c
+++ b/gcc/cfg.c
@@ -473,8 +473,6 @@ dump_edge_info (FILE *file, edge e, int flags, int do_succ)
       && (flags & TDF_SLIM) == 0)
     do_details = true;
 
-  /* ENTRY_BLOCK_PTR/EXIT_BLOCK_PTR depend on cfun.
-     Compare against ENTRY_BLOCK/EXIT_BLOCK to avoid that dependency.  */
   if (side->index == ENTRY_BLOCK)
     fputs (" ENTRY", file);
   else if (side->index == EXIT_BLOCK)

diff --git a/gcc/cfgcleanup.c b/gcc/cfgcleanup.c
index 9c126102a543bc075cd9f85c7c4dd70909a97141..dbaee9667ab36928de88308d5cd3177184c32a44 100644 (file)
--- a/gcc/cfgcleanup.c
+++ b/gcc/cfgcleanup.c
@@ -1535,7 +1535,7 @@ outgoing_edges_match (int mode, basic_block bb1, basic_block bb2)
   edge e1, e2;
   edge_iterator ei;
 
-  /* If we performed shrink-wrapping, edges to the EXIT_BLOCK_PTR can
+  /* If we performed shrink-wrapping, edges to the exit block can
      only be distinguished for JUMP_INSNs.  The two paths may differ in
      whether they went through the prologue.  Sibcalls are fine, we know
      that we either didn't need or inserted an epilogue before them.  */
@@ -2684,7 +2684,7 @@ try_optimize_cfg (int mode)
                    }
                  delete_basic_block (b);
                  changed = true;
-                 /* Avoid trying to remove ENTRY_BLOCK_PTR.  */
+                 /* Avoid trying to remove the exit block.  */
                  b = (c == ENTRY_BLOCK_PTR_FOR_FN (cfun) ? c->next_bb : c);
                  continue;
                }

diff --git a/gcc/cfgrtl.c b/gcc/cfgrtl.c
index 7ad38721606af64809610a9c90d4c001c7b103a0..63f44afbbae1eb15c41ba6970e328881005fd2eb 100644 (file)
--- a/gcc/cfgrtl.c
+++ b/gcc/cfgrtl.c
@@ -1795,7 +1795,7 @@ last_bb_in_partition (basic_block start_bb)
       if (BB_PARTITION (start_bb) != BB_PARTITION (bb->next_bb))
         return bb;
     }
-  /* Return bb before EXIT_BLOCK_PTR.  */
+  /* Return bb before the exit block.  */
   return bb->prev_bb;
 }
 

diff --git a/gcc/cgraph.c b/gcc/cgraph.c
index 624d492cb75f43489ae77e11ac2502496b153248..009a165cdfae57308cbc30f5c42b19363dfca9de 100644 (file)
--- a/gcc/cgraph.c
+++ b/gcc/cgraph.c
@@ -2334,7 +2334,7 @@ cgraph_node_cannot_return (struct cgraph_node *node)
    and thus it is safe to ignore its side effects for IPA analysis
    when computing side effects of the caller.
    FIXME: We could actually mark all edges that have no reaching
-   patch to EXIT_BLOCK_PTR or throw to get better results.  */
+   patch to the exit block or throw to get better results.  */
 bool
 cgraph_edge_cannot_lead_to_return (struct cgraph_edge *e)
 {

diff --git a/gcc/dominance.c b/gcc/dominance.c
index 3d88c0d3ed109de0e52ec0ef04faea245cb2b9ee..5ece3f68b94eeb152ad55fd7c2b554d2e8e466d1 100644 (file)
--- a/gcc/dominance.c
+++ b/gcc/dominance.c
@@ -227,7 +227,7 @@ calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb, bool reverse)
   edge_iterator *stack;
   edge_iterator ei, einext;
   int sp;
-  /* Start block (ENTRY_BLOCK_PTR for forward problem, EXIT_BLOCK for backward
+  /* Start block (the entry block for forward problem, exit block for backward
      problem).  */
   basic_block en_block;
   /* Ending block.  */

diff --git a/gcc/function.c b/gcc/function.c
index fde4a8e6d07be5b7673dae870f01cbafb6c3c572..5b33c46559b103925fa47fbbe920b7bfd57acaf1 100644 (file)
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -6349,7 +6349,7 @@ thread_prologue_and_epilogue_insns (void)
        {
          unsigned i, last;
 
-         /* convert_jumps_to_returns may add to EXIT_BLOCK_PTR->preds
+         /* convert_jumps_to_returns may add to preds of the exit block
             (but won't remove).  Stop at end of current preds.  */
          last = EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds);
          for (i = 0; i < last; i++)

diff --git a/gcc/graphite-scop-detection.c b/gcc/graphite-scop-detection.c
index 0cfb5a59cc9986926aed94de6937a5b87f91142c..15c4c0f99ea78dd00fc4b79b519a91b3137ad629 100644 (file)
--- a/gcc/graphite-scop-detection.c
+++ b/gcc/graphite-scop-detection.c
@@ -518,7 +518,7 @@ scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
            result.next = exit_e->dest;
 
            /* If we do not dominate result.next, remove it.  It's either
-              the EXIT_BLOCK_PTR, or another bb dominates it and will
+              the exit block, or another bb dominates it and will
               call the scop detection for this bb.  */
            if (!dominated_by_p (CDI_DOMINATORS, result.next, bb))
              result.next = NULL;

diff --git a/gcc/ipa-split.c b/gcc/ipa-split.c
index d7d6b8fd70f9db1db40bc4479a237ceba0995dac..2e8a062da6b59ffa3bf8fe53d38aa45bf8895558 100644 (file)
--- a/gcc/ipa-split.c
+++ b/gcc/ipa-split.c
@@ -635,7 +635,7 @@ consider_split (struct split_point *current, bitmap non_ssa_vars,
    <retval> = tmp_var;
    return <retval>
    but return_bb can not be more complex than this.
-   If nothing is found, return EXIT_BLOCK_PTR.
+   If nothing is found, return the exit block.
 
    When there are multiple RETURN statement, chose one with return value,
    since that one is more likely shared by multiple code paths.

diff --git a/gcc/profile.c b/gcc/profile.c
index 85671b30bc47f7e109cbd2ba89cd9e51b9b40607..1d0e78ab4dc779b7c192122ed55837be50c84fc4 100644 (file)
--- a/gcc/profile.c
+++ b/gcc/profile.c
@@ -1392,7 +1392,7 @@ find_spanning_tree (struct edge_list *el)
   union_groups (EXIT_BLOCK_PTR_FOR_FN (cfun), ENTRY_BLOCK_PTR_FOR_FN (cfun));
 
   /* First add all abnormal edges to the tree unless they form a cycle. Also
-     add all edges to EXIT_BLOCK_PTR to avoid inserting profiling code behind
+     add all edges to the exit block to avoid inserting profiling code behind
      setting return value from function.  */
   for (i = 0; i < num_edges; i++)
     {

diff --git a/gcc/sched-int.h b/gcc/sched-int.h
index 070404c42450d2d8b91503a83be4794af1c9d58a..84b5cb58c960e88bc758e1b9f975c793aab7fe1a 100644 (file)
--- a/gcc/sched-int.h
+++ b/gcc/sched-int.h
@@ -70,7 +70,7 @@ struct common_sched_info_def
   /* Called to notify frontend, that new basic block is being added.
      The first parameter - new basic block.
      The second parameter - block, after which new basic block is being added,
-     or EXIT_BLOCK_PTR, if recovery block is being added,
+     or the exit block, if recovery block is being added,
      or NULL, if standalone block is being added.  */
   void (*add_block) (basic_block, basic_block);
 

diff --git a/gcc/tree-cfgcleanup.c b/gcc/tree-cfgcleanup.c
index 4e5adc28a06aadb36c0b1e54941ae63e1597e46e..5ae70abc29e92cd6db65b7ea31b06a705e8c2759 100644 (file)
--- a/gcc/tree-cfgcleanup.c
+++ b/gcc/tree-cfgcleanup.c
@@ -237,7 +237,7 @@ cleanup_control_flow_bb (basic_block bb)
    the start of the successor block.
 
    As a precondition, we require that BB be not equal to
-   ENTRY_BLOCK_PTR.  */
+   the entry block.  */
 
 static bool
 tree_forwarder_block_p (basic_block bb, bool phi_wanted)
@@ -250,7 +250,7 @@ tree_forwarder_block_p (basic_block bb, bool phi_wanted)
       /* If PHI_WANTED is false, BB must not have any PHI nodes.
         Otherwise, BB must have PHI nodes.  */
       || gimple_seq_empty_p (phi_nodes (bb)) == phi_wanted
-      /* BB may not be a predecessor of EXIT_BLOCK_PTR.  */
+      /* BB may not be a predecessor of the exit block.  */
       || single_succ (bb) == EXIT_BLOCK_PTR_FOR_FN (cfun)
       /* Nor should this be an infinite loop.  */
       || single_succ (bb) == bb

diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index 678579ac3de5059e5da7b52673247e235bbf3b24..224788222f6f0f97c1c8e7c879e8c12c70d2a7ef 100644 (file)
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -2433,9 +2433,10 @@ copy_cfg_body (copy_body_data * id, gcov_type count, int frequency_scale,
   /* Register specific tree functions.  */
   gimple_register_cfg_hooks ();
 
-  /* If we are inlining just region of the function, make sure to connect new entry
-     to ENTRY_BLOCK_PTR.  Since new entry can be part of loop, we must compute
-     frequency and probability of ENTRY_BLOCK_PTR based on the frequencies and
+  /* If we are inlining just region of the function, make sure to connect
+     new entry to ENTRY_BLOCK_PTR_FOR_FN (cfun).  Since new entry can be
+     part of loop, we must compute frequency and probability of
+     ENTRY_BLOCK_PTR_FOR_FN (cfun) based on the frequencies and
      probabilities of edges incoming from nonduplicated region.  */
   if (new_entry)
     {

diff --git a/gcc/tree-scalar-evolution.h b/gcc/tree-scalar-evolution.h
index 8846fbe50cca77d7903576a081cb957742d38b39..fc87251cabeaac21823ecdd992a635404bd8e82f 100644 (file)
--- a/gcc/tree-scalar-evolution.h
+++ b/gcc/tree-scalar-evolution.h
@@ -40,8 +40,8 @@ extern bool simple_iv (struct loop *, struct loop *, tree, struct affine_iv_d *,
                       bool);
 extern tree compute_overall_effect_of_inner_loop (struct loop *, tree);
 
-/* Returns the basic block preceding LOOP or ENTRY_BLOCK_PTR when the
-   loop is function's body.  */
+/* Returns the basic block preceding LOOP, or the CFG entry block when
+   the loop is function's body.  */
 
 static inline basic_block
 block_before_loop (loop_p loop)

diff --git a/gcc/tree-ssa-propagate.c b/gcc/tree-ssa-propagate.c
index b9db34c5057369ad11a37580399b9a273bfd3d89..b45ff4755c2862fae8a61701e22bb1e3e1375a68 100644 (file)
--- a/gcc/tree-ssa-propagate.c
+++ b/gcc/tree-ssa-propagate.c
@@ -503,7 +503,7 @@ ssa_prop_init (void)
   cfg_blocks.safe_grow_cleared (20);
 
   /* Initially assume that every edge in the CFG is not executable.
-     (including the edges coming out of ENTRY_BLOCK_PTR).  */
+     (including the edges coming out of the entry block).  */
   FOR_ALL_BB (bb)
     {
       gimple_stmt_iterator si;