Lines Matching refs:tem
1146 tree tem = strip_float_extensions (t);
1147 if (tem != t)
1148 return negate_expr_p (tem);
1185 tree tem;
1197 tem = fold_negate_const (t, type);
1198 if (!TREE_OVERFLOW (tem)
1200 return tem;
1204 tem = fold_negate_const (t, type);
1206 if (! TREE_OVERFLOW (tem) || ! flag_trapping_math)
1207 return tem;
1234 tem = negate_expr (TREE_OPERAND (t, 1));
1236 tem, TREE_OPERAND (t, 0));
1242 tem = negate_expr (TREE_OPERAND (t, 0));
1244 tem, TREE_OPERAND (t, 1));
1266 tem = TREE_OPERAND (t, 1);
1267 if (negate_expr_p (tem))
1269 TREE_OPERAND (t, 0), negate_expr (tem));
1270 tem = TREE_OPERAND (t, 0);
1271 if (negate_expr_p (tem))
1273 negate_expr (tem), TREE_OPERAND (t, 1));
1291 tem = TREE_OPERAND (t, 1);
1292 if (negate_expr_p (tem))
1295 && (TREE_CODE (tem) != INTEGER_CST
1296 || integer_onep (tem)))
1299 TREE_OPERAND (t, 0), negate_expr (tem));
1301 tem = TREE_OPERAND (t, 0);
1302 if (negate_expr_p (tem))
1305 && (TREE_CODE (tem) != INTEGER_CST
1306 || tree_int_cst_equal (tem, TYPE_MIN_VALUE (type))))
1309 negate_expr (tem), TREE_OPERAND (t, 1));
1318 tem = strip_float_extensions (t);
1319 if (tem != t && negate_expr_p (tem))
1320 return negate_expr (tem);
1371 tree type, tem;
1379 tem = fold_negate_expr (t);
1380 if (!tem)
1381 tem = build1 (NEGATE_EXPR, TREE_TYPE (t), t);
1382 return fold_convert (type, tem);
2147 tree tem;
2169 tem = fold_convert_const (NOP_EXPR, type, arg);
2170 if (tem != NULL_TREE)
2171 return tem;
2178 tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2179 return fold_convert (type, tem);
2188 tem = fold_convert_const (FLOAT_EXPR, type, arg);
2189 if (tem != NULL_TREE)
2190 return tem;
2194 tem = fold_convert_const (NOP_EXPR, type, arg);
2195 if (tem != NULL_TREE)
2196 return tem;
2210 tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2211 return fold_convert (type, tem);
3355 tree tem;
3360 tem = fold_truth_not_expr (arg);
3361 if (!tem)
3362 tem = build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg), arg);
3364 return tem;
3616 tree tem = const_binop (RSHIFT_EXPR, fold_convert (signed_type, rhs),
3618 if (! integer_zerop (tem) && ! integer_all_onesp (tem))
3892 tree tem;
3903 tem = fold_build2 (code, type != 0 ? type : TREE_TYPE (arg0),
3905 STRIP_NOPS (tem);
3906 return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
4420 tree tem;
4439 tem = low0, low0 = low1, low1 = tem;
4440 tem = high0, high0 = high1, high1 = tem;
4638 tree tem;
4679 tem = fold_convert (arg1_type, arg1);
4680 return pedantic_non_lvalue (fold_convert (type, negate_expr (tem)));
4694 tem = fold_build1 (ABS_EXPR, TREE_TYPE (arg1), arg1);
4695 return pedantic_non_lvalue (fold_convert (type, tem));
4705 tem = fold_build1 (ABS_EXPR, TREE_TYPE (arg1), arg1);
4706 return negate_expr (fold_convert (type, tem));
4790 tem = (comp_code == LE_EXPR || comp_code == UNLE_EXPR)
4793 return pedantic_non_lvalue (fold_convert (type, tem));
4804 tem = (comp_code == GE_EXPR || comp_code == UNGE_EXPR)
4807 return pedantic_non_lvalue (fold_convert (type, tem));
4916 tree tem;
4932 && 0 != (tem = (build_range_check (type,
4939 return or_op ? invert_truthvalue (tem) : tem;
5504 tree tem = optimize_minmax_comparison (invert_tree_comparison (code, false),
5506 if (tem)
5507 return invert_truthvalue (tem);
6541 tree tem;
6545 tem = fold_single_bit_test_into_sign_test (code, arg0, arg1,
6547 if (tem)
6548 return tem;
7459 tree tem;
7506 tem = fold_build3 (COND_EXPR, type, TREE_OPERAND (arg0, 0),
7520 && TREE_CODE (tem) == COND_EXPR
7521 && TREE_CODE (TREE_OPERAND (tem, 1)) == code
7522 && TREE_CODE (TREE_OPERAND (tem, 2)) == code
7523 && ! VOID_TYPE_P (TREE_OPERAND (tem, 1))
7524 && ! VOID_TYPE_P (TREE_OPERAND (tem, 2))
7525 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))
7526 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 2), 0)))
7527 && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem))
7529 (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))))
7530 && TYPE_PRECISION (TREE_TYPE (tem)) <= BITS_PER_WORD)
7532 tem = build1 (code, type,
7535 (TREE_OPERAND (tem, 1), 0)),
7536 TREE_OPERAND (tem, 0),
7537 TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
7538 TREE_OPERAND (TREE_OPERAND (tem, 2), 0)));
7539 return tem;
7704 tem = fold_build1 (code, type, TREE_OPERAND (op0, 1));
7706 tem = build2 (COMPOUND_EXPR, TREE_TYPE (tem), op0, tem);
7707 TREE_NO_WARNING (tem) = 1;
7708 TREE_USED (tem) = 1;
7709 return tem;
7752 tem = build_int_cst_wide (type, TREE_INT_CST_LOW (and1),
7754 tem = force_fit_type (tem, 0, TREE_OVERFLOW (and1),
7757 fold_convert (type, and0), tem);
7791 tem = TREE_OPERAND (TREE_OPERAND (op0, 0), 0);
7792 if (INTEGRAL_TYPE_P (TREE_TYPE (tem))
7793 && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (tem)))
7794 return fold_build1 (BIT_NOT_EXPR, type, fold_convert (type, tem));
7797 tem = fold_convert_const (code, type, op0);
7798 return tem ? tem : NULL_TREE;
7806 tem = fold_negate_expr (arg0);
7807 if (tem)
7808 return fold_convert (type, tem);
7835 tem = fold_strip_sign_ops (arg0);
7836 if (tem)
7837 return fold_build1 (ABS_EXPR, type, fold_convert (type, tem));
7880 && (tem = fold_unary (BIT_NOT_EXPR, type,
7883 return fold_build2 (BIT_XOR_EXPR, type, tem,
7886 && (tem = fold_unary (BIT_NOT_EXPR, type,
7890 fold_convert (type, TREE_OPERAND (arg0, 0)), tem);
7903 tem = fold_truth_not_expr (arg0);
7904 if (!tem)
7906 return fold_convert (type, tem);
7919 tem = fold_build2 (TREE_CODE (arg0), itype,
7924 return fold_convert (type, tem);
7929 tem = fold_build1 (REALPART_EXPR, itype, TREE_OPERAND (arg0, 0));
7930 return fold_convert (type, tem);
7945 tem = fold_build2 (TREE_CODE (arg0), itype,
7950 return fold_convert (type, tem);
7955 tem = fold_build1 (IMAGPART_EXPR, itype, TREE_OPERAND (arg0, 0));
7956 return fold_convert (type, negate_expr (tem));
8019 tree arg0, arg1, tem;
8027 tem = fold_relational_const (code, type, arg0, arg1);
8028 if (tem != NULL_TREE)
8029 return tem;
8147 tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
8148 return omit_one_operand (type, tem, arg0);
8154 tem = fold_inf_compare (code, type, arg0, arg1);
8155 if (tem != NULL_TREE)
8156 return tem;
8169 && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
8172 && ! TREE_CONSTANT_OVERFLOW (tem))
8173 return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
8182 && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
8184 && ! TREE_CONSTANT_OVERFLOW (tem))
8186 TREE_OPERAND (arg0, 1), tem);
8197 tem = fold_mathfn_compare (fcode, code, type, arg0, arg1);
8198 if (tem != NULL_TREE)
8199 return tem;
8274 tem = fold_widened_comparison (code, type, arg0, arg1);
8275 if (tem)
8276 return tem;
8279 tem = fold_sign_changed_comparison (code, type, arg0, arg1);
8280 if (tem)
8281 return tem;
8291 tem = optimize_minmax_comparison (code, type, op0, op1);
8292 if (tem)
8293 return tem;
8459 tem = fold_div_compare (code, type, arg0, arg1);
8460 if (tem != NULL_TREE)
8461 return tem;
8476 tree rpart, ipart, tem;
8497 tem = fold_build2 (PLUS_EXPR, itype,
8500 return fold_build2 (COMPLEX_EXPR, type, tem,
8513 tree arg0, arg1, tem;
8556 tem = const_binop (code, arg0, arg1, 0);
8558 tem = fold_relational_const (code, type, arg0, arg1);
8560 tem = NULL_TREE;
8562 if (tem != NULL_TREE)
8564 if (TREE_TYPE (tem) != type)
8565 tem = fold_convert (type, tem);
8566 return tem;
8603 tem = fold_build2 (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
8611 tem = invert_truthvalue (tem);
8613 return fold_convert (type, tem);
8631 tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
8634 if (tem != NULL_TREE)
8635 return tem;
8640 tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
8643 if (tem != NULL_TREE)
8644 return tem;
8674 tree tem = fold_plusminus_mult_expr (code, type, arg0, arg1);
8675 if (tem)
8676 return tem;
8745 tem = try_move_mult_to_index (PLUS_EXPR, arg0, arg1);
8746 if (tem)
8747 return fold_convert (type, tem);
8751 tem = try_move_mult_to_index (PLUS_EXPR, arg1, arg0);
8752 if (tem)
8753 return fold_convert (type, tem);
8770 tem = fold_negate_const (arg1, type);
8774 fold_convert (type, tem));
8780 && (tem = distribute_real_division (code, type, arg0, arg1)))
8781 return tem;
9052 tree tem = fold_build1 (BIT_NOT_EXPR, type, mask0);
9054 if (operand_equal_p (tem, mask1, 0))
9056 tem = fold_build2 (BIT_XOR_EXPR, type,
9058 return fold_build2 (MINUS_EXPR, type, tem, mask1);
9130 tem = try_move_mult_to_index (MINUS_EXPR, arg0, arg1);
9131 if (tem)
9132 return fold_convert (type, tem);
9138 && (tem = distribute_real_division (code, type, arg0, arg1)))
9139 return tem;
9147 tree tem = fold_plusminus_mult_expr (code, type, arg0, arg1);
9148 if (tem)
9149 return tem;
9187 && 0 != (tem = extract_muldiv (op0,
9197 return fold_convert (type, tem);
9234 tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
9236 if (tem)
9237 return fold_build2 (RDIV_EXPR, type, tem,
9244 tree tem = fold_strip_sign_ops (arg0);
9245 if (tem != NULL_TREE)
9247 tem = fold_convert (type, tem);
9248 return fold_build2 (MULT_EXPR, type, tem, tem);
9649 tem = fold_convert (type, TREE_OPERAND (arg0, 0));
9651 fold_build1 (BIT_NOT_EXPR, type, tem),
9659 tem = fold_convert (type, TREE_OPERAND (arg0, 1));
9661 fold_build1 (BIT_NOT_EXPR, type, tem),
9668 tem = fold_convert (type, TREE_OPERAND (arg1, 1));
9671 fold_build1 (BIT_NOT_EXPR, type, tem));
9678 tem = fold_convert (type, TREE_OPERAND (arg1, 0));
9680 fold_build1 (BIT_NOT_EXPR, type, tem),
9741 tem = TREE_OPERAND (arg0, 0);
9743 fold_build2 (BIT_AND_EXPR, TREE_TYPE (tem), tem,
9744 build_int_cst (TREE_TYPE (tem), 1)),
9745 build_int_cst (TREE_TYPE (tem), 0));
9751 tem = TREE_OPERAND (arg0, 0);
9753 fold_build2 (BIT_AND_EXPR, TREE_TYPE (tem), tem,
9754 build_int_cst (TREE_TYPE (tem), 1)),
9755 build_int_cst (TREE_TYPE (tem), 0));
9762 tem = fold_convert (type, TREE_OPERAND (arg0, 0));
9764 fold_build1 (BIT_NOT_EXPR, type, tem),
9772 tem = fold_convert (type, TREE_OPERAND (arg0, 1));
9774 fold_build1 (BIT_NOT_EXPR, type, tem),
9781 tem = fold_convert (type, TREE_OPERAND (arg1, 1));
9784 fold_build1 (BIT_NOT_EXPR, type, tem));
9791 tem = fold_convert (type, TREE_OPERAND (arg1, 0));
9793 fold_build1 (BIT_NOT_EXPR, type, tem),
9893 && 0 != (tem = const_binop (code, build_real (type, dconst1),
9895 return fold_build2 (MULT_EXPR, type, arg0, tem);
9903 tem = build_real (type, r);
9905 fold_convert (type, arg0), tem);
9930 tree tem = const_binop (RDIV_EXPR, arg0,
9932 if (tem)
9933 return fold_build2 (RDIV_EXPR, type, tem,
10154 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
10161 return fold_convert (type, tem);
10241 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
10248 return fold_convert (type, tem);
10332 tree tem = build_int_cst (NULL_TREE,
10334 tem = fold_convert (TREE_TYPE (arg1), tem);
10335 tem = const_binop (MINUS_EXPR, tem, arg1, 0);
10336 return fold_build2 (RROTATE_EXPR, type, arg0, tem);
10373 tem = fold_minmax (MIN_EXPR, type, arg0, arg1);
10374 if (tem)
10375 return tem;
10385 tem = fold_minmax (MAX_EXPR, type, arg0, arg1);
10386 if (tem)
10387 return tem;
10430 tem = fold_to_nonsharp_ineq_using_bound (arg0, arg1);
10431 if (tem && !operand_equal_p (tem, arg0, 0))
10432 return fold_build2 (code, type, tem, arg1);
10434 tem = fold_to_nonsharp_ineq_using_bound (arg1, arg0);
10435 if (tem && !operand_equal_p (tem, arg1, 0))
10436 return fold_build2 (code, type, arg0, tem);
10487 if (0 != (tem = fold_range_test (code, type, op0, op1)))
10488 return tem;
10494 && 0 != (tem = fold_truthop (code, type,
10496 return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
10498 if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
10499 return tem;
10547 tem = fold_build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg0), arg0);
10549 tem = invert_truthvalue (arg0);
10550 return non_lvalue (fold_convert (type, tem));
10570 tem = fold_comparison (code, type, op0, op1);
10571 if (tem != NULL_TREE)
10572 return tem;
10652 && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
10656 && ! TREE_CONSTANT_OVERFLOW (tem))
10657 return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
10662 && 0 != (tem = negate_expr (arg1))
10663 && TREE_CODE (tem) == INTEGER_CST
10664 && ! TREE_CONSTANT_OVERFLOW (tem))
10665 return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
10692 tree tem = fold_build2 (RSHIFT_EXPR, TREE_TYPE (arg00),
10694 tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0), tem,
10697 fold_convert (TREE_TYPE (arg1), tem), arg1);
10702 tree tem = fold_build2 (RSHIFT_EXPR, TREE_TYPE (arg01),
10704 tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0), tem,
10707 fold_convert (TREE_TYPE (arg1), tem), arg1);
10758 tem = fold_build2 (LSHIFT_EXPR, itype, arg01, arg001);
10759 tem = fold_build2 (BIT_AND_EXPR, itype, arg000, tem);
10760 return fold_build2 (code, type, tem, arg1);
10798 tem = fold_single_bit_test_into_sign_test (code, arg0, arg1, type);
10799 if (tem)
10800 return tem;
10926 tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
10930 type, tem, arg1);
10957 tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg000),
10960 tem, build_int_cst (TREE_TYPE (tem), 0));
10975 tem = fold_comparison (code, type, op0, op1);
10976 if (tem != NULL_TREE)
10977 return tem;
11296 && (0 != (tem = negate_expr (arg1)))
11297 && TREE_CODE (tem) == INTEGER_CST
11298 && ! TREE_CONSTANT_OVERFLOW (tem))
11301 TREE_OPERAND (arg0, 0), tem),
11431 tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
11433 return pedantic_non_lvalue (tem);
11490 tree tem;
11539 tem = integer_zerop (arg0) ? op2 : op1;
11546 && (! VOID_TYPE_P (TREE_TYPE (tem))
11548 return pedantic_non_lvalue (tem);
11565 tem = fold_cond_expr_with_comparison (type, arg0, op1, op2);
11566 if (tem)
11567 return tem;
11576 tem = fold_truth_not_expr (arg0);
11577 if (tem && COMPARISON_CLASS_P (tem))
11579 tem = fold_cond_expr_with_comparison (type, tem, op2, op1);
11580 if (tem)
11581 return tem;
11593 tem = fold_truth_not_expr (arg0);
11594 if (tem)
11595 return fold_build3 (code, type, tem, op2, op1);
11620 && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
11628 if (TYPE_PRECISION (TREE_TYPE (tem))
11630 && TYPE_PRECISION (TREE_TYPE (tem))
11638 inner_width = TYPE_PRECISION (TREE_TYPE (tem));
11668 tem_type = lang_hooks.types.signed_type (TREE_TYPE (tem));
11669 tem = fold_convert (tem_type, tem);
11674 tem_type = lang_hooks.types.unsigned_type (TREE_TYPE (tem));
11675 tem = fold_convert (tem_type, tem);
11678 tem = NULL;
11681 if (tem)
11684 TREE_TYPE (tem), tem,
11685 fold_convert (TREE_TYPE (tem),
11696 tree tem = TREE_OPERAND (arg0, 0);
11697 STRIP_NOPS (tem);
11698 if (TREE_CODE (tem) == RSHIFT_EXPR
11699 && TREE_CODE (TREE_OPERAND (tem, 1)) == INTEGER_CST
11701 TREE_INT_CST_LOW (TREE_OPERAND (tem, 1)))
11703 TREE_OPERAND (tem, 0), arg1);
11734 tem = fold_truth_not_expr (arg0);
11735 if (tem)
11737 fold_convert (type, tem),
11747 tem = fold_truth_not_expr (arg0);
11748 if (tem)
11750 fold_convert (type, tem),
11822 tree tem;
11837 tem = fold_unary (code, type, op0);
11838 return tem ? tem : expr;
11842 tem = fold_binary (code, type, op0, op1);
11843 return tem ? tem : expr;
11848 tem = fold_ternary (code, type, op0, op1, op2);
11849 return tem ? tem : expr;
12080 tree tem;
12093 tem = fold_unary (code, type, op0);
12094 if (!tem)
12095 tem = build1_stat (code, type, op0 PASS_MEM_STAT);
12104 fold_check_failed (op0, tem);
12106 return tem;
12118 tree tem;
12139 tem = fold_binary (code, type, op0, op1);
12140 if (!tem)
12141 tem = build2_stat (code, type, op0, op1 PASS_MEM_STAT);
12150 fold_check_failed (op0, tem);
12158 fold_check_failed (op1, tem);
12160 return tem;
12172 tree tem;
12200 tem = fold_ternary (code, type, op0, op1, op2);
12201 if (!tem)
12202 tem = build3_stat (code, type, op0, op1, op2 PASS_MEM_STAT);
12211 fold_check_failed (op0, tem);
12219 fold_check_failed (op1, tem);
12227 fold_check_failed (op2, tem);
12229 return tem;
12943 tree tem = fold_binary (code, type, op0, op1);
12944 return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
12958 tree tem = fold_unary (code, type, op0);
12959 return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
13205 tree tem = op0;
13207 op1 = tem;