Lines Matching refs:offset
79 The CFA register and offset, which may change during the course
174 Information instructions. The register number, offset
213 HOST_WIDE_INT offset;
256 /* The size in bytes of a DWARF field indicating an offset or length
464 HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
477 if (offset < 0)
480 emit_move_insn (adjust_address (mem, mode, offset),
496 HOST_WIDE_INT offset = i * GET_MODE_SIZE (mode);
498 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
663 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
666 loc->offset
674 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
678 loc->offset
697 loc->offset = 0;
715 /* The register used for saving registers to the stack, and its offset
730 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
736 loc.offset = offset;
746 && loc1->offset == loc2->offset
765 cfa_store.offset = loc.offset;
778 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
779 the CFA register did not change but the offset did. */
780 if (loc.offset < 0)
782 HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT;
783 gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset);
791 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
795 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
796 else if (loc.offset == old_cfa.offset
802 offset has not changed. */
810 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
812 the specified offset. */
813 if (loc.offset < 0)
815 HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT;
816 gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset);
826 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
833 register-offset pair is available. */
850 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
867 /* If we get an offset that is not a multiple of
871 HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT;
873 gcc_assert (check_offset * DWARF_CIE_DATA_ALIGNMENT == offset);
876 offset /= DWARF_CIE_DATA_ALIGNMENT;
877 if (offset < 0)
880 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
932 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
934 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
941 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
943 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
962 HOST_WIDE_INT offset = 0;
978 offset = 0;
983 offset = INTVAL (XEXP (rtl, 1));
988 offset = -INTVAL (XEXP (rtl, 1));
998 /* The return address is at some offset from any value we can
1000 ignore the offset for now; it doesn't matter for unwinding frames. */
1010 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
1021 HOST_WIDE_INT offset = 0;
1033 offset = INTVAL (XEXP (src, 1));
1035 offset = -offset;
1053 offset = -INTVAL (val);
1062 offset = GET_MODE_SIZE (GET_MODE (dest));
1071 offset = -GET_MODE_SIZE (GET_MODE (dest));
1083 return offset;
1093 HOST_WIDE_INT offset;
1134 offset = -args_size;
1136 offset = args_size;
1140 offset = stack_adjust_offset (PATTERN (insn));
1146 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1148 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i));
1153 if (offset == 0)
1157 cfa.offset += offset;
1160 offset = -offset;
1163 args_size += offset;
1209 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1228 q->cfa_offset = offset;
1343 or setting up the store_reg. The "offset" field holds the integer
1344 value, not an offset. */
1381 offset is nonzero, we are saving the CFA, so we assume we have to
1382 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
1391 consists of a register and an offset.
1393 cfa_store.offset is the offset from the value of
1395 cfa_temp register holding an integral value. cfa_temp.offset
1402 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
1403 cfa_temp.offset.
1407 and cfa_temp.offset.
1412 Rules 10-14: Save a register to the stack. Define offset as the
1424 cfa.offset unchanged
1426 cfa_temp.offset = cfa.offset
1432 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1433 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1447 cfa_temp.offset = cfa.offset
1454 cfa_store.offset = cfa.offset - cfa_temp.offset
1459 cfa_temp.offset = <const_int>
1464 cfa_temp.offset |= <const_int>
1473 cfa_temp.offset = <const_int>
1477 effects: cfa_store.offset -= <const_int>
1478 cfa.offset = cfa_store.offset if cfa.reg == sp
1480 cfa.base_offset = -cfa_store.offset
1484 effects: cfa_store.offset += -/+ mode_size(mem)
1485 cfa.offset = cfa_store.offset if cfa.reg == sp
1487 cfa.base_offset = -cfa_store.offset
1494 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1499 cfa.base_offset = -{cfa_store,cfa_temp}.offset
1504 cfa.base_offset = -cfa_temp.offset
1505 cfa_temp.offset -= mode_size(mem)
1515 HOST_WIDE_INT offset;
1567 cfa_temp.offset = cfa.offset;
1590 offset = INTVAL (XEXP (src, 1));
1595 offset = cfa_temp.offset;
1614 offset = -offset;
1616 cfa.offset += offset;
1618 cfa_store.offset += offset;
1623 /* Either setting the FP from an offset of the SP,
1630 offset = INTVAL (XEXP (src, 1));
1632 offset = -offset;
1633 cfa.offset += offset;
1647 offset = - INTVAL (XEXP (src, 1));
1648 cfa.offset += offset;
1652 cfa_temp.offset = cfa.offset;
1664 cfa_store.offset = cfa.offset - cfa_temp.offset;
1672 cfa_temp.offset = INTVAL (XEXP (src, 1));
1682 cfa_temp.offset = INTVAL (src);
1693 cfa_temp.offset |= INTVAL (XEXP (src, 1));
1729 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
1734 cfa_store.offset += offset;
1736 cfa.offset = cfa_store.offset;
1738 offset = -cfa_store.offset;
1744 offset = GET_MODE_SIZE (GET_MODE (dest));
1746 offset = -offset;
1751 cfa_store.offset += offset;
1753 cfa.offset = cfa_store.offset;
1755 offset = -cfa_store.offset;
1759 /* With an offset. */
1768 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1770 offset = -offset;
1775 offset -= cfa_store.offset;
1779 offset -= cfa_temp.offset;
1785 /* Without an offset. */
1791 offset = -cfa_store.offset;
1795 offset = -cfa_temp.offset;
1804 offset = -cfa_temp.offset;
1805 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
1818 if (cfa.offset == 0)
1824 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
1838 cfa.base_offset = offset;
1846 queue_reg_save (label, src, NULL_RTX, offset);
1882 cfa_temp.offset = 0;
2309 int offset = ( 4 /* Length */
2318 int pad = -offset & (PTR_SIZE - 1);
2392 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
2395 debug_frame_section, "FDE CIE offset");
2466 int offset = ( 4 /* Length */
2467 + 4 /* CIE offset */
2470 int pad = -offset & (PTR_SIZE - 1);
3309 int offset;
3312 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
3314 dw2_asm_output_data (2, offset, NULL);
3458 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
3462 offset += cfa->offset;
3481 if (offset != 0)
3483 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
3489 if (offset == 0)
3495 head = new_loc_descr (DW_OP_breg0 + cfa->reg, offset, 0);
3497 head = new_loc_descr (DW_OP_bregx, cfa->reg, offset);
3510 cfa->offset = 0;
3601 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
3845 /* Minimum line offset in a special line info. opcode.
3863 the offset of each DIE within the .debug_info section. */
5252 /* Add a section offset attribute value to a DIE, an offset into the
5267 /* Add a section offset attribute value to a DIE, an offset into the
5282 /* Add an offset attribute value to a DIE. */
5286 unsigned HOST_WIDE_INT offset)
5292 attr.dw_attr_val.v.val_offset = offset;
5300 long unsigned int offset)
5306 attr.dw_attr_val.v.val_offset = offset;
5763 fprintf (outfile, " offset: %ld\n", die->die_offset);
5776 fprintf (outfile, "offset");
6723 DIEs in the same CU will be marked. We used to clear out the offset
7311 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
7439 "DIE offset");
7553 /* Add a new entry to .debug_ranges. Return the offset at which it
8793 /* Return a location descriptor that designates a base+offset location. */
8796 based_loc_descr (rtx reg, HOST_WIDE_INT offset)
8812 offset += INTVAL (XEXP (elim, 1));
8817 offset += frame_pointer_fb_offset;
8819 return new_loc_descr (DW_OP_fbreg, offset, 0);
8825 return new_loc_descr (DW_OP_breg0 + regno, offset, 0);
8827 return new_loc_descr (DW_OP_bregx, regno, offset);
8830 /* Return true if this RTL expression describes a base+offset calculation. */
9294 tree obj, offset;
9300 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
9311 if (offset != NULL_TREE)
9313 /* Variable offset. */
9314 add_loc_descr (&ret, loc_descriptor_from_tree_1 (offset, 0));
9628 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
9630 or return 0 if we are unable to determine what that offset is, either
9632 because the offset is actually variable. (We can't handle the latter case
9680 bit offset (relative to the start of the containing structure type) of the
9682 the byte offset value for the start of the "containing object" of a
9709 object" 64-bit field at bit-offset zero within the structure type.)
9765 represents a bit-field, the "offset" part of this special location
9785 HOST_WIDE_INT offset;
9794 aren't at a fixed offset from all (sub)objects of the same
9795 type. We need to extract the appropriate offset from our
9812 /* Calculate the address of the offset. */
9813 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
9814 gcc_assert (offset < 0);
9816 tmp = int_loc_descriptor (-offset);
9821 /* Extract the offset. */
9830 offset = tree_low_cst (BINFO_OFFSET (decl), 0);
9833 offset = field_byte_offset (decl);
9845 operator correctly. It works only if we leave the offset on the
9852 loc_descr = new_loc_descr (op, offset, 0);
10335 int offset = (UNITS_PER_WORD
10339 plus_constant (XEXP (rtl, 0), offset));
10354 fact we are not. We need to adjust the offset of the
10564 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
10579 next_cfa.offset = 0;
10602 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
10628 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
10634 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
10647 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
10653 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
10656 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
10662 offset += INTVAL (XEXP (elim, 1));
10668 frame_pointer_fb_offset = -offset;
10922 /* Note that the bit offset is always the distance (in bits) from the