Lines Matching defs:subreg
340 /* If X is a paradoxical SUBREG, use the inner value to determine both the
688 /* We are trying to reload a subreg of something that is not a register.
690 mode MODE. OUTER is the mode of the subreg, DEST_CLASS the class in
821 (a) (subreg:OUTER_MODE REG ...) represents a word or subword subreg
838 /* Return true if X is a SUBREG that will need reloading of its SUBREG_REG
849 if (GET_CODE (x) != SUBREG)
1039 /* If we are reloading a (SUBREG constant ...), really reload just the
1040 inside expression in its own mode. Similarly for (SUBREG (PLUS ...)).
1041 If we have (SUBREG:M1 (MEM:M2 ...) ...) (or an inner REG that is still
1044 For machines that extend byte loads, do this for any SUBREG of a pseudo
1047 Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R
1051 the subreg, so do nothing here, and let following statement handle it.)
1053 Note that the case of (SUBREG (CONST_INT...)...) is handled elsewhere;
1060 reload but the SUBREG does.
1072 containing SUBREG as that would change the interpretation of the
1076 if (in != 0 && GET_CODE (in) == SUBREG
1139 combine.cc. (SUBREG (MEM)) isn't supposed to occur other ways. */
1146 /* Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R
1149 Similar issue for (SUBREG constant ...) if it was not handled by the
1152 However, we must reload the inner reg *as well as* the subreg in
1188 of SUBREG_REG (out); even if wider than out, storing in a subreg is
1189 entitled to clobber it all (except in the case of a word mode subreg
1192 if (out != 0 && GET_CODE (out) == SUBREG
1211 /* The case of a word mode subreg
1238 /* Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R
1242 However, we must reload the inner reg *as well as* the subreg in
1272 /* If IN is a SUBREG of a hard register, make a new REG. This
1275 if (in != 0 && GET_CODE (in) == SUBREG && REG_P (SUBREG_REG (in))
1281 if (out != 0 && GET_CODE (out) == SUBREG
1307 inside any subreg. For example, on the 386, QImode regs
1313 else if (in != 0 && GET_CODE (in) == SUBREG)
1318 if (out != 0 && GET_CODE (out) == SUBREG)
1394 || (GET_CODE (in) == SUBREG && REG_P (SUBREG_REG (in))))
1426 || (GET_CODE (out) == SUBREG && REG_P (SUBREG_REG (out))))
1577 the output is a SUBREG that clobbers an entire register.
1619 || (GET_CODE (in) == SUBREG
1977 while (GET_CODE (out) == SUBREG)
1987 while (GET_CODE (in) == SUBREG)
2072 real_out is a subreg, and in that
2161 while (GET_CODE (op0) == SUBREG)
2206 /* Like rtx_equal_p except that it allows a REG and a SUBREG to match
2231 if ((code == REG || (code == SUBREG && REG_P (SUBREG_REG (x))))
2232 && (REG_P (y) || (GET_CODE (y) == SUBREG
2237 if (code == SUBREG)
2250 if (GET_CODE (y) == SUBREG)
2520 case SUBREG:
2880 || GET_CODE (*recog_data.operand_loc[i]) == SUBREG)
2916 else if (code == SUBREG)
3114 /* If the operand is a SUBREG, extract
3118 while (GET_CODE (operand) == SUBREG)
3150 SUBREG where both the inner and outer modes are no wider
3164 ??? When is it right at this stage to have a subreg
3186 /* We must force a reload of a SUBREG's inner expression
3190 of the containing SUBREG as that would change the
3754 || GET_CODE (recog_data.operand[j]) == SUBREG))
3963 rtx subreg = NULL_RTX;
3969 if (GET_CODE (op) == SUBREG)
3971 subreg = op;
3990 /* If we stripped a SUBREG or a PLUS above add it back. */
3994 if (subreg != NULL_RTX)
3995 tem = gen_rtx_SUBREG (operand_mode[i], tem, SUBREG_BYTE (subreg));
4005 && subreg == NULL_RTX
4148 while (GET_CODE (operand) == SUBREG)
4198 while (GET_CODE (operand) == SUBREG)
4225 while (GET_CODE (operand) == SUBREG)
4764 /* This creates (subreg (mem...)) which would cause an unnecessary
4808 if (code == SUBREG && REG_P (SUBREG_REG (x)))
4810 /* Check for SUBREG containing a REG that's equivalent to a
4815 subreg later. The constant must not be VOIDmode, because we
4843 /* If the subreg contains a reg that will be converted to a mem,
4844 attempt to convert the whole subreg to a (narrower or wider)
4868 subreg - we must make the change in a copy, rather than using
5222 subreg big-endian corrections made by find_reloads_toplev. We
5610 if (GET_CODE (op0) == SUBREG)
5623 if (GET_CODE (op1) == SUBREG)
6072 case SUBREG:
6075 /* If this is a SUBREG of a hard register and the resulting register
6076 is of the wrong class, reload the whole SUBREG. This avoids
6091 /* If this is a SUBREG of a pseudo-register, and the pseudo-register
6092 is larger than the class size, then reload the whole SUBREG. */
6101 whole subreg by a (narrower) memory reference. If
6201 /* X, a subreg of a pseudo, is a part of an address that needs to be
6204 Attempt to replace the whole subreg by a (possibly narrower or wider)
6232 /* We cannot replace the subreg with a modified memory reference if:
6234 - we have a paradoxical subreg that implicitly acts as a zero or
6237 - we have a subreg that is implicitly supposed to act on the full
6242 - we have a paradoxical subreg and the resulting memory is not
6246 paradoxical subreg, even if it were possible in principle. This
6471 else if (reloadreg && GET_CODE (*loc) == SUBREG
6544 case SUBREG:
6545 /* If this is a SUBREG of a hard reg, we can see exactly which
6562 /* Note setting a SUBREG counts as referring to the REG it is in for
6565 && ((GET_CODE (SET_DEST (x)) == SUBREG
6619 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
6641 else if (GET_CODE (x) == SUBREG && MEM_P (SUBREG_REG (x)))
6643 else if (GET_CODE (x) == SUBREG)
7046 while (GET_CODE (dest) == SUBREG
7085 while (GET_CODE (dest) == SUBREG
Indexes created Sun Mar 01 05:31:48 UTC 2026