[GSoC] outer-if expressions

[Prathamesh Kulkarni <bilbotheelffriend at gmail dot com>]

Hi,
   This patch adds support for outer-if expressions.

Couple of issues:
a) Doesn't interop with for-pattern, since we don't replace identifier
in c-expr yet,
and this gets more complicated with addition of outer-if.

b) I removed ifexpr-locations for now. I am not sure where to output
if-expr locations
when there are multiple if-exprs (one outer and one inner).

* genmatch.c (simplify::ifexpr): Remove.
      (simplify::ifexpr_location): Likewise.
      (simplify::simplify): Adjust to changes in simplify and
                                   add parameter ifexpr_vec_.
      (dt_simplify::gen_gimple): Adjust to changes in simplify.
      (dt_simplify::gen_generic): Likewise.
      (parse_if): New function.
      (parse_pattern): Add call to parse_if.

* match.pd: Use outer-if for plus-minus patterns.

Thanks,
Prathamesh

Index: gcc/genmatch.c
===================================================================
--- gcc/genmatch.c	(revision 212928)
+++ gcc/genmatch.c	(working copy)
@@ -298,18 +298,17 @@ e_operation::e_operation (const char *id
 struct simplify {
   simplify (const char *name_,
 	    operand *match_, source_location match_location_,
-	    struct operand *ifexpr_, source_location ifexpr_location_,
-	    struct operand *result_, source_location result_location_)
+	    struct operand *result_, source_location result_location_, vec<operand *> ifexpr_vec_ = vNULL)
       : name (name_), match (match_), match_location (match_location_),
-      ifexpr (ifexpr_), ifexpr_location (ifexpr_location_),
-      result (result_), result_location (result_location_) {}
+      result (result_), result_location (result_location_),
+      ifexpr_vec (ifexpr_vec_) {}
+
   const char *name;
   operand *match; 
   source_location match_location;
-  struct operand *ifexpr;
-  source_location ifexpr_location;
   struct operand *result;
   source_location result_location;
+  vec<operand *> ifexpr_vec;
 };
 
 struct dt_node
@@ -554,8 +553,7 @@ lower_commutative (simplify *s, vec<simp
   for (unsigned i = 0; i < matchers.length (); ++i)
     {
       simplify *ns = new simplify (s->name, matchers[i], s->match_location,
-				   s->ifexpr, s->ifexpr_location,
-				   s->result, s->result_location);
+				   s->result, s->result_location, s->ifexpr_vec);
       simplifiers.safe_push (ns);
     }
 }
@@ -1452,14 +1450,21 @@ dt_simplify::gen_gimple (FILE *f)
 	fprintf (f, "captures[%u] = %s;\n", i, indexes[i]->get_name (opname));
       }
 
-  if (s->ifexpr)
-	{
-	  output_line_directive (f, s->ifexpr_location);
-	  fprintf (f, "if (");
-	  s->ifexpr->gen_transform (f, NULL, true);
-	  fprintf (f, ")\n");
-	  fprintf (f, "{\n");
+  if (s->ifexpr_vec != vNULL)
+    {
+      fprintf (f, "if (");
+      // we add in LIFO order, so traverse backwards
+      for (unsigned i = s->ifexpr_vec.length (); i; --i)
+	{
+	  fprintf (f, "(");
+	  s->ifexpr_vec[i - 1]->gen_transform (f, NULL, true);
+	  fprintf (f, ")");
+	  if (i > 1)
+	    fprintf (f, " && ");
 	}
+      fprintf (f, ")\n");
+      fprintf (f, "{\n");
+    }
       output_line_directive (f, s->result_location);
 
       if (s->result->type == operand::OP_EXPR)
@@ -1487,7 +1492,7 @@ dt_simplify::gen_gimple (FILE *f)
 	gcc_unreachable ();
 
       fprintf (f, "return true;\n");
-      if (s->ifexpr)
+      if (s->ifexpr_vec != vNULL)
 	fprintf (f, "}\n");
 
   fprintf (f, "}\n");
@@ -1510,14 +1515,22 @@ dt_simplify::gen_generic (FILE *f)
 	fprintf (f, "captures[%u] = %s;\n", i, indexes[i]->get_name (opname));
       }
 
