mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-04-05 23:31:21 +08:00
Code Issues Packages Projects Releases Wiki Activity

diagnose return statement in match.pd (with { ... } expressions

Browse Source 
The expression in (with { ... } is used like a statement expression
which means control flow that leaves it is not allowed.  The following
explicitely diagnoses 'return' and fixes up the few cases that crept
into match.pd (oops).  Any such return will prematurely end matching
the current expression.

	* genmatch.cc (parser::parse_c_expr): Diagnose 'return'.
	* match.pd: Replace 'return' statements in with expressions
	with appropriate variants.
This commit is contained in:
Richard Biener 2022-10-13 12:59:09 +02:00
parent 9f0d4adabe
commit 786e4c024f
2 changed files with 151 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
gcc/genmatch.cc
View File

@ -4447,8 +4447,11 @@ parser::parse_c_expr (cpp_ttype start)
/* If this is possibly a user-defined identifier mark it used. */
if (token->type == CPP_NAME)
{
id_base *idb = get_operator ((const char *)CPP_HASHNODE
(token->val.node.node)->ident.str);
const char *str
= (const char *)CPP_HASHNODE (token->val.node.node)->ident.str;
if (strcmp (str, "return") == 0)
fatal_at (token, "return statement not allowed in C expression");
id_base *idb = get_operator (str);
user_id *p;
if (idb && (p = dyn_cast<user_id *> (idb)) && p->is_oper_list)
record_operlist (token->src_loc, p);

295
gcc/match.pd
View File

@ -7930,131 +7930,131 @@ and,
/* Build a vector of integers from the tree mask. */
vec_perm_builder builder;
if (!tree_to_vec_perm_builder (&builder, op2))
return NULL_TREE;
/* Create a vec_perm_indices for the integer vector. */
poly_uint64 nelts = TYPE_VECTOR_SUBPARTS (type);
bool single_arg = (op0 == op1);
vec_perm_indices sel (builder, single_arg ? 1 : 2, nelts);
}
(if (sel.series_p (0, 1, 0, 1))
{ op0; }
(if (sel.series_p (0, 1, nelts, 1))
{ op1; }
(with
{
if (!single_arg)
{
if (sel.all_from_input_p (0))
op1 = op0;
else if (sel.all_from_input_p (1))
{
op0 = op1;
sel.rotate_inputs (1);
}
else if (known_ge (poly_uint64 (sel[0]), nelts))
{
std::swap (op0, op1);
sel.rotate_inputs (1);
}
}
gassign *def;
tree cop0 = op0, cop1 = op1;
if (TREE_CODE (op0) == SSA_NAME
&& (def = dyn_cast <gassign *> (SSA_NAME_DEF_STMT (op0)))
&& gimple_assign_rhs_code (def) == CONSTRUCTOR)
cop0 = gimple_assign_rhs1 (def);
if (TREE_CODE (op1) == SSA_NAME
&& (def = dyn_cast <gassign *> (SSA_NAME_DEF_STMT (op1)))
&& gimple_assign_rhs_code (def) == CONSTRUCTOR)
cop1 = gimple_assign_rhs1 (def);
tree t;
(if (tree_to_vec_perm_builder (&builder, op2))
(with
{
/* Create a vec_perm_indices for the integer vector. */
poly_uint64 nelts = TYPE_VECTOR_SUBPARTS (type);
bool single_arg = (op0 == op1);
vec_perm_indices sel (builder, single_arg ? 1 : 2, nelts);
}
(if ((TREE_CODE (cop0) == VECTOR_CST
|| TREE_CODE (cop0) == CONSTRUCTOR)
&& (TREE_CODE (cop1) == VECTOR_CST
|| TREE_CODE (cop1) == CONSTRUCTOR)
&& (t = fold_vec_perm (type, cop0, cop1, sel)))
{ t; }
(with
{
bool changed = (op0 == op1 && !single_arg);
tree ins = NULL_TREE;
unsigned at = 0;
(if (sel.series_p (0, 1, 0, 1))
{ op0; }
(if (sel.series_p (0, 1, nelts, 1))
{ op1; }
(with
{
if (!single_arg)
{
if (sel.all_from_input_p (0))
op1 = op0;
else if (sel.all_from_input_p (1))
{
op0 = op1;
sel.rotate_inputs (1);
}
else if (known_ge (poly_uint64 (sel[0]), nelts))
{
std::swap (op0, op1);
sel.rotate_inputs (1);
}
}
gassign *def;
tree cop0 = op0, cop1 = op1;
if (TREE_CODE (op0) == SSA_NAME
&& (def = dyn_cast <gassign *> (SSA_NAME_DEF_STMT (op0)))
&& gimple_assign_rhs_code (def) == CONSTRUCTOR)
cop0 = gimple_assign_rhs1 (def);
if (TREE_CODE (op1) == SSA_NAME
&& (def = dyn_cast <gassign *> (SSA_NAME_DEF_STMT (op1)))
&& gimple_assign_rhs_code (def) == CONSTRUCTOR)
cop1 = gimple_assign_rhs1 (def);
tree t;
}
(if ((TREE_CODE (cop0) == VECTOR_CST
|| TREE_CODE (cop0) == CONSTRUCTOR)
&& (TREE_CODE (cop1) == VECTOR_CST
|| TREE_CODE (cop1) == CONSTRUCTOR)
&& (t = fold_vec_perm (type, cop0, cop1, sel)))
{ t; }
(with
{
bool changed = (op0 == op1 && !single_arg);
tree ins = NULL_TREE;
unsigned at = 0;
/* See if the permutation is performing a single element
insert from a CONSTRUCTOR or constant and use a BIT_INSERT_EXPR
in that case. But only if the vector mode is supported,
otherwise this is invalid GIMPLE. */
if (op_mode != BLKmode
&& (TREE_CODE (cop0) == VECTOR_CST
|| TREE_CODE (cop0) == CONSTRUCTOR
|| TREE_CODE (cop1) == VECTOR_CST
|| TREE_CODE (cop1) == CONSTRUCTOR))
{
bool insert_first_p = sel.series_p (1, 1, nelts + 1, 1);
if (insert_first_p)
{
/* After canonicalizing the first elt to come from the
first vector we only can insert the first elt from
the first vector. */
at = 0;
if ((ins = fold_read_from_vector (cop0, sel[0])))
op0 = op1;
}
/* The above can fail for two-element vectors which always
appear to insert the first element, so try inserting
into the second lane as well. For more than two
elements that's wasted time. */
if (!insert_first_p || (!ins && maybe_eq (nelts, 2u)))
{
unsigned int encoded_nelts = sel.encoding ().encoded_nelts ();
for (at = 0; at < encoded_nelts; ++at)
if (maybe_ne (sel[at], at))
break;
if (at < encoded_nelts
&& (known_eq (at + 1, nelts)
|| sel.series_p (at + 1, 1, at + 1, 1)))
{
if (known_lt (poly_uint64 (sel[at]), nelts))
ins = fold_read_from_vector (cop0, sel[at]);
else
ins = fold_read_from_vector (cop1, sel[at] - nelts);
}
}
}
/* See if the permutation is performing a single element
insert from a CONSTRUCTOR or constant and use a BIT_INSERT_EXPR
in that case. But only if the vector mode is supported,
otherwise this is invalid GIMPLE. */
if (op_mode != BLKmode
&& (TREE_CODE (cop0) == VECTOR_CST
|| TREE_CODE (cop0) == CONSTRUCTOR
|| TREE_CODE (cop1) == VECTOR_CST
|| TREE_CODE (cop1) == CONSTRUCTOR))
{
bool insert_first_p = sel.series_p (1, 1, nelts + 1, 1);
if (insert_first_p)
{
/* After canonicalizing the first elt to come from the
first vector we only can insert the first elt from
the first vector. */
at = 0;
if ((ins = fold_read_from_vector (cop0, sel[0])))
op0 = op1;
}
/* The above can fail for two-element vectors which always
appear to insert the first element, so try inserting
into the second lane as well. For more than two
elements that's wasted time. */
if (!insert_first_p || (!ins && maybe_eq (nelts, 2u)))
{
unsigned int encoded_nelts = sel.encoding ().encoded_nelts ();
for (at = 0; at < encoded_nelts; ++at)
if (maybe_ne (sel[at], at))
break;
if (at < encoded_nelts
&& (known_eq (at + 1, nelts)
|| sel.series_p (at + 1, 1, at + 1, 1)))
{
if (known_lt (poly_uint64 (sel[at]), nelts))
ins = fold_read_from_vector (cop0, sel[at]);
else
ins = fold_read_from_vector (cop1, sel[at] - nelts);
}
}
}
/* Generate a canonical form of the selector. */
if (!ins && sel.encoding () != builder)
{
/* Some targets are deficient and fail to expand a single
argument permutation while still allowing an equivalent
2-argument version. */
tree oldop2 = op2;
if (sel.ninputs () == 2
|| can_vec_perm_const_p (result_mode, op_mode, sel, false))
op2 = vec_perm_indices_to_tree (TREE_TYPE (op2), sel);
else
{
vec_perm_indices sel2 (builder, 2, nelts);
if (can_vec_perm_const_p (result_mode, op_mode, sel2, false))
op2 = vec_perm_indices_to_tree (TREE_TYPE (op2), sel2);
else
/* Not directly supported with either encoding,
so use the preferred form. */
op2 = vec_perm_indices_to_tree (TREE_TYPE (op2), sel);
}
if (!operand_equal_p (op2, oldop2, 0))
changed = true;
}
}
(if (ins)
(bit_insert { op0; } { ins; }
{ bitsize_int (at * vector_element_bits (type)); })
(if (changed)
(vec_perm { op0; } { op1; } { op2; }))))))))))
/* Generate a canonical form of the selector. */
if (!ins && sel.encoding () != builder)
{
/* Some targets are deficient and fail to expand a single
argument permutation while still allowing an equivalent
2-argument version. */
tree oldop2 = op2;
if (sel.ninputs () == 2
|| can_vec_perm_const_p (result_mode, op_mode, sel, false))
op2 = vec_perm_indices_to_tree (TREE_TYPE (op2), sel);
else
{
vec_perm_indices sel2 (builder, 2, nelts);
if (can_vec_perm_const_p (result_mode, op_mode, sel2, false))
op2 = vec_perm_indices_to_tree (TREE_TYPE (op2), sel2);
else
/* Not directly supported with either encoding,
so use the preferred form. */
op2 = vec_perm_indices_to_tree (TREE_TYPE (op2), sel);
}
if (!operand_equal_p (op2, oldop2, 0))
changed = true;
}
}
(if (ins)
(bit_insert { op0; } { ins; }
{ bitsize_int (at * vector_element_bits (type)); })
(if (changed)
(vec_perm { op0; } { op1; } { op2; }))))))))))))
/* VEC_PERM_EXPR (v, v, mask) -> v where v contains same element. */
@ -8094,37 +8094,34 @@ and,
(simplify
(vec_perm (vec_perm@0 @1 @2 VECTOR_CST@3) @0 VECTOR_CST@4)
(with
{
if (!TYPE_VECTOR_SUBPARTS (type).is_constant ())
return NULL_TREE;
(if (TYPE_VECTOR_SUBPARTS (type).is_constant ())
(with
{
machine_mode result_mode = TYPE_MODE (type);
machine_mode op_mode = TYPE_MODE (TREE_TYPE (@1));
int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
vec_perm_builder builder0;
vec_perm_builder builder1;
vec_perm_builder builder2 (nelts, nelts, 1);
}
(if (tree_to_vec_perm_builder (&builder0, @3)
&& tree_to_vec_perm_builder (&builder1, @4))
(with
{
vec_perm_indices sel0 (builder0, 2, nelts);
vec_perm_indices sel1 (builder1, 1, nelts);
tree op0;
machine_mode result_mode = TYPE_MODE (type);
machine_mode op_mode = TYPE_MODE (TREE_TYPE (@1));
int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
vec_perm_builder builder0;
vec_perm_builder builder1;
vec_perm_builder builder2 (nelts, nelts, 1);
for (int i = 0; i < nelts; i++)
builder2.quick_push (sel0[sel1[i].to_constant ()]);
if (!tree_to_vec_perm_builder (&builder0, @3)
|| !tree_to_vec_perm_builder (&builder1, @4))
return NULL_TREE;
vec_perm_indices sel2 (builder2, 2, nelts);
vec_perm_indices sel0 (builder0, 2, nelts);
vec_perm_indices sel1 (builder1, 1, nelts);
for (int i = 0; i < nelts; i++)
builder2.quick_push (sel0[sel1[i].to_constant ()]);
vec_perm_indices sel2 (builder2, 2, nelts);
if (!can_vec_perm_const_p (result_mode, op_mode, sel2, false))
return NULL_TREE;
op0 = vec_perm_indices_to_tree (TREE_TYPE (@4), sel2);
}
(vec_perm @1 @2 { op0; })))
tree op0 = NULL_TREE;
if (can_vec_perm_const_p (result_mode, op_mode, sel2, false))
op0 = vec_perm_indices_to_tree (TREE_TYPE (@4), sel2);
}
(if (op0)
(vec_perm @1 @2 { op0; })))))))
/* Match count trailing zeroes for simplify_count_trailing_zeroes in fwprop.