1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003, 2005, 2007, 2008 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 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU 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, see <http://www.gnu.org/licenses/>. */
33 #include "exceptions.h"
35 #include "elf/dwarf2.h"
36 #include "dwarf2expr.h"
37 #include "dwarf2loc.h"
39 #include "gdb_string.h"
40 #include "gdb_assert.h"
42 /* A helper function for dealing with location lists. Given a
43 symbol baton (BATON) and a pc value (PC), find the appropriate
44 location expression, set *LOCEXPR_LENGTH, and return a pointer
45 to the beginning of the expression. Returns NULL on failure.
47 For now, only return the first matching location expression; there
48 can be more than one in the list. */
51 find_location_expression (struct dwarf2_loclist_baton
*baton
,
52 size_t *locexpr_length
, CORE_ADDR pc
)
55 gdb_byte
*loc_ptr
, *buf_end
;
57 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
58 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
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 (objfile
->section_offsets
,
62 SECT_OFF_TEXT (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
, addr_size
);
72 high
= dwarf2_read_address (loc_ptr
, buf_end
, addr_size
);
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 we found a frame-relative symbol then it was certainly within
151 some function associated with a frame. If we can't find the frame,
152 something has gone wrong. */
153 gdb_assert (framefunc
!= NULL
);
155 if (SYMBOL_OPS (framefunc
) == &dwarf2_loclist_funcs
)
157 struct dwarf2_loclist_baton
*symbaton
;
158 struct frame_info
*frame
= debaton
->frame
;
160 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
161 *start
= find_location_expression (symbaton
, length
,
162 get_frame_address_in_block (frame
));
166 struct dwarf2_locexpr_baton
*symbaton
;
167 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
168 *length
= symbaton
->size
;
169 *start
= symbaton
->data
;
173 error (_("Could not find the frame base for \"%s\"."),
174 SYMBOL_NATURAL_NAME (framefunc
));
177 /* Using the objfile specified in BATON, find the address for the
178 current thread's thread-local storage with offset OFFSET. */
180 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
182 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
184 return target_translate_tls_address (debaton
->objfile
, offset
);
187 /* Evaluate a location description, starting at DATA and with length
188 SIZE, to find the current location of variable VAR in the context
190 static struct value
*
191 dwarf2_evaluate_loc_desc (struct symbol
*var
, struct frame_info
*frame
,
192 gdb_byte
*data
, unsigned short size
,
193 struct dwarf2_per_cu_data
*per_cu
)
195 struct gdbarch
*arch
= get_frame_arch (frame
);
196 struct value
*retval
;
197 struct dwarf_expr_baton baton
;
198 struct dwarf_expr_context
*ctx
;
202 retval
= allocate_value (SYMBOL_TYPE (var
));
203 VALUE_LVAL (retval
) = not_lval
;
204 set_value_optimized_out (retval
, 1);
209 baton
.objfile
= dwarf2_per_cu_objfile (per_cu
);
211 ctx
= new_dwarf_expr_context ();
212 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
214 ctx
->read_reg
= dwarf_expr_read_reg
;
215 ctx
->read_mem
= dwarf_expr_read_mem
;
216 ctx
->get_frame_base
= dwarf_expr_frame_base
;
217 ctx
->get_tls_address
= dwarf_expr_tls_address
;
219 dwarf_expr_eval (ctx
, data
, size
);
220 if (ctx
->num_pieces
> 0)
226 retval
= allocate_value (SYMBOL_TYPE (var
));
227 contents
= value_contents_raw (retval
);
228 for (i
= 0; i
< ctx
->num_pieces
; i
++)
230 struct dwarf_expr_piece
*p
= &ctx
->pieces
[i
];
233 bfd_byte regval
[MAX_REGISTER_SIZE
];
234 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum
236 get_frame_register (frame
, gdb_regnum
, regval
);
237 memcpy (contents
+ offset
, regval
, p
->size
);
239 else /* In memory? */
241 read_memory (p
->value
, contents
+ offset
, p
->size
);
246 else if (ctx
->in_reg
)
248 CORE_ADDR dwarf_regnum
= dwarf_expr_fetch (ctx
, 0);
249 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum
250 (arch
, dwarf_regnum
);
251 retval
= value_from_register (SYMBOL_TYPE (var
), gdb_regnum
, frame
);
255 CORE_ADDR address
= dwarf_expr_fetch (ctx
, 0);
257 retval
= allocate_value (SYMBOL_TYPE (var
));
258 VALUE_LVAL (retval
) = lval_memory
;
259 set_value_lazy (retval
, 1);
260 VALUE_ADDRESS (retval
) = address
;
263 set_value_initialized (retval
, ctx
->initialized
);
265 free_dwarf_expr_context (ctx
);
274 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
276 struct needs_frame_baton
281 /* Reads from registers do require a frame. */
283 needs_frame_read_reg (void *baton
, int regnum
)
285 struct needs_frame_baton
*nf_baton
= baton
;
286 nf_baton
->needs_frame
= 1;
290 /* Reads from memory do not require a frame. */
292 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
294 memset (buf
, 0, len
);
297 /* Frame-relative accesses do require a frame. */
299 needs_frame_frame_base (void *baton
, gdb_byte
**start
, size_t * length
)
301 static gdb_byte lit0
= DW_OP_lit0
;
302 struct needs_frame_baton
*nf_baton
= baton
;
307 nf_baton
->needs_frame
= 1;
310 /* Thread-local accesses do require a frame. */
312 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
314 struct needs_frame_baton
*nf_baton
= baton
;
315 nf_baton
->needs_frame
= 1;
319 /* Return non-zero iff the location expression at DATA (length SIZE)
320 requires a frame to evaluate. */
323 dwarf2_loc_desc_needs_frame (gdb_byte
*data
, unsigned short size
,
324 struct dwarf2_per_cu_data
*per_cu
)
326 struct needs_frame_baton baton
;
327 struct dwarf_expr_context
*ctx
;
330 baton
.needs_frame
= 0;
332 ctx
= new_dwarf_expr_context ();
333 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
335 ctx
->read_reg
= needs_frame_read_reg
;
336 ctx
->read_mem
= needs_frame_read_mem
;
337 ctx
->get_frame_base
= needs_frame_frame_base
;
338 ctx
->get_tls_address
= needs_frame_tls_address
;
340 dwarf_expr_eval (ctx
, data
, size
);
342 in_reg
= ctx
->in_reg
;
344 if (ctx
->num_pieces
> 0)
348 /* If the location has several pieces, and any of them are in
349 registers, then we will need a frame to fetch them from. */
350 for (i
= 0; i
< ctx
->num_pieces
; i
++)
351 if (ctx
->pieces
[i
].in_reg
)
355 free_dwarf_expr_context (ctx
);
357 return baton
.needs_frame
|| in_reg
;
361 dwarf2_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
362 struct axs_value
*value
, gdb_byte
*data
,
366 error (_("Symbol \"%s\" has been optimized out."),
367 SYMBOL_PRINT_NAME (symbol
));
370 && data
[0] >= DW_OP_reg0
371 && data
[0] <= DW_OP_reg31
)
373 value
->kind
= axs_lvalue_register
;
374 value
->u
.reg
= data
[0] - DW_OP_reg0
;
376 else if (data
[0] == DW_OP_regx
)
379 read_uleb128 (data
+ 1, data
+ size
, ®
);
380 value
->kind
= axs_lvalue_register
;
383 else if (data
[0] == DW_OP_fbreg
)
385 /* And this is worse than just minimal; we should honor the frame base
388 LONGEST frame_offset
;
391 buf_end
= read_sleb128 (data
+ 1, data
+ size
, &frame_offset
);
392 if (buf_end
!= data
+ size
)
393 error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
394 SYMBOL_PRINT_NAME (symbol
));
396 gdbarch_virtual_frame_pointer (current_gdbarch
,
397 ax
->scope
, &frame_reg
, &frame_offset
);
398 ax_reg (ax
, frame_reg
);
399 ax_const_l (ax
, frame_offset
);
400 ax_simple (ax
, aop_add
);
402 value
->kind
= axs_lvalue_memory
;
404 else if (data
[0] >= DW_OP_breg0
405 && data
[0] <= DW_OP_breg31
)
411 reg
= data
[0] - DW_OP_breg0
;
412 buf_end
= read_sleb128 (data
+ 1, data
+ size
, &offset
);
413 if (buf_end
!= data
+ size
)
414 error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
415 reg
, SYMBOL_PRINT_NAME (symbol
));
418 ax_const_l (ax
, offset
);
419 ax_simple (ax
, aop_add
);
421 value
->kind
= axs_lvalue_memory
;
424 error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
425 data
[0], SYMBOL_PRINT_NAME (symbol
));
428 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
429 evaluator to calculate the location. */
430 static struct value
*
431 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
433 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
435 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, dlbaton
->data
, dlbaton
->size
,
441 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
443 locexpr_read_needs_frame (struct symbol
*symbol
)
445 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
446 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
450 /* Print a natural-language description of SYMBOL to STREAM. */
452 locexpr_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
454 /* FIXME: be more extensive. */
455 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
456 int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
458 if (dlbaton
->size
== 1
459 && dlbaton
->data
[0] >= DW_OP_reg0
460 && dlbaton
->data
[0] <= DW_OP_reg31
)
462 int regno
= gdbarch_dwarf2_reg_to_regnum
463 (current_gdbarch
, dlbaton
->data
[0] - DW_OP_reg0
);
464 fprintf_filtered (stream
,
465 "a variable in register %s",
466 gdbarch_register_name (current_gdbarch
, regno
));
470 /* The location expression for a TLS variable looks like this (on a
473 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
474 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
476 0x3 is the encoding for DW_OP_addr, which has an operand as long
477 as the size of an address on the target machine (here is 8
478 bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
479 The operand represents the offset at which the variable is within
480 the thread local storage. */
482 if (dlbaton
->size
> 1
483 && dlbaton
->data
[dlbaton
->size
- 1] == DW_OP_GNU_push_tls_address
)
484 if (dlbaton
->data
[0] == DW_OP_addr
)
486 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
487 CORE_ADDR offset
= dwarf2_read_address (&dlbaton
->data
[1],
488 &dlbaton
->data
[dlbaton
->size
- 1],
490 fprintf_filtered (stream
,
491 "a thread-local variable at offset %s in the "
492 "thread-local storage for `%s'",
493 paddr_nz (offset
), objfile
->name
);
498 fprintf_filtered (stream
,
499 "a variable with complex or multiple locations (DWARF2)");
504 /* Describe the location of SYMBOL as an agent value in VALUE, generating
505 any necessary bytecode in AX.
507 NOTE drow/2003-02-26: This function is extremely minimal, because
508 doing it correctly is extremely complicated and there is no
509 publicly available stub with tracepoint support for me to test
510 against. When there is one this function should be revisited. */
513 locexpr_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
514 struct axs_value
* value
)
516 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
518 dwarf2_tracepoint_var_ref (symbol
, ax
, value
, dlbaton
->data
, dlbaton
->size
);
521 /* The set of location functions used with the DWARF-2 expression
523 const struct symbol_ops dwarf2_locexpr_funcs
= {
524 locexpr_read_variable
,
525 locexpr_read_needs_frame
,
526 locexpr_describe_location
,
527 locexpr_tracepoint_var_ref
531 /* Wrapper functions for location lists. These generally find
532 the appropriate location expression and call something above. */
534 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
535 evaluator to calculate the location. */
536 static struct value
*
537 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
539 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
544 data
= find_location_expression (dlbaton
, &size
,
545 frame
? get_frame_address_in_block (frame
)
549 val
= allocate_value (SYMBOL_TYPE (symbol
));
550 VALUE_LVAL (val
) = not_lval
;
551 set_value_optimized_out (val
, 1);
554 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, data
, size
,
560 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
562 loclist_read_needs_frame (struct symbol
*symbol
)
564 /* If there's a location list, then assume we need to have a frame
565 to choose the appropriate location expression. With tracking of
566 global variables this is not necessarily true, but such tracking
567 is disabled in GCC at the moment until we figure out how to
573 /* Print a natural-language description of SYMBOL to STREAM. */
575 loclist_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
577 /* FIXME: Could print the entire list of locations. */
578 fprintf_filtered (stream
, "a variable with multiple locations");
582 /* Describe the location of SYMBOL as an agent value in VALUE, generating
583 any necessary bytecode in AX. */
585 loclist_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
586 struct axs_value
* value
)
588 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
592 data
= find_location_expression (dlbaton
, &size
, ax
->scope
);
594 error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol
));
596 dwarf2_tracepoint_var_ref (symbol
, ax
, value
, data
, size
);
599 /* The set of location functions used with the DWARF-2 expression
600 evaluator and location lists. */
601 const struct symbol_ops dwarf2_loclist_funcs
= {
602 loclist_read_variable
,
603 loclist_read_needs_frame
,
604 loclist_describe_location
,
605 loclist_tracepoint_var_ref