contrib/gcc/optabs.c

672    the effective shift value is >= BITS_PER_WORD.  The arguments and return
695 				 outof_input, GEN_INT (BITS_PER_WORD - 1),
703    the effective shift value is < BITS_PER_WORD.  The arguments and return
720      We therefore need to shift OUTOF_INPUT by (BITS_PER_WORD - OP1) bits in
722   if (CONSTANT_P (op1) || shift_mask >= BITS_PER_WORD)
725       tmp = immed_double_const (BITS_PER_WORD, 0, op1_mode);
731       /* We must avoid shifting by BITS_PER_WORD bits since that is either
732 	 the same as a zero shift (if shift_mask == BITS_PER_WORD - 1) or
738       if (shift_mask == BITS_PER_WORD - 1)
746 	  tmp = immed_double_const (BITS_PER_WORD - 1, 0, op1_mode);
782    The shift is by < BITS_PER_WORD if (CMP_CODE CMP1 CMP2) is true,
783    otherwise it is by >= BITS_PER_WORD.  SUBWORD_OP1 and SUPERWORD_OP1
851    shift count is outside the range [0, BITS_PER_WORD).  This routine must
852    avoid generating such shifts for OP1s in the range [0, BITS_PER_WORD * 2).
855    masked by it and shifts in the range [BITS_PER_WORD, SHIFT_MASK) will
858    If SHIFT_MASK is BITS_PER_WORD - 1, this routine will synthesize
859    a doubleword shift whose equivalent mask is BITS_PER_WORD * 2 - 1.
882   /* See if word-mode shifts by BITS_PER_WORD...BITS_PER_WORD * 2 - 1 will
890   if (shift_mask >= BITS_PER_WORD
906      is true when the effective shift value is less than BITS_PER_WORD.
909   tmp = immed_double_const (BITS_PER_WORD, 0, op1_mode);
910   if (!CONSTANT_P (op1) && shift_mask == BITS_PER_WORD - 1)
912       /* Set CMP1 to OP1 & BITS_PER_WORD.  The result is zero iff OP1
922       /* Set CMP1 to OP1 - BITS_PER_WORD.  */
1034       2**(BITS_PER_WORD-1), i.e. the instruction multiplies op1_low
1035       with 2**BITS_PER_WORD - op0_low, and two's complements the
1036       result.  Conclusion: We need to add op1_low * 2**BITS_PER_WORD to
1040       (op0_low + op1_low) * 2**BITS_PER_WORD.
1043       (op1_low) BITS_PER_WORD-1 steps to get 0 or 1, and add this to
1054   rtx wordm1 = umulp ? NULL_RTX : GEN_INT (BITS_PER_WORD - 1);
1479       for (i = 0; i < GET_MODE_BITSIZE (mode) / BITS_PER_WORD; i++)
1497       if (i == GET_MODE_BITSIZE (mode) / BITS_PER_WORD)
1538 	  || (shift_mask == BITS_PER_WORD - 1
1539 	      && double_shift_mask == BITS_PER_WORD * 2 - 1))
1624       if (shift_count == BITS_PER_WORD)
1637 	  reverse_unsigned_shift = (left_shift ^ (shift_count < BITS_PER_WORD)
1640 	  unsigned_shift = (left_shift ^ (shift_count < BITS_PER_WORD)
1643 	  if (shift_count > BITS_PER_WORD)
1645 	      first_shift_count = GEN_INT (shift_count - BITS_PER_WORD);
1646 	      second_shift_count = GEN_INT (2 * BITS_PER_WORD - shift_count);
1650 	      first_shift_count = GEN_INT (BITS_PER_WORD - shift_count);
1709       const unsigned int nwords = GET_MODE_BITSIZE (mode) / BITS_PER_WORD;
1800       if (i == GET_MODE_BITSIZE (mode) / (unsigned) BITS_PER_WORD)
2462 	word = (GET_MODE_BITSIZE (mode) - bitpos) / BITS_PER_WORD;
2464 	word = bitpos / BITS_PER_WORD;
2465       bitpos = bitpos % BITS_PER_WORD;
2466       nwords = (GET_MODE_BITSIZE (mode) + BITS_PER_WORD - 1) / BITS_PER_WORD;
2663       for (i = 0; i < GET_MODE_BITSIZE (mode) / BITS_PER_WORD; i++)
2974 	word = (GET_MODE_BITSIZE (mode) - bitpos) / BITS_PER_WORD;
2976 	word = bitpos / BITS_PER_WORD;
2977       bitpos = bitpos % BITS_PER_WORD;
3038 	word = (GET_MODE_BITSIZE (mode) - bitpos) / BITS_PER_WORD;
3040 	word = bitpos / BITS_PER_WORD;
3041       bitpos = bitpos % BITS_PER_WORD;
3042       nwords = (GET_MODE_BITSIZE (mode) + BITS_PER_WORD - 1) / BITS_PER_WORD;
5019   int maxsize = 2*BITS_PER_WORD;