genattrtab.c (simplify_test_exp_in_temp): New function.

        * genattrtab.c (simplify_test_exp_in_temp): New function.
        (simplify_test_exp): Avoid explicit use of temporary obstack.
        (simplify_cond, insert_right_side, evaluate_eq_attr,
        simplify_and_tree, simplify_or_tree, eliminate_known_true):
        Use simplify_test_exp_in_temp.
        (optimize_attrs): Iterate until expression stabilizes.

From-SVN: r44890

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index abeaba7bde59e6507adedb50b10bf6881c48ab63..c0ed70396ad20ed69d05fad12b5853367020a1fb 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+Tue Aug 14 14:57:07 CEST 2001  Jan Hubicka  <jh@suse.cz>
+
+        * genattrtab.c (simplify_test_exp_in_temp): New function.
+        (simplify_test_exp): Avoid explicit use of temporary obstack.
+        (simplify_cond, insert_right_side, evaluate_eq_attr,
+        simplify_and_tree, simplify_or_tree, eliminate_known_true):
+        Use simplify_test_exp_in_temp.
+        (optimize_attrs): Iterate until expression stabilizes.
+
 2001-08-13  Ulrich Weigand  <uweigand@de.ibm.com>:
  
        * glimits.h: Remove the __LONG_MAX__ special case for s390x.

diff --git a/gcc/genattrtab.c b/gcc/genattrtab.c
index fcf449c073bf0a4f5cecc0ba7e02f2af737b91e3..2894e686113b8f425a026b386fc67fdea64bc361 100644 (file)
--- a/gcc/genattrtab.c
+++ b/gcc/genattrtab.c
@@ -417,6 +417,7 @@ static rtx evaluate_eq_attr PARAMS ((rtx, rtx, int, int));
 static rtx simplify_and_tree   PARAMS ((rtx, rtx *, int, int));
 static rtx simplify_or_tree    PARAMS ((rtx, rtx *, int, int));
 static rtx simplify_test_exp   PARAMS ((rtx, int, int));
+static rtx simplify_test_exp_in_temp PARAMS ((rtx, int, int));
 static void optimize_attrs     PARAMS ((void));
 static void gen_attr           PARAMS ((rtx, int));
 static int count_alternatives  PARAMS ((rtx));
@@ -2593,7 +2594,7 @@ simplify_cond (exp, insn_code, insn_index)
       rtx newtest, newval;
 
       /* Simplify this test.  */
-      newtest = SIMPLIFY_TEST_EXP (tests[i], insn_code, insn_index);
+      newtest = simplify_test_exp_in_temp (tests[i], insn_code, insn_index);
       tests[i] = newtest;
 
       newval = tests[i + 1];
@@ -2782,7 +2783,7 @@ insert_right_side (code, exp, term, insn_code, insn_index)
       newexp = attr_rtx (code, exp, term);
     }
 
