Lines Matching defs:mode
156 enum machine_mode mode; /* mode it must have */
177 is used per mode, but normally only one or two modes are ever used.
308 register class RELOAD_CLASS in mode RELOAD_MODE. If secondary reloads
323 enum machine_mode mode = reload_mode;
343 mode and object being reloaded. */
407 mode = insn_data[(int) icode].operand[2].mode;
432 && ((in_p && rld[s_reload].inmode == mode)
433 || (! in_p && rld[s_reload].outmode == mode))
443 rld[s_reload].inmode = mode;
445 rld[s_reload].outmode = mode;
467 && SECONDARY_MEMORY_NEEDED (class, reload_class, mode))
481 rld[s_reload].inmode = in_p ? mode : VOIDmode;
482 rld[s_reload].outmode = ! in_p ? mode : VOIDmode;
503 && SECONDARY_MEMORY_NEEDED (reload_class, class, mode))
504 get_secondary_mem (x, mode, opnum, type);
517 enum machine_mode mode, rtx x)
524 class = targetm.secondary_reload (in_p, x, class, mode, &sri);
567 /* Return a memory location that will be used to copy X in mode MODE.
568 If we haven't already made a location for this mode in this insn,
572 get_secondary_mem (rtx x ATTRIBUTE_UNUSED, enum machine_mode mode,
584 mode = SECONDARY_MEMORY_NEEDED_MODE (mode);
586 if (GET_MODE_BITSIZE (mode) < BITS_PER_WORD && INTEGRAL_MODE_P (mode))
587 mode = mode_for_size (BITS_PER_WORD, GET_MODE_CLASS (mode), 0);
591 if (secondary_memlocs_elim[(int) mode][opnum] != 0)
592 return secondary_memlocs_elim[(int) mode][opnum];
594 /* If this is the first time we've tried to get a MEM for this mode,
598 if (secondary_memlocs[(int) mode] == 0)
601 secondary_memlocs[(int) mode] = SECONDARY_MEMORY_NEEDED_RTX (mode);
603 secondary_memlocs[(int) mode]
604 = assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
611 loc = eliminate_regs (secondary_memlocs[(int) mode], VOIDmode, NULL_RTX);
612 mem_valid = strict_memory_address_p (mode, XEXP (loc, 0));
614 if (! mem_valid && loc == secondary_memlocs[(int) mode])
630 find_reloads_address (mode, &loc, XEXP (loc, 0), &XEXP (loc, 0),
634 secondary_memlocs_elim[(int) mode][opnum] = loc;
635 if (secondary_memlocs_elim_used <= (int)mode)
636 secondary_memlocs_elim_used = (int)mode + 1;
652 mode INNER, and which for every such register, that register number
788 reload_inner_reg_of_subreg (rtx x, enum machine_mode mode, int output)
809 if (! HARD_REGNO_MODE_OK (subreg_regno (x), mode))
815 return (GET_MODE_SIZE (mode) <= UNITS_PER_WORD
822 /* Return nonzero if IN can be reloaded into REGNO with mode MODE without
837 can_reload_into (rtx in, int regno, enum machine_mode mode)
860 dst = gen_rtx_REG (mode, regno);
882 INMODE is the machine mode that the instruction requires
885 If IN is zero, then OUT's location and mode should be passed as
919 /* INMODE and/or OUTMODE could be VOIDmode if no mode
921 use the operand's mode as the mode to reload. */
970 inside expression in its own mode. Similarly for (SUBREG (PLUS ...)).
976 M2 is an integral mode that gets extended when loaded.
984 we can't handle it here because CONST_INT does not indicate a mode.
1243 /* Verify that this class is at least possible for the mode that
1247 enum machine_mode mode;
1249 mode = inmode;
1251 mode = outmode;
1252 if (mode == VOIDmode)
1256 mode = word_mode;
1263 if (HARD_REGNO_MODE_OK (i, mode)
1266 int nregs = hard_regno_nregs[i][mode];
1373 the larger mode, so that the value is valid for both modes. */
1468 r->mode = inmode;
1476 r->mode = outmode;
1601 push_replacement (rtx *loc, int reloadnum, enum machine_mode mode)
1609 r->mode = mode;
1626 push_replacement (dup_loc, r->what, r->mode);
2011 has a real mode. */
2115 /* Return 1 if ADDR is a valid memory address for mode MODE,
2120 strict_memory_address_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx addr)
2122 GO_IF_LEGITIMATE_ADDRESS (mode, addr, win);
2785 /* Address operands are reloaded in their existing mode,
2847 /* Record the existing mode so that the check if constants are
2984 be a problem accessing OPERAND in the outer mode. */
2995 than a word and the inner mode is narrower, is integral,
3906 use Pmode as mode of the reload register, as would have
4466 rld[i].mode
4472 rld[i].nregs = CLASS_MAX_NREGS (rld[i].class, rld[i].mode);
4488 && HARD_REGNO_MODE_OK (regno, rld[i].mode))
4490 int nr = hard_regno_nregs[regno][rld[i].mode];
4620 will lose the mode of the register (this should never happen
4655 a wider mode if we have a paradoxical SUBREG. find_reloads will
4723 to mode MODE by reloading the part pointed to by PART into a
4727 maybe_memory_address_p (enum machine_mode mode, rtx ad, rtx *part)
4734 retv = memory_address_p (mode, ad);
4741 which appears in *LOC in a memory reference to mode MODE
4743 Note that we take shortcuts assuming that no multi-reg machine mode
4766 find_reloads_address (enum machine_mode mode, rtx *memrefloc, rtx ad,
4787 && (tem = eliminate_regs (tem, mode, insn))
4788 && strict_memory_address_p (mode, tem))
4816 && strict_memory_address_p (mode, tem)
4850 && regno_ok_for_base_p (regno, mode, MEM, SCRATCH)
4851 && ! regno_clobbered_p (regno, this_insn, mode, 0))
4855 push_reload (ad, NULL_RTX, loc, (rtx*) 0, base_reg_class (mode, MEM, SCRATCH),
4860 if (strict_memory_address_p (mode, ad))
4883 if (strict_memory_address_p (mode, ad))
4956 base_reg_class (mode, MEM, SCRATCH), GET_MODE (tem),
4974 && regno_ok_for_base_p (REGNO (XEXP (ad, 0)), mode, PLUS,
5005 base_reg_class (mode, MEM, SCRATCH),
5057 if ((regno_ok_for_base_p (REGNO (operand), mode, inner_code,
5067 && ! maybe_memory_address_p (mode, ad,
5086 cls = base_reg_class (mode, MEM, GET_CODE (addend));
5090 find_reloads_address_1 (mode,
5106 if (tem != ad && strict_memory_address_p (mode, tem))
5116 if (! subst_reg_equivs_changed || strict_memory_address_p (mode, tem))
5125 if (CONSTANT_P (ad) && ! strict_memory_address_p (mode, ad))
5138 find_reloads_address_part (ad, loc, base_reg_class (mode, MEM, SCRATCH),
5143 return find_reloads_address_1 (mode, ad, 0, MEM, SCRATCH, loc, opnum, type,
5230 enum machine_mode mode = GET_MODE (x);
5232 if (mode == VOIDmode)
5233 mode = GET_MODE (y);
5235 if (mode == VOIDmode)
5236 mode = Pmode;
5262 return gen_rtx_CONST (VOIDmode, gen_rtx_PLUS (mode, x, y));
5265 return gen_rtx_PLUS (mode, x, y);
5356 in mode MODE. (This function is not called if the address we find
5376 /* Note that we take shortcuts assuming that no multi-reg machine mode
5385 find_reloads_address_1 (enum machine_mode mode, rtx x, int context,
5401 context_reg_class = base_reg_class (mode, outer_code, index_code);
5432 /* ??? Why is this given op1's mode and above for
5458 find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH,
5461 find_reloads_address_1 (mode, orig_op1, 0, PLUS, code0,
5469 find_reloads_address_1 (mode, orig_op0, 0, PLUS, code1,
5472 find_reloads_address_1 (mode, orig_op1, 1, PLUS, SCRATCH,
5479 find_reloads_address_1 (mode, orig_op1, 0, PLUS, code0,
5485 find_reloads_address_1 (mode, orig_op0, 0, PLUS, code1,
5492 && regno_ok_for_base_p (REGNO (op1), mode, PLUS, REG))
5495 && regno_ok_for_base_p (REGNO (op0), mode, PLUS, REG))
5497 else if (regno_ok_for_base_p (REGNO (op1), mode, PLUS, REG))
5498 find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH,
5501 else if (regno_ok_for_base_p (REGNO (op0), mode, PLUS, REG))
5502 find_reloads_address_1 (mode, orig_op1, 1, PLUS, SCRATCH,
5506 find_reloads_address_1 (mode, orig_op0, 0, PLUS, REG,
5510 find_reloads_address_1 (mode, orig_op1, 0, PLUS, REG,
5515 find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH,
5518 find_reloads_address_1 (mode, orig_op1, 0, PLUS, REG,
5526 find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH,
5529 find_reloads_address_1 (mode, orig_op1, 0, PLUS, REG,
5536 find_reloads_address_1 (mode, orig_op1, 1, PLUS, SCRATCH,
5539 find_reloads_address_1 (mode, orig_op0, 0, PLUS, REG,
5577 find_reloads_address_1 (mode, XEXP (op1, 1), 1, code, SCRATCH,
5619 base_reg_class (mode, code,
5637 base_reg_class (mode, code, index_code),
5701 || !REG_OK_FOR_CONTEXT (context, regno, mode, outer_code,
5880 || !REG_OK_FOR_CONTEXT (context, regno, mode, outer_code,
5913 if (!REG_OK_FOR_CONTEXT (context, regno, mode, outer_code,
5954 find_reloads_address_1 (mode, XEXP (x, i), context, code, SCRATCH,
5972 MODE is the mode to use, in case X is an integer constant.
5981 enum machine_mode mode, int opnum,
5990 tem = x = force_const_mem (mode, x);
5991 find_reloads_address (mode, &tem, XEXP (tem, 0), &XEXP (tem, 0),
6004 find_reloads_address (mode, &tem, XEXP (tem, 0), &XEXP (tem, 0),
6009 mode, VOIDmode, 0, 0, opnum, type);
6078 us to widen the mode of the memory. */
6105 original mode but not in a smaller mode. For
6196 /* Encapsulate RELOADREG so its machine mode matches what
6200 if (GET_MODE (reloadreg) != r->mode && r->mode != VOIDmode)
6201 reloadreg = reload_adjust_reg_for_mode (reloadreg, r->mode);
6218 offset must be a multiple of the SUBREG's mode. */
6268 r->mode = replacements[j].mode;
6276 r->mode = replacements[j].mode;
6328 if (r->mode != VOIDmode && GET_MODE (reloadreg) != r->mode)
6329 reloadreg = gen_rtx_REG (r->mode, REGNO (reloadreg));
6353 offset must be a multiple of the SUBREG's mode. */
6627 MODE is the machine mode of the value we want an equivalence for.
6628 If GOAL is nonzero and not VOIDmode, then it must have mode MODE.
6637 short *reload_reg_p, int goalreg, enum machine_mode mode)
6786 for (i = hard_regno_nregs[valueno][mode] - 1; i >= 0; i--)
6819 if (GET_MODE (value) != mode)
6828 + hard_regno_nregs[valueno][mode]),
6835 nregs = hard_regno_nregs[regno][mode];
6838 valuenregs = hard_regno_nregs[valueno][mode];
6903 || HARD_REGNO_CALL_PART_CLOBBERED (regno + i, mode))
6909 || HARD_REGNO_CALL_PART_CLOBBERED (valueno + i, mode))
7173 regno_clobbered_p (unsigned int regno, rtx insn, enum machine_mode mode,
7181 nregs = hard_regno_nregs[regno][mode];
7221 /* Find the low part, with mode MODE, of a hard regno RELOADREG. */
7223 reload_adjust_reg_for_mode (rtx reloadreg, enum machine_mode mode)
7227 if (GET_MODE (reloadreg) == mode)
7234 - (int) hard_regno_nregs[regno][mode];
7236 return gen_rtx_REG (mode, regno);