Lines Matching defs:res_op
121 /* RES_OP is the result of a simplification. If it is conditional,
129 maybe_resimplify_conditional_op (gimple_seq *seq, gimple_match_op *res_op,
132 if (!res_op->cond.cond)
135 if (!res_op->cond.else_value
136 && res_op->code.is_tree_code ())
142 if (gimple_simplified_result_is_gimple_val (res_op))
144 res_op->cond.cond = NULL_TREE;
149 bool honor_trapv = (INTEGRAL_TYPE_P (res_op->type)
150 && TYPE_OVERFLOW_TRAPS (res_op->type));
151 tree_code op_code = (tree_code) res_op->code;
158 op_could_trap = generic_expr_could_trap_p (res_op->ops[0]);
160 op_could_trap = operation_could_trap_p ((tree_code) res_op->code,
161 FLOAT_TYPE_P (res_op->type),
163 res_op->op_or_null (1));
167 res_op->cond.cond = NULL_TREE;
176 if (res_op->cond.else_value
177 && VECTOR_TYPE_P (res_op->type)
178 && gimple_simplified_result_is_gimple_val (res_op))
180 new_op.set_op (VEC_COND_EXPR, res_op->type,
181 res_op->cond.cond, res_op->ops[0],
182 res_op->cond.else_value);
183 *res_op = new_op;
184 return gimple_resimplify3 (seq, res_op, valueize);
189 RES_OP already described. */
190 if (convert_conditional_op (res_op, &new_op))
191 *res_op = new_op;
199 RES_OP with a simplified and/or canonicalized result and
203 gimple_resimplify1 (gimple_seq *seq, gimple_match_op *res_op,
206 if (constant_for_folding (res_op->ops[0]))
209 if (res_op->code.is_tree_code ())
211 auto code = tree_code (res_op->code);
214 tem = const_unop (code, res_op->type, res_op->ops[0]);
217 tem = fold_const_call (combined_fn (res_op->code), res_op->type,
218 res_op->ops[0]);
224 res_op->set_value (tem);
225 maybe_resimplify_conditional_op (seq, res_op, valueize);
245 gimple_match_op res_op2 (*res_op);
247 res_op->code, res_op->type, res_op->ops[0]))
250 *res_op = res_op2;
255 if (maybe_resimplify_conditional_op (seq, res_op, valueize))
264 RES_OP with a simplified and/or canonicalized result and
268 gimple_resimplify2 (gimple_seq *seq, gimple_match_op *res_op,
271 if (constant_for_folding (res_op->ops[0])
272 && constant_for_folding (res_op->ops[1]))
275 if (res_op->code.is_tree_code ())
277 auto code = tree_code (res_op->code);
280 tem = const_binop (code, res_op->type,
281 res_op->ops[0], res_op->ops[1]);
284 tem = fold_const_call (combined_fn (res_op->code), res_op->type,
285 res_op->ops[0], res_op->ops[1]);
291 res_op->set_value (tem);
292 maybe_resimplify_conditional_op (seq, res_op, valueize);
300 = (res_op->code.is_tree_code ()
301 && TREE_CODE_CLASS (tree_code (res_op->code)) == tcc_comparison);
302 if ((is_comparison || commutative_binary_op_p (res_op->code, res_op->type))
303 && tree_swap_operands_p (res_op->ops[0], res_op->ops[1]))
305 std::swap (res_op->ops[0], res_op->ops[1]);
307 res_op->code = swap_tree_comparison (tree_code (res_op->code));
322 gimple_match_op res_op2 (*res_op);
324 res_op->code, res_op->type,
325 res_op->ops[0], res_op->ops[1]))
328 *res_op = res_op2;
333 if (maybe_resimplify_conditional_op (seq, res_op, valueize))
342 RES_OP with a simplified and/or canonicalized result and
346 gimple_resimplify3 (gimple_seq *seq, gimple_match_op *res_op,
349 if (constant_for_folding (res_op->ops[0])
350 && constant_for_folding (res_op->ops[1])
351 && constant_for_folding (res_op->ops[2]))
354 if (res_op->code.is_tree_code ())
356 auto code = tree_code (res_op->code);
359 tem = fold_ternary/*_to_constant*/ (code, res_op->type,
360 res_op->ops[0], res_op->ops[1],
361 res_op->ops[2]);
364 tem = fold_const_call (combined_fn (res_op->code), res_op->type,
365 res_op->ops[0], res_op->ops[1], res_op->ops[2]);
371 res_op->set_value (tem);
372 maybe_resimplify_conditional_op (seq, res_op, valueize);
379 int argno = first_commutative_argument (res_op->code, res_op->type);
381 && tree_swap_operands_p (res_op->ops[argno], res_op->ops[argno + 1]))
383 std::swap (res_op->ops[argno], res_op->ops[argno + 1]);
398 gimple_match_op res_op2 (*res_op);
400 res_op->code, res_op->type,
401 res_op->ops[0], res_op->ops[1], res_op->ops[2]))
404 *res_op = res_op2;
409 if (maybe_resimplify_conditional_op (seq, res_op, valueize))
418 RES_OP with a simplified and/or canonicalized result and
422 gimple_resimplify4 (gimple_seq *seq, gimple_match_op *res_op,
429 int argno = first_commutative_argument (res_op->code, res_op->type);
431 && tree_swap_operands_p (res_op->ops[argno], res_op->ops[argno + 1]))
433 std::swap (res_op->ops[argno], res_op->ops[argno + 1]);
448 gimple_match_op res_op2 (*res_op);
450 res_op->code, res_op->type,
451 res_op->ops[0], res_op->ops[1], res_op->ops[2],
452 res_op->ops[3]))
455 *res_op = res_op2;
460 if (maybe_resimplify_conditional_op (seq, res_op, valueize))
469 RES_OP with a simplified and/or canonicalized result and
473 gimple_resimplify5 (gimple_seq *seq, gimple_match_op *res_op,
480 int argno = first_commutative_argument (res_op->code, res_op->type);
482 && tree_swap_operands_p (res_op->ops[argno], res_op->ops[argno + 1]))
484 std::swap (res_op->ops[argno], res_op->ops[argno + 1]);
488 gimple_match_op res_op2 (*res_op);
490 res_op->code, res_op->type,
491 res_op->ops[0], res_op->ops[1], res_op->ops[2],
492 res_op->ops[3], res_op->ops[4]))
494 *res_op = res_op2;
498 if (maybe_resimplify_conditional_op (seq, res_op, valueize))
528 RES_OP should be single-rhs,
529 build a GENERIC tree for that expression and update RES_OP accordingly. */
532 maybe_build_generic_op (gimple_match_op *res_op)
534 tree_code code = (tree_code) res_op->code;
541 val = build1 (code, res_op->type, res_op->ops[0]);
542 res_op->set_value (val);
545 val = build3 (code, res_op->type, res_op->ops[0], res_op->ops[1],
546 res_op->ops[2]);
547 REF_REVERSE_STORAGE_ORDER (val) = res_op->reverse;
548 res_op->set_value (val);
556 /* Try to build RES_OP, which is known to be a call to FN. Return null
560 build_call_internal (internal_fn fn, gimple_match_op *res_op)
564 tree_pair types = direct_internal_fn_types (fn, res_op->type,
565 res_op->ops);
569 return gimple_build_call_internal (fn, res_op->num_ops,
570 res_op->op_or_null (0),
571 res_op->op_or_null (1),
572 res_op->op_or_null (2),
573 res_op->op_or_null (3),
574 res_op->op_or_null (4));
577 /* Push the exploded expression described by RES_OP as a statement to
583 maybe_push_res_to_seq (gimple_match_op *res_op, gimple_seq *seq, tree res)
585 tree *ops = res_op->ops;
586 unsigned num_ops = res_op->num_ops;
591 if (res_op->cond.cond)
594 if (res_op->code.is_tree_code ())
597 && gimple_simplified_result_is_gimple_val (res_op))
601 tree tem = mprts_hook (res_op);
623 if (res_op->code.is_tree_code ())
625 auto code = tree_code (res_op->code);
629 res = make_ssa_name (res_op->type);
631 res = create_tmp_reg (res_op->type);
633 maybe_build_generic_op (res_op);
635 res_op->op_or_null (0),
636 res_op->op_or_null (1),
637 res_op->op_or_null (2));
644 auto fn = combined_fn (res_op->code);
650 new_stmt = build_call_internal (ifn, res_op);
666 res_op->op_or_null (0),
667 res_op->op_or_null (1),
668 res_op->op_or_null (2),
669 res_op->op_or_null (3),
670 res_op->op_or_null (4));
675 res = make_ssa_name (res_op->type);
677 res = create_tmp_reg (res_op->type);
710 gimple_match_op res_op;
711 if (!gimple_simplify (&res_op, seq, valueize, code, type, op0))
713 return maybe_push_res_to_seq (&res_op, seq);
742 gimple_match_op res_op;
743 if (!gimple_simplify (&res_op, seq, valueize, code, type, op0, op1))
745 return maybe_push_res_to_seq (&res_op, seq);
770 gimple_match_op res_op;
771 if (!gimple_simplify (&res_op, seq, valueize, code, type, op0, op1, op2))
773 return maybe_push_res_to_seq (&res_op, seq);
790 gimple_match_op res_op;
791 if (!gimple_simplify (&res_op, seq, valueize, fn, type, arg0))
793 return maybe_push_res_to_seq (&res_op, seq);
811 gimple_match_op res_op;
812 if (!gimple_simplify (&res_op, seq, valueize, fn, type, arg0, arg1))
814 return maybe_push_res_to_seq (&res_op, seq);
833 gimple_match_op res_op;
834 if (!gimple_simplify (&res_op, seq, valueize, fn, type, arg0, arg1, arg2))
836 return maybe_push_res_to_seq (&res_op, seq);
857 /* If RES_OP is a call to a conditional internal function, try simplifying
859 a new conditional operation. For example, if RES_OP is:
867 RES_OP unchanged (and so suitable for other simplifications). When
871 RES_OP is known to be a call to IFN. */
874 try_conditional_simplification (internal_fn ifn, gimple_match_op *res_op,
889 unsigned int num_ops = res_op->num_ops;
890 gimple_match_op cond_op (gimple_match_cond (res_op->ops[0],
891 res_op->ops[num_ops - 1]),
892 op, res_op->type, num_ops - 2);
894 memcpy (cond_op.ops, res_op->ops + 1, (num_ops - 1) * sizeof *cond_op.ops);
912 *res_op = cond_op;
913 maybe_resimplify_conditional_op (seq, res_op, valueize);
918 describe STMT in RES_OP, returning true on success. Before recording
928 gimple_extract (gimple *stmt, gimple_match_op *res_op,
949 res_op->set_op (code, type, valueize_op (op0));
959 res_op->set_op (code, type, op0,
968 res_op->set_op (TREE_CODE (op0), type, valueize_op (op0));
975 res_op->set_op (code, type, valueize_op (rhs1));
982 res_op->set_op (code, type, rhs1, rhs2);
994 res_op->set_op (code, type, rhs1, rhs2, rhs3);
1032 res_op->set_op (cfn, TREE_TYPE (gimple_call_lhs (stmt)), num_args);
1034 res_op->ops[i] = valueize_op (gimple_call_arg (stmt, i));
1043 res_op->set_op (gimple_cond_code (stmt), boolean_type_node, lhs, rhs);
1054 /* Try to describe STMT in RES_OP, returning true on success.
1060 gimple_extract_op (gimple *stmt, gimple_match_op *res_op)
1063 return gimple_extract (stmt, res_op, nop, nop);
1070 gimple_simplify (gimple *stmt, gimple_match_op *res_op, gimple_seq *seq,
1085 gimple_match_op res_op2 (res_op->cond, TREE_CODE (op),
1109 if (!gimple_extract (stmt, res_op, valueize_op, valueize_condition))
1112 if (res_op->code.is_internal_fn ())
1114 internal_fn ifn = internal_fn (res_op->code);
1115 if (try_conditional_simplification (ifn, res_op, seq, valueize))
1119 if (!res_op->reverse
1120 && res_op->num_ops
1121 && res_op->resimplify (seq, valueize))
Indexes created Sat Jul 18 00:24:37 UTC 2026