-  if (s->ifexpr)
-	{
-	  output_line_directive (f, s->ifexpr_location);
-	  fprintf (f, "if (");
-	  s->ifexpr->gen_transform (f, NULL, false);
-	  fprintf (f, ")\n");
-	  fprintf (f, "{\n");
-	}
+  if (s->ifexpr_vec != vNULL)
+    {
+      fprintf (f, "if (\n");
+      // we add in LIFO order, so traverse backwards
+      for (unsigned i = s->ifexpr_vec.length (); i; --i)
+        {
+          fprintf (f, "(");
+          s->ifexpr_vec[i - 1]->gen_transform (f, NULL, false);
+          fprintf (f, ")");
+          if (i > 1)
+            fprintf (f, " && ");
+        }
+      fprintf (f, ")\n");
+      fprintf (f, "{\n");
+    }
+
       output_line_directive (f, s->result_location);
 
       if (s->result->type == operand::OP_EXPR)
@@ -1551,7 +1564,7 @@ dt_simplify::gen_generic (FILE *f)
       else
 	gcc_unreachable ();
 
-      if (s->ifexpr)
+      if (s->ifexpr_vec != vNULL)
 	fprintf (f, "}\n");
 
   fprintf (f, "}\n");
@@ -2025,7 +2038,7 @@ parse_match_and_simplify (cpp_reader *r,
   token = peek (r);
 
   if (token->type != CPP_OPEN_PAREN)
-    return new simplify (id, match, match_location, 0, 0, parse_op (r), token->src_loc);
+    return new simplify (id, match, match_location, parse_op (r), token->src_loc);
 
   eat_token (r, CPP_OPEN_PAREN);
 
@@ -2037,25 +2050,27 @@ parse_match_and_simplify (cpp_reader *r,
     {
       operand *result = parse_expr (r);
       eat_token (r, CPP_CLOSE_PAREN);
-      return new simplify (id, match, match_location, 0, 0, result, result_loc); 
+      return new simplify (id, match, match_location, result, result_loc); 
     }
 
   // (if c-expr)
-  source_location ifexpr_loc = token->src_loc; 
   eat_ident (r, "if");
   operand *ifexpr = parse_c_expr (r, CPP_OPEN_PAREN);
   eat_token (r, CPP_CLOSE_PAREN);
 
   result_loc = peek (r)->src_loc;
-  return new simplify (id, match, match_location, ifexpr, ifexpr_loc, parse_op (r), result_loc);
+  simplify *s = new simplify (id, match, match_location, parse_op (r), result_loc);
+  s->ifexpr_vec.safe_push (ifexpr);
+  return s;
 }
 
+void parse_pattern (cpp_reader *, vec<simplify *>&);
+
 void
 parse_for (cpp_reader *r, source_location, vec<simplify *>& simplifiers) 
 {
   const char *user_id = get_ident (r);
   eat_ident (r, "in");
-  void parse_pattern (cpp_reader *, vec<simplify *>&);
 
   vec<const char *> opers = vNULL;
 
@@ -2086,8 +2101,7 @@ parse_for (cpp_reader *r, source_locatio
 	      operand *result_op = replace_id (s->result, user_id, opers[i]);
 
 	      simplify *ns = new simplify (s->name, match_op, s->match_location,
-					   s->ifexpr, s->ifexpr_location,
-				       result_op, s->result_location);
+					   result_op, s->result_location, s->ifexpr_vec);
 
 	      simplifiers.safe_push (ns);
 	    }
@@ -2095,6 +2109,30 @@ parse_for (cpp_reader *r, source_locatio
     }
 }
 
