X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fdwarf2loc.c;h=c75767ee09cb20edc6925f139294f702ae73de69;hb=607685ecee1015d6c37e0d800d40453dc0aadc8c;hp=430e7496e360363b74f06a9a81f4fd584db20209;hpb=efd66ac6698323d9523a4dce352008c4c835812e;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c index 430e7496e3..c75767ee09 100644 --- a/gdb/dwarf2loc.c +++ b/gdb/dwarf2loc.c @@ -1,6 +1,6 @@ /* DWARF 2 location expression support for GDB. - Copyright (C) 2003-2014 Free Software Foundation, Inc. + Copyright (C) 2003-2015 Free Software Foundation, Inc. Contributed by Daniel Jacobowitz, MontaVista Software, Inc. @@ -30,7 +30,6 @@ #include "ax-gdb.h" #include "regcache.h" #include "objfiles.h" -#include "exceptions.h" #include "block.h" #include "gdbcmd.h" @@ -38,16 +37,11 @@ #include "dwarf2expr.h" #include "dwarf2loc.h" #include "dwarf2-frame.h" +#include "compile/compile.h" -#include -#include "gdb_assert.h" +extern int dwarf_always_disassemble; -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); - -static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs; +extern const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs; static struct value *dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, @@ -277,7 +271,7 @@ dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton, /* This is entry PC record present only at entry point of a function. Verify it is really the function entry point. */ - struct block *pc_block = block_for_pc (pc); + const struct block *pc_block = block_for_pc (pc); struct symbol *pc_func = NULL; if (pc_block) @@ -306,6 +300,7 @@ 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. */ @@ -317,13 +312,9 @@ dwarf_expr_read_addr_from_reg (void *baton, int dwarf_regnum) { struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton; struct gdbarch *gdbarch = get_frame_arch (debaton->frame); - CORE_ADDR result; - int regnum; + int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum); - regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum); - result = address_from_register (builtin_type (gdbarch)->builtin_data_ptr, - regnum, debaton->frame); - return result; + return address_from_register (regnum, debaton->frame); } /* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback. */ @@ -357,7 +348,7 @@ dwarf_expr_frame_base (void *baton, const gdb_byte **start, size_t * length) this_base method. */ struct symbol *framefunc; struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton; - struct block *bl = get_frame_block (debaton->frame, NULL); + const struct block *bl = get_frame_block (debaton->frame, NULL); if (bl == NULL) error (_("frame address is not available.")); @@ -372,9 +363,9 @@ dwarf_expr_frame_base (void *baton, const gdb_byte **start, size_t * length) something has gone wrong. */ gdb_assert (framefunc != NULL); - dwarf_expr_frame_base_1 (framefunc, - get_frame_address_in_block (debaton->frame), - start, length); + func_get_frame_base_dwarf_block (framefunc, + get_frame_address_in_block (debaton->frame), + start, length); } /* Implement find_frame_base_location method for LOC_BLOCK functions using @@ -418,9 +409,11 @@ const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs = loclist_find_frame_base_location }; -static void -dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc, - const gdb_byte **start, size_t *length) +/* 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) { @@ -588,23 +581,24 @@ call_site_to_target_addr (struct gdbarch *call_site_gdbarch, case FIELD_LOC_KIND_PHYSNAME: { const char *physname; - struct minimal_symbol *msym; + 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 == NULL) + if (msym.minsym == NULL) { - msym = lookup_minimal_symbol_by_pc (call_site->pc - 1).minsym; + 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 == NULL ? "???" : MSYMBOL_PRINT_NAME (msym)); + (msym.minsym == NULL ? "???" + : MSYMBOL_PRINT_NAME (msym.minsym))); } - return MSYMBOL_VALUE_ADDRESS (msym); + return BMSYMBOL_VALUE_ADDRESS (msym); } case FIELD_LOC_KIND_PHYSADDR: @@ -831,9 +825,8 @@ chain_candidate (struct gdbarch *gdbarch, struct call_site_chain **resultp, /* 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, therefore some of the former determined intermediate PCs must differ - and the unambiguous chain gets shortened. */ - gdb_assert (result->callers + result->callees < result->length); + it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */ + gdb_assert (result->callers + result->callees <= result->length); } /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the @@ -989,14 +982,13 @@ struct call_site_chain * call_site_find_chain (struct gdbarch *gdbarch, CORE_ADDR caller_pc, CORE_ADDR callee_pc) { - volatile struct gdb_exception e; struct call_site_chain *retval = NULL; - TRY_CATCH (e, RETURN_MASK_ERROR) + TRY { retval = call_site_find_chain_1 (gdbarch, caller_pc, callee_pc); } - if (e.reason < 0) + CATCH (e, RETURN_MASK_ERROR) { if (e.error == NO_ENTRY_VALUE_ERROR) { @@ -1008,6 +1000,8 @@ call_site_find_chain (struct gdbarch *gdbarch, CORE_ADDR caller_pc, else throw_exception (e); } + END_CATCH + return retval; } @@ -1212,6 +1206,7 @@ dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx, baton_local.frame = caller_frame; baton_local.per_cu = caller_per_cu; + baton_local.obj_address = 0; saved_ctx.gdbarch = ctx->gdbarch; saved_ctx.addr_size = ctx->addr_size; @@ -1241,6 +1236,22 @@ dwarf_expr_get_addr_index (void *baton, unsigned int index) return dwarf2_read_addr_index (debaton->per_cu, index); } +/* Callback function for get_object_address. Return the address of the VLA + object. */ + +static CORE_ADDR +dwarf_expr_get_obj_addr (void *baton) +{ + struct dwarf_expr_baton *debaton = baton; + + gdb_assert (debaton != NULL); + + if (debaton->obj_address == 0) + error (_("Location address is not set.")); + + return debaton->obj_address; +} + /* 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.. */ @@ -1288,8 +1299,6 @@ static const struct lval_funcs entry_data_value_funcs = { NULL, /* read */ NULL, /* write */ - NULL, /* check_validity */ - NULL, /* check_any_valid */ NULL, /* indirect */ entry_data_value_coerce_ref, NULL, /* check_synthetic_pointer */ @@ -1315,7 +1324,6 @@ value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame, struct value *outer_val, *target_val, *val; struct call_site_parameter *parameter; struct dwarf2_per_cu_data *caller_per_cu; - CORE_ADDR addr; parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u, &caller_per_cu); @@ -1338,14 +1346,6 @@ value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame, target_type, caller_frame, caller_per_cu); - /* value_as_address dereferences TYPE_CODE_REF. */ - addr = extract_typed_address (value_contents (outer_val), checked_type); - - /* The target entry value has artificial address of the entry value - reference. */ - VALUE_LVAL (target_val) = lval_memory; - set_value_address (target_val, addr); - release_value (target_val); val = allocate_computed_value (type, &entry_data_value_funcs, target_val /* closure */); @@ -1683,21 +1683,21 @@ read_pieced_value (struct value *v) { struct gdbarch *arch = get_frame_arch (frame); int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno); - int reg_offset = source_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; - /* 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; - } if (gdb_regnum != -1) { int optim, unavail; + int reg_offset = source_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; + /* 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; + } if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset, this_size, buffer, @@ -1707,7 +1707,7 @@ read_pieced_value (struct value *v) 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_bits_unavailable (v, offset, this_size_bits); } @@ -1767,7 +1767,7 @@ read_pieced_value (struct value *v) break; case DWARF_VALUE_OPTIMIZED_OUT: - set_value_optimized_out (v, 1); + mark_value_bits_optimized_out (v, offset, this_size_bits); break; default: @@ -1805,7 +1805,7 @@ write_pieced_value (struct value *to, struct value *from) if (frame == NULL) { - set_value_optimized_out (to, 1); + mark_value_bytes_optimized_out (to, 0, TYPE_LENGTH (value_type (to))); return; } @@ -1875,15 +1875,18 @@ write_pieced_value (struct value *to, struct value *from) { 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) { + int reg_offset = dest_offset; + + if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG + && this_size <= register_size (arch, gdb_regnum)) + { + /* Big-endian, and we want less than full size. */ + reg_offset = register_size (arch, gdb_regnum) - this_size; + } + if (need_bitwise) { int optim, unavail; @@ -1937,7 +1940,7 @@ write_pieced_value (struct value *to, struct value *from) source_buffer, this_size); break; default: - set_value_optimized_out (to, 1); + mark_value_bytes_optimized_out (to, 0, TYPE_LENGTH (value_type (to))); break; } offset += this_size_bits; @@ -1946,24 +1949,16 @@ write_pieced_value (struct value *to, struct value *from) do_cleanups (cleanup); } -/* 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, int 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)) @@ -1988,52 +1983,11 @@ 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; -} - -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); -} - -static int -check_pieced_value_invalid (const struct value *value) -{ - return check_pieced_value_bits (value, 0, - 8 * TYPE_LENGTH (value_type (value)), - DWARF_VALUE_OPTIMIZED_OUT); -} - -/* 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, int bit_offset, - int bit_length) -{ - return check_pieced_value_bits (value, bit_offset, bit_length, - DWARF_VALUE_IMPLICIT_POINTER); + return 1; } /* A wrapper function for get_frame_address_in_block. */ @@ -2058,6 +2012,7 @@ indirect_pieced_value (struct value *value) int i, bit_offset, bit_length; struct dwarf_expr_piece *piece = NULL; LONGEST byte_offset; + enum bfd_endian byte_order; type = check_typedef (value_type (value)); if (TYPE_CODE (type) != TYPE_CODE_PTR) @@ -2102,11 +2057,16 @@ indirect_pieced_value (struct value *value) /* 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. */ - byte_offset = value_as_address (value); - if (TYPE_LENGTH (value_type (value)) < sizeof (LONGEST)) - byte_offset = gdb_sign_extend (byte_offset, - 8 * TYPE_LENGTH (value_type (value))); + 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; gdb_assert (piece); @@ -2182,8 +2142,6 @@ free_pieced_value_closure (struct value *v) 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, NULL, /* coerce_ref */ check_pieced_synthetic_pointer, @@ -2193,7 +2151,7 @@ static const struct lval_funcs pieced_value_funcs = { /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */ -static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs = +const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs = { dwarf_expr_read_addr_from_reg, dwarf_expr_get_reg_value, @@ -2205,7 +2163,8 @@ static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs = dwarf_expr_dwarf_call, dwarf_expr_get_base_type, dwarf_expr_push_dwarf_reg_entry_value, - dwarf_expr_get_addr_index + dwarf_expr_get_addr_index, + dwarf_expr_get_obj_addr }; /* Evaluate a location description, starting at DATA and with length @@ -2224,7 +2183,6 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, 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) invalid_synthetic_pointer (); @@ -2234,6 +2192,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, baton.frame = frame; baton.per_cu = per_cu; + baton.obj_address = 0; ctx = new_dwarf_expr_context (); old_chain = make_cleanup_free_dwarf_expr_context (ctx); @@ -2246,11 +2205,11 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, ctx->baton = &baton; ctx->funcs = &dwarf_expr_ctx_funcs; - TRY_CATCH (ex, RETURN_MASK_ERROR) + TRY { dwarf_expr_eval (ctx, data, size); } - if (ex.reason < 0) + CATCH (ex, RETURN_MASK_ERROR) { if (ex.error == NOT_AVAILABLE_ERROR) { @@ -2269,6 +2228,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, else throw_exception (ex); } + END_CATCH if (ctx->num_pieces > 0) { @@ -2311,6 +2271,8 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, retval = value_from_register (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 @@ -2318,7 +2280,9 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, generic optimized out value instead, so that we show instead of . */ do_cleanups (value_chain); - retval = allocate_optimized_out_value (type); + tmp = allocate_value (type); + value_contents_copy (tmp, 0, retval, 0, TYPE_LENGTH (type)); + retval = tmp; } } break; @@ -2431,6 +2395,187 @@ dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame, return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu, 0); } +/* Evaluates a dwarf expression and stores the result in VAL, expecting + that the dwarf expression only produces a single CORE_ADDR. ADDR is a + context (location of a variable) and might be needed to evaluate the + location expression. + Returns 1 on success, 0 otherwise. */ + +static int +dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton, + CORE_ADDR addr, + CORE_ADDR *valp) +{ + struct dwarf_expr_context *ctx; + struct dwarf_expr_baton baton; + struct objfile *objfile; + struct cleanup *cleanup; + + if (dlbaton == NULL || dlbaton->size == 0) + return 0; + + ctx = new_dwarf_expr_context (); + cleanup = make_cleanup_free_dwarf_expr_context (ctx); + + baton.frame = get_selected_frame (NULL); + baton.per_cu = dlbaton->per_cu; + baton.obj_address = addr; + + 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); + ctx->funcs = &dwarf_expr_ctx_funcs; + ctx->baton = &baton; + + dwarf_expr_eval (ctx, dlbaton->data, dlbaton->size); + + switch (ctx->location) + { + case DWARF_VALUE_REGISTER: + case DWARF_VALUE_MEMORY: + case DWARF_VALUE_STACK: + *valp = dwarf_expr_fetch_address (ctx, 0); + if (ctx->location == DWARF_VALUE_REGISTER) + *valp = dwarf_expr_read_addr_from_reg (&baton, *valp); + do_cleanups (cleanup); + return 1; + case DWARF_VALUE_LITERAL: + *valp = extract_signed_integer (ctx->data, ctx->len, + gdbarch_byte_order (ctx->gdbarch)); + do_cleanups (cleanup); + return 1; + /* Unsupported dwarf values. */ + case DWARF_VALUE_OPTIMIZED_OUT: + case DWARF_VALUE_IMPLICIT_POINTER: + break; + } + + do_cleanups (cleanup); + return 0; +} + +/* See dwarf2loc.h. */ + +int +dwarf2_evaluate_property (const struct dynamic_prop *prop, + struct property_addr_info *addr_stack, + CORE_ADDR *value) +{ + if (prop == NULL) + return 0; + + switch (prop->kind) + { + case PROP_LOCEXPR: + { + const struct dwarf2_property_baton *baton = prop->data.baton; + + if (dwarf2_locexpr_baton_eval (&baton->locexpr, addr_stack->addr, + value)) + { + if (baton->referenced_type) + { + struct value *val = value_at (baton->referenced_type, *value); + + *value = value_as_address (val); + } + return 1; + } + } + break; + + case PROP_LOCLIST: + { + struct dwarf2_property_baton *baton = prop->data.baton; + struct frame_info *frame = get_selected_frame (NULL); + 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->referenced_type, frame, data, + size, baton->loclist.per_cu); + if (!value_optimized_out (val)) + { + *value = value_as_address (val); + return 1; + } + } + } + break; + + case PROP_CONST: + *value = prop->data.const_val; + return 1; + + case PROP_ADDR_OFFSET: + { + struct dwarf2_property_baton *baton = prop->data.baton; + struct property_addr_info *pinfo; + struct value *val; + + for (pinfo = addr_stack; pinfo != NULL; pinfo = pinfo->next) + if (pinfo->type == baton->referenced_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 1; + } + } + + return 0; +} + +/* See dwarf2loc.h. */ + +void +dwarf2_compile_property_to_c (struct ui_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 dwarf2_property_baton *baton = prop->data.baton; + const gdb_byte *data; + size_t size; + struct dwarf2_per_cu_data *per_cu; + + 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 functions and baton for dwarf2_loc_desc_needs_frame. */ @@ -2538,6 +2683,15 @@ needs_get_addr_index (void *baton, unsigned int index) return 1; } +/* DW_OP_push_object_address has a frame already passed through. */ + +static CORE_ADDR +needs_get_obj_addr (void *baton) +{ + /* Nothing to do. */ + return 1; +} + /* Virtual method table for dwarf2_loc_desc_needs_frame below. */ static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs = @@ -2552,7 +2706,8 @@ static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs = needs_frame_dwarf_call, NULL, /* get_base_type */ needs_dwarf_reg_entry_value, - needs_get_addr_index + needs_get_addr_index, + needs_get_obj_addr }; /* Return non-zero iff the location expression at DATA (length SIZE) @@ -2619,14 +2774,10 @@ 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) +int +dwarf2_reg_to_regnum_or_error (struct gdbarch *arch, int dwarf_reg) { int reg = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_reg); if (reg == -1) @@ -2877,14 +3028,14 @@ 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 = dwarf2_reg_to_regnum_or_error (arch, op - DW_OP_reg0); loc->kind = axs_lvalue_register; break; case DW_OP_regx: 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 = dwarf2_reg_to_regnum_or_error (arch, reg); loc->kind = axs_lvalue_register; break; @@ -2947,7 +3098,7 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, case DW_OP_breg30: case DW_OP_breg31: op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset); - i = translate_register (arch, op - DW_OP_breg0); + i = dwarf2_reg_to_regnum_or_error (arch, op - DW_OP_breg0); ax_reg (expr, i); if (offset != 0) { @@ -2959,7 +3110,7 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, { op_ptr = safe_read_uleb128 (op_ptr, op_end, ®); op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset); - i = translate_register (arch, reg); + i = dwarf2_reg_to_regnum_or_error (arch, reg); ax_reg (expr, i); if (offset != 0) { @@ -2972,7 +3123,7 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, { const gdb_byte *datastart; size_t datalen; - struct block *b; + const struct block *b; struct symbol *framefunc; b = block_for_pc (expr->scope); @@ -2985,8 +3136,8 @@ 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 = safe_read_sleb128 (op_ptr, op_end, &offset); dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart, @@ -3193,14 +3344,44 @@ 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, arch, addr_size, + cfa_start, cfa_end, per_cu); + } + + loc->kind = axs_lvalue_memory; + } break; case DW_OP_GNU_push_tls_address: unimplemented (op); break; + case DW_OP_push_object_address: + unimplemented (op); + break; + case DW_OP_skip: offset = extract_signed_integer (op_ptr, 2, byte_order); op_ptr += 2; @@ -3427,7 +3608,7 @@ locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream, } else if (data[0] == DW_OP_fbreg) { - struct block *b; + const struct block *b; struct symbol *framefunc; int frame_reg = 0; int64_t frame_offset; @@ -3452,7 +3633,7 @@ locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream, error (_("No function found for block for symbol \"%s\"."), SYMBOL_PRINT_NAME (symbol)); - 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) { @@ -3955,7 +4136,7 @@ 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, per_cu, @@ -3974,7 +4155,7 @@ locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr, get_objfile_arch (objfile), addr_size, offset_size, data, data, end, 0, - dwarf2_always_disassemble, + dwarf_always_disassemble, per_cu); } @@ -4062,6 +4243,26 @@ locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch, dlbaton->per_cu); } +/* symbol_computed_ops 'generate_c_location' method. */ + +static void +locexpr_generate_c_location (struct symbol *sym, struct ui_file *stream, + struct gdbarch *gdbarch, + unsigned char *registers_used, + CORE_ADDR pc, const char *result_name) +{ + struct dwarf2_locexpr_baton *dlbaton = 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"), SYMBOL_NATURAL_NAME (sym)); + + 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 = { @@ -4070,7 +4271,8 @@ const struct symbol_computed_ops dwarf2_locexpr_funcs = { locexpr_read_needs_frame, locexpr_describe_location, 0, /* location_has_loclist */ - locexpr_tracepoint_var_ref + locexpr_tracepoint_var_ref, + locexpr_generate_c_location }; @@ -4203,6 +4405,9 @@ loclist_describe_location (struct symbol *symbol, CORE_ADDR addr, 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; @@ -4241,6 +4446,29 @@ loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch, dlbaton->per_cu); } +/* symbol_computed_ops 'generate_c_location' method. */ + +static void +loclist_generate_c_location (struct symbol *sym, struct ui_file *stream, + struct gdbarch *gdbarch, + unsigned char *registers_used, + CORE_ADDR pc, const char *result_name) +{ + struct dwarf2_loclist_baton *dlbaton = 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"), SYMBOL_NATURAL_NAME (sym)); + + 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 = { @@ -4249,7 +4477,8 @@ const struct symbol_computed_ops dwarf2_loclist_funcs = { loclist_read_needs_frame, loclist_describe_location, 1, /* location_has_loclist */ - loclist_tracepoint_var_ref + loclist_tracepoint_var_ref, + loclist_generate_c_location }; /* Provide a prototype to silence -Wmissing-prototypes. */