contrib/gcc/combine.c

43    as to move a computation to a place where its value would be different.
52    There are a few exceptions where the dataflow information created by
245      where byte loads zero extend.
350    to be undone by storing old_contents into *where.  */
357   union { rtx *r; int *i; } where;
527   buf->where.r = into;
555   buf->where.i = into;
584   buf->where.r = into;
1509       /* Check for the case where I3 modifies its output, as discussed
1611    not.  This is used in try_combine to detect early some cases where we
1891      not handle.  Namely, the case where I1 is zero, I2 is a PARALLEL
1894      This occurs in the common code where we compute both a quotient and
1899      cases where I2 has a number of CLOBBER or PARALLELs.
1903      where I2 and I3 are adjacent to avoid making difficult register
1957 		 insn the new pattern for I3.  Then skip to where we
2009 	  /* Handle the case where inner is twice the size of outer.  */
2193      which is a famous insn on the PDP-11 where the value of r3 used as the
2272      for this case, where both the comparison and the operation result are
2464 	    /* See comment where i2pat is assigned.  */
2492   /* If the result isn't valid, see if it is a PARALLEL of two SETs where
2506      Also check the case where the first SET's destination is unused.
2791 	      /* Split "((P op Q) op R) op S" where op is PLUS or MULT.  */
2805 		     "((X op Y) op Y) op X" as "T op T" where T is
2816 		  /* Split "((X op X) op Y) op Y)" as "T op T" where
2858   /* Check for a case where we loaded from memory in a narrow mode and
2923   /* Similarly, check for a case where we have a PARALLEL of two independent
3163     /* We had one special case above where I2 had more than one set and
3445 	  *undo->where.r = undo->old_contents.r;
3448 	  *undo->where.i = undo->old_contents.i;
3451 	  PUT_MODE (*undo->where.r, undo->old_contents.m);
3483    where we have an arithmetic expression and return that point.  LOC will
3563 		 find where in SRC2 it was placed, that can become our
3673 	     bit and the result is only being used in a context where we
3763 	     AND or two shifts.  Use two shifts for field sizes where the
4001 	 where we want to suppress replacing something inside a
4112 		 well as prevent accidents where two CLOBBERs are considered
4195      things.  Check for cases where both arms are testing the same
4451 	 (neg X) to (ashiftrt (ashift X C-I) C-I) where C is the bitsize of
4567 	 can become (ashiftrt (ashift (xor x 1) C) C) where C is
4777 	     (ashift x c) where C puts the bit in the sign bit.  Remove any
4986   /* Look for cases where we have (abs x) or (neg (abs X)).  */
5035      second operand is zero, this can be done as (OP Z (mult COND C2)) where
5380       /* Get SET_SRC in a form where we have placed back any
5395      be undefined.  On machine where it is defined, this transformation is safe
5789      We must check for the case where the left shift would have a negative
6015 	 (ashift X (const_int C)), where LEN > C.  Extract the
6430    try to convert logical to arithmetic shift operations in cases where
6707    Otherwise, return the starting position of the field, where 0 is the
7046       /* If X is (minus C Y) where C's least set bit is larger than any bit
7116 	 However, we cannot do anything with shifts where we cannot
7175       /* If we have (and (lshiftrt FOO C1) C2) where the combination of the
7291 	 in the mode of X, compute where the bits we care about are.
7464       /* See if we have PLUS, IOR, XOR, MINUS or UMAX, where one of the
7893      OTHER is known to have zeros where C1 has ones, this is such an
8102    few places where this routine is called.
8639       /* Handle cases where the count is greater than the size of the mode
8883 		 Handle the case where the shift codes are the same
9067 	  /* (lshiftrt (neg A) C) where A is either 0 or 1 and C is one less
9091 	  /* (lshiftrt (plus A -1) C) where A is either 0 or 1 and C
9337    PNOTES is a pointer to a location where any REG_UNUSED notes added for
9561 /* Simplify a comparison between *POP0 and *POP1 where CODE is the
9651 	 Similarly, check for a case where the AND's are ZERO_EXTEND
10112 	  /* Check for the case where we are comparing A - C1 with C2, that is
10243 	  /* The sign bit of (minus (ashiftrt X C) X), where C is the number
10288 	  /* Check for the cases where we simply want the result of the
10409 	  /* If this is (and:M1 (subreg:M2 X 0) (const_int C1)) where C1
10463 	     Also handle the case where (not X) is expressed using xor.  */
11747 	     We must also check for the case where X is a hard register
11946 	  /* Doesn't matter much where we put this, as long as it's somewhere.
12139 	     put it back where it was.  Otherwise move it to the previous
12195 	     from a computation.  For example, we might have had A & B where
12618    of EXPR where some registers may have been replaced by constants.  */