-  return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
+  return simplify_test_exp_in_temp (newexp, insn_code, insn_index);
 }
 \f
 /* If we have an expression which AND's a bunch of
@@ -2910,8 +2911,8 @@ evaluate_eq_attr (exp, value, insn_code, insn_index)
 
       for (i = 0; i < XVECLEN (value, 0); i += 2)
        {
-         rtx this = SIMPLIFY_TEST_EXP (XVECEXP (value, 0, i),
-                                       insn_code, insn_index);
+         rtx this = simplify_test_exp_in_temp (XVECEXP (value, 0, i),
+                                               insn_code, insn_index);
 
          SIMPLIFY_ALTERNATIVE (this);
 
@@ -2992,7 +2993,7 @@ simplify_and_tree (exp, pterm, insn_code, insn_index)
        {
          newexp = attr_rtx (GET_CODE (exp), left, right);
 
-         exp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
+         exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
        }
     }
 
@@ -3015,7 +3016,7 @@ simplify_and_tree (exp, pterm, insn_code, insn_index)
        {
          newexp = attr_rtx (GET_CODE (exp), left, right);
 
-         exp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
+         exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
        }
     }
 
@@ -3111,7 +3112,7 @@ simplify_or_tree (exp, pterm, insn_code, insn_index)
        {
          newexp = attr_rtx (GET_CODE (exp), left, right);
 
-         exp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
+         exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
        }
     }
 
@@ -3134,7 +3135,7 @@ simplify_or_tree (exp, pterm, insn_code, insn_index)
        {
          newexp = attr_rtx (GET_CODE (exp), left, right);
 
-         exp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
+         exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
        }
     }
 
@@ -3207,6 +3208,29 @@ attr_rtx_cost (x)
   return cost;
 }
 \f
+
+/* Simplify test expression and use temporary obstack in order to avoid
+   memory bloat.  Use RTX_UNCHANGING_P to avoid unnecesary simplifications
+   and avoid unnecesary copying if possible.  */
+
+static rtx
+simplify_test_exp_in_temp (exp, insn_code, insn_index)
+  rtx exp;
+  int insn_code, insn_index;
+{
+  rtx x;
+  struct obstack *old;
+  if (RTX_UNCHANGING_P (exp))
+    return exp;
+  old = rtl_obstack;
+  rtl_obstack = temp_obstack;
+  x = simplify_test_exp (exp, insn_code, insn_index);
+  rtl_obstack = old;
+  if (x == exp || rtl_obstack == temp_obstack)
+    return x;
+  return attr_copy_rtx (x);
+}
+
 /* Given an expression, see if it can be simplified for a particular insn
    code based on the values of other attributes being tested.  This can
    eliminate nested get_attr_... calls.
@@ -3464,13 +3488,10 @@ simplify_test_exp (exp, insn_code, insn_index)
            if (ie->insn_code == insn_code)
              {
                rtx x;
-               struct obstack *old = rtl_obstack;
-               rtl_obstack = temp_obstack;
                x = evaluate_eq_attr (exp, av->value, insn_code, insn_index);
                x = SIMPLIFY_TEST_EXP (x, insn_code, insn_index);
-               rtl_obstack = old;
                if (attr_rtx_cost(x) < 20)
-                 return attr_copy_rtx (x);
+                 return x;
              }
       break;
 
@@ -3499,7 +3520,6 @@ optimize_attrs ()
   struct attr_value *av;
   struct insn_ent *ie;
   rtx newexp;
-  int something_changed = 1;
   int i;
   struct attr_value_list
   {
@@ -3556,42 +3576,42 @@ optimize_attrs ()
       for (iv = insn_code_values[i]; iv; iv = iv->next)
        clear_struct_flag (iv->av->value);
 
-      /* Loop until nothing changes for one iteration.  */
-      something_changed = 1;
-      while (something_changed)
+      for (iv = insn_code_values[i]; iv; iv = iv->next)
        {
-         something_changed = 0;
-         for (iv = insn_code_values[i]; iv; iv = iv->next)
-           {
-             struct obstack *old = rtl_obstack;
+         struct obstack *old = rtl_obstack;
 
-             attr = iv->attr;
-             av = iv->av;
-             ie = iv->ie;
-             if (GET_CODE (av->value) != COND)
-               continue;
+         attr = iv->attr;
+         av = iv->av;
+         ie = iv->ie;
+         if (GET_CODE (av->value) != COND)
+           continue;
 
-             rtl_obstack = temp_obstack;
+         rtl_obstack = temp_obstack;
 #if 0 /* This was intended as a speed up, but it was slower.  */
-             if (insn_n_alternatives[ie->insn_code] > 6
-                 && count_sub_rtxs (av->value, 200) >= 200)
-               newexp = simplify_by_alternatives (av->value, ie->insn_code,
-                                                  ie->insn_index);
-             else
+         if (insn_n_alternatives[ie->insn_code] > 6
+             && count_sub_rtxs (av->value, 200) >= 200)
+           newexp = simplify_by_alternatives (av->value, ie->insn_code,
+                                              ie->insn_index);
+         else
 #endif
-               newexp = simplify_cond (av->value, ie->insn_code,
-                                       ie->insn_index);
+         newexp = av->value;
+         while (GET_CODE (newexp) == COND)
+           {
+             rtx newexp2 = simplify_cond (newexp, ie->insn_code,
+                                          ie->insn_index);
+             if (newexp2 == newexp)
+               break;
+             newexp = newexp2;
+           }
 
-             rtl_obstack = old;
-             if (newexp != av->value)
-               {
-                 newexp = attr_copy_rtx (newexp);
-                 remove_insn_ent (av, ie);
-                 av = get_attr_value (newexp, attr, ie->insn_code);
-                 iv->av = av;
-                 insert_insn_ent (av, ie);
-                 something_changed = 1;
-               }
+         rtl_obstack = old;
+         if (newexp != av->value)
+           {
+             newexp = attr_copy_rtx (newexp);
+             remove_insn_ent (av, ie);
+             av = get_attr_value (newexp, attr, ie->insn_code);
+             iv->av = av;
+             insert_insn_ent (av, ie);
            }
        }
     }