1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003, 2005, 2007 Free Software Foundation, Inc.
5 Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or (at
12 your option) any later version.
14 This program is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
35 #include "exceptions.h"
37 #include "elf/dwarf2.h"
38 #include "dwarf2expr.h"
39 #include "dwarf2loc.h"
41 #include "gdb_string.h"
43 /* A helper function for dealing with location lists. Given a
44 symbol baton (BATON) and a pc value (PC), find the appropriate
45 location expression, set *LOCEXPR_LENGTH, and return a pointer
46 to the beginning of the expression. Returns NULL on failure.
48 For now, only return the first matching location expression; there
49 can be more than one in the list. */
52 find_location_expression (struct dwarf2_loclist_baton
*baton
,
53 size_t *locexpr_length
, CORE_ADDR pc
)
56 gdb_byte
*loc_ptr
, *buf_end
;
58 unsigned int addr_size
= gdbarch_addr_bit (current_gdbarch
) / TARGET_CHAR_BIT
;
59 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
60 /* Adjust base_address for relocatable objects. */
61 CORE_ADDR base_offset
= ANOFFSET (baton
->objfile
->section_offsets
,
62 SECT_OFF_TEXT (baton
->objfile
));
63 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
65 loc_ptr
= baton
->data
;
66 buf_end
= baton
->data
+ baton
->size
;
70 low
= dwarf2_read_address (loc_ptr
, buf_end
, &length
);
72 high
= dwarf2_read_address (loc_ptr
, buf_end
, &length
);
75 /* An end-of-list entry. */
76 if (low
== 0 && high
== 0)
79 /* A base-address-selection entry. */
80 if ((low
& base_mask
) == base_mask
)
86 /* Otherwise, a location expression entry. */
90 length
= extract_unsigned_integer (loc_ptr
, 2);
93 if (pc
>= low
&& pc
< high
)
95 *locexpr_length
= length
;
103 /* This is the baton used when performing dwarf2 expression
105 struct dwarf_expr_baton
107 struct frame_info
*frame
;
108 struct objfile
*objfile
;
111 /* Helper functions for dwarf2_evaluate_loc_desc. */
113 /* Using the frame specified in BATON, return the value of register
114 REGNUM, treated as a pointer. */
116 dwarf_expr_read_reg (void *baton
, int dwarf_regnum
)
118 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
122 regnum
= gdbarch_dwarf2_reg_to_regnum (current_gdbarch
, dwarf_regnum
);
123 result
= address_from_register (builtin_type_void_data_ptr
,
124 regnum
, debaton
->frame
);
128 /* Read memory at ADDR (length LEN) into BUF. */
131 dwarf_expr_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
133 read_memory (addr
, buf
, len
);
136 /* Using the frame specified in BATON, find the location expression
137 describing the frame base. Return a pointer to it in START and
138 its length in LENGTH. */
140 dwarf_expr_frame_base (void *baton
, gdb_byte
**start
, size_t * length
)
142 /* FIXME: cagney/2003-03-26: This code should be using
143 get_frame_base_address(), and then implement a dwarf2 specific
145 struct symbol
*framefunc
;
146 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
148 framefunc
= get_frame_function (debaton
->frame
);
150 if (SYMBOL_OPS (framefunc
) == &dwarf2_loclist_funcs
)
152 struct dwarf2_loclist_baton
*symbaton
;
153 struct frame_info
*frame
= debaton
->frame
;
155 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
156 *start
= find_location_expression (symbaton
, length
,
157 get_frame_address_in_block (frame
));
161 struct dwarf2_locexpr_baton
*symbaton
;
162 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
163 *length
= symbaton
->size
;
164 *start
= symbaton
->data
;
168 error (_("Could not find the frame base for \"%s\"."),
169 SYMBOL_NATURAL_NAME (framefunc
));
172 /* Using the objfile specified in BATON, find the address for the
173 current thread's thread-local storage with offset OFFSET. */
175 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
177 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
179 return target_translate_tls_address (debaton
->objfile
, offset
);
182 /* Evaluate a location description, starting at DATA and with length
183 SIZE, to find the current location of variable VAR in the context
185 static struct value
*
186 dwarf2_evaluate_loc_desc (struct symbol
*var
, struct frame_info
*frame
,
187 gdb_byte
*data
, unsigned short size
,
188 struct objfile
*objfile
)
190 struct gdbarch
*arch
= get_frame_arch (frame
);
191 struct value
*retval
;
192 struct dwarf_expr_baton baton
;
193 struct dwarf_expr_context
*ctx
;
197 retval
= allocate_value (SYMBOL_TYPE (var
));
198 VALUE_LVAL (retval
) = not_lval
;
199 set_value_optimized_out (retval
, 1);
204 baton
.objfile
= objfile
;
206 ctx
= new_dwarf_expr_context ();
208 ctx
->read_reg
= dwarf_expr_read_reg
;
209 ctx
->read_mem
= dwarf_expr_read_mem
;
210 ctx
->get_frame_base
= dwarf_expr_frame_base
;
211 ctx
->get_tls_address
= dwarf_expr_tls_address
;
213 dwarf_expr_eval (ctx
, data
, size
);
214 if (ctx
->num_pieces
> 0)
220 retval
= allocate_value (SYMBOL_TYPE (var
));
221 contents
= value_contents_raw (retval
);
222 for (i
= 0; i
< ctx
->num_pieces
; i
++)
224 struct dwarf_expr_piece
*p
= &ctx
->pieces
[i
];
227 bfd_byte regval
[MAX_REGISTER_SIZE
];
228 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum
229 (current_gdbarch
, p
->value
);
230 get_frame_register (frame
, gdb_regnum
, regval
);
231 memcpy (contents
+ offset
, regval
, p
->size
);
233 else /* In memory? */
235 read_memory (p
->value
, contents
+ offset
, p
->size
);
240 else if (ctx
->in_reg
)
242 CORE_ADDR dwarf_regnum
= dwarf_expr_fetch (ctx
, 0);
243 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum
244 (current_gdbarch
, dwarf_regnum
);
245 retval
= value_from_register (SYMBOL_TYPE (var
), gdb_regnum
, frame
);
249 CORE_ADDR address
= dwarf_expr_fetch (ctx
, 0);
251 retval
= allocate_value (SYMBOL_TYPE (var
));
252 VALUE_LVAL (retval
) = lval_memory
;
253 set_value_lazy (retval
, 1);
254 VALUE_ADDRESS (retval
) = address
;
257 set_value_initialized (retval
, ctx
->initialized
);
259 free_dwarf_expr_context (ctx
);
268 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
270 struct needs_frame_baton
275 /* Reads from registers do require a frame. */
277 needs_frame_read_reg (void *baton
, int regnum
)
279 struct needs_frame_baton
*nf_baton
= baton
;
280 nf_baton
->needs_frame
= 1;
284 /* Reads from memory do not require a frame. */
286 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
288 memset (buf
, 0, len
);
291 /* Frame-relative accesses do require a frame. */
293 needs_frame_frame_base (void *baton
, gdb_byte
**start
, size_t * length
)
295 static gdb_byte lit0
= DW_OP_lit0
;
296 struct needs_frame_baton
*nf_baton
= baton
;
301 nf_baton
->needs_frame
= 1;
304 /* Thread-local accesses do require a frame. */
306 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
308 struct needs_frame_baton
*nf_baton
= baton
;
309 nf_baton
->needs_frame
= 1;
313 /* Return non-zero iff the location expression at DATA (length SIZE)
314 requires a frame to evaluate. */
317 dwarf2_loc_desc_needs_frame (gdb_byte
*data
, unsigned short size
)
319 struct needs_frame_baton baton
;
320 struct dwarf_expr_context
*ctx
;
323 baton
.needs_frame
= 0;
325 ctx
= new_dwarf_expr_context ();
327 ctx
->read_reg
= needs_frame_read_reg
;
328 ctx
->read_mem
= needs_frame_read_mem
;
329 ctx
->get_frame_base
= needs_frame_frame_base
;
330 ctx
->get_tls_address
= needs_frame_tls_address
;
332 dwarf_expr_eval (ctx
, data
, size
);
334 in_reg
= ctx
->in_reg
;
336 if (ctx
->num_pieces
> 0)
340 /* If the location has several pieces, and any of them are in
341 registers, then we will need a frame to fetch them from. */
342 for (i
= 0; i
< ctx
->num_pieces
; i
++)
343 if (ctx
->pieces
[i
].in_reg
)
347 free_dwarf_expr_context (ctx
);
349 return baton
.needs_frame
|| in_reg
;
353 dwarf2_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
354 struct axs_value
*value
, gdb_byte
*data
,
358 error (_("Symbol \"%s\" has been optimized out."),
359 SYMBOL_PRINT_NAME (symbol
));
362 && data
[0] >= DW_OP_reg0
363 && data
[0] <= DW_OP_reg31
)
365 value
->kind
= axs_lvalue_register
;
366 value
->u
.reg
= data
[0] - DW_OP_reg0
;
368 else if (data
[0] == DW_OP_regx
)
371 read_uleb128 (data
+ 1, data
+ size
, ®
);
372 value
->kind
= axs_lvalue_register
;
375 else if (data
[0] == DW_OP_fbreg
)
377 /* And this is worse than just minimal; we should honor the frame base
380 LONGEST frame_offset
;
383 buf_end
= read_sleb128 (data
+ 1, data
+ size
, &frame_offset
);
384 if (buf_end
!= data
+ size
)
385 error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
386 SYMBOL_PRINT_NAME (symbol
));
388 gdbarch_virtual_frame_pointer (current_gdbarch
,
389 ax
->scope
, &frame_reg
, &frame_offset
);
390 ax_reg (ax
, frame_reg
);
391 ax_const_l (ax
, frame_offset
);
392 ax_simple (ax
, aop_add
);
394 value
->kind
= axs_lvalue_memory
;
396 else if (data
[0] >= DW_OP_breg0
397 && data
[0] <= DW_OP_breg31
)
403 reg
= data
[0] - DW_OP_breg0
;
404 buf_end
= read_sleb128 (data
+ 1, data
+ size
, &offset
);
405 if (buf_end
!= data
+ size
)
406 error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
407 reg
, SYMBOL_PRINT_NAME (symbol
));
410 ax_const_l (ax
, offset
);
411 ax_simple (ax
, aop_add
);
413 value
->kind
= axs_lvalue_memory
;
416 error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
417 data
[0], SYMBOL_PRINT_NAME (symbol
));
420 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
421 evaluator to calculate the location. */
422 static struct value
*
423 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
425 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
427 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, dlbaton
->data
, dlbaton
->size
,
433 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
435 locexpr_read_needs_frame (struct symbol
*symbol
)
437 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
438 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
);
441 /* Print a natural-language description of SYMBOL to STREAM. */
443 locexpr_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
445 /* FIXME: be more extensive. */
446 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
448 if (dlbaton
->size
== 1
449 && dlbaton
->data
[0] >= DW_OP_reg0
450 && dlbaton
->data
[0] <= DW_OP_reg31
)
452 int regno
= gdbarch_dwarf2_reg_to_regnum
453 (current_gdbarch
, dlbaton
->data
[0] - DW_OP_reg0
);
454 fprintf_filtered (stream
,
455 "a variable in register %s",
456 gdbarch_register_name (current_gdbarch
, regno
));
460 /* The location expression for a TLS variable looks like this (on a
463 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
464 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
466 0x3 is the encoding for DW_OP_addr, which has an operand as long
467 as the size of an address on the target machine (here is 8
468 bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
469 The operand represents the offset at which the variable is within
470 the thread local storage. */
472 if (dlbaton
->size
> 1
473 && dlbaton
->data
[dlbaton
->size
- 1] == DW_OP_GNU_push_tls_address
)
474 if (dlbaton
->data
[0] == DW_OP_addr
)
477 CORE_ADDR offset
= dwarf2_read_address (&dlbaton
->data
[1],
478 &dlbaton
->data
[dlbaton
->size
- 1],
480 fprintf_filtered (stream
,
481 "a thread-local variable at offset %s in the "
482 "thread-local storage for `%s'",
483 paddr_nz (offset
), dlbaton
->objfile
->name
);
488 fprintf_filtered (stream
,
489 "a variable with complex or multiple locations (DWARF2)");
494 /* Describe the location of SYMBOL as an agent value in VALUE, generating
495 any necessary bytecode in AX.
497 NOTE drow/2003-02-26: This function is extremely minimal, because
498 doing it correctly is extremely complicated and there is no
499 publicly available stub with tracepoint support for me to test
500 against. When there is one this function should be revisited. */
503 locexpr_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
504 struct axs_value
* value
)
506 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
508 dwarf2_tracepoint_var_ref (symbol
, ax
, value
, dlbaton
->data
, dlbaton
->size
);
511 /* The set of location functions used with the DWARF-2 expression
513 const struct symbol_ops dwarf2_locexpr_funcs
= {
514 locexpr_read_variable
,
515 locexpr_read_needs_frame
,
516 locexpr_describe_location
,
517 locexpr_tracepoint_var_ref
521 /* Wrapper functions for location lists. These generally find
522 the appropriate location expression and call something above. */
524 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
525 evaluator to calculate the location. */
526 static struct value
*
527 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
529 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
534 data
= find_location_expression (dlbaton
, &size
,
535 frame
? get_frame_address_in_block (frame
)
539 val
= allocate_value (SYMBOL_TYPE (symbol
));
540 VALUE_LVAL (val
) = not_lval
;
541 set_value_optimized_out (val
, 1);
544 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, data
, size
,
550 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
552 loclist_read_needs_frame (struct symbol
*symbol
)
554 /* If there's a location list, then assume we need to have a frame
555 to choose the appropriate location expression. With tracking of
556 global variables this is not necessarily true, but such tracking
557 is disabled in GCC at the moment until we figure out how to
563 /* Print a natural-language description of SYMBOL to STREAM. */
565 loclist_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
567 /* FIXME: Could print the entire list of locations. */
568 fprintf_filtered (stream
, "a variable with multiple locations");
572 /* Describe the location of SYMBOL as an agent value in VALUE, generating
573 any necessary bytecode in AX. */
575 loclist_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
576 struct axs_value
* value
)
578 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
582 data
= find_location_expression (dlbaton
, &size
, ax
->scope
);
584 error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol
));
586 dwarf2_tracepoint_var_ref (symbol
, ax
, value
, data
, size
);
589 /* The set of location functions used with the DWARF-2 expression
590 evaluator and location lists. */
591 const struct symbol_ops dwarf2_loclist_funcs
= {
592 loclist_read_variable
,
593 loclist_read_needs_frame
,
594 loclist_describe_location
,
595 loclist_tracepoint_var_ref