1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
34 #include "exceptions.h"
38 #include "dwarf2expr.h"
39 #include "dwarf2loc.h"
40 #include "dwarf2-frame.h"
42 #include "gdb_string.h"
43 #include "gdb_assert.h"
46 dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
47 gdb_byte **start, size_t *length);
49 /* A helper function for dealing with location lists. Given a
50 symbol baton (BATON) and a pc value (PC), find the appropriate
51 location expression, set *LOCEXPR_LENGTH, and return a pointer
52 to the beginning of the expression. Returns NULL on failure.
54 For now, only return the first matching location expression; there
55 can be more than one in the list. */
58 find_location_expression (struct dwarf2_loclist_baton *baton,
59 size_t *locexpr_length, CORE_ADDR pc)
62 gdb_byte *loc_ptr, *buf_end;
64 struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu);
65 struct gdbarch *gdbarch = get_objfile_arch (objfile);
66 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
67 unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu);
68 CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
69 /* Adjust base_address for relocatable objects. */
70 CORE_ADDR base_offset = ANOFFSET (objfile->section_offsets,
71 SECT_OFF_TEXT (objfile));
72 CORE_ADDR base_address = baton->base_address + base_offset;
74 loc_ptr = baton->data;
75 buf_end = baton->data + baton->size;
79 if (buf_end - loc_ptr < 2 * addr_size)
80 error (_("find_location_expression: Corrupted DWARF expression."));
82 low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
85 /* A base-address-selection entry. */
88 base_address = dwarf2_read_address (gdbarch,
89 loc_ptr, buf_end, addr_size);
94 high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
97 /* An end-of-list entry. */
98 if (low == 0 && high == 0)
101 /* Otherwise, a location expression entry. */
103 high += base_address;
105 length = extract_unsigned_integer (loc_ptr, 2, byte_order);
108 if (pc >= low && pc < high)
110 *locexpr_length = length;
118 /* This is the baton used when performing dwarf2 expression
120 struct dwarf_expr_baton
122 struct frame_info *frame;
123 struct objfile *objfile;
126 /* Helper functions for dwarf2_evaluate_loc_desc. */
128 /* Using the frame specified in BATON, return the value of register
129 REGNUM, treated as a pointer. */
131 dwarf_expr_read_reg (void *baton, int dwarf_regnum)
133 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
134 struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
138 regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
139 result = address_from_register (builtin_type (gdbarch)->builtin_data_ptr,
140 regnum, debaton->frame);
144 /* Read memory at ADDR (length LEN) into BUF. */
147 dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
149 read_memory (addr, buf, len);
152 /* Using the frame specified in BATON, find the location expression
153 describing the frame base. Return a pointer to it in START and
154 its length in LENGTH. */
156 dwarf_expr_frame_base (void *baton, gdb_byte **start, size_t * length)
158 /* FIXME: cagney/2003-03-26: This code should be using
159 get_frame_base_address(), and then implement a dwarf2 specific
161 struct symbol *framefunc;
162 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
164 /* Use block_linkage_function, which returns a real (not inlined)
165 function, instead of get_frame_function, which may return an
167 framefunc = block_linkage_function (get_frame_block (debaton->frame, NULL));
169 /* If we found a frame-relative symbol then it was certainly within
170 some function associated with a frame. If we can't find the frame,
171 something has gone wrong. */
172 gdb_assert (framefunc != NULL);
174 dwarf_expr_frame_base_1 (framefunc,
175 get_frame_address_in_block (debaton->frame),
180 dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
181 gdb_byte **start, size_t *length)
183 if (SYMBOL_LOCATION_BATON (framefunc) == NULL)
185 else if (SYMBOL_COMPUTED_OPS (framefunc) == &dwarf2_loclist_funcs)
187 struct dwarf2_loclist_baton *symbaton;
189 symbaton = SYMBOL_LOCATION_BATON (framefunc);
190 *start = find_location_expression (symbaton, length, pc);
194 struct dwarf2_locexpr_baton *symbaton;
195 symbaton = SYMBOL_LOCATION_BATON (framefunc);
196 if (symbaton != NULL)
198 *length = symbaton->size;
199 *start = symbaton->data;
206 error (_("Could not find the frame base for \"%s\"."),
207 SYMBOL_NATURAL_NAME (framefunc));
210 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
211 the frame in BATON. */
214 dwarf_expr_frame_cfa (void *baton)
216 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
217 return dwarf2_frame_cfa (debaton->frame);
220 /* Using the objfile specified in BATON, find the address for the
221 current thread's thread-local storage with offset OFFSET. */
223 dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
225 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
227 return target_translate_tls_address (debaton->objfile, offset);
232 /* The number of pieces used to describe this variable. */
235 /* The target address size, used only for DWARF_VALUE_STACK. */
238 /* The pieces themselves. */
239 struct dwarf_expr_piece *pieces;
242 /* Allocate a closure for a value formed from separately-described
245 static struct piece_closure *
246 allocate_piece_closure (int n_pieces, struct dwarf_expr_piece *pieces,
249 struct piece_closure *c = XZALLOC (struct piece_closure);
251 c->n_pieces = n_pieces;
252 c->addr_size = addr_size;
253 c->pieces = XCALLOC (n_pieces, struct dwarf_expr_piece);
255 memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
261 read_pieced_value (struct value *v)
266 struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
267 struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
269 contents = value_contents_raw (v);
270 for (i = 0; i < c->n_pieces; i++)
272 struct dwarf_expr_piece *p = &c->pieces[i];
275 case DWARF_VALUE_REGISTER:
277 struct gdbarch *arch = get_frame_arch (frame);
278 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch,
282 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
283 && p->size < register_size (arch, gdb_regnum))
284 /* Big-endian, and we want less than full size. */
285 reg_offset = register_size (arch, gdb_regnum) - p->size;
287 if (gdb_regnum != -1)
289 get_frame_register_bytes (frame, gdb_regnum, reg_offset,
290 p->size, contents + offset);
294 error (_("Unable to access DWARF register number %s"),
295 paddress (arch, p->v.expr.value));
300 case DWARF_VALUE_MEMORY:
301 if (p->v.expr.in_stack_memory)
302 read_stack (p->v.expr.value, contents + offset, p->size);
304 read_memory (p->v.expr.value, contents + offset, p->size);
307 case DWARF_VALUE_STACK:
309 struct gdbarch *gdbarch = get_type_arch (value_type (v));
311 if (n > c->addr_size)
313 store_unsigned_integer (contents + offset, n,
314 gdbarch_byte_order (gdbarch),
319 case DWARF_VALUE_LITERAL:
322 if (n > p->v.literal.length)
323 n = p->v.literal.length;
324 memcpy (contents + offset, p->v.literal.data, n);
329 internal_error (__FILE__, __LINE__, _("invalid location type"));
336 write_pieced_value (struct value *to, struct value *from)
341 struct piece_closure *c = (struct piece_closure *) value_computed_closure (to);
342 struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
346 set_value_optimized_out (to, 1);
350 contents = value_contents_raw (from);
351 for (i = 0; i < c->n_pieces; i++)
353 struct dwarf_expr_piece *p = &c->pieces[i];
356 case DWARF_VALUE_REGISTER:
358 struct gdbarch *arch = get_frame_arch (frame);
359 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.expr.value);
362 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
363 && p->size < register_size (arch, gdb_regnum))
364 /* Big-endian, and we want less than full size. */
365 reg_offset = register_size (arch, gdb_regnum) - p->size;
367 if (gdb_regnum != -1)
369 put_frame_register_bytes (frame, gdb_regnum, reg_offset,
370 p->size, contents + offset);
374 error (_("Unable to write to DWARF register number %s"),
375 paddress (arch, p->v.expr.value));
379 case DWARF_VALUE_MEMORY:
380 write_memory (p->v.expr.value, contents + offset, p->size);
383 set_value_optimized_out (to, 1);
391 copy_pieced_value_closure (struct value *v)
393 struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
395 return allocate_piece_closure (c->n_pieces, c->pieces, c->addr_size);
399 free_pieced_value_closure (struct value *v)
401 struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
407 /* Functions for accessing a variable described by DW_OP_piece. */
408 static struct lval_funcs pieced_value_funcs = {
411 copy_pieced_value_closure,
412 free_pieced_value_closure
415 /* Evaluate a location description, starting at DATA and with length
416 SIZE, to find the current location of variable of TYPE in the context
419 static struct value *
420 dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
421 gdb_byte *data, unsigned short size,
422 struct dwarf2_per_cu_data *per_cu)
424 struct value *retval;
425 struct dwarf_expr_baton baton;
426 struct dwarf_expr_context *ctx;
427 struct cleanup *old_chain;
431 retval = allocate_value (type);
432 VALUE_LVAL (retval) = not_lval;
433 set_value_optimized_out (retval, 1);
438 baton.objfile = dwarf2_per_cu_objfile (per_cu);
440 ctx = new_dwarf_expr_context ();
441 old_chain = make_cleanup_free_dwarf_expr_context (ctx);
443 ctx->gdbarch = get_objfile_arch (baton.objfile);
444 ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
446 ctx->read_reg = dwarf_expr_read_reg;
447 ctx->read_mem = dwarf_expr_read_mem;
448 ctx->get_frame_base = dwarf_expr_frame_base;
449 ctx->get_frame_cfa = dwarf_expr_frame_cfa;
450 ctx->get_tls_address = dwarf_expr_tls_address;
452 dwarf_expr_eval (ctx, data, size);
453 if (ctx->num_pieces > 0)
455 struct piece_closure *c;
456 struct frame_id frame_id = get_frame_id (frame);
458 c = allocate_piece_closure (ctx->num_pieces, ctx->pieces,
460 retval = allocate_computed_value (type, &pieced_value_funcs, c);
461 VALUE_FRAME_ID (retval) = frame_id;
465 switch (ctx->location)
467 case DWARF_VALUE_REGISTER:
469 struct gdbarch *arch = get_frame_arch (frame);
470 CORE_ADDR dwarf_regnum = dwarf_expr_fetch (ctx, 0);
471 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
472 if (gdb_regnum != -1)
473 retval = value_from_register (type, gdb_regnum, frame);
475 error (_("Unable to access DWARF register number %s"),
476 paddress (arch, dwarf_regnum));
480 case DWARF_VALUE_MEMORY:
482 CORE_ADDR address = dwarf_expr_fetch (ctx, 0);
483 int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
485 retval = allocate_value (type);
486 VALUE_LVAL (retval) = lval_memory;
487 set_value_lazy (retval, 1);
489 set_value_stack (retval, 1);
490 set_value_address (retval, address);
494 case DWARF_VALUE_STACK:
496 ULONGEST value = (ULONGEST) dwarf_expr_fetch (ctx, 0);
498 size_t n = ctx->addr_size;
500 retval = allocate_value (type);
501 contents = value_contents_raw (retval);
502 if (n > TYPE_LENGTH (type))
503 n = TYPE_LENGTH (type);
504 store_unsigned_integer (contents, n,
505 gdbarch_byte_order (ctx->gdbarch),
510 case DWARF_VALUE_LITERAL:
515 retval = allocate_value (type);
516 contents = value_contents_raw (retval);
517 if (n > TYPE_LENGTH (type))
518 n = TYPE_LENGTH (type);
519 memcpy (contents, ctx->data, n);
524 internal_error (__FILE__, __LINE__, _("invalid location type"));
528 set_value_initialized (retval, ctx->initialized);
530 do_cleanups (old_chain);
535 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
537 struct needs_frame_baton
542 /* Reads from registers do require a frame. */
544 needs_frame_read_reg (void *baton, int regnum)
546 struct needs_frame_baton *nf_baton = baton;
547 nf_baton->needs_frame = 1;
551 /* Reads from memory do not require a frame. */
553 needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
555 memset (buf, 0, len);
558 /* Frame-relative accesses do require a frame. */
560 needs_frame_frame_base (void *baton, gdb_byte **start, size_t * length)
562 static gdb_byte lit0 = DW_OP_lit0;
563 struct needs_frame_baton *nf_baton = baton;
568 nf_baton->needs_frame = 1;
571 /* CFA accesses require a frame. */
574 needs_frame_frame_cfa (void *baton)
576 struct needs_frame_baton *nf_baton = baton;
577 nf_baton->needs_frame = 1;
581 /* Thread-local accesses do require a frame. */
583 needs_frame_tls_address (void *baton, CORE_ADDR offset)
585 struct needs_frame_baton *nf_baton = baton;
586 nf_baton->needs_frame = 1;
590 /* Return non-zero iff the location expression at DATA (length SIZE)
591 requires a frame to evaluate. */
594 dwarf2_loc_desc_needs_frame (gdb_byte *data, unsigned short size,
595 struct dwarf2_per_cu_data *per_cu)
597 struct needs_frame_baton baton;
598 struct dwarf_expr_context *ctx;
600 struct cleanup *old_chain;
602 baton.needs_frame = 0;
604 ctx = new_dwarf_expr_context ();
605 old_chain = make_cleanup_free_dwarf_expr_context (ctx);
607 ctx->gdbarch = get_objfile_arch (dwarf2_per_cu_objfile (per_cu));
608 ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
610 ctx->read_reg = needs_frame_read_reg;
611 ctx->read_mem = needs_frame_read_mem;
612 ctx->get_frame_base = needs_frame_frame_base;
613 ctx->get_frame_cfa = needs_frame_frame_cfa;
614 ctx->get_tls_address = needs_frame_tls_address;
616 dwarf_expr_eval (ctx, data, size);
618 in_reg = ctx->location == DWARF_VALUE_REGISTER;
620 if (ctx->num_pieces > 0)
624 /* If the location has several pieces, and any of them are in
625 registers, then we will need a frame to fetch them from. */
626 for (i = 0; i < ctx->num_pieces; i++)
627 if (ctx->pieces[i].location == DWARF_VALUE_REGISTER)
631 do_cleanups (old_chain);
633 return baton.needs_frame || in_reg;
636 /* This struct keeps track of the pieces that make up a multi-location
637 object, for use in agent expression generation. It is
638 superficially similar to struct dwarf_expr_piece, but
639 dwarf_expr_piece is designed for use in immediate evaluation, and
640 does not, for example, have a way to record both base register and
645 /* Memory vs register, etc */
646 enum axs_lvalue_kind kind;
648 /* If non-zero, number of bytes in this fragment */
651 /* (GDB-numbered) reg, or base reg if >= 0 */
654 /* offset from reg */
659 dwarf2_tracepoint_var_loc (struct symbol *symbol,
660 struct agent_expr *ax,
661 struct axs_var_loc *loc,
662 struct gdbarch *gdbarch,
663 gdb_byte *data, gdb_byte *end)
665 if (data[0] >= DW_OP_reg0 && data[0] <= DW_OP_reg31)
667 loc->kind = axs_lvalue_register;
668 loc->reg = gdbarch_dwarf2_reg_to_regnum (gdbarch, data[0] - DW_OP_reg0);
671 else if (data[0] == DW_OP_regx)
674 data = read_uleb128 (data + 1, end, ®);
675 loc->kind = axs_lvalue_register;
676 loc->reg = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg);
678 else if (data[0] == DW_OP_fbreg)
681 struct symbol *framefunc;
683 LONGEST frame_offset;
686 LONGEST base_offset = 0;
688 b = block_for_pc (ax->scope);
691 error (_("No block found for address"));
693 framefunc = block_linkage_function (b);
696 error (_("No function found for block"));
698 dwarf_expr_frame_base_1 (framefunc, ax->scope,
699 &base_data, &base_size);
701 if (base_data[0] >= DW_OP_breg0 && base_data[0] <= DW_OP_breg31)
705 frame_reg = base_data[0] - DW_OP_breg0;
706 buf_end = read_sleb128 (base_data + 1,
707 base_data + base_size, &base_offset);
708 if (buf_end != base_data + base_size)
709 error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
710 frame_reg, SYMBOL_PRINT_NAME (symbol));
712 else if (base_data[0] >= DW_OP_reg0 && base_data[0] <= DW_OP_reg31)
714 /* The frame base is just the register, with no offset. */
715 frame_reg = base_data[0] - DW_OP_reg0;
720 /* We don't know what to do with the frame base expression,
721 so we can't trace this variable; give up. */
722 error (_("Cannot generate expression to collect symbol \"%s\"; DWARF 2 encoding not handled, first opcode in base data is 0x%x."),
723 SYMBOL_PRINT_NAME (symbol), base_data[0]);
726 data = read_sleb128 (data + 1, end, &frame_offset);
728 loc->kind = axs_lvalue_memory;
729 loc->reg = gdbarch_dwarf2_reg_to_regnum (gdbarch, frame_reg);
730 loc->offset = base_offset + frame_offset;
732 else if (data[0] >= DW_OP_breg0 && data[0] <= DW_OP_breg31)
737 reg = data[0] - DW_OP_breg0;
738 data = read_sleb128 (data + 1, end, &offset);
740 loc->kind = axs_lvalue_memory;
741 loc->reg = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg);
742 loc->offset = offset;
745 error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
746 data[0], SYMBOL_PRINT_NAME (symbol));
751 /* Given the location of a piece, issue bytecodes that will access it. */
754 dwarf2_tracepoint_var_access (struct agent_expr *ax,
755 struct axs_value *value,
756 struct axs_var_loc *loc)
758 value->kind = loc->kind;
762 case axs_lvalue_register:
763 value->u.reg = loc->reg;
766 case axs_lvalue_memory:
767 ax_reg (ax, loc->reg);
770 ax_const_l (ax, loc->offset);
771 ax_simple (ax, aop_add);
776 internal_error (__FILE__, __LINE__, _("Unhandled value kind in dwarf2_tracepoint_var_access"));
781 dwarf2_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
782 struct agent_expr *ax, struct axs_value *value,
783 gdb_byte *data, int size)
785 gdb_byte *end = data + size;
786 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
787 /* In practice, a variable is not going to be spread across
788 dozens of registers or memory locations. If someone comes up
789 with a real-world example, revisit this. */
791 struct axs_var_loc fragments[MAX_FRAGS];
792 int nfrags = 0, frag;
798 if (!data || size == 0)
800 value->optimized_out = 1;
808 if (nfrags == MAX_FRAGS)
809 error (_("Too many pieces in location for \"%s\"."),
810 SYMBOL_PRINT_NAME (symbol));
812 fragments[nfrags].bytes = 0;
813 data = dwarf2_tracepoint_var_loc (symbol, ax, &fragments[nfrags],
818 else if (data[0] == DW_OP_piece)
822 data = read_uleb128 (data + 1, end, &bytes);
823 /* Only deal with 4 byte fragments for now. */
825 error (_("DW_OP_piece %s not supported in location for \"%s\"."),
826 pulongest (bytes), SYMBOL_PRINT_NAME (symbol));
827 fragments[nfrags - 1].bytes = bytes;
838 if (bad || data > end)
839 error (_("Corrupted DWARF expression for \"%s\"."),
840 SYMBOL_PRINT_NAME (symbol));
842 /* If single expression, no pieces, convert to external format. */
845 dwarf2_tracepoint_var_access (ax, value, &fragments[0]);
849 if (length != TYPE_LENGTH (value->type))
850 error (_("Inconsistent piece information for \"%s\"."),
851 SYMBOL_PRINT_NAME (symbol));
853 /* Emit bytecodes to assemble the pieces into a single stack entry. */
855 for ((frag = (byte_order == BFD_ENDIAN_BIG ? 0 : nfrags - 1));
857 (frag += (byte_order == BFD_ENDIAN_BIG ? 1 : -1)))
861 /* shift the previous fragment up 32 bits */
863 ax_simple (ax, aop_lsh);
866 dwarf2_tracepoint_var_access (ax, value, &fragments[frag]);
870 case axs_lvalue_register:
871 ax_reg (ax, value->u.reg);
874 case axs_lvalue_memory:
876 extern int trace_kludge; /* Ugh. */
878 gdb_assert (fragments[frag].bytes == 4);
880 ax_trace_quick (ax, 4);
881 ax_simple (ax, aop_ref32);
888 /* or the new fragment into the previous */
889 ax_zero_ext (ax, 32);
890 ax_simple (ax, aop_bit_or);
894 value->kind = axs_rvalue;
898 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
899 evaluator to calculate the location. */
900 static struct value *
901 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
903 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
905 val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, dlbaton->data,
906 dlbaton->size, dlbaton->per_cu);
911 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
913 locexpr_read_needs_frame (struct symbol *symbol)
915 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
916 return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
920 /* Describe a single piece of a location, returning an updated
921 position in the bytecode sequence. */
924 locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
925 CORE_ADDR addr, struct objfile *objfile,
926 gdb_byte *data, int size, unsigned int addr_size)
928 struct gdbarch *gdbarch = get_objfile_arch (objfile);
931 if (data[0] >= DW_OP_reg0 && data[0] <= DW_OP_reg31)
933 regno = gdbarch_dwarf2_reg_to_regnum (gdbarch, data[0] - DW_OP_reg0);
934 fprintf_filtered (stream, _("a variable in $%s"),
935 gdbarch_register_name (gdbarch, regno));
938 else if (data[0] == DW_OP_regx)
942 data = read_uleb128 (data + 1, data + size, ®);
943 regno = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg);
944 fprintf_filtered (stream, _("a variable in $%s"),
945 gdbarch_register_name (gdbarch, regno));
947 else if (data[0] == DW_OP_fbreg)
950 struct symbol *framefunc;
952 LONGEST frame_offset;
955 LONGEST base_offset = 0;
957 b = block_for_pc (addr);
960 error (_("No block found for address for symbol \"%s\"."),
961 SYMBOL_PRINT_NAME (symbol));
963 framefunc = block_linkage_function (b);
966 error (_("No function found for block for symbol \"%s\"."),
967 SYMBOL_PRINT_NAME (symbol));
969 dwarf_expr_frame_base_1 (framefunc, addr, &base_data, &base_size);
971 if (base_data[0] >= DW_OP_breg0 && base_data[0] <= DW_OP_breg31)
975 frame_reg = base_data[0] - DW_OP_breg0;
976 buf_end = read_sleb128 (base_data + 1,
977 base_data + base_size, &base_offset);
978 if (buf_end != base_data + base_size)
979 error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
980 frame_reg, SYMBOL_PRINT_NAME (symbol));
982 else if (base_data[0] >= DW_OP_reg0 && base_data[0] <= DW_OP_reg31)
984 /* The frame base is just the register, with no offset. */
985 frame_reg = base_data[0] - DW_OP_reg0;
990 /* We don't know what to do with the frame base expression,
991 so we can't trace this variable; give up. */
992 error (_("Cannot describe location of symbol \"%s\"; "
993 "DWARF 2 encoding not handled, "
994 "first opcode in base data is 0x%x."),
995 SYMBOL_PRINT_NAME (symbol), base_data[0]);
998 regno = gdbarch_dwarf2_reg_to_regnum (gdbarch, frame_reg);
1000 data = read_sleb128 (data + 1, data + size, &frame_offset);
1002 fprintf_filtered (stream, _("a variable at frame base reg $%s offset %s+%s"),
1003 gdbarch_register_name (gdbarch, regno),
1004 plongest (base_offset), plongest (frame_offset));
1006 else if (data[0] >= DW_OP_breg0 && data[0] <= DW_OP_breg31)
1010 regno = gdbarch_dwarf2_reg_to_regnum (gdbarch, data[0] - DW_OP_breg0);
1012 data = read_sleb128 (data + 1, data + size, &offset);
1014 fprintf_filtered (stream,
1015 _("a variable at offset %s from base reg $%s"),
1017 gdbarch_register_name (gdbarch, regno));
1020 /* The location expression for a TLS variable looks like this (on a
1023 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
1024 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
1026 0x3 is the encoding for DW_OP_addr, which has an operand as long
1027 as the size of an address on the target machine (here is 8
1028 bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
1029 The operand represents the offset at which the variable is within
1030 the thread local storage. */
1033 && data[size - 1] == DW_OP_GNU_push_tls_address
1034 && data[0] == DW_OP_addr)
1036 CORE_ADDR offset = dwarf2_read_address (gdbarch,
1040 fprintf_filtered (stream,
1041 _("a thread-local variable at offset %s "
1042 "in the thread-local storage for `%s'"),
1043 paddress (gdbarch, offset), objfile->name);
1045 data += 1 + addr_size + 1;
1048 fprintf_filtered (stream,
1049 _("a variable with complex or multiple locations (DWARF2)"));
1054 /* Describe a single location, which may in turn consist of multiple
1058 locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr,
1059 struct ui_file *stream, gdb_byte *data, int size,
1060 struct objfile *objfile, unsigned int addr_size)
1062 gdb_byte *end = data + size;
1063 int piece_done = 0, first_piece = 1, bad = 0;
1065 /* A multi-piece description consists of multiple sequences of bytes
1066 each followed by DW_OP_piece + length of piece. */
1074 fprintf_filtered (stream, _(", and "));
1076 data = locexpr_describe_location_piece (symbol, stream, addr, objfile,
1077 data, size, addr_size);
1080 else if (data[0] == DW_OP_piece)
1084 data = read_uleb128 (data + 1, end, &bytes);
1086 fprintf_filtered (stream, _(" [%s-byte piece]"), pulongest (bytes));
1097 if (bad || data > end)
1098 error (_("Corrupted DWARF2 expression for \"%s\"."),
1099 SYMBOL_PRINT_NAME (symbol));
1102 /* Print a natural-language description of SYMBOL to STREAM. This
1103 version is for a symbol with a single location. */
1106 locexpr_describe_location (struct symbol *symbol, CORE_ADDR addr,
1107 struct ui_file *stream)
1109 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
1110 struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
1111 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
1113 locexpr_describe_location_1 (symbol, addr, stream, dlbaton->data, dlbaton->size,
1114 objfile, addr_size);
1117 /* Describe the location of SYMBOL as an agent value in VALUE, generating
1118 any necessary bytecode in AX. */
1121 locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
1122 struct agent_expr *ax, struct axs_value *value)
1124 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
1126 dwarf2_tracepoint_var_ref (symbol, gdbarch, ax, value,
1127 dlbaton->data, dlbaton->size);
1130 /* The set of location functions used with the DWARF-2 expression
1132 const struct symbol_computed_ops dwarf2_locexpr_funcs = {
1133 locexpr_read_variable,
1134 locexpr_read_needs_frame,
1135 locexpr_describe_location,
1136 locexpr_tracepoint_var_ref
1140 /* Wrapper functions for location lists. These generally find
1141 the appropriate location expression and call something above. */
1143 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
1144 evaluator to calculate the location. */
1145 static struct value *
1146 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
1148 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
1153 data = find_location_expression (dlbaton, &size,
1154 frame ? get_frame_address_in_block (frame)
1158 val = allocate_value (SYMBOL_TYPE (symbol));
1159 VALUE_LVAL (val) = not_lval;
1160 set_value_optimized_out (val, 1);
1163 val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, data, size,
1169 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
1171 loclist_read_needs_frame (struct symbol *symbol)
1173 /* If there's a location list, then assume we need to have a frame
1174 to choose the appropriate location expression. With tracking of
1175 global variables this is not necessarily true, but such tracking
1176 is disabled in GCC at the moment until we figure out how to
1182 /* Print a natural-language description of SYMBOL to STREAM. This
1183 version applies when there is a list of different locations, each
1184 with a specified address range. */
1187 loclist_describe_location (struct symbol *symbol, CORE_ADDR addr,
1188 struct ui_file *stream)
1190 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
1191 CORE_ADDR low, high;
1192 gdb_byte *loc_ptr, *buf_end;
1193 int length, first = 1;
1194 struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
1195 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1196 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1197 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
1198 CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
1199 /* Adjust base_address for relocatable objects. */
1200 CORE_ADDR base_offset = ANOFFSET (objfile->section_offsets,
1201 SECT_OFF_TEXT (objfile));
1202 CORE_ADDR base_address = dlbaton->base_address + base_offset;
1204 loc_ptr = dlbaton->data;
1205 buf_end = dlbaton->data + dlbaton->size;
1207 fprintf_filtered (stream, _("multi-location ("));
1209 /* Iterate through locations until we run out. */
1212 if (buf_end - loc_ptr < 2 * addr_size)
1213 error (_("Corrupted DWARF expression for symbol \"%s\"."),
1214 SYMBOL_PRINT_NAME (symbol));
1216 low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
1217 loc_ptr += addr_size;
1219 /* A base-address-selection entry. */
1220 if (low == base_mask)
1222 base_address = dwarf2_read_address (gdbarch,
1223 loc_ptr, buf_end, addr_size);
1224 fprintf_filtered (stream, _("[base address %s]"),
1225 paddress (gdbarch, base_address));
1226 loc_ptr += addr_size;
1230 high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
1231 loc_ptr += addr_size;
1233 /* An end-of-list entry. */
1234 if (low == 0 && high == 0)
1236 /* Indicate the end of the list, for readability. */
1237 fprintf_filtered (stream, _(")"));
1241 /* Otherwise, a location expression entry. */
1242 low += base_address;
1243 high += base_address;
1245 length = extract_unsigned_integer (loc_ptr, 2, byte_order);
1248 /* Separate the different locations with a semicolon. */
1252 fprintf_filtered (stream, _("; "));
1254 /* (It would improve readability to print only the minimum
1255 necessary digits of the second number of the range.) */
1256 fprintf_filtered (stream, _("range %s-%s, "),
1257 paddress (gdbarch, low), paddress (gdbarch, high));
1259 /* Now describe this particular location. */
1260 locexpr_describe_location_1 (symbol, low, stream, loc_ptr, length,
1261 objfile, addr_size);
1267 /* Describe the location of SYMBOL as an agent value in VALUE, generating
1268 any necessary bytecode in AX. */
1270 loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
1271 struct agent_expr *ax, struct axs_value *value)
1273 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
1277 data = find_location_expression (dlbaton, &size, ax->scope);
1279 dwarf2_tracepoint_var_ref (symbol, gdbarch, ax, value, data, size);
1282 /* The set of location functions used with the DWARF-2 expression
1283 evaluator and location lists. */
1284 const struct symbol_computed_ops dwarf2_loclist_funcs = {
1285 loclist_read_variable,
1286 loclist_read_needs_frame,
1287 loclist_describe_location,
1288 loclist_tracepoint_var_ref