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

[Richard Biener]

After internal discussion this changes

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

to

(match (logical_inverted_value @0)
(ne ***@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 <***@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 ***@0)
- (logical_inverted_value @0))
-(match logical_inverted_value
+(match (logical_inverted_value @0)
+ (bit_not ***@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 ***@0 integer_onep)
- (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)))
- (logical_inverted_value @0)))
-(match logical_inverted_value
- (bit_xor ***@0 integer_onep)
- (logical_inverted_value @0))
+ (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)))))
+(match (logical_inverted_value @0)
+ (bit_xor ***@0 integer_onep))
/* X & !X -> 0. */
(simplify
(bit_and @0 (logical_inverted_value @0))