From: law <law@138bc75d-0d04-0410-961f-82ee72b054a4>
Date: Mon, 18 Nov 2013 19:10:41 +0000 (+0000)
Subject:         * tree-ssa-threadupdate.c: Fix file block comment.
X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=afe75331c747822e4913032047b0172c110ec38e;p=thirdparty%2Fgcc.git

    * tree-ssa-threadupdate.c: Fix file block comment.
        Fix minor indention issue.

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

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 810197367443..d61b4946aa84 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,8 @@
+2013-11-18  Jeff Law  <law@redhat.com>
+
+	* tree-ssa-threadupdate.c: Fix file block comment.
+	Fix minor indention issue.
+
 2013-11-18  Uros Bizjak  <ubizjak@gmail.com>
 
 	* config/i386/i386.c (ix86_decompose_address): Use REG_P instead of
diff --git a/gcc/tree-ssa-threadupdate.c b/gcc/tree-ssa-threadupdate.c
index e819d65e0303..7cca91ad2682 100644
--- a/gcc/tree-ssa-threadupdate.c
+++ b/gcc/tree-ssa-threadupdate.c
@@ -73,19 +73,16 @@ along with GCC; see the file COPYING3.  If not see
    set of unique destination blocks that the incoming edges should
    be threaded to.
 
-   Block duplication can be further minimized by using B instead of
-   creating B' for one destination if all edges into B are going to be
-   threaded to a successor of B.  We had code to do this at one time, but
-   I'm not convinced it is correct with the changes to avoid mucking up
-   the loop structure (which may cancel threading requests, thus a block
-   which we thought was going to become unreachable may still be reachable).
-   This code was also going to get ugly with the introduction of the ability
-   for a single jump thread request to bypass multiple blocks.
+   We reduce the number of edges and statements we create by not copying all
+   the outgoing edges and the control statement in step #1.  We instead create
+   a template block without the outgoing edges and duplicate the template.
 
-   We further reduce the number of edges and statements we create by
-   not copying all the outgoing edges and the control statement in
-   step #1.  We instead create a template block without the outgoing
-   edges and duplicate the template.  */
+   Another case this code handles is threading through a "joiner" block.  In
+   this case, we do not know the destination of the joiner block, but one
+   of the outgoing edges from the joiner block leads to a threadable path.  This
+   case largely works as outlined above, except the duplicate of the joiner
+   block still contains a full set of outgoing edges and its control statement.
+   We just redirect one of its outgoing edges to our jump threading path.  */
 
 
 /* Steps #5 and #6 of the above algorithm are best implemented by walking
@@ -389,7 +386,7 @@ create_edge_and_update_destination_phis (struct redirection_data *rd,
 	    = new jump_thread_edge ((*path)[i]->e, (*path)[i]->type);
 	  copy->safe_push (x);
 	}
-     e->aux = (void *)copy;
+      e->aux = (void *)copy;
     }
   else
     {