Lines Matching +defs:label +defs:offset
40 The CFA register and offset, which may change during the course
176 /* Maximum size (in bytes) of an artificially generated label. */
219 char *label;
436 switch to the data section instead, and write out a synthetic start label
485 tree label = get_file_function_name ("F");
488 IDENTIFIER_POINTER (label));
489 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
616 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
619 debug_frame_section, "FDE CIE offset");
647 int offset = ( 4 /* Length */
648 + 4 /* CIE offset */
651 int pad = -offset & (PTR_SIZE - 1);
774 emit an empty label for an FDE that wouldn't otherwise be emitted. We
882 int offset = ( 4 /* Length */
891 int pad = -offset & (PTR_SIZE - 1);
1047 /* Output a marker (i.e. a label) for the beginning of a function, before
1055 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1066 call-site information. We must emit this label if it might be used. */
1074 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
1078 dup_label = xstrdup (label);
1127 /* Output a marker (i.e. a label) for the end of the generated code
1135 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1137 /* Output a label to mark the endpoint of the code generated for this
1139 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
1143 cfun->fde->dw_fde_vms_end_prologue = xstrdup (label);
1146 /* Output a marker (i.e. a label) for the beginning of the generated code
1155 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1160 /* Output a label to mark the endpoint of the code generated for this
1162 ASM_GENERATE_INTERNAL_LABEL (label, EPILOGUE_BEGIN_LABEL,
1166 fde->dw_fde_vms_begin_epilogue = xstrdup (label);
1169 /* Output a marker (i.e. a label) for the absolute end of the generated code
1178 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1186 /* Output a label to mark the endpoint of the code generated for this
1188 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
1190 ASM_OUTPUT_LABEL (asm_out_file, label);
1194 fde->dw_fde_end = xstrdup (label);
1227 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1233 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_SECOND_SECT_LABEL,
1236 fde->dw_fde_second_begin = ggc_strdup (label);
1298 char * GTY ((tag ("1"))) label;
1330 /* True if .debug_loclists.dwo offset has been emitted for it already. */
1552 HOST_WIDE_INT offset;
1553 if (!poly_offset.is_constant (&offset))
1568 offset. Don't optimize if an signed integer overflow would happen. */
1570 && ((offset > 0 && *p <= INTTYPE_MAXIMUM (HOST_WIDE_INT) - offset)
1571 || (offset < 0 && *p >= INTTYPE_MINIMUM (HOST_WIDE_INT) - offset)))
1572 *p += offset;
1574 else if (offset > 0)
1575 loc->dw_loc_next = new_loc_descr (DW_OP_plus_uconst, offset, 0);
1580 = uint_loc_descriptor (-(unsigned HOST_WIDE_INT) offset);
1589 new_reg_loc_descr (unsigned int reg, poly_int64 offset)
1592 if (offset.is_constant (&const_offset))
1603 loc_descr_plus_const (&ret, offset);
1611 loc_list_plus_const (dw_loc_list_ref list_head, poly_int64 offset)
1615 loc_descr_plus_const (&d->expr, offset);
2052 LEB128 numbers, depending on whether it's a single case label or a
2053 range label. */
2116 int offset;
2119 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
2121 dw2_asm_output_data (2, offset, NULL);
2331 /* Make sure the offset has been computed and that we can encode it as
2345 char label[MAX_ARTIFICIAL_LABEL_BYTES
2348 get_ref_die_offset_label (label, val1->v.val_die_ref.die);
2349 dw2_asm_output_offset (DWARF_REF_SIZE, label, debug_info_section, NULL);
2356 char label[MAX_ARTIFICIAL_LABEL_BYTES
2359 get_ref_die_offset_label (label, val1->v.val_die_ref.die);
2360 dw2_asm_output_offset (DWARF_REF_SIZE, label, debug_info_section, NULL);
2589 int offset;
2592 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
2595 dw2_asm_output_data_raw (2, offset);
2734 build_cfa_loc (dw_cfa_location *cfa, poly_int64 offset)
2738 offset += cfa->offset;
2747 loc_descr_plus_const (&head, offset);
2750 head = new_reg_loc_descr (cfa->reg, offset);
2761 poly_int64 offset, HOST_WIDE_INT alignment)
2773 loc_descr_plus_const (&head, offset);
2776 head = new_reg_loc_descr (dwarf_fp, offset);
2856 debug_nothing_rtx_code_label, /* label */
2897 debug_nothing_rtx_code_label, /* label */
2946 /* Emit DW_LNE_set_address; the operand is the label index. */
2970 /* Output a Fixed Advance PC; the target PC is the label index; the
2974 it when the offset might be zero but we can't tell: it's the only
2986 /* The label that marks the end of this section. */
3010 for the assembler, it denotes the LVU label number that we're
3102 offset to that symbol. */
3145 const char *label;
3300 will not emit a label because it is known to map to a view number
3311 and views label numbers recorded in it are the ones known to be
3332 requested for a label. In these cases, the compiler may not reset
3355 /* Minimum line offset in a special line info. opcode.
3377 the offset of each DIE within the .debug_info section. */
3462 const char * GTY (()) label;
3492 const char * GTY (()) label;
3599 /* Unique label counter. */
3602 /* Unique label counter for point-of-call tables. */
3932 /* enum for tracking thread-local variables whose address is really an offset
4269 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
4272 get_ref_die_offset_label (char *label, dw_die_ref ref)
4274 sprintf (label, "%s+%ld", debug_info_section_label, ref->die_offset);
4700 char label[MAX_ARTIFICIAL_LABEL_BYTES];
4706 gcc_assert (node->label);
4709 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
4711 node->label = xstrdup (label);
4735 free (node->label);
4736 node->label = NULL;
4979 return htab_hash_string (a->addr.label);
5000 return strcmp (a1->addr.label, a2->addr.label) == 0;
5019 e->addr.label = (char *) addr;
5190 /* Add a label identifier attribute value to a DIE. */
5209 /* Add a section offset attribute value to a DIE, an offset into the
5214 const char *label)
5221 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
5225 /* Add a section offset attribute value to a DIE, an offset into the
5230 const char *label)
5237 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
5251 long unsigned int offset, bool force_direct)
5258 offset should follow split-debug-info or normal semantics. This
5264 attr.dw_attr_val.v.val_offset = offset;
5268 /* Return the start label of a delta attribute. */
5277 /* Return the end label of a delta attribute. */
5341 cannot be represented as an assembler label identifier. */
5876 to store the decl <-> label + offset map. */
5895 label. */
5911 const char *symbol, HOST_WIDE_INT offset)
5919 ref->die_offset = offset;
6258 add_var_loc_to_decl (tree decl, rtx loc_note, const char *label, var_loc_view view)
6347 if (label && strcmp (last->label, label) == 0 && last->view == view)
6363 gcc_assert (strcmp (last->label, label) != 0 || last->view != view);
6479 fprintf (outfile, "offset");
6501 fprintf (outfile, "location list -> label:%s",
6561 fprintf (outfile, "die -> label: %s", die->die_id.die_symbol);
6587 fprintf (outfile, "label: %s", val->v.val_lbl_id);
6699 fprintf (outfile, " offset: %ld", die->die_offset);
8846 large the .debug_loclists* offset table should be). */
9475 it's always sized as an offset. */
9603 DIEs in the same CU will be marked. We used to clear out the offset
9784 relocatable objects - for DW_FORM_rnglistx we'd have to emit offset
10189 char label[MAX_ARTIFICIAL_LABEL_BYTES];
10190 ASM_GENERATE_INTERNAL_LABEL (label, "LVU", curr->vbegin);
10191 dw2_asm_output_symname_uleb128 (label, "Location view begin");
10198 char label[MAX_ARTIFICIAL_LABEL_BYTES];
10199 ASM_GENERATE_INTERNAL_LABEL (label, "LVU", curr->vend);
10200 dw2_asm_output_symname_uleb128 (label, "Location view end");
10241 char label[MAX_ARTIFICIAL_LABEL_BYTES];
10245 ASM_GENERATE_INTERNAL_LABEL (label, "LVU", curr->vbegin);
10246 dw2_asm_output_symname_uleb128 (label,
10257 ASM_GENERATE_INTERNAL_LABEL (label, "LVU", curr->vend);
10258 dw2_asm_output_symname_uleb128 (label,
10485 /* Output a range_list offset into the .debug_ranges or .debug_rnglists
10499 dw2_asm_output_offset (DWARF_OFFSET_SIZE, r->label,
10521 "%s (offset from %s)", name, ranges_section_label);
10524 /* Output the offset into the debug_loc section. */
10547 /* Output the offset into the debug_loc section. */
10827 offset. */
10835 And we do not clear its DIE offset after outputting it
10836 (and the label refers to the actual DIEs, not the
10837 DWARF CU unit header which is when using label + offset
10901 a->dw_attr_val.v.val_str->label,
10906 a->dw_attr_val.v.val_str->label,
11086 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11295 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11465 dw2_asm_output_data (DWARF_OFFSET_SIZE, die_offset, "DIE offset");
11572 unit (not the type unit), so we want to use the offset of
11723 /* Note that (*rnglist_table)[offset] is either a head of a rnglist
11727 note_rnglist_head (unsigned int offset)
11729 if (dwarf_version < 5 || (*ranges_table)[offset].label)
11731 (*ranges_table)[offset].label = gen_internal_sym ("LLRL");
11744 unsigned int offset;
11747 offset = add_ranges_num (-(int)in_use - 1, true);
11750 add_AT_range_list (die, DW_AT_ranges, offset, force_direct);
11752 note_rnglist_head (offset);
11864 if (r->label)
11897 /* Emit the offset table only for -gsplit-dwarf. If we don't care
11900 the offset table plus corresponding DW_FORM_rnglistx uleb128 indexes
11909 if (r->label)
11910 dw2_asm_output_delta (DWARF_OFFSET_SIZE, r->label,
11921 if (r->label)
11923 ASM_OUTPUT_LABEL (asm_out_file, r->label);
11924 lab = r->label;
11926 if (HAVE_AS_LEB128 && (r->label || r->maybe_new_sec))
11958 && r2->label == NULL
12170 dw2_asm_output_offset (DWARF_OFFSET_SIZE, node->label,
13800 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
13947 add any constant offset at the end. */
14350 /* Return a location descriptor that designates a base+offset location. */
14353 based_loc_descr (rtx reg, poly_int64 offset,
14376 elim = strip_offset_and_add (elim, &offset);
14381 pointer + offset to access stack variables. If stack
14382 is aligned without drap, use stack pointer + offset to
14391 return new_reg_loc_descr (base_reg, offset);
14395 offset += frame_pointer_fb_offset;
14397 if (offset.is_constant (&const_offset))
14402 loc_descr_plus_const (&ret, offset);
14422 && offset.is_constant (&const_offset))
14424 /* Use cfa+offset to represent the location of arguments passed
14433 result = new_reg_loc_descr (regno, offset);
14441 /* Return true if this RTL expression describes a base+offset calculation. */
15468 poly_int64 offset;
15729 /* Some ports can transform a symbol ref into a label ref, because
16583 implicit_ptr_descriptor (rtx rtl, HOST_WIDE_INT offset)
16594 ret = new_loc_descr (dwarf_OP (DW_OP_implicit_pointer), 0, offset);
17038 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize, HOST_WIDE_INT offset)
17040 if ((bitsize % BITS_PER_UNIT) == 0 && offset == 0)
17043 return new_loc_descr (DW_OP_bit_piece, bitsize, offset);
17144 HOST_WIDE_INT offset = 0;
17164 /* DW_OP_bit_size offset should be zero for register
17182 offset = memsize - bitsize;
17186 *descr_tail = new_loc_descr_op_bit_piece (bitsize, offset);
17235 a range of [last location start, end of function label]. */
17271 /* If section switch happens in between node->label
17272 and node->next->label (or end of function) and
17294 endname = node->next->label, endview = node->next->view;
17295 /* If the variable has a location at the last label
17307 *listp = new_loc_list (descr, node->label, node->view,
17312 && strcmp (node->label, endname) == 0)
17343 endname = node->next->label, endview = node->next->view;
17503 tree obj, offset;
17510 &bitsize, &bitpos, &offset, &mode,
17524 if (!offset && known_eq (bitpos, 0))
17534 if (offset)
17536 /* Variable offset. */
17537 list_ret1 = loc_list_from_tree (offset, 0, context);
17648 Thanks to stor-layout.c, size and offset expressions in GENERIC trees are
17668 - We call "frame offset" the number of stack slots that are "under DWARF
17720 offset *before* evaluating the corresponding operation. */
17746 /* If needed, relocate the picking offset with respect to the frame
17747 offset. */
18031 offset *before* LOC is executed. Return if all relocations were
18038 /* Associate to all visited operations the frame offset *before* evaluating
18370 one of its arguments: find the appropriate argument offset and let
18371 the resolve_args_picking pass compute the offset that complies
18521 tree obj, offset;
18526 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
18534 && !offset ? 2 : 1,
18548 if (offset != NULL_TREE)
18550 /* Variable offset. */
18551 list_ret1 = loc_list_from_tree_1 (offset, 0, context);
18621 unsigned HOST_WIDE_INT offset = 0;
18644 size = offset = (unsigned HOST_WIDE_INT)-1;
18652 if (pos < offset)
18656 size = offset = (unsigned HOST_WIDE_INT)-1;
18660 if (pos > offset)
18662 ret1 = new_loc_descr (DW_OP_piece, pos - offset, 0);
18664 offset = pos;
18673 size = offset = (unsigned HOST_WIDE_INT)-1;
18683 offset = pos + fieldsize;
18687 if (offset != size)
18689 ret1 = new_loc_descr (DW_OP_piece, size - offset, 0);
18691 offset = size;
19140 QUAL_UNION_TYPE), this holds an expression that computes the offset for
19146 /* Given a pointer to a FIELD_DECL, compute the byte offset of the lowest
19149 returned); otherwise return a DWARF expression that computes the offset.
19152 that offset is, either because the argument turns out to be a pointer to an
19153 ERROR_MARK node, or because the offset expression is too complex for us.
19215 starting bit offset (relative to the start of the containing
19217 bit-field. Thus, when computing the byte offset value for the
19247 "containing object" 64-bit field at bit-offset zero within the
19297 /* If the byte offset is a constant, it's simplier to handle a native
19381 represents a bit-field, the "offset" part of this special location
19405 HOST_WIDE_INT offset;
19414 aren't at a fixed offset from all (sub)objects of the same
19415 type. We need to extract the appropriate offset from our
19432 /* Calculate the address of the offset. */
19433 offset = tree_to_shwi (BINFO_VPTR_FIELD (decl));
19434 gcc_assert (offset < 0);
19436 tmp = int_loc_descriptor (-offset);
19441 /* Extract the offset. */
19450 offset = tree_to_shwi (BINFO_OFFSET (decl));
19454 loc_descr = field_byte_offset (decl, ctx, &offset);
19456 /* If loc_descr is available then we know the field offset is dynamic.
19462 offset = 0;
19466 stack. Compute the field offset and add it to this base address. */
19493 if (offset < 0)
19494 add_AT_int (die, DW_AT_data_member_location, offset);
19496 add_AT_unsigned (die, DW_AT_data_member_location, offset);
19507 loc_descr = new_loc_descr (op, offset, 0);
20072 poly_int64 offset = (UNITS_PER_WORD
20076 plus_constant (addr_mode, XEXP (rtl, 0), offset));
20085 poly_int64 offset = byte_lowpart_offset (TYPE_MODE (TREE_TYPE (decl)),
20091 fact we are not. We need to adjust the offset of the
20094 if (maybe_ne (offset, 0))
20096 plus_constant (addr_mode, XEXP (rtl, 0), offset));
20138 value is the offset into the common block for the symbol. */
20146 tree offset;
20151 it does not have a value (the offset into the common area), or if it
20164 cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset, &mode,
20177 if (offset != NULL)
20179 if (!tree_fits_shwi_p (offset))
20181 *value = tree_to_shwi (offset);
20383 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
20418 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
20434 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
20456 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
20463 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
20472 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
20478 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
20495 compute_frame_pointer_to_fb_displacement (poly_int64 offset)
20501 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
20504 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
20510 elim = strip_offset_and_add (elim, &offset);
20512 frame_pointer_fb_offset = -offset;
21167 /* Note that the bit offset is always the distance (in bits) from the
21445 char label[MAX_ARTIFICIAL_LABEL_BYTES];
21451 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
21453 add_AT_lbl_id (die, DW_AT_entry_pc, label);
21719 /* Get the decl's label, as described by its RTL. This may be different
22711 add_AT_lbl_id (die, dwarf_AT (DW_AT_call_return_pc), ca_loc->label);
23143 alignment offset. */
23158 containing the function label. Then make and emit a
23582 /* The label at the inlined entry point. */
24037 /* Generate a DIE to represent a label identifier. */
24045 char label[MAX_ARTIFICIAL_LABEL_BYTES];
24079 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
24080 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
24087 ASM_GENERATE_INTERNAL_LABEL (label, "LDL", CODE_LABEL_NUMBER (insn));
24088 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
24122 char label[MAX_ARTIFICIAL_LABEL_BYTES];
24135 ASM_GENERATE_INTERNAL_LABEL (label, ied->label_pfx, ied->label_num);
24136 add_AT_lbl_id (die, DW_AT_entry_pc, label);
24145 ASM_GENERATE_INTERNAL_LABEL (label, "LVU", ied->view);
24151 label in this case. Ideally, we'd have a single form
24156 add_AT_symview (die, DW_AT_GNU_entry_view, label);
24172 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
24174 add_AT_lbl_id (die, DW_AT_entry_pc, label);
24225 unsigned int offset = add_ranges (stmt, true);
24226 add_AT_range_list (die, DW_AT_ranges, offset, false);
24227 note_rnglist_head (offset);
24243 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
24247 add_AT_low_high_pc (die, label, label_high, false);
24358 /* If we have a variant part offset, then we are supposed to process a member
25013 offset attributes that are relative to the embedding record base address.
25015 must be an expression that computes the offset of the variant part to
25060 /* If the offset for this variant part is more complex than a constant,
27005 /* Output a marker (i.e. a label) for the beginning of the generated code for
27016 /* Output a marker (i.e. a label) for the end of the generated code for a
27276 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
27424 last_{,postcall_}label so that they are not reused this time. */
27435 const char *label
27439 newloc = add_var_loc_to_decl (decl, loc_note, label, view);
27450 and this note, use the label we emitted last time. Otherwise
27451 create a new label and emit it. */
27511 ca_loc->label = last_label;
27550 newloc->label = last_label;
27560 newloc->label = last_postcall_label;
27566 by target magic. Then, even the -1 in the label will be
27790 char label[MAX_ARTIFICIAL_LABEL_BYTES];
27791 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
27793 end_label = ggc_strdup (label);
27842 might end with a .LVL* label that could be equal to .Ltext0.
27857 if (node && node->next && node->next->label)
27860 const char *label = node->next->label;
27866 if (strcmp (label, loclabel) == 0)
27923 /* Output a label to mark the beginning of a source code line entry
27966 char label[MAX_ARTIFICIAL_LABEL_BYTES];
27967 ASM_GENERATE_INTERNAL_LABEL (label, "LVU", table->view);
27970 assemble_name (asm_out_file, label);
28065 char label[MAX_ARTIFICIAL_LABEL_BYTES];
28066 ASM_GENERATE_INTERNAL_LABEL (label, "LVU", table->view);
28067 assemble_name (asm_out_file, label);
28250 char label[MAX_ARTIFICIAL_LABEL_BYTES];
28312 dw2_asm_output_offset (DWARF_OFFSET_SIZE, node->label,
28321 ASM_GENERATE_INTERNAL_LABEL (label,
28324 dw2_asm_output_offset (DWARF_OFFSET_SIZE, label, NULL, NULL);
28522 offset expected by debuggers. */
28591 label number for the fat LTO object DWARF. */
28607 char label[MAX_ARTIFICIAL_LABEL_BYTES];
28617 ASM_GENERATE_INTERNAL_LABEL (label,
28620 ASM_OUTPUT_LABEL (asm_out_file, label);
28948 htab_traverse. Output the offset to a string and update the
28949 current offset. */
28952 output_index_string_offset (indirect_string_node **h, unsigned int *offset)
28961 dw2_asm_output_data (DWARF_OFFSET_SIZE, *offset,
28963 *offset += strlen (node->str) + 1;
29011 ASM_OUTPUT_LABEL (asm_out_file, node->label);
29029 unsigned int offset = 0;
29038 header. Note that we don't need to generate a label to the
29042 if we would start using string offset tables for the main (or
29065 <unsigned int *, output_index_string_offset> (&offset);
29104 dw2_asm_output_addr (DWARF2_ADDR_SIZE, entry->addr.label,
29966 HOST_WIDE_INT offset = 0;
29974 offset = INTVAL (XEXP (XEXP (rtl, 0), 1));
30004 loc->dw_loc_oprnd2.v.val_int = offset;
30212 HOST_WIDE_INT offset = 0;
30229 offset = tree_to_shwi (TREE_OPERAND (init, 1));
30258 l = new_loc_descr (dwarf_OP (DW_OP_implicit_pointer), 0, offset);
30777 int offset;
30780 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
30781 hstate.add_object (offset);
31492 /* Output a terminator label for the .text section. */
31554 offset expected by debuggers. */
31671 /* Add the base offset of the ranges table to the skeleton
32249 offset expected by debuggers. */