gcc/gcc/fold-const.c

238    one, but that is fine since it is sufficient to only give one
494       /* INT_MIN/n * n doesn't overflow while negating one operand it does
2025      have one, set the overflow bit so that we can produce some kind of
2799      code, try to swap the comparison operands of one arg to produce
3255 	 one side of the comparison is each of the values; test for the
3431    FIXME: one would think we would fold the result, but it causes
3520 	/* A COND_EXPR may have a throw as one operand, which
3878      (in case this was a signed field).  If we changed it, make a new one.  */
3913    Return 0 if this is not a component reference or is one that we can't
4110    range with a lower and upper bound.  If one of the bounds is omitted,
4193 /* Helper routine for make_range.  Perform one step for it, return
4689 /* Given two ranges, see if we can merge them into one.  Return 1 if we
5117      if C1 is one less or one more than C2, this might have started
5247      can build the range test, return it or it inverted.  If one of the
5330      zero or one, and the conversion to a signed type can never overflow.
5352    we can drop one of the inner expressions and simplify to
5429    operations to do this with one comparison.
5432    function and the one above.
5453      comparison for one-bit fields.  */
5474      If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5609      fail.  However, we can convert a one-bit comparison against zero into
5618 	     in the value of one bit.  Otherwise we are doing the wrong
6418      on at least one of the branches once its pushed inside the COND_EXPR.  */
6443   /* Check that we have simplified at least one of the branches.  */
6487      In this situation, there is only one case we can return true for.
6897       tree tem, one;
6941       one = build_int_cst (intermediate_type, 1);
6944 	inner = fold_build2_loc (loc, BIT_XOR_EXPR, intermediate_type, inner, one);
6947       inner = build2 (BIT_AND_EXPR, intermediate_type, inner, one);
7220 /* Fold a sum or difference of at least one multiplication.
8124          when one of the new casts will fold away. Conservatively we assume
8673      would produce one outside of its types range.  */
8893      This requires at least one operand being an ADDR_EXPR or a
9149      original one and has the same sign.  */
9342       /* If we are widening one operand of an integer comparison,
9408      or 1 or one of the six possible comparisons.
10018      one of the operands is a comparison and the other is a comparison, a
10160 	 one.  Make sure the type is not saturating and has the signedness of
10435 	     which wraps on overflow, if that is one of the operand types.  */
10448 	  /* With undefined overflow we can only associate constants with one
10755 	 one.  Make sure the type is not saturating and has the signedness of
11525 	      /* Only build anything new if we optimized one or both arguments
12007 	 At one time others generated faster code, it's not clear if they do
12491 	 two operations, but the latter can be done in one less insn
12656 	 Other cases should reduce to one of these two (or a constant)
12676       /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
13202 	 well not be faster than doing the ABS and one comparison.
13520 	 for reasons given above each one.
15837      have already handled the one case that it matters.  */
16278       /* If only one of the offsets is non-constant, the difference cannot