tree
gimple_simplify (enum built_in_function fn, tree type,
tree arg0, tree arg1, tree arg2,
gimple_seq *seq, tree (*valueize)(tree))
{
if (constant_for_folding (arg0)
&& constant_for_folding (arg1)
&& constant_for_folding (arg2))
{
tree decl = builtin_decl_implicit (fn);
if (decl)
{
tree args[3];
args[0] = arg0;
args[1] = arg1;
args[2] = arg2;
tree res = fold_builtin_n (UNKNOWN_LOCATION, decl, args, 3, false);
if (res)
{
/* fold_builtin_n wraps the result inside a NOP_EXPR. */
STRIP_NOPS (res);
res = fold_convert (type, res);
if (CONSTANT_CLASS_P (res))
return res;
}
}
}
code_helper rcode;
tree ops[3] = {};
if (!gimple_simplify (&rcode, ops, seq, valueize,
fn, type, arg0, arg1, arg2))
return NULL_TREE;
return maybe_push_res_to_seq (rcode, type, ops, seq);
}
tree
gimple_simplify (enum tree_code code, tree type,
tree op0, tree op1,
gimple_seq *seq, tree (*valueize)(tree))
{
if (constant_for_folding (op0) && constant_for_folding (op1))
{
tree res = const_binop (code, type, op0, op1);
if (res != NULL_TREE
&& CONSTANT_CLASS_P (res))
return res;
}
/* Canonicalize operand order both for matching and fallback stmt
generation. */
if ((commutative_tree_code (code)
|| TREE_CODE_CLASS (code) == tcc_comparison)
&& tree_swap_operands_p (op0, op1, false))
{
tree tem = op0;
op0 = op1;
op1 = tem;
if (TREE_CODE_CLASS (code) == tcc_comparison)
code = swap_tree_comparison (code);
}
code_helper rcode;
tree ops[3] = {};
if (!gimple_simplify (&rcode, ops, seq, valueize,
code, type, op0, op1))
return NULL_TREE;
return maybe_push_res_to_seq (rcode, type, ops, seq);
}
tree
gimple_simplify (enum tree_code code, tree type,
tree op0, tree op1, tree op2,
gimple_seq *seq, tree (*valueize)(tree))
{
if (constant_for_folding (op0) && constant_for_folding (op1)
&& constant_for_folding (op2))
{
tree res = fold_ternary/*_to_constant */ (code, type, op0, op1, op2);
if (res != NULL_TREE
&& CONSTANT_CLASS_P (res))
return res;
}
/* Canonicalize operand order both for matching and fallback stmt
generation. */
if (commutative_ternary_tree_code (code)
&& tree_swap_operands_p (op0, op1, false))
{
tree tem = op0;
op0 = op1;
op1 = tem;
}
code_helper rcode;
tree ops[3] = {};
if (!gimple_simplify (&rcode, ops, seq, valueize,
code, type, op0, op1, op2))
return NULL_TREE;
return maybe_push_res_to_seq (rcode, type, ops, seq);
}
bool
gimple_resimplify3 (gimple_seq *seq,
code_helper *res_code, tree type, tree *res_ops,
tree (*valueize)(tree))
{
if (constant_for_folding (res_ops[0]) && constant_for_folding (res_ops[1])
&& constant_for_folding (res_ops[2]))
{
tree tem = NULL_TREE;
if (res_code->is_tree_code ())
tem = fold_ternary/*_to_constant*/ (*res_code, type, res_ops[0],
res_ops[1], res_ops[2]);
else
tem = fold_const_call (combined_fn (*res_code), type,
res_ops[0], res_ops[1], res_ops[2]);
if (tem != NULL_TREE
&& CONSTANT_CLASS_P (tem))
{
if (TREE_OVERFLOW_P (tem))
tem = drop_tree_overflow (tem);
res_ops[0] = tem;
res_ops[1] = NULL_TREE;
res_ops[2] = NULL_TREE;
*res_code = TREE_CODE (res_ops[0]);
return true;
}
}
/* Canonicalize operand order. */
bool canonicalized = false;
if (res_code->is_tree_code ()
&& commutative_ternary_tree_code (*res_code)
&& tree_swap_operands_p (res_ops[0], res_ops[1]))
{
std::swap (res_ops[0], res_ops[1]);
canonicalized = true;
}
code_helper res_code2;
tree res_ops2[3] = {};
if (gimple_simplify (&res_code2, res_ops2, seq, valueize,
*res_code, type,
res_ops[0], res_ops[1], res_ops[2]))
{
*res_code = res_code2;
res_ops[0] = res_ops2[0];
res_ops[1] = res_ops2[1];
res_ops[2] = res_ops2[2];
return true;
}
return canonicalized;
}
static bool
gimple_resimplify1 (gimple_seq *seq,
code_helper *res_code, tree type, tree *res_ops,
tree (*valueize)(tree))
{
if (constant_for_folding (res_ops[0]))
{
tree tem = NULL_TREE;
if (res_code->is_tree_code ())
tem = const_unop (*res_code, type, res_ops[0]);
else
{
tree decl = builtin_decl_implicit (*res_code);
if (decl)
{
tem = fold_builtin_n (UNKNOWN_LOCATION, decl, res_ops, 1, false);
if (tem)
{
/* fold_builtin_n wraps the result inside a NOP_EXPR. */
STRIP_NOPS (tem);
tem = fold_convert (type, tem);
}
}
}
if (tem != NULL_TREE
&& CONSTANT_CLASS_P (tem))
{
res_ops[0] = tem;
res_ops[1] = NULL_TREE;
res_ops[2] = NULL_TREE;
*res_code = TREE_CODE (res_ops[0]);
return true;
}
}
code_helper res_code2;
tree res_ops2[3] = {};
if (gimple_simplify (&res_code2, res_ops2, seq, valueize,
*res_code, type, res_ops[0]))
{
*res_code = res_code2;
res_ops[0] = res_ops2[0];
res_ops[1] = res_ops2[1];
res_ops[2] = res_ops2[2];
return true;
}
return false;
}
tree
gimple_simplify (enum built_in_function fn, tree type,
tree arg0,
gimple_seq *seq, tree (*valueize)(tree))
{
if (constant_for_folding (arg0))
{
tree res = fold_const_call (as_combined_fn (fn), type, arg0);
if (res && CONSTANT_CLASS_P (res))
return res;
}
code_helper rcode;
tree ops[3] = {};
if (!gimple_simplify (&rcode, ops, seq, valueize,
as_combined_fn (fn), type, arg0))
return NULL_TREE;
return maybe_push_res_to_seq (rcode, type, ops, seq);
}
tree
gimple_simplify (enum tree_code code, tree type,
tree op0,
gimple_seq *seq, tree (*valueize)(tree))
{
if (constant_for_folding (op0))
{
tree res = const_unop (code, type, op0);
if (res != NULL_TREE
&& CONSTANT_CLASS_P (res))
return res;
}
code_helper rcode;
tree ops[3] = {};
if (!gimple_simplify (&rcode, ops, seq, valueize,
code, type, op0))
return NULL_TREE;
return maybe_push_res_to_seq (rcode, type, ops, seq);
}
bool
gimple_resimplify1 (gimple_seq *seq,
code_helper *res_code, tree type, tree *res_ops,
tree (*valueize)(tree))
{
if (constant_for_folding (res_ops[0]))
{
tree tem = NULL_TREE;
if (res_code->is_tree_code ())
tem = const_unop (*res_code, type, res_ops[0]);
else
tem = fold_const_call (combined_fn (*res_code), type, res_ops[0]);
if (tem != NULL_TREE
&& CONSTANT_CLASS_P (tem))
{
if (TREE_OVERFLOW_P (tem))
tem = drop_tree_overflow (tem);
res_ops[0] = tem;
res_ops[1] = NULL_TREE;
res_ops[2] = NULL_TREE;
*res_code = TREE_CODE (res_ops[0]);
return true;
}
}
code_helper res_code2;
tree res_ops2[3] = {};
if (gimple_simplify (&res_code2, res_ops2, seq, valueize,
*res_code, type, res_ops[0]))
{
*res_code = res_code2;
res_ops[0] = res_ops2[0];
res_ops[1] = res_ops2[1];
res_ops[2] = res_ops2[2];
return true;
}
return false;
}
static bool
gimple_resimplify3 (gimple_seq *seq,
code_helper *res_code, tree type, tree *res_ops,
tree (*valueize)(tree))
{
if (constant_for_folding (res_ops[0]) && constant_for_folding (res_ops[1])
&& constant_for_folding (res_ops[2]))
{
tree tem = NULL_TREE;
if (res_code->is_tree_code ())
tem = fold_ternary/*_to_constant*/ (*res_code, type, res_ops[0],
res_ops[1], res_ops[2]);
else
{
tree decl = builtin_decl_implicit (*res_code);
if (decl)
{
tem = fold_builtin_n (UNKNOWN_LOCATION, decl, res_ops, 3, false);
if (tem)
{
/* fold_builtin_n wraps the result inside a NOP_EXPR. */
STRIP_NOPS (tem);
tem = fold_convert (type, tem);
}
}
}
if (tem != NULL_TREE
&& CONSTANT_CLASS_P (tem))
{
res_ops[0] = tem;
res_ops[1] = NULL_TREE;
res_ops[2] = NULL_TREE;
*res_code = TREE_CODE (res_ops[0]);
return true;
}
}
/* Canonicalize operand order. */
bool canonicalized = false;
if (res_code->is_tree_code ()
&& commutative_ternary_tree_code (*res_code)
&& tree_swap_operands_p (res_ops[0], res_ops[1], false))
{
tree tem = res_ops[0];
res_ops[0] = res_ops[1];
res_ops[1] = tem;
canonicalized = true;
}
code_helper res_code2;
tree res_ops2[3] = {};
if (gimple_simplify (&res_code2, res_ops2, seq, valueize,
*res_code, type,
res_ops[0], res_ops[1], res_ops[2]))
{
*res_code = res_code2;
res_ops[0] = res_ops2[0];
res_ops[1] = res_ops2[1];
res_ops[2] = res_ops2[2];
return true;
}
return canonicalized;
}
