/* DWARF 2 location expression support for GDB.
- Copyright (C) 2003-2016 Free Software Foundation, Inc.
+ Copyright (C) 2003-2020 Free Software Foundation, Inc.
Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
#include "dwarf2.h"
#include "dwarf2expr.h"
#include "dwarf2loc.h"
+#include "dwarf2read.h"
#include "dwarf2-frame.h"
#include "compile/compile.h"
-#include "selftest.h"
+#include "gdbsupport/selftest.h"
#include <algorithm>
#include <vector>
-
-extern int dwarf_always_disassemble;
+#include <unordered_set>
+#include "gdbsupport/underlying.h"
+#include "gdbsupport/byte-vector.h"
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);
+ struct type *subobj_type,
+ LONGEST subobj_byte_offset);
static struct call_site_parameter *dwarf_expr_reg_to_entry_parameter
(struct frame_info *frame,
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,
return DEBUG_LOC_START_END;
}
+/* Decode the addresses in .debug_loclists entry.
+ A pointer to the next byte to examine is returned in *NEW_PTR.
+ The encoded low,high addresses are return in *LOW,*HIGH.
+ The result indicates the kind of entry found. */
+
+static enum debug_loc_kind
+decode_debug_loclists_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,
+ unsigned int addr_size,
+ int signed_addr_p)
+{
+ uint64_t u64;
+
+ if (loc_ptr == buf_end)
+ return DEBUG_LOC_BUFFER_OVERFLOW;
+
+ switch (*loc_ptr++)
+ {
+ case DW_LLE_end_of_list:
+ *new_ptr = loc_ptr;
+ return DEBUG_LOC_END_OF_LIST;
+ case DW_LLE_base_address:
+ if (loc_ptr + addr_size > buf_end)
+ return DEBUG_LOC_BUFFER_OVERFLOW;
+ if (signed_addr_p)
+ *high = extract_signed_integer (loc_ptr, addr_size, byte_order);
+ else
+ *high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
+ loc_ptr += addr_size;
+ *new_ptr = loc_ptr;
+ return DEBUG_LOC_BASE_ADDRESS;
+ case DW_LLE_offset_pair:
+ loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &u64);
+ if (loc_ptr == NULL)
+ return DEBUG_LOC_BUFFER_OVERFLOW;
+ *low = u64;
+ loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &u64);
+ if (loc_ptr == NULL)
+ return DEBUG_LOC_BUFFER_OVERFLOW;
+ *high = u64;
+ *new_ptr = loc_ptr;
+ return DEBUG_LOC_START_END;
+ default:
+ return DEBUG_LOC_INVALID_ENTRY;
+ }
+}
+
/* Decode the addresses in .debug_loc.dwo entry.
A pointer to the next byte to examine is returned in *NEW_PTR.
The encoded low,high addresses are return in *LOW,*HIGH.
switch (*loc_ptr++)
{
- case DEBUG_LOC_END_OF_LIST:
+ case DW_LLE_GNU_end_of_list_entry:
*new_ptr = loc_ptr;
return DEBUG_LOC_END_OF_LIST;
- case DEBUG_LOC_BASE_ADDRESS:
+ case DW_LLE_GNU_base_address_selection_entry:
*low = 0;
loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
if (loc_ptr == NULL)
*high = dwarf2_read_addr_index (per_cu, high_index);
*new_ptr = loc_ptr;
return DEBUG_LOC_BASE_ADDRESS;
- case DEBUG_LOC_START_END:
+ case DW_LLE_GNU_start_end_entry:
loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index);
if (loc_ptr == NULL)
return DEBUG_LOC_BUFFER_OVERFLOW;
*high = dwarf2_read_addr_index (per_cu, high_index);
*new_ptr = loc_ptr;
return DEBUG_LOC_START_END;
- case DEBUG_LOC_START_LENGTH:
+ case DW_LLE_GNU_start_length_entry:
loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index);
if (loc_ptr == NULL)
return DEBUG_LOC_BUFFER_OVERFLOW;
kind = decode_debug_loc_dwo_addresses (baton->per_cu,
loc_ptr, buf_end, &new_ptr,
&low, &high, byte_order);
- else
+ else if (dwarf2_version (baton->per_cu) < 5)
kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
&low, &high,
byte_order, addr_size,
signed_addr_p);
+ else
+ kind = decode_debug_loclists_addresses (baton->per_cu,
+ loc_ptr, buf_end, &new_ptr,
+ &low, &high, byte_order,
+ addr_size, signed_addr_p);
+
loc_ptr = new_ptr;
switch (kind)
{
high += base_address;
}
- length = extract_unsigned_integer (loc_ptr, 2, byte_order);
- loc_ptr += 2;
+ if (dwarf2_version (baton->per_cu) < 5)
+ {
+ length = extract_unsigned_integer (loc_ptr, 2, byte_order);
+ loc_ptr += 2;
+ }
+ else
+ {
+ unsigned int bytes_read;
+
+ length = read_unsigned_leb128 (NULL, loc_ptr, &bytes_read);
+ loc_ptr += bytes_read;
+ }
if (low == high && pc == low)
{
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;
if (*length == 0)
error (_("Could not find the frame base for \"%s\"."),
- SYMBOL_NATURAL_NAME (framefunc));
+ framefunc->natural_name ());
}
static CORE_ADDR
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:
/* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
the frame in BATON. */
- CORE_ADDR get_frame_cfa () OVERRIDE
+ CORE_ADDR get_frame_cfa () override
{
return dwarf2_frame_cfa (frame);
}
/* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
the frame in BATON. */
- CORE_ADDR get_frame_pc () OVERRIDE
+ CORE_ADDR get_frame_pc () override
{
return get_frame_address_in_block (frame);
}
/* Using the objfile specified in BATON, find the address for the
current thread's thread-local storage with offset OFFSET. */
- CORE_ADDR get_tls_address (CORE_ADDR offset) OVERRIDE
+ CORE_ADDR get_tls_address (CORE_ADDR offset) override
{
struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
/* Helper interface of per_cu_dwarf_call for
dwarf2_evaluate_loc_desc. */
- void dwarf_call (cu_offset die_offset) OVERRIDE
+ void dwarf_call (cu_offset die_offset) override
{
per_cu_dwarf_call (this, die_offset, per_cu);
}
- struct type *get_base_type (cu_offset die_offset, int size) OVERRIDE
+ /* 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);
if (result == NULL)
- error (_("Could not find type for DW_OP_GNU_const_type"));
+ error (_("Could not find type for DW_OP_const_type"));
if (size != 0 && TYPE_LENGTH (result) != size)
- error (_("DW_OP_GNU_const_type has different sizes for type and data"));
+ error (_("DW_OP_const_type has different sizes for type and data"));
return result;
}
/* Callback function for dwarf2_evaluate_loc_desc.
- Fetch the address indexed by DW_OP_GNU_addr_index. */
+ Fetch the address indexed by DW_OP_addrx or DW_OP_GNU_addr_index. */
- CORE_ADDR get_addr_index (unsigned int index) OVERRIDE
+ CORE_ADDR get_addr_index (unsigned int index) override
{
return dwarf2_read_addr_index (per_cu, index);
}
/* Callback function for get_object_address. Return the address of the VLA
object. */
- CORE_ADDR get_object_address () OVERRIDE
+ CORE_ADDR get_object_address () override
{
if (obj_address == 0)
error (_("Location address is not set."));
void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind,
union call_site_parameter_u kind_u,
- int deref_size) OVERRIDE
+ int deref_size) override
{
struct frame_info *caller_frame;
struct dwarf2_per_cu_data *caller_per_cu;
/* DEREF_SIZE size is not verified here. */
if (data_src == NULL)
throw_error (NO_ENTRY_VALUE_ERROR,
- _("Cannot resolve DW_AT_GNU_call_site_data_value"));
+ _("Cannot resolve DW_AT_call_data_value"));
scoped_restore save_frame = make_scoped_restore (&this->frame,
caller_frame);
/* Using the frame specified in BATON, find the location expression
describing the frame base. Return a pointer to it in START and
its length in LENGTH. */
- void get_frame_base (const gdb_byte **start, size_t * length) OVERRIDE
+ void get_frame_base (const gdb_byte **start, size_t * length) override
{
/* FIXME: cagney/2003-03-26: This code should be using
get_frame_base_address(), and then implement a dwarf2 specific
/* Read memory at ADDR (length LEN) into BUF. */
- void read_mem (gdb_byte *buf, CORE_ADDR addr, size_t len) OVERRIDE
+ void read_mem (gdb_byte *buf, CORE_ADDR addr, size_t len) override
{
read_memory (addr, buf, len);
}
/* Using the frame specified in BATON, return the value of register
REGNUM, treated as a pointer. */
- CORE_ADDR read_addr_from_reg (int dwarf_regnum) OVERRIDE
+ CORE_ADDR read_addr_from_reg (int dwarf_regnum) override
{
struct gdbarch *gdbarch = get_frame_arch (frame);
int regnum = dwarf_reg_to_regnum_or_error (gdbarch, dwarf_regnum);
/* Implement "get_reg_value" callback. */
- struct value *get_reg_value (struct type *type, int dwarf_regnum) OVERRIDE
+ struct value *get_reg_value (struct type *type, int dwarf_regnum) override
{
struct gdbarch *gdbarch = get_frame_arch (frame);
int regnum = dwarf_reg_to_regnum_or_error (gdbarch, dwarf_regnum);
value);
}
-/* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
+/* Find DW_TAG_call_site's DW_AT_call_target address.
CALLER_FRAME (for registers) can be NULL if it is not known. This function
always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
throw_error (NO_ENTRY_VALUE_ERROR,
- _("DW_AT_GNU_call_site_target is not specified "
- "at %s in %s"),
+ _("DW_AT_call_target is not specified at %s in %s"),
paddress (call_site_gdbarch, call_site->pc),
(msym.minsym == NULL ? "???"
- : MSYMBOL_PRINT_NAME (msym.minsym)));
+ : msym.minsym->print_name ()));
}
if (caller_frame == NULL)
msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
throw_error (NO_ENTRY_VALUE_ERROR,
- _("DW_AT_GNU_call_site_target DWARF block resolving "
+ _("DW_AT_call_target DWARF block resolving "
"requires known frame which is currently not "
"available at %s in %s"),
paddress (call_site_gdbarch, call_site->pc),
(msym.minsym == NULL ? "???"
- : MSYMBOL_PRINT_NAME (msym.minsym)));
+ : msym.minsym->print_name ()));
}
caller_arch = get_frame_arch (caller_frame);
val = dwarf2_evaluate_loc_desc (caller_core_addr_type, caller_frame,
dwarf_block->data, dwarf_block->size,
dwarf_block->per_cu);
- /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
- location. */
+ /* DW_AT_call_target is a DWARF expression, not a DWARF location. */
if (VALUE_LVAL (val) == lval_memory)
return value_address (val);
else
"at %s in %s"),
physname, paddress (call_site_gdbarch, call_site->pc),
(msym.minsym == NULL ? "???"
- : MSYMBOL_PRINT_NAME (msym.minsym)));
+ : msym.minsym->print_name ()));
}
return BMSYMBOL_VALUE_ADDRESS (msym);
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_GNU_call_site resolving failed to find function "
+ _("DW_TAG_call_site resolving failed to find function "
"name for address %s"),
paddress (gdbarch, addr));
static void
func_verify_no_selftailcall (struct gdbarch *gdbarch, CORE_ADDR verify_addr)
{
- struct obstack addr_obstack;
- struct cleanup *old_chain;
CORE_ADDR addr;
- /* Track here CORE_ADDRs which were already visited. */
- htab_t addr_hash;
-
/* The verification is completely unordered. Track here function addresses
which still need to be iterated. */
- VEC (CORE_ADDR) *todo = NULL;
-
- obstack_init (&addr_obstack);
- old_chain = make_cleanup_obstack_free (&addr_obstack);
- addr_hash = htab_create_alloc_ex (64, core_addr_hash, core_addr_eq, NULL,
- &addr_obstack, hashtab_obstack_allocate,
- NULL);
- make_cleanup_htab_delete (addr_hash);
+ std::vector<CORE_ADDR> todo;
- make_cleanup (VEC_cleanup (CORE_ADDR), &todo);
+ /* Track here CORE_ADDRs which were already visited. */
+ std::unordered_set<CORE_ADDR> addr_hash;
- VEC_safe_push (CORE_ADDR, todo, verify_addr);
- while (!VEC_empty (CORE_ADDR, todo))
+ todo.push_back (verify_addr);
+ while (!todo.empty ())
{
struct symbol *func_sym;
struct call_site *call_site;
- addr = VEC_pop (CORE_ADDR, todo);
+ addr = todo.back ();
+ todo.pop_back ();
func_sym = func_addr_to_tail_call_list (gdbarch, addr);
call_site; call_site = call_site->tail_call_next)
{
CORE_ADDR target_addr;
- void **slot;
/* CALLER_FRAME with registers is not available for tail-call jumped
frames. */
msym = lookup_minimal_symbol_by_pc (verify_addr);
throw_error (NO_ENTRY_VALUE_ERROR,
- _("DW_OP_GNU_entry_value resolving has found "
+ _("DW_OP_entry_value resolving has found "
"function \"%s\" at %s can call itself via tail "
"calls"),
(msym.minsym == NULL ? "???"
- : MSYMBOL_PRINT_NAME (msym.minsym)),
+ : msym.minsym->print_name ()),
paddress (gdbarch, verify_addr));
}
- slot = htab_find_slot (addr_hash, &target_addr, INSERT);
- if (*slot == NULL)
- {
- *slot = obstack_copy (&addr_obstack, &target_addr,
- sizeof (target_addr));
- VEC_safe_push (CORE_ADDR, todo, target_addr);
- }
+ if (addr_hash.insert (target_addr).second)
+ todo.push_back (target_addr);
}
}
-
- do_cleanups (old_chain);
}
/* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
fprintf_unfiltered (gdb_stdlog, " %s(%s)", paddress (gdbarch, addr),
(msym.minsym == NULL ? "???"
- : MSYMBOL_PRINT_NAME (msym.minsym)));
+ : msym.minsym->print_name ()));
}
-/* vec.h needs single word type name, typedef it. */
-typedef struct call_site *call_sitep;
-
-/* Define VEC (call_sitep) functions. */
-DEF_VEC_P (call_sitep);
-
/* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
only top callers and bottom callees which are present in both. GDBARCH is
used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
responsible for xfree of any RESULTP data. */
static void
-chain_candidate (struct gdbarch *gdbarch, struct call_site_chain **resultp,
- VEC (call_sitep) *chain)
+chain_candidate (struct gdbarch *gdbarch,
+ gdb::unique_xmalloc_ptr<struct call_site_chain> *resultp,
+ std::vector<struct call_site *> *chain)
{
- struct call_site_chain *result = *resultp;
- long length = VEC_length (call_sitep, chain);
+ long length = chain->size ();
int callers, callees, idx;
- if (result == NULL)
+ if (*resultp == NULL)
{
/* Create the initial chain containing all the passed PCs. */
- result = ((struct call_site_chain *)
- xmalloc (sizeof (*result)
- + sizeof (*result->call_site) * (length - 1)));
+ struct call_site_chain *result
+ = ((struct call_site_chain *)
+ xmalloc (sizeof (*result)
+ + sizeof (*result->call_site) * (length - 1)));
result->length = length;
result->callers = result->callees = length;
- if (!VEC_empty (call_sitep, chain))
- memcpy (result->call_site, VEC_address (call_sitep, chain),
+ if (!chain->empty ())
+ memcpy (result->call_site, chain->data (),
sizeof (*result->call_site) * length);
- *resultp = result;
+ resultp->reset (result);
if (entry_values_debug)
{
{
fprintf_unfiltered (gdb_stdlog, "tailcall: compare:");
for (idx = 0; idx < length; idx++)
- tailcall_dump (gdbarch, VEC_index (call_sitep, chain, idx));
+ tailcall_dump (gdbarch, chain->at (idx));
fputc_unfiltered ('\n', gdb_stdlog);
}
/* Intersect callers. */
- callers = std::min ((long) result->callers, length);
+ callers = std::min ((long) (*resultp)->callers, length);
for (idx = 0; idx < callers; idx++)
- if (result->call_site[idx] != VEC_index (call_sitep, chain, idx))
+ if ((*resultp)->call_site[idx] != chain->at (idx))
{
- result->callers = idx;
+ (*resultp)->callers = idx;
break;
}
/* Intersect callees. */
- callees = std::min ((long) result->callees, length);
+ callees = std::min ((long) (*resultp)->callees, length);
for (idx = 0; idx < callees; idx++)
- if (result->call_site[result->length - 1 - idx]
- != VEC_index (call_sitep, chain, length - 1 - idx))
+ if ((*resultp)->call_site[(*resultp)->length - 1 - idx]
+ != chain->at (length - 1 - idx))
{
- result->callees = idx;
+ (*resultp)->callees = idx;
break;
}
if (entry_values_debug)
{
fprintf_unfiltered (gdb_stdlog, "tailcall: reduced:");
- for (idx = 0; idx < result->callers; idx++)
- tailcall_dump (gdbarch, result->call_site[idx]);
+ for (idx = 0; idx < (*resultp)->callers; idx++)
+ tailcall_dump (gdbarch, (*resultp)->call_site[idx]);
fputs_unfiltered (" |", gdb_stdlog);
- for (idx = 0; idx < result->callees; idx++)
- tailcall_dump (gdbarch, result->call_site[result->length
- - result->callees + idx]);
+ for (idx = 0; idx < (*resultp)->callees; idx++)
+ tailcall_dump (gdbarch,
+ (*resultp)->call_site[(*resultp)->length
+ - (*resultp)->callees + idx]);
fputc_unfiltered ('\n', gdb_stdlog);
}
- if (result->callers == 0 && result->callees == 0)
+ if ((*resultp)->callers == 0 && (*resultp)->callees == 0)
{
/* There are no common callers or callees. It could be also a direct
call (which has length 0) with ambiguous possibility of an indirect
call - CALLERS == CALLEES == 0 is valid during the first allocation
but any subsequence processing of such entry means ambiguity. */
- xfree (result);
- *resultp = NULL;
+ resultp->reset (NULL);
return;
}
/* See call_site_find_chain_1 why there is no way to reach the bottom callee
PC again. In such case there must be two different code paths to reach
it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
- gdb_assert (result->callers + result->callees <= result->length);
+ gdb_assert ((*resultp)->callers + (*resultp)->callees <= (*resultp)->length);
}
/* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
CORE_ADDR callee_pc)
{
CORE_ADDR save_callee_pc = callee_pc;
- struct obstack addr_obstack;
- struct cleanup *back_to_retval, *back_to_workdata;
- struct call_site_chain *retval = NULL;
+ gdb::unique_xmalloc_ptr<struct call_site_chain> retval;
struct call_site *call_site;
- /* Mark CALL_SITEs so we do not visit the same ones twice. */
- htab_t addr_hash;
-
/* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
call_site nor any possible call_site at CALLEE_PC's function is there.
Any CALL_SITE in CHAIN will be iterated to its siblings - via
TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
- VEC (call_sitep) *chain = NULL;
+ std::vector<struct call_site *> chain;
/* We are not interested in the specific PC inside the callee function. */
callee_pc = get_pc_function_start (callee_pc);
throw_error (NO_ENTRY_VALUE_ERROR, _("Unable to find function for PC %s"),
paddress (gdbarch, save_callee_pc));
- back_to_retval = make_cleanup (free_current_contents, &retval);
-
- obstack_init (&addr_obstack);
- back_to_workdata = make_cleanup_obstack_free (&addr_obstack);
- addr_hash = htab_create_alloc_ex (64, core_addr_hash, core_addr_eq, NULL,
- &addr_obstack, hashtab_obstack_allocate,
- NULL);
- make_cleanup_htab_delete (addr_hash);
-
- make_cleanup (VEC_cleanup (call_sitep), &chain);
+ /* Mark CALL_SITEs so we do not visit the same ones twice. */
+ std::unordered_set<CORE_ADDR> addr_hash;
/* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
at the target's function. All the possible tail call sites in the
if (target_func_addr == callee_pc)
{
- chain_candidate (gdbarch, &retval, chain);
+ chain_candidate (gdbarch, &retval, &chain);
if (retval == NULL)
break;
if (target_call_site)
{
- void **slot;
-
- slot = htab_find_slot (addr_hash, &target_call_site->pc, INSERT);
- if (*slot == NULL)
+ if (addr_hash.insert (target_call_site->pc).second)
{
/* Successfully entered TARGET_CALL_SITE. */
- *slot = &target_call_site->pc;
- VEC_safe_push (call_sitep, chain, target_call_site);
+ chain.push_back (target_call_site);
break;
}
}
sibling etc. */
target_call_site = NULL;
- while (!VEC_empty (call_sitep, chain))
+ while (!chain.empty ())
{
- call_site = VEC_pop (call_sitep, chain);
+ call_site = chain.back ();
+ chain.pop_back ();
- gdb_assert (htab_find_slot (addr_hash, &call_site->pc,
- NO_INSERT) != NULL);
- htab_remove_elt (addr_hash, &call_site->pc);
+ size_t removed = addr_hash.erase (call_site->pc);
+ gdb_assert (removed == 1);
target_call_site = call_site->tail_call_next;
if (target_call_site)
}
while (target_call_site);
- if (VEC_empty (call_sitep, chain))
+ if (chain.empty ())
call_site = NULL;
else
- call_site = VEC_last (call_sitep, chain);
+ call_site = chain.back ();
}
if (retval == NULL)
"callers or callees between caller function \"%s\" at %s "
"and callee function \"%s\" at %s"),
(msym_caller.minsym == NULL
- ? "???" : MSYMBOL_PRINT_NAME (msym_caller.minsym)),
+ ? "???" : msym_caller.minsym->print_name ()),
paddress (gdbarch, caller_pc),
(msym_callee.minsym == NULL
- ? "???" : MSYMBOL_PRINT_NAME (msym_callee.minsym)),
+ ? "???" : msym_callee.minsym->print_name ()),
paddress (gdbarch, callee_pc));
}
- do_cleanups (back_to_workdata);
- discard_cleanups (back_to_retval);
- return retval;
+ return retval.release ();
}
/* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
{
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;
}
case CALL_SITE_PARAMETER_FB_OFFSET:
return kind_u.fb_offset == parameter->u.fb_offset;
case CALL_SITE_PARAMETER_PARAM_OFFSET:
- return kind_u.param_offset.cu_off == parameter->u.param_offset.cu_off;
+ return kind_u.param_cu_off == parameter->u.param_cu_off;
}
return 0;
}
struct gdbarch *caller_gdbarch = frame_unwind_arch (frame);
throw_error (NO_ENTRY_VALUE_ERROR,
- _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
+ _("DW_OP_entry_value resolving callee gdbarch %s "
"(of %s (%s)) does not match caller gdbarch %s"),
gdbarch_bfd_arch_info (gdbarch)->printable_name,
paddress (gdbarch, func_addr),
(msym.minsym == NULL ? "???"
- : MSYMBOL_PRINT_NAME (msym.minsym)),
+ : msym.minsym->print_name ()),
gdbarch_bfd_arch_info (caller_gdbarch)->printable_name);
}
struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (func_addr);
- throw_error (NO_ENTRY_VALUE_ERROR, _("DW_OP_GNU_entry_value resolving "
+ throw_error (NO_ENTRY_VALUE_ERROR, _("DW_OP_entry_value resolving "
"requires caller of %s (%s)"),
paddress (gdbarch, func_addr),
(msym.minsym == NULL ? "???"
- : MSYMBOL_PRINT_NAME (msym.minsym)));
+ : msym.minsym->print_name ()));
}
caller_pc = get_frame_pc (caller_frame);
call_site = call_site_for_pc (gdbarch, caller_pc);
target_msym = lookup_minimal_symbol_by_pc (target_addr).minsym;
func_msym = lookup_minimal_symbol_by_pc (func_addr).minsym;
throw_error (NO_ENTRY_VALUE_ERROR,
- _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
+ _("DW_OP_entry_value resolving expects callee %s at %s "
"but the called frame is for %s at %s"),
(target_msym == NULL ? "???"
- : MSYMBOL_PRINT_NAME (target_msym)),
+ : target_msym->print_name ()),
paddress (gdbarch, target_addr),
- func_msym == NULL ? "???" : MSYMBOL_PRINT_NAME (func_msym),
+ func_msym == NULL ? "???" : func_msym->print_name (),
paddress (gdbarch, func_addr));
}
struct minimal_symbol *msym
= lookup_minimal_symbol_by_pc (caller_pc).minsym;
- /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
+ /* DW_TAG_call_site_parameter will be missing just if GCC could not
determine its value. */
throw_error (NO_ENTRY_VALUE_ERROR, _("Cannot find matching parameter "
- "at DW_TAG_GNU_call_site %s at %s"),
+ "at DW_TAG_call_site %s at %s"),
paddress (gdbarch, caller_pc),
- msym == NULL ? "???" : MSYMBOL_PRINT_NAME (msym));
+ msym == NULL ? "???" : msym->print_name ());
}
*per_cu_return = call_site->per_cu;
}
/* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
- the normal DW_AT_GNU_call_site_value block. Otherwise return the
- DW_AT_GNU_call_site_data_value (dereferenced) block.
+ the normal DW_AT_call_value block. Otherwise return the
+ DW_AT_call_data_value (dereferenced) block.
TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
struct value.
/* DEREF_SIZE size is not verified here. */
if (data_src == NULL)
throw_error (NO_ENTRY_VALUE_ERROR,
- _("Cannot resolve DW_AT_GNU_call_site_data_value"));
+ _("Cannot resolve DW_AT_call_data_value"));
- /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
+ /* DW_AT_call_value is a DWARF expression, not a DWARF
location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
DWARF block. */
data = (gdb_byte *) alloca (size + 1);
struct type *checked_type = check_typedef (value_type (value));
struct value *target_val;
- if (TYPE_CODE (checked_type) != TYPE_CODE_REF)
+ if (!TYPE_IS_REFERENCE (checked_type))
return NULL;
target_val = (struct value *) value_computed_closure (value);
{
struct value *target_val = (struct value *) value_computed_closure (v);
- value_free (target_val);
+ value_decref (target_val);
}
/* Vector for methods for an entry value reference where the referenced value
is stored in the caller. On the first dereference use
- DW_AT_GNU_call_site_data_value in the caller. */
+ DW_AT_call_data_value in the caller. */
static const struct lval_funcs entry_data_value_funcs =
{
/* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
are used to match DW_AT_location at the caller's
- DW_TAG_GNU_call_site_parameter.
+ DW_TAG_call_site_parameter.
Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
cannot resolve the parameter for any reason. */
type, caller_frame,
caller_per_cu);
- /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
+ /* Check if DW_AT_call_data_value cannot be used. If it should be
used and it is not available do not fall back to OUTER_VAL - dereferencing
TYPE_CODE_REF with non-entry data value would give current value - not the
entry value. */
- if (TYPE_CODE (checked_type) != TYPE_CODE_REF
+ if (!TYPE_IS_REFERENCE (checked_type)
|| TYPE_TARGET_TYPE (checked_type) == NULL)
return outer_val;
target_type, caller_frame,
caller_per_cu);
- release_value (target_val);
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),
/* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
SIZE are DWARF block used to match DW_AT_location at the caller's
- DW_TAG_GNU_call_site_parameter.
+ DW_TAG_call_site_parameter.
Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
cannot resolve the parameter for any reason. */
suppressed during normal operation. The expression can be arbitrary if
there is no caller-callee entry value binding expected. */
throw_error (NO_ENTRY_VALUE_ERROR,
- _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
+ _("DWARF-2 expression error: DW_OP_entry_value is supported "
"only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
}
struct piece_closure
{
/* Reference count. */
- int refc;
+ int refc = 0;
/* The CU from which this closure's expression came. */
- struct dwarf2_per_cu_data *per_cu;
-
- /* The number of pieces used to describe this variable. */
- int n_pieces;
+ struct dwarf2_per_cu_data *per_cu = NULL;
- /* The target address size, used only for DWARF_VALUE_STACK. */
- int addr_size;
-
- /* The pieces themselves. */
- struct dwarf_expr_piece *pieces;
+ /* The pieces describing this variable. */
+ std::vector<dwarf_expr_piece> pieces;
/* Frame ID of frame to which a register value is relative, used
only by DWARF_VALUE_REGISTER. */
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, struct frame_info *frame)
+ std::vector<dwarf_expr_piece> &&pieces,
+ struct frame_info *frame)
{
- struct piece_closure *c = XCNEW (struct piece_closure);
- int i;
+ struct piece_closure *c = new piece_closure;
c->refc = 1;
c->per_cu = per_cu;
- c->n_pieces = n_pieces;
- c->addr_size = addr_size;
- c->pieces = XCNEWVEC (struct dwarf_expr_piece, n_pieces);
+ c->pieces = std::move (pieces);
if (frame == NULL)
c->frame_id = null_frame_id;
else
c->frame_id = get_frame_id (frame);
- memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
- for (i = 0; i < n_pieces; ++i)
- if (c->pieces[i].location == DWARF_VALUE_STACK)
- value_incref (c->pieces[i].v.value);
+ for (dwarf_expr_piece &piece : c->pieces)
+ if (piece.location == DWARF_VALUE_STACK)
+ value_incref (piece.v.value);
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. */
+/* Return the number of bytes overlapping a contiguous chunk of N_BITS
+ bits whose first bit is located at bit offset START. */
-static void
-copy_bitwise (gdb_byte *dest, ULONGEST dest_offset,
- const gdb_byte *source, ULONGEST source_offset,
- ULONGEST nbits, int bits_big_endian)
+static size_t
+bits_to_bytes (ULONGEST start, ULONGEST n_bits)
{
- 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;
- }
+ return (start % 8 + n_bits + 7) / 8;
}
-#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. */
+/* Read or write a pieced value V. If FROM != NULL, operate in "write
+ mode": copy FROM into the pieces comprising V. If FROM == NULL,
+ operate in "read mode": fetch the contents of the (lazy) value V by
+ composing it from its pieces. */
static void
-bits_to_str (char *str, const gdb_byte *bits, ULONGEST offs,
- ULONGEST nbits, int msb0)
+rw_pieced_value (struct value *v, struct value *from)
{
- unsigned int j;
- size_t i;
+ int i;
+ LONGEST offset = 0, max_offset;
+ ULONGEST bits_to_skip;
+ gdb_byte *v_contents;
+ const gdb_byte *from_contents;
+ struct piece_closure *c
+ = (struct piece_closure *) value_computed_closure (v);
+ gdb::byte_vector buffer;
+ bool bits_big_endian = type_byte_order (value_type (v)) == BFD_ENDIAN_BIG;
- for (i = offs / 8, j = offs % 8; nbits; i++, j = 0)
+ if (from != NULL)
{
- unsigned int ch = bits[i];
- for (; j < 8 && nbits; j++, nbits--)
- *str++ = (ch & (msb0 ? (1 << (7 - j)) : (1 << j))) ? '1' : '0';
+ from_contents = value_contents (from);
+ v_contents = NULL;
}
-}
-
-/* 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++)
+ else
{
- 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);
+ if (value_type (v) != value_enclosing_type (v))
+ internal_error (__FILE__, __LINE__,
+ _("Should not be able to create a lazy value with "
+ "an enclosing type"));
+ v_contents = value_contents_raw (v);
+ from_contents = NULL;
}
-}
-
-} /* namespace selftests */
-
-#endif /* GDB_SELF_TEST */
-static void
-read_pieced_value (struct value *v)
-{
- int i;
- long offset = 0;
- ULONGEST bits_to_skip;
- gdb_byte *contents;
- struct piece_closure *c
- = (struct piece_closure *) value_computed_closure (v);
- size_t type_len;
- size_t buffer_size = 0;
- std::vector<gdb_byte> buffer;
- int bits_big_endian
- = gdbarch_bits_big_endian (get_type_arch (value_type (v)));
-
- if (value_type (v) != value_enclosing_type (v))
- internal_error (__FILE__, __LINE__,
- _("Should not be able to create a lazy value with "
- "an enclosing type"));
-
- contents = value_contents_raw (v);
bits_to_skip = 8 * value_offset (v);
if (value_bitsize (v))
{
- bits_to_skip += value_bitpos (v);
- type_len = value_bitsize (v);
+ bits_to_skip += (8 * value_offset (value_parent (v))
+ + value_bitpos (v));
+ if (from != NULL
+ && (type_byte_order (value_type (from))
+ == BFD_ENDIAN_BIG))
+ {
+ /* Use the least significant bits of FROM. */
+ max_offset = 8 * TYPE_LENGTH (value_type (from));
+ offset = max_offset - value_bitsize (v);
+ }
+ else
+ max_offset = value_bitsize (v);
}
else
- type_len = 8 * TYPE_LENGTH (value_type (v));
+ max_offset = 8 * TYPE_LENGTH (value_type (v));
+
+ /* Advance to the first non-skipped piece. */
+ for (i = 0; i < c->pieces.size () && bits_to_skip >= c->pieces[i].size; i++)
+ bits_to_skip -= c->pieces[i].size;
- for (i = 0; i < c->n_pieces && offset < type_len; i++)
+ for (; i < c->pieces.size () && offset < max_offset; i++)
{
struct dwarf_expr_piece *p = &c->pieces[i];
- size_t this_size, this_size_bits;
- long dest_offset_bits, source_offset_bits, source_offset;
- const gdb_byte *intermediate_buffer;
-
- /* Compute size, source, and destination offsets for copying, in
- bits. */
- this_size_bits = p->size;
- if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
- {
- bits_to_skip -= this_size_bits;
- continue;
- }
- if (bits_to_skip > 0)
- {
- dest_offset_bits = 0;
- source_offset_bits = bits_to_skip;
- this_size_bits -= bits_to_skip;
- bits_to_skip = 0;
- }
- else
- {
- dest_offset_bits = offset;
- source_offset_bits = 0;
- }
- if (this_size_bits > type_len - offset)
- this_size_bits = type_len - offset;
+ size_t this_size_bits, this_size;
- this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
- source_offset = source_offset_bits / 8;
- if (buffer_size < this_size)
- {
- buffer_size = this_size;
- buffer.reserve (buffer_size);
- }
- intermediate_buffer = buffer.data ();
+ this_size_bits = p->size - bits_to_skip;
+ if (this_size_bits > max_offset - offset)
+ this_size_bits = max_offset - offset;
- /* Copy from the source to DEST_BUFFER. */
switch (p->location)
{
case DWARF_VALUE_REGISTER:
struct frame_info *frame = frame_find_by_id (c->frame_id);
struct gdbarch *arch = get_frame_arch (frame);
int gdb_regnum = dwarf_reg_to_regnum_or_error (arch, p->v.regno);
+ ULONGEST reg_bits = 8 * register_size (arch, gdb_regnum);
int optim, unavail;
- LONGEST reg_offset = source_offset;
if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
- && this_size < register_size (arch, gdb_regnum))
+ && p->offset + p->size < reg_bits)
{
/* Big-endian, and we want less than full size. */
- reg_offset = register_size (arch, gdb_regnum) - this_size;
- /* We want the lower-order THIS_SIZE_BITS of the bytes
- we extract from the register. */
- source_offset_bits += 8 * this_size - this_size_bits;
+ bits_to_skip += reg_bits - (p->offset + p->size);
}
+ else
+ bits_to_skip += p->offset;
- if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
- this_size, buffer.data (),
- &optim, &unavail))
+ this_size = bits_to_bytes (bits_to_skip, this_size_bits);
+ buffer.resize (this_size);
+
+ if (from == NULL)
{
- /* Just so garbage doesn't ever shine through. */
- memset (buffer.data (), 0, this_size);
+ /* Read mode. */
+ if (!get_frame_register_bytes (frame, gdb_regnum,
+ bits_to_skip / 8,
+ this_size, buffer.data (),
+ &optim, &unavail))
+ {
+ if (optim)
+ mark_value_bits_optimized_out (v, offset,
+ this_size_bits);
+ if (unavail)
+ mark_value_bits_unavailable (v, offset,
+ this_size_bits);
+ break;
+ }
- if (optim)
- mark_value_bits_optimized_out (v, offset, this_size_bits);
- if (unavail)
- mark_value_bits_unavailable (v, offset, this_size_bits);
+ copy_bitwise (v_contents, offset,
+ buffer.data (), bits_to_skip % 8,
+ this_size_bits, bits_big_endian);
+ }
+ else
+ {
+ /* Write mode. */
+ if (bits_to_skip % 8 != 0 || this_size_bits % 8 != 0)
+ {
+ /* Data is copied non-byte-aligned into the register.
+ Need some bits from original register value. */
+ get_frame_register_bytes (frame, gdb_regnum,
+ bits_to_skip / 8,
+ this_size, buffer.data (),
+ &optim, &unavail);
+ if (optim)
+ throw_error (OPTIMIZED_OUT_ERROR,
+ _("Can't do read-modify-write to "
+ "update bitfield; containing word "
+ "has been optimized out"));
+ if (unavail)
+ throw_error (NOT_AVAILABLE_ERROR,
+ _("Can't do read-modify-write to "
+ "update bitfield; containing word "
+ "is unavailable"));
+ }
+
+ copy_bitwise (buffer.data (), bits_to_skip % 8,
+ from_contents, offset,
+ this_size_bits, bits_big_endian);
+ put_frame_register_bytes (frame, gdb_regnum,
+ bits_to_skip / 8,
+ this_size, buffer.data ());
}
}
break;
case DWARF_VALUE_MEMORY:
- read_value_memory (v, offset,
- p->v.mem.in_stack_memory,
- p->v.mem.addr + source_offset,
- buffer.data (), this_size);
- break;
-
- case DWARF_VALUE_STACK:
{
- size_t n = this_size;
+ bits_to_skip += p->offset;
- if (n > c->addr_size - source_offset)
- n = (c->addr_size >= source_offset
- ? c->addr_size - source_offset
- : 0);
- if (n == 0)
+ CORE_ADDR start_addr = p->v.mem.addr + bits_to_skip / 8;
+
+ if (bits_to_skip % 8 == 0 && this_size_bits % 8 == 0
+ && offset % 8 == 0)
+ {
+ /* Everything is byte-aligned; no buffer needed. */
+ if (from != NULL)
+ write_memory_with_notification (start_addr,
+ (from_contents
+ + offset / 8),
+ this_size_bits / 8);
+ else
+ read_value_memory (v, offset,
+ p->v.mem.in_stack_memory,
+ p->v.mem.addr + bits_to_skip / 8,
+ v_contents + offset / 8,
+ this_size_bits / 8);
+ break;
+ }
+
+ this_size = bits_to_bytes (bits_to_skip, this_size_bits);
+ buffer.resize (this_size);
+
+ if (from == NULL)
{
- /* Nothing. */
+ /* Read mode. */
+ read_value_memory (v, offset,
+ p->v.mem.in_stack_memory,
+ p->v.mem.addr + bits_to_skip / 8,
+ buffer.data (), this_size);
+ copy_bitwise (v_contents, offset,
+ buffer.data (), bits_to_skip % 8,
+ this_size_bits, bits_big_endian);
}
else
{
- const gdb_byte *val_bytes = value_contents_all (p->v.value);
+ /* Write mode. */
+ if (bits_to_skip % 8 != 0 || this_size_bits % 8 != 0)
+ {
+ if (this_size <= 8)
+ {
+ /* Perform a single read for small sizes. */
+ read_memory (start_addr, buffer.data (),
+ this_size);
+ }
+ else
+ {
+ /* Only the first and last bytes can possibly have
+ any bits reused. */
+ read_memory (start_addr, buffer.data (), 1);
+ read_memory (start_addr + this_size - 1,
+ &buffer[this_size - 1], 1);
+ }
+ }
+
+ copy_bitwise (buffer.data (), bits_to_skip % 8,
+ from_contents, offset,
+ this_size_bits, bits_big_endian);
+ write_memory_with_notification (start_addr,
+ buffer.data (),
+ this_size);
+ }
+ }
+ break;
- intermediate_buffer = val_bytes + source_offset;
+ case DWARF_VALUE_STACK:
+ {
+ if (from != NULL)
+ {
+ mark_value_bits_optimized_out (v, offset, this_size_bits);
+ break;
}
+
+ struct objfile *objfile = dwarf2_per_cu_objfile (c->per_cu);
+ struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
+ ULONGEST stack_value_size_bits
+ = 8 * TYPE_LENGTH (value_type (p->v.value));
+
+ /* Use zeroes if piece reaches beyond stack value. */
+ if (p->offset + p->size > stack_value_size_bits)
+ break;
+
+ /* Piece is anchored at least significant bit end. */
+ if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
+ bits_to_skip += stack_value_size_bits - p->offset - p->size;
+ else
+ bits_to_skip += p->offset;
+
+ copy_bitwise (v_contents, offset,
+ value_contents_all (p->v.value),
+ bits_to_skip,
+ this_size_bits, bits_big_endian);
}
break;
case DWARF_VALUE_LITERAL:
{
- size_t n = this_size;
-
- if (n > p->v.literal.length - source_offset)
- n = (p->v.literal.length >= source_offset
- ? p->v.literal.length - source_offset
- : 0);
- if (n != 0)
- intermediate_buffer = p->v.literal.data + source_offset;
+ if (from != NULL)
+ {
+ mark_value_bits_optimized_out (v, offset, this_size_bits);
+ break;
+ }
+
+ ULONGEST literal_size_bits = 8 * p->v.literal.length;
+ size_t n = this_size_bits;
+
+ /* Cut off at the end of the implicit value. */
+ bits_to_skip += p->offset;
+ if (bits_to_skip >= literal_size_bits)
+ break;
+ if (n > literal_size_bits - bits_to_skip)
+ n = literal_size_bits - bits_to_skip;
+
+ copy_bitwise (v_contents, offset,
+ p->v.literal.data, bits_to_skip,
+ n, bits_big_endian);
}
break;
- /* These bits show up as zeros -- but do not cause the value
- to be considered optimized-out. */
case DWARF_VALUE_IMPLICIT_POINTER:
+ if (from != NULL)
+ {
+ mark_value_bits_optimized_out (v, offset, this_size_bits);
+ break;
+ }
+
+ /* These bits show up as zeros -- but do not cause the value to
+ be considered optimized-out. */
break;
case DWARF_VALUE_OPTIMIZED_OUT:
internal_error (__FILE__, __LINE__, _("invalid location type"));
}
- if (p->location != DWARF_VALUE_OPTIMIZED_OUT
- && p->location != DWARF_VALUE_IMPLICIT_POINTER)
- copy_bitwise (contents, dest_offset_bits,
- intermediate_buffer, source_offset_bits % 8,
- this_size_bits, bits_big_endian);
-
offset += this_size_bits;
+ bits_to_skip = 0;
}
}
+
static void
-write_pieced_value (struct value *to, struct value *from)
+read_pieced_value (struct value *v)
{
- int i;
- long offset = 0;
- ULONGEST bits_to_skip;
- const gdb_byte *contents;
- struct piece_closure *c
- = (struct piece_closure *) value_computed_closure (to);
- struct frame_info *frame;
- size_t type_len;
- size_t buffer_size = 0;
- std::vector<gdb_byte> buffer;
- int bits_big_endian
- = gdbarch_bits_big_endian (get_type_arch (value_type (to)));
-
- /* VALUE_FRAME_ID is used instead of VALUE_NEXT_FRAME_ID here
- because FRAME is passed to get_frame_register_bytes() and
- put_frame_register_bytes(), both of which do their own "->next"
- operations. */
- frame = frame_find_by_id (VALUE_FRAME_ID (to));
- if (frame == NULL)
- {
- mark_value_bytes_optimized_out (to, 0, TYPE_LENGTH (value_type (to)));
- return;
- }
-
- contents = value_contents (from);
- bits_to_skip = 8 * value_offset (to);
- if (value_bitsize (to))
- {
- bits_to_skip += value_bitpos (to);
- type_len = value_bitsize (to);
- }
- else
- type_len = 8 * TYPE_LENGTH (value_type (to));
-
- for (i = 0; i < c->n_pieces && offset < type_len; i++)
- {
- struct dwarf_expr_piece *p = &c->pieces[i];
- size_t this_size_bits, this_size;
- long dest_offset_bits, source_offset_bits, dest_offset, source_offset;
- int need_bitwise;
- const gdb_byte *source_buffer;
-
- this_size_bits = p->size;
- if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
- {
- bits_to_skip -= this_size_bits;
- continue;
- }
- if (this_size_bits > type_len - offset)
- this_size_bits = type_len - offset;
- if (bits_to_skip > 0)
- {
- dest_offset_bits = bits_to_skip;
- source_offset_bits = 0;
- this_size_bits -= bits_to_skip;
- bits_to_skip = 0;
- }
- else
- {
- dest_offset_bits = 0;
- source_offset_bits = offset;
- }
-
- this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
- source_offset = source_offset_bits / 8;
- dest_offset = dest_offset_bits / 8;
- if (dest_offset_bits % 8 == 0 && source_offset_bits % 8 == 0)
- {
- source_buffer = contents + source_offset;
- need_bitwise = 0;
- }
- else
- {
- if (buffer_size < this_size)
- {
- buffer_size = this_size;
- buffer.reserve (buffer_size);
- }
- source_buffer = buffer.data ();
- need_bitwise = 1;
- }
-
- switch (p->location)
- {
- case DWARF_VALUE_REGISTER:
- {
- struct gdbarch *arch = get_frame_arch (frame);
- int gdb_regnum = dwarf_reg_to_regnum_or_error (arch, p->v.regno);
- int reg_offset = dest_offset;
-
- if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
- && this_size <= register_size (arch, gdb_regnum))
- {
- /* Big-endian, and we want less than full size. */
- reg_offset = register_size (arch, gdb_regnum) - this_size;
- }
-
- if (need_bitwise)
- {
- int optim, unavail;
-
- if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
- this_size, buffer.data (),
- &optim, &unavail))
- {
- if (optim)
- throw_error (OPTIMIZED_OUT_ERROR,
- _("Can't do read-modify-write to "
- "update bitfield; containing word "
- "has been optimized out"));
- if (unavail)
- throw_error (NOT_AVAILABLE_ERROR,
- _("Can't do read-modify-write to update "
- "bitfield; containing word "
- "is unavailable"));
- }
- copy_bitwise (buffer.data (), dest_offset_bits,
- contents, source_offset_bits,
- this_size_bits,
- bits_big_endian);
- }
-
- put_frame_register_bytes (frame, gdb_regnum, reg_offset,
- this_size, source_buffer);
- }
- break;
- case DWARF_VALUE_MEMORY:
- if (need_bitwise)
- {
- /* Only the first and last bytes can possibly have any
- bits reused. */
- read_memory (p->v.mem.addr + dest_offset, buffer.data (), 1);
- read_memory (p->v.mem.addr + dest_offset + this_size - 1,
- &buffer[this_size - 1], 1);
- copy_bitwise (buffer.data (), dest_offset_bits,
- contents, source_offset_bits,
- this_size_bits,
- bits_big_endian);
- }
+ rw_pieced_value (v, NULL);
+}
- write_memory (p->v.mem.addr + dest_offset,
- source_buffer, this_size);
- break;
- default:
- mark_value_bytes_optimized_out (to, 0, TYPE_LENGTH (value_type (to)));
- break;
- }
- offset += this_size_bits;
- }
+static void
+write_pieced_value (struct value *to, struct value *from)
+{
+ rw_pieced_value (to, from);
}
/* An implementation of an lval_funcs method to see whether a value is
if (value_bitsize (value))
bit_offset += value_bitpos (value);
- for (i = 0; i < c->n_pieces && bit_length > 0; i++)
+ for (i = 0; i < c->pieces.size () && bit_length > 0; i++)
{
struct dwarf_expr_piece *p = &c->pieces[i];
size_t this_size_bits = p->size;
struct type *type)
{
struct value *result = NULL;
- struct obstack temp_obstack;
- struct cleanup *cleanup;
const gdb_byte *bytes;
LONGEST len;
- obstack_init (&temp_obstack);
- cleanup = make_cleanup_obstack_free (&temp_obstack);
+ auto_obstack temp_obstack;
bytes = dwarf2_fetch_constant_bytes (die, per_cu, &temp_obstack, &len);
if (bytes != NULL)
else
result = allocate_optimized_out_value (TYPE_TARGET_TYPE (type));
- do_cleanups (cleanup);
-
return result;
}
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);
+ if (orig_type == NULL)
+ invalid_synthetic_pointer ();
/* If pointed-to DIE has a DW_AT_location, evaluate it and return the
resulting value. Otherwise, it may have a DW_AT_const_value instead,
or it may've been optimized out. */
if (baton.data != NULL)
- return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
- baton.data, baton.size, baton.per_cu,
+ return dwarf2_evaluate_loc_desc_full (orig_type, frame, baton.data,
+ baton.size, baton.per_cu,
+ TYPE_TARGET_TYPE (type),
byte_offset);
else
return fetch_const_value_from_synthetic_pointer (die, byte_offset, per_cu,
= (struct piece_closure *) value_computed_closure (value);
struct type *type;
struct frame_info *frame;
- struct dwarf2_locexpr_baton baton;
int i, bit_length;
LONGEST bit_offset;
struct dwarf_expr_piece *piece = NULL;
if (value_bitsize (value))
bit_offset += value_bitpos (value);
- for (i = 0; i < c->n_pieces && bit_length > 0; i++)
+ for (i = 0; i < c->pieces.size () && bit_length > 0; i++)
{
struct dwarf_expr_piece *p = &c->pieces[i];
size_t this_size_bits = p->size;
return NULL;
if (bit_length != 0)
- error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
+ error (_("Invalid use of DW_OP_implicit_pointer"));
piece = p;
break;
TYPE_LENGTH (type), byte_order);
byte_offset += piece->v.ptr.offset;
- return indirect_synthetic_pointer (piece->v.ptr.die, byte_offset, c->per_cu,
+ return indirect_synthetic_pointer (piece->v.ptr.die_sect_off,
+ byte_offset, c->per_cu,
frame, type);
}
/* gdb represents synthetic pointers as pieced values with a single
piece. */
gdb_assert (closure != NULL);
- gdb_assert (closure->n_pieces == 1);
+ gdb_assert (closure->pieces.size () == 1);
- return indirect_synthetic_pointer (closure->pieces->v.ptr.die,
- closure->pieces->v.ptr.offset,
- closure->per_cu, frame, type);
+ return indirect_synthetic_pointer
+ (closure->pieces[0].v.ptr.die_sect_off,
+ closure->pieces[0].v.ptr.offset,
+ closure->per_cu, frame, type);
}
else
{
--c->refc;
if (c->refc == 0)
{
- int i;
+ for (dwarf_expr_piece &p : c->pieces)
+ if (p.location == DWARF_VALUE_STACK)
+ value_decref (p.v.value);
- for (i = 0; i < c->n_pieces; ++i)
- if (c->pieces[i].location == DWARF_VALUE_STACK)
- value_free (c->pieces[i].v.value);
-
- xfree (c->pieces);
- xfree (c);
+ delete c;
}
}
/* Evaluate a location description, starting at DATA and with length
SIZE, to find the current location of variable of TYPE in the
- context of FRAME. BYTE_OFFSET is applied after the contents are
- computed. */
+ context of FRAME. If SUBOBJ_TYPE is non-NULL, return instead the
+ location of the subobject of type SUBOBJ_TYPE at byte offset
+ SUBOBJ_BYTE_OFFSET within the variable of type TYPE. */
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)
+ struct type *subobj_type,
+ LONGEST subobj_byte_offset)
{
struct value *retval;
- struct cleanup *value_chain;
struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
- if (byte_offset < 0)
+ if (subobj_type == NULL)
+ {
+ subobj_type = type;
+ subobj_byte_offset = 0;
+ }
+ else if (subobj_byte_offset < 0)
invalid_synthetic_pointer ();
if (size == 0)
- return allocate_optimized_out_value (type);
+ return allocate_optimized_out_value (subobj_type);
dwarf_evaluate_loc_desc ctx;
ctx.frame = frame;
ctx.per_cu = per_cu;
ctx.obj_address = 0;
- value_chain = make_cleanup_value_free_to_mark (value_mark ());
+ scoped_value_mark free_values;
ctx.gdbarch = get_objfile_arch (objfile);
ctx.addr_size = dwarf2_per_cu_addr_size (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)
{
- do_cleanups (value_chain);
- retval = allocate_value (type);
- mark_value_bytes_unavailable (retval, 0, TYPE_LENGTH (type));
+ free_values.free_to_mark ();
+ retval = allocate_value (subobj_type);
+ mark_value_bytes_unavailable (retval, 0,
+ TYPE_LENGTH (subobj_type));
return retval;
}
else if (ex.error == NO_ENTRY_VALUE_ERROR)
{
if (entry_values_debug)
exception_print (gdb_stdout, ex);
- do_cleanups (value_chain);
- return allocate_optimized_out_value (type);
+ free_values.free_to_mark ();
+ return allocate_optimized_out_value (subobj_type);
}
else
- throw_exception (ex);
+ throw;
}
- END_CATCH
- if (ctx.num_pieces > 0)
+ if (ctx.pieces.size () > 0)
{
struct piece_closure *c;
ULONGEST bit_size = 0;
- int i;
- for (i = 0; i < ctx.num_pieces; ++i)
- bit_size += ctx.pieces[i].size;
- if (8 * (byte_offset + TYPE_LENGTH (type)) > bit_size)
+ for (dwarf_expr_piece &piece : ctx.pieces)
+ bit_size += piece.size;
+ /* Complain if the expression is larger than the size of the
+ outer type. */
+ if (bit_size > 8 * TYPE_LENGTH (type))
invalid_synthetic_pointer ();
- c = allocate_piece_closure (per_cu, ctx.num_pieces, ctx.pieces,
- ctx.addr_size, frame);
+ c = allocate_piece_closure (per_cu, std::move (ctx.pieces), frame);
/* We must clean up the value chain after creating the piece
closure but before allocating the result. */
- do_cleanups (value_chain);
- retval = allocate_computed_value (type, &pieced_value_funcs, c);
- set_value_offset (retval, byte_offset);
+ free_values.free_to_mark ();
+ retval = allocate_computed_value (subobj_type,
+ &pieced_value_funcs, c);
+ set_value_offset (retval, subobj_byte_offset);
}
else
{
= longest_to_int (value_as_long (ctx.fetch (0)));
int gdb_regnum = dwarf_reg_to_regnum_or_error (arch, dwarf_regnum);
- if (byte_offset != 0)
+ if (subobj_byte_offset != 0)
error (_("cannot use offset on synthetic pointer to register"));
- do_cleanups (value_chain);
- retval = value_from_register (type, gdb_regnum, frame);
+ free_values.free_to_mark ();
+ retval = value_from_register (subobj_type, gdb_regnum, frame);
if (value_optimized_out (retval))
{
struct value *tmp;
inspecting a register ($pc, $sp, etc.), return a
generic optimized out value instead, so that we show
<optimized out> instead of <not saved>. */
- do_cleanups (value_chain);
- tmp = allocate_value (type);
- value_contents_copy (tmp, 0, retval, 0, TYPE_LENGTH (type));
+ tmp = allocate_value (subobj_type);
+ value_contents_copy (tmp, 0, retval, 0,
+ TYPE_LENGTH (subobj_type));
retval = tmp;
}
}
{
struct type *ptr_type;
CORE_ADDR address = ctx.fetch_address (0);
- int in_stack_memory = ctx.fetch_in_stack_memory (0);
+ bool in_stack_memory = ctx.fetch_in_stack_memory (0);
/* DW_OP_deref_size (and possibly other operations too) may
create a pointer instead of an address. Ideally, the
the operation. Therefore, we do the conversion here
since the type is readily available. */
- switch (TYPE_CODE (type))
+ switch (TYPE_CODE (subobj_type))
{
case TYPE_CODE_FUNC:
case TYPE_CODE_METHOD:
}
address = value_as_address (value_from_pointer (ptr_type, address));
- do_cleanups (value_chain);
- retval = value_at_lazy (type, address + byte_offset);
+ free_values.free_to_mark ();
+ retval = value_at_lazy (subobj_type,
+ address + subobj_byte_offset);
if (in_stack_memory)
set_value_stack (retval, 1);
}
case DWARF_VALUE_STACK:
{
struct value *value = ctx.fetch (0);
- gdb_byte *contents;
- const gdb_byte *val_bytes;
size_t n = TYPE_LENGTH (value_type (value));
+ size_t len = TYPE_LENGTH (subobj_type);
+ size_t max = TYPE_LENGTH (type);
+ struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
- if (byte_offset + TYPE_LENGTH (type) > n)
+ if (subobj_byte_offset + len > max)
invalid_synthetic_pointer ();
- val_bytes = value_contents_all (value);
- val_bytes += byte_offset;
- n -= byte_offset;
-
/* Preserve VALUE because we are going to free values back
to the mark, but we still need the value contents
below. */
- value_incref (value);
- do_cleanups (value_chain);
- make_cleanup_value_free (value);
+ value_ref_ptr value_holder = value_ref_ptr::new_reference (value);
+ free_values.free_to_mark ();
- retval = allocate_value (type);
- contents = value_contents_raw (retval);
- if (n > TYPE_LENGTH (type))
- {
- struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
+ retval = allocate_value (subobj_type);
- if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
- val_bytes += n - TYPE_LENGTH (type);
- n = TYPE_LENGTH (type);
- }
- memcpy (contents, val_bytes, n);
+ /* The given offset is relative to the actual object. */
+ if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
+ subobj_byte_offset += n - max;
+
+ memcpy (value_contents_raw (retval),
+ value_contents_all (value) + subobj_byte_offset, len);
}
break;
case DWARF_VALUE_LITERAL:
{
bfd_byte *contents;
- const bfd_byte *ldata;
- size_t n = ctx.len;
+ size_t n = TYPE_LENGTH (subobj_type);
- if (byte_offset + TYPE_LENGTH (type) > n)
+ if (subobj_byte_offset + n > ctx.len)
invalid_synthetic_pointer ();
- do_cleanups (value_chain);
- retval = allocate_value (type);
+ free_values.free_to_mark ();
+ retval = allocate_value (subobj_type);
contents = value_contents_raw (retval);
-
- ldata = ctx.data + byte_offset;
- n -= byte_offset;
-
- if (n > TYPE_LENGTH (type))
- {
- struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
-
- if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
- ldata += n - TYPE_LENGTH (type);
- n = TYPE_LENGTH (type);
- }
- memcpy (contents, ldata, n);
+ memcpy (contents, ctx.data + subobj_byte_offset, n);
}
break;
case DWARF_VALUE_OPTIMIZED_OUT:
- do_cleanups (value_chain);
- retval = allocate_optimized_out_value (type);
+ free_values.free_to_mark ();
+ retval = allocate_optimized_out_value (subobj_type);
break;
/* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
set_value_initialized (retval, ctx.initialized);
- do_cleanups (value_chain);
-
return retval;
}
const gdb_byte *data, size_t size,
struct dwarf2_per_cu_data *per_cu)
{
- return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu, 0);
+ return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu,
+ NULL, 0);
}
/* Evaluates a dwarf expression and stores the result in VAL, expecting
CORE_ADDR *valp)
{
struct objfile *objfile;
- struct cleanup *cleanup;
if (dlbaton == NULL || dlbaton->size == 0)
return 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. */
-int
+bool
dwarf2_evaluate_property (const struct dynamic_prop *prop,
struct frame_info *frame,
struct property_addr_info *addr_stack,
CORE_ADDR *value)
{
if (prop == NULL)
- return 0;
+ return false;
if (frame == NULL && has_stack_frames ())
frame = get_selected_frame (NULL);
{
const struct dwarf2_property_baton *baton
= (const struct dwarf2_property_baton *) prop->data.baton;
+ gdb_assert (baton->property_type != NULL);
if (dwarf2_locexpr_baton_eval (&baton->locexpr, frame,
addr_stack ? addr_stack->addr : 0,
value))
{
- if (baton->referenced_type)
+ if (baton->locexpr.is_reference)
{
- struct value *val = value_at (baton->referenced_type, *value);
-
+ struct value *val = value_at (baton->property_type, *value);
*value = value_as_address (val);
}
- return 1;
+ else
+ {
+ gdb_assert (baton->property_type != NULL);
+
+ struct type *type = check_typedef (baton->property_type);
+ if (TYPE_LENGTH (type) < sizeof (CORE_ADDR)
+ && !TYPE_UNSIGNED (type))
+ {
+ /* If we have a valid return candidate and it's value
+ is signed, we have to sign-extend the value because
+ CORE_ADDR on 64bit machine has 8 bytes but address
+ size of an 32bit application is bytes. */
+ const int addr_size
+ = (dwarf2_per_cu_addr_size (baton->locexpr.per_cu)
+ * TARGET_CHAR_BIT);
+ const CORE_ADDR neg_mask
+ = (~((CORE_ADDR) 0) << (addr_size - 1));
+
+ /* Check if signed bit is set and sign-extend values. */
+ if (*value & neg_mask)
+ *value |= neg_mask;
+ }
+ }
+ return true;
}
}
break;
data = dwarf2_find_location_expression (&baton->loclist, &size, pc);
if (data != NULL)
{
- val = dwarf2_evaluate_loc_desc (baton->referenced_type, frame, data,
+ val = dwarf2_evaluate_loc_desc (baton->property_type, frame, data,
size, baton->loclist.per_cu);
if (!value_optimized_out (val))
{
*value = value_as_address (val);
- return 1;
+ return true;
}
}
}
case PROP_CONST:
*value = prop->data.const_val;
- return 1;
+ return true;
case PROP_ADDR_OFFSET:
{
struct value *val;
for (pinfo = addr_stack; pinfo != NULL; pinfo = pinfo->next)
- if (pinfo->type == baton->referenced_type)
- break;
+ {
+ /* This approach lets us avoid checking the qualifiers. */
+ if (TYPE_MAIN_TYPE (pinfo->type)
+ == TYPE_MAIN_TYPE (baton->property_type))
+ break;
+ }
if (pinfo == NULL)
error (_("cannot find reference address for offset property"));
if (pinfo->valaddr != NULL)
val = value_at (baton->offset_info.type,
pinfo->addr + baton->offset_info.offset);
*value = value_as_address (val);
- return 1;
+ return true;
}
}
- return 0;
+ return false;
}
/* See dwarf2loc.h. */
void
-dwarf2_compile_property_to_c (struct ui_file *stream,
+dwarf2_compile_property_to_c (string_file *stream,
const char *result_name,
struct gdbarch *gdbarch,
unsigned char *registers_used,
struct dwarf2_per_cu_data *per_cu;
/* Reads from registers do require a frame. */
- CORE_ADDR read_addr_from_reg (int regnum) OVERRIDE
+ CORE_ADDR read_addr_from_reg (int regnum) override
{
needs = SYMBOL_NEEDS_FRAME;
return 1;
/* "get_reg_value" callback: Reads from registers do require a
frame. */
- struct value *get_reg_value (struct type *type, int regnum) OVERRIDE
+ struct value *get_reg_value (struct type *type, int regnum) override
{
needs = SYMBOL_NEEDS_FRAME;
return value_zero (type, not_lval);
}
/* Reads from memory do not require a frame. */
- void read_mem (gdb_byte *buf, CORE_ADDR addr, size_t len) OVERRIDE
+ void read_mem (gdb_byte *buf, CORE_ADDR addr, size_t len) override
{
memset (buf, 0, len);
}
/* Frame-relative accesses do require a frame. */
- void get_frame_base (const gdb_byte **start, size_t *length) OVERRIDE
+ void get_frame_base (const gdb_byte **start, size_t *length) override
{
static gdb_byte lit0 = DW_OP_lit0;
}
/* CFA accesses require a frame. */
- CORE_ADDR get_frame_cfa () OVERRIDE
+ CORE_ADDR get_frame_cfa () override
{
needs = SYMBOL_NEEDS_FRAME;
return 1;
}
- CORE_ADDR get_frame_pc () OVERRIDE
+ CORE_ADDR get_frame_pc () override
{
needs = SYMBOL_NEEDS_FRAME;
return 1;
}
/* Thread-local accesses require registers, but not a frame. */
- CORE_ADDR get_tls_address (CORE_ADDR offset) OVERRIDE
+ CORE_ADDR get_tls_address (CORE_ADDR offset) override
{
if (needs <= SYMBOL_NEEDS_REGISTERS)
needs = SYMBOL_NEEDS_REGISTERS;
/* Helper interface of per_cu_dwarf_call for
dwarf2_loc_desc_get_symbol_read_needs. */
- void dwarf_call (cu_offset die_offset) OVERRIDE
+ void dwarf_call (cu_offset die_offset) override
{
per_cu_dwarf_call (this, die_offset, per_cu);
}
- /* DW_OP_GNU_entry_value accesses require a caller, therefore a
+ /* 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. */
void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind,
union call_site_parameter_u kind_u,
- int deref_size) OVERRIDE
+ int deref_size) override
{
needs = SYMBOL_NEEDS_FRAME;
push_address (0, 0);
}
- /* DW_OP_GNU_addr_index doesn't require a frame. */
+ /* DW_OP_addrx and DW_OP_GNU_addr_index doesn't require a frame. */
- CORE_ADDR get_addr_index (unsigned int index) OVERRIDE
+ CORE_ADDR get_addr_index (unsigned int index) override
{
/* Nothing to do. */
return 1;
/* DW_OP_push_object_address has a frame already passed through. */
- CORE_ADDR get_object_address () OVERRIDE
+ CORE_ADDR get_object_address () override
{
/* Nothing to do. */
return 1;
struct dwarf2_per_cu_data *per_cu)
{
int in_reg;
- struct cleanup *old_chain;
struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
+ scoped_value_mark free_values;
+
symbol_needs_eval_context ctx;
ctx.needs = SYMBOL_NEEDS_NONE;
ctx.per_cu = per_cu;
-
- old_chain = make_cleanup_value_free_to_mark (value_mark ());
-
ctx.gdbarch = get_objfile_arch (objfile);
ctx.addr_size = dwarf2_per_cu_addr_size (per_cu);
ctx.ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu);
in_reg = ctx.location == DWARF_VALUE_REGISTER;
- if (ctx.num_pieces > 0)
- {
- int i;
-
- /* If the location has several pieces, and any of them are in
- registers, then we will need a frame to fetch them from. */
- for (i = 0; i < ctx.num_pieces; i++)
- if (ctx.pieces[i].location == DWARF_VALUE_REGISTER)
- in_reg = 1;
- }
-
- do_cleanups (old_chain);
+ /* If the location has several pieces, and any of them are in
+ registers, then we will need a frame to fetch them from. */
+ for (dwarf_expr_piece &p : ctx.pieces)
+ if (p.location == DWARF_VALUE_REGISTER)
+ in_reg = 1;
if (in_reg)
ctx.needs = SYMBOL_NEEDS_FRAME;
/* A helper function that throws an unimplemented error mentioning a
given DWARF operator. */
-static void
+static void ATTRIBUTE_NORETURN
unimplemented (unsigned int op)
{
const char *name = get_DW_OP_name (op);
if (reg == -1)
{
- complaint (&symfile_complaints,
- _("bad DWARF register number %d"), dwarf_reg);
+ complaint (_("bad DWARF register number %d"), dwarf_reg);
}
return reg;
}
if (8 * nbytes == nbits)
return;
- if (gdbarch_bits_big_endian (arch))
+ if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG)
{
/* On a bits-big-endian machine, we want the high-order
NBITS. */
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,
+ unsigned int addr_size, const gdb_byte *op_ptr,
+ const gdb_byte *op_end,
struct dwarf2_per_cu_data *per_cu)
{
- int i;
+ gdbarch *arch = expr->gdbarch;
std::vector<int> dw_labels, patches;
const gdb_byte * const base = op_ptr;
const gdb_byte *previous_piece = op_ptr;
enum bfd_endian byte_order = gdbarch_byte_order (arch);
ULONGEST bits_collected = 0;
unsigned int addr_size_bits = 8 * addr_size;
- int bits_big_endian = gdbarch_bits_big_endian (arch);
+ bool bits_big_endian = byte_order == BFD_ENDIAN_BIG;
std::vector<int> offsets (op_end - op_ptr, -1);
&datastart, &datalen);
op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
- dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart,
+ dwarf2_compile_expr_to_ax (expr, loc, addr_size, datastart,
datastart + datalen, per_cu);
if (loc->kind == axs_lvalue_register)
require_rvalue (expr, loc);
{
/* Another expression. */
ax_const_l (expr, text_offset);
- dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
- cfa_start, cfa_end, per_cu);
+ dwarf2_compile_expr_to_ax (expr, loc, addr_size, cfa_start,
+ cfa_end, per_cu);
}
loc->kind = axs_lvalue_memory;
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;
{
struct dwarf2_locexpr_baton block;
int size = (op == DW_OP_call2 ? 2 : 4);
- cu_offset offset;
uoffset = extract_unsigned_integer (op_ptr, size, byte_order);
op_ptr += size;
- offset.cu_off = 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. */
gdb_assert (block.per_cu == per_cu);
- dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
- block.data, block.data + block.size,
- per_cu);
+ dwarf2_compile_expr_to_ax (expr, loc, addr_size, block.data,
+ block.data + block.size, per_cu);
}
break;
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)
if (!b)
error (_("No block found for address for symbol \"%s\"."),
- SYMBOL_PRINT_NAME (symbol));
+ symbol->print_name ());
framefunc = block_linkage_function (b);
if (!framefunc)
error (_("No function found for block for symbol \"%s\"."),
- SYMBOL_PRINT_NAME (symbol));
+ symbol->print_name ());
func_get_frame_base_dwarf_block (framefunc, addr, &base_data, &base_size);
if (buf_end != base_data + base_size)
error (_("Unexpected opcode after "
"DW_OP_breg%u for symbol \"%s\"."),
- frame_reg, SYMBOL_PRINT_NAME (symbol));
+ frame_reg, symbol->print_name ());
}
else if (base_data[0] >= DW_OP_reg0 && base_data[0] <= DW_OP_reg31)
{
}
break;
+ case DW_OP_implicit_pointer:
case DW_OP_GNU_implicit_pointer:
{
ul = extract_unsigned_integer (data, offset_size,
}
break;
+ case DW_OP_deref_type:
case DW_OP_GNU_deref_type:
{
- int addr_size = *data++;
- cu_offset offset;
+ int deref_addr_size = *data++;
struct type *type;
data = safe_read_uleb128 (data, end, &ul);
- offset.cu_off = ul;
+ cu_offset offset = (cu_offset) ul;
type = dwarf2_get_die_type (offset, per_cu);
fprintf_filtered (stream, "<");
type_print (type, "", stream, -1);
- fprintf_filtered (stream, " [0x%s]> %d", phex_nz (offset.cu_off, 0),
- addr_size);
+ fprintf_filtered (stream, " [0x%s]> %d",
+ phex_nz (to_underlying (offset), 0),
+ deref_addr_size);
}
break;
+ case DW_OP_const_type:
case DW_OP_GNU_const_type:
{
- cu_offset type_die;
struct type *type;
data = safe_read_uleb128 (data, end, &ul);
- type_die.cu_off = ul;
+ cu_offset type_die = (cu_offset) ul;
type = dwarf2_get_die_type (type_die, per_cu);
fprintf_filtered (stream, "<");
type_print (type, "", stream, -1);
- fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die.cu_off, 0));
+ fprintf_filtered (stream, " [0x%s]>",
+ phex_nz (to_underlying (type_die), 0));
}
break;
+ case DW_OP_regval_type:
case DW_OP_GNU_regval_type:
{
uint64_t reg;
- cu_offset type_die;
struct type *type;
data = safe_read_uleb128 (data, end, ®);
data = safe_read_uleb128 (data, end, &ul);
- type_die.cu_off = ul;
+ cu_offset type_die = (cu_offset) ul;
type = dwarf2_get_die_type (type_die, per_cu);
fprintf_filtered (stream, "<");
type_print (type, "", stream, -1);
fprintf_filtered (stream, " [0x%s]> [$%s]",
- phex_nz (type_die.cu_off, 0),
+ phex_nz (to_underlying (type_die), 0),
locexpr_regname (arch, reg));
}
break;
+ case DW_OP_convert:
case DW_OP_GNU_convert:
+ case DW_OP_reinterpret:
case DW_OP_GNU_reinterpret:
{
- cu_offset type_die;
-
data = safe_read_uleb128 (data, end, &ul);
- type_die.cu_off = ul;
+ cu_offset type_die = (cu_offset) ul;
- if (type_die.cu_off == 0)
+ if (to_underlying (type_die) == 0)
fprintf_filtered (stream, "<0>");
else
{
type = dwarf2_get_die_type (type_die, per_cu);
fprintf_filtered (stream, "<");
type_print (type, "", stream, -1);
- fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die.cu_off, 0));
+ fprintf_filtered (stream, " [0x%s]>",
+ phex_nz (to_underlying (type_die), 0));
}
}
break;
+ case DW_OP_entry_value:
case DW_OP_GNU_entry_value:
data = safe_read_uleb128 (data, end, &ul);
fputc_filtered ('\n', stream);
fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
break;
+ case DW_OP_addrx:
case DW_OP_GNU_addr_index:
data = safe_read_uleb128 (data, end, &ul);
ul = dwarf2_read_addr_index (per_cu, ul);
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");
if (bad || data > end)
error (_("Corrupted DWARF2 expression for \"%s\"."),
- SYMBOL_PRINT_NAME (symbol));
+ symbol->print_name ());
}
/* Print a natural-language description of SYMBOL to STREAM. This
any necessary bytecode in AX. */
static void
-locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
- struct agent_expr *ax, struct axs_value *value)
+locexpr_tracepoint_var_ref (struct symbol *symbol, struct agent_expr *ax,
+ struct axs_value *value)
{
struct dwarf2_locexpr_baton *dlbaton
= (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol);
if (dlbaton->size == 0)
value->optimized_out = 1;
else
- dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size,
- dlbaton->data, dlbaton->data + dlbaton->size,
- dlbaton->per_cu);
+ dwarf2_compile_expr_to_ax (ax, value, addr_size, dlbaton->data,
+ dlbaton->data + dlbaton->size, dlbaton->per_cu);
}
/* symbol_computed_ops 'generate_c_location' method. */
static void
-locexpr_generate_c_location (struct symbol *sym, struct ui_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)
unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
if (dlbaton->size == 0)
- error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym));
+ error (_("symbol \"%s\" is optimized out"), sym->natural_name ());
compile_dwarf_expr_to_c (stream, result_name,
sym, pc, gdbarch, registers_used, addr_size,
case DEBUG_LOC_BUFFER_OVERFLOW:
case DEBUG_LOC_INVALID_ENTRY:
error (_("Corrupted DWARF expression for symbol \"%s\"."),
- SYMBOL_PRINT_NAME (symbol));
+ symbol->print_name ());
default:
gdb_assert_not_reached ("bad debug_loc_kind");
}
/* Describe the location of SYMBOL as an agent value in VALUE, generating
any necessary bytecode in AX. */
static void
-loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
- struct agent_expr *ax, struct axs_value *value)
+loclist_tracepoint_var_ref (struct symbol *symbol, struct agent_expr *ax,
+ struct axs_value *value)
{
struct dwarf2_loclist_baton *dlbaton
= (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol);
if (size == 0)
value->optimized_out = 1;
else
- dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size, data, data + size,
+ dwarf2_compile_expr_to_ax (ax, value, addr_size, data, data + size,
dlbaton->per_cu);
}
/* symbol_computed_ops 'generate_c_location' method. */
static void
-loclist_generate_c_location (struct symbol *sym, struct ui_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)
data = dwarf2_find_location_expression (dlbaton, &size, pc);
if (size == 0)
- error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym));
+ error (_("symbol \"%s\" is optimized out"), sym->natural_name ());
compile_dwarf_expr_to_c (stream, result_name,
sym, pc, gdbarch, registers_used, addr_size,
loclist_generate_c_location
};
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_dwarf2loc;
-
void
_initialize_dwarf2loc (void)
{
NULL,
show_entry_values_debug,
&setdebuglist, &showdebuglist);
-
-#if GDB_SELF_TEST
- register_self_test (selftests::copy_bitwise_tests);
-#endif
}
projects / thirdparty / binutils-gdb.git / blobdiff