From: Zoran Zaric Date: Thu, 17 Sep 2020 09:28:20 +0000 (+0100) Subject: Simplify dwarf_expr_context class interface X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=0579205aec4369375dccb8566ba37eefee2be912;p=binutils-gdb.git Simplify dwarf_expr_context class interface Idea of this patch is to get a clean and simple public interface for the dwarf_expr_context class, looking like: - constructor, - destructor, - push_address method and - evaluate method. Where constructor should only ever require a target architecture information. This information is held in per object file (dwarf2_per_objfile) structure, so it makes sense to keep that structure as a constructor argument. It also makes sense to get the address size from that structure, but unfortunately that interface doesn't exist at the moment, so the dwarf_expr_context class user needs to provide that information. The push_address method is used to push a CORE_ADDR as a value on top of the DWARF stack before the evaluation. This method can be later changed to push any struct value object on the stack. The evaluate method is the method that evaluates a DWARF expression and provides the evaluation result, in a form of a single struct value object that describes a location. To do this, the method requires a context of the evaluation, as well as expected result type information. If the type information is not provided, the DWARF generic type will be used instead. To avoid storing the gdbarch information in the evaluator object, that information is now always acquired from the per_objfile object. All data members are now private and only visible to the evaluator class, so a m_ prefix was added to all of their names to reflect that. To make this distinction clear, they are also accessed through objects this pointer, wherever that was not the case before. gdb/ChangeLog: * dwarf2/expr.c (dwarf_expr_context::dwarf_expr_context): Add address size argument. (dwarf_expr_context::read_mem): Change to use property_addr_info structure. (dwarf_expr_context::evaluate): New function. (dwarf_expr_context::execute_stack_op): Change to use property_addr_info structure. * dwarf2/expr.h (struct dwarf_expr_context): New evaluate declaration. Change eval and fetch_result method to private. (dwarf_expr_context::gdbarch): Remove member. (dwarf_expr_context::stack): Make private and add m_ prefix. (dwarf_expr_context::addr_size): Make private and add m_ prefix. (dwarf_expr_context::recursion_depth): Make private and add m_ prefix. (dwarf_expr_context::max_recursion_depth): Make private and add m_ prefix. (dwarf_expr_context::len): Make private and add m_ prefix. (dwarf_expr_context::data): Make private and add m_ prefix. (dwarf_expr_context::initialized): Make private and add m_ prefix. (dwarf_expr_context::pieces): Make private and add m_ prefix. (dwarf_expr_context::per_objfile): Make private and add m_ prefix. (dwarf_expr_context::frame): Make private and add m_ prefix. (dwarf_expr_context::per_cu): Make private and add m_ prefix. (dwarf_expr_context::addr_info): Make private and add m_ prefix. * dwarf2/frame.c (execute_stack_op): Change to call evaluate method. * dwarf2/loc.c (dwarf2_evaluate_loc_desc_full): Change to call evaluate method. (dwarf2_locexpr_baton_eval): Change to call evaluate method. --- diff --git a/gdb/dwarf2/expr.c b/gdb/dwarf2/expr.c index 5b4b734ccd2..1e67ffaf248 100644 --- a/gdb/dwarf2/expr.c +++ b/gdb/dwarf2/expr.c @@ -668,25 +668,24 @@ sect_variable_value (sect_offset sect_off, struct type * dwarf_expr_context::address_type () const { - struct dwarf_gdbarch_types *types - = (struct dwarf_gdbarch_types *) gdbarch_data (this->gdbarch, - dwarf_arch_cookie); + gdbarch *arch = this->m_per_objfile->objfile->arch (); + dwarf_gdbarch_types *types + = (dwarf_gdbarch_types *) gdbarch_data (arch, dwarf_arch_cookie); int ndx; - if (this->addr_size == 2) + if (this->m_addr_size == 2) ndx = 0; - else if (this->addr_size == 4) + else if (this->m_addr_size == 4) ndx = 1; - else if (this->addr_size == 8) + else if (this->m_addr_size == 8) ndx = 2; else error (_("Unsupported address size in DWARF expressions: %d bits"), - 8 * this->addr_size); + 8 * this->m_addr_size); if (types->dw_types[ndx] == NULL) types->dw_types[ndx] - = arch_integer_type (this->gdbarch, - 8 * this->addr_size, + = arch_integer_type (arch, 8 * this->m_addr_size, 0, ""); return types->dw_types[ndx]; @@ -694,8 +693,10 @@ dwarf_expr_context::address_type () const /* Create a new context for the expression evaluator. */ -dwarf_expr_context::dwarf_expr_context (dwarf2_per_objfile *per_objfile) -: per_objfile (per_objfile) +dwarf_expr_context::dwarf_expr_context (dwarf2_per_objfile *per_objfile, + int addr_size) +: m_addr_size (addr_size), + m_per_objfile (per_objfile) { } @@ -704,7 +705,7 @@ dwarf_expr_context::dwarf_expr_context (dwarf2_per_objfile *per_objfile) void dwarf_expr_context::push (struct value *value, bool in_stack_memory) { - stack.emplace_back (value, in_stack_memory); + this->m_stack.emplace_back (value, in_stack_memory); } /* Push VALUE onto the stack. */ @@ -720,10 +721,10 @@ dwarf_expr_context::push_address (CORE_ADDR value, bool in_stack_memory) void dwarf_expr_context::pop () { - if (stack.empty ()) + if (this->m_stack.empty ()) error (_("dwarf expression stack underflow")); - stack.pop_back (); + this->m_stack.pop_back (); } /* Retrieve the N'th item on the stack. */ @@ -731,11 +732,11 @@ dwarf_expr_context::pop () struct value * dwarf_expr_context::fetch (int n) { - if (stack.size () <= n) + if (this->m_stack.size () <= n) error (_("Asked for position %d of stack, " "stack only has %zu elements on it."), - n, stack.size ()); - return stack[stack.size () - (1 + n)].value; + n, this->m_stack.size ()); + return this->m_stack[this->m_stack.size () - (1 + n)].value; } /* See expr.h. */ @@ -744,9 +745,9 @@ void dwarf_expr_context::get_frame_base (const gdb_byte **start, size_t * length) { - ensure_have_frame (this->frame, "DW_OP_fbreg"); + ensure_have_frame (this->m_frame, "DW_OP_fbreg"); - const block *bl = get_frame_block (this->frame, NULL); + const block *bl = get_frame_block (this->m_frame, NULL); if (bl == NULL) error (_("frame address is not available.")); @@ -762,7 +763,7 @@ dwarf_expr_context::get_frame_base (const gdb_byte **start, gdb_assert (framefunc != NULL); func_get_frame_base_dwarf_block (framefunc, - get_frame_address_in_block (this->frame), + get_frame_address_in_block (this->m_frame), start, length); } @@ -771,11 +772,11 @@ dwarf_expr_context::get_frame_base (const gdb_byte **start, struct type * dwarf_expr_context::get_base_type (cu_offset die_cu_off) { - if (per_cu == nullptr) - return builtin_type (this->gdbarch)->builtin_int; + if (this->m_per_cu == nullptr) + return builtin_type (this->m_per_objfile->objfile->arch ())->builtin_int; - struct type *result = dwarf2_get_die_type (die_cu_off, this->per_cu, - this->per_objfile); + struct type *result = dwarf2_get_die_type (die_cu_off, this->m_per_cu, + this->m_per_objfile); if (result == nullptr) error (_("Could not find type for operation")); @@ -788,9 +789,9 @@ dwarf_expr_context::get_base_type (cu_offset die_cu_off) void dwarf_expr_context::dwarf_call (cu_offset die_cu_off) { - ensure_have_per_cu (this->per_cu, "DW_OP_call"); + ensure_have_per_cu (this->m_per_cu, "DW_OP_call"); - frame_info *frame = this->frame; + frame_info *frame = this->m_frame; auto get_pc_from_frame = [frame] () { @@ -799,11 +800,11 @@ dwarf_expr_context::dwarf_call (cu_offset die_cu_off) }; dwarf2_locexpr_baton block - = dwarf2_fetch_die_loc_cu_off (die_cu_off, this->per_cu, this->per_objfile, - get_pc_from_frame); + = dwarf2_fetch_die_loc_cu_off (die_cu_off, this->m_per_cu, + this->m_per_objfile, get_pc_from_frame); /* DW_OP_call_ref is currently not supported. */ - gdb_assert (block.per_cu == this->per_cu); + gdb_assert (block.per_cu == this->m_per_cu); this->eval (block.data, block.size); } @@ -818,13 +819,16 @@ dwarf_expr_context::read_mem (gdb_byte *buf, CORE_ADDR addr, return; /* Prefer the passed-in memory, if it exists. */ - CORE_ADDR offset = addr - this->obj_address; - - if (offset < this->data_view.size () - && offset + length <= this->data_view.size ()) + if (this->m_addr_info != nullptr) { - memcpy (buf, this->data_view.data (), length); - return; + CORE_ADDR offset = addr - this->m_addr_info->addr; + + if (offset < this->m_addr_info->valaddr.size () + && offset + length <= this->m_addr_info->valaddr.size ()) + { + memcpy (buf, this->m_addr_info->valaddr.data (), length); + return; + } } read_memory (addr, buf, length); @@ -837,14 +841,14 @@ dwarf_expr_context::push_dwarf_reg_entry_value (call_site_parameter_kind kind, call_site_parameter_u kind_u, int deref_size) { - ensure_have_per_cu (this->per_cu, "DW_OP_entry_value"); - ensure_have_frame (this->frame, "DW_OP_entry_value"); + ensure_have_per_cu (this->m_per_cu, "DW_OP_entry_value"); + ensure_have_frame (this->m_frame, "DW_OP_entry_value"); dwarf2_per_cu_data *caller_per_cu; dwarf2_per_objfile *caller_per_objfile; - frame_info *caller_frame = get_prev_frame (this->frame); + frame_info *caller_frame = get_prev_frame (this->m_frame); call_site_parameter *parameter - = dwarf_expr_reg_to_entry_parameter (this->frame, kind, kind_u, + = dwarf_expr_reg_to_entry_parameter (this->m_frame, kind, kind_u, &caller_per_cu, &caller_per_objfile); const gdb_byte *data_src @@ -863,19 +867,17 @@ dwarf_expr_context::push_dwarf_reg_entry_value (call_site_parameter_kind kind, It is possible for the caller to be from a different objfile from the callee if the call is made through a function pointer. */ - scoped_restore save_frame = make_scoped_restore (&this->frame, + scoped_restore save_frame = make_scoped_restore (&this->m_frame, caller_frame); - scoped_restore save_per_cu = make_scoped_restore (&this->per_cu, + scoped_restore save_per_cu = make_scoped_restore (&this->m_per_cu, caller_per_cu); - scoped_restore save_obj_addr = make_scoped_restore (&this->obj_address, - (CORE_ADDR) 0); - scoped_restore save_per_objfile = make_scoped_restore (&this->per_objfile, + scoped_restore save_addr_info = make_scoped_restore (&this->m_addr_info, + nullptr); + scoped_restore save_per_objfile = make_scoped_restore (&this->m_per_objfile, caller_per_objfile); - scoped_restore save_arch = make_scoped_restore (&this->gdbarch); - this->gdbarch = this->per_objfile->objfile->arch (); - scoped_restore save_addr_size = make_scoped_restore (&this->addr_size); - this->addr_size = this->per_cu->addr_size (); + scoped_restore save_addr_size = make_scoped_restore (&this->m_addr_size); + this->m_addr_size = this->m_per_cu->addr_size (); this->eval (data_src, size); } @@ -887,6 +889,7 @@ dwarf_expr_context::fetch_result (struct type *type, struct type *subobj_type, LONGEST subobj_offset) { value *retval = nullptr; + gdbarch *arch = this->m_per_objfile->objfile->arch (); if (type == nullptr) type = address_type (); @@ -894,11 +897,11 @@ dwarf_expr_context::fetch_result (struct type *type, struct type *subobj_type, if (subobj_type == nullptr) subobj_type = type; - if (this->pieces.size () > 0) + if (this->m_pieces.size () > 0) { ULONGEST bit_size = 0; - for (dwarf_expr_piece &piece : this->pieces) + for (dwarf_expr_piece &piece : this->m_pieces) bit_size += piece.size; /* Complain if the expression is larger than the size of the outer type. */ @@ -906,30 +909,29 @@ dwarf_expr_context::fetch_result (struct type *type, struct type *subobj_type, invalid_synthetic_pointer (); piece_closure *c - = allocate_piece_closure (this->per_cu, this->per_objfile, - std::move (this->pieces), this->frame); + = allocate_piece_closure (this->m_per_cu, this->m_per_objfile, + std::move (this->m_pieces), this->m_frame); retval = allocate_computed_value (subobj_type, &pieced_value_funcs, c); set_value_offset (retval, subobj_offset); } else { - switch (this->location) + switch (this->m_location) { case DWARF_VALUE_REGISTER: { int dwarf_regnum = longest_to_int (value_as_long (this->fetch (0))); - int gdb_regnum = dwarf_reg_to_regnum_or_error (this->gdbarch, - dwarf_regnum); + int gdb_regnum = dwarf_reg_to_regnum_or_error (arch, dwarf_regnum); if (subobj_offset != 0) error (_("cannot use offset on synthetic pointer to register")); - gdb_assert (this->frame != NULL); + gdb_assert (this->m_frame != NULL); retval = value_from_register (subobj_type, gdb_regnum, - this->frame); + this->m_frame); if (value_optimized_out (retval)) { /* This means the register has undefined value / was @@ -964,10 +966,10 @@ dwarf_expr_context::fetch_result (struct type *type, struct type *subobj_type, { case TYPE_CODE_FUNC: case TYPE_CODE_METHOD: - ptr_type = builtin_type (this->gdbarch)->builtin_func_ptr; + ptr_type = builtin_type (arch)->builtin_func_ptr; break; default: - ptr_type = builtin_type (this->gdbarch)->builtin_data_ptr; + ptr_type = builtin_type (arch)->builtin_data_ptr; break; } address = value_as_address (value_from_pointer (ptr_type, address)); @@ -992,7 +994,7 @@ dwarf_expr_context::fetch_result (struct type *type, struct type *subobj_type, retval = allocate_value (subobj_type); /* The given offset is relative to the actual object. */ - if (gdbarch_byte_order (this->gdbarch) == BFD_ENDIAN_BIG) + if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG) subobj_offset += n - max; memcpy (value_contents_raw (retval), @@ -1004,12 +1006,12 @@ dwarf_expr_context::fetch_result (struct type *type, struct type *subobj_type, { size_t n = TYPE_LENGTH (subobj_type); - if (subobj_offset + n > this->len) + if (subobj_offset + n > this->m_len) invalid_synthetic_pointer (); retval = allocate_value (subobj_type); bfd_byte *contents = value_contents_raw (retval); - memcpy (contents, this->data + subobj_offset, n); + memcpy (contents, this->m_data + subobj_offset, n); } break; @@ -1027,11 +1029,28 @@ dwarf_expr_context::fetch_result (struct type *type, struct type *subobj_type, } } - set_value_initialized (retval, this->initialized); + set_value_initialized (retval, this->m_initialized); return retval; } +/* See expr.h. */ + +value * +dwarf_expr_context::evaluate (const gdb_byte *addr, size_t len, + dwarf2_per_cu_data *per_cu, frame_info *frame, + const struct property_addr_info *addr_info, + struct type *type, struct type *subobj_type, + LONGEST subobj_offset) +{ + this->m_per_cu = per_cu; + this->m_frame = frame; + this->m_addr_info = addr_info; + + eval (addr, len); + return fetch_result (type, subobj_type, subobj_offset); +} + /* Require that TYPE be an integral type; throw an exception if not. */ static void @@ -1092,8 +1111,9 @@ get_signed_type (struct gdbarch *gdbarch, struct type *type) CORE_ADDR dwarf_expr_context::fetch_address (int n) { - struct value *result_val = fetch (n); - enum bfd_endian byte_order = gdbarch_byte_order (this->gdbarch); + gdbarch *arch = this->m_per_objfile->objfile->arch (); + value *result_val = fetch (n); + bfd_endian byte_order = gdbarch_byte_order (arch); ULONGEST result; dwarf_require_integral (value_type (result_val)); @@ -1107,14 +1127,14 @@ dwarf_expr_context::fetch_address (int n) extract_unsigned_integer() will not produce a correct result. Make sure we invoke gdbarch_integer_to_address() for those architectures which require it. */ - if (gdbarch_integer_to_address_p (this->gdbarch)) + if (gdbarch_integer_to_address_p (arch)) { - gdb_byte *buf = (gdb_byte *) alloca (this->addr_size); - struct type *int_type = get_unsigned_type (this->gdbarch, - value_type (result_val)); + gdb_byte *buf = (gdb_byte *) alloca (this->m_addr_size); + type *int_type = get_unsigned_type (arch, + value_type (result_val)); - store_unsigned_integer (buf, this->addr_size, byte_order, result); - return gdbarch_integer_to_address (this->gdbarch, int_type, buf); + store_unsigned_integer (buf, this->m_addr_size, byte_order, result); + return gdbarch_integer_to_address (arch, int_type, buf); } return (CORE_ADDR) result; @@ -1125,11 +1145,11 @@ dwarf_expr_context::fetch_address (int n) bool dwarf_expr_context::fetch_in_stack_memory (int n) { - if (stack.size () <= n) + if (this->m_stack.size () <= n) error (_("Asked for position %d of stack, " "stack only has %zu elements on it."), - n, stack.size ()); - return stack[stack.size () - (1 + n)].in_stack_memory; + n, this->m_stack.size ()); + return this->m_stack[this->m_stack.size () - (1 + n)].in_stack_memory; } /* Return true if the expression stack is empty. */ @@ -1137,24 +1157,24 @@ dwarf_expr_context::fetch_in_stack_memory (int n) bool dwarf_expr_context::stack_empty_p () const { - return stack.empty (); + return m_stack.empty (); } /* Add a new piece to the dwarf_expr_context's piece list. */ void dwarf_expr_context::add_piece (ULONGEST size, ULONGEST offset) { - this->pieces.emplace_back (); - dwarf_expr_piece &p = this->pieces.back (); + this->m_pieces.emplace_back (); + dwarf_expr_piece &p = this->m_pieces.back (); - p.location = this->location; + p.location = this->m_location; p.size = size; p.offset = offset; if (p.location == DWARF_VALUE_LITERAL) { - p.v.literal.data = this->data; - p.v.literal.length = this->len; + p.v.literal.data = this->m_data; + p.v.literal.length = this->m_len; } else if (stack_empty_p ()) { @@ -1163,7 +1183,7 @@ dwarf_expr_context::add_piece (ULONGEST size, ULONGEST offset) a somewhat strange approach, but this lets us avoid setting the location to DWARF_VALUE_MEMORY in all the individual cases in the evaluator. */ - this->location = DWARF_VALUE_OPTIMIZED_OUT; + this->m_location = DWARF_VALUE_OPTIMIZED_OUT; } else if (p.location == DWARF_VALUE_MEMORY) { @@ -1172,7 +1192,7 @@ dwarf_expr_context::add_piece (ULONGEST size, ULONGEST offset) } else if (p.location == DWARF_VALUE_IMPLICIT_POINTER) { - p.v.ptr.die_sect_off = (sect_offset) this->len; + p.v.ptr.die_sect_off = (sect_offset) this->m_len; p.v.ptr.offset = value_as_long (fetch (0)); } else if (p.location == DWARF_VALUE_REGISTER) @@ -1188,13 +1208,13 @@ dwarf_expr_context::add_piece (ULONGEST size, ULONGEST offset) void dwarf_expr_context::eval (const gdb_byte *addr, size_t len) { - int old_recursion_depth = this->recursion_depth; + int old_recursion_depth = this->m_recursion_depth; execute_stack_op (addr, addr + len); /* RECURSION_DEPTH becomes invalid if an exception was thrown here. */ - gdb_assert (this->recursion_depth == old_recursion_depth); + gdb_assert (this->m_recursion_depth == old_recursion_depth); } /* Helper to read a uleb128 value or throw an error. */ @@ -1438,7 +1458,8 @@ void dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, const gdb_byte *op_end) { - enum bfd_endian byte_order = gdbarch_byte_order (this->gdbarch); + gdbarch *arch = this->m_per_objfile->objfile->arch (); + bfd_endian byte_order = gdbarch_byte_order (arch); /* Old-style "untyped" DWARF values need special treatment in a couple of places, specifically DW_OP_mod and DW_OP_shr. We need a special type for these values so we can distinguish them from @@ -1446,19 +1467,19 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, values do not need special treatment. This special type must be different (in the `==' sense) from any base type coming from the CU. */ - struct type *address_type = this->address_type (); + type *address_type = this->address_type (); - this->location = DWARF_VALUE_MEMORY; - this->initialized = 1; /* Default is initialized. */ + this->m_location = DWARF_VALUE_MEMORY; + this->m_initialized = 1; /* Default is initialized. */ - if (this->recursion_depth > this->max_recursion_depth) + if (this->m_recursion_depth > this->m_max_recursion_depth) error (_("DWARF-2 expression error: Loop detected (%d)."), - this->recursion_depth); - this->recursion_depth++; + this->m_recursion_depth); + this->m_recursion_depth++; while (op_ptr < op_end) { - enum dwarf_location_atom op = (enum dwarf_location_atom) *op_ptr++; + dwarf_location_atom op = (dwarf_location_atom) *op_ptr++; ULONGEST result; /* Assume the value is not in stack memory. Code that knows otherwise sets this to true. @@ -1469,7 +1490,7 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, bool in_stack_memory = false; uint64_t uoffset, reg; int64_t offset; - struct value *result_val = NULL; + value *result_val = NULL; /* The DWARF expression might have a bug causing an infinite loop. In that case, quitting is the only way out. */ @@ -1515,32 +1536,32 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, case DW_OP_addr: result = extract_unsigned_integer (op_ptr, - this->addr_size, byte_order); - op_ptr += this->addr_size; + this->m_addr_size, byte_order); + op_ptr += this->m_addr_size; /* Some versions of GCC emit DW_OP_addr before DW_OP_GNU_push_tls_address. In this case the value is an index, not an address. We don't support things like branching between the address and the TLS op. */ if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address) - result += this->per_objfile->objfile->text_section_offset (); + result += this->m_per_objfile->objfile->text_section_offset (); result_val = value_from_ulongest (address_type, result); break; case DW_OP_addrx: case DW_OP_GNU_addr_index: - ensure_have_per_cu (this->per_cu, "DW_OP_addrx"); + ensure_have_per_cu (this->m_per_cu, "DW_OP_addrx"); op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset); - result = dwarf2_read_addr_index (this->per_cu, this->per_objfile, + result = dwarf2_read_addr_index (this->m_per_cu, this->m_per_objfile, uoffset); - result += this->per_objfile->objfile->text_section_offset (); + result += this->m_per_objfile->objfile->text_section_offset (); result_val = value_from_ulongest (address_type, result); break; case DW_OP_GNU_const_index: - ensure_have_per_cu (this->per_cu, "DW_OP_GNU_const_index"); + ensure_have_per_cu (this->m_per_cu, "DW_OP_GNU_const_index"); op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset); - result = dwarf2_read_addr_index (this->per_cu, this->per_objfile, + result = dwarf2_read_addr_index (this->m_per_cu, this->m_per_objfile, uoffset); result_val = value_from_ulongest (address_type, result); break; @@ -1634,7 +1655,7 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, result = op - DW_OP_reg0; result_val = value_from_ulongest (address_type, result); - this->location = DWARF_VALUE_REGISTER; + this->m_location = DWARF_VALUE_REGISTER; break; case DW_OP_regx: @@ -1643,7 +1664,7 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, result = reg; result_val = value_from_ulongest (address_type, result); - this->location = DWARF_VALUE_REGISTER; + this->m_location = DWARF_VALUE_REGISTER; break; case DW_OP_implicit_value: @@ -1653,9 +1674,9 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, 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.")); - this->len = len; - this->data = op_ptr; - this->location = DWARF_VALUE_LITERAL; + this->m_len = len; + this->m_data = op_ptr; + this->m_location = DWARF_VALUE_LITERAL; op_ptr += len; dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_implicit_value"); @@ -1663,7 +1684,7 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, goto no_push; case DW_OP_stack_value: - this->location = DWARF_VALUE_STACK; + this->m_location = DWARF_VALUE_STACK; dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value"); goto no_push; @@ -1671,12 +1692,12 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, case DW_OP_GNU_implicit_pointer: { int64_t len; - ensure_have_per_cu (this->per_cu, "DW_OP_implicit_pointer"); + ensure_have_per_cu (this->m_per_cu, "DW_OP_implicit_pointer"); - int ref_addr_size = this->per_cu->ref_addr_size (); + int ref_addr_size = this->m_per_cu->ref_addr_size (); /* The referred-to DIE of sect_offset kind. */ - this->len = extract_unsigned_integer (op_ptr, ref_addr_size, + this->m_len = extract_unsigned_integer (op_ptr, ref_addr_size, byte_order); op_ptr += ref_addr_size; @@ -1685,7 +1706,7 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, result = (ULONGEST) len; result_val = value_from_ulongest (address_type, result); - this->location = DWARF_VALUE_IMPLICIT_POINTER; + this->m_location = DWARF_VALUE_IMPLICIT_POINTER; dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_implicit_pointer"); } @@ -1725,9 +1746,9 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, case DW_OP_breg31: { op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset); - ensure_have_frame (this->frame, "DW_OP_breg"); + ensure_have_frame (this->m_frame, "DW_OP_breg"); - result = read_addr_from_reg (this->frame, op - DW_OP_breg0); + result = read_addr_from_reg (this->m_frame, op - DW_OP_breg0); result += offset; result_val = value_from_ulongest (address_type, result); } @@ -1736,9 +1757,9 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, { op_ptr = safe_read_uleb128 (op_ptr, op_end, ®); op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset); - ensure_have_frame (this->frame, "DW_OP_bregx"); + ensure_have_frame (this->m_frame, "DW_OP_bregx"); - result = read_addr_from_reg (this->frame, reg); + result = read_addr_from_reg (this->m_frame, reg); result += offset; result_val = value_from_ulongest (address_type, result); } @@ -1754,19 +1775,19 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, backup the current stack locally and install a new empty stack, then reset it afterwards, effectively erasing whatever the recursive call put there. */ - std::vector saved_stack = std::move (stack); - stack.clear (); + std::vector saved_stack = std::move (this->m_stack); + this->m_stack.clear (); /* FIXME: cagney/2003-03-26: This code should be using get_frame_base_address(), and then implement a dwarf2 specific this_base method. */ this->get_frame_base (&datastart, &datalen); eval (datastart, datalen); - if (this->location == DWARF_VALUE_MEMORY) + if (this->m_location == DWARF_VALUE_MEMORY) result = fetch_address (0); - else if (this->location == DWARF_VALUE_REGISTER) + else if (this->m_location == DWARF_VALUE_REGISTER) result - = read_addr_from_reg (this->frame, value_as_long (fetch (0))); + = read_addr_from_reg (this->m_frame, value_as_long (fetch (0))); else error (_("Not implemented: computing frame " "base using explicit value operator")); @@ -1775,9 +1796,9 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, in_stack_memory = true; /* Restore the content of the original stack. */ - stack = std::move (saved_stack); + this->m_stack = std::move (saved_stack); - this->location = DWARF_VALUE_MEMORY; + this->m_location = DWARF_VALUE_MEMORY; } break; @@ -1798,13 +1819,13 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, case DW_OP_swap: { - if (stack.size () < 2) + if (this->m_stack.size () < 2) error (_("Not enough elements for " "DW_OP_swap. Need 2, have %zu."), - stack.size ()); + this->m_stack.size ()); - dwarf_stack_value &t1 = stack[stack.size () - 1]; - dwarf_stack_value &t2 = stack[stack.size () - 2]; + dwarf_stack_value &t1 = this->m_stack[this->m_stack.size () - 1]; + dwarf_stack_value &t2 = this->m_stack[this->m_stack.size () - 2]; std::swap (t1, t2); goto no_push; } @@ -1816,15 +1837,17 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, case DW_OP_rot: { - if (stack.size () < 3) + if (this->m_stack.size () < 3) error (_("Not enough elements for " "DW_OP_rot. Need 3, have %zu."), - stack.size ()); - - dwarf_stack_value temp = stack[stack.size () - 1]; - stack[stack.size () - 1] = stack[stack.size () - 2]; - stack[stack.size () - 2] = stack[stack.size () - 3]; - stack[stack.size () - 3] = temp; + this->m_stack.size ()); + + dwarf_stack_value temp = this->m_stack[this->m_stack.size () - 1]; + this->m_stack[this->m_stack.size () - 1] + = this->m_stack[this->m_stack.size () - 2]; + this->m_stack[this->m_stack.size () - 2] + = this->m_stack[this->m_stack.size () - 3]; + this->m_stack[this->m_stack.size () - 3] = temp; goto no_push; } @@ -1833,7 +1856,7 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, case DW_OP_deref_type: case DW_OP_GNU_deref_type: { - int addr_size = (op == DW_OP_deref ? this->addr_size : *op_ptr++); + int addr_size = (op == DW_OP_deref ? this->m_addr_size : *op_ptr++); gdb_byte *buf = (gdb_byte *) alloca (addr_size); CORE_ADDR addr = fetch_address (0); struct type *type; @@ -1954,8 +1977,7 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, math. */ if (orig_type == address_type) { - struct type *utype - = get_unsigned_type (this->gdbarch, orig_type); + struct type *utype = get_unsigned_type (arch, orig_type); cast_back = 1; first = value_cast (utype, first); @@ -1990,7 +2012,7 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, if (!value_type (first)->is_unsigned ()) { struct type *utype - = get_unsigned_type (this->gdbarch, value_type (first)); + = get_unsigned_type (arch, value_type (first)); first = value_cast (utype, first); } @@ -2007,7 +2029,7 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, if (value_type (first)->is_unsigned ()) { struct type *stype - = get_signed_type (this->gdbarch, value_type (first)); + = get_signed_type (arch, value_type (first)); first = value_cast (stype, first); } @@ -2058,9 +2080,9 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, break; case DW_OP_call_frame_cfa: - ensure_have_frame (this->frame, "DW_OP_call_frame_cfa"); + ensure_have_frame (this->m_frame, "DW_OP_call_frame_cfa"); - result = dwarf2_frame_cfa (this->frame); + result = dwarf2_frame_cfa (this->m_frame); result_val = value_from_ulongest (address_type, result); in_stack_memory = true; break; @@ -2077,7 +2099,7 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, returned. */ result = value_as_long (fetch (0)); pop (); - result = target_translate_tls_address (this->per_objfile->objfile, + result = target_translate_tls_address (this->m_per_objfile->objfile, result); result_val = value_from_ulongest (address_type, result); break; @@ -2115,10 +2137,10 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, /* Pop off the address/regnum, and reset the location type. */ - if (this->location != DWARF_VALUE_LITERAL - && this->location != DWARF_VALUE_OPTIMIZED_OUT) + if (this->m_location != DWARF_VALUE_LITERAL + && this->m_location != DWARF_VALUE_OPTIMIZED_OUT) pop (); - this->location = DWARF_VALUE_MEMORY; + this->m_location = DWARF_VALUE_MEMORY; } goto no_push; @@ -2133,10 +2155,10 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, /* Pop off the address/regnum, and reset the location type. */ - if (this->location != DWARF_VALUE_LITERAL - && this->location != DWARF_VALUE_OPTIMIZED_OUT) + if (this->m_location != DWARF_VALUE_LITERAL + && this->m_location != DWARF_VALUE_OPTIMIZED_OUT) pop (); - this->location = DWARF_VALUE_MEMORY; + this->m_location = DWARF_VALUE_MEMORY; } goto no_push; @@ -2145,7 +2167,7 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always " "be the very last op.")); - this->initialized = 0; + this->m_initialized = 0; goto no_push; case DW_OP_call2: @@ -2168,16 +2190,16 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, case DW_OP_GNU_variable_value: { - ensure_have_per_cu (this->per_cu, "DW_OP_GNU_variable_value"); - int ref_addr_size = this->per_cu->ref_addr_size (); + ensure_have_per_cu (this->m_per_cu, "DW_OP_GNU_variable_value"); + int ref_addr_size = this->m_per_cu->ref_addr_size (); sect_offset sect_off = (sect_offset) extract_unsigned_integer (op_ptr, ref_addr_size, byte_order); op_ptr += ref_addr_size; - result_val = sect_variable_value (sect_off, this->per_cu, - this->per_objfile); + result_val = sect_variable_value (sect_off, this->m_per_cu, + this->m_per_objfile); result_val = value_cast (address_type, result_val); } break; @@ -2209,7 +2231,7 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, if (kind_u.dwarf_reg != -1) { if (deref_size == -1) - deref_size = this->addr_size; + deref_size = this->m_addr_size; op_ptr += len; this->push_dwarf_reg_entry_value (CALL_SITE_PARAMETER_DWARF_REG, kind_u, deref_size); @@ -2264,13 +2286,13 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset); cu_offset type_die_cu_off = (cu_offset) uoffset; - ensure_have_frame (this->frame, "DW_OP_regval_type"); + ensure_have_frame (this->m_frame, "DW_OP_regval_type"); struct type *type = get_base_type (type_die_cu_off); int regnum - = dwarf_reg_to_regnum_or_error (get_frame_arch (this->frame), + = dwarf_reg_to_regnum_or_error (get_frame_arch (this->m_frame), reg); - result_val = value_from_register (type, regnum, this->frame); + result_val = value_from_register (type, regnum, this->m_frame); } break; @@ -2310,11 +2332,11 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, case DW_OP_push_object_address: /* Return the address of the object we are currently observing. */ - if (this->data_view.data () == nullptr - && this->obj_address == 0) + if (this->m_addr_info == nullptr) error (_("Location address is not set.")); - result_val = value_from_ulongest (address_type, this->obj_address); + result_val + = value_from_ulongest (address_type, this->m_addr_info->addr); break; default: @@ -2331,11 +2353,11 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, /* To simplify our main caller, if the result is an implicit pointer, then make a pieced value. This is ok because we can't have implicit pointers in contexts where pieces are invalid. */ - if (this->location == DWARF_VALUE_IMPLICIT_POINTER) - add_piece (8 * this->addr_size, 0); + if (this->m_location == DWARF_VALUE_IMPLICIT_POINTER) + add_piece (8 * this->m_addr_size, 0); - this->recursion_depth--; - gdb_assert (this->recursion_depth >= 0); + this->m_recursion_depth--; + gdb_assert (this->m_recursion_depth >= 0); } void _initialize_dwarf2expr (); diff --git a/gdb/dwarf2/expr.h b/gdb/dwarf2/expr.h index 4b94951c3a5..a10fbac0744 100644 --- a/gdb/dwarf2/expr.h +++ b/gdb/dwarf2/expr.h @@ -119,45 +119,48 @@ struct dwarf_stack_value its current state and its callbacks. */ struct dwarf_expr_context { - dwarf_expr_context (dwarf2_per_objfile *per_objfile); + dwarf_expr_context (dwarf2_per_objfile *per_objfile, + int addr_size); virtual ~dwarf_expr_context () = default; void push_address (CORE_ADDR value, bool in_stack_memory); - void eval (const gdb_byte *addr, size_t len); - /* Fetch the result of the expression evaluation in a form of - a struct value, where TYPE, SUBOBJ_TYPE and SUBOBJ_OFFSET - describe the source level representation of that result. */ - value *fetch_result (struct type *type = nullptr, - struct type *subobj_type = nullptr, - LONGEST subobj_offset = 0); + /* Evaluate the expression at ADDR (LEN bytes long) in a given PER_CU + and FRAME context. TYPE, SUBOBJ_TYPE and SUBOBJ_OFFSET describe + the expected struct value representation of the evaluation + result. The ADDR_INFO property can be specified to override the + range of memory addresses with the passed in buffer. */ + value *evaluate (const gdb_byte *addr, size_t len, + dwarf2_per_cu_data *per_cu, frame_info *frame, + const struct property_addr_info *addr_info = nullptr, + struct type *type = nullptr, + struct type *subobj_type = nullptr, + LONGEST subobj_offset = 0); +private: /* The stack of values. */ - std::vector stack; - - /* Target architecture to use for address operations. */ - struct gdbarch *gdbarch = nullptr; + std::vector m_stack; /* Target address size in bytes. */ - int addr_size = 0; + int m_addr_size = 0; /* The current depth of dwarf expression recursion, via DW_OP_call*, DW_OP_fbreg, DW_OP_push_object_address, etc., and the maximum depth we'll tolerate before raising an error. */ - int recursion_depth = 0, max_recursion_depth = 0x100; + int m_recursion_depth = 0, m_max_recursion_depth = 0x100; /* Location of the value. */ - dwarf_value_location location = DWARF_VALUE_MEMORY; + dwarf_value_location m_location = DWARF_VALUE_MEMORY; /* For DWARF_VALUE_LITERAL, the current literal value's length and data. For DWARF_VALUE_IMPLICIT_POINTER, LEN is the offset of the target DIE of sect_offset kind. */ - ULONGEST len = 0; - const gdb_byte *data = nullptr; + ULONGEST m_len = 0; + const gdb_byte *m_data = nullptr; /* Initialization status of variable: Non-zero if variable has been initialized; zero otherwise. */ - int initialized = 0; + int m_initialized = 0; /* A vector of pieces. @@ -181,25 +184,21 @@ struct dwarf_expr_context no DW_OP_piece operations have no value to place in a piece's 'size' field; the size comes from the surrounding data. So the two cases need to be handled separately.) */ - std::vector pieces; + std::vector m_pieces; /* We evaluate the expression in the context of this objfile. */ - dwarf2_per_objfile *per_objfile; + dwarf2_per_objfile *m_per_objfile; /* Frame information used for the evaluation. */ - frame_info *frame = nullptr; + frame_info *m_frame = nullptr; /* Compilation unit used for the evaluation. */ - dwarf2_per_cu_data *per_cu = nullptr; - - /* Object address used for the evaluation. */ - CORE_ADDR obj_address = 0; + dwarf2_per_cu_data *m_per_cu = nullptr; - /* The data that was passed in. */ - gdb::array_view data_view; - -private: + /* Property address info used for the evaluation. */ + const struct property_addr_info *m_addr_info = nullptr; + void eval (const gdb_byte *addr, size_t len); struct type *address_type () const; void push (struct value *value, bool in_stack_memory); bool stack_empty_p () const; @@ -210,6 +209,12 @@ private: CORE_ADDR fetch_address (int n); bool fetch_in_stack_memory (int n); + /* Fetch the result of the expression evaluation in a form of + a struct value, where TYPE, SUBOBJ_TYPE and SUBOBJ_OFFSET + describe the source level representation of that result. */ + value *fetch_result (struct type *type, struct type *subobj_type, + LONGEST subobj_offset); + /* Return the location expression for the frame base attribute, in START and LENGTH. The result must be live until the current expression evaluation is complete. */ diff --git a/gdb/dwarf2/frame.c b/gdb/dwarf2/frame.c index c773034c305..ae26a8868d1 100644 --- a/gdb/dwarf2/frame.c +++ b/gdb/dwarf2/frame.c @@ -229,25 +229,16 @@ execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size, struct frame_info *this_frame, CORE_ADDR initial, int initial_in_stack_memory, dwarf2_per_objfile *per_objfile) { - dwarf_expr_context ctx (per_objfile); + dwarf_expr_context ctx (per_objfile, addr_size); scoped_value_mark free_values; - ctx.frame = this_frame; - ctx.gdbarch = get_frame_arch (this_frame); - ctx.addr_size = addr_size; - ctx.push_address (initial, initial_in_stack_memory); - ctx.eval (exp, len); - - CORE_ADDR result; - struct value *result_val = ctx.fetch_result (); + value *result_val = ctx.evaluate (exp, len, nullptr, this_frame); if (VALUE_LVAL (result_val) == lval_memory) - result = value_address (result_val); + return value_address (result_val); else - result = value_as_address (result_val); - - return result; + return value_as_address (result_val); } diff --git a/gdb/dwarf2/loc.c b/gdb/dwarf2/loc.c index 894cda238a9..d29fdcf6330 100644 --- a/gdb/dwarf2/loc.c +++ b/gdb/dwarf2/loc.c @@ -1461,8 +1461,6 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, struct type *subobj_type, LONGEST subobj_byte_offset) { - struct value *retval; - if (subobj_type == NULL) { subobj_type = type; @@ -1474,21 +1472,15 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, if (size == 0) return allocate_optimized_out_value (subobj_type); - dwarf_expr_context ctx (per_objfile); - ctx.frame = frame; - ctx.per_cu = per_cu; - ctx.obj_address = 0; + dwarf_expr_context ctx (per_objfile, per_cu->addr_size ()); + value *retval; scoped_value_mark free_values; - ctx.gdbarch = per_objfile->objfile->arch (); - ctx.addr_size = per_cu->addr_size (); - try { - ctx.eval (data, size); - retval = ctx.fetch_result (type, subobj_type, - subobj_byte_offset); + retval = ctx.evaluate (data, size, per_cu, frame, nullptr, type, + subobj_type, subobj_byte_offset); } catch (const gdb_exception_error &ex) { @@ -1558,29 +1550,24 @@ dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton, return 0; dwarf2_per_objfile *per_objfile = dlbaton->per_objfile; - dwarf_expr_context ctx (per_objfile); + dwarf2_per_cu_data *per_cu = dlbaton->per_cu; + dwarf_expr_context ctx (per_objfile, per_cu->addr_size ()); - struct value *result; + value *result; scoped_value_mark free_values; - ctx.frame = frame; - ctx.per_cu = dlbaton->per_cu; - if (addr_stack != nullptr) + if (push_initial_value) { - ctx.obj_address = addr_stack->addr; - ctx.data_view = addr_stack->valaddr; + if (addr_stack != nullptr) + ctx.push_address (addr_stack->addr, false); + else + ctx.push_address (0, false); } - ctx.gdbarch = per_objfile->objfile->arch (); - ctx.addr_size = dlbaton->per_cu->addr_size (); - - if (push_initial_value) - ctx.push_address (ctx.obj_address, false); - try { - ctx.eval (dlbaton->data, dlbaton->size); - result = ctx.fetch_result (); + result = ctx.evaluate (dlbaton->data, dlbaton->size, + per_cu, frame, addr_stack); } catch (const gdb_exception_error &ex) {