1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003, 2005, 2007 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., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
35 #include "exceptions.h"
37 #include "elf/dwarf2.h"
38 #include "dwarf2expr.h"
39 #include "dwarf2loc.h"
41 #include "gdb_string.h"
43 #ifndef DWARF2_REG_TO_REGNUM
44 #define DWARF2_REG_TO_REGNUM(REG) (REG)
47 /* A helper function for dealing with location lists. Given a
48 symbol baton (BATON) and a pc value (PC), find the appropriate
49 location expression, set *LOCEXPR_LENGTH, and return a pointer
50 to the beginning of the expression. Returns NULL on failure.
52 For now, only return the first matching location expression; there
53 can be more than one in the list. */
56 find_location_expression (struct dwarf2_loclist_baton
*baton
,
57 size_t *locexpr_length
, CORE_ADDR pc
)
60 gdb_byte
*loc_ptr
, *buf_end
;
62 unsigned int addr_size
= TARGET_ADDR_BIT
/ TARGET_CHAR_BIT
;
63 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
64 /* Adjust base_address for relocatable objects. */
65 CORE_ADDR base_offset
= ANOFFSET (baton
->objfile
->section_offsets
,
66 SECT_OFF_TEXT (baton
->objfile
));
67 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
69 loc_ptr
= baton
->data
;
70 buf_end
= baton
->data
+ baton
->size
;
74 low
= dwarf2_read_address (loc_ptr
, buf_end
, &length
);
76 high
= dwarf2_read_address (loc_ptr
, buf_end
, &length
);
79 /* An end-of-list entry. */
80 if (low
== 0 && high
== 0)
83 /* A base-address-selection entry. */
84 if ((low
& base_mask
) == base_mask
)
90 /* Otherwise, a location expression entry. */
94 length
= extract_unsigned_integer (loc_ptr
, 2);
97 if (pc
>= low
&& pc
< high
)
99 *locexpr_length
= length
;
107 /* This is the baton used when performing dwarf2 expression
109 struct dwarf_expr_baton
111 struct frame_info
*frame
;
112 struct objfile
*objfile
;
115 /* Helper functions for dwarf2_evaluate_loc_desc. */
117 /* Using the frame specified in BATON, return the value of register
118 REGNUM, treated as a pointer. */
120 dwarf_expr_read_reg (void *baton
, int dwarf_regnum
)
122 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
126 regnum
= DWARF2_REG_TO_REGNUM (dwarf_regnum
);
127 result
= address_from_register (builtin_type_void_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 framefunc
= get_frame_function (debaton
->frame
);
154 if (SYMBOL_OPS (framefunc
) == &dwarf2_loclist_funcs
)
156 struct dwarf2_loclist_baton
*symbaton
;
157 struct frame_info
*frame
= debaton
->frame
;
159 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
160 *start
= find_location_expression (symbaton
, length
,
161 get_frame_address_in_block (frame
));
165 struct dwarf2_locexpr_baton
*symbaton
;
166 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
167 *length
= symbaton
->size
;
168 *start
= symbaton
->data
;
172 error (_("Could not find the frame base for \"%s\"."),
173 SYMBOL_NATURAL_NAME (framefunc
));
176 /* Using the objfile specified in BATON, find the address for the
177 current thread's thread-local storage with offset OFFSET. */
179 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
181 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
183 return target_translate_tls_address (debaton
->objfile
, offset
);
186 /* Evaluate a location description, starting at DATA and with length
187 SIZE, to find the current location of variable VAR in the context
189 static struct value
*
190 dwarf2_evaluate_loc_desc (struct symbol
*var
, struct frame_info
*frame
,
191 gdb_byte
*data
, unsigned short size
,
192 struct objfile
*objfile
)
194 struct gdbarch
*arch
= get_frame_arch (frame
);
195 struct value
*retval
;
196 struct dwarf_expr_baton baton
;
197 struct dwarf_expr_context
*ctx
;
201 retval
= allocate_value (SYMBOL_TYPE (var
));
202 VALUE_LVAL (retval
) = not_lval
;
203 set_value_optimized_out (retval
, 1);
208 baton
.objfile
= objfile
;
210 ctx
= new_dwarf_expr_context ();
212 ctx
->read_reg
= dwarf_expr_read_reg
;
213 ctx
->read_mem
= dwarf_expr_read_mem
;
214 ctx
->get_frame_base
= dwarf_expr_frame_base
;
215 ctx
->get_tls_address
= dwarf_expr_tls_address
;
217 dwarf_expr_eval (ctx
, data
, size
);
218 if (ctx
->num_pieces
> 0)
224 retval
= allocate_value (SYMBOL_TYPE (var
));
225 contents
= value_contents_raw (retval
);
226 for (i
= 0; i
< ctx
->num_pieces
; i
++)
228 struct dwarf_expr_piece
*p
= &ctx
->pieces
[i
];
231 bfd_byte regval
[MAX_REGISTER_SIZE
];
232 int gdb_regnum
= DWARF2_REG_TO_REGNUM (p
->value
);
233 get_frame_register (frame
, gdb_regnum
, regval
);
234 memcpy (contents
+ offset
, regval
, p
->size
);
236 else /* In memory? */
238 read_memory (p
->value
, contents
+ offset
, p
->size
);
243 else if (ctx
->in_reg
)
245 CORE_ADDR dwarf_regnum
= dwarf_expr_fetch (ctx
, 0);
246 int gdb_regnum
= DWARF2_REG_TO_REGNUM (dwarf_regnum
);
247 retval
= value_from_register (SYMBOL_TYPE (var
), gdb_regnum
, frame
);
251 CORE_ADDR address
= dwarf_expr_fetch (ctx
, 0);
253 retval
= allocate_value (SYMBOL_TYPE (var
));
254 VALUE_LVAL (retval
) = lval_memory
;
255 set_value_lazy (retval
, 1);
256 VALUE_ADDRESS (retval
) = address
;
259 set_value_initialized (retval
, ctx
->initialized
);
261 free_dwarf_expr_context (ctx
);
270 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
272 struct needs_frame_baton
277 /* Reads from registers do require a frame. */
279 needs_frame_read_reg (void *baton
, int regnum
)
281 struct needs_frame_baton
*nf_baton
= baton
;
282 nf_baton
->needs_frame
= 1;
286 /* Reads from memory do not require a frame. */
288 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
290 memset (buf
, 0, len
);
293 /* Frame-relative accesses do require a frame. */
295 needs_frame_frame_base (void *baton
, gdb_byte
**start
, size_t * length
)
297 static gdb_byte lit0
= DW_OP_lit0
;
298 struct needs_frame_baton
*nf_baton
= baton
;
303 nf_baton
->needs_frame
= 1;
306 /* Thread-local accesses do require a frame. */
308 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
310 struct needs_frame_baton
*nf_baton
= baton
;
311 nf_baton
->needs_frame
= 1;
315 /* Return non-zero iff the location expression at DATA (length SIZE)
316 requires a frame to evaluate. */
319 dwarf2_loc_desc_needs_frame (gdb_byte
*data
, unsigned short size
)
321 struct needs_frame_baton baton
;
322 struct dwarf_expr_context
*ctx
;
325 baton
.needs_frame
= 0;
327 ctx
= new_dwarf_expr_context ();
329 ctx
->read_reg
= needs_frame_read_reg
;
330 ctx
->read_mem
= needs_frame_read_mem
;
331 ctx
->get_frame_base
= needs_frame_frame_base
;
332 ctx
->get_tls_address
= needs_frame_tls_address
;
334 dwarf_expr_eval (ctx
, data
, size
);
336 in_reg
= ctx
->in_reg
;
338 if (ctx
->num_pieces
> 0)
342 /* If the location has several pieces, and any of them are in
343 registers, then we will need a frame to fetch them from. */
344 for (i
= 0; i
< ctx
->num_pieces
; i
++)
345 if (ctx
->pieces
[i
].in_reg
)
349 free_dwarf_expr_context (ctx
);
351 return baton
.needs_frame
|| in_reg
;
355 dwarf2_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
356 struct axs_value
*value
, gdb_byte
*data
,
360 error (_("Symbol \"%s\" has been optimized out."),
361 SYMBOL_PRINT_NAME (symbol
));
364 && data
[0] >= DW_OP_reg0
365 && data
[0] <= DW_OP_reg31
)
367 value
->kind
= axs_lvalue_register
;
368 value
->u
.reg
= data
[0] - DW_OP_reg0
;
370 else if (data
[0] == DW_OP_regx
)
373 read_uleb128 (data
+ 1, data
+ size
, ®
);
374 value
->kind
= axs_lvalue_register
;
377 else if (data
[0] == DW_OP_fbreg
)
379 /* And this is worse than just minimal; we should honor the frame base
382 LONGEST frame_offset
;
385 buf_end
= read_sleb128 (data
+ 1, data
+ size
, &frame_offset
);
386 if (buf_end
!= data
+ size
)
387 error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
388 SYMBOL_PRINT_NAME (symbol
));
390 TARGET_VIRTUAL_FRAME_POINTER (ax
->scope
, &frame_reg
, &frame_offset
);
391 ax_reg (ax
, frame_reg
);
392 ax_const_l (ax
, frame_offset
);
393 ax_simple (ax
, aop_add
);
395 value
->kind
= axs_lvalue_memory
;
397 else if (data
[0] >= DW_OP_breg0
398 && data
[0] <= DW_OP_breg31
)
404 reg
= data
[0] - DW_OP_breg0
;
405 buf_end
= read_sleb128 (data
+ 1, data
+ size
, &offset
);
406 if (buf_end
!= data
+ size
)
407 error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
408 reg
, SYMBOL_PRINT_NAME (symbol
));
411 ax_const_l (ax
, offset
);
412 ax_simple (ax
, aop_add
);
414 value
->kind
= axs_lvalue_memory
;
417 error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
418 data
[0], SYMBOL_PRINT_NAME (symbol
));
421 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
422 evaluator to calculate the location. */
423 static struct value
*
424 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
426 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
428 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, dlbaton
->data
, dlbaton
->size
,
434 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
436 locexpr_read_needs_frame (struct symbol
*symbol
)
438 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
439 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
);
442 /* Print a natural-language description of SYMBOL to STREAM. */
444 locexpr_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
446 /* FIXME: be more extensive. */
447 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
449 if (dlbaton
->size
== 1
450 && dlbaton
->data
[0] >= DW_OP_reg0
451 && dlbaton
->data
[0] <= DW_OP_reg31
)
453 int regno
= DWARF2_REG_TO_REGNUM (dlbaton
->data
[0] - DW_OP_reg0
);
454 fprintf_filtered (stream
,
455 "a variable in register %s", REGISTER_NAME (regno
));
459 /* The location expression for a TLS variable looks like this (on a
462 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
463 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
465 0x3 is the encoding for DW_OP_addr, which has an operand as long
466 as the size of an address on the target machine (here is 8
467 bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
468 The operand represents the offset at which the variable is within
469 the thread local storage. */
471 if (dlbaton
->size
> 1
472 && dlbaton
->data
[dlbaton
->size
- 1] == DW_OP_GNU_push_tls_address
)
473 if (dlbaton
->data
[0] == DW_OP_addr
)
476 CORE_ADDR offset
= dwarf2_read_address (&dlbaton
->data
[1],
477 &dlbaton
->data
[dlbaton
->size
- 1],
479 fprintf_filtered (stream
,
480 "a thread-local variable at offset %s in the "
481 "thread-local storage for `%s'",
482 paddr_nz (offset
), dlbaton
->objfile
->name
);
487 fprintf_filtered (stream
,
488 "a variable with complex or multiple locations (DWARF2)");
493 /* Describe the location of SYMBOL as an agent value in VALUE, generating
494 any necessary bytecode in AX.
496 NOTE drow/2003-02-26: This function is extremely minimal, because
497 doing it correctly is extremely complicated and there is no
498 publicly available stub with tracepoint support for me to test
499 against. When there is one this function should be revisited. */
502 locexpr_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
503 struct axs_value
* value
)
505 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
507 dwarf2_tracepoint_var_ref (symbol
, ax
, value
, dlbaton
->data
, dlbaton
->size
);
510 /* The set of location functions used with the DWARF-2 expression
512 const struct symbol_ops dwarf2_locexpr_funcs
= {
513 locexpr_read_variable
,
514 locexpr_read_needs_frame
,
515 locexpr_describe_location
,
516 locexpr_tracepoint_var_ref
520 /* Wrapper functions for location lists. These generally find
521 the appropriate location expression and call something above. */
523 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
524 evaluator to calculate the location. */
525 static struct value
*
526 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
528 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
533 data
= find_location_expression (dlbaton
, &size
,
534 frame
? get_frame_address_in_block (frame
)
538 val
= allocate_value (SYMBOL_TYPE (symbol
));
539 VALUE_LVAL (val
) = not_lval
;
540 set_value_optimized_out (val
, 1);
543 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, data
, size
,
549 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
551 loclist_read_needs_frame (struct symbol
*symbol
)
553 /* If there's a location list, then assume we need to have a frame
554 to choose the appropriate location expression. With tracking of
555 global variables this is not necessarily true, but such tracking
556 is disabled in GCC at the moment until we figure out how to
562 /* Print a natural-language description of SYMBOL to STREAM. */
564 loclist_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
566 /* FIXME: Could print the entire list of locations. */
567 fprintf_filtered (stream
, "a variable with multiple locations");
571 /* Describe the location of SYMBOL as an agent value in VALUE, generating
572 any necessary bytecode in AX. */
574 loclist_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
575 struct axs_value
* value
)
577 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
581 data
= find_location_expression (dlbaton
, &size
, ax
->scope
);
583 error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol
));
585 dwarf2_tracepoint_var_ref (symbol
, ax
, value
, data
, size
);
588 /* The set of location functions used with the DWARF-2 expression
589 evaluator and location lists. */
590 const struct symbol_ops dwarf2_loclist_funcs
= {
591 loclist_read_variable
,
592 loclist_read_needs_frame
,
593 loclist_describe_location
,
594 loclist_tracepoint_var_ref