This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH][match-and-simplify] Change (match ...) syntax


After internal discussion this changes

(match logical_inverted_value
 (ne truth_valued_p@0 integer_onep)
 (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)))
  (logical_inverted_value @0)))

to

(match (logical_inverted_value @0)
 (ne truth_valued_p@0 integer_onep)
 (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)))))

thus avoids repeating 'logical_inverted_value' and puts whether
this is an expression or predicate matcher and its operands first.

Bootstrapped and tested on x86_64-unknown-linux-gnu, applied.

Richard.

2014-10-07  Richard Biener  <rguenther@suse.de>

	* genmatch.c (parser::parse_pattern): Change match parsing
	to expect the matching template first, not as result.
	(parser::parse_simplify): Likewise.
	* match-bitwise.pd: Adjust.

Index: gcc/genmatch.c
===================================================================
--- gcc/genmatch.c	(revision 215917)
+++ gcc/genmatch.c	(working copy)
@@ -2163,7 +2163,8 @@ private:
   operand *parse_op ();
 
   void parse_pattern ();
-  void parse_simplify (source_location, vec<simplify *>&, predicate_id *);
+  void parse_simplify (source_location, vec<simplify *>&, predicate_id *,
+		       expr *);
   void parse_for (source_location);
   void parse_if (source_location);
   void parse_predicates (source_location);
@@ -2528,7 +2529,8 @@ parser::parse_op ()
 
 void
 parser::parse_simplify (source_location match_location,
-			vec<simplify *>& simplifiers, predicate_id *matcher)
+			vec<simplify *>& simplifiers, predicate_id *matcher,
+			expr *result)
 {
   /* Reset the capture map.  */
   capture_ids = new std::map<std::string, unsigned>;
@@ -2549,12 +2551,8 @@ parser::parse_simplify (source_location
     {
       if (!matcher)
 	fatal_at (token, "expected transform expression");
-      else if (matcher->nargs > 0)
-	fatal_at (token, "expected match operand expression");
-      if (matcher->nargs == -1)
-	matcher->nargs = 0;
       simplifiers.safe_push
-	(new simplify (match, match_location, NULL, token->src_loc,
+	(new simplify (match, match_location, result, token->src_loc,
 		       active_ifs.copy (), active_fors.copy (),
 		       capture_ids));
       return;
@@ -2579,12 +2577,8 @@ parser::parse_simplify (source_location
 		{
 		  if (!matcher)
 		    fatal_at (token, "manual transform not implemented");
-		  else if (matcher->nargs > 0)
-		    fatal_at (token, "expected match operand expression");
-		  if (matcher->nargs == -1)
-		    matcher->nargs = 0;
 		  simplifiers.safe_push
-		      (new simplify (match, match_location, NULL,
+		      (new simplify (match, match_location, result,
 				     paren_loc, active_ifs.copy (),
 				     active_fors.copy (), capture_ids));
 		}
@@ -2599,19 +2593,9 @@ parser::parse_simplify (source_location
 	    }
 	  else
 	    {
-	      operand *op = parse_expr ();
-	      if (matcher)
-		{
-		  expr *e = dyn_cast <expr *> (op);
-		  if (!e)
-		    fatal_at (token, "match operand expression cannot "
-			      "be captured");
-		  if (matcher->nargs == -1)
-		    matcher->nargs = e->ops.length ();
-		  if (matcher->nargs == 0
-		      || (unsigned) matcher->nargs != e->ops.length ())
-		    fatal_at (token, "match arity doesn't match");
-		}
+	      operand *op = result;
+	      if (!matcher)
+		op = parse_expr ();
 	      simplifiers.safe_push
 		  (new simplify (match, match_location, op,
 				 token->src_loc, active_ifs.copy (),
@@ -2644,7 +2628,8 @@ parser::parse_simplify (source_location
 	  if (matcher)
 	    fatal_at (token, "expected match operand expression");
 	  simplifiers.safe_push
-	      (new simplify (match, match_location, parse_op (),
+	      (new simplify (match, match_location,
+			     matcher ? result : parse_op (),
 			     token->src_loc, active_ifs.copy (),
 			     active_fors.copy (), capture_ids));
 	  /* A "default" result closes the enclosing scope.  */
@@ -2811,9 +2796,15 @@ parser::parse_pattern ()
   const cpp_token *token = peek ();
   const char *id = get_ident ();
   if (strcmp (id, "simplify") == 0)
-    parse_simplify (token->src_loc, simplifiers, NULL);
+    parse_simplify (token->src_loc, simplifiers, NULL, NULL);
   else if (strcmp (id, "match") == 0)
     {
+      bool with_args = false;
+      if (peek ()->type == CPP_OPEN_PAREN)
+	{
+	  eat_token (CPP_OPEN_PAREN);
+	  with_args = true;
+	}
       const char *name = get_ident ();
       id_base *id = get_operator (name);
       predicate_id *p;
@@ -2826,7 +2817,21 @@ parser::parse_pattern ()
 	;
       else
 	fatal_at (token, "cannot add a match to a non-predicate ID");
-      parse_simplify (token->src_loc, p->matchers, p);
+      /* Parse (match <id> <arg>... (match-expr)) here.  */
+      expr *e = NULL;
+      if (with_args)
+	{
+	  e = new expr (p);
+	  while (peek ()->type == CPP_ATSIGN)
+	    e->append_op (parse_capture (NULL));
+	  eat_token (CPP_CLOSE_PAREN);
+	}
+      if (p->nargs != -1
+	  && ((e && e->ops.length () != (unsigned)p->nargs)
+	      || (!e && p->nargs != 0)))
+	fatal_at (token, "non-matching number of match operands");
+      p->nargs = e ? e->ops.length () : 0;
+      parse_simplify (token->src_loc, p->matchers, p, e);
     }
   else if (strcmp (id, "for") == 0)
     parse_for (token->src_loc);
Index: gcc/match-bitwise.pd
===================================================================
--- gcc/match-bitwise.pd	(revision 215917)
+++ gcc/match-bitwise.pd	(working copy)
@@ -80,20 +80,16 @@ along with GCC; see the file COPYING3.
   (op @0 @1)))
 (match truth_valued_p
   (truth_not @0))
-(match logical_inverted_value
- (bit_not truth_valued_p@0)
- (logical_inverted_value @0))
-(match logical_inverted_value
+(match (logical_inverted_value @0)
+ (bit_not truth_valued_p@0))
+(match (logical_inverted_value @0)
  (eq @0 integer_zerop)
- (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)))
-  (logical_inverted_value @0)))
-(match logical_inverted_value
+ (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)))))
+(match (logical_inverted_value @0)
  (ne truth_valued_p@0 integer_onep)
- (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)))
-  (logical_inverted_value @0)))
-(match logical_inverted_value
- (bit_xor truth_valued_p@0 integer_onep)
- (logical_inverted_value @0))
+ (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)))))
+(match (logical_inverted_value @0)
+ (bit_xor truth_valued_p@0 integer_onep))
 /* X & !X -> 0.  */
 (simplify
  (bit_and @0 (logical_inverted_value @0))


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]