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"
36 #include "elf/dwarf2.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 low
= dwarf2_read_address (gdbarch
, loc_ptr
, buf_end
, addr_size
);
75 high
= dwarf2_read_address (gdbarch
, loc_ptr
, buf_end
, addr_size
);
78 /* An end-of-list entry. */
79 if (low
== 0 && high
== 0)
82 /* A base-address-selection entry. */
83 if ((low
& base_mask
) == base_mask
)
89 /* Otherwise, a location expression entry. */
93 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
96 if (pc
>= low
&& pc
< high
)
98 *locexpr_length
= length
;
106 /* This is the baton used when performing dwarf2 expression
108 struct dwarf_expr_baton
110 struct frame_info
*frame
;
111 struct objfile
*objfile
;
114 /* Helper functions for dwarf2_evaluate_loc_desc. */
116 /* Using the frame specified in BATON, return the value of register
117 REGNUM, treated as a pointer. */
119 dwarf_expr_read_reg (void *baton
, int dwarf_regnum
)
121 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
122 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
126 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
127 result
= address_from_register (builtin_type (gdbarch
)->builtin_data_ptr
,
128 regnum
, debaton
->frame
);
132 /* Read memory at ADDR (length LEN) into BUF. */
135 dwarf_expr_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
137 read_memory (addr
, buf
, len
);
140 /* Using the frame specified in BATON, find the location expression
141 describing the frame base. Return a pointer to it in START and
142 its length in LENGTH. */
144 dwarf_expr_frame_base (void *baton
, gdb_byte
**start
, size_t * length
)
146 /* FIXME: cagney/2003-03-26: This code should be using
147 get_frame_base_address(), and then implement a dwarf2 specific
149 struct symbol
*framefunc
;
150 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
152 /* Use block_linkage_function, which returns a real (not inlined)
153 function, instead of get_frame_function, which may return an
155 framefunc
= block_linkage_function (get_frame_block (debaton
->frame
, NULL
));
157 /* If we found a frame-relative symbol then it was certainly within
158 some function associated with a frame. If we can't find the frame,
159 something has gone wrong. */
160 gdb_assert (framefunc
!= NULL
);
162 if (SYMBOL_LOCATION_BATON (framefunc
) == NULL
)
164 else if (SYMBOL_COMPUTED_OPS (framefunc
) == &dwarf2_loclist_funcs
)
166 struct dwarf2_loclist_baton
*symbaton
;
167 struct frame_info
*frame
= debaton
->frame
;
169 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
170 *start
= find_location_expression (symbaton
, length
,
171 get_frame_address_in_block (frame
));
175 struct dwarf2_locexpr_baton
*symbaton
;
176 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
177 if (symbaton
!= NULL
)
179 *length
= symbaton
->size
;
180 *start
= symbaton
->data
;
187 error (_("Could not find the frame base for \"%s\"."),
188 SYMBOL_NATURAL_NAME (framefunc
));
191 /* Using the objfile specified in BATON, find the address for the
192 current thread's thread-local storage with offset OFFSET. */
194 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
196 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
198 return target_translate_tls_address (debaton
->objfile
, offset
);
201 /* Evaluate a location description, starting at DATA and with length
202 SIZE, to find the current location of variable VAR in the context
204 static struct value
*
205 dwarf2_evaluate_loc_desc (struct symbol
*var
, struct frame_info
*frame
,
206 gdb_byte
*data
, unsigned short size
,
207 struct dwarf2_per_cu_data
*per_cu
)
209 struct value
*retval
;
210 struct dwarf_expr_baton baton
;
211 struct dwarf_expr_context
*ctx
;
215 retval
= allocate_value (SYMBOL_TYPE (var
));
216 VALUE_LVAL (retval
) = not_lval
;
217 set_value_optimized_out (retval
, 1);
222 baton
.objfile
= dwarf2_per_cu_objfile (per_cu
);
224 ctx
= new_dwarf_expr_context ();
225 ctx
->gdbarch
= get_objfile_arch (baton
.objfile
);
226 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
228 ctx
->read_reg
= dwarf_expr_read_reg
;
229 ctx
->read_mem
= dwarf_expr_read_mem
;
230 ctx
->get_frame_base
= dwarf_expr_frame_base
;
231 ctx
->get_tls_address
= dwarf_expr_tls_address
;
233 dwarf_expr_eval (ctx
, data
, size
);
234 if (ctx
->num_pieces
> 0)
240 retval
= allocate_value (SYMBOL_TYPE (var
));
241 contents
= value_contents_raw (retval
);
242 for (i
= 0; i
< ctx
->num_pieces
; i
++)
244 struct dwarf_expr_piece
*p
= &ctx
->pieces
[i
];
247 struct gdbarch
*arch
= get_frame_arch (frame
);
248 bfd_byte regval
[MAX_REGISTER_SIZE
];
249 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->value
);
250 get_frame_register (frame
, gdb_regnum
, regval
);
251 memcpy (contents
+ offset
, regval
, p
->size
);
253 else /* In memory? */
255 read_memory (p
->value
, contents
+ offset
, p
->size
);
260 else if (ctx
->in_reg
)
262 struct gdbarch
*arch
= get_frame_arch (frame
);
263 CORE_ADDR dwarf_regnum
= dwarf_expr_fetch (ctx
, 0);
264 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
265 retval
= value_from_register (SYMBOL_TYPE (var
), gdb_regnum
, frame
);
269 CORE_ADDR address
= dwarf_expr_fetch (ctx
, 0);
271 retval
= allocate_value (SYMBOL_TYPE (var
));
272 VALUE_LVAL (retval
) = lval_memory
;
273 set_value_lazy (retval
, 1);
274 set_value_address (retval
, address
);
277 set_value_initialized (retval
, ctx
->initialized
);
279 free_dwarf_expr_context (ctx
);
288 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
290 struct needs_frame_baton
295 /* Reads from registers do require a frame. */
297 needs_frame_read_reg (void *baton
, int regnum
)
299 struct needs_frame_baton
*nf_baton
= baton
;
300 nf_baton
->needs_frame
= 1;
304 /* Reads from memory do not require a frame. */
306 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
308 memset (buf
, 0, len
);
311 /* Frame-relative accesses do require a frame. */
313 needs_frame_frame_base (void *baton
, gdb_byte
**start
, size_t * length
)
315 static gdb_byte lit0
= DW_OP_lit0
;
316 struct needs_frame_baton
*nf_baton
= baton
;
321 nf_baton
->needs_frame
= 1;
324 /* Thread-local accesses do require a frame. */
326 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
328 struct needs_frame_baton
*nf_baton
= baton
;
329 nf_baton
->needs_frame
= 1;
333 /* Return non-zero iff the location expression at DATA (length SIZE)
334 requires a frame to evaluate. */
337 dwarf2_loc_desc_needs_frame (gdb_byte
*data
, unsigned short size
,
338 struct dwarf2_per_cu_data
*per_cu
)
340 struct needs_frame_baton baton
;
341 struct dwarf_expr_context
*ctx
;
344 baton
.needs_frame
= 0;
346 ctx
= new_dwarf_expr_context ();
347 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (per_cu
));
348 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
350 ctx
->read_reg
= needs_frame_read_reg
;
351 ctx
->read_mem
= needs_frame_read_mem
;
352 ctx
->get_frame_base
= needs_frame_frame_base
;
353 ctx
->get_tls_address
= needs_frame_tls_address
;
355 dwarf_expr_eval (ctx
, data
, size
);
357 in_reg
= ctx
->in_reg
;
359 if (ctx
->num_pieces
> 0)
363 /* If the location has several pieces, and any of them are in
364 registers, then we will need a frame to fetch them from. */
365 for (i
= 0; i
< ctx
->num_pieces
; i
++)
366 if (ctx
->pieces
[i
].in_reg
)
370 free_dwarf_expr_context (ctx
);
372 return baton
.needs_frame
|| in_reg
;
376 dwarf2_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
377 struct agent_expr
*ax
, struct axs_value
*value
,
378 gdb_byte
*data
, int size
)
381 error (_("Symbol \"%s\" has been optimized out."),
382 SYMBOL_PRINT_NAME (symbol
));
385 && data
[0] >= DW_OP_reg0
386 && data
[0] <= DW_OP_reg31
)
388 value
->kind
= axs_lvalue_register
;
389 value
->u
.reg
= data
[0] - DW_OP_reg0
;
391 else if (data
[0] == DW_OP_regx
)
394 read_uleb128 (data
+ 1, data
+ size
, ®
);
395 value
->kind
= axs_lvalue_register
;
398 else if (data
[0] == DW_OP_fbreg
)
400 /* And this is worse than just minimal; we should honor the frame base
403 LONGEST frame_offset
;
406 buf_end
= read_sleb128 (data
+ 1, data
+ size
, &frame_offset
);
407 if (buf_end
!= data
+ size
)
408 error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
409 SYMBOL_PRINT_NAME (symbol
));
411 gdbarch_virtual_frame_pointer (gdbarch
,
412 ax
->scope
, &frame_reg
, &frame_offset
);
413 ax_reg (ax
, frame_reg
);
414 ax_const_l (ax
, frame_offset
);
415 ax_simple (ax
, aop_add
);
417 value
->kind
= axs_lvalue_memory
;
419 else if (data
[0] >= DW_OP_breg0
420 && data
[0] <= DW_OP_breg31
)
426 reg
= data
[0] - DW_OP_breg0
;
427 buf_end
= read_sleb128 (data
+ 1, data
+ size
, &offset
);
428 if (buf_end
!= data
+ size
)
429 error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
430 reg
, SYMBOL_PRINT_NAME (symbol
));
433 ax_const_l (ax
, offset
);
434 ax_simple (ax
, aop_add
);
436 value
->kind
= axs_lvalue_memory
;
439 error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
440 data
[0], SYMBOL_PRINT_NAME (symbol
));
443 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
444 evaluator to calculate the location. */
445 static struct value
*
446 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
448 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
450 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, dlbaton
->data
, dlbaton
->size
,
456 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
458 locexpr_read_needs_frame (struct symbol
*symbol
)
460 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
461 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
465 /* Print a natural-language description of SYMBOL to STREAM. */
467 locexpr_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
469 /* FIXME: be more extensive. */
470 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
471 int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
473 if (dlbaton
->size
== 1
474 && dlbaton
->data
[0] >= DW_OP_reg0
475 && dlbaton
->data
[0] <= DW_OP_reg31
)
477 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
478 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
479 int regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
,
480 dlbaton
->data
[0] - DW_OP_reg0
);
481 fprintf_filtered (stream
,
482 "a variable in register %s",
483 gdbarch_register_name (gdbarch
, regno
));
487 /* The location expression for a TLS variable looks like this (on a
490 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
491 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
493 0x3 is the encoding for DW_OP_addr, which has an operand as long
494 as the size of an address on the target machine (here is 8
495 bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
496 The operand represents the offset at which the variable is within
497 the thread local storage. */
499 if (dlbaton
->size
> 1
500 && dlbaton
->data
[dlbaton
->size
- 1] == DW_OP_GNU_push_tls_address
)
501 if (dlbaton
->data
[0] == DW_OP_addr
)
503 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
504 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
505 CORE_ADDR offset
= dwarf2_read_address (gdbarch
,
507 &dlbaton
->data
[dlbaton
->size
- 1],
509 fprintf_filtered (stream
,
510 "a thread-local variable at offset %s in the "
511 "thread-local storage for `%s'",
512 paddress (gdbarch
, offset
), objfile
->name
);
517 fprintf_filtered (stream
,
518 "a variable with complex or multiple locations (DWARF2)");
523 /* Describe the location of SYMBOL as an agent value in VALUE, generating
524 any necessary bytecode in AX.
526 NOTE drow/2003-02-26: This function is extremely minimal, because
527 doing it correctly is extremely complicated and there is no
528 publicly available stub with tracepoint support for me to test
529 against. When there is one this function should be revisited. */
532 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
533 struct agent_expr
*ax
, struct axs_value
*value
)
535 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
537 dwarf2_tracepoint_var_ref (symbol
, gdbarch
, ax
, value
,
538 dlbaton
->data
, dlbaton
->size
);
541 /* The set of location functions used with the DWARF-2 expression
543 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
544 locexpr_read_variable
,
545 locexpr_read_needs_frame
,
546 locexpr_describe_location
,
547 locexpr_tracepoint_var_ref
551 /* Wrapper functions for location lists. These generally find
552 the appropriate location expression and call something above. */
554 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
555 evaluator to calculate the location. */
556 static struct value
*
557 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
559 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
564 data
= find_location_expression (dlbaton
, &size
,
565 frame
? get_frame_address_in_block (frame
)
569 val
= allocate_value (SYMBOL_TYPE (symbol
));
570 VALUE_LVAL (val
) = not_lval
;
571 set_value_optimized_out (val
, 1);
574 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, data
, size
,
580 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
582 loclist_read_needs_frame (struct symbol
*symbol
)
584 /* If there's a location list, then assume we need to have a frame
585 to choose the appropriate location expression. With tracking of
586 global variables this is not necessarily true, but such tracking
587 is disabled in GCC at the moment until we figure out how to
593 /* Print a natural-language description of SYMBOL to STREAM. */
595 loclist_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
597 /* FIXME: Could print the entire list of locations. */
598 fprintf_filtered (stream
, "a variable with multiple locations");
602 /* Describe the location of SYMBOL as an agent value in VALUE, generating
603 any necessary bytecode in AX. */
605 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
606 struct agent_expr
*ax
, struct axs_value
*value
)
608 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
612 data
= find_location_expression (dlbaton
, &size
, ax
->scope
);
614 error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol
));
616 dwarf2_tracepoint_var_ref (symbol
, gdbarch
, ax
, value
, data
, size
);
619 /* The set of location functions used with the DWARF-2 expression
620 evaluator and location lists. */
621 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
622 loclist_read_variable
,
623 loclist_read_needs_frame
,
624 loclist_describe_location
,
625 loclist_tracepoint_var_ref