Skip to content

R
riscv-gcc-1
Commit 64d3a1f0 by Richard Biener Committed by Richard Biener
Options

genmatch.c (parser::peek, [...]): Add argument to tell how many tokens to peek ahead (default 1). 

2015-07-15  Richard Biener  <rguenther@suse.de>

	* genmatch.c (parser::peek, parser::peek_ident): Add argument
	to tell how many tokens to peek ahead (default 1).
	(parser::eat_token, parser::eat_ident): Return token consumed.
	(parser::parse_result): Parse new switch statement.
	* match.pd: Use case statements where appropriate.

From-SVN: r225809
parent a16bca31
Showing with 107 additions and 39 deletions
gcc/ChangeLog
2015-07-15 Richard Biener <rguenther@suse.de>
* genmatch.c (parser::peek, parser::peek_ident): Add argument
to tell how many tokens to peek ahead (default 1).
(parser::eat_token, parser::eat_ident): Return token consumed.
(parser::parse_result): Parse new switch statement.
* match.pd: Use case statements where appropriate.
2015-07-15 Uros Bizjak <ubizjak@gmail.com>
PR rtl-optimization/58066
......
gcc/genmatch.c
......@@ -3014,13 +3014,13 @@ public:
private:
const cpp_token *next ();
const cpp_token *peek ();
const cpp_token *peek_ident (const char * = NULL);
const cpp_token *peek (unsigned = 1);
const cpp_token *peek_ident (const char * = NULL, unsigned = 1);
const cpp_token *expect (enum cpp_ttype);
void eat_token (enum cpp_ttype);
const cpp_token *eat_token (enum cpp_ttype);
const char *get_string ();
const char *get_ident ();
void eat_ident (const char *);
const cpp_token *eat_ident (const char *);
const char *get_number ();
id_base *parse_operation ();
......@@ -3078,7 +3078,7 @@ parser::next ()
/* Peek at the next non-whitespace token from R. */
const cpp_token *
parser::peek ()
parser::peek (unsigned num)
{
const cpp_token *token;
unsigned i = 0;
......@@ -3086,8 +3086,9 @@ parser::peek ()
{
token = cpp_peek_token (r, i++);
}
while (token->type == CPP_PADDING
&& token->type != CPP_EOF);
while ((token->type == CPP_PADDING
&& token->type != CPP_EOF)
|| (--num > 0));
/* If we peek at EOF this is a fatal error as it leaves the
cpp_reader in unusable state. Assume we really wanted a
token and thus this EOF is unexpected. */
......@@ -3100,9 +3101,9 @@ parser::peek ()
token is not an identifier or equal to ID if supplied). */
const cpp_token *
parser::peek_ident (const char *id)
parser::peek_ident (const char *id, unsigned num)
{
const cpp_token *token = peek ();
const cpp_token *token = peek (num);
if (token->type != CPP_NAME)
return 0;
......@@ -3131,10 +3132,10 @@ parser::expect (enum cpp_ttype tk)
/* Consume the next token from R and assert it is of type TK. */
void
const cpp_token *
parser::eat_token (enum cpp_ttype tk)
{
expect (tk);
return expect (tk);
}
/* Read the next token from R and assert it is of type CPP_STRING and
......@@ -3159,13 +3160,14 @@ parser::get_ident ()
/* Eat an identifier token with value S from R. */
void
const cpp_token *
parser::eat_ident (const char *s)
{
const cpp_token *token = peek ();
const char *t = get_ident ();
if (strcmp (s, t) != 0)
fatal_at (token, "expected '%s' got '%s'\n", s, t);
return token;
}
/* Read the next token from R and assert it is of type CPP_NUMBER and
......@@ -3557,6 +3559,58 @@ parser::parse_result (operand *result, predicate_id *matcher)
eat_token (CPP_CLOSE_PAREN);
return withe;
}
else if (peek_ident ("switch"))
{
token = eat_ident ("switch");
eat_token (CPP_OPEN_PAREN);
eat_ident ("if");
if_expr *ife = new if_expr ();
operand *res = ife;
ife->cond = parse_c_expr (CPP_OPEN_PAREN);
if (peek ()->type == CPP_OPEN_PAREN)
ife->trueexpr = parse_result (result, matcher);
else
ife->trueexpr = parse_op ();
eat_token (CPP_CLOSE_PAREN);
if (peek ()->type != CPP_OPEN_PAREN
|| !peek_ident ("if", 2))
fatal_at (token, "switch can be implemented with a single if");
while (peek ()->type != CPP_CLOSE_PAREN)
{
if (peek ()->type == CPP_OPEN_PAREN)
{
if (peek_ident ("if", 2))
{
eat_token (CPP_OPEN_PAREN);
eat_ident ("if");
ife->falseexpr = new if_expr ();
ife = as_a <if_expr *> (ife->falseexpr);
ife->cond = parse_c_expr (CPP_OPEN_PAREN);
if (peek ()->type == CPP_OPEN_PAREN)
ife->trueexpr = parse_result (result, matcher);
else
ife->trueexpr = parse_op ();
eat_token (CPP_CLOSE_PAREN);
}
else
{
/* switch default clause */
ife->falseexpr = parse_result (result, matcher);
eat_token (CPP_CLOSE_PAREN);
return res;
}
}
else
{
/* switch default clause */
ife->falseexpr = parse_op ();
eat_token (CPP_CLOSE_PAREN);
return res;
}
}
eat_token (CPP_CLOSE_PAREN);
return res;
}
else
{
operand *op = result;
......
gcc/match.pd
......@@ -1107,6 +1107,7 @@ along with GCC; see the file COPYING3. If not see
unsigned int final_prec = TYPE_PRECISION (type);
int final_unsignedp = TYPE_UNSIGNED (type);
}
(switch
/* In addition to the cases of two conversions in a row
handled below, if we are converting something to its own
type via an object of identical or wider precision, neither
......@@ -1117,7 +1118,7 @@ along with GCC; see the file COPYING3. If not see
&& (((inter_int || inter_ptr) && final_int)
|| (inter_float && final_float))
&& inter_prec >= final_prec)
(ocvt @0)
(ocvt @0))
/* Likewise, if the intermediate and initial types are either both
float or both integer, we don't need the middle conversion if the
......@@ -1131,7 +1132,7 @@ along with GCC; see the file COPYING3. If not see
&& (inter_float || inter_unsignedp == inside_unsignedp)
&& ! (final_prec != GET_MODE_PRECISION (TYPE_MODE (type))
&& TYPE_MODE (type) == TYPE_MODE (inter_type)))
(ocvt @0)
(ocvt @0))
/* If we have a sign-extension of a zero-extended value, we can
replace that by a single zero-extension. Likewise if the
......@@ -1141,7 +1142,7 @@ along with GCC; see the file COPYING3. If not see
&& ((inside_prec < inter_prec && inter_prec < final_prec
&& inside_unsignedp && !inter_unsignedp)
|| final_prec == inter_prec))
(ocvt @0)
(ocvt @0))
/* Two conversions in a row are not needed unless:
- some conversion is floating-point (overstrict for now), or
......@@ -1166,7 +1167,7 @@ along with GCC; see the file COPYING3. If not see
&& ! (final_ptr && inside_prec != inter_prec)
&& ! (final_prec != GET_MODE_PRECISION (TYPE_MODE (type))
&& TYPE_MODE (type) == TYPE_MODE (inter_type)))
(ocvt @0)
(ocvt @0))
/* A truncation to an unsigned type (a zero-extension) should be
canonicalized as bitwise and of a mask. */
......@@ -1177,7 +1178,7 @@ along with GCC; see the file COPYING3. If not see
(convert (bit_and @0 { wide_int_to_tree
(inside_type,
wi::mask (inter_prec, false,
TYPE_PRECISION (inside_type))); }))
TYPE_PRECISION (inside_type))); })))
/* If we are converting an integer to a floating-point that can
represent it exactly and back to an integer, we can skip the
......@@ -1186,7 +1187,7 @@ along with GCC; see the file COPYING3. If not see
&& inside_int && inter_float && final_int &&
(unsigned) significand_size (TYPE_MODE (inter_type))
>= inside_prec - !inside_unsignedp)
(convert @0)))))))))))
(convert @0)))))))
/* If we have a narrowing conversion to an integral type that is fed by a
BIT_AND_EXPR, we might be able to remove the BIT_AND_EXPR if it merely
......@@ -1463,13 +1464,14 @@ along with GCC; see the file COPYING3. If not see
(simplify
(cmp @0 REAL_CST@1)
/* IEEE doesn't distinguish +0 and -0 in comparisons. */
(switch
/* a CMP (-0) -> a CMP 0 */
(if (REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (@1)))
(cmp @0 { build_real (TREE_TYPE (@1), dconst0); })
(cmp @0 { build_real (TREE_TYPE (@1), dconst0); }))
/* x != NaN is always true, other ops are always false. */
(if (REAL_VALUE_ISNAN (TREE_REAL_CST (@1))
&& ! HONOR_SNANS (@1))
{ constant_boolean_node (cmp == NE_EXPR, type); }
{ constant_boolean_node (cmp == NE_EXPR, type); })
/* Fold comparisons against infinity. */
(if (REAL_VALUE_ISINF (TREE_REAL_CST (@1))
&& MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (@1))))
......@@ -1481,28 +1483,29 @@ along with GCC; see the file COPYING3. If not see
if (neg)
code = swap_tree_comparison (code);
}
(switch
/* x > +Inf is always false, if with ignore sNANs. */
(if (code == GT_EXPR
&& ! HONOR_SNANS (@0))
{ constant_boolean_node (false, type); }
{ constant_boolean_node (false, type); })
(if (code == LE_EXPR)
/* x <= +Inf is always true, if we don't case about NaNs. */
(if (! HONOR_NANS (@0))
{ constant_boolean_node (true, type); }
/* x <= +Inf is the same as x == x, i.e. isfinite(x). */
(eq @0 @0))
(eq @0 @0)))
/* x == +Inf and x >= +Inf are always equal to x > DBL_MAX. */
(if (code == EQ_EXPR || code == GE_EXPR)
(with { real_maxval (&max, neg, TYPE_MODE (TREE_TYPE (@0))); }
(if (neg)
(lt @0 { build_real (TREE_TYPE (@0), max); })
(gt @0 { build_real (TREE_TYPE (@0), max); })))
(gt @0 { build_real (TREE_TYPE (@0), max); }))))
/* x < +Inf is always equal to x <= DBL_MAX. */
(if (code == LT_EXPR)
(with { real_maxval (&max, neg, TYPE_MODE (TREE_TYPE (@0))); }
(if (neg)
(ge @0 { build_real (TREE_TYPE (@0), max); })
(le @0 { build_real (TREE_TYPE (@0), max); })))
(le @0 { build_real (TREE_TYPE (@0), max); }))))
/* x != +Inf is always equal to !(x > DBL_MAX). */
(if (code == NE_EXPR)
(with { real_maxval (&max, neg, TYPE_MODE (TREE_TYPE (@0))); }
......@@ -1514,7 +1517,7 @@ along with GCC; see the file COPYING3. If not see
(bit_xor (lt @0 { build_real (TREE_TYPE (@0), max); })
{ build_one_cst (type); })
(bit_xor (gt @0 { build_real (TREE_TYPE (@0), max); })
{ build_one_cst (type); }))))))))))))))
{ build_one_cst (type); }))))))))))
/* If this is a comparison of a real constant with a PLUS_EXPR
or a MINUS_EXPR of a real constant, we can convert it into a
......@@ -1549,21 +1552,24 @@ along with GCC; see the file COPYING3. If not see
(for sq (SQRT)
(simplify
(cmp (sq @0) REAL_CST@1)
(switch
(if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (@1)))
(switch
/* sqrt(x) < y is always false, if y is negative. */
(if (cmp == EQ_EXPR || cmp == LT_EXPR || cmp == LE_EXPR)
{ constant_boolean_node (false, type); }
{ constant_boolean_node (false, type); })
/* sqrt(x) > y is always true, if y is negative and we
don't care about NaNs, i.e. negative values of x. */
(if (cmp == NE_EXPR || !HONOR_NANS (@0))
{ constant_boolean_node (true, type); }
{ constant_boolean_node (true, type); })
/* sqrt(x) > y is the same as x >= 0, if y is negative. */
(ge @0 { build_real (TREE_TYPE (@0), dconst0); })))
(if (cmp == GT_EXPR || cmp == GE_EXPR)
(with
{
REAL_VALUE_TYPE c2;
REAL_ARITHMETIC (c2, MULT_EXPR, TREE_REAL_CST (@1), TREE_REAL_CST (@1));
REAL_ARITHMETIC (c2, MULT_EXPR,
TREE_REAL_CST (@1), TREE_REAL_CST (@1));
real_convert (&c2, TYPE_MODE (TREE_TYPE (@0)), &c2);
}
(if (REAL_VALUE_ISINF (c2))
......@@ -1572,42 +1578,42 @@ along with GCC; see the file COPYING3. If not see
(eq @0 { build_real (TREE_TYPE (@0), c2); })
{ constant_boolean_node (false, type); })
/* sqrt(x) > c is the same as x > c*c. */
(cmp @0 { build_real (TREE_TYPE (@0), c2); })))
(cmp @0 { build_real (TREE_TYPE (@0), c2); }))))
(if (cmp == LT_EXPR || cmp == LE_EXPR)
(with
{
REAL_VALUE_TYPE c2;
REAL_ARITHMETIC (c2, MULT_EXPR, TREE_REAL_CST (@1), TREE_REAL_CST (@1));
REAL_ARITHMETIC (c2, MULT_EXPR,
TREE_REAL_CST (@1), TREE_REAL_CST (@1));
real_convert (&c2, TYPE_MODE (TREE_TYPE (@0)), &c2);
}
(if (REAL_VALUE_ISINF (c2))
(switch
/* sqrt(x) < y is always true, when y is a very large
value and we don't care about NaNs or Infinities. */
(if (! HONOR_NANS (@0) && ! HONOR_INFINITIES (@0))
{ constant_boolean_node (true, type); }
{ constant_boolean_node (true, type); })
/* sqrt(x) < y is x != +Inf when y is very large and we
don't care about NaNs. */
(if (! HONOR_NANS (@0))
(ne @0 { build_real (TREE_TYPE (@0), c2); })
(ne @0 { build_real (TREE_TYPE (@0), c2); }))
/* sqrt(x) < y is x >= 0 when y is very large and we
don't care about Infinities. */
(if (! HONOR_INFINITIES (@0))
(ge @0 { build_real (TREE_TYPE (@0), dconst0); })
(ge @0 { build_real (TREE_TYPE (@0), dconst0); }))
/* sqrt(x) < y is x >= 0 && x != +Inf, when y is large. */
(if (GENERIC)
(truth_andif
(ge @0 { build_real (TREE_TYPE (@0), dconst0); })
(ne @0 { build_real (TREE_TYPE (@0), c2); }))))))
(ne @0 { build_real (TREE_TYPE (@0), c2); }))))
/* sqrt(x) < c is the same as x < c*c, if we ignore NaNs. */
(if (! REAL_VALUE_ISINF (c2)
&& ! HONOR_NANS (@0))
(if (! HONOR_NANS (@0))
(cmp @0 { build_real (TREE_TYPE (@0), c2); })
/* sqrt(x) < c is the same as x >= 0 && x < c*c. */
(if (! REAL_VALUE_ISINF (c2)
&& GENERIC)
(if (GENERIC)
(truth_andif
(ge @0 { build_real (TREE_TYPE (@0), dconst0); })
(cmp @0 { build_real (TREE_TYPE (@0), c2); })))))))))))))
(cmp @0 { build_real (TREE_TYPE (@0), c2); }))))))))))))
/* Unordered tests if either argument is a NaN. */
(simplify
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment