Lines Matching refs:offset
117 A natural register + offset address. The register satisfies
118 mips_valid_base_register_p and the offset is a const_arith_operand.
427 HOST_WIDE_INT gp_save_offset; /* offset from vfp to store gp registers */
428 HOST_WIDE_INT fp_save_offset; /* offset from vfp to store fp registers */
429 HOST_WIDE_INT gp_sp_offset; /* offset from new sp to store gp registers */
430 HOST_WIDE_INT fp_sp_offset; /* offset from new sp to store fp registers */
473 /* For EABI, the offset of the first register from GP_ARG_FIRST or
474 FP_ARG_FIRST. For other ABIs, the offset of the first register from
485 /* The offset from the start of the stack overflow area of the argument's
497 REG is the base register and OFFSET is the constant offset.
511 rtx offset;
1285 /* Split X into a base and a constant offset, storing them in *BASE
1289 mips_split_const (rtx x, rtx *base, HOST_WIDE_INT *offset)
1291 *offset = 0;
1298 *offset += INTVAL (XEXP (x, 1));
1311 HOST_WIDE_INT offset;
1313 mips_split_const (x, &x, &offset);
1324 mips_offset_within_object_p (rtx symbol, HOST_WIDE_INT offset)
1330 && offset >= 0
1331 && offset < (int) GET_MODE_SIZE (get_pool_mode (symbol)))
1335 && offset >= 0
1336 && offset < int_size_in_bytes (TREE_TYPE (SYMBOL_REF_DECL (symbol))))
1342 && ((unsigned HOST_WIDE_INT) offset + SYMBOL_REF_BLOCK_OFFSET (symbol)
1357 HOST_WIDE_INT offset;
1359 mips_split_const (x, &x, &offset);
1371 if (offset == 0)
1374 /* Check whether a nonzero offset is valid for the underlying
1384 sign-extended. In this case we can't allow an arbitrary offset
1387 return mips_offset_within_object_p (x, offset);
1389 /* In other cases the relocations can handle any offset. */
1402 /* Make sure that the offset refers to something within the
1404 PC- or GP-relative offset is within the 16-bit limit. */
1405 return mips_offset_within_object_p (x, offset);
1410 16-bit offset. Larger offsets may lead to GOT overflow. */
1411 return SMALL_OPERAND (offset);
1542 info->offset = const0_rtx;
1548 info->offset = XEXP (x, 1);
1550 && const_arith_operand (info->offset, VOIDmode));
1555 info->offset = XEXP (x, 1);
1559 adds an offset to a LO_SUM must prove that the offset will not
1565 info->symbol_type = mips_classify_symbolic_expression (info->offset);
1611 HOST_WIDE_INT offset;
1627 mips_split_const (x, &base, &offset);
1628 if (symbolic_operand (base, VOIDmode) && SMALL_OPERAND (offset))
1722 /* Check whether the offset is a 16- or 32-bit value. */
1748 Usually the offset in an unextended instruction is a 5-bit field.
1749 The offset is unsigned and shifted left once for HIs, twice
1754 mips16_unextended_reference_p (enum machine_mode mode, rtx base, rtx offset)
1757 && GET_CODE (offset) == CONST_INT
1758 && INTVAL (offset) >= 0
1759 && (INTVAL (offset) & (GET_MODE_SIZE (mode) - 1)) == 0)
1762 return INTVAL (offset) < 256 * GET_MODE_SIZE (mode);
1763 return INTVAL (offset) < 32 * GET_MODE_SIZE (mode);
1792 && !mips16_unextended_reference_p (mode, addr.reg, addr.offset))
1816 HOST_WIDE_INT offset;
1854 /* Otherwise try splitting the constant into a base and offset.
1857 mips_split_const (x, &x, &offset);
1858 if (offset != 0)
1863 if (SMALL_OPERAND (offset))
1866 return n + 1 + mips_build_integer (codes, offset);
1967 HOST_WIDE_INT offset;
1969 mips_split_const (address, &base, &offset);
1972 return plus_constant (gen_rtx_CONST (Pmode, base), offset);
2001 mips_add_offset (rtx temp, rtx reg, HOST_WIDE_INT offset)
2003 if (!SMALL_OPERAND (offset))
2008 /* Load the full offset into a register so that we can use
2010 high = GEN_INT (offset);
2011 offset = 0;
2015 /* Leave OFFSET as a 16-bit offset and put the excess in HIGH. */
2016 high = GEN_INT (CONST_HIGH_PART (offset));
2017 offset = CONST_LOW_PART (offset);
2022 return plus_constant (reg, offset);
2321 HOST_WIDE_INT offset;
2343 /* If we have (const (plus symbol offset)), load the symbol first
2344 and then add in the offset. This is usually better than forcing
2346 mips_split_const (src, &base, &offset);
2348 && offset != 0
2349 && (!no_new_pseudos || SMALL_OPERAND (offset)))
2352 emit_move_insn (dest, mips_add_offset (0, base, offset));
3540 HOST_WIDE_INT offset, delta;
3565 for (offset = 0, i = 0; offset + delta <= length; offset += delta, i++)
3569 emit_move_insn (regs[i], adjust_address (src, mode, offset));
3572 rtx part = adjust_address (src, BLKmode, offset);
3579 for (offset = 0, i = 0; offset + delta <= length; offset += delta, i++)
3581 emit_move_insn (adjust_address (dest, mode, offset), regs[i]);
3584 rtx part = adjust_address (dest, BLKmode, offset);
3590 if (offset < length)
3592 src = adjust_address (src, BLKmode, offset);
3593 dest = adjust_address (dest, BLKmode, offset);
3594 move_by_pieces (dest, src, length - offset,
3822 /* Work out the offset of a stack argument. */
4127 /* Set OFF to the offset from virtual_incoming_args_rtx of
4291 /* Emit code to initialize GOFF, the offset from GTOP of the
4297 /* Likewise emit code to initialize FOFF, the offset from FTOP
4350 OFF be the offset from TOP of the next register;
5338 mips_debugger_offset (rtx addr, HOST_WIDE_INT offset)
5343 if (offset == 0)
5344 offset = INTVAL (offset2);
5357 offset = offset - frame_size;
5367 return offset;
5721 HOST_WIDE_INT offset;
5728 mips_split_const (op, &base, &offset);
5730 op = plus_constant (UNSPEC_ADDRESS (base), offset);
5751 print_operand (file, addr.offset, 0);
5756 print_operand (file, addr.offset, 'R');
6508 HOST_WIDE_INT offset;
6510 offset = (args_size + cprestore_size + var_size
6512 cfun->machine->frame.gp_sp_offset = offset;
6513 cfun->machine->frame.gp_save_offset = offset - total_size;
6523 HOST_WIDE_INT offset;
6525 offset = (args_size + cprestore_size + var_size
6528 cfun->machine->frame.fp_sp_offset = offset;
6529 cfun->machine->frame.fp_save_offset = offset - total_size;
6549 HOST_WIDE_INT offset;
6553 /* Set OFFSET to the offset from the stack pointer. */
6557 offset = 0;
6561 offset = (cfun->machine->frame.total_size
6570 offset -= cfun->machine->frame.args_size;
6572 return offset;
6589 mode and OFFSET is the offset of its save slot from the current
6594 HOST_WIDE_INT offset, mips_save_restore_fn fn)
6598 mem = gen_frame_mem (mode, plus_constant (stack_pointer_rtx, offset));
6605 SP_OFFSET is the offset of the current stack pointer from the start
6614 HOST_WIDE_INT offset;
6621 offset = cfun->machine->frame.gp_sp_offset - sp_offset;
6625 mips_save_restore_reg (gpr_mode, regno, offset, fn);
6626 offset -= GET_MODE_SIZE (gpr_mode);
6631 offset = cfun->machine->frame.fp_sp_offset - sp_offset;
6638 mips_save_restore_reg (fpr_mode, regno, offset, fn);
6639 offset -= GET_MODE_SIZE (fpr_mode);
6683 rtx addr, offset, incoming_address;
6698 offset = mips_unspec_address (addr, SYMBOL_GOTOFF_LOADGP);
6700 emit_insn (gen_loadgp (offset, incoming_address));
6950 rtx offset = GEN_INT (cfun->machine->frame.args_size);
6955 offset))) = 1;
6958 emit_move_insn (MIPS_PROLOGUE_TEMP (Pmode), offset);
7070 frame pointer offset used by mips16 code. */
7232 rtx offset = GEN_INT (delta);
7235 emit_move_insn (temp1, offset);
7236 offset = temp1;
7238 emit_insn (gen_add3_insn (this, this, offset));
7252 /* Load the offset and add it to THIS. */
7528 MODE1 and OFFSET1 are the mode and byte offset for the first value,
7714 HOST_WIDE_INT offset;
7719 mips_split_const (x, &x, &offset);
10479 unsigned int offset;
10689 offset = 0;
10696 d - m->bdesc + offset,
10698 offset += m->size;
10818 rtx offset, condition, cmp_result, ops[MAX_RECOG_OPERANDS];
10856 offset = GEN_INT (builtin_type == MIPS_BUILTIN_CMP_UPPER);
10857 condition = gen_single_cc (cmp_result, offset);