Lines Matching +defs:label +defs:offset
78 /* Extract the symbol or label from UNSPEC wrapper X. */
182 A natural register + offset address. The register satisfies
183 mips_valid_base_register_p and the offset is a const_arith_operand.
342 /* For EABI, the offset of the first register from GP_ARG_FIRST or
343 FP_ARG_FIRST. For other ABIs, the offset of the first register from
354 /* The offset from the start of the stack overflow area of the argument's
365 REG is the base register and OFFSET is the constant offset.
376 rtx offset;
459 /* The offset of the CFA from the stack pointer while restoring
2087 code and if we know that the label is in the current function's
2162 rtx offset;
2164 split_const (x, &x, &offset);
2175 mips_offset_within_alignment_p (rtx x, HOST_WIDE_INT offset)
2180 return IN_RANGE (offset, 0, align - 1);
2190 rtx offset;
2192 split_const (x, &x, &offset);
2207 if (offset == const0_rtx)
2210 /* Check whether a nonzero offset is valid for the underlying
2220 sign-extended. In this case we can't allow an arbitrary offset
2223 return offset_within_block_p (x, INTVAL (offset));
2225 /* In other cases the relocations can handle any offset. */
2238 /* Make sure that the offset refers to something within the
2240 PC- or GP-relative offset is within the 16-bit limit. */
2241 return offset_within_block_p (x, INTVAL (offset));
2246 address, and we will apply a 16-bit offset after loading it.
2248 GOT entries for a 16-bit offset, but larger offsets may lead
2250 return SMALL_INT (offset);
2255 offset is only valid if we know it won't lead to such a carry. */
2256 return mips_offset_within_alignment_p (x, INTVAL (offset));
2408 rtx base, offset;
2428 split_const (x, &base, &offset);
2436 if (SMALL_INT (offset) && mips_symbol_insns (type, MAX_MACHINE_MODE) > 0)
2573 info->offset = const0_rtx;
2579 info->offset = XEXP (x, 1);
2581 && mips_valid_offset_p (info->offset, mode));
2586 info->offset = XEXP (x, 1);
2590 adds an offset to a LO_SUM must prove that the offset will not
2597 = mips_classify_symbolic_expression (info->offset, SYMBOL_CONTEXT_MEM);
2655 rtx offset = XEXP (addr, 0);
2656 if (GET_CODE (offset) == MULT
2657 && REG_P (XEXP (offset, 0))
2658 && CONST_INT_P (XEXP (offset, 1))
2659 && INTVAL (XEXP (offset, 1)) == 4)
2695 Usually the offset in an unextended instruction is a 5-bit field.
2696 The offset is unsigned and shifted left once for LH and SH, twice
2702 unsigned HOST_WIDE_INT offset)
2704 if (mode != BLKmode && offset % GET_MODE_SIZE (mode) == 0)
2707 return offset < 256U * GET_MODE_SIZE (mode);
2708 return offset < 32U * GET_MODE_SIZE (mode);
2743 if (mips_signed_immediate_p (INTVAL (addr.offset), 10,
2751 UINTVAL (addr.offset)))
2786 /* Return the scale shift that applied to MSA LD/ST address offset. */
2800 if it is based on a MIPS16 register, and if the offset satisfies
2812 && offset_predicate (addr.offset, mode));
2826 && uw5_operand (addr.offset, mode));
2829 /* Return true if X is a legitimate address with a 12-bit offset.
2839 && CONST_INT_P (addr.offset)
2840 && UMIPS_12BIT_OFFSET_P (INTVAL (addr.offset)));
2843 /* Return true if X is a legitimate address with a 9-bit offset.
2853 && CONST_INT_P (addr.offset)
2854 && MIPS_9BIT_OFFSET_P (INTVAL (addr.offset)));
2866 rtx offset;
2911 /* Otherwise try splitting the constant into a base and offset.
2912 If the offset is a 16-bit value, we can load the base address
2913 into a register and then use (D)ADDIU to add in the offset.
2914 If the offset is larger, we can load the base and offset
2919 split_const (x, &x, &offset);
2920 if (offset != 0)
2925 if (SMALL_INT (offset))
2928 return n + 1 + mips_build_integer (codes, INTVAL (offset));
3162 /* Wrap symbol or label BASE in an UNSPEC address of type SYMBOL_TYPE,
3166 mips_unspec_address_offset (rtx base, rtx offset,
3171 if (offset != const0_rtx)
3172 base = gen_rtx_PLUS (Pmode, base, offset);
3182 rtx base, offset;
3184 split_const (address, &base, &offset);
3185 return mips_unspec_address_offset (base, offset, symbol_type);
3194 rtx base, offset;
3196 split_const (op, &base, &offset);
3198 op = plus_constant (Pmode, UNSPEC_ADDRESS (base), INTVAL (offset));
3415 mips_add_offset (rtx temp, rtx reg, HOST_WIDE_INT offset)
3417 if (!SMALL_OPERAND (offset))
3423 /* Load the full offset into a register so that we can use
3425 high = GEN_INT (offset);
3426 offset = 0;
3430 /* Leave OFFSET as a 16-bit offset and put the excess in HIGH.
3433 high = gen_int_mode (CONST_HIGH_PART (offset), Pmode);
3434 offset = CONST_LOW_PART (offset);
3439 return plus_constant (Pmode, reg, offset);
3511 rtx dest, v0, tp, tmp1, tmp2, eqv, offset;
3544 offset = mips_unspec_address (loc, SYMBOL_DTPREL);
3548 dest = gen_rtx_LO_SUM (Pmode, tmp2, offset);
3551 dest = expand_binop (Pmode, add_optab, tmp1, offset,
3570 offset = mips_unspec_address (loc, SYMBOL_TPREL);
3574 dest = gen_rtx_LO_SUM (Pmode, tmp2, offset);
3577 dest = expand_binop (Pmode, add_optab, tmp1, offset,
3634 HOST_WIDE_INT offset;
3644 mips_split_plus (x, &base, &offset);
3645 if (offset != 0)
3649 addr = mips_add_offset (NULL, base, offset);
3694 rtx base, offset;
3717 /* If we have (const (plus symbol offset)), and that expression cannot
3718 be forced into memory, load the symbol first and add in the offset.
3721 split_const (src, &base, &offset);
3722 if (offset != const0_rtx
3727 mips_emit_move (dest, mips_add_offset (NULL, base, INTVAL (offset)));
4607 /* True if this is a label, false if it is code. */
4666 /* Add the given label definition to the current multi-insn sequence.
4670 mips_multi_add_label (const char *label)
4676 member->format = label;
4733 unsigned int byte, offset;
4748 offset = (UNITS_PER_WORD < UNITS_PER_HWFPVALUE ? high_p : byte != 0);
4749 return gen_rtx_REG (word_mode, REGNO (op) + offset);
5968 /* Work out the offset of a stack argument. */
6396 MODE1 and OFFSET1 are the mode and byte offset for the first value,
6617 /* Set OFF to the offset from virtual_incoming_args_rtx of
6779 /* Emit code to initialize GOFF, the offset from GTOP of the
6785 /* Likewise emit code to initialize FOFF, the offset from FTOP
6918 OFF be the offset from TOP of the next register;
8060 HOST_WIDE_INT offset, delta;
8095 for (offset = 0, i = 0; offset + delta <= length; offset += delta, i++)
8099 mips_emit_move (regs[i], adjust_address (src, mode, offset));
8102 rtx part = adjust_address (src, BLKmode, offset);
8110 for (offset = 0, i = 0; offset + delta <= length; offset += delta, i++)
8112 mips_emit_move (adjust_address (dest, mode, offset), regs[i]);
8115 rtx part = adjust_address (dest, BLKmode, offset);
8122 if (offset < length)
8124 src = adjust_address (src, BLKmode, offset);
8125 dest = adjust_address (dest, BLKmode, offset);
8126 move_by_pieces (dest, src, length - offset,
8159 rtx_code_label *label;
8176 label = gen_label_rtx ();
8177 emit_label (label);
8189 emit_jump_insn (gen_cbranchdi4 (test, src_reg, final_src, label));
8191 emit_jump_insn (gen_cbranchsi4 (test, src_reg, final_src, label));
8236 rtx_code_label *label, *end_label;
8263 label = gen_label_rtx ();
8264 emit_label (label);
8276 emit_jump_insn (gen_condjump (cmp_result, label));
8319 /* Work out the byte offset of the QImode or HImode value,
9042 'b' Print the address of a memory operand, without offset.
9294 mips_print_operand (file, addr.offset, 0);
9299 mips_print_operand_reloc (file, addr.offset, SYMBOL_CONTEXT_MEM,
9477 mips_debugger_offset (rtx addr, HOST_WIDE_INT offset)
9482 if (offset == 0)
9483 offset = INTVAL (offset2);
9489 offset -= cfun->machine->frame.total_size;
9491 offset += cfun->machine->frame.hard_frame_pointer_offset;
9494 return offset;
9729 /* Emit either a label, .comm, or .lcomm directive. When using assembler
9814 definitions except that it uses mips_declare_object to emit the label. */
10177 HOST_WIDE_INT offset, required_offset;
10194 mips_split_plus (addr, &base, &offset);
10200 if (offset != required_offset)
10265 HOST_WIDE_INT offset, unsigned int regno)
10270 offset));
10301 byte offset from the bottom of the allocated stack area. */
10309 HOST_WIDE_INT offset, top_offset;
10340 offset = top_offset + i * UNITS_PER_WORD;
10341 set = mips16e_save_restore_reg (restore_p, true, offset,
10347 offset = top_offset;
10353 offset -= UNITS_PER_WORD;
10354 set = mips16e_save_restore_reg (restore_p, false, offset, regno);
10360 /* Tell the caller what offset it should use for the remaining registers. */
10361 *offset_ptr = size + (offset - top_offset);
10378 HOST_WIDE_INT top_offset, save_offset, offset;
10407 possibly-zero constant offset. */
10408 mips_split_plus (XEXP (mem, 0), &base, &offset);
10418 if (offset == top_offset + nargs * UNITS_PER_WORD
10421 else if (offset == save_offset)
11028 HOST_WIDE_INT offset, size;
11107 offset = frame->args_size + frame->cprestore_size;
11111 offset += frame->var_size;
11144 offset += MIPS_STACK_ALIGN (frame->num_gp * UNITS_PER_WORD);
11145 frame->gp_sp_offset = offset - UNITS_PER_WORD;
11161 offset += MIPS_STACK_ALIGN (frame->num_fp * UNITS_PER_FPREG);
11162 frame->fp_sp_offset = offset - UNITS_PER_HWFPVALUE;
11195 offset += frame->num_acc * 2 * UNITS_PER_WORD;
11196 frame->acc_sp_offset = offset - UNITS_PER_WORD;
11202 offset += frame->num_cop0_regs * UNITS_PER_WORD;
11203 frame->cop0_sp_offset = offset - UNITS_PER_WORD;
11230 offset = 0;
11236 offset += MIPS_STACK_ALIGN (cfun->machine->varargs_size);
11237 frame->arg_pointer_offset = offset;
11240 offset += crtl->args.pretend_args_size;
11241 frame->total_size = offset;
11245 frame->gp_save_offset = frame->gp_sp_offset - offset;
11247 frame->fp_save_offset = frame->fp_sp_offset - offset;
11249 frame->acc_save_offset = frame->acc_sp_offset - offset;
11251 frame->cop0_save_offset = frame->cop0_sp_offset - offset;
11312 HOST_WIDE_INT offset;
11316 /* Set OFFSET to the offset from the end-of-prologue stack pointer. */
11321 offset = (cfun->machine->frame.args_size
11325 offset = 0;
11329 offset = cfun->machine->frame.arg_pointer_offset;
11337 offset -= cfun->machine->frame.hard_frame_pointer_offset;
11339 return offset;
11407 mips_get_cprestore_base_and_offset (rtx *base, HOST_WIDE_INT *offset,
11428 *offset = frame->args_size - frame->hard_frame_pointer_offset;
11433 *offset = frame->args_size;
11459 HOST_WIDE_INT offset;
11461 mips_get_cprestore_base_and_offset (&base, &offset, load_p);
11462 return gen_frame_mem (Pmode, mips_add_offset (temp, base, offset));
11466 slot MEM. OFFSET is the offset that MEM applies to the base register.
11472 mips_save_gp_to_cprestore_slot (rtx mem, rtx offset, rtx gp, rtx temp)
11477 emit_insn (PMODE_INSN (gen_cprestore, (mem, offset)));
11517 mode and OFFSET is the offset of its save slot from the current
11522 HOST_WIDE_INT offset, mips_save_restore_fn fn)
11527 offset));
11532 SP_OFFSET is the offset of the current stack pointer from the start
11538 HOST_WIDE_INT offset;
11541 offset = cfun->machine->frame.acc_sp_offset - sp_offset;
11544 mips_save_restore_reg (word_mode, LO_REGNUM, offset, fn);
11545 offset -= UNITS_PER_WORD;
11546 mips_save_restore_reg (word_mode, HI_REGNUM, offset, fn);
11547 offset -= UNITS_PER_WORD;
11554 mips_save_restore_reg (word_mode, regno, offset, fn);
11555 offset -= UNITS_PER_WORD;
11600 as many GPRs in *MASK as possible. *OFFSET is the offset from the
11608 unsigned *mask, HOST_WIDE_INT *offset)
11624 /* Get the offset of the lowest save slot. */
11626 this_offset = *offset - UNITS_PER_WORD * (nregs - 1);
11639 HOST_WIDE_INT offset = this_offset + j * UNITS_PER_WORD;
11640 mem = gen_frame_mem (SImode, plus_constant (Pmode, this_base, offset));
11657 HOST_WIDE_INT offset = this_offset + j * UNITS_PER_WORD;
11659 mem = gen_frame_mem (SImode, plus_constant (Pmode, this_base, offset));
11675 /* Adjust the last offset. */
11676 *offset -= UNITS_PER_WORD * nregs;
11682 SP_OFFSET is the offset of the current stack pointer from the start
11692 HOST_WIDE_INT offset;
11699 offset = frame->gp_sp_offset - sp_offset;
11703 umips_build_save_restore (fn, &mask, &offset);
11708 /* Record the ra offset for use by mips_function_profiler. */
11710 cfun->machine->frame.ra_fp_offset = offset + sp_offset;
11711 mips_save_restore_reg (word_mode, regno, offset, fn);
11712 offset -= UNITS_PER_WORD;
11717 offset = cfun->machine->frame.fp_sp_offset - sp_offset;
11728 mips_save_restore_reg (SFmode, regno + 1, offset, fn);
11730 mips_save_restore_reg (SFmode, regno, offset, fn);
11733 mips_save_restore_reg (fpr_mode, regno, offset, fn);
11734 offset -= GET_MODE_SIZE (fpr_mode);
11974 rtx addr, offset, incoming_address, base, index, pic_reg;
11995 offset = mips_unspec_address (addr, SYMBOL_GOTOFF_LOADGP);
11998 (pic_reg, offset, incoming_address)));
12218 HOST_WIDE_INT offset;
12226 rtx insn = mips16e_build_save_restore (false, &mask, &offset,
12236 offset -= UNITS_PER_WORD;
12238 offset, mips_save_reg);
12245 HOST_WIDE_INT offset;
12274 offset = frame->cop0_sp_offset - size;
12279 offset));
12281 offset -= UNITS_PER_WORD;
12298 offset));
12300 offset -= UNITS_PER_WORD;
12399 HOST_WIDE_INT offset;
12401 offset = frame->hard_frame_pointer_offset;
12402 if (offset == 0)
12407 else if (SMALL_OPERAND (offset))
12410 stack_pointer_rtx, GEN_INT (offset));
12415 mips_emit_move (MIPS_PROLOGUE_TEMP (Pmode), GEN_INT (offset));
12422 plus_constant (Pmode, stack_pointer_rtx, offset)));
12432 HOST_WIDE_INT offset;
12434 mips_get_cprestore_base_and_offset (&base, &offset, false);
12435 mem = gen_frame_mem (Pmode, plus_constant (Pmode, base, offset));
12437 temp = (SMALL_OPERAND (offset)
12441 (mem, GEN_INT (offset), gp, temp)));
12443 mips_get_cprestore_base_and_offset (&base, &offset, true);
12444 mem = gen_frame_mem (Pmode, plus_constant (Pmode, base, offset));
12493 mips_epilogue_set_cfa (rtx reg, HOST_WIDE_INT offset)
12498 if (reg != mips_epilogue.cfa_reg || offset != mips_epilogue.cfa_offset)
12502 plus_constant (Pmode, reg, offset),
12505 mips_epilogue.cfa_offset = offset;
12543 mips_deallocate_stack (rtx base, rtx offset, HOST_WIDE_INT new_frame_size)
12545 if (base == stack_pointer_rtx && offset == const0_rtx)
12549 if (offset == const0_rtx)
12556 emit_insn (gen_add3_insn (base, base, offset));
12562 emit_insn (gen_add3_insn (stack_pointer_rtx, base, offset));
12657 HOST_WIDE_INT offset;
12662 restore = mips16e_build_save_restore (true, &mask, &offset, 0, step2);
12668 offset -= UNITS_PER_WORD;
12669 mips_save_restore_reg (word_mode, regno, offset, mips_restore_reg);
12687 HOST_WIDE_INT offset;
12690 offset = frame->cop0_sp_offset - (frame->total_size - step2);
12695 offset));
12697 offset -= UNITS_PER_WORD;
12706 offset));
12708 offset -= UNITS_PER_WORD;
13600 /* Build up a multi-insn sequence that loads label TARGET into $AT. */
13606 HOST_WIDE_INT offset;
13626 mips_get_cprestore_base_and_offset (&base, &offset, true);
13627 if (!SMALL_OPERAND (offset))
13629 intop = GEN_INT (CONST_HIGH_PART (offset));
13634 offset = CONST_LOW_PART (offset);
13636 intop = GEN_INT (offset);
13651 /* Return the number of instructions needed to load a label into $AT. */
13665 of a label into $1. */
14237 /* Output the branch-back label. */
14352 /* Output the exit label, if needed. */
17264 rtx offset, condition, cmp_result;
17283 offset = GEN_INT (builtin_type == MIPS_BUILTIN_CMP_UPPER);
17284 condition = gen_single_cc (cmp_result, offset);
17377 rtx_code_label *label;
17391 /* Add constant VALUE to POOL and return its label. MODE is the
17402 existing label, otherwise leave P pointing to the place where the
17411 return (*p)->label;
17441 c->label = gen_label_rtx ();
17445 return c->label;
17477 label number in the `consttable' and `consttable_end' insns emitted
17485 int label_num = constants ? CODE_LABEL_NUMBER (constants->label) : 0;
17502 insn = emit_label_after (c->label, insn);
17533 the constant to POOL and rewrite *X to use the constant's label. */
17538 rtx base, offset;
17539 rtx_code_label *label;
17541 split_const (*x, &base, &offset);
17544 label = mips16_add_constant (pool, copy_rtx (get_pool_constant (base)),
17546 base = gen_rtx_LABEL_REF (Pmode, label);
17547 *x = mips_unspec_address_offset (base, offset, SYMBOL_PC_RELATIVE);
17552 label instead. */
17635 rtx_code_label *label;
17638 label = gen_label_rtx ();
17640 jump = emit_jump_insn_before (gen_jump (label), insn);
17641 JUMP_LABEL (jump) = label;
17642 LABEL_NUSES (label) = 1;
17645 emit_label_after (label, barrier);
17669 at a known offset from the incoming stack pointer. */
17709 /* LO_SUMs can be offset from HIGHs, if we know they won't
17792 rtx base, offset;
17812 split_const (x, &base, &offset);
17813 return offset_within_block_p (base, INTVAL (offset));
17821 r10k_safe_mem_expr_p (tree expr, unsigned HOST_WIDE_INT offset)
17833 offset += bitoffset / BITS_PER_UNIT;
17834 return offset < tree_to_uhwi (DECL_SIZE_UNIT (inner));
18448 /* We can't predict the processor state after a call or label. */
18727 /* See whether INSN is an aligned label. */
18737 the largest offset applied to BASE by all such LO_SUMs. */
18740 HOST_WIDE_INT offset;
18787 rtx base, offset;
18791 /* Split X into a base and offset. */
18792 split_const (x, &base, &offset);
18808 entry->offset = INTVAL (offset);
18813 if (INTVAL (offset) > entry->offset)
18814 entry->offset = INTVAL (offset);
18817 return INTVAL (offset) <= entry->offset;
19422 /* Create a branch-around label for the original
19611 rtx offset = GEN_INT (delta);
19614 mips_emit_move (temp1, offset);
19615 offset = temp1;
19617 emit_insn (gen_add3_insn (this_rtx, this_rtx, offset));
19631 /* Load the offset and add it to THIS_RTX. */
20716 pool's initial label number in the local symbol produced so that
20718 symbols. The label number is carried by the `consttable' insn
20737 of a pool table use the pool's initial label number to keep symbols
20738 unique. The label number is carried by the `consttable_end' insn
20838 constant offset. Determine if the offset is in range. */
20882 HOST_WIDE_INT offset;
20894 mips_split_plus (XEXP (mem, 0), &base, &offset);
20916 s += sprintf (s, "%d(%s)", (int)offset, reg_names[REGNO (base)]);
20921 offset of MEM2 equals the offset of MEM1 plus 4. FIRST_REG is the
21212 where 12 is the offset of "1:" from the start of the code block. */