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
;
218 struct cleanup
*old_chain
;
222 retval
= allocate_value (SYMBOL_TYPE (var
));
223 VALUE_LVAL (retval
) = not_lval
;
224 set_value_optimized_out (retval
, 1);
229 baton
.objfile
= dwarf2_per_cu_objfile (per_cu
);
231 ctx
= new_dwarf_expr_context ();
232 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
234 ctx
->gdbarch
= get_objfile_arch (baton
.objfile
);
235 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
237 ctx
->read_reg
= dwarf_expr_read_reg
;
238 ctx
->read_mem
= dwarf_expr_read_mem
;
239 ctx
->get_frame_base
= dwarf_expr_frame_base
;
240 ctx
->get_tls_address
= dwarf_expr_tls_address
;
242 dwarf_expr_eval (ctx
, data
, size
);
243 if (ctx
->num_pieces
> 0)
249 retval
= allocate_value (SYMBOL_TYPE (var
));
250 contents
= value_contents_raw (retval
);
251 for (i
= 0; i
< ctx
->num_pieces
; i
++)
253 struct dwarf_expr_piece
*p
= &ctx
->pieces
[i
];
256 struct gdbarch
*arch
= get_frame_arch (frame
);
257 bfd_byte regval
[MAX_REGISTER_SIZE
];
258 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->value
);
259 get_frame_register (frame
, gdb_regnum
, regval
);
260 memcpy (contents
+ offset
, regval
, p
->size
);
262 else /* In memory? */
264 read_memory (p
->value
, contents
+ offset
, p
->size
);
269 else if (ctx
->in_reg
)
271 struct gdbarch
*arch
= get_frame_arch (frame
);
272 CORE_ADDR dwarf_regnum
= dwarf_expr_fetch (ctx
, 0);
273 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
274 retval
= value_from_register (SYMBOL_TYPE (var
), gdb_regnum
, frame
);
278 CORE_ADDR address
= dwarf_expr_fetch (ctx
, 0);
280 retval
= allocate_value (SYMBOL_TYPE (var
));
281 VALUE_LVAL (retval
) = lval_memory
;
282 set_value_lazy (retval
, 1);
283 set_value_stack (retval
, 1);
284 set_value_address (retval
, address
);
287 set_value_initialized (retval
, ctx
->initialized
);
289 do_cleanups (old_chain
);
298 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
300 struct needs_frame_baton
305 /* Reads from registers do require a frame. */
307 needs_frame_read_reg (void *baton
, int regnum
)
309 struct needs_frame_baton
*nf_baton
= baton
;
310 nf_baton
->needs_frame
= 1;
314 /* Reads from memory do not require a frame. */
316 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
318 memset (buf
, 0, len
);
321 /* Frame-relative accesses do require a frame. */
323 needs_frame_frame_base (void *baton
, gdb_byte
**start
, size_t * length
)
325 static gdb_byte lit0
= DW_OP_lit0
;
326 struct needs_frame_baton
*nf_baton
= baton
;
331 nf_baton
->needs_frame
= 1;
334 /* Thread-local accesses do require a frame. */
336 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
338 struct needs_frame_baton
*nf_baton
= baton
;
339 nf_baton
->needs_frame
= 1;
343 /* Return non-zero iff the location expression at DATA (length SIZE)
344 requires a frame to evaluate. */
347 dwarf2_loc_desc_needs_frame (gdb_byte
*data
, unsigned short size
,
348 struct dwarf2_per_cu_data
*per_cu
)
350 struct needs_frame_baton baton
;
351 struct dwarf_expr_context
*ctx
;
353 struct cleanup
*old_chain
;
355 baton
.needs_frame
= 0;
357 ctx
= new_dwarf_expr_context ();
358 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
360 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (per_cu
));
361 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
363 ctx
->read_reg
= needs_frame_read_reg
;
364 ctx
->read_mem
= needs_frame_read_mem
;
365 ctx
->get_frame_base
= needs_frame_frame_base
;
366 ctx
->get_tls_address
= needs_frame_tls_address
;
368 dwarf_expr_eval (ctx
, data
, size
);
370 in_reg
= ctx
->in_reg
;
372 if (ctx
->num_pieces
> 0)
376 /* If the location has several pieces, and any of them are in
377 registers, then we will need a frame to fetch them from. */
378 for (i
= 0; i
< ctx
->num_pieces
; i
++)
379 if (ctx
->pieces
[i
].in_reg
)
383 do_cleanups (old_chain
);
385 return baton
.needs_frame
|| in_reg
;
389 dwarf2_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
390 struct agent_expr
*ax
, struct axs_value
*value
,
391 gdb_byte
*data
, int size
)
394 error (_("Symbol \"%s\" has been optimized out."),
395 SYMBOL_PRINT_NAME (symbol
));
398 && data
[0] >= DW_OP_reg0
399 && data
[0] <= DW_OP_reg31
)
401 value
->kind
= axs_lvalue_register
;
402 value
->u
.reg
= data
[0] - DW_OP_reg0
;
404 else if (data
[0] == DW_OP_regx
)
407 read_uleb128 (data
+ 1, data
+ size
, ®
);
408 value
->kind
= axs_lvalue_register
;
411 else if (data
[0] == DW_OP_fbreg
)
413 /* And this is worse than just minimal; we should honor the frame base
416 LONGEST frame_offset
;
419 buf_end
= read_sleb128 (data
+ 1, data
+ size
, &frame_offset
);
420 if (buf_end
!= data
+ size
)
421 error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
422 SYMBOL_PRINT_NAME (symbol
));
424 gdbarch_virtual_frame_pointer (gdbarch
,
425 ax
->scope
, &frame_reg
, &frame_offset
);
426 ax_reg (ax
, frame_reg
);
427 ax_const_l (ax
, frame_offset
);
428 ax_simple (ax
, aop_add
);
430 value
->kind
= axs_lvalue_memory
;
432 else if (data
[0] >= DW_OP_breg0
433 && data
[0] <= DW_OP_breg31
)
439 reg
= data
[0] - DW_OP_breg0
;
440 buf_end
= read_sleb128 (data
+ 1, data
+ size
, &offset
);
441 if (buf_end
!= data
+ size
)
442 error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
443 reg
, SYMBOL_PRINT_NAME (symbol
));
446 ax_const_l (ax
, offset
);
447 ax_simple (ax
, aop_add
);
449 value
->kind
= axs_lvalue_memory
;
452 error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
453 data
[0], SYMBOL_PRINT_NAME (symbol
));
456 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
457 evaluator to calculate the location. */
458 static struct value
*
459 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
461 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
463 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, dlbaton
->data
, dlbaton
->size
,
469 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
471 locexpr_read_needs_frame (struct symbol
*symbol
)
473 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
474 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
478 /* Print a natural-language description of SYMBOL to STREAM. */
480 locexpr_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
482 /* FIXME: be more extensive. */
483 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
484 int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
486 if (dlbaton
->size
== 1
487 && dlbaton
->data
[0] >= DW_OP_reg0
488 && dlbaton
->data
[0] <= DW_OP_reg31
)
490 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
491 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
492 int regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
,
493 dlbaton
->data
[0] - DW_OP_reg0
);
494 fprintf_filtered (stream
,
495 "a variable in register %s",
496 gdbarch_register_name (gdbarch
, regno
));
500 /* The location expression for a TLS variable looks like this (on a
503 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
504 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
506 0x3 is the encoding for DW_OP_addr, which has an operand as long
507 as the size of an address on the target machine (here is 8
508 bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
509 The operand represents the offset at which the variable is within
510 the thread local storage. */
512 if (dlbaton
->size
> 1
513 && dlbaton
->data
[dlbaton
->size
- 1] == DW_OP_GNU_push_tls_address
)
514 if (dlbaton
->data
[0] == DW_OP_addr
)
516 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
517 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
518 CORE_ADDR offset
= dwarf2_read_address (gdbarch
,
520 &dlbaton
->data
[dlbaton
->size
- 1],
522 fprintf_filtered (stream
,
523 "a thread-local variable at offset %s in the "
524 "thread-local storage for `%s'",
525 paddress (gdbarch
, offset
), objfile
->name
);
530 fprintf_filtered (stream
,
531 "a variable with complex or multiple locations (DWARF2)");
536 /* Describe the location of SYMBOL as an agent value in VALUE, generating
537 any necessary bytecode in AX.
539 NOTE drow/2003-02-26: This function is extremely minimal, because
540 doing it correctly is extremely complicated and there is no
541 publicly available stub with tracepoint support for me to test
542 against. When there is one this function should be revisited. */
545 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
546 struct agent_expr
*ax
, struct axs_value
*value
)
548 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
550 dwarf2_tracepoint_var_ref (symbol
, gdbarch
, ax
, value
,
551 dlbaton
->data
, dlbaton
->size
);
554 /* The set of location functions used with the DWARF-2 expression
556 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
557 locexpr_read_variable
,
558 locexpr_read_needs_frame
,
559 locexpr_describe_location
,
560 locexpr_tracepoint_var_ref
564 /* Wrapper functions for location lists. These generally find
565 the appropriate location expression and call something above. */
567 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
568 evaluator to calculate the location. */
569 static struct value
*
570 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
572 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
577 data
= find_location_expression (dlbaton
, &size
,
578 frame
? get_frame_address_in_block (frame
)
582 val
= allocate_value (SYMBOL_TYPE (symbol
));
583 VALUE_LVAL (val
) = not_lval
;
584 set_value_optimized_out (val
, 1);
587 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, data
, size
,
593 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
595 loclist_read_needs_frame (struct symbol
*symbol
)
597 /* If there's a location list, then assume we need to have a frame
598 to choose the appropriate location expression. With tracking of
599 global variables this is not necessarily true, but such tracking
600 is disabled in GCC at the moment until we figure out how to
606 /* Print a natural-language description of SYMBOL to STREAM. */
608 loclist_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
610 /* FIXME: Could print the entire list of locations. */
611 fprintf_filtered (stream
, "a variable with multiple locations");
615 /* Describe the location of SYMBOL as an agent value in VALUE, generating
616 any necessary bytecode in AX. */
618 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
619 struct agent_expr
*ax
, struct axs_value
*value
)
621 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
625 data
= find_location_expression (dlbaton
, &size
, ax
->scope
);
627 error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol
));
629 dwarf2_tracepoint_var_ref (symbol
, gdbarch
, ax
, value
, data
, size
);
632 /* The set of location functions used with the DWARF-2 expression
633 evaluator and location lists. */
634 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
635 loclist_read_variable
,
636 loclist_read_needs_frame
,
637 loclist_describe_location
,
638 loclist_tracepoint_var_ref