1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003, 2005, 2007, 2008, 2009 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"
37 #include "dwarf2expr.h"
38 #include "dwarf2loc.h"
40 #include "gdb_string.h"
41 #include "gdb_assert.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 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
59 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
60 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
61 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
62 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
63 /* Adjust base_address for relocatable objects. */
64 CORE_ADDR base_offset
= ANOFFSET (objfile
->section_offsets
,
65 SECT_OFF_TEXT (objfile
));
66 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
68 loc_ptr
= baton
->data
;
69 buf_end
= baton
->data
+ baton
->size
;
73 if (buf_end
- loc_ptr
< 2 * addr_size
)
74 error (_("find_location_expression: Corrupted DWARF expression."));
76 low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
79 /* A base-address-selection entry. */
82 base_address
= dwarf2_read_address (gdbarch
,
83 loc_ptr
, buf_end
, addr_size
);
88 high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
91 /* An end-of-list entry. */
92 if (low
== 0 && high
== 0)
95 /* Otherwise, a location expression entry. */
99 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
102 if (pc
>= low
&& pc
< high
)
104 *locexpr_length
= length
;
112 /* This is the baton used when performing dwarf2 expression
114 struct dwarf_expr_baton
116 struct frame_info
*frame
;
117 struct objfile
*objfile
;
120 /* Helper functions for dwarf2_evaluate_loc_desc. */
122 /* Using the frame specified in BATON, return the value of register
123 REGNUM, treated as a pointer. */
125 dwarf_expr_read_reg (void *baton
, int dwarf_regnum
)
127 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
128 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
132 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
133 result
= address_from_register (builtin_type (gdbarch
)->builtin_data_ptr
,
134 regnum
, debaton
->frame
);
138 /* Read memory at ADDR (length LEN) into BUF. */
141 dwarf_expr_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
143 read_memory (addr
, buf
, len
);
146 /* Using the frame specified in BATON, find the location expression
147 describing the frame base. Return a pointer to it in START and
148 its length in LENGTH. */
150 dwarf_expr_frame_base (void *baton
, gdb_byte
**start
, size_t * length
)
152 /* FIXME: cagney/2003-03-26: This code should be using
153 get_frame_base_address(), and then implement a dwarf2 specific
155 struct symbol
*framefunc
;
156 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
158 /* Use block_linkage_function, which returns a real (not inlined)
159 function, instead of get_frame_function, which may return an
161 framefunc
= block_linkage_function (get_frame_block (debaton
->frame
, NULL
));
163 /* If we found a frame-relative symbol then it was certainly within
164 some function associated with a frame. If we can't find the frame,
165 something has gone wrong. */
166 gdb_assert (framefunc
!= NULL
);
168 if (SYMBOL_LOCATION_BATON (framefunc
) == NULL
)
170 else if (SYMBOL_COMPUTED_OPS (framefunc
) == &dwarf2_loclist_funcs
)
172 struct dwarf2_loclist_baton
*symbaton
;
173 struct frame_info
*frame
= debaton
->frame
;
175 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
176 *start
= find_location_expression (symbaton
, length
,
177 get_frame_address_in_block (frame
));
181 struct dwarf2_locexpr_baton
*symbaton
;
182 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
183 if (symbaton
!= NULL
)
185 *length
= symbaton
->size
;
186 *start
= symbaton
->data
;
193 error (_("Could not find the frame base for \"%s\"."),
194 SYMBOL_NATURAL_NAME (framefunc
));
197 /* Using the objfile specified in BATON, find the address for the
198 current thread's thread-local storage with offset OFFSET. */
200 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
202 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
204 return target_translate_tls_address (debaton
->objfile
, offset
);
207 /* Evaluate a location description, starting at DATA and with length
208 SIZE, to find the current location of variable VAR in the context
210 static struct value
*
211 dwarf2_evaluate_loc_desc (struct symbol
*var
, struct frame_info
*frame
,
212 gdb_byte
*data
, unsigned short size
,
213 struct dwarf2_per_cu_data
*per_cu
)
215 struct value
*retval
;
216 struct dwarf_expr_baton baton
;
217 struct dwarf_expr_context
*ctx
;
221 retval
= allocate_value (SYMBOL_TYPE (var
));
222 VALUE_LVAL (retval
) = not_lval
;
223 set_value_optimized_out (retval
, 1);
228 baton
.objfile
= dwarf2_per_cu_objfile (per_cu
);
230 ctx
= new_dwarf_expr_context ();
231 ctx
->gdbarch
= get_objfile_arch (baton
.objfile
);
232 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
234 ctx
->read_reg
= dwarf_expr_read_reg
;
235 ctx
->read_mem
= dwarf_expr_read_mem
;
236 ctx
->get_frame_base
= dwarf_expr_frame_base
;
237 ctx
->get_tls_address
= dwarf_expr_tls_address
;
239 dwarf_expr_eval (ctx
, data
, size
);
240 if (ctx
->num_pieces
> 0)
246 retval
= allocate_value (SYMBOL_TYPE (var
));
247 contents
= value_contents_raw (retval
);
248 for (i
= 0; i
< ctx
->num_pieces
; i
++)
250 struct dwarf_expr_piece
*p
= &ctx
->pieces
[i
];
253 struct gdbarch
*arch
= get_frame_arch (frame
);
254 bfd_byte regval
[MAX_REGISTER_SIZE
];
255 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->value
);
256 get_frame_register (frame
, gdb_regnum
, regval
);
257 memcpy (contents
+ offset
, regval
, p
->size
);
259 else /* In memory? */
261 read_memory (p
->value
, contents
+ offset
, p
->size
);
266 else if (ctx
->in_reg
)
268 struct gdbarch
*arch
= get_frame_arch (frame
);
269 CORE_ADDR dwarf_regnum
= dwarf_expr_fetch (ctx
, 0);
270 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
271 retval
= value_from_register (SYMBOL_TYPE (var
), gdb_regnum
, frame
);
275 CORE_ADDR address
= dwarf_expr_fetch (ctx
, 0);
277 retval
= allocate_value (SYMBOL_TYPE (var
));
278 VALUE_LVAL (retval
) = lval_memory
;
279 set_value_lazy (retval
, 1);
280 set_value_address (retval
, address
);
283 set_value_initialized (retval
, ctx
->initialized
);
285 free_dwarf_expr_context (ctx
);
294 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
296 struct needs_frame_baton
301 /* Reads from registers do require a frame. */
303 needs_frame_read_reg (void *baton
, int regnum
)
305 struct needs_frame_baton
*nf_baton
= baton
;
306 nf_baton
->needs_frame
= 1;
310 /* Reads from memory do not require a frame. */
312 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
314 memset (buf
, 0, len
);
317 /* Frame-relative accesses do require a frame. */
319 needs_frame_frame_base (void *baton
, gdb_byte
**start
, size_t * length
)
321 static gdb_byte lit0
= DW_OP_lit0
;
322 struct needs_frame_baton
*nf_baton
= baton
;
327 nf_baton
->needs_frame
= 1;
330 /* Thread-local accesses do require a frame. */
332 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
334 struct needs_frame_baton
*nf_baton
= baton
;
335 nf_baton
->needs_frame
= 1;
339 /* Return non-zero iff the location expression at DATA (length SIZE)
340 requires a frame to evaluate. */
343 dwarf2_loc_desc_needs_frame (gdb_byte
*data
, unsigned short size
,
344 struct dwarf2_per_cu_data
*per_cu
)
346 struct needs_frame_baton baton
;
347 struct dwarf_expr_context
*ctx
;
350 baton
.needs_frame
= 0;
352 ctx
= new_dwarf_expr_context ();
353 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (per_cu
));
354 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
356 ctx
->read_reg
= needs_frame_read_reg
;
357 ctx
->read_mem
= needs_frame_read_mem
;
358 ctx
->get_frame_base
= needs_frame_frame_base
;
359 ctx
->get_tls_address
= needs_frame_tls_address
;
361 dwarf_expr_eval (ctx
, data
, size
);
363 in_reg
= ctx
->in_reg
;
365 if (ctx
->num_pieces
> 0)
369 /* If the location has several pieces, and any of them are in
370 registers, then we will need a frame to fetch them from. */
371 for (i
= 0; i
< ctx
->num_pieces
; i
++)
372 if (ctx
->pieces
[i
].in_reg
)
376 free_dwarf_expr_context (ctx
);
378 return baton
.needs_frame
|| in_reg
;
382 dwarf2_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
383 struct agent_expr
*ax
, struct axs_value
*value
,
384 gdb_byte
*data
, int size
)
387 error (_("Symbol \"%s\" has been optimized out."),
388 SYMBOL_PRINT_NAME (symbol
));
391 && data
[0] >= DW_OP_reg0
392 && data
[0] <= DW_OP_reg31
)
394 value
->kind
= axs_lvalue_register
;
395 value
->u
.reg
= data
[0] - DW_OP_reg0
;
397 else if (data
[0] == DW_OP_regx
)
400 read_uleb128 (data
+ 1, data
+ size
, ®
);
401 value
->kind
= axs_lvalue_register
;
404 else if (data
[0] == DW_OP_fbreg
)
406 /* And this is worse than just minimal; we should honor the frame base
409 LONGEST frame_offset
;
412 buf_end
= read_sleb128 (data
+ 1, data
+ size
, &frame_offset
);
413 if (buf_end
!= data
+ size
)
414 error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
415 SYMBOL_PRINT_NAME (symbol
));
417 gdbarch_virtual_frame_pointer (gdbarch
,
418 ax
->scope
, &frame_reg
, &frame_offset
);
419 ax_reg (ax
, frame_reg
);
420 ax_const_l (ax
, frame_offset
);
421 ax_simple (ax
, aop_add
);
423 value
->kind
= axs_lvalue_memory
;
425 else if (data
[0] >= DW_OP_breg0
426 && data
[0] <= DW_OP_breg31
)
432 reg
= data
[0] - DW_OP_breg0
;
433 buf_end
= read_sleb128 (data
+ 1, data
+ size
, &offset
);
434 if (buf_end
!= data
+ size
)
435 error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
436 reg
, SYMBOL_PRINT_NAME (symbol
));
439 ax_const_l (ax
, offset
);
440 ax_simple (ax
, aop_add
);
442 value
->kind
= axs_lvalue_memory
;
445 error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
446 data
[0], SYMBOL_PRINT_NAME (symbol
));
449 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
450 evaluator to calculate the location. */
451 static struct value
*
452 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
454 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
456 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, dlbaton
->data
, dlbaton
->size
,
462 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
464 locexpr_read_needs_frame (struct symbol
*symbol
)
466 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
467 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
471 /* Print a natural-language description of SYMBOL to STREAM. */
473 locexpr_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
475 /* FIXME: be more extensive. */
476 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
477 int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
479 if (dlbaton
->size
== 1
480 && dlbaton
->data
[0] >= DW_OP_reg0
481 && dlbaton
->data
[0] <= DW_OP_reg31
)
483 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
484 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
485 int regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
,
486 dlbaton
->data
[0] - DW_OP_reg0
);
487 fprintf_filtered (stream
,
488 "a variable in register %s",
489 gdbarch_register_name (gdbarch
, regno
));
493 /* The location expression for a TLS variable looks like this (on a
496 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
497 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
499 0x3 is the encoding for DW_OP_addr, which has an operand as long
500 as the size of an address on the target machine (here is 8
501 bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
502 The operand represents the offset at which the variable is within
503 the thread local storage. */
505 if (dlbaton
->size
> 1
506 && dlbaton
->data
[dlbaton
->size
- 1] == DW_OP_GNU_push_tls_address
)
507 if (dlbaton
->data
[0] == DW_OP_addr
)
509 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
510 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
511 CORE_ADDR offset
= dwarf2_read_address (gdbarch
,
513 &dlbaton
->data
[dlbaton
->size
- 1],
515 fprintf_filtered (stream
,
516 "a thread-local variable at offset %s in the "
517 "thread-local storage for `%s'",
518 paddress (gdbarch
, offset
), objfile
->name
);
523 fprintf_filtered (stream
,
524 "a variable with complex or multiple locations (DWARF2)");
529 /* Describe the location of SYMBOL as an agent value in VALUE, generating
530 any necessary bytecode in AX.
532 NOTE drow/2003-02-26: This function is extremely minimal, because
533 doing it correctly is extremely complicated and there is no
534 publicly available stub with tracepoint support for me to test
535 against. When there is one this function should be revisited. */
538 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
539 struct agent_expr
*ax
, struct axs_value
*value
)
541 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
543 dwarf2_tracepoint_var_ref (symbol
, gdbarch
, ax
, value
,
544 dlbaton
->data
, dlbaton
->size
);
547 /* The set of location functions used with the DWARF-2 expression
549 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
550 locexpr_read_variable
,
551 locexpr_read_needs_frame
,
552 locexpr_describe_location
,
553 locexpr_tracepoint_var_ref
557 /* Wrapper functions for location lists. These generally find
558 the appropriate location expression and call something above. */
560 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
561 evaluator to calculate the location. */
562 static struct value
*
563 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
565 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
570 data
= find_location_expression (dlbaton
, &size
,
571 frame
? get_frame_address_in_block (frame
)
575 val
= allocate_value (SYMBOL_TYPE (symbol
));
576 VALUE_LVAL (val
) = not_lval
;
577 set_value_optimized_out (val
, 1);
580 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, data
, size
,
586 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
588 loclist_read_needs_frame (struct symbol
*symbol
)
590 /* If there's a location list, then assume we need to have a frame
591 to choose the appropriate location expression. With tracking of
592 global variables this is not necessarily true, but such tracking
593 is disabled in GCC at the moment until we figure out how to
599 /* Print a natural-language description of SYMBOL to STREAM. */
601 loclist_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
603 /* FIXME: Could print the entire list of locations. */
604 fprintf_filtered (stream
, "a variable with multiple locations");
608 /* Describe the location of SYMBOL as an agent value in VALUE, generating
609 any necessary bytecode in AX. */
611 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
612 struct agent_expr
*ax
, struct axs_value
*value
)
614 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
618 data
= find_location_expression (dlbaton
, &size
, ax
->scope
);
620 error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol
));
622 dwarf2_tracepoint_var_ref (symbol
, gdbarch
, ax
, value
, data
, size
);
625 /* The set of location functions used with the DWARF-2 expression
626 evaluator and location lists. */
627 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
628 loclist_read_variable
,
629 loclist_read_needs_frame
,
630 loclist_describe_location
,
631 loclist_tracepoint_var_ref