gcc4/gcc/fold-const.c

1019 	  tree op1 = TREE_OPERAND (t, 1);
1020 	  if (TREE_INT_CST_HIGH (op1) == 0
1022 		 == TREE_INT_CST_LOW (op1))
1168 	  tree op1 = TREE_OPERAND (t, 1);
1169 	  if (TREE_INT_CST_HIGH (op1) == 0
1171 		 == TREE_INT_CST_LOW (op1))
1177 	      temp = fold_build2 (RSHIFT_EXPR, ntype, temp, op1);
1237       tree op1 = TREE_OPERAND (in, 1);
1244       else if (TREE_CODE (op1) == INTEGER_CST || TREE_CODE (op1) == REAL_CST)
1245 	*litp = op1, neg_litp_p = neg1_p, op1 = 0;
1249       else if (op1 != 0 && TREE_CONSTANT (op1))
1250 	*conp = op1, neg_conp_p = neg1_p, op1 = 0;
1254       if (op0 != 0 && op1 != 0)
1259 	var = op1, neg_var_p = neg1_p;
4604 fold_range_test (enum tree_code code, tree type, tree op0, tree op1)
4611   tree rhs = make_range (op1, &in1_p, &low1, &high1);
4647 		       type, op0, op1);
5151 optimize_minmax_comparison (enum tree_code code, tree type, tree op0, tree op1)
5155   tree comp_const = op1;
5186 	tree tem = invert_truthvalue (build2 (code, type, op0, op1));
5301   tree op0 = NULL_TREE, op1 = NULL_TREE;
5311     op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
5392 	  && (t2 = extract_muldiv (op1, c, code, wide_type)) != 0)
5409       if (TREE_CODE (op1) == INTEGER_CST
5413 	  && TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
5414 	  && TREE_INT_CST_HIGH (op1) == 0
5418 						   op1, 0)))
5432       t2 = extract_muldiv (op1, c, code, wide_type);
5438 	          && multiple_of_p (ctype, op1, c))))
5445 	tcode = PLUS_EXPR, op1 = negate_expr (op1);
5447       if (TREE_CODE (op1) != INTEGER_CST)
5453       if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
5467 	  || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
5469 	  op1 = const_binop (code, fold_convert (ctype, op1),
5472 	  if (op1 == 0
5473 	      || (TREE_OVERFLOW (op1) && ! flag_wrapv))
5490 	return fold_build2 (tcode, ctype, fold_convert (ctype, t1), op1);
5500 			    op1);
5510 	  && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
5523 			    fold_convert (ctype, op1));
5525 	       && (t1 = extract_muldiv (op1, c, code, wide_type)) != 0)
5528       else if (TREE_CODE (op1) != INTEGER_CST)
5534 	  && 0 != (t1 = const_binop (MULT_EXPR, fold_convert (ctype, op1),
5555 	  if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
5559 							   op1, c, 0)));
5560 	  else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
5564 							   c, op1, 0)));
5672 				     tree type, tree op0, tree op1,
5675   tree cond_type = cond_first_p ? TREE_TYPE (op0) : TREE_TYPE (op1);
5676   tree arg_type = cond_first_p ? TREE_TYPE (op1) : TREE_TYPE (op0);
6470 try_move_mult_to_index (enum tree_code code, tree addr, tree op1)
6477   /* Canonicalize op1 into a possibly non-constant delta
6479   if (TREE_CODE (op1) == MULT_EXPR)
6481       tree arg0 = TREE_OPERAND (op1, 0), arg1 = TREE_OPERAND (op1, 1);
6499   else if (TREE_CODE (op1) == INTEGER_CST)
6501       delta = op1;
6507       delta = op1;
7077 fold_binary (enum tree_code code, tree type, tree op0, tree op1)
7092   arg1 = op1;
7164     return fold_build2 (code, type, op1, op0);
7214 				    TREE_OPERAND (arg0, 1), op1));
7223 	  tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
7232 	  tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
7823 	      tree op1 = fold_convert (type, TREE_OPERAND (aref1, 1));
7825 	      tree diff = build2 (MINUS_EXPR, type, op0, op1);
8886       if (0 != (tem = fold_range_test (code, type, op0, op1)))
8975 	return fold_build2 (swap_tree_comparison (code), type, op1, op0);
9409 		  return fold_build2 (EQ_EXPR, type, op0, op1);
9415 		  return fold_build2 (NE_EXPR, type, op0, op1);
9450 		  return fold_build2 (EQ_EXPR, type, op0, op1);
9456 		  return fold_build2 (NE_EXPR, type, op0, op1);
9556 	  tem = optimize_minmax_comparison (code, type, op0, op1);
9900 	      tree op1 = TREE_OPERAND (cref1, 0);
9903 				  build_fold_addr_expr (op1));
10082 fold_ternary (enum tree_code code, tree type, tree op0, tree op1, tree op2)
10107   if (op1)
10109       arg1 = op1;
10132 	  tree unused_op = integer_zerop (arg0) ? op1 : op2;
10133 	  tem = integer_zerop (arg0) ? op2 : op1;
10159 	  tem = fold_cond_expr_with_comparison (type, arg0, op1, op2);
10173 	      tem = fold_cond_expr_with_comparison (type, tem, op2, op1);
10182 	  && tree_swap_operands_p (op1, op2, false))
10190 	    return fold_build3 (code, type, tem, op2, op1);
10194       if (integer_onep (op1)
10205       if (integer_zerop (op1)
10364 	return fold_builtin (TREE_OPERAND (op0, 0), op1, false);
10426       tree op0, op1, op2;
10436 	  op1 = TREE_OPERAND (t, 1);
10437 	  tem = fold_binary (code, type, op0, op1);
10441 	  op1 = TREE_OPERAND (t, 1);
10443 	  tem = fold_ternary (code, type, op0, op1, op2);
10707 fold_build2_stat (enum tree_code code, tree type, tree op0, tree op1
10726   fold_checksum_tree (op1, &ctx, ht);
10731   tem = fold_binary (code, type, op0, op1);
10733     tem = build2_stat (code, type, op0, op1 PASS_MEM_STAT);
10745   fold_checksum_tree (op1, &ctx, ht);
10750     fold_check_failed (op1, tem);
10761 fold_build3_stat (enum tree_code code, tree type, tree op0, tree op1, tree op2
10782   fold_checksum_tree (op1, &ctx, ht);
10792   tem = fold_ternary (code, type, op0, op1, op2);
10794     tem =  build3_stat (code, type, op0, op1, op2 PASS_MEM_STAT);
10806   fold_checksum_tree (op1, &ctx, ht);
10811     fold_check_failed (op1, tem);
10857 fold_build2_initializer (enum tree_code code, tree type, tree op0, tree op1)
10862   result = fold_build2 (code, type, op0, op1);
10869 fold_build3_initializer (enum tree_code code, tree type, tree op0, tree op1,
10875   result = fold_build3 (code, type, op0, op1, op2);
10954 	  tree op1, t1;
10956 	  op1 = TREE_OPERAND (top, 1);
10960 	      > TREE_INT_CST_LOW (op1)
10961 	      && TREE_INT_CST_HIGH (op1) == 0
10965 						       op1, 0)))
11394 fold_binary_to_constant (enum tree_code code, tree type, tree op0, tree op1)
11396   tree tem = fold_binary (code, type, op0, op1);
11576 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
11583   if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
11586       const REAL_VALUE_TYPE *c1 = TREE_REAL_CST_PTR (op1);
11629   if (TREE_CODE (op0) == COMPLEX_CST && TREE_CODE (op1) == COMPLEX_CST)
11633 					  TREE_REALPART (op1));
11636 					  TREE_IMAGPART (op1));
11657       op0 = op1;
11658       op1 = tem;
11674   if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
11677 	result = tree_int_cst_equal (op0, op1);
11679 	result = INT_CST_LT_UNSIGNED (op0, op1);
11681 	result = INT_CST_LT (op0, op1);