Fixed a silly mistake in match-bitwise.pd (I had put ')' at wrong place).
This patch also checks if operator-list is used outside for-pattern
(in parser::parse_operation).
* genmatch.c
(user_id): Add new member is_oper_list.
(user_id::user_id): Add new default argument.
(parser::parse_operator_list): New member function in parser.
(add_substitute): New function.
(flatten_substitutes): Likewise.
(parser::parse_for): Call add_substitute.
(parser::parse_pattern): Call parser::parse_operator_list.
(parser::parse_operation): Put check for operator-list.
* match-bitwise.pd
(bitwise_ors): New operator-list.
(bitwise_ops): Likewise.
Use bitwise_ors and bitwise_ops in patterns.
* match-comparison.pd
(eq_ops): New operator-list.
(cmp_ops): Likewise.
Use cmp_ops and eq_ops in patterns.
Thanks,
Prathamesh
On Sat, Oct 25, 2014 at 10:44 PM, Prathamesh Kulkarni
<bilbotheelffri...@gmail.com> wrote:
> Hi,
> This patch adds support for operator-lists, and uses
> them in match-bitwise.pd and match-comparison.pd
>
> * genmatch.c
> (parser::parse_operator_list): New member function in parser.
> (add_substitute): New function.
> (flatten_substitutes): Likewise.
> (parser::parse_for): Call add_substitute.
> (parser::parse_pattern): Call parser::parse_operator_list.
>
> * match-bitwise.pd
> (bitwise_ors): New operator-list.
> (bitwise_ops): Likewise.
> Use bitwise_ors and bitwise_ops in patterns.
>
> * match-comparison.pd
> (eq_ops): New operator-list.
> (cmp_ops): Likewise.
> Use cmp_ops and eq_ops in patterns.
>
> Thanks,
> Prathamesh
Index: gcc/genmatch.c
===================================================================
--- gcc/genmatch.c (revision 216673)
+++ gcc/genmatch.c (working copy)
@@ -218,9 +218,10 @@
struct user_id : public id_base
{
- user_id (const char *id_)
- : id_base (id_base::USER, id_), substitutes (vNULL) {}
+ user_id (const char *id_, bool is_oper_list_ = false)
+ : id_base (id_base::USER, id_), substitutes (vNULL), is_oper_list (is_oper_list_) {}
vec<id_base *> substitutes;
+ bool is_oper_list;
};
template<>
@@ -2419,6 +2420,7 @@
void parse_simplify (source_location, vec<simplify *>&, predicate_id *,
expr *);
void parse_for (source_location);
+ void parse_operator_list ();
void parse_if (source_location);
void parse_predicates (source_location);
@@ -2582,8 +2584,14 @@
|| strcmp (id, "convert2") == 0)
fatal_at (id_tok, "expected '?' after conditional operator");
id_base *op = get_operator (id);
+
if (!op)
fatal_at (id_tok, "unknown operator %s", id);
+
+ user_id *uid;
+ if ((uid = dyn_cast<user_id *> (op)) != 0 && uid->is_oper_list)
+ fatal_at (id_tok, "operator-list '%s' can be used only in for", uid->id);
+
return op;
}
@@ -2900,6 +2908,20 @@
/* Parsing of the outer control structures. */
+bool
+add_substitute (user_id *op, id_base *idb, int& arity)
+{
+ if (arity == -1)
+ arity = idb->nargs;
+ else if (idb->nargs == -1)
+ ;
+ else if (idb->nargs != arity)
+ return false;
+
+ op->substitutes.safe_push (idb);
+ return true;
+}
+
/* Parse a for expression
for = '(' 'for' <subst>... <pattern> ')'
subst = <ident> '(' <ident>... ')' */
@@ -2938,15 +2960,16 @@
if (*idb == CONVERT0 || *idb == CONVERT1 || *idb == CONVERT2)
fatal_at (token, "conditional operators cannot be used inside for");
- if (arity == -1)
- arity = idb->nargs;
- else if (idb->nargs == -1)
- ;
- else if (idb->nargs != arity)
- fatal_at (token, "operator '%s' with arity %d does not match "
- "others with arity %d", oper, idb->nargs, arity);
+ vec<id_base *> substitutes = vNULL;
+ if (idb->kind == id_base::USER)
+ substitutes = (as_a<user_id *> (idb))->substitutes;
+ else
+ substitutes.safe_push (idb);
- op->substitutes.safe_push (idb);
+ for (unsigned si = 0; si < substitutes.length (); ++si)
+ if (!add_substitute (op, substitutes[si], arity))
+ fatal_at (token, "operator '%s' with arity %d does not match "
+ "others with arity %d", oper, idb->nargs, arity);
}
op->nargs = arity;
token = expect (CPP_CLOSE_PAREN);
@@ -2997,6 +3020,55 @@
operators->remove_elt (user_ids[i]);
}
+void
+flatten_substitutes (vec<id_base *>& ids, vec<id_base *>& substitutes)
+{
+ user_id *op;
+
+ for (unsigned i = 0; i < ids.length (); ++i)
+ if ((op = dyn_cast<user_id *> (ids[i])) != 0)
+ flatten_substitutes (op->substitutes, substitutes);
+ else
+ substitutes.safe_push (ids[i]);
+}
+
+void
+parser::parse_operator_list ()
+{
+ const char *id = get_ident ();
+ user_id *op = new user_id (id, true);
+ vec<const cpp_token *> user_id_tokens = vNULL;
+
+ id_base **slot = operators->find_slot_with_hash (op, op->hashval, INSERT);
+ if (*slot)
+ fatal ("operator %s already defined", id);
+ *slot = op;
+
+ const cpp_token *token;
+ vec<id_base *> ids = vNULL;
+
+ while ((token = peek_ident ()) != 0)
+ {
+ const char *oper = get_ident ();
+ id_base *p = get_operator (oper);
+ if (p == 0)
+ fatal_at (token, "%s is not defined", oper);
+ ids.safe_push (p);
+ user_id_tokens.safe_push (token);
+ }
+
+ if (ids.length () == 0)
+ fatal_at (token, "operator list cannot be empty");
+
+ flatten_substitutes (ids, op->substitutes);
+ int arity = op->substitutes[0]->nargs;
+ for (unsigned i = 1; i < op->substitutes.length (); ++i)
+ if (op->substitutes[i]->nargs != -1 && arity != op->substitutes[i]->nargs)
+ fatal_at (user_id_tokens[i], "operator '%s' with arity %d does not match "
+ "others with arity %d", op->substitutes[i]->id, op->substitutes[i]->nargs, arity);
+}
+
+
/* Parse an outer if expression.
if = '(' 'if' '(' <c-expr> ')' <pattern> ')' */
@@ -3097,6 +3169,8 @@
fatal_at (token, "define_predicates inside if or for is not supported");
parse_predicates (token->src_loc);
}
+ else if (strcmp (id, "define_operator_list") == 0)
+ parse_operator_list ();
else
fatal_at (token, "expected %s'simplify', 'match', 'for' or 'if'",
active_ifs.length () == 0 && active_fors.length () == 0
Index: gcc/match-bitwise.pd
===================================================================
--- gcc/match-bitwise.pd (revision 216673)
+++ gcc/match-bitwise.pd (working copy)
@@ -17,6 +17,9 @@
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
+(define_operator_list bitwise_ors bit_ior bit_xor)
+(define_operator_list bitwise_ops bit_and bitwise_ors)
+
/* Try to fold (type) X op CST -> (type) (X op ((type-x) CST))
when profitable. */
/* For bitwise binary operations apply operand conversions to the
@@ -23,7 +26,7 @@
binary operation result instead of to the operands. This allows
to combine successive conversions and bitwise binary operations. */
/* We combine the above two cases by using a conditional convert. */
-(for bitop (bit_and bit_ior bit_xor)
+(for bitop (bitwise_ops)
(simplify
(bitop (convert @0) (convert? @1))
(if (((TREE_CODE (@1) == INTEGER_CST
@@ -48,7 +51,7 @@
(convert (bitop @0 (convert @1))))))
/* Simplify (A & B) OP0 (C & B) to (A OP0 C) & B. */
-(for bitop (bit_and bit_ior bit_xor)
+(for bitop (bitwise_ops)
(simplify
(bitop (bit_and:c @0 @1) (bit_and @2 @1))
(bit_and (bitop @0 @2) @1)))
@@ -59,7 +62,7 @@
(bit_ior (bit_and @0 @2) (bit_and @1 @2)))
/* Combine successive equal operations with constants. */
-(for bitop (bit_and bit_ior bit_xor)
+(for bitop (bitwise_ops)
(simplify
(bitop (bitop @0 CONSTANT_CLASS_P@1) CONSTANT_CLASS_P@2)
(bitop @0 (bitop @1 @2))))
@@ -95,7 +98,7 @@
(bit_and @0 (logical_inverted_value @0))
{ build_zero_cst (type); })
/* X | !X and X ^ !X -> 1, , if X is truth-valued. */
-(for op (bit_ior bit_xor)
+(for op (bitwise_ors)
(simplify
(op truth_valued_p@0 (logical_inverted_value @0))
{ build_one_cst (type); }))
@@ -110,7 +113,7 @@
(bit_and:c @0 (bit_not @0))
{ build_zero_cst (type); })
/* X | ~X -> ~0, X ^ ~X -> ~0. */
-(for bitop (bit_ior bit_xor)
+(for bitop (bitwise_ors)
(simplify
(bitop:c @0 (bit_not @0))
{ build_all_ones_cst (type); }))
@@ -118,7 +121,7 @@
Also X != 1 vs. X ^ 1 vs ~X wants canonicalization for truth
values. */
#if 0 /* FIXME. truth_valued_ssa_name isn't exported either. */
-(for bitop (bit_and bit_ior bit_xor)
+(for bitop (bitwise_ops)
/* X & (X == 0) -> 0. */
/* X | (X == 0) -> 1. */
(simplify
@@ -201,7 +204,7 @@
/* Simple association cases that cancel one operand. */
/* ((a OP b) & ~a) -> (b & ~a) OP 0 */
-(for bitop (bit_and bit_ior bit_xor)
+(for bitop (bitwise_ops)
(simplify
(bit_and:c (bitop:c @0 @1) (bit_not@2 @0))
(bitop (bit_and @1 @2) { build_zero_cst (type); })))
@@ -264,7 +267,7 @@
/* Similar transform for vector permute.
??? Missing an easy way to check if a mask is a reverse
operation of another mask (most masks are not reversible). */
-(for bitop (bit_xor bit_ior bit_and)
+(for bitop (bitwise_ops)
(simplify
(bitop (vec_perm @1 @2 @0) (vec_perm @3 @4 @0))
(vec_perm (bitop @1 @3) (bitop @2 @4) @0)))
Index: gcc/match-comparison.pd
===================================================================
--- gcc/match-comparison.pd (revision 216673)
+++ gcc/match-comparison.pd (working copy)
@@ -1,5 +1,8 @@
/* From fold_binary. */
+(define_operator_list eq_ops eq ne)
+(define_operator_list cmp_ops eq_ops lt le gt ge)
+
/* On GIMPLE bool != 0 is simply the canonical way to express a
condition in COND_EXPRs and GIMPLE_CONDs.
??? Of course for assignments we still may want to strip those... */
@@ -15,7 +18,7 @@
@0)))
/* Distribute operations in equality compares. */
-(for op (eq ne)
+(for op (eq_ops)
/* -exp op CST is exp op -CST. */
(simplify
/* ??? fix fold-const to use negate_expr_p */
@@ -29,7 +32,7 @@
/* From fold_comparison, in the order of transforms in there. */
/* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 -+ C1. */
-(for cmp (lt le eq ge gt ne)
+(for cmp (cmp_ops)
(for op (plus minus)
(simplify
(cmp (op @0 INTEGER_CST@1) INTEGER_CST@2)
@@ -47,7 +50,7 @@
is undefined for the type, but performing it here badly interacts
with the transformation in fold_cond_expr_with_comparison which
attempts to synthetize ABS_EXPR. */
-(for cmp (eq ne)
+(for cmp (eq_ops)
(simplify
(cmp (minus @0 @1) integer_zerop)
(cmp @0 @1)))
@@ -65,7 +68,7 @@
#endif
/* Simplify X * C1 CMP 0 to X CMP 0 if C1 is not zero. */
-(for op (lt le eq ne ge gt)
+(for op (cmp_ops)
(simplify
(op (mult @0 INTEGER_CST@1) integer_zerop@2)
/* In fold-const.c we have this and the following pattern
@@ -131,13 +134,13 @@
#endif
/* Fold ~X op ~Y as Y op X. */
-(for cmp (lt le eq ge gt ne)
+(for cmp (cmp_ops)
(simplify
(cmp (bit_not @0) (bit_not @1))
(cmp @1 @0)))
/* Fold ~X op C as X op' ~C, where op' is the swapped comparison. */
-(for cmp (lt le eq ge gt ne)
+(for cmp (cmp_ops)
(simplify
(cmp (bit_not @0) @1)
/* ??? (for cst in INTEGER_CST VECTOR_CST) is not supported yet. */
