91 error (
_(
"access outside bounds of object "
92 "referenced via synthetic pointer"));
104 enum bfd_endian byte_order,
105 unsigned int addr_size,
110 if (buf_end - loc_ptr < 2 * addr_size)
117 loc_ptr += addr_size;
123 loc_ptr += addr_size;
128 if ((*low & base_mask) == base_mask)
132 if (*low == 0 && *high == 0)
149 enum bfd_endian byte_order)
151 uint64_t low_index, high_index;
153 if (loc_ptr == buf_end)
185 if (loc_ptr + 4 > buf_end)
189 *new_ptr = loc_ptr + 4;
212 int signed_addr_p = bfd_get_sign_extend_vma (objfile->
obfd);
218 loc_ptr = baton->
data;
219 buf_end = baton->
data + baton->
size;
230 loc_ptr, buf_end, &new_ptr,
231 &low, &high, byte_order);
235 byte_order, addr_size,
244 base_address = high + base_offset;
251 error (
_(
"dwarf2_find_location_expression: "
252 "Corrupted DWARF expression."));
263 high += base_address;
269 if (low == high && pc == low)
275 struct symbol *pc_func = NULL;
282 *locexpr_length = length;
287 if (pc >= low && pc < high)
289 *locexpr_length = length;
322 static struct value *
354 error (
_(
"frame address is not available."));
376 const gdb_byte **start,
size_t *length)
380 *length = symbaton->
size;
381 *start = symbaton->
data;
397 const gdb_byte **start,
size_t *length)
416 const gdb_byte **start,
size_t *length)
428 error (
_(
"Could not find the frame base for \"%s\"."),
509 unsigned int entry_values_debug = 0;
518 _(
"Entry values and tail call frames debugging is %s.\n"),
537 struct type *caller_core_addr_type;
538 struct gdbarch *caller_arch;
541 if (dwarf_block == NULL)
547 _(
"DW_AT_GNU_call_site_target is not specified "
550 (msym.minsym == NULL ?
"???"
554 if (caller_frame == NULL)
560 _(
"DW_AT_GNU_call_site_target DWARF block resolving "
561 "requires known frame which is currently not "
562 "available at %s in %s"),
564 (msym.minsym == NULL ?
"???"
571 dwarf_block->
data, dwarf_block->
size,
583 const char *physname;
594 _(
"Cannot find function \"%s\" for a call site target "
596 physname,
paddress (call_site_gdbarch, call_site->
pc),
597 (msym.
minsym == NULL ?
"???"
608 internal_error (__FILE__, __LINE__,
_(
"invalid call site target kind"));
624 _(
"DW_TAG_GNU_call_site resolving failed to find function "
625 "name for address %s"),
647 struct obstack addr_obstack;
658 obstack_init (&addr_obstack);
687 if (target_addr == verify_addr)
693 _(
"DW_OP_GNU_entry_value resolving has found "
694 "function \"%s\" at %s can call itself via tail "
696 (msym.minsym == NULL ?
"???"
701 slot = htab_find_slot (addr_hash, &target_addr, INSERT);
704 *slot = obstack_copy (&addr_obstack, &target_addr,
705 sizeof (target_addr));
724 (msym.
minsym == NULL ?
"???"
744 VEC (call_sitep) *chain)
763 if (entry_values_debug)
766 for (idx = 0; idx <
length; idx++)
774 if (entry_values_debug)
777 for (idx = 0; idx <
length; idx++)
785 for (idx = 0; idx <
callers; idx++)
795 for (idx = 0; idx <
callees; idx++)
797 !=
VEC_index (call_sitep, chain, length - 1 - idx))
803 if (entry_values_debug)
806 for (idx = 0; idx < result->
callers; idx++)
809 for (idx = 0; idx < result->
callees; idx++)
844 struct obstack addr_obstack;
845 struct cleanup *back_to_retval, *back_to_workdata;
856 VEC (call_sitep) *chain = NULL;
862 paddress (gdbarch, save_callee_pc));
866 obstack_init (&addr_obstack);
884 struct call_site *target_call_site;
890 if (target_func_addr == callee_pc)
898 target_call_site = NULL;
902 struct symbol *target_func;
912 if (target_call_site)
916 slot = htab_find_slot (addr_hash, &target_call_site->
pc, INSERT);
921 *slot = &target_call_site->
pc;
931 target_call_site = NULL;
934 call_site =
VEC_pop (call_sitep, chain);
938 htab_remove_elt (addr_hash, &call_site->
pc);
941 if (target_call_site)
945 while (target_call_site);
950 call_site =
VEC_last (call_sitep, chain);
960 _(
"There are no unambiguously determinable intermediate "
961 "callers or callees between caller function \"%s\" at %s "
962 "and callee function \"%s\" at %s"),
963 (msym_caller.minsym == NULL
966 (msym_callee.
minsym == NULL
995 if (entry_values_debug)
1015 if (kind == parameter->
kind)
1041 struct gdbarch *gdbarch;
1065 _(
"DW_OP_GNU_entry_value resolving callee gdbarch %s "
1066 "(of %s (%s)) does not match caller gdbarch %s"),
1069 (msym.
minsym == NULL ?
"???"
1074 if (caller_frame == NULL)
1080 "requires caller of %s (%s)"),
1082 (msym.
minsym == NULL ?
"???"
1089 if (target_addr != func_addr)
1096 _(
"DW_OP_GNU_entry_value resolving expects callee %s at %s "
1097 "but the called frame is for %s at %s"),
1098 (target_msym == NULL ?
"???"
1111 parameter = &call_site->
parameter[iparams];
1123 "at DW_TAG_GNU_call_site %s at %s"),
1128 *per_cu_return = call_site->
per_cu;
1142 static struct value *
1152 data_src = deref_size == -1 ? parameter->
value : parameter->
data_value;
1156 if (data_src == NULL)
1158 _(
"Cannot resolve DW_AT_GNU_call_site_data_value"));
1163 data = alloca (size + 1);
1164 memcpy (data, data_src, size);
1165 data[
size] = DW_OP_stack_value;
1193 debaton = ctx->
baton;
1194 frame = debaton->
frame;
1199 data_src = deref_size == -1 ? parameter->
value : parameter->
data_value;
1203 if (data_src == NULL)
1205 _(
"Cannot resolve DW_AT_GNU_call_site_data_value"));
1207 baton_local.
frame = caller_frame;
1208 baton_local.
per_cu = caller_per_cu;
1218 ctx->
baton = &baton_local;
1250 error (
_(
"Location address is not set."));
1259 static struct value *
1263 struct value *target_val;
1316 static struct value *
1324 struct value *outer_val, *target_val, *val;
1346 target_type, caller_frame,
1368 static struct value *
1387 _(
"DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1388 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1447 unsigned int *source_offset_bits,
1448 int *nbits,
int bits_big_endian)
1450 unsigned int avail, mask, datum;
1454 avail = 8 - *source_offset_bits;
1458 mask = (1 << avail) - 1;
1460 if (bits_big_endian)
1461 datum >>= 8 - (*source_offset_bits + *nbits);
1463 datum >>= *source_offset_bits;
1467 *source_offset_bits += avail;
1468 if (*source_offset_bits >= 8)
1470 *source_offset_bits -= 8;
1490 int nbits,
int bits_big_endian)
1504 if (bits_big_endian)
1526 gdb_byte *dest,
unsigned int dest_offset_bits,
1527 int nbits,
int bits_big_endian)
1533 mask = (1 << nbits) - 1;
1534 if (bits_big_endian)
1536 datum <<= 8 - (dest_offset_bits + nbits);
1537 mask <<= 8 - (dest_offset_bits + nbits);
1541 datum <<= dest_offset_bits;
1542 mask <<= dest_offset_bits;
1547 *dest = (*dest & ~mask) | datum;
1561 const gdb_byte *source,
unsigned int source_offset_bits,
1562 unsigned int bit_count,
1563 int bits_big_endian)
1565 unsigned int dest_avail;
1569 dest += dest_offset_bits / 8;
1570 dest_offset_bits %= 8;
1571 source += source_offset_bits / 8;
1572 source_offset_bits %= 8;
1574 dest_avail = 8 - dest_offset_bits % 8;
1577 if (dest_avail < bit_count)
1579 datum =
extract_bits (&source, &source_offset_bits, dest_avail,
1581 insert_bits (datum, dest, dest_offset_bits, dest_avail, bits_big_endian);
1583 dest_offset_bits = 0;
1584 bit_count -= dest_avail;
1589 gdb_assert (dest_offset_bits % 8 == 0 || bit_count < 8);
1590 for (; bit_count >= 8; bit_count -= 8)
1592 datum =
extract_bits (&source, &source_offset_bits, 8, bits_big_endian);
1597 gdb_assert (bit_count <= 8 - dest_offset_bits % 8);
1600 datum =
extract_bits (&source, &source_offset_bits, bit_count,
1602 insert_bits (datum, dest, dest_offset_bits, bit_count, bits_big_endian);
1617 size_t buffer_size = 0;
1625 _(
"Should not be able to create a lazy value with "
1626 "an enclosing type"));
1640 for (i = 0; i < c->
n_pieces && offset < type_len; i++)
1643 size_t this_size, this_size_bits;
1644 long dest_offset_bits, source_offset_bits, source_offset;
1645 const gdb_byte *intermediate_buffer;
1649 this_size_bits = p->
size;
1650 if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
1652 bits_to_skip -= this_size_bits;
1655 if (bits_to_skip > 0)
1657 dest_offset_bits = 0;
1658 source_offset_bits = bits_to_skip;
1659 this_size_bits -= bits_to_skip;
1664 dest_offset_bits =
offset;
1665 source_offset_bits = 0;
1667 if (this_size_bits > type_len - offset)
1668 this_size_bits = type_len -
offset;
1670 this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
1671 source_offset = source_offset_bits / 8;
1672 if (buffer_size < this_size)
1674 buffer_size = this_size;
1675 buffer =
xrealloc (buffer, buffer_size);
1677 intermediate_buffer = buffer;
1687 if (gdb_regnum != -1)
1699 source_offset_bits += 8 * this_size - this_size_bits;
1707 memset (buffer, 0, this_size);
1717 error (
_(
"Unable to access DWARF register number %s"),
1725 p->
v.
mem.in_stack_memory,
1726 p->
v.
mem.addr + source_offset,
1732 size_t n = this_size;
1746 intermediate_buffer = val_bytes + source_offset;
1753 size_t n = this_size;
1755 if (n > p->
v.
literal.length - source_offset)
1756 n = (p->
v.
literal.length >= source_offset
1757 ? p->
v.
literal.length - source_offset
1760 intermediate_buffer = p->
v.
literal.data + source_offset;
1780 intermediate_buffer, source_offset_bits % 8,
1781 this_size_bits, bits_big_endian);
1783 offset += this_size_bits;
1800 size_t buffer_size = 0;
1824 for (i = 0; i < c->
n_pieces && offset < type_len; i++)
1827 size_t this_size_bits, this_size;
1828 long dest_offset_bits, source_offset_bits, dest_offset, source_offset;
1832 this_size_bits = p->
size;
1833 if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
1835 bits_to_skip -= this_size_bits;
1838 if (this_size_bits > type_len - offset)
1839 this_size_bits = type_len -
offset;
1840 if (bits_to_skip > 0)
1842 dest_offset_bits = bits_to_skip;
1843 source_offset_bits = 0;
1844 this_size_bits -= bits_to_skip;
1849 dest_offset_bits = 0;
1850 source_offset_bits =
offset;
1853 this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
1854 source_offset = source_offset_bits / 8;
1855 dest_offset = dest_offset_bits / 8;
1856 if (dest_offset_bits % 8 == 0 && source_offset_bits % 8 == 0)
1858 source_buffer = contents + source_offset;
1863 if (buffer_size < this_size)
1865 buffer_size = this_size;
1866 buffer =
xrealloc (buffer, buffer_size);
1868 source_buffer = buffer;
1879 if (gdb_regnum != -1)
1900 _(
"Can't do read-modify-write to "
1901 "update bitfield; containing word "
1902 "has been optimized out"));
1905 _(
"Can't do read-modify-write to update "
1906 "bitfield; containing word "
1910 contents, source_offset_bits,
1916 this_size, source_buffer);
1920 error (
_(
"Unable to write to DWARF register number %s"),
1932 buffer + this_size - 1, 1);
1934 contents, source_offset_bits,
1940 source_buffer, this_size);
1946 offset += this_size_bits;
1967 for (i = 0; i < c->
n_pieces && bit_length > 0; i++)
1970 size_t this_size_bits = p->
size;
1974 if (bit_offset >= this_size_bits)
1976 bit_offset -= this_size_bits;
1980 bit_length -= this_size_bits - bit_offset;
1984 bit_length -= this_size_bits;
2004 static struct value *
2012 int i, bit_offset, bit_length;
2015 enum bfd_endian byte_order;
2026 for (i = 0; i < c->
n_pieces && bit_length > 0; i++)
2029 size_t this_size_bits = p->
size;
2033 if (bit_offset >= this_size_bits)
2035 bit_offset -= this_size_bits;
2039 bit_length -= this_size_bits - bit_offset;
2043 bit_length -= this_size_bits;
2048 if (bit_length != 0)
2049 error (
_(
"Invalid use of DW_OP_GNU_implicit_pointer"));
2070 byte_offset += piece->
v.
ptr.offset;
2078 if (baton.
data != NULL)
2084 struct obstack temp_obstack;
2088 struct value *result;
2090 obstack_init (&temp_obstack);
2094 &temp_obstack, &len);
2102 bytes += byte_offset;
2175 static struct value *
2181 struct value *retval;
2184 struct cleanup *old_chain, *value_chain;
2187 if (byte_offset < 0)
2193 baton.
frame = frame;
2205 ctx->
baton = &baton;
2223 if (entry_values_debug)
2265 if (byte_offset != 0)
2266 error (
_(
"cannot use offset on synthetic pointer to register"));
2268 if (gdb_regnum == -1)
2269 error (
_(
"Unable to access DWARF register number %d"),
2297 if (in_stack_memory)
2313 val_bytes += byte_offset;
2333 memcpy (contents, val_bytes, n);
2340 const bfd_byte *ldata;
2341 size_t n = ctx->
len;
2350 ldata = ctx->
data + byte_offset;
2361 memcpy (contents, ldata, n);
2414 if (dlbaton == NULL || dlbaton->
size == 0)
2431 ctx->
baton = &baton;
2523 for (pinfo = addr_stack; pinfo != NULL; pinfo = pinfo->
next)
2527 error (
_(
"cannot find reference address for offset property"));
2547 const char *result_name,
2548 struct gdbarch *gdbarch,
2549 unsigned char *registers_used,
2574 gdbarch, registers_used,
2576 data, data + size, per_cu);
2601 static struct value *
2614 memset (buf, 0, len);
2737 ctx->
baton = &baton;
2766 const char *
name = get_DW_OP_name (op);
2769 error (
_(
"DWARF operator %s cannot be translated to an agent expression"),
2772 error (
_(
"Unknown DWARF operator 0x%02x cannot be translated "
2773 "to an agent expression"),
2784 error (
_(
"Unable to access DWARF register number %d"), dwarf_reg);
2806 else if (nbits <= 16)
2808 else if (nbits <= 32)
2814 if (8 * nbytes == nbits)
2856 struct gdbarch *arch,
unsigned int addr_size,
2862 VEC(
int) *dw_labels = NULL, *patches = NULL;
2863 const gdb_byte *
const base = op_ptr;
2864 const gdb_byte *previous_piece = op_ptr;
2867 unsigned int addr_size_bits = 8 * addr_size;
2870 offsets =
xmalloc ((op_end - op_ptr) *
sizeof (
int));
2873 for (i = 0; i < op_end - op_ptr; ++i)
2882 while (op_ptr < op_end)
2884 enum dwarf_location_atom op = *op_ptr;
2885 uint64_t uoffset,
reg;
2889 offsets[op_ptr - base] = expr->
len;
2947 op_ptr += addr_size;
2952 if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
3042 case DW_OP_implicit_value:
3047 if (op_ptr + len > op_end)
3048 error (
_(
"DW_OP_implicit_value: too few bytes available."));
3050 error (
_(
"Cannot translate DW_OP_implicit_value of %d bytes"),
3057 "DW_OP_implicit_value");
3063 case DW_OP_stack_value:
3126 const struct block *b;
3127 struct symbol *framefunc;
3132 error (
_(
"No block found for address"));
3137 error (
_(
"No function found for block"));
3140 &datastart, &datalen);
3144 datastart + datalen, per_cu);
3184 case DW_OP_deref_size:
3188 if (op == DW_OP_deref_size)
3193 if (size != 1 && size != 2 && size != 4 && size != 8)
3194 error (
_(
"Unsupported size %d in %s"),
3195 size, get_DW_OP_name (op));
3202 ax_ext (expr, addr_size_bits);
3207 i =
ax_goto (expr, aop_if_goto);
3224 ax_ext (expr, addr_size_bits);
3228 case DW_OP_plus_uconst:
3245 ax_ext (expr, addr_size_bits);
3247 ax_ext (expr, addr_size_bits);
3290 ax_ext (expr, addr_size_bits);
3292 ax_ext (expr, addr_size_bits);
3300 ax_ext (expr, addr_size_bits);
3302 ax_ext (expr, addr_size_bits);
3311 ax_ext (expr, addr_size_bits);
3313 ax_ext (expr, addr_size_bits);
3320 ax_ext (expr, addr_size_bits);
3322 ax_ext (expr, addr_size_bits);
3329 ax_ext (expr, addr_size_bits);
3331 ax_ext (expr, addr_size_bits);
3338 ax_ext (expr, addr_size_bits);
3340 ax_ext (expr, addr_size_bits);
3346 case DW_OP_call_frame_cfa:
3351 const gdb_byte *cfa_start, *cfa_end;
3355 &text_offset, &cfa_start, &cfa_end))
3370 cfa_start, cfa_end, per_cu);
3377 case DW_OP_GNU_push_tls_address:
3381 case DW_OP_push_object_address:
3398 i =
ax_goto (expr, aop_if_goto);
3407 case DW_OP_bit_piece:
3411 if (op_ptr - 1 == previous_piece)
3412 error (
_(
"Cannot translate empty pieces to agent expressions"));
3413 previous_piece = op_ptr - 1;
3416 if (op == DW_OP_piece)
3424 if (bits_collected + size > 8 *
sizeof (
LONGEST))
3425 error (
_(
"Expression pieces exceed word size"));
3451 if (bits_collected > 0)
3453 if (bits_big_endian)
3469 bits_collected +=
size;
3474 case DW_OP_GNU_uninit:
3481 int size = (op == DW_OP_call2 ? 2 : 4);
3500 case DW_OP_call_ref:
3509 for (i = 0; i <
VEC_length (
int, patches); ++i)
3511 int targ = offsets[
VEC_index (
int, dw_labels, i)];
3523 static struct value *
3539 static struct value *
3564 return data == end || data[0] == DW_OP_piece || data[0] == DW_OP_bit_piece;
3590 unsigned int addr_size)
3595 if (data[0] >= DW_OP_reg0 && data[0] <= DW_OP_reg31)
3601 else if (data[0] == DW_OP_regx)
3609 else if (data[0] == DW_OP_fbreg)
3611 const struct block *b;
3612 struct symbol *framefunc;
3614 int64_t frame_offset;
3615 const gdb_byte *base_data, *new_data, *save_data = data;
3617 int64_t base_offset = 0;
3627 error (
_(
"No block found for address for symbol \"%s\"."),
3633 error (
_(
"No function found for block for symbol \"%s\"."),
3638 if (base_data[0] >= DW_OP_breg0 && base_data[0] <= DW_OP_breg31)
3642 frame_reg = base_data[0] - DW_OP_breg0;
3645 if (buf_end != base_data + base_size)
3646 error (
_(
"Unexpected opcode after "
3647 "DW_OP_breg%u for symbol \"%s\"."),
3650 else if (base_data[0] >= DW_OP_reg0 && base_data[0] <= DW_OP_reg31)
3653 frame_reg = base_data[0] - DW_OP_reg0;
3664 _(
"a variable at frame base reg $%s offset %s+%s"),
3668 else if (data[0] >= DW_OP_breg0 && data[0] <= DW_OP_breg31
3676 _(
"a variable at offset %s from base reg $%s"),
3695 else if (data + 1 + addr_size < end
3696 && (data[0] == DW_OP_addr
3697 || (addr_size == 4 && data[0] == DW_OP_const4u)
3698 || (addr_size == 8 && data[0] == DW_OP_const8u))
3699 && data[1 + addr_size] == DW_OP_GNU_push_tls_address
3707 _(
"a thread-local variable at offset 0x%s "
3708 "in the thread-local storage for `%s'"),
3711 data += 1 + addr_size + 1;
3718 else if (data + 3 <= end
3719 && data + 1 + (leb128_size = skip_leb128 (data + 1, end)) < end
3720 && data[0] == DW_OP_GNU_const_index
3722 && data[1 + leb128_size] == DW_OP_GNU_push_tls_address
3730 _(
"a thread-local variable at offset 0x%s "
3731 "in the thread-local storage for `%s'"),
3736 else if (data[0] >= DW_OP_lit0
3737 && data[0] <= DW_OP_lit31
3739 && data[1] == DW_OP_stack_value)
3757 struct gdbarch *
arch,
unsigned int addr_size,
3758 int offset_size,
const gdb_byte *start,
3760 int indent,
int all,
3765 || (data[0] != DW_OP_piece && data[0] != DW_OP_bit_piece)))
3767 enum dwarf_location_atom op = *data++;
3772 name = get_DW_OP_name (op);
3775 error (
_(
"Unrecognized DWARF opcode 0x%02x at %ld"),
3776 op, (
long) (data - 1 - start));
3778 (
long) (data - 1 - start), name);
3880 case DW_OP_implicit_value:
3937 case DW_OP_xderef_size:
3938 case DW_OP_deref_size:
3944 case DW_OP_plus_uconst:
3953 (
long) (data + l - start));
3960 (
long) (data + l - start));
3975 case DW_OP_call_ref:
3978 data += offset_size;
3987 case DW_OP_bit_piece:
3998 case DW_OP_GNU_implicit_pointer:
4002 data += offset_size;
4012 case DW_OP_GNU_deref_type:
4014 int addr_size = *data++;
4028 case DW_OP_GNU_const_type:
4042 case DW_OP_GNU_regval_type:
4061 case DW_OP_GNU_convert:
4062 case DW_OP_GNU_reinterpret:
4069 if (type_die.
cu_off == 0)
4083 case DW_OP_GNU_entry_value:
4087 start, data, data + ul, indent + 2,
4092 case DW_OP_GNU_parameter_ref:
4098 case DW_OP_GNU_addr_index:
4103 case DW_OP_GNU_const_index:
4127 int first_piece = 1, bad = 0;
4132 int disassemble = 1;
4139 if (!dwarf_always_disassemble)
4142 addr, objfile, per_cu,
4143 data, end, addr_size);
4147 || data[0] == DW_OP_piece
4148 || data[0] == DW_OP_bit_piece)
4156 addr_size, offset_size, data,
4158 dwarf_always_disassemble,
4164 int empty = data == here;
4168 if (data[0] == DW_OP_piece)
4181 else if (data[0] == DW_OP_bit_piece)
4190 _(
"an empty %s-bit piece"),
4194 _(
" [%s-bit piece, offset %s bits]"),
4205 if (bad || data > end)
4206 error (
_(
"Corrupted DWARF2 expression for \"%s\"."),
4224 objfile, addr_size, offset_size,
4238 if (dlbaton->
size == 0)
4250 struct gdbarch *gdbarch,
4251 unsigned char *registers_used,
4257 if (dlbaton->
size == 0)
4261 sym, pc, gdbarch, registers_used, addr_size,
4284 static struct value *
4308 static struct value *
4354 int signed_addr_p = bfd_get_sign_extend_vma (objfile->
obfd);
4360 loc_ptr = dlbaton->
data;
4361 buf_end = dlbaton->
data + dlbaton->
size;
4375 loc_ptr, buf_end, &new_ptr,
4376 &low, &high, byte_order);
4380 byte_order, addr_size,
4389 base_address = high + base_offset;
4398 error (
_(
"Corrupted DWARF expression for symbol \"%s\"."),
4405 low += base_address;
4406 high += base_address;
4421 objfile, addr_size, offset_size,
4453 struct gdbarch *gdbarch,
4454 unsigned char *registers_used,
4467 sym, pc, gdbarch, registers_used, addr_size,
4491 &entry_values_debug,
4492 _(
"Set entry values and tail call frames "
4494 _(
"Show entry values and tail call frames "
4496 _(
"When non-zero, the process of determining "
4497 "parameter values from function entry point "
4498 "and tail call frames will be printed."),
struct frame_info * frame_find_by_id(struct frame_id id)
void dwarf_expr_push_address(struct dwarf_expr_context *ctx, CORE_ADDR value, int in_stack_memory)
struct value * value_zero(struct type *type, enum lval_type lv)
struct dwarf2_locexpr_baton dwarf2_fetch_die_loc_cu_off(cu_offset offset_in_cu, struct dwarf2_per_cu_data *per_cu, CORE_ADDR(*get_frame_pc)(void *baton), void *baton)
static enum debug_loc_kind decode_debug_loc_addresses(const gdb_byte *loc_ptr, const gdb_byte *buf_end, const gdb_byte **new_ptr, CORE_ADDR *low, CORE_ADDR *high, enum bfd_endian byte_order, unsigned int addr_size, int signed_addr_p)
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
int dwarf2_per_cu_offset_size(struct dwarf2_per_cu_data *cu)
struct value * value_mark(void)
static void needs_frame_read_mem(void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
struct dwarf2_per_cu_data * per_cu
void compile_dwarf_bounds_to_c(struct ui_file *stream, const char *result_name, const struct dynamic_prop *prop, struct symbol *sym, CORE_ADDR pc, struct gdbarch *arch, unsigned char *registers_used, unsigned int addr_size, const gdb_byte *op_ptr, const gdb_byte *op_end, struct dwarf2_per_cu_data *per_cu)
static struct value * locexpr_read_variable_at_entry(struct symbol *symbol, struct frame_info *frame)
static void loclist_generate_c_location(struct symbol *sym, struct ui_file *stream, struct gdbarch *gdbarch, unsigned char *registers_used, CORE_ADDR pc, const char *result_name)
struct type * referenced_type
int ax_goto(struct agent_expr *x, enum agent_op op)
static void needs_frame_dwarf_call(struct dwarf_expr_context *ctx, cu_offset die_offset)
CORE_ADDR get_frame_address_in_block(struct frame_info *this_frame)
static CORE_ADDR needs_frame_tls_address(void *baton, CORE_ADDR offset)
struct dwarf2_per_cu_data * per_cu
union dynamic_prop_data data
static void loclist_describe_location(struct symbol *symbol, CORE_ADDR addr, struct ui_file *stream)
struct frame_info * get_selected_frame(const char *message)
#define VALUE_FRAME_ID(val)
static CORE_ADDR dwarf_expr_get_obj_addr(void *baton)
struct type * builtin_func_ptr
static void access_memory(struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits)
CORE_ADDR get_frame_pc(struct frame_info *frame)
hashval_t core_addr_hash(const void *ap)
#define SYMBOL_PRINT_NAME(symbol)
void set_value_initialized(struct value *val, int status)
struct call_site * call_site[1]
void add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
static int leb128_size(const gdb_byte *buf)
int dwarf2_fetch_cfa_info(struct gdbarch *gdbarch, CORE_ADDR pc, struct dwarf2_per_cu_data *data, int *regnum_out, LONGEST *offset_out, CORE_ADDR *text_offset_out, const gdb_byte **cfa_start_out, const gdb_byte **cfa_end_out)
struct dwarf2_per_cu_data * per_cu
static int locexpr_read_needs_frame(struct symbol *symbol)
static const char * locexpr_regname(struct gdbarch *gdbarch, int dwarf_regnum)
static CORE_ADDR dwarf_expr_read_addr_from_reg(void *baton, int dwarf_regnum)
static struct value * locexpr_read_variable(struct symbol *symbol, struct frame_info *frame)
static void show_entry_values_debug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
void fputs_unfiltered(const char *buf, struct ui_file *file)
void value_contents_copy(struct value *dst, int dst_offset, struct value *src, int src_offset, int length)
static void dwarf_expr_push_dwarf_reg_entry_value(struct dwarf_expr_context *ctx, enum call_site_parameter_kind kind, union call_site_parameter_u kind_u, int deref_size)
static CORE_ADDR needs_frame_frame_cfa(void *baton)
int value_offset(const struct value *value)
struct value * value_from_contents(struct type *type, const gdb_byte *contents)
CORE_ADDR dwarf2_read_addr_index(struct dwarf2_per_cu_data *per_cu, unsigned int addr_index)
struct frame_info * get_prev_frame(struct frame_info *this_frame)
struct dwarf_expr_piece::@52::@55 ptr
LONGEST value_as_long(struct value *val)
static struct value * dwarf2_evaluate_loc_desc_full(struct type *type, struct frame_info *frame, const gdb_byte *data, size_t size, struct dwarf2_per_cu_data *per_cu, LONGEST byte_offset)
#define BMSYMBOL_VALUE_ADDRESS(symbol)
int fputc_filtered(int c, struct ui_file *stream)
CORE_ADDR dwarf2_frame_cfa(struct frame_info *this_frame)
struct cleanup * make_cleanup_value_free(struct value *value)
static CORE_ADDR needs_get_addr_index(void *baton, unsigned int index)
void value_incref(struct value *val)
int value_bitpos(const struct value *value)
struct value * value_at(struct type *type, CORE_ADDR addr)
void put_frame_register_bytes(struct frame_info *frame, int regnum, CORE_ADDR offset, int len, const gdb_byte *myaddr)
char * plongest(LONGEST l)
static struct value * loclist_read_variable(struct symbol *symbol, struct frame_info *frame)
struct ui_file * gdb_stdout
#define FIELD_DWARF_BLOCK(thisfld)
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
#define TYPE_SPECIFIC_FIELD(thistype)
void internal_error(const char *file, int line, const char *fmt,...)
void * value_computed_closure(const struct value *v)
const gdb_byte * dwarf2_fetch_constant_bytes(sect_offset, struct dwarf2_per_cu_data *, struct obstack *, LONGEST *)
static void insert_bits(unsigned int datum, gdb_byte *dest, unsigned int dest_offset_bits, int nbits, int bits_big_endian)
static int loclist_read_needs_frame(struct symbol *symbol)
void value_free(struct value *val)
struct symbol * block_linkage_function(const struct block *bl)
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
void set_value_lazy(struct value *value, int val)
static void func_verify_no_selftailcall(struct gdbarch *gdbarch, CORE_ADDR verify_addr)
static void loclist_tracepoint_var_ref(struct symbol *symbol, struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value)
void dwarf_expr_require_composition(const gdb_byte *op_ptr, const gdb_byte *op_end, const char *op_name)
void mark_value_bytes_unavailable(struct value *value, int offset, int length)
#define VEC_safe_push(T, V, O)
int dwarf2_per_cu_addr_size(struct dwarf2_per_cu_data *cu)
static void dwarf_expr_read_mem(void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
#define SYMBOL_BLOCK_OPS(symbol)
const gdb_byte * safe_read_uleb128(const gdb_byte *buf, const gdb_byte *buf_end, uint64_t *r)
void ax_reg(struct agent_expr *x, int reg)
static void locexpr_tracepoint_var_ref(struct symbol *symbol, struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value)
static void loclist_find_frame_base_location(struct symbol *framefunc, CORE_ADDR pc, const gdb_byte **start, size_t *length)
static int call_site_parameter_matches(struct call_site_parameter *parameter, enum call_site_parameter_kind kind, union call_site_parameter_u kind_u)
static void per_cu_dwarf_call(struct dwarf_expr_context *ctx, cu_offset die_offset, struct dwarf2_per_cu_data *per_cu, CORE_ADDR(*get_frame_pc)(void *baton), void *baton)
#define FIELD_LOC_KIND(thisfld)
#define bits(obj, st, fn)
const gdb_byte * dwarf2_find_location_expression(struct dwarf2_loclist_baton *baton, size_t *locexpr_length, CORE_ADDR pc)
struct objfile * dwarf2_per_cu_objfile(struct dwarf2_per_cu_data *cu)
struct value * allocate_value(struct type *type)
const struct block * block_for_pc(CORE_ADDR pc)
struct value * dwarf_expr_fetch(struct dwarf_expr_context *ctx, int n)
static struct piece_closure * allocate_piece_closure(struct dwarf2_per_cu_data *per_cu, int n_pieces, struct dwarf_expr_piece *pieces, int addr_size)
static void chain_candidate(struct gdbarch *gdbarch, struct call_site_chain **resultp, VEC(call_sitep)*chain)
static enum debug_loc_kind decode_debug_loc_dwo_addresses(struct dwarf2_per_cu_data *per_cu, const gdb_byte *loc_ptr, const gdb_byte *buf_end, const gdb_byte **new_ptr, CORE_ADDR *low, CORE_ADDR *high, enum bfd_endian byte_order)
int longest_to_int(LONGEST)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
struct gdbarch * frame_unwind_arch(struct frame_info *next_frame)
static void write_pieced_value(struct value *to, struct value *from)
static CORE_ADDR dwarf_expr_frame_pc(void *baton)
#define MSYMBOL_PRINT_NAME(symbol)
static int dwarf2_locexpr_baton_eval(const struct dwarf2_locexpr_baton *dlbaton, CORE_ADDR addr, CORE_ADDR *valp)
struct value * dwarf2_evaluate_loc_desc(struct type *type, struct frame_info *frame, const gdb_byte *data, size_t size, struct dwarf2_per_cu_data *per_cu)
static void dwarf_expr_frame_base(void *baton, const gdb_byte **start, size_t *length)
struct value * value_from_register(struct type *type, int regnum, struct frame_info *frame)
enum frame_type get_frame_type(struct frame_info *frame)
void(* find_frame_base_location)(struct symbol *framefunc, CORE_ADDR pc, const gdb_byte **start, size_t *length)
struct frame_id get_frame_id(struct frame_info *fi)
struct type * check_typedef(struct type *type)
const gdb_byte * value_contents(struct value *value)
static int check_pieced_synthetic_pointer(const struct value *value, int bit_offset, int bit_length)
static struct symbol * func_addr_to_tail_call_list(struct gdbarch *gdbarch, CORE_ADDR addr)
#define CATCH(EXCEPTION, MASK)
static struct value * loclist_read_variable_at_entry(struct symbol *symbol, struct frame_info *frame)
struct dwarf_expr_piece::@52::@53 mem
static void locexpr_describe_location_1(struct symbol *symbol, CORE_ADDR addr, struct ui_file *stream, const gdb_byte *data, size_t size, struct objfile *objfile, unsigned int addr_size, int offset_size, struct dwarf2_per_cu_data *per_cu)
static void locexpr_describe_location(struct symbol *symbol, CORE_ADDR addr, struct ui_file *stream)
const struct dwarf_expr_context_funcs * funcs
static void free_pieced_value_closure(struct value *v)
int fputc_unfiltered(int c, struct ui_file *stream)
static void tailcall_dump(struct gdbarch *gdbarch, const struct call_site *call_site)
int core_addr_eq(const void *ap, const void *bp)
void initialize_file_ftype(void)
struct value * allocate_computed_value(struct type *type, const struct lval_funcs *funcs, void *closure)
void compile_dwarf_expr_to_c(struct ui_file *stream, const char *result_name, struct symbol *sym, CORE_ADDR pc, struct gdbarch *arch, unsigned char *registers_used, unsigned int addr_size, const gdb_byte *op_ptr, const gdb_byte *op_end, struct dwarf2_per_cu_data *per_cu)
void fprintf_filtered(struct ui_file *stream, const char *format,...)
int value_bitsize(const struct value *value)
struct symbol * find_pc_function(CORE_ADDR pc)
const struct block * get_frame_block(struct frame_info *frame, CORE_ADDR *addr_in_block)
void mark_value_bits_unavailable(struct value *value, int offset, int length)
static struct call_site_parameter * dwarf_expr_reg_to_entry_parameter(struct frame_info *frame, enum call_site_parameter_kind kind, union call_site_parameter_u kind_u, struct dwarf2_per_cu_data **per_cu_return)
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
static int piece_end_p(const gdb_byte *data, const gdb_byte *end)
void exception_print(struct ui_file *file, struct gdb_exception e)
const gdb_byte * value_contents_all(struct value *value)
struct cleanup * make_cleanup_value_free_to_mark(struct value *mark)
#define gdb_assert_not_reached(message)
void free_current_contents(void *ptr)
struct type * value_enclosing_type(struct value *value)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
struct dwarf2_per_cu_data * per_cu
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
char * pulongest(ULONGEST u)
void dwarf2_compile_expr_to_ax(struct agent_expr *expr, struct axs_value *loc, struct gdbarch *arch, unsigned int addr_size, const gdb_byte *op_ptr, const gdb_byte *op_end, struct dwarf2_per_cu_data *per_cu)
static CORE_ADDR dwarf_expr_tls_address(void *baton, CORE_ADDR offset)
struct frame_info * frame
void ax_ext(struct agent_expr *x, int n)
static struct value * entry_data_value_coerce_ref(const struct value *value)
static struct value * dwarf_entry_parameter_to_value(struct call_site_parameter *parameter, CORE_ADDR deref_size, struct type *type, struct frame_info *caller_frame, struct dwarf2_per_cu_data *per_cu)
#define VEC_index(T, V, I)
static struct type * dwarf_expr_get_base_type(struct dwarf_expr_context *ctx, cu_offset die_offset)
void ax_label(struct agent_expr *x, int patch, int target)
CORE_ADDR(* get_frame_pc)(void *baton)
struct gdbarch * get_type_arch(const struct type *type)
static const gdb_byte * gdb_read_uleb128(const gdb_byte *buf, const gdb_byte *buf_end, uint64_t *r)
static void invalid_synthetic_pointer(void)
static void needs_dwarf_reg_entry_value(struct dwarf_expr_context *ctx, enum call_site_parameter_kind kind, union call_site_parameter_u kind_u, int deref_size)
static struct value * value_of_dwarf_reg_entry(struct type *type, struct frame_info *frame, enum call_site_parameter_kind kind, union call_site_parameter_u kind_u)
struct dwarf2_locexpr_baton locexpr
struct dwarf_expr_piece * pieces
static struct value * value_of_dwarf_block_entry(struct type *type, struct frame_info *frame, const gdb_byte *block, size_t block_len)
CORE_ADDR gdbarch_adjust_dwarf2_addr(struct gdbarch *gdbarch, CORE_ADDR pc)
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
struct dwarf_expr_context * new_dwarf_expr_context(void)
void ax_simple(struct agent_expr *x, enum agent_op op)
static void needs_frame_frame_base(void *baton, const gdb_byte **start, size_t *length)
struct property_addr_info * next
void set_value_offset(struct value *value, int offset)
struct value * value_at_lazy(struct type *type, CORE_ADDR addr)
struct dwarf_expr_piece::@52::@54 literal
static CORE_ADDR call_site_to_target_addr(struct gdbarch *call_site_gdbarch, struct call_site *call_site, struct frame_info *caller_frame)
static unsigned int extract_bits_primitive(const gdb_byte **source, unsigned int *source_offset_bits, int *nbits, int bits_big_endian)
CORE_ADDR dwarf2_per_cu_text_offset(struct dwarf2_per_cu_data *cu)
struct type * dwarf2_get_die_type(cu_offset die_offset, struct dwarf2_per_cu_data *per_cu)
struct cmd_list_element * setdebuglist
static void entry_data_value_free_closure(struct value *v)
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
const char * objfile_name(const struct objfile *objfile)
static CORE_ADDR dwarf_expr_get_addr_index(void *baton, unsigned int index)
#define TYPE_TAIL_CALL_LIST(thistype)
struct ui_file * gdb_stdlog
enum dwarf_value_location location
CORE_ADDR address_from_register(int regnum, struct frame_info *frame)
struct dwarf_expr_piece * pieces
static void dwarf_expr_dwarf_call(struct dwarf_expr_context *ctx, cu_offset die_offset)
const gdb_byte * safe_read_sleb128(const gdb_byte *buf, const gdb_byte *buf_end, int64_t *r)
static const gdb_byte * disassemble_dwarf_expression(struct ui_file *stream, struct gdbarch *arch, unsigned int addr_size, int offset_size, const gdb_byte *start, const gdb_byte *data, const gdb_byte *end, int indent, int all, struct dwarf2_per_cu_data *per_cu)
struct dwarf2_offset_baton offset_info
void * hashtab_obstack_allocate(void *data, size_t size, size_t count)
PTR xrealloc(PTR ptr, size_t size)
int gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, int dwarf2_regnr)
int dwarf_block_to_dwarf_reg(const gdb_byte *buf, const gdb_byte *buf_end)
void throw_exception(struct gdb_exception exception)
struct dwarf2_loclist_baton loclist
int get_frame_func_if_available(struct frame_info *this_frame, CORE_ADDR *pc)
__extension__ enum call_site_parameter_kind kind
void discard_cleanups(struct cleanup *old_chain)
static void locexpr_generate_c_location(struct symbol *sym, struct ui_file *stream, struct gdbarch *gdbarch, unsigned char *registers_used, CORE_ADDR pc, const char *result_name)
int dwarf2_reg_to_regnum_or_error(struct gdbarch *arch, int dwarf_reg)
int value_optimized_out(struct value *value)
#define TYPE_TARGET_TYPE(thistype)
struct call_site * call_sitep
char * phex_nz(ULONGEST l, int sizeof_l)
static const gdb_byte * locexpr_describe_location_piece(struct symbol *symbol, struct ui_file *stream, CORE_ADDR addr, struct objfile *objfile, struct dwarf2_per_cu_data *per_cu, const gdb_byte *data, const gdb_byte *end, unsigned int addr_size)
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
void func_get_frame_base_dwarf_block(struct symbol *framefunc, CORE_ADDR pc, const gdb_byte **start, size_t *length)
CORE_ADDR target_translate_tls_address(struct objfile *objfile, CORE_ADDR offset)
void mark_value_bytes_optimized_out(struct value *value, int offset, int length)
struct dwarf2_locexpr_baton dwarf2_fetch_die_loc_sect_off(sect_offset offset_in_cu, struct dwarf2_per_cu_data *per_cu, CORE_ADDR(*get_frame_pc)(void *baton), void *baton)
void dwarf2_compile_property_to_c(struct ui_file *stream, const char *result_name, struct gdbarch *gdbarch, unsigned char *registers_used, const struct dynamic_prop *prop, CORE_ADDR pc, struct symbol *sym)
#define SYMBOL_BLOCK_VALUE(symbol)
#define TYPE_CODE(thistype)
void read_value_memory(struct value *val, int embedded_offset, int stack, CORE_ADDR memaddr, gdb_byte *buffer, size_t length)
void mark_value_bits_optimized_out(struct value *value, int offset, int length)
const gdb_byte * data_value
struct minimal_symbol * minsym
static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs
struct call_site_parameter parameter[1]
static CORE_ADDR get_ax_pc(void *baton)
const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
static struct value * dwarf_expr_get_reg_value(void *baton, struct type *type, int dwarf_regnum)
#define VEC_address(T, V)
void require_rvalue(struct agent_expr *ax, struct axs_value *value)
struct cleanup * make_cleanup_htab_delete(htab_t htab)
static CORE_ADDR dwarf_expr_frame_cfa(void *baton)
static CORE_ADDR needs_get_obj_addr(void *baton)
void ax_trace_quick(struct agent_expr *x, int n)
void ax_const_l(struct agent_expr *x, LONGEST l)
int dwarf_expr_fetch_in_stack_memory(struct dwarf_expr_context *ctx, int n)
void set_value_stack(struct value *value, int val)
void ax_pick(struct agent_expr *x, int depth)
int get_frame_register_bytes(struct frame_info *frame, int regnum, CORE_ADDR offset, int len, gdb_byte *myaddr, int *optimizedp, int *unavailablep)
enum dynamic_prop_kind kind
#define SYMBOL_NATURAL_NAME(symbol)
enum dwarf_value_location location
int dwarf2_evaluate_property(const struct dynamic_prop *prop, struct property_addr_info *addr_stack, CORE_ADDR *value)
int gdbarch_bits_big_endian(struct gdbarch *gdbarch)
unsigned long long ULONGEST
int dwarf_always_disassemble
void release_value(struct value *val)
struct call_site * call_site_for_pc(struct gdbarch *gdbarch, CORE_ADDR pc)
int register_size(struct gdbarch *gdbarch, int regnum)
struct type * value_type(const struct value *value)
#define SYMBOL_TYPE(symbol)
struct call_site * tail_call_next
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
struct cmd_list_element * showdebuglist
static CORE_ADDR get_frame_address_in_block_wrapper(void *baton)
static void locexpr_find_frame_base_location(struct symbol *framefunc, CORE_ADDR pc, const gdb_byte **start, size_t *length)
CORE_ADDR value_as_address(struct value *val)
union dwarf_expr_piece::@52 v
CORE_ADDR dwarf_expr_fetch_address(struct dwarf_expr_context *ctx, int n)
static struct call_site_chain * call_site_find_chain_1(struct gdbarch *gdbarch, CORE_ADDR caller_pc, CORE_ADDR callee_pc)
void ax_zero_ext(struct agent_expr *x, int n)
gdb_byte * value_contents_raw(struct value *value)
static void unimplemented(unsigned int op)
#define TYPE_LENGTH(thistype)
static void read_pieced_value(struct value *v)
static void * copy_pieced_value_closure(const struct value *v)
#define FIELD_STATIC_PHYSADDR(thisfld)
CORE_ADDR get_pc_function_start(CORE_ADDR pc)
void dwarf_expr_eval(struct dwarf_expr_context *ctx, const gdb_byte *addr, size_t len)
static int dwarf2_loc_desc_needs_frame(const gdb_byte *data, size_t size, struct dwarf2_per_cu_data *per_cu)
struct value * allocate_optimized_out_value(struct type *type)
static struct value * needs_frame_get_reg_value(void *baton, struct type *type, int regnum)
static CORE_ADDR needs_frame_read_addr_from_reg(void *baton, int regnum)
LONGEST extract_signed_integer(const gdb_byte *, int, enum bfd_endian)
struct cleanup * make_cleanup_obstack_free(struct obstack *obstack)
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
CORE_ADDR value_address(const struct value *value)
int dwarf2_per_cu_ref_addr_size(struct dwarf2_per_cu_data *cu)
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
enum axs_lvalue_kind kind
enum bfd_endian byte_order
struct call_site_target target
static void copy_bitwise(gdb_byte *dest, unsigned int dest_offset_bits, const gdb_byte *source, unsigned int source_offset_bits, unsigned int bit_count, int bits_big_endian)
CORE_ADDR get_frame_func(struct frame_info *this_frame)
#define FIELD_STATIC_PHYSNAME(thisfld)
struct dwarf2_per_cu_data * per_cu
void error(const char *fmt,...)
struct call_site_chain * call_site_find_chain(struct gdbarch *gdbarch, CORE_ADDR caller_pc, CORE_ADDR callee_pc)
int dwarf_block_to_fb_offset(const gdb_byte *buf, const gdb_byte *buf_end, CORE_ADDR *fb_offset_return)
union call_site_parameter_u u
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
void throw_error(enum errors error, const char *fmt,...)
static struct value * indirect_pieced_value(struct value *value)
void do_cleanups(struct cleanup *old_chain)
struct dwarf2_per_cu_data * per_cu
#define SYMBOL_LOCATION_BATON(symbol)
struct cleanup * make_cleanup_free_dwarf_expr_context(struct dwarf_expr_context *ctx)
static void * entry_data_value_copy_closure(const struct value *v)
const ULONGEST const LONGEST len
static unsigned int extract_bits(const gdb_byte **source, unsigned int *source_offset_bits, int nbits, int bits_big_endian)
initialize_file_ftype _initialize_dwarf2loc