c-gimplify.c (gimplify_c_loop): Improve initial implementations for loops whose condi...

	* c-gimplify.c (gimplify_c_loop): Improve initial implementations
	for loops whose conditions are known at compile-time.
	* gimplify.c (append_to_statement_list_1): Remove side_effects
	parameter, this function should never be called if its false.
	(append_to_statement_list): Only call append_to_statement_list_1
	if t is non-NULL tree with side-effects.
	(append_to_statement_list_force):  Likewise, if t is not NULL.

From-SVN: r91784

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 6cc24b7b1b2e23c58cf585e7b601849ea7ae18c6..f5e676e1afe1345f4bbadf44f1f9971677f478fc 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,13 @@
+2004-12-06  Roger Sayle  <roger@eyesopen.com>
+
+       * c-gimplify.c (gimplify_c_loop): Improve initial implementations
+       for loops whose conditions are known at compile-time.
+       * gimplify.c (append_to_statement_list_1): Remove side_effects
+       parameter, this function should never be called if its false.
+       (append_to_statement_list): Only call append_to_statement_list_1
+       if t is non-NULL tree with side-effects.
+       (append_to_statement_list_force):  Likewise, if t is not NULL.
+
 2004-12-06  J"orn Rennecke <joern.rennecke@st.com>
 
        * bt-load.c (btr_def_s): New member own_end;

diff --git a/gcc/c-gimplify.c b/gcc/c-gimplify.c
index d77d75c2f77ce23571fccb92197d1b610e4c10aa..db6cd88fd9b566459572b90937e03b9315cd9e4c 100644 (file)
--- a/gcc/c-gimplify.c
+++ b/gcc/c-gimplify.c
@@ -338,10 +338,23 @@ gimplify_c_loop (tree cond, tree body, tree incr, bool cond_is_first)
   location_t stmt_locus;
 
   stmt_locus = input_location;
+  stmt_list = NULL_TREE;
+  entry = NULL_TREE;
 
-  /* Detect do { ... } while (0) and don't generate loop construct.  */
-  if (!cond_is_first && cond && integer_zerop (cond))
-    top = cond = NULL;
+  break_block = begin_bc_block (bc_break);
+  cont_block = begin_bc_block (bc_continue);
+
+  /* If condition is zero don't generate a loop construct.  */
+  if (cond && integer_zerop (cond))
+    {
+      top = NULL_TREE;
+      exit = NULL_TREE;
+      if (cond_is_first)
+       {
+         t = build_bc_goto (bc_break);
+         append_to_statement_list (t, &stmt_list);
+       }
+    }
   else
     {
       /* If we use a LOOP_EXPR here, we have to feed the whole thing
@@ -349,45 +362,37 @@ gimplify_c_loop (tree cond, tree body, tree incr, bool cond_is_first)
         have to gimplify the loop body NOW so that we can resolve
         break/continue stmts, seems easier to just expand to gotos.  */
       top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
-    }
-
-  break_block = begin_bc_block (bc_break);
 
-  if (top)
-    {
       /* If we have an exit condition, then we build an IF with gotos either
         out of the loop, or to the top of it.  If there's no exit condition,
         then we just build a jump back to the top.  */
       exit = build_and_jump (&LABEL_EXPR_LABEL (top));
-      if (cond)
+      if (cond && !integer_nonzerop (cond))
        {
          t = build_bc_goto (bc_break);
          exit = build3 (COND_EXPR, void_type_node, cond, exit, t);
          exit = fold (exit);
          gimplify_stmt (&exit);
+
+         if (cond_is_first)
+           {
+             if (incr)
+               {
+                 entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
+                 t = build_and_jump (&LABEL_EXPR_LABEL (entry));
+               }
+             else
+               t = build_bc_goto (bc_continue);
+             append_to_statement_list (t, &stmt_list);
+           }
        }
     }
-  else
-    exit = NULL_TREE;
-
-  cont_block = begin_bc_block (bc_continue);
 
   gimplify_stmt (&body);
   gimplify_stmt (&incr);
 
   body = finish_bc_block (cont_block, body);
 
-  stmt_list = NULL;
-
-  if (cond_is_first && cond)
-    {
-      entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
-      t = build_and_jump (&LABEL_EXPR_LABEL (entry));
-      append_to_statement_list (t, &stmt_list);
-    }
-  else
-    entry = NULL_TREE;
-
   append_to_statement_list (top, &stmt_list);
   append_to_statement_list (body, &stmt_list);
   append_to_statement_list (incr, &stmt_list);

diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index 6a9e3b140c7a379bc332b0a332a280d82a17dd00..41814a7fddf305a9f172281b592e5b5a1b178767 100644 (file)
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -214,17 +214,14 @@ gimple_pop_condition (tree *pre_p)
     }
 }
 
-/* A subroutine of append_to_statement_list{,_force}.  */
+/* A subroutine of append_to_statement_list{,_force}.  T is not NULL.  */
 
 static void
-append_to_statement_list_1 (tree t, tree *list_p, bool side_effects)
+append_to_statement_list_1 (tree t, tree *list_p)
 {
   tree list = *list_p;
   tree_stmt_iterator i;
 
-  if (!side_effects)
-    return;
-
   if (!list)
     {
       if (t && TREE_CODE (t) == STATEMENT_LIST)
@@ -245,7 +242,8 @@ append_to_statement_list_1 (tree t, tree *list_p, bool side_effects)
 void
 append_to_statement_list (tree t, tree *list_p)
 {
-  append_to_statement_list_1 (t, list_p, t ? TREE_SIDE_EFFECTS (t) : false);
+  if (t && TREE_SIDE_EFFECTS (t))
+    append_to_statement_list_1 (t, list_p);
 }
 
 /* Similar, but the statement is always added, regardless of side effects.  */
@@ -253,7 +251,8 @@ append_to_statement_list (tree t, tree *list_p)
 void
 append_to_statement_list_force (tree t, tree *list_p)
 {
-  append_to_statement_list_1 (t, list_p, t != NULL);
+  if (t != NULL_TREE)
+    append_to_statement_list_1 (t, list_p);
 }
 
 /* Both gimplify the statement T and append it to LIST_P.  */