gcc/gcc/fold-const.c

228    to issue any warnings, since it works with expressions which do not
244    level at which the warning should be emitted.  */
259    the statement with which the warning should be associated (used for
516 	 B is 1, we may turn this into INT_MIN / -1 which is undefined
526 	     division which is not ok for example for
708 	 B is 1, we may turn this into INT_MIN / -1 which is undefined
728 	     division which is not ok for example for
791    negated in a simpler way.  Also allow for T to be NULL_TREE, in which case
824    literal for which we use *MINUS_LITP instead.
827    for which we use *MINUS_LITP instead.  If a variable part is of pointer
1770    indicates which particular sizetype to create.  */
1860      overflow) and negate (which can't either).  Special-case a result
2639 /* Return a tree for the comparison which is the combination of
2673 	 which are not used unless the mode has NaNs.  */
2743    executed between the evaluation of its "operands" (which may often
2841   /* Next handle constant cases, those for which we can return 1 even
3157      signedness comparison, which doesn't matter here.  */
3195    two different values, which will be stored in *CVAL1 and *CVAL2; if
3442      floating-point non-equality comparisons, in which case we just
3483 	 unless the second operand is a TRUTH_NOT_EXPR in which case our
3520 	/* A COND_EXPR may have a throw as one operand, which
4339 	/* Check for an unsigned range which has wrapped around the maximum
4421 	     range for which the original unsigned value will be
4481      the switch, which will "break" the while.  */
5068 	     operand which will be used if they are equal first
5274 	 which cases we can't do this.  */
5361    which we must not transform.  If RHS_ONLY is true, only eliminate the
5848 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
5954    modulus (CODE says which and what kind of divide or modulus) by a
6307 	 optimizations of this pass, which occur when either constant is a
6308 	 multiple of the other, in which case we replace this with either an
6349 /* Return a node which has the indicated constant VALUE (either 0 or
7318 	     end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
8737    expressions like &p->x which can not wrap.  */
8881 	 with the transformation in fold_cond_expr_with_comparison which
9079 	         arithmetic which operates on unsigned pointer types of size
9080 	         type size and ARRAY_REF offsets which are properly sign or
9407      eight possibilities, each of which corresponds to the constant 0
9411      expressions like  ((x > y) - (y > x)) > 0, which supposedly
10177 	  /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
10435 	     which wraps on overflow, if that is one of the operand types.  */
11038 	      /* Canonicalize x*x as pow(x,2.0), which is expanded as x*x.  */
11099 	     mode which allows further optimizations.  */
11153 	 which will allow use of NAND instructions provided by the
11190       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
11444 	         mode which allows further optimizations.  */
11473 	      int which = 0;
11484 		  which = 1;
11488 		which = -1;
11490 	      for (; which >= 0; which--)
11491 		switch (TREE_CODE (pmop[which]))
11496 		    if (TREE_CODE (TREE_OPERAND (pmop[which], 1))
11499 		    cst0 = TREE_OPERAND (pmop[which], 1);
11501 		    if (TREE_CODE (pmop[which]) == BIT_AND_EXPR)
11511 		    pmop[which] = TREE_OPERAND (pmop[which], 0);
11517 			 || (TREE_CODE (arg0) == MINUS_EXPR && which == 0))
11518 			&& (cst1 & pmop[which]) == 0)
11519 		      pmop[which] = NULL;
11589 	 which will allow use of NOR instructions provided by the
12384 	 unaliased symbols neither of which are extern (since we do not
12492 	 on machines that have only two-operand insns or on which a
13203 	 But ABS (X) <= C is a range comparison, which becomes a subtraction
13395 /* Return whether the sub-tree ST contains a label which is accessible from
13483              Avoid throwing away that operand which contains label.  */
13570 	     a COND, which will recurse.  In that case, the COND_EXPR
14767     /* Truth values evaluate to 0 or 1, which is nonnegative unless we
15587 	     +INDEX), which becomes (ARRAY+255+INDEX).  Oops!)  */