1 /* DWARF 2 location expression support for GDB.
3 Copyright 2003, 2005 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., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
36 #include "elf/dwarf2.h"
37 #include "dwarf2expr.h"
38 #include "dwarf2loc.h"
40 #include "gdb_string.h"
42 #ifndef DWARF2_REG_TO_REGNUM
43 #define DWARF2_REG_TO_REGNUM(REG) (REG)
46 /* A helper function for dealing with location lists. Given a
47 symbol baton (BATON) and a pc value (PC), find the appropriate
48 location expression, set *LOCEXPR_LENGTH, and return a pointer
49 to the beginning of the expression. Returns NULL on failure.
51 For now, only return the first matching location expression; there
52 can be more than one in the list. */
55 find_location_expression (struct dwarf2_loclist_baton
*baton
,
56 size_t *locexpr_length
, CORE_ADDR pc
)
59 char *loc_ptr
, *buf_end
;
60 unsigned int addr_size
= TARGET_ADDR_BIT
/ TARGET_CHAR_BIT
, length
;
61 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
62 /* Adjust base_address for relocatable objects. */
63 CORE_ADDR base_offset
= ANOFFSET (baton
->objfile
->section_offsets
,
64 SECT_OFF_TEXT (baton
->objfile
));
65 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
67 loc_ptr
= baton
->data
;
68 buf_end
= baton
->data
+ baton
->size
;
72 low
= dwarf2_read_address (loc_ptr
, buf_end
, &length
);
74 high
= dwarf2_read_address (loc_ptr
, buf_end
, &length
);
77 /* An end-of-list entry. */
78 if (low
== 0 && high
== 0)
81 /* A base-address-selection entry. */
82 if ((low
& base_mask
) == base_mask
)
88 /* Otherwise, a location expression entry. */
92 length
= extract_unsigned_integer (loc_ptr
, 2);
95 if (pc
>= low
&& pc
< high
)
97 *locexpr_length
= length
;
105 /* This is the baton used when performing dwarf2 expression
107 struct dwarf_expr_baton
109 struct frame_info
*frame
;
110 struct objfile
*objfile
;
113 /* Helper functions for dwarf2_evaluate_loc_desc. */
115 /* Using the frame specified in BATON, read register REGNUM. The lval
116 type will be returned in LVALP, and for lval_memory the register
117 save address will be returned in ADDRP. */
119 dwarf_expr_read_reg (void *baton
, int dwarf_regnum
)
121 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
122 CORE_ADDR result
, save_addr
;
123 enum lval_type lval_type
;
125 int optimized
, regnum
, realnum
, regsize
;
127 regnum
= DWARF2_REG_TO_REGNUM (dwarf_regnum
);
128 regsize
= register_size (current_gdbarch
, regnum
);
129 buf
= (char *) alloca (regsize
);
131 frame_register (debaton
->frame
, regnum
, &optimized
, &lval_type
, &save_addr
,
133 /* NOTE: cagney/2003-05-22: This extract is assuming that a DWARF 2
134 address is always unsigned. That may or may not be true. */
135 result
= extract_unsigned_integer (buf
, regsize
);
140 /* Read memory at ADDR (length LEN) into BUF. */
143 dwarf_expr_read_mem (void *baton
, char *buf
, CORE_ADDR addr
, size_t len
)
145 read_memory (addr
, buf
, len
);
148 /* Using the frame specified in BATON, find the location expression
149 describing the frame base. Return a pointer to it in START and
150 its length in LENGTH. */
152 dwarf_expr_frame_base (void *baton
, unsigned char **start
, size_t * length
)
154 /* FIXME: cagney/2003-03-26: This code should be using
155 get_frame_base_address(), and then implement a dwarf2 specific
157 struct symbol
*framefunc
;
158 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
160 framefunc
= get_frame_function (debaton
->frame
);
162 if (SYMBOL_OPS (framefunc
) == &dwarf2_loclist_funcs
)
164 struct dwarf2_loclist_baton
*symbaton
;
165 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
166 *start
= find_location_expression (symbaton
, length
,
167 get_frame_pc (debaton
->frame
));
171 struct dwarf2_locexpr_baton
*symbaton
;
172 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
173 *length
= symbaton
->size
;
174 *start
= symbaton
->data
;
178 error (_("Could not find the frame base for \"%s\"."),
179 SYMBOL_NATURAL_NAME (framefunc
));
182 /* Using the objfile specified in BATON, find the address for the
183 current thread's thread-local storage with offset OFFSET. */
185 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
187 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
190 if (target_get_thread_local_address_p ())
191 addr
= target_get_thread_local_address (inferior_ptid
,
194 /* It wouldn't be wrong here to try a gdbarch method, too; finding
195 TLS is an ABI-specific thing. But we don't do that yet. */
197 error (_("Cannot find thread-local variables on this target"));
202 /* Evaluate a location description, starting at DATA and with length
203 SIZE, to find the current location of variable VAR in the context
205 static struct value
*
206 dwarf2_evaluate_loc_desc (struct symbol
*var
, struct frame_info
*frame
,
207 unsigned char *data
, unsigned short size
,
208 struct objfile
*objfile
)
210 struct gdbarch
*arch
= get_frame_arch (frame
);
211 struct value
*retval
;
212 struct dwarf_expr_baton baton
;
213 struct dwarf_expr_context
*ctx
;
217 retval
= allocate_value (SYMBOL_TYPE (var
));
218 VALUE_LVAL (retval
) = not_lval
;
219 set_value_optimized_out (retval
, 1);
223 baton
.objfile
= objfile
;
225 ctx
= new_dwarf_expr_context ();
227 ctx
->read_reg
= dwarf_expr_read_reg
;
228 ctx
->read_mem
= dwarf_expr_read_mem
;
229 ctx
->get_frame_base
= dwarf_expr_frame_base
;
230 ctx
->get_tls_address
= dwarf_expr_tls_address
;
232 dwarf_expr_eval (ctx
, data
, size
);
233 if (ctx
->num_pieces
> 0)
235 /* We haven't implemented splicing together pieces from
236 arbitrary sources yet. */
237 error (_("The value of variable '%s' is distributed across several\n"
238 "locations, and GDB cannot access its value.\n"),
239 SYMBOL_NATURAL_NAME (var
));
241 else if (ctx
->in_reg
)
243 CORE_ADDR dwarf_regnum
= dwarf_expr_fetch (ctx
, 0);
244 int gdb_regnum
= DWARF2_REG_TO_REGNUM (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 free_dwarf_expr_context (ctx
);
266 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
268 struct needs_frame_baton
273 /* Reads from registers do require a frame. */
275 needs_frame_read_reg (void *baton
, int regnum
)
277 struct needs_frame_baton
*nf_baton
= baton
;
278 nf_baton
->needs_frame
= 1;
282 /* Reads from memory do not require a frame. */
284 needs_frame_read_mem (void *baton
, char *buf
, CORE_ADDR addr
, size_t len
)
286 memset (buf
, 0, len
);
289 /* Frame-relative accesses do require a frame. */
291 needs_frame_frame_base (void *baton
, unsigned char **start
, size_t * length
)
293 static char lit0
= DW_OP_lit0
;
294 struct needs_frame_baton
*nf_baton
= baton
;
299 nf_baton
->needs_frame
= 1;
302 /* Thread-local accesses do require a frame. */
304 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
306 struct needs_frame_baton
*nf_baton
= baton
;
307 nf_baton
->needs_frame
= 1;
311 /* Return non-zero iff the location expression at DATA (length SIZE)
312 requires a frame to evaluate. */
315 dwarf2_loc_desc_needs_frame (unsigned char *data
, unsigned short size
)
317 struct needs_frame_baton baton
;
318 struct dwarf_expr_context
*ctx
;
321 baton
.needs_frame
= 0;
323 ctx
= new_dwarf_expr_context ();
325 ctx
->read_reg
= needs_frame_read_reg
;
326 ctx
->read_mem
= needs_frame_read_mem
;
327 ctx
->get_frame_base
= needs_frame_frame_base
;
328 ctx
->get_tls_address
= needs_frame_tls_address
;
330 dwarf_expr_eval (ctx
, data
, size
);
332 in_reg
= ctx
->in_reg
;
334 if (ctx
->num_pieces
> 0)
338 /* If the location has several pieces, and any of them are in
339 registers, then we will need a frame to fetch them from. */
340 for (i
= 0; i
< ctx
->num_pieces
; i
++)
341 if (ctx
->pieces
[i
].in_reg
)
345 free_dwarf_expr_context (ctx
);
347 return baton
.needs_frame
|| in_reg
;
351 dwarf2_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
352 struct axs_value
* value
, unsigned char *data
,
356 error (_("Symbol \"%s\" has been optimized out."),
357 SYMBOL_PRINT_NAME (symbol
));
360 && data
[0] >= DW_OP_reg0
361 && data
[0] <= DW_OP_reg31
)
363 value
->kind
= axs_lvalue_register
;
364 value
->u
.reg
= data
[0] - DW_OP_reg0
;
366 else if (data
[0] == DW_OP_regx
)
369 read_uleb128 (data
+ 1, data
+ size
, ®
);
370 value
->kind
= axs_lvalue_register
;
373 else if (data
[0] == DW_OP_fbreg
)
375 /* And this is worse than just minimal; we should honor the frame base
378 LONGEST frame_offset
;
379 unsigned char *buf_end
;
381 buf_end
= read_sleb128 (data
+ 1, data
+ size
, &frame_offset
);
382 if (buf_end
!= data
+ size
)
383 error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
384 SYMBOL_PRINT_NAME (symbol
));
386 TARGET_VIRTUAL_FRAME_POINTER (ax
->scope
, &frame_reg
, &frame_offset
);
387 ax_reg (ax
, frame_reg
);
388 ax_const_l (ax
, frame_offset
);
389 ax_simple (ax
, aop_add
);
391 ax_const_l (ax
, frame_offset
);
392 ax_simple (ax
, aop_add
);
393 value
->kind
= axs_lvalue_memory
;
396 error (_("Unsupported DWARF opcode in the location of \"%s\"."),
397 SYMBOL_PRINT_NAME (symbol
));
400 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
401 evaluator to calculate the location. */
402 static struct value
*
403 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
405 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
407 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, dlbaton
->data
, dlbaton
->size
,
413 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
415 locexpr_read_needs_frame (struct symbol
*symbol
)
417 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
418 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
);
421 /* Print a natural-language description of SYMBOL to STREAM. */
423 locexpr_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
425 /* FIXME: be more extensive. */
426 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
428 if (dlbaton
->size
== 1
429 && dlbaton
->data
[0] >= DW_OP_reg0
430 && dlbaton
->data
[0] <= DW_OP_reg31
)
432 int regno
= DWARF2_REG_TO_REGNUM (dlbaton
->data
[0] - DW_OP_reg0
);
433 fprintf_filtered (stream
,
434 "a variable in register %s", REGISTER_NAME (regno
));
438 /* The location expression for a TLS variable looks like this (on a
441 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
442 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
444 0x3 is the encoding for DW_OP_addr, which has an operand as long
445 as the size of an address on the target machine (here is 8
446 bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
447 The operand represents the offset at which the variable is within
448 the thread local storage. */
450 if (dlbaton
->size
> 1
451 && dlbaton
->data
[dlbaton
->size
- 1] == DW_OP_GNU_push_tls_address
)
452 if (dlbaton
->data
[0] == DW_OP_addr
)
455 CORE_ADDR offset
= dwarf2_read_address (&dlbaton
->data
[1],
456 &dlbaton
->data
[dlbaton
->size
- 1],
458 fprintf_filtered (stream
,
459 "a thread-local variable at offset %s in the "
460 "thread-local storage for `%s'",
461 paddr_nz (offset
), dlbaton
->objfile
->name
);
466 fprintf_filtered (stream
,
467 "a variable with complex or multiple locations (DWARF2)");
472 /* Describe the location of SYMBOL as an agent value in VALUE, generating
473 any necessary bytecode in AX.
475 NOTE drow/2003-02-26: This function is extremely minimal, because
476 doing it correctly is extremely complicated and there is no
477 publicly available stub with tracepoint support for me to test
478 against. When there is one this function should be revisited. */
481 locexpr_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
482 struct axs_value
* value
)
484 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
486 dwarf2_tracepoint_var_ref (symbol
, ax
, value
, dlbaton
->data
, dlbaton
->size
);
489 /* The set of location functions used with the DWARF-2 expression
491 const struct symbol_ops dwarf2_locexpr_funcs
= {
492 locexpr_read_variable
,
493 locexpr_read_needs_frame
,
494 locexpr_describe_location
,
495 locexpr_tracepoint_var_ref
499 /* Wrapper functions for location lists. These generally find
500 the appropriate location expression and call something above. */
502 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
503 evaluator to calculate the location. */
504 static struct value
*
505 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
507 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
512 data
= find_location_expression (dlbaton
, &size
,
513 frame
? get_frame_pc (frame
) : 0);
516 val
= allocate_value (SYMBOL_TYPE (symbol
));
517 VALUE_LVAL (val
) = not_lval
;
518 set_value_optimized_out (val
, 1);
521 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, data
, size
,
527 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
529 loclist_read_needs_frame (struct symbol
*symbol
)
531 /* If there's a location list, then assume we need to have a frame
532 to choose the appropriate location expression. With tracking of
533 global variables this is not necessarily true, but such tracking
534 is disabled in GCC at the moment until we figure out how to
540 /* Print a natural-language description of SYMBOL to STREAM. */
542 loclist_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
544 /* FIXME: Could print the entire list of locations. */
545 fprintf_filtered (stream
, "a variable with multiple locations");
549 /* Describe the location of SYMBOL as an agent value in VALUE, generating
550 any necessary bytecode in AX. */
552 loclist_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
553 struct axs_value
* value
)
555 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
559 data
= find_location_expression (dlbaton
, &size
, ax
->scope
);
561 error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol
));
563 dwarf2_tracepoint_var_ref (symbol
, ax
, value
, data
, size
);
566 /* The set of location functions used with the DWARF-2 expression
567 evaluator and location lists. */
568 const struct symbol_ops dwarf2_loclist_funcs
= {
569 loclist_read_variable
,
570 loclist_read_needs_frame
,
571 loclist_describe_location
,
572 loclist_tracepoint_var_ref