/* DWARF 2 location expression support for GDB.
- Copyright (C) 2003-2018 Free Software Foundation, Inc.
+ Copyright (C) 2003-2019 Free Software Foundation, Inc.
Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
#include "dwarf2loc.h"
#include "dwarf2-frame.h"
#include "compile/compile.h"
-#include "selftest.h"
+#include "common/selftest.h"
#include <algorithm>
#include <vector>
#include <unordered_set>
union call_site_parameter_u kind_u,
struct dwarf2_per_cu_data **per_cu_return);
+static struct value *indirect_synthetic_pointer
+ (sect_offset die, LONGEST byte_offset,
+ struct dwarf2_per_cu_data *per_cu,
+ struct frame_info *frame,
+ struct type *type, bool resolve_abstract_p = false);
+
/* Until these have formal names, we define these here.
ref: http://gcc.gnu.org/wiki/DebugFission
Each entry in .debug_loc.dwo begins with a byte that describes the entry,
if (pc_block)
pc_func = block_linkage_function (pc_block);
- if (pc_func && pc == BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func)))
+ if (pc_func && pc == BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (pc_func)))
{
*locexpr_length = length;
return loc_ptr;
ctx->eval (block.data, block.size);
}
+/* Given context CTX, section offset SECT_OFF, and compilation unit
+ data PER_CU, execute the "variable value" operation on the DIE
+ found at SECT_OFF. */
+
+static struct value *
+sect_variable_value (struct dwarf_expr_context *ctx, sect_offset sect_off,
+ struct dwarf2_per_cu_data *per_cu)
+{
+ struct type *die_type = dwarf2_fetch_die_type_sect_off (sect_off, per_cu);
+
+ if (die_type == NULL)
+ error (_("Bad DW_OP_GNU_variable_value DIE."));
+
+ /* Note: Things still work when the following test is removed. This
+ test and error is here to conform to the proposed specification. */
+ if (TYPE_CODE (die_type) != TYPE_CODE_INT
+ && TYPE_CODE (die_type) != TYPE_CODE_PTR)
+ error (_("Type of DW_OP_GNU_variable_value DIE must be an integer or pointer."));
+
+ struct type *type = lookup_pointer_type (die_type);
+ struct frame_info *frame = get_selected_frame (_("No frame selected."));
+ return indirect_synthetic_pointer (sect_off, 0, per_cu, frame, type, true);
+}
+
class dwarf_evaluate_loc_desc : public dwarf_expr_context
{
public:
per_cu_dwarf_call (this, die_offset, per_cu);
}
+ /* Helper interface of sect_variable_value for
+ dwarf2_evaluate_loc_desc. */
+
+ struct value *dwarf_variable_value (sect_offset sect_off) override
+ {
+ return sect_variable_value (this, sect_off, per_cu);
+ }
+
struct type *get_base_type (cu_offset die_offset, int size) override
{
struct type *result = dwarf2_get_die_type (die_offset, per_cu);
struct symbol *sym = find_pc_function (addr);
struct type *type;
- if (sym == NULL || BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) != addr)
+ if (sym == NULL || BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)) != addr)
throw_error (NO_ENTRY_VALUE_ERROR,
_("DW_TAG_call_site resolving failed to find function "
"name for address %s"),
{
struct call_site_chain *retval = NULL;
- TRY
+ try
{
retval = call_site_find_chain_1 (gdbarch, caller_pc, callee_pc);
}
- CATCH (e, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &e)
{
if (e.error == NO_ENTRY_VALUE_ERROR)
{
return NULL;
}
else
- throw_exception (e);
+ throw;
}
- END_CATCH
return retval;
}
target_type, caller_frame,
caller_per_cu);
- release_value (target_val).release ();
val = allocate_computed_value (type, &entry_data_value_funcs,
- target_val /* closure */);
+ release_value (target_val).release ());
/* Copy the referencing pointer to the new computed value. */
memcpy (value_contents_raw (val), value_contents_raw (outer_val),
return c;
}
-/* Copy NBITS bits from SOURCE to DEST starting at the given bit
- offsets. Use the bit order as specified by BITS_BIG_ENDIAN.
- Source and destination buffers must not overlap. */
-
-static void
-copy_bitwise (gdb_byte *dest, ULONGEST dest_offset,
- const gdb_byte *source, ULONGEST source_offset,
- ULONGEST nbits, int bits_big_endian)
-{
- unsigned int buf, avail;
-
- if (nbits == 0)
- return;
-
- if (bits_big_endian)
- {
- /* Start from the end, then work backwards. */
- dest_offset += nbits - 1;
- dest += dest_offset / 8;
- dest_offset = 7 - dest_offset % 8;
- source_offset += nbits - 1;
- source += source_offset / 8;
- source_offset = 7 - source_offset % 8;
- }
- else
- {
- dest += dest_offset / 8;
- dest_offset %= 8;
- source += source_offset / 8;
- source_offset %= 8;
- }
-
- /* Fill BUF with DEST_OFFSET bits from the destination and 8 -
- SOURCE_OFFSET bits from the source. */
- buf = *(bits_big_endian ? source-- : source++) >> source_offset;
- buf <<= dest_offset;
- buf |= *dest & ((1 << dest_offset) - 1);
-
- /* NBITS: bits yet to be written; AVAIL: BUF's fill level. */
- nbits += dest_offset;
- avail = dest_offset + 8 - source_offset;
-
- /* Flush 8 bits from BUF, if appropriate. */
- if (nbits >= 8 && avail >= 8)
- {
- *(bits_big_endian ? dest-- : dest++) = buf;
- buf >>= 8;
- avail -= 8;
- nbits -= 8;
- }
-
- /* Copy the middle part. */
- if (nbits >= 8)
- {
- size_t len = nbits / 8;
-
- /* Use a faster method for byte-aligned copies. */
- if (avail == 0)
- {
- if (bits_big_endian)
- {
- dest -= len;
- source -= len;
- memcpy (dest + 1, source + 1, len);
- }
- else
- {
- memcpy (dest, source, len);
- dest += len;
- source += len;
- }
- }
- else
- {
- while (len--)
- {
- buf |= *(bits_big_endian ? source-- : source++) << avail;
- *(bits_big_endian ? dest-- : dest++) = buf;
- buf >>= 8;
- }
- }
- nbits %= 8;
- }
-
- /* Write the last byte. */
- if (nbits)
- {
- if (avail < nbits)
- buf |= *source << avail;
-
- buf &= (1 << nbits) - 1;
- *dest = (*dest & (~0 << nbits)) | buf;
- }
-}
-
-#if GDB_SELF_TEST
-
-namespace selftests {
-
-/* Helper function for the unit test of copy_bitwise. Convert NBITS bits
- out of BITS, starting at OFFS, to the respective '0'/'1'-string. MSB0
- specifies whether to assume big endian bit numbering. Store the
- resulting (not null-terminated) string at STR. */
-
-static void
-bits_to_str (char *str, const gdb_byte *bits, ULONGEST offs,
- ULONGEST nbits, int msb0)
-{
- unsigned int j;
- size_t i;
-
- for (i = offs / 8, j = offs % 8; nbits; i++, j = 0)
- {
- unsigned int ch = bits[i];
- for (; j < 8 && nbits; j++, nbits--)
- *str++ = (ch & (msb0 ? (1 << (7 - j)) : (1 << j))) ? '1' : '0';
- }
-}
-
-/* Check one invocation of copy_bitwise with the given parameters. */
-
-static void
-check_copy_bitwise (const gdb_byte *dest, unsigned int dest_offset,
- const gdb_byte *source, unsigned int source_offset,
- unsigned int nbits, int msb0)
-{
- size_t len = align_up (dest_offset + nbits, 8);
- char *expected = (char *) alloca (len + 1);
- char *actual = (char *) alloca (len + 1);
- gdb_byte *buf = (gdb_byte *) alloca (len / 8);
-
- /* Compose a '0'/'1'-string that represents the expected result of
- copy_bitwise below:
- Bits from [0, DEST_OFFSET) are filled from DEST.
- Bits from [DEST_OFFSET, DEST_OFFSET + NBITS) are filled from SOURCE.
- Bits from [DEST_OFFSET + NBITS, LEN) are filled from DEST.
-
- E.g., with:
- dest_offset: 4
- nbits: 2
- len: 8
- dest: 00000000
- source: 11111111
-
- We should end up with:
- buf: 00001100
- DDDDSSDD (D=dest, S=source)
- */
- bits_to_str (expected, dest, 0, len, msb0);
- bits_to_str (expected + dest_offset, source, source_offset, nbits, msb0);
-
- /* Fill BUF with data from DEST, apply copy_bitwise, and convert the
- result to a '0'/'1'-string. */
- memcpy (buf, dest, len / 8);
- copy_bitwise (buf, dest_offset, source, source_offset, nbits, msb0);
- bits_to_str (actual, buf, 0, len, msb0);
-
- /* Compare the resulting strings. */
- expected[len] = actual[len] = '\0';
- if (strcmp (expected, actual) != 0)
- error (_("copy_bitwise %s != %s (%u+%u -> %u)"),
- expected, actual, source_offset, nbits, dest_offset);
-}
-
-/* Unit test for copy_bitwise. */
-
-static void
-copy_bitwise_tests (void)
-{
- /* Data to be used as both source and destination buffers. The two
- arrays below represent the lsb0- and msb0- encoded versions of the
- following bit string, respectively:
- 00000000 00011111 11111111 01001000 10100101 11110010
- This pattern is chosen such that it contains:
- - constant 0- and 1- chunks of more than a full byte;
- - 0/1- and 1/0 transitions on all bit positions within a byte;
- - several sufficiently asymmetric bytes.
- */
- static const gdb_byte data_lsb0[] = {
- 0x00, 0xf8, 0xff, 0x12, 0xa5, 0x4f
- };
- static const gdb_byte data_msb0[] = {
- 0x00, 0x1f, 0xff, 0x48, 0xa5, 0xf2
- };
-
- constexpr size_t data_nbits = 8 * sizeof (data_lsb0);
- constexpr unsigned max_nbits = 24;
-
- /* Try all combinations of:
- lsb0/msb0 bit order (using the respective data array)
- X [0, MAX_NBITS] copy bit width
- X feasible source offsets for the given copy bit width
- X feasible destination offsets
- */
- for (int msb0 = 0; msb0 < 2; msb0++)
- {
- const gdb_byte *data = msb0 ? data_msb0 : data_lsb0;
-
- for (unsigned int nbits = 1; nbits <= max_nbits; nbits++)
- {
- const unsigned int max_offset = data_nbits - nbits;
-
- for (unsigned source_offset = 0;
- source_offset <= max_offset;
- source_offset++)
- {
- for (unsigned dest_offset = 0;
- dest_offset <= max_offset;
- dest_offset++)
- {
- check_copy_bitwise (data + dest_offset / 8,
- dest_offset % 8,
- data + source_offset / 8,
- source_offset % 8,
- nbits, msb0);
- }
- }
- }
-
- /* Special cases: copy all, copy nothing. */
- check_copy_bitwise (data_lsb0, 0, data_msb0, 0, data_nbits, msb0);
- check_copy_bitwise (data_msb0, 0, data_lsb0, 0, data_nbits, msb0);
- check_copy_bitwise (data, data_nbits - 7, data, 9, 0, msb0);
- }
-}
-
-} /* namespace selftests */
-
-#endif /* GDB_SELF_TEST */
-
/* Return the number of bytes overlapping a contiguous chunk of N_BITS
bits whose first bit is located at bit offset START. */
static struct value *
indirect_synthetic_pointer (sect_offset die, LONGEST byte_offset,
struct dwarf2_per_cu_data *per_cu,
- struct frame_info *frame, struct type *type)
+ struct frame_info *frame, struct type *type,
+ bool resolve_abstract_p)
{
/* Fetch the location expression of the DIE we're pointing to. */
struct dwarf2_locexpr_baton baton
= dwarf2_fetch_die_loc_sect_off (die, per_cu,
- get_frame_address_in_block_wrapper, frame);
+ get_frame_address_in_block_wrapper, frame,
+ resolve_abstract_p);
/* Get type of pointed-to DIE. */
struct type *orig_type = dwarf2_fetch_die_type_sect_off (die, per_cu);
ctx.ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu);
ctx.offset = dwarf2_per_cu_text_offset (per_cu);
- TRY
+ try
{
ctx.eval (data, size);
}
- CATCH (ex, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &ex)
{
if (ex.error == NOT_AVAILABLE_ERROR)
{
return allocate_optimized_out_value (subobj_type);
}
else
- throw_exception (ex);
+ throw;
}
- END_CATCH
if (ctx.pieces.size () > 0)
{
ctx.ref_addr_size = dwarf2_per_cu_ref_addr_size (dlbaton->per_cu);
ctx.offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
- ctx.eval (dlbaton->data, dlbaton->size);
+ try
+ {
+ ctx.eval (dlbaton->data, dlbaton->size);
+ }
+ catch (const gdb_exception_error &ex)
+ {
+ if (ex.error == NOT_AVAILABLE_ERROR)
+ {
+ return 0;
+ }
+ else if (ex.error == NO_ENTRY_VALUE_ERROR)
+ {
+ if (entry_values_debug)
+ exception_print (gdb_stdout, ex);
+ return 0;
+ }
+ else
+ throw;
+ }
switch (ctx.location)
{
/* See dwarf2loc.h. */
void
-dwarf2_compile_property_to_c (string_file &stream,
+dwarf2_compile_property_to_c (string_file *stream,
const char *result_name,
struct gdbarch *gdbarch,
unsigned char *registers_used,
per_cu_dwarf_call (this, die_offset, per_cu);
}
+ /* Helper interface of sect_variable_value for
+ dwarf2_loc_desc_get_symbol_read_needs. */
+
+ struct value *dwarf_variable_value (sect_offset sect_off) override
+ {
+ return sect_variable_value (this, sect_off, per_cu);
+ }
+
/* DW_OP_entry_value accesses require a caller, therefore a
frame. */
struct dwarf2_per_cu_data *per_cu)
{
gdbarch *arch = expr->gdbarch;
- int i;
std::vector<int> dw_labels, patches;
const gdb_byte * const base = op_ptr;
const gdb_byte *previous_piece = op_ptr;
case DW_OP_piece:
case DW_OP_bit_piece:
{
- uint64_t size, offset;
+ uint64_t size;
if (op_ptr - 1 == previous_piece)
error (_("Cannot translate empty pieces to agent expressions"));
if (op == DW_OP_piece)
{
size *= 8;
- offset = 0;
+ uoffset = 0;
}
else
- op_ptr = safe_read_uleb128 (op_ptr, op_end, &offset);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
if (bits_collected + size > 8 * sizeof (LONGEST))
error (_("Expression pieces exceed word size"));
case axs_lvalue_memory:
/* Offset the pointer, if needed. */
- if (offset > 8)
+ if (uoffset > 8)
{
- ax_const_l (expr, offset / 8);
+ ax_const_l (expr, uoffset / 8);
ax_simple (expr, aop_add);
- offset %= 8;
+ uoffset %= 8;
}
access_memory (arch, expr, size);
break;
uoffset = extract_unsigned_integer (op_ptr, size, byte_order);
op_ptr += size;
- cu_offset offset = (cu_offset) uoffset;
- block = dwarf2_fetch_die_loc_cu_off (offset, per_cu,
+ cu_offset cuoffset = (cu_offset) uoffset;
+ block = dwarf2_fetch_die_loc_cu_off (cuoffset, per_cu,
get_ax_pc, expr);
/* DW_OP_call_ref is currently not supported. */
case DW_OP_call_ref:
unimplemented (op);
+ case DW_OP_GNU_variable_value:
+ unimplemented (op);
+
default:
unimplemented (op);
}
}
/* Patch all the branches we emitted. */
- for (i = 0; i < patches.size (); ++i)
+ for (int i = 0; i < patches.size (); ++i)
{
int targ = offsets[dw_labels[i]];
if (targ == -1)
case DW_OP_deref_type:
case DW_OP_GNU_deref_type:
{
- int addr_size = *data++;
+ int deref_addr_size = *data++;
struct type *type;
data = safe_read_uleb128 (data, end, &ul);
type_print (type, "", stream, -1);
fprintf_filtered (stream, " [0x%s]> %d",
phex_nz (to_underlying (offset), 0),
- addr_size);
+ deref_addr_size);
}
break;
ul = dwarf2_read_addr_index (per_cu, ul);
fprintf_filtered (stream, " %s", pulongest (ul));
break;
+
+ case DW_OP_GNU_variable_value:
+ ul = extract_unsigned_integer (data, offset_size,
+ gdbarch_byte_order (arch));
+ data += offset_size;
+ fprintf_filtered (stream, " offset %s", phex_nz (ul, offset_size));
+ break;
}
fprintf_filtered (stream, "\n");
/* symbol_computed_ops 'generate_c_location' method. */
static void
-locexpr_generate_c_location (struct symbol *sym, string_file &stream,
+locexpr_generate_c_location (struct symbol *sym, string_file *stream,
struct gdbarch *gdbarch,
unsigned char *registers_used,
CORE_ADDR pc, const char *result_name)
/* symbol_computed_ops 'generate_c_location' method. */
static void
-loclist_generate_c_location (struct symbol *sym, string_file &stream,
+loclist_generate_c_location (struct symbol *sym, string_file *stream,
struct gdbarch *gdbarch,
unsigned char *registers_used,
CORE_ADDR pc, const char *result_name)
NULL,
show_entry_values_debug,
&setdebuglist, &showdebuglist);
-
-#if GDB_SELF_TEST
- selftests::register_test ("copy_bitwise", selftests::copy_bitwise_tests);
-#endif
}
projects / thirdparty / binutils-gdb.git / blobdiff