X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fdwarf2loc.c;h=976d453d3ca2283fe2f75084544050dd42a94dac;hb=46f77ef90f0671955214a8492fb050e0cccd1309;hp=01e95da19eab68ac5306e96d8b9dba99879582a1;hpb=1632a688b328f08eee83e6eb9f3354580a27287e;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c index 01e95da19e..976d453d3c 100644 --- a/gdb/dwarf2loc.c +++ b/gdb/dwarf2loc.c @@ -1,7 +1,6 @@ /* DWARF 2 location expression support for GDB. - Copyright (C) 2003, 2005, 2007, 2008, 2009, 2010, 2011 - Free Software Foundation, Inc. + Copyright (C) 2003-2019 Free Software Foundation, Inc. Contributed by Daniel Jacobowitz, MontaVista Software, Inc. @@ -31,28 +30,235 @@ #include "ax-gdb.h" #include "regcache.h" #include "objfiles.h" -#include "exceptions.h" #include "block.h" - +#include "gdbcmd.h" +#include "complaints.h" #include "dwarf2.h" #include "dwarf2expr.h" #include "dwarf2loc.h" +#include "dwarf2read.h" #include "dwarf2-frame.h" - -#include "gdb_string.h" -#include "gdb_assert.h" - -extern int dwarf2_always_disassemble; - -static void dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc, - const gdb_byte **start, size_t *length); +#include "compile/compile.h" +#include "gdbsupport/selftest.h" +#include +#include +#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, - unsigned short size, - struct dwarf2_per_cu_data *per_cu, - LONGEST byte_offset); + size_t size, + struct dwarf2_per_cu_data *per_cu, + struct type *subobj_type, + LONGEST subobj_byte_offset); + +static struct call_site_parameter *dwarf_expr_reg_to_entry_parameter + (struct frame_info *frame, + enum call_site_parameter_kind kind, + union call_site_parameter_u kind_u, + struct dwarf2_per_cu_data **per_cu_return); + +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, + and is then followed by data specific to that entry. */ + +enum debug_loc_kind +{ + /* Indicates the end of the list of entries. */ + DEBUG_LOC_END_OF_LIST = 0, + + /* This is followed by an unsigned LEB128 number that is an index into + .debug_addr and specifies the base address for all following entries. */ + DEBUG_LOC_BASE_ADDRESS = 1, + + /* This is followed by two unsigned LEB128 numbers that are indices into + .debug_addr and specify the beginning and ending addresses, and then + a normal location expression as in .debug_loc. */ + DEBUG_LOC_START_END = 2, + + /* This is followed by an unsigned LEB128 number that is an index into + .debug_addr and specifies the beginning address, and a 4 byte unsigned + number that specifies the length, and then a normal location expression + as in .debug_loc. */ + DEBUG_LOC_START_LENGTH = 3, + + /* An internal value indicating there is insufficient data. */ + DEBUG_LOC_BUFFER_OVERFLOW = -1, + + /* An internal value indicating an invalid kind of entry was found. */ + DEBUG_LOC_INVALID_ENTRY = -2 +}; + +/* Helper function which throws an error if a synthetic pointer is + invalid. */ + +static void +invalid_synthetic_pointer (void) +{ + error (_("access outside bounds of object " + "referenced via synthetic pointer")); +} + +/* Decode the addresses in a non-dwo .debug_loc 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_loc_addresses (const gdb_byte *loc_ptr, const gdb_byte *buf_end, + const gdb_byte **new_ptr, + CORE_ADDR *low, CORE_ADDR *high, + enum bfd_endian byte_order, + unsigned int addr_size, + int signed_addr_p) +{ + CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1)); + + if (buf_end - loc_ptr < 2 * addr_size) + return DEBUG_LOC_BUFFER_OVERFLOW; + + if (signed_addr_p) + *low = extract_signed_integer (loc_ptr, addr_size, byte_order); + else + *low = extract_unsigned_integer (loc_ptr, addr_size, byte_order); + loc_ptr += addr_size; + + 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; + + /* A base-address-selection entry. */ + if ((*low & base_mask) == base_mask) + return DEBUG_LOC_BASE_ADDRESS; + + /* An end-of-list entry. */ + if (*low == 0 && *high == 0) + return DEBUG_LOC_END_OF_LIST; + + 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. + The result indicates the kind of entry found. */ + +static enum debug_loc_kind +decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data *per_cu, + const gdb_byte *loc_ptr, + const gdb_byte *buf_end, + const gdb_byte **new_ptr, + CORE_ADDR *low, CORE_ADDR *high, + enum bfd_endian byte_order) +{ + uint64_t low_index, high_index; + + if (loc_ptr == buf_end) + return DEBUG_LOC_BUFFER_OVERFLOW; + + switch (*loc_ptr++) + { + case DW_LLE_GNU_end_of_list_entry: + *new_ptr = loc_ptr; + return DEBUG_LOC_END_OF_LIST; + 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) + return DEBUG_LOC_BUFFER_OVERFLOW; + *high = dwarf2_read_addr_index (per_cu, high_index); + *new_ptr = loc_ptr; + return DEBUG_LOC_BASE_ADDRESS; + 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; + *low = dwarf2_read_addr_index (per_cu, low_index); + loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_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 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; + *low = dwarf2_read_addr_index (per_cu, low_index); + if (loc_ptr + 4 > buf_end) + return DEBUG_LOC_BUFFER_OVERFLOW; + *high = *low; + *high += extract_unsigned_integer (loc_ptr, 4, byte_order); + *new_ptr = loc_ptr + 4; + return DEBUG_LOC_START_LENGTH; + default: + return DEBUG_LOC_INVALID_ENTRY; + } +} /* A function for dealing with location lists. Given a symbol baton (BATON) and a pc value (PC), find the appropriate @@ -66,57 +272,106 @@ const gdb_byte * dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton, size_t *locexpr_length, CORE_ADDR pc) { - CORE_ADDR low, high; - const gdb_byte *loc_ptr, *buf_end; - int length; struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu); struct gdbarch *gdbarch = get_objfile_arch (objfile); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu); int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd); - CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1)); /* Adjust base_address for relocatable objects. */ CORE_ADDR base_offset = dwarf2_per_cu_text_offset (baton->per_cu); CORE_ADDR base_address = baton->base_address + base_offset; + const gdb_byte *loc_ptr, *buf_end; loc_ptr = baton->data; buf_end = baton->data + baton->size; while (1) { - if (buf_end - loc_ptr < 2 * addr_size) - error (_("dwarf2_find_location_expression: " - "Corrupted DWARF expression.")); - - if (signed_addr_p) - low = extract_signed_integer (loc_ptr, addr_size, byte_order); - else - low = extract_unsigned_integer (loc_ptr, addr_size, byte_order); - loc_ptr += addr_size; - - if (signed_addr_p) - high = extract_signed_integer (loc_ptr, addr_size, byte_order); + CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */ + int length; + enum debug_loc_kind kind; + const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */ + + if (baton->from_dwo) + kind = decode_debug_loc_dwo_addresses (baton->per_cu, + loc_ptr, buf_end, &new_ptr, + &low, &high, byte_order); + 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 - high = extract_unsigned_integer (loc_ptr, addr_size, byte_order); - loc_ptr += addr_size; + kind = decode_debug_loclists_addresses (baton->per_cu, + loc_ptr, buf_end, &new_ptr, + &low, &high, byte_order, + addr_size, signed_addr_p); - /* A base-address-selection entry. */ - if ((low & base_mask) == base_mask) + loc_ptr = new_ptr; + switch (kind) { + case DEBUG_LOC_END_OF_LIST: + *locexpr_length = 0; + return NULL; + case DEBUG_LOC_BASE_ADDRESS: base_address = high + base_offset; continue; + case DEBUG_LOC_START_END: + case DEBUG_LOC_START_LENGTH: + break; + case DEBUG_LOC_BUFFER_OVERFLOW: + case DEBUG_LOC_INVALID_ENTRY: + error (_("dwarf2_find_location_expression: " + "Corrupted DWARF expression.")); + default: + gdb_assert_not_reached ("bad debug_loc_kind"); } - /* An end-of-list entry. */ - if (low == 0 && high == 0) - return NULL; + /* Otherwise, a location expression entry. + If the entry is from a DWO, don't add base address: the entry is from + .debug_addr which already has the DWARF "base address". We still add + base_offset in case we're debugging a PIE executable. */ + if (baton->from_dwo) + { + low += base_offset; + high += base_offset; + } + else + { + low += base_address; + high += base_address; + } - /* Otherwise, a location expression entry. */ - low += base_address; - high += base_address; + 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 = extract_unsigned_integer (loc_ptr, 2, byte_order); - loc_ptr += 2; + length = read_unsigned_leb128 (NULL, loc_ptr, &bytes_read); + loc_ptr += bytes_read; + } + + if (low == high && pc == low) + { + /* This is entry PC record present only at entry point + of a function. Verify it is really the function entry point. */ + + const struct block *pc_block = block_for_pc (pc); + struct symbol *pc_func = NULL; + + if (pc_block) + pc_func = block_linkage_function (pc_block); + + if (pc_func && pc == BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (pc_func))) + { + *locexpr_length = length; + return loc_ptr; + } + } if (pc >= low && pc < high) { @@ -134,749 +389,1495 @@ struct dwarf_expr_baton { struct frame_info *frame; struct dwarf2_per_cu_data *per_cu; + CORE_ADDR obj_address; }; -/* Helper functions for dwarf2_evaluate_loc_desc. */ +/* Implement find_frame_base_location method for LOC_BLOCK functions using + DWARF expression for its DW_AT_frame_base. */ -/* Using the frame specified in BATON, return the value of register - REGNUM, treated as a pointer. */ -static CORE_ADDR -dwarf_expr_read_reg (void *baton, int dwarf_regnum) +static void +locexpr_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc, + const gdb_byte **start, size_t *length) { - struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton; - struct gdbarch *gdbarch = get_frame_arch (debaton->frame); - CORE_ADDR result; - int regnum; + struct dwarf2_locexpr_baton *symbaton + = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (framefunc); - regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum); - result = address_from_register (builtin_type (gdbarch)->builtin_data_ptr, - regnum, debaton->frame); - return result; + *length = symbaton->size; + *start = symbaton->data; } -/* Read memory at ADDR (length LEN) into BUF. */ +/* Implement the struct symbol_block_ops::get_frame_base method for + LOC_BLOCK functions using a DWARF expression as its DW_AT_frame_base. */ -static void -dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len) +static CORE_ADDR +locexpr_get_frame_base (struct symbol *framefunc, struct frame_info *frame) { - read_memory (addr, buf, len); + struct gdbarch *gdbarch; + struct type *type; + struct dwarf2_locexpr_baton *dlbaton; + const gdb_byte *start; + size_t length; + struct value *result; + + /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block. + Thus, it's supposed to provide the find_frame_base_location method as + well. */ + gdb_assert (SYMBOL_BLOCK_OPS (framefunc)->find_frame_base_location != NULL); + + gdbarch = get_frame_arch (frame); + type = builtin_type (gdbarch)->builtin_data_ptr; + dlbaton = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (framefunc); + + SYMBOL_BLOCK_OPS (framefunc)->find_frame_base_location + (framefunc, get_frame_pc (frame), &start, &length); + result = dwarf2_evaluate_loc_desc (type, frame, start, length, + dlbaton->per_cu); + + /* The DW_AT_frame_base attribute contains a location description which + computes the base address itself. However, the call to + dwarf2_evaluate_loc_desc returns a value representing a variable at + that address. The frame base address is thus this variable's + address. */ + return value_address (result); } -/* 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. */ +/* Vector for inferior functions as represented by LOC_BLOCK, if the inferior + function uses DWARF expression for its DW_AT_frame_base. */ + +const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs = +{ + locexpr_find_frame_base_location, + locexpr_get_frame_base +}; + +/* Implement find_frame_base_location method for LOC_BLOCK functions using + DWARF location list for its DW_AT_frame_base. */ + static void -dwarf_expr_frame_base (void *baton, const gdb_byte **start, size_t * length) +loclist_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc, + const gdb_byte **start, size_t *length) { - /* FIXME: cagney/2003-03-26: This code should be using - get_frame_base_address(), and then implement a dwarf2 specific - this_base method. */ - struct symbol *framefunc; - struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton; + struct dwarf2_loclist_baton *symbaton + = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (framefunc); + + *start = dwarf2_find_location_expression (symbaton, length, pc); +} - /* Use block_linkage_function, which returns a real (not inlined) - function, instead of get_frame_function, which may return an - inlined function. */ - framefunc = block_linkage_function (get_frame_block (debaton->frame, NULL)); +/* Implement the struct symbol_block_ops::get_frame_base method for + LOC_BLOCK functions using a DWARF location list as its DW_AT_frame_base. */ - /* If we found a frame-relative symbol then it was certainly within - some function associated with a frame. If we can't find the frame, - something has gone wrong. */ - gdb_assert (framefunc != NULL); +static CORE_ADDR +loclist_get_frame_base (struct symbol *framefunc, struct frame_info *frame) +{ + struct gdbarch *gdbarch; + struct type *type; + struct dwarf2_loclist_baton *dlbaton; + const gdb_byte *start; + size_t length; + struct value *result; - dwarf_expr_frame_base_1 (framefunc, - get_frame_address_in_block (debaton->frame), - start, length); + /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block. + Thus, it's supposed to provide the find_frame_base_location method as + well. */ + gdb_assert (SYMBOL_BLOCK_OPS (framefunc)->find_frame_base_location != NULL); + + gdbarch = get_frame_arch (frame); + type = builtin_type (gdbarch)->builtin_data_ptr; + dlbaton = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (framefunc); + + SYMBOL_BLOCK_OPS (framefunc)->find_frame_base_location + (framefunc, get_frame_pc (frame), &start, &length); + result = dwarf2_evaluate_loc_desc (type, frame, start, length, + dlbaton->per_cu); + + /* The DW_AT_frame_base attribute contains a location description which + computes the base address itself. However, the call to + dwarf2_evaluate_loc_desc returns a value representing a variable at + that address. The frame base address is thus this variable's + address. */ + return value_address (result); } -static void -dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc, - const gdb_byte **start, size_t *length) +/* Vector for inferior functions as represented by LOC_BLOCK, if the inferior + function uses DWARF location list for its DW_AT_frame_base. */ + +const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs = { - if (SYMBOL_LOCATION_BATON (framefunc) == NULL) - *start = NULL; - else if (SYMBOL_COMPUTED_OPS (framefunc) == &dwarf2_loclist_funcs) - { - struct dwarf2_loclist_baton *symbaton; + loclist_find_frame_base_location, + loclist_get_frame_base +}; - symbaton = SYMBOL_LOCATION_BATON (framefunc); - *start = dwarf2_find_location_expression (symbaton, length, pc); - } - else +/* See dwarf2loc.h. */ + +void +func_get_frame_base_dwarf_block (struct symbol *framefunc, CORE_ADDR pc, + const gdb_byte **start, size_t *length) +{ + if (SYMBOL_BLOCK_OPS (framefunc) != NULL) { - struct dwarf2_locexpr_baton *symbaton; + const struct symbol_block_ops *ops_block = SYMBOL_BLOCK_OPS (framefunc); - symbaton = SYMBOL_LOCATION_BATON (framefunc); - if (symbaton != NULL) - { - *length = symbaton->size; - *start = symbaton->data; - } - else - *start = NULL; + ops_block->find_frame_base_location (framefunc, pc, start, length); } + else + *length = 0; - if (*start == NULL) + if (*length == 0) error (_("Could not find the frame base for \"%s\"."), - SYMBOL_NATURAL_NAME (framefunc)); + framefunc->natural_name ()); } -/* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for - the frame in BATON. */ - static CORE_ADDR -dwarf_expr_frame_cfa (void *baton) +get_frame_pc_for_per_cu_dwarf_call (void *baton) { - struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton; + dwarf_expr_context *ctx = (dwarf_expr_context *) baton; - return dwarf2_frame_cfa (debaton->frame); + return ctx->get_frame_pc (); } -/* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for - the frame in BATON. */ +static void +per_cu_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset, + struct dwarf2_per_cu_data *per_cu) +{ + struct dwarf2_locexpr_baton block; -static CORE_ADDR -dwarf_expr_frame_pc (void *baton) + block = dwarf2_fetch_die_loc_cu_off (die_offset, per_cu, + get_frame_pc_for_per_cu_dwarf_call, + ctx); + + /* DW_OP_call_ref is currently not supported. */ + gdb_assert (block.per_cu == per_cu); + + 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 dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton; + 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.")); - return get_frame_address_in_block (debaton->frame); + 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); } -/* Using the objfile specified in BATON, find the address for the - current thread's thread-local storage with offset OFFSET. */ +class dwarf_evaluate_loc_desc : public dwarf_expr_context +{ + public: + + struct frame_info *frame; + struct dwarf2_per_cu_data *per_cu; + CORE_ADDR obj_address; + + /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for + the frame in BATON. */ + + 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 + { + 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 + { + struct objfile *objfile = dwarf2_per_cu_objfile (per_cu); + + return target_translate_tls_address (objfile, offset); + } + + /* Helper interface of per_cu_dwarf_call for + dwarf2_evaluate_loc_desc. */ + + void dwarf_call (cu_offset die_offset) override + { + per_cu_dwarf_call (this, die_offset, per_cu); + } + + /* Helper interface of sect_variable_value for + dwarf2_evaluate_loc_desc. */ + + struct value *dwarf_variable_value (sect_offset sect_off) override + { + return sect_variable_value (this, sect_off, per_cu); + } + + struct type *get_base_type (cu_offset die_offset, int size) override + { + struct type *result = dwarf2_get_die_type (die_offset, per_cu); + if (result == NULL) + error (_("Could not find type for DW_OP_const_type")); + if (size != 0 && TYPE_LENGTH (result) != size) + 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_addrx or DW_OP_GNU_addr_index. */ + + 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 + { + if (obj_address == 0) + error (_("Location address is not set.")); + return obj_address; + } + + /* Execute DWARF block of call_site_parameter which matches KIND and + KIND_U. Choose DEREF_SIZE value of that parameter. Search + caller of this objects's frame. + + The caller can be from a different CU - per_cu_dwarf_call + implementation can be more simple as it does not support cross-CU + DWARF executions. */ + + void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind, + union call_site_parameter_u kind_u, + int deref_size) override + { + struct frame_info *caller_frame; + struct dwarf2_per_cu_data *caller_per_cu; + struct call_site_parameter *parameter; + const gdb_byte *data_src; + size_t size; + + caller_frame = get_prev_frame (frame); + + parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u, + &caller_per_cu); + data_src = deref_size == -1 ? parameter->value : parameter->data_value; + size = deref_size == -1 ? parameter->value_size : parameter->data_value_size; + + /* DEREF_SIZE size is not verified here. */ + if (data_src == NULL) + throw_error (NO_ENTRY_VALUE_ERROR, + _("Cannot resolve DW_AT_call_data_value")); + + scoped_restore save_frame = make_scoped_restore (&this->frame, + caller_frame); + scoped_restore save_per_cu = make_scoped_restore (&this->per_cu, + caller_per_cu); + scoped_restore save_obj_addr = make_scoped_restore (&this->obj_address, + (CORE_ADDR) 0); + + scoped_restore save_arch = make_scoped_restore (&this->gdbarch); + this->gdbarch + = get_objfile_arch (dwarf2_per_cu_objfile (per_cu)); + scoped_restore save_addr_size = make_scoped_restore (&this->addr_size); + this->addr_size = dwarf2_per_cu_addr_size (per_cu); + scoped_restore save_offset = make_scoped_restore (&this->offset); + this->offset = dwarf2_per_cu_text_offset (per_cu); + + this->eval (data_src, size); + } + + /* 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 + { + /* FIXME: cagney/2003-03-26: This code should be using + get_frame_base_address(), and then implement a dwarf2 specific + this_base method. */ + struct symbol *framefunc; + const struct block *bl = get_frame_block (frame, NULL); + + if (bl == NULL) + error (_("frame address is not available.")); + + /* Use block_linkage_function, which returns a real (not inlined) + function, instead of get_frame_function, which may return an + inlined function. */ + framefunc = block_linkage_function (bl); + + /* If we found a frame-relative symbol then it was certainly within + some function associated with a frame. If we can't find the frame, + something has gone wrong. */ + gdb_assert (framefunc != NULL); + + func_get_frame_base_dwarf_block (framefunc, + get_frame_address_in_block (frame), + start, length); + } + + /* Read memory at ADDR (length LEN) into BUF. */ + + 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 + { + struct gdbarch *gdbarch = get_frame_arch (frame); + int regnum = dwarf_reg_to_regnum_or_error (gdbarch, dwarf_regnum); + + return address_from_register (regnum, frame); + } + + /* Implement "get_reg_value" callback. */ + + 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); + + return value_from_register (type, regnum, frame); + } +}; + +/* See dwarf2loc.h. */ + +unsigned int entry_values_debug = 0; + +/* Helper to set entry_values_debug. */ + +static void +show_entry_values_debug (struct ui_file *file, int from_tty, + struct cmd_list_element *c, const char *value) +{ + fprintf_filtered (file, + _("Entry values and tail call frames debugging is %s.\n"), + value); +} + +/* 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. */ + static CORE_ADDR -dwarf_expr_tls_address (void *baton, CORE_ADDR offset) +call_site_to_target_addr (struct gdbarch *call_site_gdbarch, + struct call_site *call_site, + struct frame_info *caller_frame) { - struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton; - struct objfile *objfile = dwarf2_per_cu_objfile (debaton->per_cu); + switch (FIELD_LOC_KIND (call_site->target)) + { + case FIELD_LOC_KIND_DWARF_BLOCK: + { + struct dwarf2_locexpr_baton *dwarf_block; + struct value *val; + struct type *caller_core_addr_type; + struct gdbarch *caller_arch; + + dwarf_block = FIELD_DWARF_BLOCK (call_site->target); + if (dwarf_block == NULL) + { + struct bound_minimal_symbol msym; + + msym = lookup_minimal_symbol_by_pc (call_site->pc - 1); + throw_error (NO_ENTRY_VALUE_ERROR, + _("DW_AT_call_target is not specified at %s in %s"), + paddress (call_site_gdbarch, call_site->pc), + (msym.minsym == NULL ? "???" + : msym.minsym->print_name ())); + + } + if (caller_frame == NULL) + { + struct bound_minimal_symbol msym; + + msym = lookup_minimal_symbol_by_pc (call_site->pc - 1); + throw_error (NO_ENTRY_VALUE_ERROR, + _("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 ? "???" + : msym.minsym->print_name ())); + + } + caller_arch = get_frame_arch (caller_frame); + caller_core_addr_type = builtin_type (caller_arch)->builtin_func_ptr; + val = dwarf2_evaluate_loc_desc (caller_core_addr_type, caller_frame, + dwarf_block->data, dwarf_block->size, + dwarf_block->per_cu); + /* DW_AT_call_target is a DWARF expression, not a DWARF location. */ + if (VALUE_LVAL (val) == lval_memory) + return value_address (val); + else + return value_as_address (val); + } + + case FIELD_LOC_KIND_PHYSNAME: + { + const char *physname; + struct bound_minimal_symbol msym; + + physname = FIELD_STATIC_PHYSNAME (call_site->target); + + /* Handle both the mangled and demangled PHYSNAME. */ + msym = lookup_minimal_symbol (physname, NULL, NULL); + if (msym.minsym == NULL) + { + msym = lookup_minimal_symbol_by_pc (call_site->pc - 1); + throw_error (NO_ENTRY_VALUE_ERROR, + _("Cannot find function \"%s\" for a call site target " + "at %s in %s"), + physname, paddress (call_site_gdbarch, call_site->pc), + (msym.minsym == NULL ? "???" + : msym.minsym->print_name ())); + + } + return BMSYMBOL_VALUE_ADDRESS (msym); + } + + case FIELD_LOC_KIND_PHYSADDR: + return FIELD_STATIC_PHYSADDR (call_site->target); - return target_translate_tls_address (objfile, offset); + default: + internal_error (__FILE__, __LINE__, _("invalid call site target kind")); + } } -/* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in - current CU (as is PER_CU). State of the CTX is not affected by the - call and return. */ +/* Convert function entry point exact address ADDR to the function which is + compliant with TAIL_CALL_LIST_COMPLETE condition. Throw + NO_ENTRY_VALUE_ERROR otherwise. */ -static void -per_cu_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset, - struct dwarf2_per_cu_data *per_cu, - CORE_ADDR (*get_frame_pc) (void *baton), - void *baton) +static struct symbol * +func_addr_to_tail_call_list (struct gdbarch *gdbarch, CORE_ADDR addr) { - struct dwarf2_locexpr_baton block; + struct symbol *sym = find_pc_function (addr); + struct type *type; - block = dwarf2_fetch_die_location_block (die_offset, per_cu, - get_frame_pc, baton); + if (sym == NULL || BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)) != addr) + throw_error (NO_ENTRY_VALUE_ERROR, + _("DW_TAG_call_site resolving failed to find function " + "name for address %s"), + paddress (gdbarch, addr)); - /* DW_OP_call_ref is currently not supported. */ - gdb_assert (block.per_cu == per_cu); + type = SYMBOL_TYPE (sym); + gdb_assert (TYPE_CODE (type) == TYPE_CODE_FUNC); + gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_FUNC); - dwarf_expr_eval (ctx, block.data, block.size); + return sym; } -/* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */ +/* Verify function with entry point exact address ADDR can never call itself + via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it + can call itself via tail calls. + + If a funtion can tail call itself its entry value based parameters are + unreliable. There is no verification whether the value of some/all + parameters is unchanged through the self tail call, we expect if there is + a self tail call all the parameters can be modified. */ static void -dwarf_expr_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset) +func_verify_no_selftailcall (struct gdbarch *gdbarch, CORE_ADDR verify_addr) { - struct dwarf_expr_baton *debaton = ctx->baton; + CORE_ADDR addr; + + /* The verification is completely unordered. Track here function addresses + which still need to be iterated. */ + std::vector todo; + + /* Track here CORE_ADDRs which were already visited. */ + std::unordered_set addr_hash; + + todo.push_back (verify_addr); + while (!todo.empty ()) + { + struct symbol *func_sym; + struct call_site *call_site; + + addr = todo.back (); + todo.pop_back (); - per_cu_dwarf_call (ctx, die_offset, debaton->per_cu, - ctx->get_frame_pc, ctx->baton); + func_sym = func_addr_to_tail_call_list (gdbarch, addr); + + for (call_site = TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym)); + call_site; call_site = call_site->tail_call_next) + { + CORE_ADDR target_addr; + + /* CALLER_FRAME with registers is not available for tail-call jumped + frames. */ + target_addr = call_site_to_target_addr (gdbarch, call_site, NULL); + + if (target_addr == verify_addr) + { + struct bound_minimal_symbol msym; + + msym = lookup_minimal_symbol_by_pc (verify_addr); + throw_error (NO_ENTRY_VALUE_ERROR, + _("DW_OP_entry_value resolving has found " + "function \"%s\" at %s can call itself via tail " + "calls"), + (msym.minsym == NULL ? "???" + : msym.minsym->print_name ()), + paddress (gdbarch, verify_addr)); + } + + if (addr_hash.insert (target_addr).second) + todo.push_back (target_addr); + } + } } -/* Callback function for dwarf2_evaluate_loc_desc. */ +/* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for + ENTRY_VALUES_DEBUG. */ -static struct type * -dwarf_expr_get_base_type (struct dwarf_expr_context *ctx, size_t die_offset) +static void +tailcall_dump (struct gdbarch *gdbarch, const struct call_site *call_site) { - struct dwarf_expr_baton *debaton = ctx->baton; + CORE_ADDR addr = call_site->pc; + struct bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (addr - 1); + + fprintf_unfiltered (gdb_stdlog, " %s(%s)", paddress (gdbarch, addr), + (msym.minsym == NULL ? "???" + : msym.minsym->print_name ())); - return dwarf2_get_die_type (die_offset, debaton->per_cu); } -struct piece_closure +/* 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 + no remaining possibilities to provide unambiguous non-trivial result. + RESULTP should point to NULL on the first (initialization) call. Caller is + responsible for xfree of any RESULTP data. */ + +static void +chain_candidate (struct gdbarch *gdbarch, + gdb::unique_xmalloc_ptr *resultp, + std::vector *chain) { - /* Reference count. */ - int refc; + long length = chain->size (); + int callers, callees, idx; - /* The CU from which this closure's expression came. */ - struct dwarf2_per_cu_data *per_cu; + if (*resultp == NULL) + { + /* Create the initial chain containing all the passed PCs. */ + + 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 (!chain->empty ()) + memcpy (result->call_site, chain->data (), + sizeof (*result->call_site) * length); + resultp->reset (result); + + if (entry_values_debug) + { + fprintf_unfiltered (gdb_stdlog, "tailcall: initial:"); + for (idx = 0; idx < length; idx++) + tailcall_dump (gdbarch, result->call_site[idx]); + fputc_unfiltered ('\n', gdb_stdlog); + } - /* The number of pieces used to describe this variable. */ - int n_pieces; + return; + } - /* The target address size, used only for DWARF_VALUE_STACK. */ - int addr_size; + if (entry_values_debug) + { + fprintf_unfiltered (gdb_stdlog, "tailcall: compare:"); + for (idx = 0; idx < length; idx++) + tailcall_dump (gdbarch, chain->at (idx)); + fputc_unfiltered ('\n', gdb_stdlog); + } - /* The pieces themselves. */ - struct dwarf_expr_piece *pieces; -}; + /* Intersect callers. */ -/* Allocate a closure for a value formed from separately-described - PIECES. */ + callers = std::min ((long) (*resultp)->callers, length); + for (idx = 0; idx < callers; idx++) + if ((*resultp)->call_site[idx] != chain->at (idx)) + { + (*resultp)->callers = idx; + break; + } -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 piece_closure *c = XZALLOC (struct piece_closure); - int i; + /* Intersect callees. */ - c->refc = 1; - c->per_cu = per_cu; - c->n_pieces = n_pieces; - c->addr_size = addr_size; - c->pieces = XCALLOC (n_pieces, struct dwarf_expr_piece); + callees = std::min ((long) (*resultp)->callees, length); + for (idx = 0; idx < callees; idx++) + if ((*resultp)->call_site[(*resultp)->length - 1 - idx] + != chain->at (length - 1 - idx)) + { + (*resultp)->callees = idx; + break; + } - 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); + if (entry_values_debug) + { + fprintf_unfiltered (gdb_stdlog, "tailcall: reduced:"); + for (idx = 0; idx < (*resultp)->callers; idx++) + tailcall_dump (gdbarch, (*resultp)->call_site[idx]); + fputs_unfiltered (" |", gdb_stdlog); + for (idx = 0; idx < (*resultp)->callees; idx++) + tailcall_dump (gdbarch, + (*resultp)->call_site[(*resultp)->length + - (*resultp)->callees + idx]); + fputc_unfiltered ('\n', gdb_stdlog); + } - return c; + 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. */ + 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 ((*resultp)->callers + (*resultp)->callees <= (*resultp)->length); } -/* The lowest-level function to extract bits from a byte buffer. - SOURCE is the buffer. It is updated if we read to the end of a - byte. - SOURCE_OFFSET_BITS is the offset of the first bit to read. It is - updated to reflect the number of bits actually read. - NBITS is the number of bits we want to read. It is updated to - reflect the number of bits actually read. This function may read - fewer bits. - BITS_BIG_ENDIAN is taken directly from gdbarch. - This function returns the extracted bits. */ +/* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the + assumed frames between them use GDBARCH. Use depth first search so we can + keep single CHAIN of call_site's back to CALLER_PC. Function recursion + would have needless GDB stack overhead. Caller is responsible for xfree of + the returned result. Any unreliability results in thrown + NO_ENTRY_VALUE_ERROR. */ -static unsigned int -extract_bits_primitive (const gdb_byte **source, - unsigned int *source_offset_bits, - int *nbits, int bits_big_endian) +static struct call_site_chain * +call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc, + CORE_ADDR callee_pc) { - unsigned int avail, mask, datum; + CORE_ADDR save_callee_pc = callee_pc; + gdb::unique_xmalloc_ptr retval; + struct call_site *call_site; + + /* 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. */ + std::vector chain; + + /* We are not interested in the specific PC inside the callee function. */ + callee_pc = get_pc_function_start (callee_pc); + if (callee_pc == 0) + throw_error (NO_ENTRY_VALUE_ERROR, _("Unable to find function for PC %s"), + paddress (gdbarch, save_callee_pc)); + + /* 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 + target's function will get iterated as already pushed into CHAIN via their + TAIL_CALL_NEXT. */ + call_site = call_site_for_pc (gdbarch, caller_pc); + + while (call_site) + { + CORE_ADDR target_func_addr; + struct call_site *target_call_site; - gdb_assert (*source_offset_bits < 8); + /* CALLER_FRAME with registers is not available for tail-call jumped + frames. */ + target_func_addr = call_site_to_target_addr (gdbarch, call_site, NULL); - avail = 8 - *source_offset_bits; - if (avail > *nbits) - avail = *nbits; + if (target_func_addr == callee_pc) + { + chain_candidate (gdbarch, &retval, &chain); + if (retval == NULL) + break; - mask = (1 << avail) - 1; - datum = **source; - if (bits_big_endian) - datum >>= 8 - (*source_offset_bits + *nbits); - else - datum >>= *source_offset_bits; - datum &= mask; + /* There is no way to reach CALLEE_PC again as we would prevent + entering it twice as being already marked in ADDR_HASH. */ + target_call_site = NULL; + } + else + { + struct symbol *target_func; - *nbits -= avail; - *source_offset_bits += avail; - if (*source_offset_bits >= 8) + target_func = func_addr_to_tail_call_list (gdbarch, target_func_addr); + target_call_site = TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func)); + } + + do + { + /* Attempt to visit TARGET_CALL_SITE. */ + + if (target_call_site) + { + if (addr_hash.insert (target_call_site->pc).second) + { + /* Successfully entered TARGET_CALL_SITE. */ + + chain.push_back (target_call_site); + break; + } + } + + /* Backtrack (without revisiting the originating call_site). Try the + callers's sibling; if there isn't any try the callers's callers's + sibling etc. */ + + target_call_site = NULL; + while (!chain.empty ()) + { + call_site = chain.back (); + chain.pop_back (); + + 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) + break; + } + } + while (target_call_site); + + if (chain.empty ()) + call_site = NULL; + else + call_site = chain.back (); + } + + if (retval == NULL) { - *source_offset_bits -= 8; - ++*source; + struct bound_minimal_symbol msym_caller, msym_callee; + + msym_caller = lookup_minimal_symbol_by_pc (caller_pc); + msym_callee = lookup_minimal_symbol_by_pc (callee_pc); + throw_error (NO_ENTRY_VALUE_ERROR, + _("There are no unambiguously determinable intermediate " + "callers or callees between caller function \"%s\" at %s " + "and callee function \"%s\" at %s"), + (msym_caller.minsym == NULL + ? "???" : msym_caller.minsym->print_name ()), + paddress (gdbarch, caller_pc), + (msym_callee.minsym == NULL + ? "???" : msym_callee.minsym->print_name ()), + paddress (gdbarch, callee_pc)); } - return datum; + return retval.release (); } -/* Extract some bits from a source buffer and move forward in the - buffer. - - SOURCE is the source buffer. It is updated as bytes are read. - SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as - bits are read. - NBITS is the number of bits to read. - BITS_BIG_ENDIAN is taken directly from gdbarch. - - This function returns the bits that were read. */ +/* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the + assumed frames between them use GDBARCH. If valid call_site_chain cannot be + constructed return NULL. Caller is responsible for xfree of the returned + result. */ -static unsigned int -extract_bits (const gdb_byte **source, unsigned int *source_offset_bits, - int nbits, int bits_big_endian) +struct call_site_chain * +call_site_find_chain (struct gdbarch *gdbarch, CORE_ADDR caller_pc, + CORE_ADDR callee_pc) { - unsigned int datum; - - gdb_assert (nbits > 0 && nbits <= 8); + struct call_site_chain *retval = NULL; - datum = extract_bits_primitive (source, source_offset_bits, &nbits, - bits_big_endian); - if (nbits > 0) + try { - unsigned int more; + retval = call_site_find_chain_1 (gdbarch, caller_pc, callee_pc); + } + catch (const gdb_exception_error &e) + { + if (e.error == NO_ENTRY_VALUE_ERROR) + { + if (entry_values_debug) + exception_print (gdb_stdout, e); - more = extract_bits_primitive (source, source_offset_bits, &nbits, - bits_big_endian); - if (bits_big_endian) - datum <<= nbits; + return NULL; + } else - more <<= nbits; - datum |= more; + throw; + } + + return retval; +} + +/* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */ + +static int +call_site_parameter_matches (struct call_site_parameter *parameter, + enum call_site_parameter_kind kind, + union call_site_parameter_u kind_u) +{ + if (kind == parameter->kind) + switch (kind) + { + case CALL_SITE_PARAMETER_DWARF_REG: + return kind_u.dwarf_reg == parameter->u.dwarf_reg; + 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_cu_off == parameter->u.param_cu_off; + } + return 0; +} + +/* Fetch call_site_parameter from caller matching KIND and KIND_U. + FRAME is for callee. + + Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR + otherwise. */ + +static struct call_site_parameter * +dwarf_expr_reg_to_entry_parameter (struct frame_info *frame, + enum call_site_parameter_kind kind, + union call_site_parameter_u kind_u, + struct dwarf2_per_cu_data **per_cu_return) +{ + CORE_ADDR func_addr, caller_pc; + struct gdbarch *gdbarch; + struct frame_info *caller_frame; + struct call_site *call_site; + int iparams; + /* Initialize it just to avoid a GCC false warning. */ + struct call_site_parameter *parameter = NULL; + CORE_ADDR target_addr; + + while (get_frame_type (frame) == INLINE_FRAME) + { + frame = get_prev_frame (frame); + gdb_assert (frame != NULL); } - return datum; + func_addr = get_frame_func (frame); + gdbarch = get_frame_arch (frame); + caller_frame = get_prev_frame (frame); + if (gdbarch != frame_unwind_arch (frame)) + { + struct bound_minimal_symbol msym + = lookup_minimal_symbol_by_pc (func_addr); + struct gdbarch *caller_gdbarch = frame_unwind_arch (frame); + + throw_error (NO_ENTRY_VALUE_ERROR, + _("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 ? "???" + : msym.minsym->print_name ()), + gdbarch_bfd_arch_info (caller_gdbarch)->printable_name); + } + + if (caller_frame == NULL) + { + struct bound_minimal_symbol msym + = lookup_minimal_symbol_by_pc (func_addr); + + throw_error (NO_ENTRY_VALUE_ERROR, _("DW_OP_entry_value resolving " + "requires caller of %s (%s)"), + paddress (gdbarch, func_addr), + (msym.minsym == NULL ? "???" + : msym.minsym->print_name ())); + } + caller_pc = get_frame_pc (caller_frame); + call_site = call_site_for_pc (gdbarch, caller_pc); + + target_addr = call_site_to_target_addr (gdbarch, call_site, caller_frame); + if (target_addr != func_addr) + { + struct minimal_symbol *target_msym, *func_msym; + + 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_entry_value resolving expects callee %s at %s " + "but the called frame is for %s at %s"), + (target_msym == NULL ? "???" + : target_msym->print_name ()), + paddress (gdbarch, target_addr), + func_msym == NULL ? "???" : func_msym->print_name (), + paddress (gdbarch, func_addr)); + } + + /* No entry value based parameters would be reliable if this function can + call itself via tail calls. */ + func_verify_no_selftailcall (gdbarch, func_addr); + + for (iparams = 0; iparams < call_site->parameter_count; iparams++) + { + parameter = &call_site->parameter[iparams]; + if (call_site_parameter_matches (parameter, kind, kind_u)) + break; + } + if (iparams == call_site->parameter_count) + { + struct minimal_symbol *msym + = lookup_minimal_symbol_by_pc (caller_pc).minsym; + + /* 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_call_site %s at %s"), + paddress (gdbarch, caller_pc), + msym == NULL ? "???" : msym->print_name ()); + } + + *per_cu_return = call_site->per_cu; + return parameter; +} + +/* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return + 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. + + Function always returns non-NULL, non-optimized out value. It throws + NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */ + +static struct value * +dwarf_entry_parameter_to_value (struct call_site_parameter *parameter, + CORE_ADDR deref_size, struct type *type, + struct frame_info *caller_frame, + struct dwarf2_per_cu_data *per_cu) +{ + const gdb_byte *data_src; + gdb_byte *data; + size_t size; + + data_src = deref_size == -1 ? parameter->value : parameter->data_value; + size = deref_size == -1 ? parameter->value_size : parameter->data_value_size; + + /* DEREF_SIZE size is not verified here. */ + if (data_src == NULL) + throw_error (NO_ENTRY_VALUE_ERROR, + _("Cannot resolve DW_AT_call_data_value")); + + /* 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); + memcpy (data, data_src, size); + data[size] = DW_OP_stack_value; + + return dwarf2_evaluate_loc_desc (type, caller_frame, data, size + 1, per_cu); +} + +/* VALUE must be of type lval_computed with entry_data_value_funcs. Perform + the indirect method on it, that is use its stored target value, the sole + purpose of entry_data_value_funcs.. */ + +static struct value * +entry_data_value_coerce_ref (const struct value *value) +{ + struct type *checked_type = check_typedef (value_type (value)); + struct value *target_val; + + if (!TYPE_IS_REFERENCE (checked_type)) + return NULL; + + target_val = (struct value *) value_computed_closure (value); + value_incref (target_val); + return target_val; +} + +/* Implement copy_closure. */ + +static void * +entry_data_value_copy_closure (const struct value *v) +{ + struct value *target_val = (struct value *) value_computed_closure (v); + + value_incref (target_val); + return target_val; +} + +/* Implement free_closure. */ + +static void +entry_data_value_free_closure (struct value *v) +{ + struct value *target_val = (struct value *) value_computed_closure (v); + + 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_call_data_value in the caller. */ + +static const struct lval_funcs entry_data_value_funcs = +{ + NULL, /* read */ + NULL, /* write */ + NULL, /* indirect */ + entry_data_value_coerce_ref, + NULL, /* check_synthetic_pointer */ + entry_data_value_copy_closure, + entry_data_value_free_closure +}; + +/* 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_call_site_parameter. + + Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it + cannot resolve the parameter for any reason. */ + +static struct value * +value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame, + enum call_site_parameter_kind kind, + union call_site_parameter_u kind_u) +{ + struct type *checked_type = check_typedef (type); + struct type *target_type = TYPE_TARGET_TYPE (checked_type); + struct frame_info *caller_frame = get_prev_frame (frame); + struct value *outer_val, *target_val, *val; + struct call_site_parameter *parameter; + struct dwarf2_per_cu_data *caller_per_cu; + + parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u, + &caller_per_cu); + + outer_val = dwarf_entry_parameter_to_value (parameter, -1 /* deref_size */, + type, caller_frame, + caller_per_cu); + + /* 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_IS_REFERENCE (checked_type) + || TYPE_TARGET_TYPE (checked_type) == NULL) + return outer_val; + + target_val = dwarf_entry_parameter_to_value (parameter, + TYPE_LENGTH (target_type), + target_type, caller_frame, + caller_per_cu); + + val = allocate_computed_value (type, &entry_data_value_funcs, + release_value (target_val).release ()); + + /* Copy the referencing pointer to the new computed value. */ + memcpy (value_contents_raw (val), value_contents_raw (outer_val), + TYPE_LENGTH (checked_type)); + set_value_lazy (val, 0); + + return val; } -/* Write some bits into a buffer and move forward in the buffer. - - DATUM is the bits to write. The low-order bits of DATUM are used. - DEST is the destination buffer. It is updated as bytes are - written. - DEST_OFFSET_BITS is the bit offset in DEST at which writing is - done. - NBITS is the number of valid bits in DATUM. - BITS_BIG_ENDIAN is taken directly from gdbarch. */ +/* 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_call_site_parameter. -static void -insert_bits (unsigned int datum, - gdb_byte *dest, unsigned int dest_offset_bits, - int nbits, int bits_big_endian) + Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it + cannot resolve the parameter for any reason. */ + +static struct value * +value_of_dwarf_block_entry (struct type *type, struct frame_info *frame, + const gdb_byte *block, size_t block_len) { - unsigned int mask; + union call_site_parameter_u kind_u; + + kind_u.dwarf_reg = dwarf_block_to_dwarf_reg (block, block + block_len); + if (kind_u.dwarf_reg != -1) + return value_of_dwarf_reg_entry (type, frame, CALL_SITE_PARAMETER_DWARF_REG, + kind_u); + + if (dwarf_block_to_fb_offset (block, block + block_len, &kind_u.fb_offset)) + return value_of_dwarf_reg_entry (type, frame, CALL_SITE_PARAMETER_FB_OFFSET, + kind_u); + + /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message + 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_entry_value is supported " + "only for single DW_OP_reg* or for DW_OP_fbreg(*)")); +} - gdb_assert (dest_offset_bits + nbits <= 8); +struct piece_closure +{ + /* Reference count. */ + int refc = 0; - mask = (1 << nbits) - 1; - if (bits_big_endian) - { - datum <<= 8 - (dest_offset_bits + nbits); - mask <<= 8 - (dest_offset_bits + nbits); - } - else - { - datum <<= dest_offset_bits; - mask <<= dest_offset_bits; - } + /* The CU from which this closure's expression came. */ + struct dwarf2_per_cu_data *per_cu = NULL; - gdb_assert ((datum & ~mask) == 0); + /* The pieces describing this variable. */ + std::vector pieces; - *dest = (*dest & ~mask) | datum; -} + /* Frame ID of frame to which a register value is relative, used + only by DWARF_VALUE_REGISTER. */ + struct frame_id frame_id; +}; -/* Copy bits from a source to a destination. - - DEST is where the bits should be written. - DEST_OFFSET_BITS is the bit offset into DEST. - SOURCE is the source of bits. - SOURCE_OFFSET_BITS is the bit offset into SOURCE. - BIT_COUNT is the number of bits to copy. - BITS_BIG_ENDIAN is taken directly from gdbarch. */ +/* Allocate a closure for a value formed from separately-described + PIECES. */ -static void -copy_bitwise (gdb_byte *dest, unsigned int dest_offset_bits, - const gdb_byte *source, unsigned int source_offset_bits, - unsigned int bit_count, - int bits_big_endian) +static struct piece_closure * +allocate_piece_closure (struct dwarf2_per_cu_data *per_cu, + std::vector &&pieces, + struct frame_info *frame) { - unsigned int dest_avail; - int datum; + struct piece_closure *c = new piece_closure; - /* Reduce everything to byte-size pieces. */ - dest += dest_offset_bits / 8; - dest_offset_bits %= 8; - source += source_offset_bits / 8; - source_offset_bits %= 8; + c->refc = 1; + c->per_cu = per_cu; + c->pieces = std::move (pieces); + if (frame == NULL) + c->frame_id = null_frame_id; + else + c->frame_id = get_frame_id (frame); - dest_avail = 8 - dest_offset_bits % 8; + for (dwarf_expr_piece &piece : c->pieces) + if (piece.location == DWARF_VALUE_STACK) + value_incref (piece.v.value); - /* See if we can fill the first destination byte. */ - if (dest_avail < bit_count) - { - datum = extract_bits (&source, &source_offset_bits, dest_avail, - bits_big_endian); - insert_bits (datum, dest, dest_offset_bits, dest_avail, bits_big_endian); - ++dest; - dest_offset_bits = 0; - bit_count -= dest_avail; - } + return c; +} - /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer - than 8 bits remaining. */ - gdb_assert (dest_offset_bits % 8 == 0 || bit_count < 8); - for (; bit_count >= 8; bit_count -= 8) - { - datum = extract_bits (&source, &source_offset_bits, 8, bits_big_endian); - *dest++ = (gdb_byte) datum; - } +/* Return the number of bytes overlapping a contiguous chunk of N_BITS + bits whose first bit is located at bit offset START. */ - /* Finally, we may have a few leftover bits. */ - gdb_assert (bit_count <= 8 - dest_offset_bits % 8); - if (bit_count > 0) - { - datum = extract_bits (&source, &source_offset_bits, bit_count, - bits_big_endian); - insert_bits (datum, dest, dest_offset_bits, bit_count, bits_big_endian); - } +static size_t +bits_to_bytes (ULONGEST start, ULONGEST n_bits) +{ + 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 = frame_find_by_id (VALUE_FRAME_ID (v)); - size_t type_len; - size_t buffer_size = 0; - char *buffer = NULL; - struct cleanup *cleanup; - 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")); - - cleanup = make_cleanup (free_current_contents, &buffer); - - 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 -= this_size_bits; - continue; - } - if (this_size_bits > type_len - offset) - this_size_bits = type_len - offset; - if (bits_to_skip > 0) + bits_to_skip += (8 * value_offset (value_parent (v)) + + value_bitpos (v)); + if (from != NULL + && (type_byte_order (value_type (from)) + == BFD_ENDIAN_BIG)) { - 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; - } + 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 = xrealloc (buffer, buffer_size); - } - intermediate_buffer = buffer; + /* 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 = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno); - int reg_offset = source_offset; + 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; 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 (gdb_regnum != -1) - { - int optim, unavail; + 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, + if (from == NULL) + { + /* Read mode. */ + if (!get_frame_register_bytes (frame, gdb_regnum, + bits_to_skip / 8, + this_size, buffer.data (), &optim, &unavail)) { - /* Just so garbage doesn't ever shine through. */ - memset (buffer, 0, this_size); - if (optim) - set_value_optimized_out (v, 1); + mark_value_bits_optimized_out (v, offset, + this_size_bits); if (unavail) - mark_value_bytes_unavailable (v, offset, this_size); + 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 { - error (_("Unable to access DWARF register number %s"), - paddress (arch, p->v.regno)); + /* 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, 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: - set_value_optimized_out (v, 1); + mark_value_bits_optimized_out (v, offset, this_size_bits); break; default: 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; } +} + - do_cleanups (cleanup); +static void +read_pieced_value (struct value *v) +{ + rw_pieced_value (v, NULL); } static void write_pieced_value (struct value *to, struct value *from) { - 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 = frame_find_by_id (VALUE_FRAME_ID (to)); - size_t type_len; - size_t buffer_size = 0; - char *buffer = NULL; - struct cleanup *cleanup; - int bits_big_endian - = gdbarch_bits_big_endian (get_type_arch (value_type (to))); - - if (frame == NULL) - { - set_value_optimized_out (to, 1); - return; - } - - cleanup = make_cleanup (free_current_contents, &buffer); - - 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 = xrealloc (buffer, buffer_size); - } - source_buffer = buffer; - need_bitwise = 1; - } - - switch (p->location) - { - case DWARF_VALUE_REGISTER: - { - struct gdbarch *arch = get_frame_arch (frame); - int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (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 (gdb_regnum != -1) - { - if (need_bitwise) - { - int optim, unavail; - - if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset, - this_size, buffer, - &optim, &unavail)) - { - if (optim) - 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, 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); - } - else - { - error (_("Unable to write to DWARF register number %s"), - paddress (arch, p->v.regno)); - } - } - 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, 1); - read_memory (p->v.mem.addr + dest_offset + this_size - 1, - buffer + this_size - 1, 1); - copy_bitwise (buffer, dest_offset_bits, - contents, source_offset_bits, - this_size_bits, - bits_big_endian); - } - - write_memory (p->v.mem.addr + dest_offset, - source_buffer, this_size); - break; - default: - set_value_optimized_out (to, 1); - break; - } - offset += this_size_bits; - } - - do_cleanups (cleanup); + rw_pieced_value (to, from); } -/* A helper function that checks bit validity in a pieced value. - CHECK_FOR indicates the kind of validity checking. - DWARF_VALUE_MEMORY means to check whether any bit is valid. - DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is - optimized out. - DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an - implicit pointer. */ +/* An implementation of an lval_funcs method to see whether a value is + a synthetic pointer. */ static int -check_pieced_value_bits (const struct value *value, int bit_offset, - int bit_length, - enum dwarf_value_location check_for) +check_pieced_synthetic_pointer (const struct value *value, LONGEST bit_offset, + int bit_length) { struct piece_closure *c = (struct piece_closure *) value_computed_closure (value); int i; - int validity = (check_for == DWARF_VALUE_MEMORY - || check_for == DWARF_VALUE_IMPLICIT_POINTER); bit_offset += 8 * value_offset (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; @@ -895,60 +1896,82 @@ check_pieced_value_bits (const struct value *value, int bit_offset, else bit_length -= this_size_bits; - if (check_for == DWARF_VALUE_IMPLICIT_POINTER) - { - if (p->location != DWARF_VALUE_IMPLICIT_POINTER) - return 0; - } - else if (p->location == DWARF_VALUE_OPTIMIZED_OUT - || p->location == DWARF_VALUE_IMPLICIT_POINTER) - { - if (validity) - return 0; - } - else - { - if (!validity) - return 1; - } + if (p->location != DWARF_VALUE_IMPLICIT_POINTER) + return 0; } - return validity; + return 1; } -static int -check_pieced_value_validity (const struct value *value, int bit_offset, - int bit_length) -{ - return check_pieced_value_bits (value, bit_offset, bit_length, - DWARF_VALUE_MEMORY); -} +/* A wrapper function for get_frame_address_in_block. */ -static int -check_pieced_value_invalid (const struct value *value) +static CORE_ADDR +get_frame_address_in_block_wrapper (void *baton) { - return check_pieced_value_bits (value, 0, - 8 * TYPE_LENGTH (value_type (value)), - DWARF_VALUE_OPTIMIZED_OUT); + return get_frame_address_in_block ((struct frame_info *) baton); } -/* An implementation of an lval_funcs method to see whether a value is - a synthetic pointer. */ +/* Fetch a DW_AT_const_value through a synthetic pointer. */ -static int -check_pieced_synthetic_pointer (const struct value *value, int bit_offset, - int bit_length) +static struct value * +fetch_const_value_from_synthetic_pointer (sect_offset die, LONGEST byte_offset, + struct dwarf2_per_cu_data *per_cu, + struct type *type) { - return check_pieced_value_bits (value, bit_offset, bit_length, - DWARF_VALUE_IMPLICIT_POINTER); + struct value *result = NULL; + const gdb_byte *bytes; + LONGEST len; + + auto_obstack temp_obstack; + bytes = dwarf2_fetch_constant_bytes (die, per_cu, &temp_obstack, &len); + + if (bytes != NULL) + { + if (byte_offset >= 0 + && byte_offset + TYPE_LENGTH (TYPE_TARGET_TYPE (type)) <= len) + { + bytes += byte_offset; + result = value_from_contents (TYPE_TARGET_TYPE (type), bytes); + } + else + invalid_synthetic_pointer (); + } + else + result = allocate_optimized_out_value (TYPE_TARGET_TYPE (type)); + + return result; } -/* A wrapper function for get_frame_address_in_block. */ +/* Fetch the value pointed to by a synthetic pointer. */ -static CORE_ADDR -get_frame_address_in_block_wrapper (void *baton) +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) { - return get_frame_address_in_block (baton); + /* 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, + 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 (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, + type); } /* An implementation of an lval_funcs method to indirect through a @@ -961,13 +1984,13 @@ 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_offset, bit_length; + int i, bit_length; + LONGEST bit_offset; struct dwarf_expr_piece *piece = NULL; - struct value *result; LONGEST byte_offset; + enum bfd_endian byte_order; - type = value_type (value); + type = check_typedef (value_type (value)); if (TYPE_CODE (type) != TYPE_CODE_PTR) return NULL; @@ -976,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; @@ -999,25 +2022,66 @@ 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; } + gdb_assert (piece != NULL); frame = get_selected_frame (_("No frame selected.")); - byte_offset = value_as_address (value); - gdb_assert (piece); - baton = dwarf2_fetch_die_location_block (piece->v.ptr.die, c->per_cu, - get_frame_address_in_block_wrapper, - frame); + /* This is an offset requested by GDB, such as value subscripts. + However, due to how synthetic pointers are implemented, this is + always presented to us as a pointer type. This means we have to + sign-extend it manually as appropriate. Use raw + extract_signed_integer directly rather than value_as_address and + sign extend afterwards on architectures that would need it + (mostly everywhere except MIPS, which has signed addresses) as + the later would go through gdbarch_pointer_to_address and thus + return a CORE_ADDR with high bits set on architectures that + encode address spaces and other things in CORE_ADDR. */ + byte_order = gdbarch_byte_order (get_frame_arch (frame)); + byte_offset = extract_signed_integer (value_contents (value), + TYPE_LENGTH (type), byte_order); + byte_offset += piece->v.ptr.offset; + + return indirect_synthetic_pointer (piece->v.ptr.die_sect_off, + byte_offset, c->per_cu, + frame, type); +} - result = dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame, - baton.data, baton.size, baton.per_cu, - byte_offset); +/* Implementation of the coerce_ref method of lval_funcs for synthetic C++ + references. */ - return result; +static struct value * +coerce_pieced_ref (const struct value *value) +{ + struct type *type = check_typedef (value_type (value)); + + if (value_bits_synthetic_pointer (value, value_embedded_offset (value), + TARGET_CHAR_BIT * TYPE_LENGTH (type))) + { + const struct piece_closure *closure + = (struct piece_closure *) value_computed_closure (value); + struct frame_info *frame + = get_selected_frame (_("No frame selected.")); + + /* gdb represents synthetic pointers as pieced values with a single + piece. */ + gdb_assert (closure != NULL); + gdb_assert (closure->pieces.size () == 1); + + return indirect_synthetic_pointer + (closure->pieces[0].v.ptr.die_sect_off, + closure->pieces[0].v.ptr.offset, + closure->per_cu, frame, type); + } + else + { + /* Else: not a synthetic reference; do nothing. */ + return NULL; + } } static void * @@ -1039,210 +2103,222 @@ free_pieced_value_closure (struct value *v) --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; } } /* Functions for accessing a variable described by DW_OP_piece. */ -static struct lval_funcs pieced_value_funcs = { +static const struct lval_funcs pieced_value_funcs = { read_pieced_value, write_pieced_value, - check_pieced_value_validity, - check_pieced_value_invalid, - indirect_pieced_value, - check_pieced_synthetic_pointer, - copy_pieced_value_closure, - free_pieced_value_closure -}; - -/* Helper function which throws an error if a synthetic pointer is - invalid. */ - -static void -invalid_synthetic_pointer (void) -{ - error (_("access outside bounds of object " - "referenced via synthetic pointer")); -} + indirect_pieced_value, + coerce_pieced_ref, + check_pieced_synthetic_pointer, + copy_pieced_value_closure, + free_pieced_value_closure +}; /* 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, unsigned short size, + 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 dwarf_expr_baton baton; - struct dwarf_expr_context *ctx; - struct cleanup *old_chain, *value_chain; struct objfile *objfile = dwarf2_per_cu_objfile (per_cu); - volatile struct gdb_exception ex; - 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); - - baton.frame = frame; - baton.per_cu = per_cu; - - ctx = new_dwarf_expr_context (); - old_chain = make_cleanup_free_dwarf_expr_context (ctx); - value_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->offset = dwarf2_per_cu_text_offset (per_cu); - ctx->baton = &baton; - ctx->read_reg = dwarf_expr_read_reg; - ctx->read_mem = dwarf_expr_read_mem; - ctx->get_frame_base = dwarf_expr_frame_base; - ctx->get_frame_cfa = dwarf_expr_frame_cfa; - ctx->get_frame_pc = dwarf_expr_frame_pc; - ctx->get_tls_address = dwarf_expr_tls_address; - ctx->dwarf_call = dwarf_expr_dwarf_call; - ctx->get_base_type = dwarf_expr_get_base_type; - - TRY_CATCH (ex, RETURN_MASK_ERROR) + return allocate_optimized_out_value (subobj_type); + + dwarf_evaluate_loc_desc ctx; + ctx.frame = frame; + ctx.per_cu = per_cu; + ctx.obj_address = 0; + + 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 { - dwarf_expr_eval (ctx, data, size); + ctx.eval (data, size); } - if (ex.reason < 0) + catch (const gdb_exception_error &ex) { if (ex.error == NOT_AVAILABLE_ERROR) { - do_cleanups (old_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); + free_values.free_to_mark (); + return allocate_optimized_out_value (subobj_type); + } else - throw_exception (ex); + throw; } - if (ctx->num_pieces > 0) + if (ctx.pieces.size () > 0) { struct piece_closure *c; - struct frame_id frame_id = get_frame_id (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_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 { - switch (ctx->location) + switch (ctx.location) { case DWARF_VALUE_REGISTER: { struct gdbarch *arch = get_frame_arch (frame); - ULONGEST dwarf_regnum = value_as_long (dwarf_expr_fetch (ctx, 0)); - int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum); + int dwarf_regnum + = 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); - if (gdb_regnum != -1) - retval = value_from_register (type, gdb_regnum, frame); - else - error (_("Unable to access DWARF register number %s"), - paddress (arch, dwarf_regnum)); + free_values.free_to_mark (); + retval = value_from_register (subobj_type, gdb_regnum, frame); + if (value_optimized_out (retval)) + { + struct value *tmp; + + /* This means the register has undefined value / was + not saved. As we're computing the location of some + variable etc. in the program, not a value for + inspecting a register ($pc, $sp, etc.), return a + generic optimized out value instead, so that we show + instead of . */ + tmp = allocate_value (subobj_type); + value_contents_copy (tmp, 0, retval, 0, + TYPE_LENGTH (subobj_type)); + retval = tmp; + } } break; case DWARF_VALUE_MEMORY: { - CORE_ADDR address = dwarf_expr_fetch_address (ctx, 0); - int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0); + struct type *ptr_type; + CORE_ADDR address = ctx.fetch_address (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 + pointer to address conversion would be performed as part + of those operations, but the type of the object to + which the address refers is not known at the time of + the operation. Therefore, we do the conversion here + since the type is readily available. */ + + switch (TYPE_CODE (subobj_type)) + { + case TYPE_CODE_FUNC: + case TYPE_CODE_METHOD: + ptr_type = builtin_type (ctx.gdbarch)->builtin_func_ptr; + break; + default: + ptr_type = builtin_type (ctx.gdbarch)->builtin_data_ptr; + break; + } + address = value_as_address (value_from_pointer (ptr_type, address)); - do_cleanups (value_chain); - retval = allocate_value_lazy (type); - VALUE_LVAL (retval) = lval_memory; + free_values.free_to_mark (); + retval = value_at_lazy (subobj_type, + address + subobj_byte_offset); if (in_stack_memory) set_value_stack (retval, 1); - set_value_address (retval, address + byte_offset); } break; case DWARF_VALUE_STACK: { - struct value *value = dwarf_expr_fetch (ctx, 0); - gdb_byte *contents; - const gdb_byte *val_bytes; + struct value *value = ctx.fetch (0); 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)) - n = TYPE_LENGTH (type); - memcpy (contents, val_bytes, n); + retval = allocate_value (subobj_type); + + /* 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)) - 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 @@ -1255,9 +2331,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, } } - set_value_initialized (retval, ctx->initialized); - - do_cleanups (old_chain); + set_value_initialized (retval, ctx.initialized); return retval; } @@ -1267,142 +2341,392 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, struct value * dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame, - const gdb_byte *data, unsigned short size, + 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); } - -/* Helper functions and baton for dwarf2_loc_desc_needs_frame. */ +/* Evaluates a dwarf expression and stores the result in VAL, expecting + that the dwarf expression only produces a single CORE_ADDR. FRAME is the + frame in which the expression is evaluated. ADDR is a context (location of + a variable) and might be needed to evaluate the location expression. + Returns 1 on success, 0 otherwise. */ -struct needs_frame_baton +static int +dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton, + struct frame_info *frame, + CORE_ADDR addr, + CORE_ADDR *valp) { - int needs_frame; - struct dwarf2_per_cu_data *per_cu; -}; + struct objfile *objfile; -/* Reads from registers do require a frame. */ -static CORE_ADDR -needs_frame_read_reg (void *baton, int regnum) -{ - struct needs_frame_baton *nf_baton = baton; + if (dlbaton == NULL || dlbaton->size == 0) + return 0; - nf_baton->needs_frame = 1; - return 1; -} + dwarf_evaluate_loc_desc ctx; -/* Reads from memory do not require a frame. */ -static void -needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len) -{ - memset (buf, 0, len); -} + ctx.frame = frame; + ctx.per_cu = dlbaton->per_cu; + ctx.obj_address = addr; -/* Frame-relative accesses do require a frame. */ -static void -needs_frame_frame_base (void *baton, const gdb_byte **start, size_t * length) -{ - static gdb_byte lit0 = DW_OP_lit0; - struct needs_frame_baton *nf_baton = baton; + objfile = dwarf2_per_cu_objfile (dlbaton->per_cu); + + ctx.gdbarch = get_objfile_arch (objfile); + ctx.addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu); + ctx.ref_addr_size = dwarf2_per_cu_ref_addr_size (dlbaton->per_cu); + ctx.offset = dwarf2_per_cu_text_offset (dlbaton->per_cu); + + 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; + } - *start = &lit0; - *length = 1; + switch (ctx.location) + { + case DWARF_VALUE_REGISTER: + case DWARF_VALUE_MEMORY: + case DWARF_VALUE_STACK: + *valp = ctx.fetch_address (0); + if (ctx.location == DWARF_VALUE_REGISTER) + *valp = ctx.read_addr_from_reg (*valp); + return 1; + case DWARF_VALUE_LITERAL: + *valp = extract_signed_integer (ctx.data, ctx.len, + gdbarch_byte_order (ctx.gdbarch)); + return 1; + /* Unsupported dwarf values. */ + case DWARF_VALUE_OPTIMIZED_OUT: + case DWARF_VALUE_IMPLICIT_POINTER: + break; + } - nf_baton->needs_frame = 1; + return 0; } -/* CFA accesses require a frame. */ +/* See dwarf2loc.h. */ -static CORE_ADDR -needs_frame_frame_cfa (void *baton) +bool +dwarf2_evaluate_property (const struct dynamic_prop *prop, + struct frame_info *frame, + struct property_addr_info *addr_stack, + CORE_ADDR *value) { - struct needs_frame_baton *nf_baton = baton; + if (prop == NULL) + return false; - nf_baton->needs_frame = 1; - return 1; + if (frame == NULL && has_stack_frames ()) + frame = get_selected_frame (NULL); + + switch (prop->kind) + { + case PROP_LOCEXPR: + { + 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->locexpr.is_reference) + { + struct value *val = value_at (baton->property_type, *value); + *value = value_as_address (val); + } + 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; + + case PROP_LOCLIST: + { + struct dwarf2_property_baton *baton + = (struct dwarf2_property_baton *) prop->data.baton; + CORE_ADDR pc = get_frame_address_in_block (frame); + const gdb_byte *data; + struct value *val; + size_t size; + + data = dwarf2_find_location_expression (&baton->loclist, &size, pc); + if (data != NULL) + { + 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 true; + } + } + } + break; + + case PROP_CONST: + *value = prop->data.const_val; + return true; + + case PROP_ADDR_OFFSET: + { + struct dwarf2_property_baton *baton + = (struct dwarf2_property_baton *) prop->data.baton; + struct property_addr_info *pinfo; + struct value *val; + + for (pinfo = addr_stack; pinfo != NULL; pinfo = pinfo->next) + { + /* 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_from_contents + (baton->offset_info.type, + pinfo->valaddr + baton->offset_info.offset); + else + val = value_at (baton->offset_info.type, + pinfo->addr + baton->offset_info.offset); + *value = value_as_address (val); + return true; + } + } + + return false; } -/* Thread-local accesses do require a frame. */ -static CORE_ADDR -needs_frame_tls_address (void *baton, CORE_ADDR offset) +/* See dwarf2loc.h. */ + +void +dwarf2_compile_property_to_c (string_file *stream, + const char *result_name, + struct gdbarch *gdbarch, + unsigned char *registers_used, + const struct dynamic_prop *prop, + CORE_ADDR pc, + struct symbol *sym) { - struct needs_frame_baton *nf_baton = baton; + struct dwarf2_property_baton *baton + = (struct dwarf2_property_baton *) prop->data.baton; + const gdb_byte *data; + size_t size; + struct dwarf2_per_cu_data *per_cu; - nf_baton->needs_frame = 1; - return 1; + if (prop->kind == PROP_LOCEXPR) + { + data = baton->locexpr.data; + size = baton->locexpr.size; + per_cu = baton->locexpr.per_cu; + } + else + { + gdb_assert (prop->kind == PROP_LOCLIST); + + data = dwarf2_find_location_expression (&baton->loclist, &size, pc); + per_cu = baton->loclist.per_cu; + } + + compile_dwarf_bounds_to_c (stream, result_name, prop, sym, pc, + gdbarch, registers_used, + dwarf2_per_cu_addr_size (per_cu), + data, data + size, per_cu); } -/* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */ + +/* Helper functions and baton for dwarf2_loc_desc_get_symbol_read_needs. */ -static void -needs_frame_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset) +class symbol_needs_eval_context : public dwarf_expr_context { - struct needs_frame_baton *nf_baton = ctx->baton; + public: - per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu, - ctx->get_frame_pc, ctx->baton); -} + enum symbol_needs_kind needs; + struct dwarf2_per_cu_data *per_cu; + + /* Reads from registers do require a frame. */ + 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 + { + 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 + { + memset (buf, 0, len); + } + + /* Frame-relative accesses do require a frame. */ + void get_frame_base (const gdb_byte **start, size_t *length) override + { + static gdb_byte lit0 = DW_OP_lit0; + + *start = &lit0; + *length = 1; + + needs = SYMBOL_NEEDS_FRAME; + } + + /* CFA accesses require a frame. */ + CORE_ADDR get_frame_cfa () override + { + needs = SYMBOL_NEEDS_FRAME; + return 1; + } + + 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 + { + if (needs <= SYMBOL_NEEDS_REGISTERS) + needs = SYMBOL_NEEDS_REGISTERS; + return 1; + } + + /* Helper interface of per_cu_dwarf_call for + dwarf2_loc_desc_get_symbol_read_needs. */ + + void dwarf_call (cu_offset die_offset) override + { + per_cu_dwarf_call (this, die_offset, per_cu); + } + + /* Helper interface of sect_variable_value for + dwarf2_loc_desc_get_symbol_read_needs. */ + + struct value *dwarf_variable_value (sect_offset sect_off) override + { + return sect_variable_value (this, sect_off, per_cu); + } + + /* DW_OP_entry_value accesses require a caller, therefore a + frame. */ + + void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind, + union call_site_parameter_u kind_u, + int deref_size) override + { + needs = SYMBOL_NEEDS_FRAME; + + /* The expression may require some stub values on DWARF stack. */ + push_address (0, 0); + } + + /* DW_OP_addrx and DW_OP_GNU_addr_index doesn't require a frame. */ + + 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 + { + /* Nothing to do. */ + return 1; + } +}; -/* Return non-zero iff the location expression at DATA (length SIZE) - requires a frame to evaluate. */ +/* Compute the correct symbol_needs_kind value for the location + expression at DATA (length SIZE). */ -static int -dwarf2_loc_desc_needs_frame (const gdb_byte *data, unsigned short size, - struct dwarf2_per_cu_data *per_cu) +static enum symbol_needs_kind +dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte *data, size_t size, + struct dwarf2_per_cu_data *per_cu) { - struct needs_frame_baton baton; - struct dwarf_expr_context *ctx; int in_reg; - struct cleanup *old_chain; struct objfile *objfile = dwarf2_per_cu_objfile (per_cu); - baton.needs_frame = 0; - baton.per_cu = per_cu; + scoped_value_mark free_values; - ctx = new_dwarf_expr_context (); - old_chain = make_cleanup_free_dwarf_expr_context (ctx); - make_cleanup_value_free_to_mark (value_mark ()); + symbol_needs_eval_context ctx; - ctx->gdbarch = get_objfile_arch (objfile); - ctx->addr_size = dwarf2_per_cu_addr_size (per_cu); - ctx->offset = dwarf2_per_cu_text_offset (per_cu); - ctx->baton = &baton; - ctx->read_reg = needs_frame_read_reg; - ctx->read_mem = needs_frame_read_mem; - ctx->get_frame_base = needs_frame_frame_base; - ctx->get_frame_cfa = needs_frame_frame_cfa; - ctx->get_frame_pc = needs_frame_frame_cfa; - ctx->get_tls_address = needs_frame_tls_address; - ctx->dwarf_call = needs_frame_dwarf_call; + ctx.needs = SYMBOL_NEEDS_NONE; + ctx.per_cu = per_cu; + 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); - dwarf_expr_eval (ctx, data, size); + ctx.eval (data, size); - in_reg = ctx->location == DWARF_VALUE_REGISTER; + 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; - } + /* 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; - do_cleanups (old_chain); - - return baton.needs_frame || in_reg; + if (in_reg) + ctx.needs = SYMBOL_NEEDS_FRAME; + return ctx.needs; } /* 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 = dwarf_stack_op_name (op); + const char *name = get_DW_OP_name (op); if (name) error (_("DWARF operator %s cannot be translated to an agent expression"), @@ -1413,18 +2737,53 @@ unimplemented (unsigned int op) op); } -/* A helper function to convert a DWARF register to an arch register. - ARCH is the architecture. - DWARF_REG is the register. - This will throw an exception if the DWARF register cannot be - translated to an architecture register. */ +/* See dwarf2loc.h. -static int -translate_register (struct gdbarch *arch, int dwarf_reg) + This is basically a wrapper on gdbarch_dwarf2_reg_to_regnum so that we + can issue a complaint, which is better than having every target's + implementation of dwarf2_reg_to_regnum do it. */ + +int +dwarf_reg_to_regnum (struct gdbarch *arch, int dwarf_reg) { int reg = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_reg); + + if (reg == -1) + { + complaint (_("bad DWARF register number %d"), dwarf_reg); + } + return reg; +} + +/* Subroutine of dwarf_reg_to_regnum_or_error to simplify it. + Throw an error because DWARF_REG is bad. */ + +static void +throw_bad_regnum_error (ULONGEST dwarf_reg) +{ + /* Still want to print -1 as "-1". + We *could* have int and ULONGEST versions of dwarf2_reg_to_regnum_or_error + but that's overkill for now. */ + if ((int) dwarf_reg == dwarf_reg) + error (_("Unable to access DWARF register number %d"), (int) dwarf_reg); + error (_("Unable to access DWARF register number %s"), + pulongest (dwarf_reg)); +} + +/* See dwarf2loc.h. */ + +int +dwarf_reg_to_regnum_or_error (struct gdbarch *arch, ULONGEST dwarf_reg) +{ + int reg; + + if (dwarf_reg > INT_MAX) + throw_bad_regnum_error (dwarf_reg); + /* Yes, we will end up issuing a complaint and an error if DWARF_REG is + bad, but that's ok. */ + reg = dwarf_reg_to_regnum (arch, (int) dwarf_reg); if (reg == -1) - error (_("Unable to access DWARF register number %d"), dwarf_reg); + throw_bad_regnum_error (dwarf_reg); return reg; } @@ -1439,9 +2798,9 @@ access_memory (struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits) { ULONGEST nbytes = (nbits + 7) / 8; - gdb_assert (nbits > 0 && nbits <= sizeof (LONGEST)); + gdb_assert (nbytes > 0 && nbytes <= sizeof (LONGEST)); - if (trace_kludge) + if (expr->tracing) ax_trace_quick (expr, nbytes); if (nbits <= 8) @@ -1457,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. */ @@ -1476,7 +2835,7 @@ access_memory (struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits) static CORE_ADDR get_ax_pc (void *baton) { - struct agent_expr *expr = baton; + struct agent_expr *expr = (struct agent_expr *) baton; return expr->scope; } @@ -1496,37 +2855,29 @@ 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) { - struct cleanup *cleanups; - int i, *offsets; - VEC(int) *dw_labels = NULL, *patches = NULL; + 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; - offsets = xmalloc ((op_end - op_ptr) * sizeof (int)); - cleanups = make_cleanup (xfree, offsets); - - for (i = 0; i < op_end - op_ptr; ++i) - offsets[i] = -1; - - make_cleanup (VEC_cleanup (int), &dw_labels); - make_cleanup (VEC_cleanup (int), &patches); + std::vector offsets (op_end - op_ptr, -1); /* By default we are making an address. */ loc->kind = axs_lvalue_memory; while (op_ptr < op_end) { - enum dwarf_location_atom op = *op_ptr; - ULONGEST uoffset, reg; - LONGEST offset; + enum dwarf_location_atom op = (enum dwarf_location_atom) *op_ptr; + uint64_t uoffset, reg; + int64_t offset; int i; offsets[op_ptr - base] = expr->len; @@ -1630,11 +2981,11 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, op_ptr += 8; break; case DW_OP_constu: - op_ptr = read_uleb128 (op_ptr, op_end, &uoffset); + op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset); ax_const_l (expr, uoffset); break; case DW_OP_consts: - op_ptr = read_sleb128 (op_ptr, op_end, &offset); + op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset); ax_const_l (expr, offset); break; @@ -1671,22 +3022,22 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, case DW_OP_reg30: case DW_OP_reg31: dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx"); - loc->u.reg = translate_register (arch, op - DW_OP_reg0); + loc->u.reg = dwarf_reg_to_regnum_or_error (arch, op - DW_OP_reg0); loc->kind = axs_lvalue_register; break; case DW_OP_regx: - op_ptr = read_uleb128 (op_ptr, op_end, ®); + op_ptr = safe_read_uleb128 (op_ptr, op_end, ®); dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx"); - loc->u.reg = translate_register (arch, reg); + loc->u.reg = dwarf_reg_to_regnum_or_error (arch, reg); loc->kind = axs_lvalue_register; break; case DW_OP_implicit_value: { - ULONGEST len; + uint64_t len; - op_ptr = read_uleb128 (op_ptr, op_end, &len); + op_ptr = safe_read_uleb128 (op_ptr, op_end, &len); if (op_ptr + len > op_end) error (_("DW_OP_implicit_value: too few bytes available.")); if (len > sizeof (ULONGEST)) @@ -1740,8 +3091,8 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, case DW_OP_breg29: case DW_OP_breg30: case DW_OP_breg31: - op_ptr = read_sleb128 (op_ptr, op_end, &offset); - i = translate_register (arch, op - DW_OP_breg0); + op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset); + i = dwarf_reg_to_regnum_or_error (arch, op - DW_OP_breg0); ax_reg (expr, i); if (offset != 0) { @@ -1751,9 +3102,9 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, break; case DW_OP_bregx: { - op_ptr = read_uleb128 (op_ptr, op_end, ®); - op_ptr = read_sleb128 (op_ptr, op_end, &offset); - i = translate_register (arch, reg); + op_ptr = safe_read_uleb128 (op_ptr, op_end, ®); + op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset); + i = dwarf_reg_to_regnum_or_error (arch, reg); ax_reg (expr, i); if (offset != 0) { @@ -1766,10 +3117,8 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, { const gdb_byte *datastart; size_t datalen; - unsigned int before_stack_len; - struct block *b; + const struct block *b; struct symbol *framefunc; - LONGEST base_offset = 0; b = block_for_pc (expr->scope); @@ -1781,12 +3130,14 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, if (!framefunc) error (_("No function found for block")); - dwarf_expr_frame_base_1 (framefunc, expr->scope, - &datastart, &datalen); + func_get_frame_base_dwarf_block (framefunc, expr->scope, + &datastart, &datalen); - op_ptr = read_sleb128 (op_ptr, op_end, &offset); - dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart, + op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset); + dwarf2_compile_expr_to_ax (expr, loc, addr_size, datastart, datastart + datalen, per_cu); + if (loc->kind == axs_lvalue_register) + require_rvalue (expr, loc); if (offset != 0) { @@ -1833,26 +3184,10 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, else size = addr_size; - switch (size) - { - case 8: - ax_simple (expr, aop_ref8); - break; - case 16: - ax_simple (expr, aop_ref16); - break; - case 32: - ax_simple (expr, aop_ref32); - break; - case 64: - ax_simple (expr, aop_ref64); - break; - default: - /* Note that dwarf_stack_op_name will never return - NULL here. */ - error (_("Unsupported size %d in %s"), - size, dwarf_stack_op_name (op)); - } + if (size != 1 && size != 2 && size != 4 && size != 8) + error (_("Unsupported size %d in %s"), + size, get_DW_OP_name (op)); + access_memory (arch, expr, size * TARGET_CHAR_BIT); } break; @@ -1885,7 +3220,7 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, break; case DW_OP_plus_uconst: - op_ptr = read_uleb128 (op_ptr, op_end, ®); + op_ptr = safe_read_uleb128 (op_ptr, op_end, ®); /* It would be really weird to emit `DW_OP_plus_uconst 0', but we micro-optimize anyhow. */ if (reg != 0) @@ -2003,11 +3338,42 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, break; case DW_OP_call_frame_cfa: - dwarf2_compile_cfa_to_ax (expr, loc, arch, expr->scope, per_cu); - loc->kind = axs_lvalue_memory; + { + int regnum; + CORE_ADDR text_offset; + LONGEST off; + const gdb_byte *cfa_start, *cfa_end; + + if (dwarf2_fetch_cfa_info (arch, expr->scope, per_cu, + ®num, &off, + &text_offset, &cfa_start, &cfa_end)) + { + /* Register. */ + ax_reg (expr, regnum); + if (off != 0) + { + ax_const_l (expr, off); + ax_simple (expr, aop_add); + } + } + else + { + /* Another expression. */ + ax_const_l (expr, text_offset); + dwarf2_compile_expr_to_ax (expr, loc, addr_size, cfa_start, + cfa_end, per_cu); + } + + loc->kind = axs_lvalue_memory; + } break; case DW_OP_GNU_push_tls_address: + case DW_OP_form_tls_address: + unimplemented (op); + break; + + case DW_OP_push_object_address: unimplemented (op); break; @@ -2015,8 +3381,8 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, offset = extract_signed_integer (op_ptr, 2, byte_order); op_ptr += 2; i = ax_goto (expr, aop_goto); - VEC_safe_push (int, dw_labels, op_ptr + offset - base); - VEC_safe_push (int, patches, i); + dw_labels.push_back (op_ptr + offset - base); + patches.push_back (i); break; case DW_OP_bra: @@ -2025,8 +3391,8 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, /* Zero extend the operand. */ ax_zero_ext (expr, addr_size_bits); i = ax_goto (expr, aop_if_goto); - VEC_safe_push (int, dw_labels, op_ptr + offset - base); - VEC_safe_push (int, patches, i); + dw_labels.push_back (op_ptr + offset - base); + patches.push_back (i); break; case DW_OP_nop: @@ -2035,20 +3401,20 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, case DW_OP_piece: case DW_OP_bit_piece: { - ULONGEST size, offset; + uint64_t size; if (op_ptr - 1 == previous_piece) error (_("Cannot translate empty pieces to agent expressions")); previous_piece = op_ptr - 1; - op_ptr = read_uleb128 (op_ptr, op_end, &size); + op_ptr = safe_read_uleb128 (op_ptr, op_end, &size); if (op == DW_OP_piece) { size *= 8; - offset = 0; + uoffset = 0; } else - op_ptr = 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")); @@ -2062,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; @@ -2112,36 +3478,37 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, uoffset = extract_unsigned_integer (op_ptr, size, byte_order); op_ptr += size; - block = dwarf2_fetch_die_location_block (uoffset, per_cu, - get_ax_pc, expr); + 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 < VEC_length (int, patches); ++i) + for (int i = 0; i < patches.size (); ++i) { - int targ = offsets[VEC_index (int, dw_labels, i)]; + int targ = offsets[dw_labels[i]]; if (targ == -1) internal_error (__FILE__, __LINE__, _("invalid label")); - ax_label (expr, VEC_index (int, patches, i), targ); + ax_label (expr, patches[i], targ); } - - do_cleanups (cleanups); } @@ -2150,7 +3517,8 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, static struct value * locexpr_read_variable (struct symbol *symbol, struct frame_info *frame) { - struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol); + struct dwarf2_locexpr_baton *dlbaton + = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol); struct value *val; val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, dlbaton->data, @@ -2159,14 +3527,31 @@ locexpr_read_variable (struct symbol *symbol, struct frame_info *frame) return val; } -/* Return non-zero iff we need a frame to evaluate SYMBOL. */ -static int -locexpr_read_needs_frame (struct symbol *symbol) +/* Return the value of SYMBOL in FRAME at (callee) FRAME's function + entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR + will be thrown. */ + +static struct value * +locexpr_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame) +{ + struct dwarf2_locexpr_baton *dlbaton + = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol); + + return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, dlbaton->data, + dlbaton->size); +} + +/* Implementation of get_symbol_read_needs from + symbol_computed_ops. */ + +static enum symbol_needs_kind +locexpr_get_symbol_read_needs (struct symbol *symbol) { - struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol); + struct dwarf2_locexpr_baton *dlbaton + = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol); - return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size, - dlbaton->per_cu); + return dwarf2_loc_desc_get_symbol_read_needs (dlbaton->data, dlbaton->size, + dlbaton->per_cu); } /* Return true if DATA points to the end of a piece. END is one past @@ -2186,22 +3571,35 @@ locexpr_regname (struct gdbarch *gdbarch, int dwarf_regnum) { int regnum; - regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum); + /* This doesn't use dwarf_reg_to_regnum_or_error on purpose. + We'd rather print *something* here than throw an error. */ + regnum = dwarf_reg_to_regnum (gdbarch, dwarf_regnum); + /* gdbarch_register_name may just return "", return something more + descriptive for bad register numbers. */ + if (regnum == -1) + { + /* The text is output as "$bad_register_number". + That is why we use the underscores. */ + return _("bad_register_number"); + } return gdbarch_register_name (gdbarch, regnum); } /* Nicely describe a single piece of a location, returning an updated position in the bytecode sequence. This function cannot recognize all locations; if a location is not recognized, it simply returns - DATA. */ + DATA. If there is an error during reading, e.g. we run off the end + of the buffer, an error is thrown. */ static const gdb_byte * locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream, CORE_ADDR addr, struct objfile *objfile, + struct dwarf2_per_cu_data *per_cu, const gdb_byte *data, const gdb_byte *end, unsigned int addr_size) { struct gdbarch *gdbarch = get_objfile_arch (objfile); + size_t leb128_size; if (data[0] >= DW_OP_reg0 && data[0] <= DW_OP_reg31) { @@ -2211,23 +3609,23 @@ locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream, } else if (data[0] == DW_OP_regx) { - ULONGEST reg; + uint64_t reg; - data = read_uleb128 (data + 1, end, ®); + data = safe_read_uleb128 (data + 1, end, ®); fprintf_filtered (stream, _("a variable in $%s"), locexpr_regname (gdbarch, reg)); } else if (data[0] == DW_OP_fbreg) { - struct block *b; + const struct block *b; struct symbol *framefunc; int frame_reg = 0; - LONGEST frame_offset; + int64_t frame_offset; const gdb_byte *base_data, *new_data, *save_data = data; size_t base_size; - LONGEST base_offset = 0; + int64_t base_offset = 0; - new_data = read_sleb128 (data + 1, end, &frame_offset); + new_data = safe_read_sleb128 (data + 1, end, &frame_offset); if (!piece_end_p (new_data, end)) return data; data = new_data; @@ -2236,27 +3634,27 @@ 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 ()); - dwarf_expr_frame_base_1 (framefunc, addr, &base_data, &base_size); + func_get_frame_base_dwarf_block (framefunc, addr, &base_data, &base_size); if (base_data[0] >= DW_OP_breg0 && base_data[0] <= DW_OP_breg31) { const gdb_byte *buf_end; frame_reg = base_data[0] - DW_OP_breg0; - buf_end = read_sleb128 (base_data + 1, - base_data + base_size, &base_offset); + buf_end = safe_read_sleb128 (base_data + 1, base_data + base_size, + &base_offset); 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) { @@ -2279,9 +3677,9 @@ locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream, else if (data[0] >= DW_OP_breg0 && data[0] <= DW_OP_breg31 && piece_end_p (data, end)) { - LONGEST offset; + int64_t offset; - data = read_sleb128 (data + 1, end, &offset); + data = safe_read_sleb128 (data + 1, end, &offset); fprintf_filtered (stream, _("a variable at offset %s from base reg $%s"), @@ -2307,7 +3705,8 @@ locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream, && (data[0] == DW_OP_addr || (addr_size == 4 && data[0] == DW_OP_const4u) || (addr_size == 8 && data[0] == DW_OP_const8u)) - && data[1 + addr_size] == DW_OP_GNU_push_tls_address + && (data[1 + addr_size] == DW_OP_GNU_push_tls_address + || data[1 + addr_size] == DW_OP_form_tls_address) && piece_end_p (data + 2 + addr_size, end)) { ULONGEST offset; @@ -2317,10 +3716,34 @@ locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream, fprintf_filtered (stream, _("a thread-local variable at offset 0x%s " "in the thread-local storage for `%s'"), - phex_nz (offset, addr_size), objfile->name); + phex_nz (offset, addr_size), objfile_name (objfile)); data += 1 + addr_size + 1; } + + /* With -gsplit-dwarf a TLS variable can also look like this: + DW_AT_location : 3 byte block: fc 4 e0 + (DW_OP_GNU_const_index: 4; + DW_OP_GNU_push_tls_address) */ + else if (data + 3 <= end + && data + 1 + (leb128_size = skip_leb128 (data + 1, end)) < end + && data[0] == DW_OP_GNU_const_index + && leb128_size > 0 + && (data[1 + leb128_size] == DW_OP_GNU_push_tls_address + || data[1 + leb128_size] == DW_OP_form_tls_address) + && piece_end_p (data + 2 + leb128_size, end)) + { + uint64_t offset; + + data = safe_read_uleb128 (data + 1, end, &offset); + offset = dwarf2_read_addr_index (per_cu, offset); + fprintf_filtered (stream, + _("a thread-local variable at offset 0x%s " + "in the thread-local storage for `%s'"), + phex_nz (offset, addr_size), objfile_name (objfile)); + ++data; + } + else if (data[0] >= DW_OP_lit0 && data[0] <= DW_OP_lit31 && data + 1 < end @@ -2336,35 +3759,34 @@ locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream, /* Disassemble an expression, stopping at the end of a piece or at the end of the expression. Returns a pointer to the next unread byte in the input expression. If ALL is nonzero, then this function - will keep going until it reaches the end of the expression. */ + will keep going until it reaches the end of the expression. + If there is an error during reading, e.g. we run off the end + of the buffer, an error is thrown. */ static const gdb_byte * disassemble_dwarf_expression (struct ui_file *stream, struct gdbarch *arch, unsigned int addr_size, - int offset_size, + int offset_size, const gdb_byte *start, const gdb_byte *data, const gdb_byte *end, - int all, + int indent, int all, struct dwarf2_per_cu_data *per_cu) { - const gdb_byte *start = data; - - fprintf_filtered (stream, _("a complex DWARF expression:\n")); - while (data < end && (all || (data[0] != DW_OP_piece && data[0] != DW_OP_bit_piece))) { - enum dwarf_location_atom op = *data++; - ULONGEST ul; - LONGEST l; + enum dwarf_location_atom op = (enum dwarf_location_atom) *data++; + uint64_t ul; + int64_t l; const char *name; - name = dwarf_stack_op_name (op); + name = get_DW_OP_name (op); if (!name) error (_("Unrecognized DWARF opcode 0x%02x at %ld"), op, (long) (data - 1 - start)); - fprintf_filtered (stream, " % 4ld: %s", (long) (data - 1 - start), name); + fprintf_filtered (stream, " %*ld: %s", indent + 4, + (long) (data - 1 - start), name); switch (op) { @@ -2416,11 +3838,11 @@ disassemble_dwarf_expression (struct ui_file *stream, fprintf_filtered (stream, " %s", plongest (l)); break; case DW_OP_constu: - data = read_uleb128 (data, end, &ul); + data = safe_read_uleb128 (data, end, &ul); fprintf_filtered (stream, " %s", pulongest (ul)); break; case DW_OP_consts: - data = read_sleb128 (data, end, &l); + data = safe_read_sleb128 (data, end, &l); fprintf_filtered (stream, " %s", plongest (l)); break; @@ -2461,13 +3883,13 @@ disassemble_dwarf_expression (struct ui_file *stream, break; case DW_OP_regx: - data = read_uleb128 (data, end, &ul); + data = safe_read_uleb128 (data, end, &ul); fprintf_filtered (stream, " %s [$%s]", pulongest (ul), locexpr_regname (arch, (int) ul)); break; case DW_OP_implicit_value: - data = read_uleb128 (data, end, &ul); + data = safe_read_uleb128 (data, end, &ul); data += ul; fprintf_filtered (stream, " %s", pulongest (ul)); break; @@ -2504,14 +3926,14 @@ disassemble_dwarf_expression (struct ui_file *stream, case DW_OP_breg29: case DW_OP_breg30: case DW_OP_breg31: - data = read_sleb128 (data, end, &l); + data = safe_read_sleb128 (data, end, &l); fprintf_filtered (stream, " %s [$%s]", plongest (l), locexpr_regname (arch, op - DW_OP_breg0)); break; case DW_OP_bregx: - data = read_uleb128 (data, end, &ul); - data = read_sleb128 (data, end, &l); + data = safe_read_uleb128 (data, end, &ul); + data = safe_read_sleb128 (data, end, &l); fprintf_filtered (stream, " register %s [$%s] offset %s", pulongest (ul), locexpr_regname (arch, (int) ul), @@ -2519,7 +3941,7 @@ disassemble_dwarf_expression (struct ui_file *stream, break; case DW_OP_fbreg: - data = read_sleb128 (data, end, &l); + data = safe_read_sleb128 (data, end, &l); fprintf_filtered (stream, " %s", plongest (l)); break; @@ -2531,7 +3953,7 @@ disassemble_dwarf_expression (struct ui_file *stream, break; case DW_OP_plus_uconst: - data = read_uleb128 (data, end, &ul); + data = safe_read_uleb128 (data, end, &ul); fprintf_filtered (stream, " %s", pulongest (ul)); break; @@ -2569,28 +3991,29 @@ disassemble_dwarf_expression (struct ui_file *stream, break; case DW_OP_piece: - data = read_uleb128 (data, end, &ul); + data = safe_read_uleb128 (data, end, &ul); fprintf_filtered (stream, " %s (bytes)", pulongest (ul)); break; case DW_OP_bit_piece: { - ULONGEST offset; + uint64_t offset; - data = read_uleb128 (data, end, &ul); - data = read_uleb128 (data, end, &offset); + data = safe_read_uleb128 (data, end, &ul); + data = safe_read_uleb128 (data, end, &offset); fprintf_filtered (stream, " size %s offset %s (bits)", pulongest (ul), pulongest (offset)); } break; + case DW_OP_implicit_pointer: case DW_OP_GNU_implicit_pointer: { ul = extract_unsigned_integer (data, offset_size, gdbarch_byte_order (arch)); data += offset_size; - data = read_sleb128 (data, end, &l); + data = safe_read_sleb128 (data, end, &l); fprintf_filtered (stream, " DIE %s offset %s", phex_nz (ul, offset_size), @@ -2598,58 +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++; - ULONGEST offset; + int deref_addr_size = *data++; struct type *type; - data = read_uleb128 (data, end, &offset); + data = safe_read_uleb128 (data, end, &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, 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: { - ULONGEST type_die; struct type *type; - data = read_uleb128 (data, end, &type_die); + data = safe_read_uleb128 (data, end, &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, 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: { - ULONGEST type_die, reg; + uint64_t reg; struct type *type; - data = read_uleb128 (data, end, ®); - data = read_uleb128 (data, end, &type_die); + data = safe_read_uleb128 (data, end, ®); + data = safe_read_uleb128 (data, end, &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, 0), + fprintf_filtered (stream, " [0x%s]> [$%s]", + 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: { - ULONGEST type_die; + data = safe_read_uleb128 (data, end, &ul); + cu_offset type_die = (cu_offset) ul; - data = read_uleb128 (data, end, &type_die); - - if (type_die == 0) + if (to_underlying (type_die) == 0) fprintf_filtered (stream, "<0>"); else { @@ -2658,10 +4089,46 @@ 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, 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); + disassemble_dwarf_expression (stream, arch, addr_size, offset_size, + start, data, data + ul, indent + 2, + all, per_cu); + data += ul; + continue; + + case DW_OP_GNU_parameter_ref: + ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch)); + data += 4; + 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); + fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size)); + break; + case DW_OP_GNU_const_index: + data = safe_read_uleb128 (data, end, &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"); @@ -2676,7 +4143,7 @@ disassemble_dwarf_expression (struct ui_file *stream, static void locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr, struct ui_file *stream, - const gdb_byte *data, int size, + const gdb_byte *data, size_t size, struct objfile *objfile, unsigned int addr_size, int offset_size, struct dwarf2_per_cu_data *per_cu) { @@ -2693,10 +4160,10 @@ locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr, else fprintf_filtered (stream, _(", and ")); - if (!dwarf2_always_disassemble) + if (!dwarf_always_disassemble) { data = locexpr_describe_location_piece (symbol, stream, - addr, objfile, + addr, objfile, per_cu, data, end, addr_size); /* If we printed anything, or if we have an empty piece, then don't disassemble. */ @@ -2706,11 +4173,15 @@ locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr, disassemble = 0; } if (disassemble) - data = disassemble_dwarf_expression (stream, - get_objfile_arch (objfile), - addr_size, offset_size, data, end, - dwarf2_always_disassemble, - per_cu); + { + fprintf_filtered (stream, _("a complex DWARF expression:\n")); + data = disassemble_dwarf_expression (stream, + get_objfile_arch (objfile), + addr_size, offset_size, data, + data, end, 0, + dwarf_always_disassemble, + per_cu); + } if (data < end) { @@ -2720,9 +4191,9 @@ locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr, fprintf_filtered (stream, " "); if (data[0] == DW_OP_piece) { - ULONGEST bytes; + uint64_t bytes; - data = read_uleb128 (data + 1, end, &bytes); + data = safe_read_uleb128 (data + 1, end, &bytes); if (empty) fprintf_filtered (stream, _("an empty %s-byte piece"), @@ -2733,10 +4204,10 @@ locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr, } else if (data[0] == DW_OP_bit_piece) { - ULONGEST bits, offset; + uint64_t bits, offset; - data = read_uleb128 (data + 1, end, &bits); - data = read_uleb128 (data, end, &offset); + data = safe_read_uleb128 (data + 1, end, &bits); + data = safe_read_uleb128 (data, end, &offset); if (empty) fprintf_filtered (stream, @@ -2757,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 @@ -2767,7 +4238,8 @@ static void locexpr_describe_location (struct symbol *symbol, CORE_ADDR addr, struct ui_file *stream) { - struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol); + struct dwarf2_locexpr_baton *dlbaton + = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol); struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu); unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu); int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu); @@ -2782,27 +4254,51 @@ 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 = SYMBOL_LOCATION_BATON (symbol); + struct dwarf2_locexpr_baton *dlbaton + = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol); unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu); - if (dlbaton->data == NULL || dlbaton->size == 0) + 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, string_file *stream, + struct gdbarch *gdbarch, + unsigned char *registers_used, + CORE_ADDR pc, const char *result_name) +{ + struct dwarf2_locexpr_baton *dlbaton + = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (sym); + unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu); + + if (dlbaton->size == 0) + error (_("symbol \"%s\" is optimized out"), sym->natural_name ()); + + compile_dwarf_expr_to_c (stream, result_name, + sym, pc, gdbarch, registers_used, addr_size, + dlbaton->data, dlbaton->data + dlbaton->size, + dlbaton->per_cu); } /* The set of location functions used with the DWARF-2 expression evaluator. */ const struct symbol_computed_ops dwarf2_locexpr_funcs = { locexpr_read_variable, - locexpr_read_needs_frame, + locexpr_read_variable_at_entry, + locexpr_get_symbol_read_needs, locexpr_describe_location, - locexpr_tracepoint_var_ref + 0, /* location_has_loclist */ + locexpr_tracepoint_var_ref, + locexpr_generate_c_location }; @@ -2814,25 +4310,52 @@ const struct symbol_computed_ops dwarf2_locexpr_funcs = { static struct value * loclist_read_variable (struct symbol *symbol, struct frame_info *frame) { - struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol); + struct dwarf2_loclist_baton *dlbaton + = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol); struct value *val; const gdb_byte *data; size_t size; CORE_ADDR pc = frame ? get_frame_address_in_block (frame) : 0; data = dwarf2_find_location_expression (dlbaton, &size, pc); - if (data == NULL) - val = allocate_optimized_out_value (SYMBOL_TYPE (symbol)); - else - val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, data, size, - dlbaton->per_cu); + val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, data, size, + dlbaton->per_cu); return val; } -/* Return non-zero iff we need a frame to evaluate SYMBOL. */ -static int -loclist_read_needs_frame (struct symbol *symbol) +/* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function + entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR + will be thrown. + + Function always returns non-NULL value, it may be marked optimized out if + inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR + if it cannot resolve the parameter for any reason. */ + +static struct value * +loclist_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame) +{ + struct dwarf2_loclist_baton *dlbaton + = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol); + const gdb_byte *data; + size_t size; + CORE_ADDR pc; + + if (frame == NULL || !get_frame_func_if_available (frame, &pc)) + return allocate_optimized_out_value (SYMBOL_TYPE (symbol)); + + data = dwarf2_find_location_expression (dlbaton, &size, pc); + if (data == NULL) + return allocate_optimized_out_value (SYMBOL_TYPE (symbol)); + + return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, data, size); +} + +/* Implementation of get_symbol_read_needs from + symbol_computed_ops. */ + +static enum symbol_needs_kind +loclist_symbol_needs (struct symbol *symbol) { /* If there's a location list, then assume we need to have a frame to choose the appropriate location expression. With tracking of @@ -2840,7 +4363,7 @@ loclist_read_needs_frame (struct symbol *symbol) is disabled in GCC at the moment until we figure out how to represent it. */ - return 1; + return SYMBOL_NEEDS_FRAME; } /* Print a natural-language description of SYMBOL to STREAM. This @@ -2851,20 +4374,19 @@ static void loclist_describe_location (struct symbol *symbol, CORE_ADDR addr, struct ui_file *stream) { - struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol); - CORE_ADDR low, high; + struct dwarf2_loclist_baton *dlbaton + = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol); const gdb_byte *loc_ptr, *buf_end; - int length, first = 1; struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu); struct gdbarch *gdbarch = get_objfile_arch (objfile); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu); int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu); int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd); - CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1)); /* Adjust base_address for relocatable objects. */ CORE_ADDR base_offset = dwarf2_per_cu_text_offset (dlbaton->per_cu); CORE_ADDR base_address = dlbaton->base_address + base_offset; + int done = 0; loc_ptr = dlbaton->data; buf_end = dlbaton->data + dlbaton->size; @@ -2872,41 +4394,51 @@ loclist_describe_location (struct symbol *symbol, CORE_ADDR addr, fprintf_filtered (stream, _("multi-location:\n")); /* Iterate through locations until we run out. */ - while (1) + while (!done) { - if (buf_end - loc_ptr < 2 * addr_size) - error (_("Corrupted DWARF expression for symbol \"%s\"."), - SYMBOL_PRINT_NAME (symbol)); - - if (signed_addr_p) - low = extract_signed_integer (loc_ptr, addr_size, byte_order); - else - low = extract_unsigned_integer (loc_ptr, addr_size, byte_order); - loc_ptr += addr_size; - - if (signed_addr_p) - high = extract_signed_integer (loc_ptr, addr_size, byte_order); + CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */ + int length; + enum debug_loc_kind kind; + const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */ + + if (dlbaton->from_dwo) + kind = decode_debug_loc_dwo_addresses (dlbaton->per_cu, + loc_ptr, buf_end, &new_ptr, + &low, &high, byte_order); else - high = extract_unsigned_integer (loc_ptr, addr_size, byte_order); - loc_ptr += addr_size; - - /* A base-address-selection entry. */ - if ((low & base_mask) == base_mask) + kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr, + &low, &high, + byte_order, addr_size, + signed_addr_p); + loc_ptr = new_ptr; + switch (kind) { + case DEBUG_LOC_END_OF_LIST: + done = 1; + continue; + case DEBUG_LOC_BASE_ADDRESS: base_address = high + base_offset; fprintf_filtered (stream, _(" Base address %s"), paddress (gdbarch, base_address)); continue; + case DEBUG_LOC_START_END: + case DEBUG_LOC_START_LENGTH: + break; + case DEBUG_LOC_BUFFER_OVERFLOW: + case DEBUG_LOC_INVALID_ENTRY: + error (_("Corrupted DWARF expression for symbol \"%s\"."), + symbol->print_name ()); + default: + gdb_assert_not_reached ("bad debug_loc_kind"); } - /* An end-of-list entry. */ - if (low == 0 && high == 0) - break; - /* Otherwise, a location expression entry. */ low += base_address; high += base_address; + low = gdbarch_adjust_dwarf2_addr (gdbarch, low); + high = gdbarch_adjust_dwarf2_addr (gdbarch, high); + length = extract_unsigned_integer (loc_ptr, 2, byte_order); loc_ptr += 2; @@ -2929,27 +4461,72 @@ 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 = SYMBOL_LOCATION_BATON (symbol); + struct dwarf2_loclist_baton *dlbaton + = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol); const gdb_byte *data; size_t size; unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu); data = dwarf2_find_location_expression (dlbaton, &size, ax->scope); - if (data == NULL || size == 0) + 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, string_file *stream, + struct gdbarch *gdbarch, + unsigned char *registers_used, + CORE_ADDR pc, const char *result_name) +{ + struct dwarf2_loclist_baton *dlbaton + = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (sym); + unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu); + const gdb_byte *data; + size_t size; + + data = dwarf2_find_location_expression (dlbaton, &size, pc); + if (size == 0) + error (_("symbol \"%s\" is optimized out"), sym->natural_name ()); + + compile_dwarf_expr_to_c (stream, result_name, + sym, pc, gdbarch, registers_used, addr_size, + data, data + size, + dlbaton->per_cu); +} + /* The set of location functions used with the DWARF-2 expression evaluator and location lists. */ const struct symbol_computed_ops dwarf2_loclist_funcs = { loclist_read_variable, - loclist_read_needs_frame, + loclist_read_variable_at_entry, + loclist_symbol_needs, loclist_describe_location, - loclist_tracepoint_var_ref + 1, /* location_has_loclist */ + loclist_tracepoint_var_ref, + loclist_generate_c_location }; + +void +_initialize_dwarf2loc (void) +{ + add_setshow_zuinteger_cmd ("entry-values", class_maintenance, + &entry_values_debug, + _("Set entry values and tail call frames " + "debugging."), + _("Show entry values and tail call frames " + "debugging."), + _("When non-zero, the process of determining " + "parameter values from function entry point " + "and tail call frames will be printed."), + NULL, + show_entry_values_debug, + &setdebuglist, &showdebuglist); +}