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 VAR in the context
418 static struct value
*
419 dwarf2_evaluate_loc_desc (struct symbol
*var
, struct frame_info
*frame
,
420 gdb_byte
*data
, unsigned short size
,
421 struct dwarf2_per_cu_data
*per_cu
)
423 struct value
*retval
;
424 struct dwarf_expr_baton baton
;
425 struct dwarf_expr_context
*ctx
;
426 struct cleanup
*old_chain
;
430 retval
= allocate_value (SYMBOL_TYPE (var
));
431 VALUE_LVAL (retval
) = not_lval
;
432 set_value_optimized_out (retval
, 1);
437 baton
.objfile
= dwarf2_per_cu_objfile (per_cu
);
439 ctx
= new_dwarf_expr_context ();
440 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
442 ctx
->gdbarch
= get_objfile_arch (baton
.objfile
);
443 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
445 ctx
->read_reg
= dwarf_expr_read_reg
;
446 ctx
->read_mem
= dwarf_expr_read_mem
;
447 ctx
->get_frame_base
= dwarf_expr_frame_base
;
448 ctx
->get_frame_cfa
= dwarf_expr_frame_cfa
;
449 ctx
->get_tls_address
= dwarf_expr_tls_address
;
451 dwarf_expr_eval (ctx
, data
, size
);
452 if (ctx
->num_pieces
> 0)
454 struct piece_closure
*c
;
455 struct frame_id frame_id
= get_frame_id (frame
);
457 c
= allocate_piece_closure (ctx
->num_pieces
, ctx
->pieces
,
459 retval
= allocate_computed_value (SYMBOL_TYPE (var
),
462 VALUE_FRAME_ID (retval
) = frame_id
;
466 switch (ctx
->location
)
468 case DWARF_VALUE_REGISTER
:
470 struct gdbarch
*arch
= get_frame_arch (frame
);
471 CORE_ADDR dwarf_regnum
= dwarf_expr_fetch (ctx
, 0);
472 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
473 if (gdb_regnum
!= -1)
475 retval
= value_from_register (SYMBOL_TYPE (var
),
480 error (_("Unable to access DWARF register number %s"),
481 paddress (arch
, dwarf_regnum
));
486 case DWARF_VALUE_MEMORY
:
488 CORE_ADDR address
= dwarf_expr_fetch (ctx
, 0);
489 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
491 retval
= allocate_value (SYMBOL_TYPE (var
));
492 VALUE_LVAL (retval
) = lval_memory
;
493 set_value_lazy (retval
, 1);
495 set_value_stack (retval
, 1);
496 set_value_address (retval
, address
);
500 case DWARF_VALUE_STACK
:
502 ULONGEST value
= (ULONGEST
) dwarf_expr_fetch (ctx
, 0);
504 size_t n
= ctx
->addr_size
;
506 retval
= allocate_value (SYMBOL_TYPE (var
));
507 contents
= value_contents_raw (retval
);
508 if (n
> TYPE_LENGTH (SYMBOL_TYPE (var
)))
509 n
= TYPE_LENGTH (SYMBOL_TYPE (var
));
510 store_unsigned_integer (contents
, n
,
511 gdbarch_byte_order (ctx
->gdbarch
),
516 case DWARF_VALUE_LITERAL
:
521 retval
= allocate_value (SYMBOL_TYPE (var
));
522 contents
= value_contents_raw (retval
);
523 if (n
> TYPE_LENGTH (SYMBOL_TYPE (var
)))
524 n
= TYPE_LENGTH (SYMBOL_TYPE (var
));
525 memcpy (contents
, ctx
->data
, n
);
530 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
534 set_value_initialized (retval
, ctx
->initialized
);
536 do_cleanups (old_chain
);
541 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
543 struct needs_frame_baton
548 /* Reads from registers do require a frame. */
550 needs_frame_read_reg (void *baton
, int regnum
)
552 struct needs_frame_baton
*nf_baton
= baton
;
553 nf_baton
->needs_frame
= 1;
557 /* Reads from memory do not require a frame. */
559 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
561 memset (buf
, 0, len
);
564 /* Frame-relative accesses do require a frame. */
566 needs_frame_frame_base (void *baton
, gdb_byte
**start
, size_t * length
)
568 static gdb_byte lit0
= DW_OP_lit0
;
569 struct needs_frame_baton
*nf_baton
= baton
;
574 nf_baton
->needs_frame
= 1;
577 /* CFA accesses require a frame. */
580 needs_frame_frame_cfa (void *baton
)
582 struct needs_frame_baton
*nf_baton
= baton
;
583 nf_baton
->needs_frame
= 1;
587 /* Thread-local accesses do require a frame. */
589 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
591 struct needs_frame_baton
*nf_baton
= baton
;
592 nf_baton
->needs_frame
= 1;
596 /* Return non-zero iff the location expression at DATA (length SIZE)
597 requires a frame to evaluate. */
600 dwarf2_loc_desc_needs_frame (gdb_byte
*data
, unsigned short size
,
601 struct dwarf2_per_cu_data
*per_cu
)
603 struct needs_frame_baton baton
;
604 struct dwarf_expr_context
*ctx
;
606 struct cleanup
*old_chain
;
608 baton
.needs_frame
= 0;
610 ctx
= new_dwarf_expr_context ();
611 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
613 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (per_cu
));
614 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
616 ctx
->read_reg
= needs_frame_read_reg
;
617 ctx
->read_mem
= needs_frame_read_mem
;
618 ctx
->get_frame_base
= needs_frame_frame_base
;
619 ctx
->get_frame_cfa
= needs_frame_frame_cfa
;
620 ctx
->get_tls_address
= needs_frame_tls_address
;
622 dwarf_expr_eval (ctx
, data
, size
);
624 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
626 if (ctx
->num_pieces
> 0)
630 /* If the location has several pieces, and any of them are in
631 registers, then we will need a frame to fetch them from. */
632 for (i
= 0; i
< ctx
->num_pieces
; i
++)
633 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
637 do_cleanups (old_chain
);
639 return baton
.needs_frame
|| in_reg
;
642 /* This struct keeps track of the pieces that make up a multi-location
643 object, for use in agent expression generation. It is
644 superficially similar to struct dwarf_expr_piece, but
645 dwarf_expr_piece is designed for use in immediate evaluation, and
646 does not, for example, have a way to record both base register and
651 /* Memory vs register, etc */
652 enum axs_lvalue_kind kind
;
654 /* If non-zero, number of bytes in this fragment */
657 /* (GDB-numbered) reg, or base reg if >= 0 */
660 /* offset from reg */
665 dwarf2_tracepoint_var_loc (struct symbol
*symbol
,
666 struct agent_expr
*ax
,
667 struct axs_var_loc
*loc
,
668 struct gdbarch
*gdbarch
,
669 gdb_byte
*data
, gdb_byte
*end
)
671 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
673 loc
->kind
= axs_lvalue_register
;
674 loc
->reg
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, data
[0] - DW_OP_reg0
);
677 else if (data
[0] == DW_OP_regx
)
680 data
= read_uleb128 (data
+ 1, end
, ®
);
681 loc
->kind
= axs_lvalue_register
;
682 loc
->reg
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
);
684 else if (data
[0] == DW_OP_fbreg
)
687 struct symbol
*framefunc
;
689 LONGEST frame_offset
;
692 LONGEST base_offset
= 0;
694 b
= block_for_pc (ax
->scope
);
697 error (_("No block found for address"));
699 framefunc
= block_linkage_function (b
);
702 error (_("No function found for block"));
704 dwarf_expr_frame_base_1 (framefunc
, ax
->scope
,
705 &base_data
, &base_size
);
707 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
711 frame_reg
= base_data
[0] - DW_OP_breg0
;
712 buf_end
= read_sleb128 (base_data
+ 1,
713 base_data
+ base_size
, &base_offset
);
714 if (buf_end
!= base_data
+ base_size
)
715 error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
716 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
718 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
720 /* The frame base is just the register, with no offset. */
721 frame_reg
= base_data
[0] - DW_OP_reg0
;
726 /* We don't know what to do with the frame base expression,
727 so we can't trace this variable; give up. */
728 error (_("Cannot generate expression to collect symbol \"%s\"; DWARF 2 encoding not handled, first opcode in base data is 0x%x."),
729 SYMBOL_PRINT_NAME (symbol
), base_data
[0]);
732 data
= read_sleb128 (data
+ 1, end
, &frame_offset
);
734 loc
->kind
= axs_lvalue_memory
;
735 loc
->reg
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, frame_reg
);
736 loc
->offset
= base_offset
+ frame_offset
;
738 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
)
743 reg
= data
[0] - DW_OP_breg0
;
744 data
= read_sleb128 (data
+ 1, end
, &offset
);
746 loc
->kind
= axs_lvalue_memory
;
747 loc
->reg
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
);
748 loc
->offset
= offset
;
751 error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
752 data
[0], SYMBOL_PRINT_NAME (symbol
));
757 /* Given the location of a piece, issue bytecodes that will access it. */
760 dwarf2_tracepoint_var_access (struct agent_expr
*ax
,
761 struct axs_value
*value
,
762 struct axs_var_loc
*loc
)
764 value
->kind
= loc
->kind
;
768 case axs_lvalue_register
:
769 value
->u
.reg
= loc
->reg
;
772 case axs_lvalue_memory
:
773 ax_reg (ax
, loc
->reg
);
776 ax_const_l (ax
, loc
->offset
);
777 ax_simple (ax
, aop_add
);
782 internal_error (__FILE__
, __LINE__
, _("Unhandled value kind in dwarf2_tracepoint_var_access"));
787 dwarf2_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
788 struct agent_expr
*ax
, struct axs_value
*value
,
789 gdb_byte
*data
, int size
)
791 gdb_byte
*end
= data
+ size
;
792 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
793 /* In practice, a variable is not going to be spread across
794 dozens of registers or memory locations. If someone comes up
795 with a real-world example, revisit this. */
797 struct axs_var_loc fragments
[MAX_FRAGS
];
798 int nfrags
= 0, frag
;
804 if (!data
|| size
== 0)
806 value
->optimized_out
= 1;
814 if (nfrags
== MAX_FRAGS
)
815 error (_("Too many pieces in location for \"%s\"."),
816 SYMBOL_PRINT_NAME (symbol
));
818 fragments
[nfrags
].bytes
= 0;
819 data
= dwarf2_tracepoint_var_loc (symbol
, ax
, &fragments
[nfrags
],
824 else if (data
[0] == DW_OP_piece
)
828 data
= read_uleb128 (data
+ 1, end
, &bytes
);
829 /* Only deal with 4 byte fragments for now. */
831 error (_("DW_OP_piece %s not supported in location for \"%s\"."),
832 pulongest (bytes
), SYMBOL_PRINT_NAME (symbol
));
833 fragments
[nfrags
- 1].bytes
= bytes
;
844 if (bad
|| data
> end
)
845 error (_("Corrupted DWARF expression for \"%s\"."),
846 SYMBOL_PRINT_NAME (symbol
));
848 /* If single expression, no pieces, convert to external format. */
851 dwarf2_tracepoint_var_access (ax
, value
, &fragments
[0]);
855 if (length
!= TYPE_LENGTH (value
->type
))
856 error (_("Inconsistent piece information for \"%s\"."),
857 SYMBOL_PRINT_NAME (symbol
));
859 /* Emit bytecodes to assemble the pieces into a single stack entry. */
861 for ((frag
= (byte_order
== BFD_ENDIAN_BIG
? 0 : nfrags
- 1));
863 (frag
+= (byte_order
== BFD_ENDIAN_BIG
? 1 : -1)))
867 /* shift the previous fragment up 32 bits */
869 ax_simple (ax
, aop_lsh
);
872 dwarf2_tracepoint_var_access (ax
, value
, &fragments
[frag
]);
876 case axs_lvalue_register
:
877 ax_reg (ax
, value
->u
.reg
);
880 case axs_lvalue_memory
:
882 extern int trace_kludge
; /* Ugh. */
884 gdb_assert (fragments
[frag
].bytes
== 4);
886 ax_trace_quick (ax
, 4);
887 ax_simple (ax
, aop_ref32
);
894 /* or the new fragment into the previous */
895 ax_zero_ext (ax
, 32);
896 ax_simple (ax
, aop_bit_or
);
900 value
->kind
= axs_rvalue
;
904 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
905 evaluator to calculate the location. */
906 static struct value
*
907 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
909 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
911 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, dlbaton
->data
, dlbaton
->size
,
917 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
919 locexpr_read_needs_frame (struct symbol
*symbol
)
921 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
922 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
926 /* Describe a single piece of a location, returning an updated
927 position in the bytecode sequence. */
930 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
931 CORE_ADDR addr
, struct objfile
*objfile
,
932 gdb_byte
*data
, int size
, unsigned int addr_size
)
934 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
937 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
939 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, data
[0] - DW_OP_reg0
);
940 fprintf_filtered (stream
, _("a variable in $%s"),
941 gdbarch_register_name (gdbarch
, regno
));
944 else if (data
[0] == DW_OP_regx
)
948 data
= read_uleb128 (data
+ 1, data
+ size
, ®
);
949 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
);
950 fprintf_filtered (stream
, _("a variable in $%s"),
951 gdbarch_register_name (gdbarch
, regno
));
953 else if (data
[0] == DW_OP_fbreg
)
956 struct symbol
*framefunc
;
958 LONGEST frame_offset
;
961 LONGEST base_offset
= 0;
963 b
= block_for_pc (addr
);
966 error (_("No block found for address for symbol \"%s\"."),
967 SYMBOL_PRINT_NAME (symbol
));
969 framefunc
= block_linkage_function (b
);
972 error (_("No function found for block for symbol \"%s\"."),
973 SYMBOL_PRINT_NAME (symbol
));
975 dwarf_expr_frame_base_1 (framefunc
, addr
, &base_data
, &base_size
);
977 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
981 frame_reg
= base_data
[0] - DW_OP_breg0
;
982 buf_end
= read_sleb128 (base_data
+ 1,
983 base_data
+ base_size
, &base_offset
);
984 if (buf_end
!= base_data
+ base_size
)
985 error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
986 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
988 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
990 /* The frame base is just the register, with no offset. */
991 frame_reg
= base_data
[0] - DW_OP_reg0
;
996 /* We don't know what to do with the frame base expression,
997 so we can't trace this variable; give up. */
998 error (_("Cannot describe location of symbol \"%s\"; "
999 "DWARF 2 encoding not handled, "
1000 "first opcode in base data is 0x%x."),
1001 SYMBOL_PRINT_NAME (symbol
), base_data
[0]);
1004 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, frame_reg
);
1006 data
= read_sleb128 (data
+ 1, data
+ size
, &frame_offset
);
1008 fprintf_filtered (stream
, _("a variable at frame base reg $%s offset %s+%s"),
1009 gdbarch_register_name (gdbarch
, regno
),
1010 plongest (base_offset
), plongest (frame_offset
));
1012 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
)
1016 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, data
[0] - DW_OP_breg0
);
1018 data
= read_sleb128 (data
+ 1, data
+ size
, &offset
);
1020 fprintf_filtered (stream
,
1021 _("a variable at offset %s from base reg $%s"),
1023 gdbarch_register_name (gdbarch
, regno
));
1026 /* The location expression for a TLS variable looks like this (on a
1029 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
1030 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
1032 0x3 is the encoding for DW_OP_addr, which has an operand as long
1033 as the size of an address on the target machine (here is 8
1034 bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
1035 The operand represents the offset at which the variable is within
1036 the thread local storage. */
1039 && data
[size
- 1] == DW_OP_GNU_push_tls_address
1040 && data
[0] == DW_OP_addr
)
1042 CORE_ADDR offset
= dwarf2_read_address (gdbarch
,
1046 fprintf_filtered (stream
,
1047 _("a thread-local variable at offset %s "
1048 "in the thread-local storage for `%s'"),
1049 paddress (gdbarch
, offset
), objfile
->name
);
1051 data
+= 1 + addr_size
+ 1;
1054 fprintf_filtered (stream
,
1055 _("a variable with complex or multiple locations (DWARF2)"));
1060 /* Describe a single location, which may in turn consist of multiple
1064 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
1065 struct ui_file
*stream
, gdb_byte
*data
, int size
,
1066 struct objfile
*objfile
, unsigned int addr_size
)
1068 gdb_byte
*end
= data
+ size
;
1069 int piece_done
= 0, first_piece
= 1, bad
= 0;
1071 /* A multi-piece description consists of multiple sequences of bytes
1072 each followed by DW_OP_piece + length of piece. */
1080 fprintf_filtered (stream
, _(", and "));
1082 data
= locexpr_describe_location_piece (symbol
, stream
, addr
, objfile
,
1083 data
, size
, addr_size
);
1086 else if (data
[0] == DW_OP_piece
)
1090 data
= read_uleb128 (data
+ 1, end
, &bytes
);
1092 fprintf_filtered (stream
, _(" [%s-byte piece]"), pulongest (bytes
));
1103 if (bad
|| data
> end
)
1104 error (_("Corrupted DWARF2 expression for \"%s\"."),
1105 SYMBOL_PRINT_NAME (symbol
));
1108 /* Print a natural-language description of SYMBOL to STREAM. This
1109 version is for a symbol with a single location. */
1112 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
1113 struct ui_file
*stream
)
1115 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
1116 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
1117 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
1119 locexpr_describe_location_1 (symbol
, addr
, stream
, dlbaton
->data
, dlbaton
->size
,
1120 objfile
, addr_size
);
1123 /* Describe the location of SYMBOL as an agent value in VALUE, generating
1124 any necessary bytecode in AX. */
1127 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
1128 struct agent_expr
*ax
, struct axs_value
*value
)
1130 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
1132 dwarf2_tracepoint_var_ref (symbol
, gdbarch
, ax
, value
,
1133 dlbaton
->data
, dlbaton
->size
);
1136 /* The set of location functions used with the DWARF-2 expression
1138 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
1139 locexpr_read_variable
,
1140 locexpr_read_needs_frame
,
1141 locexpr_describe_location
,
1142 locexpr_tracepoint_var_ref
1146 /* Wrapper functions for location lists. These generally find
1147 the appropriate location expression and call something above. */
1149 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
1150 evaluator to calculate the location. */
1151 static struct value
*
1152 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
1154 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
1159 data
= find_location_expression (dlbaton
, &size
,
1160 frame
? get_frame_address_in_block (frame
)
1164 val
= allocate_value (SYMBOL_TYPE (symbol
));
1165 VALUE_LVAL (val
) = not_lval
;
1166 set_value_optimized_out (val
, 1);
1169 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, data
, size
,
1175 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
1177 loclist_read_needs_frame (struct symbol
*symbol
)
1179 /* If there's a location list, then assume we need to have a frame
1180 to choose the appropriate location expression. With tracking of
1181 global variables this is not necessarily true, but such tracking
1182 is disabled in GCC at the moment until we figure out how to
1188 /* Print a natural-language description of SYMBOL to STREAM. This
1189 version applies when there is a list of different locations, each
1190 with a specified address range. */
1193 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
1194 struct ui_file
*stream
)
1196 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
1197 CORE_ADDR low
, high
;
1198 gdb_byte
*loc_ptr
, *buf_end
;
1199 int length
, first
= 1;
1200 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
1201 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1202 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1203 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
1204 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
1205 /* Adjust base_address for relocatable objects. */
1206 CORE_ADDR base_offset
= ANOFFSET (objfile
->section_offsets
,
1207 SECT_OFF_TEXT (objfile
));
1208 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
1210 loc_ptr
= dlbaton
->data
;
1211 buf_end
= dlbaton
->data
+ dlbaton
->size
;
1213 fprintf_filtered (stream
, _("multi-location ("));
1215 /* Iterate through locations until we run out. */
1218 if (buf_end
- loc_ptr
< 2 * addr_size
)
1219 error (_("Corrupted DWARF expression for symbol \"%s\"."),
1220 SYMBOL_PRINT_NAME (symbol
));
1222 low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
1223 loc_ptr
+= addr_size
;
1225 /* A base-address-selection entry. */
1226 if (low
== base_mask
)
1228 base_address
= dwarf2_read_address (gdbarch
,
1229 loc_ptr
, buf_end
, addr_size
);
1230 fprintf_filtered (stream
, _("[base address %s]"),
1231 paddress (gdbarch
, base_address
));
1232 loc_ptr
+= addr_size
;
1236 high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
1237 loc_ptr
+= addr_size
;
1239 /* An end-of-list entry. */
1240 if (low
== 0 && high
== 0)
1242 /* Indicate the end of the list, for readability. */
1243 fprintf_filtered (stream
, _(")"));
1247 /* Otherwise, a location expression entry. */
1248 low
+= base_address
;
1249 high
+= base_address
;
1251 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
1254 /* Separate the different locations with a semicolon. */
1258 fprintf_filtered (stream
, _("; "));
1260 /* (It would improve readability to print only the minimum
1261 necessary digits of the second number of the range.) */
1262 fprintf_filtered (stream
, _("range %s-%s, "),
1263 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
1265 /* Now describe this particular location. */
1266 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
1267 objfile
, addr_size
);
1273 /* Describe the location of SYMBOL as an agent value in VALUE, generating
1274 any necessary bytecode in AX. */
1276 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
1277 struct agent_expr
*ax
, struct axs_value
*value
)
1279 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
1283 data
= find_location_expression (dlbaton
, &size
, ax
->scope
);
1285 dwarf2_tracepoint_var_ref (symbol
, gdbarch
, ax
, value
, data
, size
);
1288 /* The set of location functions used with the DWARF-2 expression
1289 evaluator and location lists. */
1290 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
1291 loclist_read_variable
,
1292 loclist_read_needs_frame
,
1293 loclist_describe_location
,
1294 loclist_tracepoint_var_ref