From f4091d26441c7a3bead8bdfd1a37f072a32f40a0 Mon Sep 17 00:00:00 2001 From: Zoran Zaric Date: Tue, 15 Sep 2020 16:08:45 +0100 Subject: [PATCH] Move piece_closure and its support to expr.c Following 5 patches series is trying to clean up the interface of the DWARF expression evaluator class (dwarf_expr_context). After merging all expression evaluators into one class, the next logical step is to make a clean user interface for that class. To do that, we first need to address the issue of class users writing and reading the internal data of the class directly. Fixing the case of writing is simple, it makes sense for an evaluator instance to be per architecture basis. Currently, the best separation seems to be per object file, so having that data (dwarf2_per_objfile) as a constructor argument makes sense. It also makes sense to get the address size from that object file, but unfortunately that interface does not exist at the moment. Luckily, address size information is already available to the users through other means. As a result, the address size also needs to be a class constructor argument, at least until a better interface for acquiring that information from an object file is implemented. The rest of the user written data comes down to a context of an evaluated expression (compilation unit context, frame context and passed in buffer context) and a source type information that a result of evaluating expression is representing. So, it makes sense for all of these to be arguments of an evaluation method. To address the problem of reading the dwarf_expr_context class internal data, we first need to understand why it is implemented that way? This is actualy a question of which existing class can be used to represent both values and a location descriptions and why it is not used currently? The answer is in a struct value class/structure, but the problem is that before the evaluators were merged, only one evaluator had an infrastructure to resolve composite and implicit pointer location descriptions. After the merge, we are now able to use the struct value to represent any result of the expression evaluation. It also makes sense to move all infrastructure for those location descriptions to the expr.c file considering that that is the only place using that infrastructure. What we are left with in the end is a clean public interface of the dwarf_expr_context class containing: - constructor, - destructor, - push_address method and - eval_exp method. The idea with this particular patch is to move piece_closure structure and the interface that handles it (lval_funcs) to expr.c file. While implicit pointer location descriptions are still not useful in the CFI context (of the AMD's DWARF standard extensions), the composite location descriptions are certainly necessary to describe a results of specific compiler optimizations. Considering that a piece_closure structure is used to represent both, there was no benefit in splitting them. gdb/ChangeLog: * dwarf2/expr.c (struct piece_closure): Add from loc.c. (allocate_piece_closure): Add from loc.c. (bits_to_bytes): Add from loc.c. (rw_pieced_value): Add from loc.c. (read_pieced_value): Add from loc.c. (write_pieced_value): Add from loc.c. (check_pieced_synthetic_pointer): Add from loc.c. (indirect_pieced_value): Add from loc.c. (coerce_pieced_ref): Add from loc.c. (copy_pieced_value_closure): Add from loc.c. (free_pieced_value_closure): Add from loc.c. (sect_variable_value): Add from loc.c. * dwarf2/loc.c (sect_variable_value): Move to expr.c. (struct piece_closure): Move to expr.c. (allocate_piece_closure): Move to expr.c. (bits_to_bytes): Move to expr.c. (rw_pieced_value): Move to expr.c. (read_pieced_value): Move to expr.c. (write_pieced_value): Move to expr.c. (check_pieced_synthetic_pointer): Move to expr.c. (indirect_pieced_value): Move to expr.c. (coerce_pieced_ref): Move to expr.c. (copy_pieced_value_closure): Move to expr.c. (free_pieced_value_closure): Move to expr.c. --- gdb/dwarf2/expr.c | 571 ++++++++++++++++++++++++++++++++++++++++++++ gdb/dwarf2/expr.h | 10 + gdb/dwarf2/loc.c | 597 +--------------------------------------------- gdb/dwarf2/loc.h | 16 +- 4 files changed, 595 insertions(+), 599 deletions(-) diff --git a/gdb/dwarf2/expr.c b/gdb/dwarf2/expr.c index f9ac77160f6..d0a74f1a586 100644 --- a/gdb/dwarf2/expr.c +++ b/gdb/dwarf2/expr.c @@ -78,6 +78,15 @@ ensure_have_per_cu (dwarf2_per_cu_data *per_cu, const char* op_name) _("%s evaluation requires a compilation unit."), op_name); } +/* Return the number of bytes overlapping a contiguous chunk of N_BITS + bits whose first bit is located at bit offset START. */ + +static size_t +bits_to_bytes (ULONGEST start, ULONGEST n_bits) +{ + return (start % HOST_CHAR_BIT + n_bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT; +} + /* See expr.h. */ CORE_ADDR @@ -89,6 +98,568 @@ read_addr_from_reg (frame_info *frame, int reg) return address_from_register (regnum, frame); } +struct piece_closure +{ + /* Reference count. */ + int refc = 0; + + /* The objfile from which this closure's expression came. */ + dwarf2_per_objfile *per_objfile = nullptr; + + /* The CU from which this closure's expression came. */ + dwarf2_per_cu_data *per_cu = nullptr; + + /* The pieces describing this variable. */ + std::vector pieces; + + /* Frame ID of frame to which a register value is relative, used + only by DWARF_VALUE_REGISTER. */ + struct frame_id frame_id; +}; + +/* See expr.h. */ + +piece_closure * +allocate_piece_closure (dwarf2_per_cu_data *per_cu, + dwarf2_per_objfile *per_objfile, + std::vector &&pieces, + frame_info *frame) +{ + piece_closure *c = new piece_closure; + + c->refc = 1; + /* We must capture this here due to sharing of DWARF state. */ + c->per_objfile = per_objfile; + c->per_cu = per_cu; + c->pieces = std::move (pieces); + if (frame == nullptr) + c->frame_id = null_frame_id; + else + c->frame_id = get_frame_id (frame); + + for (dwarf_expr_piece &piece : c->pieces) + if (piece.location == DWARF_VALUE_STACK) + value_incref (piece.v.value); + + return c; +} + +/* 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 +rw_pieced_value (value *v, value *from) +{ + int i; + LONGEST offset = 0, max_offset; + gdb_byte *v_contents; + const gdb_byte *from_contents; + piece_closure *c + = (piece_closure *) value_computed_closure (v); + gdb::byte_vector buffer; + bool bits_big_endian = type_byte_order (value_type (v)) == BFD_ENDIAN_BIG; + + if (from != nullptr) + { + from_contents = value_contents (from); + v_contents = nullptr; + } + else + { + 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 = nullptr; + } + + ULONGEST bits_to_skip = 8 * value_offset (v); + if (value_bitsize (v)) + { + bits_to_skip += (8 * value_offset (value_parent (v)) + + value_bitpos (v)); + if (from != nullptr + && (type_byte_order (value_type (from)) + == BFD_ENDIAN_BIG)) + { + /* Use the least significant bits of FROM. */ + max_offset = 8 * TYPE_LENGTH (value_type (from)); + offset = max_offset - value_bitsize (v); + } + else + max_offset = value_bitsize (v); + } + else + max_offset = 8 * TYPE_LENGTH (value_type (v)); + + /* Advance to the first non-skipped piece. */ + for (i = 0; i < c->pieces.size () && bits_to_skip >= c->pieces[i].size; i++) + bits_to_skip -= c->pieces[i].size; + + for (; i < c->pieces.size () && offset < max_offset; i++) + { + 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; + + switch (p->location) + { + case DWARF_VALUE_REGISTER: + { + frame_info *frame = frame_find_by_id (c->frame_id); + gdbarch *arch = get_frame_arch (frame); + int gdb_regnum = dwarf_reg_to_regnum_or_error (arch, p->v.regno); + ULONGEST reg_bits = 8 * register_size (arch, gdb_regnum); + int optim, unavail; + + if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG + && p->offset + p->size < reg_bits) + { + /* Big-endian, and we want less than full size. */ + bits_to_skip += reg_bits - (p->offset + p->size); + } + else + bits_to_skip += p->offset; + + this_size = bits_to_bytes (bits_to_skip, this_size_bits); + buffer.resize (this_size); + + if (from == nullptr) + { + /* Read mode. */ + if (!get_frame_register_bytes (frame, gdb_regnum, + bits_to_skip / 8, + buffer, &optim, &unavail)) + { + if (optim) + mark_value_bits_optimized_out (v, offset, + this_size_bits); + if (unavail) + mark_value_bits_unavailable (v, offset, + this_size_bits); + break; + } + + copy_bitwise (v_contents, offset, + buffer.data (), bits_to_skip % 8, + this_size_bits, bits_big_endian); + } + else + { + /* Write mode. */ + if (bits_to_skip % 8 != 0 || this_size_bits % 8 != 0) + { + /* Data is copied non-byte-aligned into the register. + Need some bits from original register value. */ + get_frame_register_bytes (frame, gdb_regnum, + bits_to_skip / 8, + buffer, &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, + buffer); + } + } + break; + + case DWARF_VALUE_MEMORY: + { + 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 != nullptr) + write_memory_with_notification (start_addr, + (from_contents + + offset / 8), + this_size_bits / 8); + else + read_value_memory (v, offset, + p->v.mem.in_stack_memory, + p->v.mem.addr + bits_to_skip / 8, + v_contents + offset / 8, + this_size_bits / 8); + break; + } + + this_size = bits_to_bytes (bits_to_skip, this_size_bits); + buffer.resize (this_size); + + if (from == nullptr) + { + /* 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 + { + /* 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; + + case DWARF_VALUE_STACK: + { + if (from != nullptr) + { + mark_value_bits_optimized_out (v, offset, this_size_bits); + break; + } + + gdbarch *objfile_gdbarch = c->per_objfile->objfile->arch (); + 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: + { + if (from != nullptr) + { + 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; + + case DWARF_VALUE_IMPLICIT_POINTER: + if (from != nullptr) + { + 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: + mark_value_bits_optimized_out (v, offset, this_size_bits); + break; + + default: + internal_error (__FILE__, __LINE__, _("invalid location type")); + } + + offset += this_size_bits; + bits_to_skip = 0; + } +} + +static void +read_pieced_value (value *v) +{ + rw_pieced_value (v, nullptr); +} + +static void +write_pieced_value (value *to, value *from) +{ + rw_pieced_value (to, from); +} + +/* An implementation of an lval_funcs method to see whether a value is + a synthetic pointer. */ + +static int +check_pieced_synthetic_pointer (const value *value, LONGEST bit_offset, + int bit_length) +{ + piece_closure *c = (piece_closure *) value_computed_closure (value); + int i; + + bit_offset += 8 * value_offset (value); + if (value_bitsize (value)) + bit_offset += value_bitpos (value); + + for (i = 0; i < c->pieces.size () && bit_length > 0; i++) + { + dwarf_expr_piece *p = &c->pieces[i]; + size_t this_size_bits = p->size; + + if (bit_offset > 0) + { + if (bit_offset >= this_size_bits) + { + bit_offset -= this_size_bits; + continue; + } + + bit_length -= this_size_bits - bit_offset; + bit_offset = 0; + } + else + bit_length -= this_size_bits; + + if (p->location != DWARF_VALUE_IMPLICIT_POINTER) + return 0; + } + + return 1; +} + +/* An implementation of an lval_funcs method to indirect through a + pointer. This handles the synthetic pointer case when needed. */ + +static value * +indirect_pieced_value (value *value) +{ + piece_closure *c + = (piece_closure *) value_computed_closure (value); + int i; + dwarf_expr_piece *piece = NULL; + + struct type *type = check_typedef (value_type (value)); + if (type->code () != TYPE_CODE_PTR) + return NULL; + + int bit_length = 8 * TYPE_LENGTH (type); + LONGEST bit_offset = 8 * value_offset (value); + if (value_bitsize (value)) + bit_offset += value_bitpos (value); + + for (i = 0; i < c->pieces.size () && bit_length > 0; i++) + { + dwarf_expr_piece *p = &c->pieces[i]; + size_t this_size_bits = p->size; + + if (bit_offset > 0) + { + if (bit_offset >= this_size_bits) + { + bit_offset -= this_size_bits; + continue; + } + + bit_length -= this_size_bits - bit_offset; + bit_offset = 0; + } + else + bit_length -= this_size_bits; + + if (p->location != DWARF_VALUE_IMPLICIT_POINTER) + return NULL; + + if (bit_length != 0) + error (_("Invalid use of DW_OP_implicit_pointer")); + + piece = p; + break; + } + + gdb_assert (piece != NULL && c->per_cu != nullptr); + frame_info *frame = get_selected_frame (_("No frame selected.")); + + /* 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. */ + bfd_endian byte_order = gdbarch_byte_order (get_frame_arch (frame)); + LONGEST 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, + c->per_objfile, frame, type); +} + +/* Implementation of the coerce_ref method of lval_funcs for synthetic C++ + references. */ + +static value * +coerce_pieced_ref (const 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 piece_closure *closure + = (piece_closure *) value_computed_closure (value); + 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, closure->per_objfile, frame, type); + } + else + { + /* Else: not a synthetic reference; do nothing. */ + return NULL; + } +} + +static void * +copy_pieced_value_closure (const value *v) +{ + piece_closure *c = (piece_closure *) value_computed_closure (v); + + ++c->refc; + return c; +} + +static void +free_pieced_value_closure (value *v) +{ + piece_closure *c = (piece_closure *) value_computed_closure (v); + + --c->refc; + if (c->refc == 0) + { + for (dwarf_expr_piece &p : c->pieces) + if (p.location == DWARF_VALUE_STACK) + value_decref (p.v.value); + + delete c; + } +} + +/* Functions for accessing a variable described by DW_OP_piece. */ +const struct lval_funcs pieced_value_funcs = { + read_pieced_value, + write_pieced_value, + indirect_pieced_value, + coerce_pieced_ref, + check_pieced_synthetic_pointer, + copy_pieced_value_closure, + free_pieced_value_closure +}; + +/* 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 value * +sect_variable_value (sect_offset sect_off, + dwarf2_per_cu_data *per_cu, + dwarf2_per_objfile *per_objfile) +{ + const char *var_name = nullptr; + struct type *die_type + = dwarf2_fetch_die_type_sect_off (sect_off, per_cu, per_objfile, + &var_name); + + 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 (die_type->code () != TYPE_CODE_INT + && die_type->code () != TYPE_CODE_ENUM + && die_type->code () != TYPE_CODE_RANGE + && die_type->code () != TYPE_CODE_PTR) + error (_("Type of DW_OP_GNU_variable_value DIE must be an integer or pointer.")); + + if (var_name != nullptr) + { + value *result = compute_var_value (var_name); + if (result != nullptr) + return result; + } + + struct type *type = lookup_pointer_type (die_type); + frame_info *frame = get_selected_frame (_("No frame selected.")); + return indirect_synthetic_pointer (sect_off, 0, per_cu, per_objfile, frame, + type, true); +} + /* Return the type used for DWARF operations where the type is unspecified in the DWARF spec. Only certain sizes are supported. */ diff --git a/gdb/dwarf2/expr.h b/gdb/dwarf2/expr.h index 76c073cf38f..c9ba2a6325d 100644 --- a/gdb/dwarf2/expr.h +++ b/gdb/dwarf2/expr.h @@ -26,6 +26,7 @@ #include "gdbtypes.h" struct dwarf2_per_objfile; +struct piece_closure; /* The location of a value. */ enum dwarf_value_location @@ -300,4 +301,13 @@ extern const gdb_byte *safe_read_sleb128 (const gdb_byte *buf, extern const gdb_byte *safe_skip_leb128 (const gdb_byte *buf, const gdb_byte *buf_end); +extern const struct lval_funcs pieced_value_funcs; + +/* Allocate a closure for a value formed from separately-described + PIECES. */ + +piece_closure *allocate_piece_closure + (dwarf2_per_cu_data *per_cu, dwarf2_per_objfile *per_objfile, + std::vector &&pieces, frame_info *frame); + #endif /* dwarf2expr.h */ diff --git a/gdb/dwarf2/loc.c b/gdb/dwarf2/loc.c index 6b9fc19ec05..4e1316dcbd4 100644 --- a/gdb/dwarf2/loc.c +++ b/gdb/dwarf2/loc.c @@ -52,13 +52,6 @@ static struct value *dwarf2_evaluate_loc_desc_full size_t size, dwarf2_per_cu_data *per_cu, dwarf2_per_objfile *per_objfile, struct type *subobj_type, LONGEST subobj_byte_offset); -static struct value *indirect_synthetic_pointer - (sect_offset die, LONGEST byte_offset, - dwarf2_per_cu_data *per_cu, - dwarf2_per_objfile *per_objfile, - 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, @@ -611,10 +604,9 @@ func_get_frame_base_dwarf_block (struct symbol *framefunc, CORE_ADDR pc, framefunc->natural_name ()); } -/* A helper function to find the definition of NAME and compute its - value. Returns nullptr if the name is not found. */ +/* See loc.h. */ -static value * +value * compute_var_value (const char *name) { struct block_symbol sym = lookup_symbol (name, nullptr, VAR_DOMAIN, @@ -624,42 +616,6 @@ compute_var_value (const char *name) return nullptr; } -/* See loc.h. */ - -struct value * -sect_variable_value (sect_offset sect_off, - dwarf2_per_cu_data *per_cu, - dwarf2_per_objfile *per_objfile) -{ - const char *var_name = nullptr; - struct type *die_type - = dwarf2_fetch_die_type_sect_off (sect_off, per_cu, per_objfile, - &var_name); - - 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 (die_type->code () != TYPE_CODE_INT - && die_type->code () != TYPE_CODE_ENUM - && die_type->code () != TYPE_CODE_RANGE - && die_type->code () != TYPE_CODE_PTR) - error (_("Type of DW_OP_GNU_variable_value DIE must be an integer or pointer.")); - - if (var_name != nullptr) - { - value *result = compute_var_value (var_name); - if (result != nullptr) - return result; - } - - 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, per_objfile, frame, - type, true); -} - /* See dwarf2loc.h. */ unsigned int entry_values_debug = 0; @@ -1419,403 +1375,6 @@ value_of_dwarf_block_entry (struct type *type, struct frame_info *frame, "only for single DW_OP_reg* or for DW_OP_fbreg(*)")); } -struct piece_closure -{ - /* Reference count. */ - int refc = 0; - - /* The objfile from which this closure's expression came. */ - dwarf2_per_objfile *per_objfile = nullptr; - - /* The CU from which this closure's expression came. */ - struct dwarf2_per_cu_data *per_cu = NULL; - - /* The pieces describing this variable. */ - std::vector pieces; - - /* Frame ID of frame to which a register value is relative, used - only by DWARF_VALUE_REGISTER. */ - struct frame_id frame_id; -}; - -/* Allocate a closure for a value formed from separately-described - PIECES. */ - -static struct piece_closure * -allocate_piece_closure (dwarf2_per_cu_data *per_cu, - dwarf2_per_objfile *per_objfile, - std::vector &&pieces, - struct frame_info *frame) -{ - struct piece_closure *c = new piece_closure; - - c->refc = 1; - /* We must capture this here due to sharing of DWARF state. */ - c->per_objfile = per_objfile; - 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); - - for (dwarf_expr_piece &piece : c->pieces) - if (piece.location == DWARF_VALUE_STACK) - value_incref (piece.v.value); - - return c; -} - -/* Return the number of bytes overlapping a contiguous chunk of N_BITS - bits whose first bit is located at bit offset START. */ - -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 -rw_pieced_value (struct value *v, struct value *from) -{ - int i; - LONGEST offset = 0, max_offset; - ULONGEST bits_to_skip; - gdb_byte *v_contents; - const gdb_byte *from_contents; - struct piece_closure *c - = (struct piece_closure *) value_computed_closure (v); - gdb::byte_vector buffer; - bool bits_big_endian = type_byte_order (value_type (v)) == BFD_ENDIAN_BIG; - - if (from != NULL) - { - from_contents = value_contents (from); - v_contents = NULL; - } - else - { - 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; - } - - bits_to_skip = 8 * value_offset (v); - if (value_bitsize (v)) - { - bits_to_skip += (8 * value_offset (value_parent (v)) - + value_bitpos (v)); - if (from != NULL - && (type_byte_order (value_type (from)) - == BFD_ENDIAN_BIG)) - { - /* Use the least significant bits of FROM. */ - max_offset = 8 * TYPE_LENGTH (value_type (from)); - offset = max_offset - value_bitsize (v); - } - else - max_offset = value_bitsize (v); - } - else - max_offset = 8 * TYPE_LENGTH (value_type (v)); - - /* Advance to the first non-skipped piece. */ - for (i = 0; i < c->pieces.size () && bits_to_skip >= c->pieces[i].size; i++) - bits_to_skip -= c->pieces[i].size; - - for (; i < 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; - - switch (p->location) - { - case DWARF_VALUE_REGISTER: - { - struct frame_info *frame = frame_find_by_id (c->frame_id); - struct gdbarch *arch = get_frame_arch (frame); - int gdb_regnum = dwarf_reg_to_regnum_or_error (arch, p->v.regno); - ULONGEST reg_bits = 8 * register_size (arch, gdb_regnum); - int optim, unavail; - - if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG - && p->offset + p->size < reg_bits) - { - /* Big-endian, and we want less than full size. */ - bits_to_skip += reg_bits - (p->offset + p->size); - } - else - bits_to_skip += p->offset; - - this_size = bits_to_bytes (bits_to_skip, this_size_bits); - buffer.resize (this_size); - - if (from == NULL) - { - /* Read mode. */ - if (!get_frame_register_bytes (frame, gdb_regnum, - bits_to_skip / 8, - buffer, - &optim, &unavail)) - { - if (optim) - mark_value_bits_optimized_out (v, offset, - this_size_bits); - if (unavail) - mark_value_bits_unavailable (v, offset, - this_size_bits); - break; - } - - copy_bitwise (v_contents, offset, - buffer.data (), bits_to_skip % 8, - this_size_bits, bits_big_endian); - } - else - { - /* Write mode. */ - if (bits_to_skip % 8 != 0 || this_size_bits % 8 != 0) - { - /* Data is copied non-byte-aligned into the register. - Need some bits from original register value. */ - get_frame_register_bytes (frame, gdb_regnum, - bits_to_skip / 8, - buffer, - &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, - buffer); - } - } - break; - - case DWARF_VALUE_MEMORY: - { - 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 (from == NULL) - { - /* 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 - { - /* 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; - - case DWARF_VALUE_STACK: - { - if (from != NULL) - { - mark_value_bits_optimized_out (v, offset, this_size_bits); - break; - } - - gdbarch *objfile_gdbarch = c->per_objfile->objfile->arch (); - 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: - { - 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; - - 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: - mark_value_bits_optimized_out (v, offset, this_size_bits); - break; - - default: - internal_error (__FILE__, __LINE__, _("invalid location type")); - } - - offset += this_size_bits; - bits_to_skip = 0; - } -} - - -static void -read_pieced_value (struct value *v) -{ - rw_pieced_value (v, NULL); -} - -static void -write_pieced_value (struct value *to, struct value *from) -{ - rw_pieced_value (to, from); -} - -/* An implementation of an lval_funcs method to see whether a value is - a synthetic pointer. */ - -static int -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; - - bit_offset += 8 * value_offset (value); - if (value_bitsize (value)) - bit_offset += value_bitpos (value); - - 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; - - if (bit_offset > 0) - { - if (bit_offset >= this_size_bits) - { - bit_offset -= this_size_bits; - continue; - } - - bit_length -= this_size_bits - bit_offset; - bit_offset = 0; - } - else - bit_length -= this_size_bits; - - if (p->location != DWARF_VALUE_IMPLICIT_POINTER) - return 0; - } - - return 1; -} - /* Fetch a DW_AT_const_value through a synthetic pointer. */ static struct value * @@ -1849,9 +1408,9 @@ fetch_const_value_from_synthetic_pointer (sect_offset die, LONGEST byte_offset, return result; } -/* Fetch the value pointed to by a synthetic pointer. */ +/* See loc.h. */ -static struct value * +struct value * indirect_synthetic_pointer (sect_offset die, LONGEST byte_offset, dwarf2_per_cu_data *per_cu, dwarf2_per_objfile *per_objfile, @@ -1888,154 +1447,6 @@ indirect_synthetic_pointer (sect_offset die, LONGEST byte_offset, per_objfile, type); } -/* An implementation of an lval_funcs method to indirect through a - pointer. This handles the synthetic pointer case when needed. */ - -static struct value * -indirect_pieced_value (struct value *value) -{ - struct piece_closure *c - = (struct piece_closure *) value_computed_closure (value); - struct type *type; - struct frame_info *frame; - int i, bit_length; - LONGEST bit_offset; - struct dwarf_expr_piece *piece = NULL; - LONGEST byte_offset; - enum bfd_endian byte_order; - - type = check_typedef (value_type (value)); - if (type->code () != TYPE_CODE_PTR) - return NULL; - - bit_length = 8 * TYPE_LENGTH (type); - bit_offset = 8 * value_offset (value); - if (value_bitsize (value)) - bit_offset += value_bitpos (value); - - 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; - - if (bit_offset > 0) - { - if (bit_offset >= this_size_bits) - { - bit_offset -= this_size_bits; - continue; - } - - bit_length -= this_size_bits - bit_offset; - bit_offset = 0; - } - else - bit_length -= this_size_bits; - - if (p->location != DWARF_VALUE_IMPLICIT_POINTER) - return NULL; - - if (bit_length != 0) - error (_("Invalid use of DW_OP_implicit_pointer")); - - piece = p; - break; - } - - gdb_assert (piece != NULL); - frame = get_selected_frame (_("No frame selected.")); - - /* 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, - c->per_objfile, frame, type); -} - -/* Implementation of the coerce_ref method of lval_funcs for synthetic C++ - references. */ - -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, closure->per_objfile, frame, type); - } - else - { - /* Else: not a synthetic reference; do nothing. */ - return NULL; - } -} - -static void * -copy_pieced_value_closure (const struct value *v) -{ - struct piece_closure *c - = (struct piece_closure *) value_computed_closure (v); - - ++c->refc; - return c; -} - -static void -free_pieced_value_closure (struct value *v) -{ - struct piece_closure *c - = (struct piece_closure *) value_computed_closure (v); - - --c->refc; - if (c->refc == 0) - { - for (dwarf_expr_piece &p : c->pieces) - if (p.location == DWARF_VALUE_STACK) - value_decref (p.v.value); - - delete c; - } -} - -/* Functions for accessing a variable described by DW_OP_piece. */ -static const struct lval_funcs pieced_value_funcs = { - read_pieced_value, - write_pieced_value, - 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. If SUBOBJ_TYPE is non-NULL, return instead the diff --git a/gdb/dwarf2/loc.h b/gdb/dwarf2/loc.h index f4dc3d7fed3..33a5e8adc10 100644 --- a/gdb/dwarf2/loc.h +++ b/gdb/dwarf2/loc.h @@ -53,13 +53,10 @@ extern void func_get_frame_base_dwarf_block (struct symbol *framefunc, const gdb_byte **start, size_t *length); -/* Given section offset SECT_OFF, and compilation unit data - PER_CU, execute the "variable value" operation on the DIE - found at SECT_OFF. */ +/* A helper function to find the definition of NAME and compute its + value. Returns nullptr if the name is not found. */ -struct value *sect_variable_value (sect_offset sect_off, - dwarf2_per_cu_data *per_cu, - dwarf2_per_objfile *per_objfile); +value *compute_var_value (const char *name); /* Fetch call_site_parameter from caller matching KIND and KIND_U. FRAME is for callee. @@ -283,4 +280,11 @@ extern int dwarf_reg_to_regnum (struct gdbarch *arch, int dwarf_reg); extern int dwarf_reg_to_regnum_or_error (struct gdbarch *arch, ULONGEST dwarf_reg); +/* Fetch the value pointed to by a synthetic pointer. */ + +extern struct value *indirect_synthetic_pointer + (sect_offset die, LONGEST byte_offset, dwarf2_per_cu_data *per_cu, + dwarf2_per_objfile *per_objfile, struct frame_info *frame, + struct type *type, bool resolve_abstract_p = false); + #endif /* dwarf2loc.h */ -- 2.30.2