1 /* DWARF 2 location expression support for GDB.
3 Copyright 2003, 2005 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., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, 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, read register REGNUM. The lval
118 type will be returned in LVALP, and for lval_memory the register
119 save address will be returned in ADDRP. */
121 dwarf_expr_read_reg (void *baton
, int dwarf_regnum
)
123 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
124 CORE_ADDR result
, save_addr
;
125 enum lval_type lval_type
;
127 int optimized
, regnum
, realnum
, regsize
;
129 regnum
= DWARF2_REG_TO_REGNUM (dwarf_regnum
);
130 regsize
= register_size (current_gdbarch
, regnum
);
131 buf
= alloca (regsize
);
133 frame_register (debaton
->frame
, regnum
, &optimized
, &lval_type
, &save_addr
,
135 /* NOTE: cagney/2003-05-22: This extract is assuming that a DWARF 2
136 address is always unsigned. That may or may not be true. */
137 result
= extract_unsigned_integer (buf
, regsize
);
142 /* Read memory at ADDR (length LEN) into BUF. */
145 dwarf_expr_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
147 read_memory (addr
, buf
, len
);
150 /* Using the frame specified in BATON, find the location expression
151 describing the frame base. Return a pointer to it in START and
152 its length in LENGTH. */
154 dwarf_expr_frame_base (void *baton
, gdb_byte
**start
, size_t * length
)
156 /* FIXME: cagney/2003-03-26: This code should be using
157 get_frame_base_address(), and then implement a dwarf2 specific
159 struct symbol
*framefunc
;
160 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
162 framefunc
= get_frame_function (debaton
->frame
);
164 if (SYMBOL_OPS (framefunc
) == &dwarf2_loclist_funcs
)
166 struct dwarf2_loclist_baton
*symbaton
;
167 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
168 *start
= find_location_expression (symbaton
, length
,
169 get_frame_pc (debaton
->frame
));
173 struct dwarf2_locexpr_baton
*symbaton
;
174 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
175 *length
= symbaton
->size
;
176 *start
= symbaton
->data
;
180 error (_("Could not find the frame base for \"%s\"."),
181 SYMBOL_NATURAL_NAME (framefunc
));
184 /* Using the objfile specified in BATON, find the address for the
185 current thread's thread-local storage with offset OFFSET. */
187 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
189 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
190 volatile CORE_ADDR addr
= 0;
192 if (target_get_thread_local_address_p ()
193 && gdbarch_fetch_tls_load_module_address_p (current_gdbarch
))
195 ptid_t ptid
= inferior_ptid
;
196 struct objfile
*objfile
= debaton
->objfile
;
197 volatile struct gdb_exception ex
;
199 TRY_CATCH (ex
, RETURN_MASK_ALL
)
203 /* Fetch the load module address for this objfile. */
204 lm_addr
= gdbarch_fetch_tls_load_module_address (current_gdbarch
,
206 /* If it's 0, throw the appropriate exception. */
208 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
209 _("TLS load module not found"));
211 addr
= target_get_thread_local_address (ptid
, lm_addr
, offset
);
213 /* If an error occurred, print TLS related messages here. Otherwise,
214 throw the error to some higher catcher. */
217 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
221 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
222 error (_("Cannot find thread-local variables in this thread library."));
224 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
225 if (objfile_is_library
)
226 error (_("Cannot find shared library `%s' in dynamic"
227 " linker's load module list"), objfile
->name
);
229 error (_("Cannot find executable file `%s' in dynamic"
230 " linker's load module list"), objfile
->name
);
232 case TLS_NOT_ALLOCATED_YET_ERROR
:
233 if (objfile_is_library
)
234 error (_("The inferior has not yet allocated storage for"
235 " thread-local variables in\n"
236 "the shared library `%s'\n"
238 objfile
->name
, target_pid_to_str (ptid
));
240 error (_("The inferior has not yet allocated storage for"
241 " thread-local variables in\n"
242 "the executable `%s'\n"
244 objfile
->name
, target_pid_to_str (ptid
));
246 case TLS_GENERIC_ERROR
:
247 if (objfile_is_library
)
248 error (_("Cannot find thread-local storage for %s, "
249 "shared library %s:\n%s"),
250 target_pid_to_str (ptid
),
251 objfile
->name
, ex
.message
);
253 error (_("Cannot find thread-local storage for %s, "
254 "executable file %s:\n%s"),
255 target_pid_to_str (ptid
),
256 objfile
->name
, ex
.message
);
259 throw_exception (ex
);
264 /* It wouldn't be wrong here to try a gdbarch method, too; finding
265 TLS is an ABI-specific thing. But we don't do that yet. */
267 error (_("Cannot find thread-local variables on this target"));
272 /* Evaluate a location description, starting at DATA and with length
273 SIZE, to find the current location of variable VAR in the context
275 static struct value
*
276 dwarf2_evaluate_loc_desc (struct symbol
*var
, struct frame_info
*frame
,
277 gdb_byte
*data
, unsigned short size
,
278 struct objfile
*objfile
)
280 struct gdbarch
*arch
= get_frame_arch (frame
);
281 struct value
*retval
;
282 struct dwarf_expr_baton baton
;
283 struct dwarf_expr_context
*ctx
;
287 retval
= allocate_value (SYMBOL_TYPE (var
));
288 VALUE_LVAL (retval
) = not_lval
;
289 set_value_optimized_out (retval
, 1);
293 baton
.objfile
= objfile
;
295 ctx
= new_dwarf_expr_context ();
297 ctx
->read_reg
= dwarf_expr_read_reg
;
298 ctx
->read_mem
= dwarf_expr_read_mem
;
299 ctx
->get_frame_base
= dwarf_expr_frame_base
;
300 ctx
->get_tls_address
= dwarf_expr_tls_address
;
302 dwarf_expr_eval (ctx
, data
, size
);
303 if (ctx
->num_pieces
> 0)
305 /* We haven't implemented splicing together pieces from
306 arbitrary sources yet. */
307 error (_("The value of variable '%s' is distributed across several\n"
308 "locations, and GDB cannot access its value.\n"),
309 SYMBOL_NATURAL_NAME (var
));
311 else if (ctx
->in_reg
)
313 CORE_ADDR dwarf_regnum
= dwarf_expr_fetch (ctx
, 0);
314 int gdb_regnum
= DWARF2_REG_TO_REGNUM (dwarf_regnum
);
315 retval
= value_from_register (SYMBOL_TYPE (var
), gdb_regnum
, frame
);
319 CORE_ADDR address
= dwarf_expr_fetch (ctx
, 0);
321 retval
= allocate_value (SYMBOL_TYPE (var
));
322 VALUE_LVAL (retval
) = lval_memory
;
323 set_value_lazy (retval
, 1);
324 VALUE_ADDRESS (retval
) = address
;
327 free_dwarf_expr_context (ctx
);
336 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
338 struct needs_frame_baton
343 /* Reads from registers do require a frame. */
345 needs_frame_read_reg (void *baton
, int regnum
)
347 struct needs_frame_baton
*nf_baton
= baton
;
348 nf_baton
->needs_frame
= 1;
352 /* Reads from memory do not require a frame. */
354 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
356 memset (buf
, 0, len
);
359 /* Frame-relative accesses do require a frame. */
361 needs_frame_frame_base (void *baton
, gdb_byte
**start
, size_t * length
)
363 static gdb_byte lit0
= DW_OP_lit0
;
364 struct needs_frame_baton
*nf_baton
= baton
;
369 nf_baton
->needs_frame
= 1;
372 /* Thread-local accesses do require a frame. */
374 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
376 struct needs_frame_baton
*nf_baton
= baton
;
377 nf_baton
->needs_frame
= 1;
381 /* Return non-zero iff the location expression at DATA (length SIZE)
382 requires a frame to evaluate. */
385 dwarf2_loc_desc_needs_frame (gdb_byte
*data
, unsigned short size
)
387 struct needs_frame_baton baton
;
388 struct dwarf_expr_context
*ctx
;
391 baton
.needs_frame
= 0;
393 ctx
= new_dwarf_expr_context ();
395 ctx
->read_reg
= needs_frame_read_reg
;
396 ctx
->read_mem
= needs_frame_read_mem
;
397 ctx
->get_frame_base
= needs_frame_frame_base
;
398 ctx
->get_tls_address
= needs_frame_tls_address
;
400 dwarf_expr_eval (ctx
, data
, size
);
402 in_reg
= ctx
->in_reg
;
404 if (ctx
->num_pieces
> 0)
408 /* If the location has several pieces, and any of them are in
409 registers, then we will need a frame to fetch them from. */
410 for (i
= 0; i
< ctx
->num_pieces
; i
++)
411 if (ctx
->pieces
[i
].in_reg
)
415 free_dwarf_expr_context (ctx
);
417 return baton
.needs_frame
|| in_reg
;
421 dwarf2_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
422 struct axs_value
*value
, gdb_byte
*data
,
426 error (_("Symbol \"%s\" has been optimized out."),
427 SYMBOL_PRINT_NAME (symbol
));
430 && data
[0] >= DW_OP_reg0
431 && data
[0] <= DW_OP_reg31
)
433 value
->kind
= axs_lvalue_register
;
434 value
->u
.reg
= data
[0] - DW_OP_reg0
;
436 else if (data
[0] == DW_OP_regx
)
439 read_uleb128 (data
+ 1, data
+ size
, ®
);
440 value
->kind
= axs_lvalue_register
;
443 else if (data
[0] == DW_OP_fbreg
)
445 /* And this is worse than just minimal; we should honor the frame base
448 LONGEST frame_offset
;
451 buf_end
= read_sleb128 (data
+ 1, data
+ size
, &frame_offset
);
452 if (buf_end
!= data
+ size
)
453 error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
454 SYMBOL_PRINT_NAME (symbol
));
456 TARGET_VIRTUAL_FRAME_POINTER (ax
->scope
, &frame_reg
, &frame_offset
);
457 ax_reg (ax
, frame_reg
);
458 ax_const_l (ax
, frame_offset
);
459 ax_simple (ax
, aop_add
);
461 ax_const_l (ax
, frame_offset
);
462 ax_simple (ax
, aop_add
);
463 value
->kind
= axs_lvalue_memory
;
466 error (_("Unsupported DWARF opcode in the location of \"%s\"."),
467 SYMBOL_PRINT_NAME (symbol
));
470 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
471 evaluator to calculate the location. */
472 static struct value
*
473 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
475 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
477 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, dlbaton
->data
, dlbaton
->size
,
483 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
485 locexpr_read_needs_frame (struct symbol
*symbol
)
487 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
488 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
);
491 /* Print a natural-language description of SYMBOL to STREAM. */
493 locexpr_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
495 /* FIXME: be more extensive. */
496 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
498 if (dlbaton
->size
== 1
499 && dlbaton
->data
[0] >= DW_OP_reg0
500 && dlbaton
->data
[0] <= DW_OP_reg31
)
502 int regno
= DWARF2_REG_TO_REGNUM (dlbaton
->data
[0] - DW_OP_reg0
);
503 fprintf_filtered (stream
,
504 "a variable in register %s", REGISTER_NAME (regno
));
508 /* The location expression for a TLS variable looks like this (on a
511 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
512 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
514 0x3 is the encoding for DW_OP_addr, which has an operand as long
515 as the size of an address on the target machine (here is 8
516 bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
517 The operand represents the offset at which the variable is within
518 the thread local storage. */
520 if (dlbaton
->size
> 1
521 && dlbaton
->data
[dlbaton
->size
- 1] == DW_OP_GNU_push_tls_address
)
522 if (dlbaton
->data
[0] == DW_OP_addr
)
525 CORE_ADDR offset
= dwarf2_read_address (&dlbaton
->data
[1],
526 &dlbaton
->data
[dlbaton
->size
- 1],
528 fprintf_filtered (stream
,
529 "a thread-local variable at offset %s in the "
530 "thread-local storage for `%s'",
531 paddr_nz (offset
), dlbaton
->objfile
->name
);
536 fprintf_filtered (stream
,
537 "a variable with complex or multiple locations (DWARF2)");
542 /* Describe the location of SYMBOL as an agent value in VALUE, generating
543 any necessary bytecode in AX.
545 NOTE drow/2003-02-26: This function is extremely minimal, because
546 doing it correctly is extremely complicated and there is no
547 publicly available stub with tracepoint support for me to test
548 against. When there is one this function should be revisited. */
551 locexpr_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
552 struct axs_value
* value
)
554 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
556 dwarf2_tracepoint_var_ref (symbol
, ax
, value
, dlbaton
->data
, dlbaton
->size
);
559 /* The set of location functions used with the DWARF-2 expression
561 const struct symbol_ops dwarf2_locexpr_funcs
= {
562 locexpr_read_variable
,
563 locexpr_read_needs_frame
,
564 locexpr_describe_location
,
565 locexpr_tracepoint_var_ref
569 /* Wrapper functions for location lists. These generally find
570 the appropriate location expression and call something above. */
572 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
573 evaluator to calculate the location. */
574 static struct value
*
575 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
577 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
582 data
= find_location_expression (dlbaton
, &size
,
583 frame
? get_frame_pc (frame
) : 0);
586 val
= allocate_value (SYMBOL_TYPE (symbol
));
587 VALUE_LVAL (val
) = not_lval
;
588 set_value_optimized_out (val
, 1);
591 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, data
, size
,
597 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
599 loclist_read_needs_frame (struct symbol
*symbol
)
601 /* If there's a location list, then assume we need to have a frame
602 to choose the appropriate location expression. With tracking of
603 global variables this is not necessarily true, but such tracking
604 is disabled in GCC at the moment until we figure out how to
610 /* Print a natural-language description of SYMBOL to STREAM. */
612 loclist_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
614 /* FIXME: Could print the entire list of locations. */
615 fprintf_filtered (stream
, "a variable with multiple locations");
619 /* Describe the location of SYMBOL as an agent value in VALUE, generating
620 any necessary bytecode in AX. */
622 loclist_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
623 struct axs_value
* value
)
625 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
629 data
= find_location_expression (dlbaton
, &size
, ax
->scope
);
631 error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol
));
633 dwarf2_tracepoint_var_ref (symbol
, ax
, value
, data
, size
);
636 /* The set of location functions used with the DWARF-2 expression
637 evaluator and location lists. */
638 const struct symbol_ops dwarf2_loclist_funcs
= {
639 loclist_read_variable
,
640 loclist_read_needs_frame
,
641 loclist_describe_location
,
642 loclist_tracepoint_var_ref