X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fdwarf2loc.c;h=99cac03a54745c35f979de1dba349d475598291f;hb=f5df0b5f0874598790a60f1462f67887868bd77f;hp=b238133463ebec430bec1dda4deeb8b641034d4a;hpb=22347e554cd7ba2a0bf36dc81ebfcbe2e2fd74af;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c index b238133463..99cac03a54 100644 --- a/gdb/dwarf2loc.c +++ b/gdb/dwarf2loc.c @@ -1,6 +1,6 @@ /* 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. @@ -36,19 +36,23 @@ #include "dwarf2.h" #include "dwarf2expr.h" #include "dwarf2loc.h" +#include "dwarf2read.h" #include "dwarf2-frame.h" #include "compile/compile.h" +#include "gdbsupport/selftest.h" #include #include - -extern int dwarf_always_disassemble; +#include +#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, @@ -56,6 +60,12 @@ static struct call_site_parameter *dwarf_expr_reg_to_entry_parameter 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, @@ -141,6 +151,57 @@ decode_debug_loc_addresses (const gdb_byte *loc_ptr, const gdb_byte *buf_end, 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. @@ -161,10 +222,10 @@ decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data *per_cu, 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) @@ -172,7 +233,7 @@ decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data *per_cu, *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; @@ -183,7 +244,7 @@ decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data *per_cu, *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; @@ -235,11 +296,17 @@ dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton, 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) { @@ -275,8 +342,18 @@ dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton, 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) { @@ -289,7 +366,7 @@ dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton, 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; @@ -447,7 +524,7 @@ func_get_frame_base_dwarf_block (struct symbol *framefunc, CORE_ADDR pc, if (*length == 0) error (_("Could not find the frame base for \"%s\"."), - SYMBOL_NATURAL_NAME (framefunc)); + framefunc->natural_name ()); } static CORE_ADDR @@ -474,6 +551,30 @@ per_cu_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset, 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: @@ -485,7 +586,7 @@ class dwarf_evaluate_loc_desc : public dwarf_expr_context /* 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); } @@ -493,14 +594,14 @@ class dwarf_evaluate_loc_desc : public dwarf_expr_context /* 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); @@ -510,25 +611,33 @@ class dwarf_evaluate_loc_desc : public dwarf_expr_context /* 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); } @@ -536,7 +645,7 @@ class dwarf_evaluate_loc_desc : public dwarf_expr_context /* 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.")); @@ -553,7 +662,7 @@ class dwarf_evaluate_loc_desc : public dwarf_expr_context 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; @@ -571,7 +680,7 @@ class dwarf_evaluate_loc_desc : public dwarf_expr_context /* 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); @@ -594,7 +703,7 @@ class dwarf_evaluate_loc_desc : public dwarf_expr_context /* 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 @@ -622,14 +731,14 @@ class dwarf_evaluate_loc_desc : public dwarf_expr_context /* 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); @@ -639,7 +748,7 @@ class dwarf_evaluate_loc_desc : public dwarf_expr_context /* 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); @@ -663,7 +772,7 @@ show_entry_values_debug (struct ui_file *file, int from_tty, 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. */ @@ -688,11 +797,10 @@ call_site_to_target_addr (struct gdbarch *call_site_gdbarch, 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) @@ -701,12 +809,12 @@ call_site_to_target_addr (struct gdbarch *call_site_gdbarch, 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); @@ -714,8 +822,7 @@ call_site_to_target_addr (struct gdbarch *call_site_gdbarch, 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 @@ -739,7 +846,7 @@ call_site_to_target_addr (struct gdbarch *call_site_gdbarch, "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); @@ -763,9 +870,9 @@ func_addr_to_tail_call_list (struct gdbarch *gdbarch, CORE_ADDR addr) 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)); @@ -788,33 +895,23 @@ func_addr_to_tail_call_list (struct gdbarch *gdbarch, CORE_ADDR 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 todo; - make_cleanup (VEC_cleanup (CORE_ADDR), &todo); + /* Track here CORE_ADDRs which were already visited. */ + std::unordered_set 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); @@ -822,7 +919,6 @@ func_verify_no_selftailcall (struct gdbarch *gdbarch, CORE_ADDR verify_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. */ @@ -834,25 +930,18 @@ func_verify_no_selftailcall (struct gdbarch *gdbarch, CORE_ADDR verify_addr) 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 @@ -866,16 +955,10 @@ tailcall_dump (struct gdbarch *gdbarch, const struct call_site *call_site) 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 @@ -884,26 +967,27 @@ DEF_VEC_P (call_sitep); 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 *resultp, + std::vector *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) { @@ -920,58 +1004,58 @@ chain_candidate (struct gdbarch *gdbarch, struct call_site_chain **resultp, { 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 @@ -986,19 +1070,14 @@ call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc, 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 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 chain; /* We are not interested in the specific PC inside the callee function. */ callee_pc = get_pc_function_start (callee_pc); @@ -1006,16 +1085,8 @@ call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_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 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 @@ -1034,7 +1105,7 @@ call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc, if (target_func_addr == callee_pc) { - chain_candidate (gdbarch, &retval, chain); + chain_candidate (gdbarch, &retval, &chain); if (retval == NULL) break; @@ -1056,15 +1127,11 @@ call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc, 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; } } @@ -1074,13 +1141,13 @@ call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc, 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) @@ -1089,10 +1156,10 @@ call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc, } 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) @@ -1106,16 +1173,14 @@ call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc, "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 @@ -1129,11 +1194,11 @@ call_site_find_chain (struct gdbarch *gdbarch, CORE_ADDR caller_pc, { 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) { @@ -1143,9 +1208,8 @@ call_site_find_chain (struct gdbarch *gdbarch, CORE_ADDR caller_pc, return NULL; } else - throw_exception (e); + throw; } - END_CATCH return retval; } @@ -1165,7 +1229,7 @@ call_site_parameter_matches (struct call_site_parameter *parameter, 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; } @@ -1207,12 +1271,12 @@ dwarf_expr_reg_to_entry_parameter (struct frame_info *frame, 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); } @@ -1221,11 +1285,11 @@ dwarf_expr_reg_to_entry_parameter (struct frame_info *frame, 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); @@ -1238,12 +1302,12 @@ dwarf_expr_reg_to_entry_parameter (struct frame_info *frame, 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)); } @@ -1262,12 +1326,12 @@ dwarf_expr_reg_to_entry_parameter (struct frame_info *frame, 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; @@ -1275,8 +1339,8 @@ dwarf_expr_reg_to_entry_parameter (struct frame_info *frame, } /* 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. @@ -1300,9 +1364,9 @@ dwarf_entry_parameter_to_value (struct call_site_parameter *parameter, /* 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); @@ -1322,7 +1386,7 @@ entry_data_value_coerce_ref (const struct value *value) 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); @@ -1348,12 +1412,12 @@ entry_data_value_free_closure (struct value *v) { 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 = { @@ -1368,7 +1432,7 @@ 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. */ @@ -1392,12 +1456,12 @@ value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame, 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; @@ -1406,9 +1470,8 @@ value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame, 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), @@ -1420,7 +1483,7 @@ value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame, /* 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. */ @@ -1444,26 +1507,24 @@ value_of_dwarf_block_entry (struct type *type, struct frame_info *frame, 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; + struct dwarf2_per_cu_data *per_cu = NULL; - /* The number of pieces used to describe this variable. */ - int n_pieces; + /* The pieces describing this variable. */ + std::vector pieces; - /* The target address size, used only for DWARF_VALUE_STACK. */ - int addr_size; - - /* The pieces themselves. */ - struct dwarf_expr_piece *pieces; + /* Frame ID of frame to which a register value is relative, used + only by DWARF_VALUE_REGISTER. */ + struct frame_id frame_id; }; /* Allocate a closure for a value formed from separately-described @@ -1471,256 +1532,308 @@ struct piece_closure 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) + std::vector &&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; - - 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; } +/* 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 -read_pieced_value (struct value *v) +rw_pieced_value (struct value *v, struct value *from) { int i; - long offset = 0; + LONGEST offset = 0, max_offset; ULONGEST bits_to_skip; - gdb_byte *contents; + gdb_byte *v_contents; + const gdb_byte *from_contents; struct piece_closure *c = (struct piece_closure *) value_computed_closure (v); - struct frame_info *frame; - size_t type_len; - size_t buffer_size = 0; - std::vector buffer; - int bits_big_endian - = gdbarch_bits_big_endian (get_type_arch (value_type (v))); - - /* VALUE_FRAME_ID is used instead of VALUE_NEXT_FRAME_ID here - because FRAME is passed to get_frame_register_bytes(), which - does its own "->next" operation. */ - frame = frame_find_by_id (VALUE_FRAME_ID (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)) + gdb::byte_vector buffer; + bool bits_big_endian = type_byte_order (value_type (v)) == BFD_ENDIAN_BIG; + + if (from != NULL) { - bits_to_skip += value_bitpos (v); - type_len = value_bitsize (v); + from_contents = value_contents (from); + v_contents = NULL; } else - type_len = 8 * TYPE_LENGTH (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")); + v_contents = value_contents_raw (v); + from_contents = NULL; + } - for (i = 0; i < c->n_pieces && offset < type_len; i++) + bits_to_skip = 8 * value_offset (v); + if (value_bitsize (v)) { - 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 += (8 * value_offset (value_parent (v)) + + value_bitpos (v)); + if (from != NULL + && (type_byte_order (value_type (from)) + == BFD_ENDIAN_BIG)) { - 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; + /* Use the least significant bits of FROM. */ + max_offset = 8 * TYPE_LENGTH (value_type (from)); + offset = max_offset - value_bitsize (v); } else - { - dest_offset_bits = offset; - source_offset_bits = 0; - } - if (this_size_bits > type_len - offset) - this_size_bits = type_len - offset; + max_offset = value_bitsize (v); + } + else + max_offset = 8 * TYPE_LENGTH (value_type (v)); - 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 (); + /* 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 < c->pieces.size () && offset < max_offset; i++) + { + struct dwarf_expr_piece *p = &c->pieces[i]; + size_t this_size_bits, this_size; + + 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; + + this_size = bits_to_bytes (bits_to_skip, this_size_bits); + buffer.resize (this_size); - if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset, - this_size, buffer.data (), - &optim, &unavail)) + 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; + } + + 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")); + } - 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 (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; + + 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 (n > c->addr_size - source_offset) - n = (c->addr_size >= source_offset - ? c->addr_size - source_offset - : 0); - if (n == 0) + 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: @@ -1731,168 +1844,22 @@ read_pieced_value (struct value *v) 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 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 @@ -1910,7 +1877,7 @@ check_pieced_synthetic_pointer (const struct value *value, LONGEST bit_offset, 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; @@ -1952,13 +1919,10 @@ fetch_const_value_from_synthetic_pointer (sect_offset die, LONGEST byte_offset, 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) @@ -1975,8 +1939,6 @@ fetch_const_value_from_synthetic_pointer (sect_offset die, LONGEST byte_offset, else result = allocate_optimized_out_value (TYPE_TARGET_TYPE (type)); - do_cleanups (cleanup); - return result; } @@ -1985,19 +1947,27 @@ fetch_const_value_from_synthetic_pointer (sect_offset die, LONGEST byte_offset, 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, @@ -2014,7 +1984,6 @@ indirect_pieced_value (struct value *value) = (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; @@ -2030,7 +1999,7 @@ indirect_pieced_value (struct value *value) 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; @@ -2053,7 +2022,7 @@ indirect_pieced_value (struct value *value) 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; @@ -2077,7 +2046,8 @@ indirect_pieced_value (struct value *value) 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); } @@ -2100,11 +2070,12 @@ coerce_pieced_ref (const struct value *value) /* 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 { @@ -2132,14 +2103,11 @@ free_pieced_value_closure (struct value *v) --c->refc; if (c->refc == 0) { - int i; - - for (i = 0; i < c->n_pieces; ++i) - if (c->pieces[i].location == DWARF_VALUE_STACK) - value_free (c->pieces[i].v.value); + for (dwarf_expr_piece &p : c->pieces) + if (p.location == DWARF_VALUE_STACK) + value_decref (p.v.value); - xfree (c->pieces); - xfree (c); + delete c; } } @@ -2156,85 +2124,87 @@ static const struct lval_funcs pieced_value_funcs = { /* 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; - struct frame_id frame_id - = frame == NULL - ? null_frame_id - : get_frame_id (get_next_frame_sentinel_okay (frame)); 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); + 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); - VALUE_NEXT_FRAME_ID (retval) = frame_id; - 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 { @@ -2247,10 +2217,10 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, = 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; @@ -2261,9 +2231,9 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, inspecting a register ($pc, $sp, etc.), return a generic optimized out value instead, so that we show instead of . */ - 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; } } @@ -2273,7 +2243,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, { 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 @@ -2283,7 +2253,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, 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: @@ -2295,8 +2265,9 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, } 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); } @@ -2305,69 +2276,49 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, 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 @@ -2382,8 +2333,6 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, set_value_initialized (retval, ctx.initialized); - do_cleanups (value_chain); - return retval; } @@ -2395,7 +2344,8 @@ dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame, const gdb_byte *data, size_t size, struct dwarf2_per_cu_data *per_cu) { - 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 @@ -2411,7 +2361,6 @@ dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton, CORE_ADDR *valp) { struct objfile *objfile; - struct cleanup *cleanup; if (dlbaton == NULL || dlbaton->size == 0) return 0; @@ -2429,7 +2378,25 @@ dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton, 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) { @@ -2455,14 +2422,14 @@ dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton, /* 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); @@ -2473,18 +2440,41 @@ dwarf2_evaluate_property (const struct dynamic_prop *prop, { 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; @@ -2501,12 +2491,12 @@ dwarf2_evaluate_property (const struct dynamic_prop *prop, 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; } } } @@ -2514,7 +2504,7 @@ dwarf2_evaluate_property (const struct dynamic_prop *prop, case PROP_CONST: *value = prop->data.const_val; - return 1; + return true; case PROP_ADDR_OFFSET: { @@ -2524,8 +2514,12 @@ dwarf2_evaluate_property (const struct dynamic_prop *prop, 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) @@ -2536,17 +2530,17 @@ dwarf2_evaluate_property (const struct dynamic_prop *prop, 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, @@ -2591,7 +2585,7 @@ class symbol_needs_eval_context : public dwarf_expr_context 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; @@ -2600,20 +2594,20 @@ class symbol_needs_eval_context : public dwarf_expr_context /* "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; @@ -2624,20 +2618,20 @@ class symbol_needs_eval_context : public dwarf_expr_context } /* 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; @@ -2647,17 +2641,25 @@ class symbol_needs_eval_context : public dwarf_expr_context /* 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; @@ -2665,9 +2667,9 @@ class symbol_needs_eval_context : public dwarf_expr_context 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; @@ -2675,7 +2677,7 @@ class symbol_needs_eval_context : public dwarf_expr_context /* 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; @@ -2690,16 +2692,14 @@ dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte *data, size_t size, 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); @@ -2709,18 +2709,11 @@ dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte *data, size_t size, 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; @@ -2730,7 +2723,7 @@ dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte *data, size_t size, /* 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); @@ -2757,8 +2750,7 @@ dwarf_reg_to_regnum (struct gdbarch *arch, int dwarf_reg) if (reg == -1) { - complaint (&symfile_complaints, - _("bad DWARF register number %d"), dwarf_reg); + complaint (_("bad DWARF register number %d"), dwarf_reg); } return reg; } @@ -2824,7 +2816,7 @@ access_memory (struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits) 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. */ @@ -2863,18 +2855,18 @@ get_ax_pc (void *baton) 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 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 offsets (op_end - op_ptr, -1); @@ -3142,7 +3134,7 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, &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); @@ -3368,8 +3360,8 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *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; @@ -3409,7 +3401,7 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, 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")); @@ -3419,10 +3411,10 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, 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")); @@ -3436,11 +3428,11 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, 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; @@ -3482,34 +3474,35 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, { 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) @@ -3641,13 +3634,13 @@ locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream, 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); @@ -3661,7 +3654,7 @@ locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream, 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) { @@ -4013,6 +4006,7 @@ disassemble_dwarf_expression (struct ui_file *stream, } break; + case DW_OP_implicit_pointer: case DW_OP_GNU_implicit_pointer: { ul = extract_unsigned_integer (data, offset_size, @@ -4027,64 +4021,66 @@ disassemble_dwarf_expression (struct ui_file *stream, } 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 { @@ -4093,11 +4089,13 @@ disassemble_dwarf_expression (struct ui_file *stream, 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); @@ -4113,6 +4111,7 @@ disassemble_dwarf_expression (struct ui_file *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); @@ -4123,6 +4122,13 @@ disassemble_dwarf_expression (struct ui_file *stream, 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"); @@ -4222,7 +4228,7 @@ locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr, 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 @@ -4248,8 +4254,8 @@ locexpr_describe_location (struct symbol *symbol, CORE_ADDR addr, 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); @@ -4258,15 +4264,14 @@ locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch, 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) @@ -4276,7 +4281,7 @@ locexpr_generate_c_location (struct symbol *sym, struct ui_file *stream, 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, @@ -4422,7 +4427,7 @@ loclist_describe_location (struct symbol *symbol, CORE_ADDR addr, 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"); } @@ -4456,8 +4461,8 @@ loclist_describe_location (struct symbol *symbol, CORE_ADDR addr, /* 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); @@ -4469,14 +4474,14 @@ loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch, 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) @@ -4489,7 +4494,7 @@ loclist_generate_c_location (struct symbol *sym, struct ui_file *stream, 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, @@ -4509,9 +4514,6 @@ const struct symbol_computed_ops dwarf2_loclist_funcs = { loclist_generate_c_location }; -/* Provide a prototype to silence -Wmissing-prototypes. */ -extern initialize_file_ftype _initialize_dwarf2loc; - void _initialize_dwarf2loc (void) {