From 6c9ff2793c7c1875b1a2db026ea01b46cf9e4ad1 Mon Sep 17 00:00:00 2001 From: zack Date: Mon, 23 Jan 2006 15:16:19 +0000 Subject: [PATCH] r110130@banpei: zack | 2006-01-22 14:52:43 -0800 * rtl.def (match_code): Add second argument. * genpreds.c (write_extract_subexp): New function. (write_match_code): Add path argument. Use write_extract_subexp. (write_predicate_expr): Pass path to write_match_code. (mark_mode_tests): MATCH_CODE applied to a subexpression does not perform a mode test. * genrecog.c (compute_predicate_codes): MATCH_CODE applied to a subexpression does not constrain the top-level code set. * read-rtl.c (read_rtx_variadic): New function. (read_rtx_1): Use it; allow AND and IOR to be variadic. * doc/md.texi: Document new notation. * config/i386/predicates.md (cmpsi_operand_1): Fold into ... (cmpsi_operand): ... here, using new notation. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@110126 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ChangeLog | 16 ++++++++++++ gcc/config/i386/predicates.md | 21 ++++++--------- gcc/doc/md.texi | 29 ++++++++++++++++++--- gcc/genpreds.c | 60 +++++++++++++++++++++++++++++++++++-------- gcc/genrecog.c | 10 +++++++- gcc/read-rtl.c | 45 +++++++++++++++++++++++++++++++- gcc/rtl.def | 9 +++++-- 7 files changed, 159 insertions(+), 31 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 291dd51..eaaf2d8 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,5 +1,21 @@ 2006-01-22 Zack Weinberg + * rtl.def (match_code): Add second argument. + * genpreds.c (write_extract_subexp): New function. + (write_match_code): Add path argument. Use write_extract_subexp. + (write_predicate_expr): Pass path to write_match_code. + (mark_mode_tests): MATCH_CODE applied to a subexpression does + not perform a mode test. + * genrecog.c (compute_predicate_codes): MATCH_CODE applied to + a subexpression does not constrain the top-level code set. + * read-rtl.c (read_rtx_variadic): New function. + (read_rtx_1): Use it; allow AND and IOR to be variadic. + * doc/md.texi: Document new notation. + * config/i386/predicates.md (cmpsi_operand_1): Fold into ... + (cmpsi_operand): ... here, using new notation. + +2006-01-22 Zack Weinberg + * varray.c: Remove GENERATOR_FILE #ifdefs. 2006-01-22 Zack Weinberg diff --git a/gcc/config/i386/predicates.md b/gcc/config/i386/predicates.md index 2d423d4..acc01ee 100644 --- a/gcc/config/i386/predicates.md +++ b/gcc/config/i386/predicates.md @@ -931,21 +931,16 @@ ;; ??? It seems likely that this will only work because cmpsi is an ;; expander, and no actual insns use this. -(define_predicate "cmpsi_operand_1" - (match_code "and") -{ - return (GET_MODE (op) == SImode - && GET_CODE (XEXP (op, 0)) == ZERO_EXTRACT - && GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST_INT - && GET_CODE (XEXP (XEXP (op, 0), 2)) == CONST_INT - && INTVAL (XEXP (XEXP (op, 0), 1)) == 8 - && INTVAL (XEXP (XEXP (op, 0), 2)) == 8 - && GET_CODE (XEXP (op, 1)) == CONST_INT); -}) - (define_predicate "cmpsi_operand" (ior (match_operand 0 "nonimmediate_operand") - (match_operand 0 "cmpsi_operand_1"))) + (and (match_code "and") + (match_code "zero_extract" "0") + (match_code "const_int" "1") + (match_code "const_int" "01") + (match_code "const_int" "02") + (match_test "INTVAL (XEXP (XEXP (op, 0), 1)) == 8") + (match_test "INTVAL (XEXP (XEXP (op, 0), 2)) == 8") + ))) (define_predicate "compare_operator" (match_code "compare")) diff --git a/gcc/doc/md.texi b/gcc/doc/md.texi index b6dd838..df16e93 100644 --- a/gcc/doc/md.texi +++ b/gcc/doc/md.texi @@ -898,9 +898,27 @@ limitations in @command{genrecog}, you can only refer to generic predicates and predicates that have already been defined. @item MATCH_CODE -This expression has one operand, a string constant containing a -comma-separated list of RTX code names (in lower case). It evaluates -to true if @var{op} has any of the listed codes. +This expression evaluates to true if @var{op} or a specified +subexpression of @var{op} has one of a given list of RTX codes. + +The first operand of this expression is a string constant containing a +comma-separated list of RTX code names (in lower case). These are the +codes for which the @code{MATCH_CODE} will be true. + +The second operand is a string constant which indicates what +subexpression of @var{op} to examine. If it is absent or the empty +string, @var{op} itself is examined. Otherwise, the string constant +must be a sequence of digits and/or lowercase letters. Each character +indicates a subexpression to extract from the current expression; for +the first character this is @var{op}, for the second and subsequent +characters it is the result of the previous character. A digit +@var{n} extracts @samp{@w{XEXP (@var{e}, @var{n})}}; a letter @var{l} +extracts @samp{@w{XVECEXP (@var{e}, 0, @var{n})}} where @var{n} is the +alphabetic ordinal of @var{l} (0 for `a', 1 for 'b', and so on). The +@code{MATCH_CODE} then examines the RTX code of the subexpression +extracted by the complete string. It is not possible to extract +components of an @code{rtvec} that is not at position 0 within its RTX +object. @item MATCH_TEST This expression has one operand, a string constant containing a C @@ -915,7 +933,10 @@ evaluates to true if the C expression evaluates to a nonzero value. @itemx IF_THEN_ELSE The basic @samp{MATCH_} expressions can be combined using these logical operators, which have the semantics of the C operators -@samp{&&}, @samp{||}, @samp{!}, and @samp{@w{? :}} respectively. +@samp{&&}, @samp{||}, @samp{!}, and @samp{@w{? :}} respectively. As +in Common Lisp, you may give an @code{AND} or @code{IOR} expression an +arbitrary number of arguments; this has exactly the same effect as +writing a chain of two-argument @code{AND} or @code{IOR} expressions. @end table @item diff --git a/gcc/genpreds.c b/gcc/genpreds.c index 6dbe7d4..bfd681c 100644 --- a/gcc/genpreds.c +++ b/gcc/genpreds.c @@ -148,11 +148,11 @@ write_predicate_subfunction (struct pred_data *p) /* Given an RTL expression EXP, find all subexpressions which we may assume to perform mode tests. Normal MATCH_OPERAND does; - MATCH_CODE does if and only if it accepts CONST_INT or - CONST_DOUBLE; and we have to assume that MATCH_TEST does not. - These combine in almost-boolean fashion - the only exception is - that (not X) must be assumed not to perform a mode test, whether or - not X does. + MATCH_CODE does if it applies to the whole expression and accepts + CONST_INT or CONST_DOUBLE; and we have to assume that MATCH_TEST + does not. These combine in almost-boolean fashion - the only + exception is that (not X) must be assumed not to perform a mode + test, whether or not X does. The mark is the RTL /v flag, which is true for subexpressions which do *not* perform mode tests. @@ -174,8 +174,9 @@ mark_mode_tests (rtx exp) break; case MATCH_CODE: - if (!strstr (XSTR (exp, 0), "const_int") - && !strstr (XSTR (exp, 0), "const_double")) + if (XSTR (exp, 1)[0] != '\0' + || (!strstr (XSTR (exp, 0), "const_int") + && !strstr (XSTR (exp, 0), "const_double"))) NO_MODE_TEST (exp) = 1; break; @@ -305,17 +306,56 @@ add_mode_tests (struct pred_data *p) *pos = and_exp; } +/* PATH is a string describing a path from the root of an RTL + expression to an inner subexpression to be tested. Output + code which computes the subexpression from the variable + holding the root of the expression. */ +static void +write_extract_subexp (const char *path) +{ + int len = strlen (path); + int i; + + /* We first write out the operations (XEXP or XVECEXP) in reverse + order, then write "op", then the indices in forward order. */ + for (i = len - 1; i >= 0; i--) + { + if (ISLOWER (path[i])) + fputs ("XVECEXP (", stdout); + else if (ISDIGIT (path[i])) + fputs ("XEXP (", stdout); + else + { + error ("bad character in path string '%s'", path); + return; + } + } + + fputs ("op", stdout); + + for (i = 0; i < len; i++) + { + if (ISLOWER (path[i])) + printf (", 0, %d)", path[i] - 'a'); + else if (ISDIGIT (path[i])) + printf (", %d)", path[i] - '0'); + else + gcc_unreachable (); + } +} /* CODES is a list of RTX codes. Write out an expression which determines whether the operand has one of those codes. */ static void -write_match_code (const char *codes) +write_match_code (const char *path, const char *codes) { const char *code; while ((code = scan_comma_elt (&codes)) != 0) { - fputs ("GET_CODE (op) == ", stdout); + fputs ("GET_CODE (", stdout); + write_extract_subexp (path); + fputs (") == ", stdout); while (code < codes) { putchar (TOUPPER (*code)); @@ -374,7 +414,7 @@ write_predicate_expr (const char *name, rtx exp) break; case MATCH_CODE: - write_match_code (XSTR (exp, 0)); + write_match_code (XSTR (exp, 1), XSTR (exp, 0)); break; case MATCH_TEST: diff --git a/gcc/genrecog.c b/gcc/genrecog.c index cb86849..56d6598 100644 --- a/gcc/genrecog.c +++ b/gcc/genrecog.c @@ -270,7 +270,15 @@ compute_predicate_codes (rtx exp, char codes[NUM_RTX_CODE]) break; case MATCH_CODE: - /* MATCH_CODE allows a specified list of codes. */ + /* MATCH_CODE allows a specified list of codes. However, if it + does not apply to the top level of the expression, it does not + constrain the set of codes for the top level. */ + if (XSTR (exp, 1)[0] != '\0') + { + memset (codes, Y, NUM_RTX_CODE); + break; + } + memset (codes, N, NUM_RTX_CODE); { const char *next_code = XSTR (exp, 0); diff --git a/gcc/read-rtl.c b/gcc/read-rtl.c index b4b1051..5eb642ee 100644 --- a/gcc/read-rtl.c +++ b/gcc/read-rtl.c @@ -145,6 +145,7 @@ static int find_macro (struct macro_group *, const char *, FILE *); static struct mapping *read_mapping (struct macro_group *, htab_t, FILE *); static void check_code_macro (struct mapping *, FILE *); static rtx read_rtx_1 (FILE *, struct map_value **); +static rtx read_rtx_variadic (FILE *, struct map_value **, rtx); /* The mode and code macro structures. */ static struct macro_group modes, codes; @@ -1696,7 +1697,49 @@ read_rtx_1 (FILE *infile, struct map_value **mode_maps) c = read_skip_spaces (infile); if (c != ')') - fatal_expected_char (infile, ')', c); + { + /* Syntactic sugar for AND and IOR, allowing Lisp-like + arbitrary number of arguments for them. */ + if (c == '(' && (GET_CODE (return_rtx) == AND + || GET_CODE (return_rtx) == IOR)) + return read_rtx_variadic (infile, mode_maps, return_rtx); + else + fatal_expected_char (infile, ')', c); + } return return_rtx; } + +/* Mutually recursive subroutine of read_rtx which reads + (thing x1 x2 x3 ...) and produces RTL as if + (thing x1 (thing x2 (thing x3 ...))) had been written. + When called, FORM is (thing x1 x2), and the file position + is just past the leading parenthesis of x3. Only works + for THINGs which are dyadic expressions, e.g. AND, IOR. */ +static rtx +read_rtx_variadic (FILE *infile, struct map_value **mode_maps, rtx form) +{ + char c = '('; + rtx p = form, q; + + do + { + ungetc (c, infile); + + q = rtx_alloc (GET_CODE (p)); + PUT_MODE (q, GET_MODE (p)); + + XEXP (q, 0) = XEXP (p, 1); + XEXP (q, 1) = read_rtx_1 (infile, mode_maps); + + XEXP (p, 1) = q; + p = q; + c = read_skip_spaces (infile); + } + while (c == '('); + + if (c != ')') + fatal_expected_char (infile, ')', c); + + return form; +} diff --git a/gcc/rtl.def b/gcc/rtl.def index f9dd11e..8710f54 100644 --- a/gcc/rtl.def +++ b/gcc/rtl.def @@ -727,8 +727,13 @@ DEF_RTL_EXPR(MATCH_PAR_DUP, "match_par_dup", "iE", RTX_MATCH) /* Appears only in define_predicate/define_special_predicate expressions. Evaluates true only if the operand has an RTX code - from the set given by the argument (a comma-separated list). */ -DEF_RTL_EXPR(MATCH_CODE, "match_code", "s", RTX_MATCH) + from the set given by the argument (a comma-separated list). If the + second argument is present and nonempty, it is a sequence of digits + and/or letters which indicates the subexpression to test, using the + same syntax as genextract/genrecog's location strings: 0-9 for + XEXP (op, n), a-z for XVECEXP (op, 0, n); each character applies to + the result of the one before it. */ +DEF_RTL_EXPR(MATCH_CODE, "match_code", "ss", RTX_MATCH) /* Appears only in define_predicate/define_special_predicate expressions. The argument is a C expression to be injected at this -- 2.7.4