+void
+parse_if (cpp_reader *r, vec<simplify *>& simplifiers)
+{
+  operand *ifexpr = parse_c_expr (r, CPP_OPEN_PAREN);
+
+  unsigned pos = (simplifiers != vNULL) ? simplifiers.length () - 1 : 0;
+
+  const cpp_token *token = peek (r);
+  if (token->type == CPP_CLOSE_PAREN)
+    fatal_at (token, "no pattern defined in if");
+
+  while (1)
+    {
+      const cpp_token *token = peek (r);
+      if (token->type == CPP_CLOSE_PAREN)
+	break;
+    
+      parse_pattern (r, simplifiers);
+    }
+
+  for (unsigned i = pos; i < simplifiers.length (); ++i)
+    simplifiers[i]->ifexpr_vec.safe_push (ifexpr);
+}
+
 static size_t
 round_alloc_size (size_t s)
 {
@@ -2112,6 +2150,8 @@ parse_pattern (cpp_reader *r, vec<simpli
     simplifiers.safe_push (parse_match_and_simplify (r, token->src_loc));
   else if (strcmp (id, "for") == 0)
     parse_for (r, token->src_loc, simplifiers); 
+  else if (strcmp (id, "if") == 0)
+    parse_if (r, simplifiers);
   else
     fatal_at (token, "expected 'match_and_simplify' or 'for'");
 
@@ -2183,7 +2223,7 @@ main(int argc, char **argv)
 
   for (unsigned i = 0; i < simplifiers.length (); ++i)
     check_no_user_id (simplifiers[i]);
-  
+
   vec<simplify *> out_simplifiers = vNULL;
   for (unsigned i = 0; i < simplifiers.length (); ++i)
     lower_commutative (simplifiers[i], out_simplifiers);
Index: gcc/match.pd
===================================================================
--- gcc/match.pd	(revision 212928)
+++ gcc/match.pd	(working copy)
@@ -120,28 +120,24 @@ along with GCC; see the file COPYING3.
    ???  !FLOAT_TYPE_P && !FIXED_POINT_TYPE_P condition missing
    because of saturation to +-Inf.  */
 
-/* (A +- B) - A -> +-B.  */
-(match_and_simplify
-  (minus (plus @0 @1) @0)
-  (if (!TYPE_SATURATING (type)
-      && !FLOAT_TYPE_P (type) && !FIXED_POINT_TYPE_P (type)))
-  @1)
-(match_and_simplify
-  (minus (minus @0 @1) @0)
-  (if (!TYPE_SATURATING (type)
-      && !FLOAT_TYPE_P (type) && !FIXED_POINT_TYPE_P (type)))
-  (negate @1))
-/* (A +- B) -+ B -> A.  */
-(match_and_simplify
-  (minus (plus @0 @1) @1)
-  (if (!TYPE_SATURATING (type)
-      && !FLOAT_TYPE_P (type) && !FIXED_POINT_TYPE_P (type)))
-  @0)
-(match_and_simplify
-  (plus:c (minus @0 @1) @1)
-  (if (!TYPE_SATURATING (type)
-      && !FLOAT_TYPE_P (type) && !FIXED_POINT_TYPE_P (type)))
-  @0)
+(if (!TYPE_SATURATING (type)
+    && !FLOAT_TYPE_P (type) && !FIXED_POINT_TYPE_P (type))
+  (match_and_simplify
+    (minus (plus @0 @1) @0)
+    @1)
+
+  (match_and_simplify
+    (minus (minus @0 @1) @0)
+    (negate @1))
+
+  (match_and_simplify
+    (minus (plus @0 @1) @1)
+    @0)
+
+  (match_and_simplify
+    (plus:c (minus @0 @1) @1)
+    @0))
+
 /* (CST +- A) +- CST -> CST' +- A.  */
 /* match_and_simplify handles constant folding for us so we can
    implement these as re-association patterns.