Lines Matching defs:it
6 GCC is free software; you can redistribute it and/or modify it under
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
38 of indirect addressing supported by the machine. If it is zero,
39 indirect addressing is not valid. If it is one, (MEM (REG n))
40 is valid even if (REG n) did not get a hard register; if it is two,
58 find_reloads can alter the operands of the instruction it is called on.
74 When an insn has reloads, it is considered as having three parts:
82 When a reload is used for addresses in multiple parts, or when it is
83 an ordinary operand, it is classified as RELOAD_OTHER, and cannot share
88 /* We do not enable this with ENABLE_CHECKING, since it is awfully slow. */
175 an entry is made for it in the table `replacements'.
187 machine_mode mode; /* mode it must have */
221 so we can test whether a register dies in it. */
238 /* Set to 1 in subst_reg_equivs if it changes anything. */
319 /* Add NEW to reg_equiv_alt_mem_list[REGNO] if it's not present in the
325 rtx it;
327 for (it = reg_equiv_alt_mem_list (regno); it; it = XEXP (it, 1))
328 if (rtx_equal_p (XEXP (it, 0), mem))
380 /* If X is a pseudo-register that has an equivalent MEM (actually, if it
381 is still a pseudo-register by now, it *must* have an equivalent MEM
492 set it up now. Note that we do the input case before making
516 /* Maybe we could combine these, but it seems too tricky. */
568 /* ICODE is the insn_code of a reload pattern. Check that it has exactly
604 /* By default, if MODE is narrower than a word, widen it to a word.
616 /* If we already have made a MEM for this operand in MODE, return it. */
635 didn't give us a new MEM, make a new one if it isn't valid. */
648 address. If it wasn't valid, we need to make a reload each time, so
649 don't save it. */
816 /* If the existing reload has a register, it must fit our class. */
832 Likewise, it can match a preincrement reload, since we regard
838 /* If the existing reload has a register, it must fit our
929 Speed this up, since it trivially works. */
935 And since we've already handled address reloads for this MEM, it
960 If IN and OUT are both nonzero, it means the same register must be used
973 it can be discarded if that is more convenient.
1016 Note that it can't simply be done here if we missed it earlier
1071 the subreg, so do nothing here, and let following statement handle it.)
1074 we can't handle it here because CONST_INT does not indicate a mode.
1079 Also reload the inner expression if it does not require a secondary
1082 Finally, reload the inner expression if it is a register that is in
1086 register class. But if it is inside a STRICT_LOW_PART, we have
1160 where M1 is not valid for R if it was not handled by the code above.
1162 Similar issue for (SUBREG constant ...) if it was not handled by the
1196 entitled to clobber it all (except in the case of a word mode subreg
1198 label it input-output.) */
1316 /* Discard what the target said if we cannot do it. */
1367 /* We used to continue here setting class to ALL_REGS, but it triggers
1456 but we may have additional information for it.
1541 because we cannot reliably tell whether it appears in the insn. */
1551 it must be for an autoincrement. It doesn't work to store
1554 increment it, store it back, then decrement again. */
1589 /* If this reload is just being introduced and it has both
1605 as the incoming one, we can dispense with loading it.
1616 dies in this insn and is used nowhere else, see if it is the right class
1617 to be used for this reload. Use it if so. (This occurs most commonly
1619 this if it is also an output reload that mentions the register unless
1622 Note that the operand might be one of the spill regs, if it is a
1652 the reload register if it is set in this insn unless IN
1751 or a subpart of it. If we have any replacements registered for IN_RTX,
1789 /* If there is only one output reload, and it is not for an earlyclobber
1790 operand, try to combine it with a (logically unrelated) input reload
1795 it is not needed any more once the original insn completes.
1798 die in this insn as a reload register. We can if it is of the right
1833 need to change it to RELOAD_FOR_OTHER_ADDRESS. But that would extend
1842 /* Check each input reload; can we combine it? */
1903 /* If the output reload had a secondary reload, copy it. */
1932 to be the first), it must be the one corresponding to this reload. It
1934 that it does not occur in the output (we already know it isn't an
1990 If FOR_REAL is >= 0, it is the number of the reload,
1991 and in some cases when it can be discovered that OUT doesn't need
1995 is just to see if a register can be found, not to find and install it.
1999 IN must not appear elsewhere in the insn (it is assumed that IN itself
2067 If the insn uses IN elsewhere and it contains OUT,
2068 that counts. We can't be sure it's the "same" operand
2069 so it might not go through this reload.
2071 We also need to avoid using OUT if it, or part of it, is a
2105 We can't use IN unless it is dies in this insn,
2126 global can assign some hardreg to it that is the same as
2127 the one assigned to a different, also live pseudo (as it
2162 and changed our mind, it means OUT is a dummy that
2163 dies here. So don't bother copying value to it. */
2253 /* Like rtx_equal_p except that it allows a REG and a SUBREG to match
2433 If X is pushing on the stack, we can assume it causes no trouble,
2552 /* This could be more precise, but it's good enough. */
2564 /* This hasn't been assigned yet, so it can't conflict yet. */
2663 /* These are the preferred classes for an operand, or NO_REGS if it isn't
2741 /* Dispose quickly of (set (reg..) (reg..)) if both have hard regs and it
2742 is cheap to move between them. If it is not, there may not be an insn
2789 /* Scan this operand's constraint to see if it is an output operand,
2811 but sometimes it would crash the compiler. We
2814 future we may handle it correctly. */
2821 /* Use of ISDIGIT is tempting here, but it may get expensive because
2976 we replace it by the constant. We must be sure, however,
2977 that we don't try to replace it in the insn in which it
3001 /* If the operand is still a register (we didn't replace it with an
3002 equivalent), get the preferred class to reload it into. */
3058 /* If insn is commutative (it's safe to exchange a certain pair
3069 /* BAD is set to 1 if it some operand can't fit this alternative
3072 /* REJECT is a count of how undesirable this alternative says it is
3074 then REJECT is ignored, but otherwise it gets this much
3075 counted against it in addition to the reloading needed. Each
3135 /* If the predicate accepts a unary operator, it means that
3148 it is a hard reg. This is because it is passed
3149 to reg_fits_class_p if it is a REG and all pseudos
3172 big-endian machines, it may also reference outside
3187 subregs for push_reload to see. Make sure it does
3190 ??? When is it right at this stage to have a subreg
3277 may be rejected when it is actually desirable.) */
3294 this combination, because we can't reload it. */
3309 as a loser, if it wasn't already. */
3428 /* A reloaded address is offsettable because it is now
3435 loading it into a register; hence it will be
3463 it from a register when eliminating registers. */
3584 /* Alternative loses if it has no regs for a reg operand. */
3591 class by copying it to memory first, count that as another
3609 /* Alternative loses if it requires a type of reload not
3642 insns, just using a register, so it is also preferred.
3645 it will then win since we don't want to have a different
3664 but it intersects that class, use the preferred class
3665 instead. If it does not intersect the preferred
3667 discouraged; it will be discouraged more still if the
3669 because it increases the chance of reusing our spill
3676 Don't do this for a multiword operand, since it is
3740 /* Is it altered by storing the earlyclobber operand? */
3745 it's costly to reload it, so reload the input instead. */
3758 it must be reloaded, so request this and count the cost. */
3809 and it needs less reloading than the others checked so far,
3810 record it as the chosen goal for reloading. */
3869 Reload so as to fit it. */
3992 /* If we stripped a SUBREG or a PLUS above add it back. */
4036 so we don't bother with it. It may not be worth doing. */
4164 If this is an asm, we can't delete it; we must not even call
4206 it as one that can be safely deleted at the end
4250 /* We only do this on the last pass through reload, because it is
4267 /* For a JUMP_P, if it was a branch target it must have
4290 it doesn't expect. */
4302 (or at least find_equiv_reg isn't smart enough to find it any more),
4303 causing this insn to need more reload regs than it needed before.
4309 We can use it as long as we don't need to change its contents. */
4380 of a reload when two operands match. If a reload is optional, treat it
4384 reload, it means the object is hanging around. Thus we need only
4418 /* If there's a tertiary reload we have to change it also. */
4433 /* If there's a tertiary reload we have to change it also. */
4467 RELOAD_FOR_OPERAND_ADDRESS reloads other than the one that uses it.
4471 actually fail are extremely rare, so it turns out to be better to fix
4479 does not conflict with any of them, if it is only used for the first of
4619 destination of a hard reg, if the hard reg is ok, use it. */
4655 MEM gives the reference if it didn't need any reloads, otherwise it
4677 to disallow the original constant address, forcing it to be
4694 We may alter X destructively if it contains a reference to such.
4745 that delete_output_reload can see it. */
4747 /* We mark the USE with QImode so that we recognize it
4778 constant. If the constant has a known value, truncate it
4780 multi-word constant. If the constant is symbolic, allow it
4784 because one of the cases above should handle it). */
4833 /* If we have replaced a reg with it's equivalent memory loc -
4834 that can still be handled here e.g. if it's in a paradoxical
4861 /* If TEM might contain a pseudo, we must copy it to avoid
4862 modifying it when we do the substitution for the reload. */
4869 /* Copy the result if it's still the same as the equivalence, to avoid
4870 modifying it when we do the substitution for the reload. */
4910 Value is one if this address is reloaded or replaced as a whole; it is
4912 it is -1 if it may or may not have been reloaded or replaced.
4932 /* If the address is a register, see if it is a legitimate address and
4987 recognize it as one that can be safely
4993 as a whole, since it is still a memory access. */
5023 it has failed to get a hard reg.
5063 we have an outer AND and remove it if so. Then analyze what's inside. */
5072 /* One possibility for why the address is invalid is that it is itself
5088 hold it and store it back into memrefloc. */
5110 /* Must use TEM here, not AD, since it is the one that will
5122 /* If we have address of a stack slot but it's not valid because the
5140 /* Unshare the MEM rtx so we can safely alter it. */
5176 it might be invalid: The index might need to be reloaded, the address
5183 is valid when not interpreted strictly. If it is, the only problem is
5185 of it.
5193 If we decide to do something, it must be that `double_reg_address_ok'
5298 Unshare it so we can safely alter it. */
5323 front of it for pseudos that we have to replace with stack slots. */
5358 /* We mark the USE with QImode so that we recognize it
5438 (But it is not guaranteed to be one.)
5442 so it is more likely to be a valid address.
5543 Also, this is not fully machine-customizable; it works for machines
5609 register rematerialization for expression like &localvar*4. Reload it.
5611 but it is probably not worthwhile to do so. */
5744 conservative and class it as RELOAD_OTHER. */
5776 write back the value after reading it, hence we actually
5846 write back the value after reading it, hence we actually
5856 /* Proceed to reload that, as if it contained a register. */
5862 autoincdec, we can reload it. But, if an autoincrement of a
5864 isn't "valid", it must be that no autoincrement is "valid".
5868 We can't improve this address, so leave it alone. */
5884 CALL_INSN - and it does not set CC0.
5886 memory location, since this will make it harder to
5959 register. Verify that the specified address is valid and reload it
5965 Note that this is actually conservative: it would be slightly more
6029 in this insn, reload it into some other register to be safe.
6031 from before this insn to after it. */
6127 it into the register.
6216 paradoxical subreg, even if it were possible in principle. This
6257 Note that this may not work in the general case, but it seems to cover
6279 delete_output_reload can see it. */
6281 /* We mark the USE with QImode so that we recognize it as one that
6318 those arrays needs to be reloaded, it must be unshared before
6320 Otherwise, if the equivalence is used after that, it will
6535 /* Note setting a SUBREG counts as referring to the REG it is in for
6633 /* If this is a pseudo, it must not have been assigned a hard register.
6634 Therefore, it must either be in memory or be a constant. */
6716 it is a vector indexed by hard reg number
6724 If GOAL is nonzero and not VOIDmode, then it must have mode MODE.
6728 If GOAL is the sum of the stack pointer and a constant, we treat it
6729 as if it were a constant except that sp is required to be unchanging. */
6804 function call; on the second return (from the longjmp) it
6806 seem worthwhile to actually go and see if it is actually
6808 just don't reuse it across the setjmp call. */
6820 reject it below, but it might hide a usable equivalent.
6822 spilled for this insn because it was assumed we would find
6922 /* Reject VALUE if it was loaded from GOAL
6942 /* Reject VALUE if it is one of the regs reserved for reloads.
6943 Reload1 knows how to reuse them anyway, and it would get
6956 /* Reject VALUE if it is a register being used for an input reload
6957 even if it is not one of those reserved. */
6976 since it can vary--in a nonlocal goto as generated by expand_goto. */