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 char *loc_ptr
, *buf_end
;
61 unsigned int addr_size
= TARGET_ADDR_BIT
/ TARGET_CHAR_BIT
, length
;
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 (baton
->objfile
->section_offsets
,
65 SECT_OFF_TEXT (baton
->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 (loc_ptr
, buf_end
, &length
);
75 high
= dwarf2_read_address (loc_ptr
, buf_end
, &length
);
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);
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, read register REGNUM. The lval
117 type will be returned in LVALP, and for lval_memory the register
118 save address will be returned in ADDRP. */
120 dwarf_expr_read_reg (void *baton
, int dwarf_regnum
)
122 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
123 CORE_ADDR result
, save_addr
;
124 enum lval_type lval_type
;
126 int optimized
, regnum
, realnum
, regsize
;
128 regnum
= DWARF2_REG_TO_REGNUM (dwarf_regnum
);
129 regsize
= register_size (current_gdbarch
, regnum
);
130 buf
= (char *) alloca (regsize
);
132 frame_register (debaton
->frame
, regnum
, &optimized
, &lval_type
, &save_addr
,
134 /* NOTE: cagney/2003-05-22: This extract is assuming that a DWARF 2
135 address is always unsigned. That may or may not be true. */
136 result
= extract_unsigned_integer (buf
, regsize
);
141 /* Read memory at ADDR (length LEN) into BUF. */
144 dwarf_expr_read_mem (void *baton
, char *buf
, CORE_ADDR addr
, size_t len
)
146 read_memory (addr
, buf
, len
);
149 /* Using the frame specified in BATON, find the location expression
150 describing the frame base. Return a pointer to it in START and
151 its length in LENGTH. */
153 dwarf_expr_frame_base (void *baton
, unsigned char **start
, size_t * length
)
155 /* FIXME: cagney/2003-03-26: This code should be using
156 get_frame_base_address(), and then implement a dwarf2 specific
158 struct symbol
*framefunc
;
159 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
161 framefunc
= get_frame_function (debaton
->frame
);
163 if (SYMBOL_OPS (framefunc
) == &dwarf2_loclist_funcs
)
165 struct dwarf2_loclist_baton
*symbaton
;
166 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
167 *start
= find_location_expression (symbaton
, length
,
168 get_frame_pc (debaton
->frame
));
172 struct dwarf2_locexpr_baton
*symbaton
;
173 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
174 *length
= symbaton
->size
;
175 *start
= symbaton
->data
;
179 error (_("Could not find the frame base for \"%s\"."),
180 SYMBOL_NATURAL_NAME (framefunc
));
183 /* Using the objfile specified in BATON, find the address for the
184 current thread's thread-local storage with offset OFFSET. */
186 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
188 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
189 volatile CORE_ADDR addr
= 0;
191 if (target_get_thread_local_address_p ()
192 && gdbarch_fetch_tls_load_module_address_p (current_gdbarch
))
194 ptid_t ptid
= inferior_ptid
;
195 struct objfile
*objfile
= debaton
->objfile
;
196 volatile struct exception ex
;
198 TRY_CATCH (ex
, RETURN_MASK_ALL
)
202 /* Fetch the load module address for this objfile. */
203 lm_addr
= gdbarch_fetch_tls_load_module_address (current_gdbarch
,
205 /* If it's 0, throw the appropriate exception. */
209 = { RETURN_ERROR
, TLS_LOAD_MODULE_NOT_FOUND_ERROR
, 0 };
214 addr
= target_get_thread_local_address (ptid
, lm_addr
, offset
);
216 /* If an error occurred, print TLS related messages here. Otherwise,
217 throw the error to some higher catcher. */
220 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
224 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
225 error (_("Cannot find thread-local variables in this thread library."));
227 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
228 if (objfile_is_library
)
229 error (_("Cannot find shared library `%s' in dynamic"
230 " linker's load module list"), objfile
->name
);
232 error (_("Cannot find executable file `%s' in dynamic"
233 " linker's load module list"), objfile
->name
);
235 case TLS_NOT_ALLOCATED_YET_ERROR
:
236 if (objfile_is_library
)
237 error (_("The inferior has not yet allocated storage for"
238 " thread-local variables in\n"
239 "the shared library `%s'\n"
241 objfile
->name
, target_pid_to_str (ptid
));
243 error (_("The inferior has not yet allocated storage for"
244 " thread-local variables in\n"
245 "the executable `%s'\n"
247 objfile
->name
, target_pid_to_str (ptid
));
249 case TLS_GENERIC_ERROR
:
250 if (objfile_is_library
)
251 error (_("Cannot find thread-local storage for %s, "
252 "shared library %s:\n%s"),
253 target_pid_to_str (ptid
),
254 objfile
->name
, ex
.message
);
256 error (_("Cannot find thread-local storage for %s, "
257 "executable file %s:\n%s"),
258 target_pid_to_str (ptid
),
259 objfile
->name
, ex
.message
);
262 throw_exception (ex
);
267 /* It wouldn't be wrong here to try a gdbarch method, too; finding
268 TLS is an ABI-specific thing. But we don't do that yet. */
270 error (_("Cannot find thread-local variables on this target"));
275 /* Evaluate a location description, starting at DATA and with length
276 SIZE, to find the current location of variable VAR in the context
278 static struct value
*
279 dwarf2_evaluate_loc_desc (struct symbol
*var
, struct frame_info
*frame
,
280 unsigned char *data
, unsigned short size
,
281 struct objfile
*objfile
)
283 struct gdbarch
*arch
= get_frame_arch (frame
);
284 struct value
*retval
;
285 struct dwarf_expr_baton baton
;
286 struct dwarf_expr_context
*ctx
;
290 retval
= allocate_value (SYMBOL_TYPE (var
));
291 VALUE_LVAL (retval
) = not_lval
;
292 set_value_optimized_out (retval
, 1);
296 baton
.objfile
= objfile
;
298 ctx
= new_dwarf_expr_context ();
300 ctx
->read_reg
= dwarf_expr_read_reg
;
301 ctx
->read_mem
= dwarf_expr_read_mem
;
302 ctx
->get_frame_base
= dwarf_expr_frame_base
;
303 ctx
->get_tls_address
= dwarf_expr_tls_address
;
305 dwarf_expr_eval (ctx
, data
, size
);
306 if (ctx
->num_pieces
> 0)
308 /* We haven't implemented splicing together pieces from
309 arbitrary sources yet. */
310 error (_("The value of variable '%s' is distributed across several\n"
311 "locations, and GDB cannot access its value.\n"),
312 SYMBOL_NATURAL_NAME (var
));
314 else if (ctx
->in_reg
)
316 CORE_ADDR dwarf_regnum
= dwarf_expr_fetch (ctx
, 0);
317 int gdb_regnum
= DWARF2_REG_TO_REGNUM (dwarf_regnum
);
318 retval
= value_from_register (SYMBOL_TYPE (var
), gdb_regnum
, frame
);
322 CORE_ADDR address
= dwarf_expr_fetch (ctx
, 0);
324 retval
= allocate_value (SYMBOL_TYPE (var
));
325 VALUE_LVAL (retval
) = lval_memory
;
326 set_value_lazy (retval
, 1);
327 VALUE_ADDRESS (retval
) = address
;
330 free_dwarf_expr_context (ctx
);
339 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
341 struct needs_frame_baton
346 /* Reads from registers do require a frame. */
348 needs_frame_read_reg (void *baton
, int regnum
)
350 struct needs_frame_baton
*nf_baton
= baton
;
351 nf_baton
->needs_frame
= 1;
355 /* Reads from memory do not require a frame. */
357 needs_frame_read_mem (void *baton
, char *buf
, CORE_ADDR addr
, size_t len
)
359 memset (buf
, 0, len
);
362 /* Frame-relative accesses do require a frame. */
364 needs_frame_frame_base (void *baton
, unsigned char **start
, size_t * length
)
366 static char lit0
= DW_OP_lit0
;
367 struct needs_frame_baton
*nf_baton
= baton
;
372 nf_baton
->needs_frame
= 1;
375 /* Thread-local accesses do require a frame. */
377 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
379 struct needs_frame_baton
*nf_baton
= baton
;
380 nf_baton
->needs_frame
= 1;
384 /* Return non-zero iff the location expression at DATA (length SIZE)
385 requires a frame to evaluate. */
388 dwarf2_loc_desc_needs_frame (unsigned char *data
, unsigned short size
)
390 struct needs_frame_baton baton
;
391 struct dwarf_expr_context
*ctx
;
394 baton
.needs_frame
= 0;
396 ctx
= new_dwarf_expr_context ();
398 ctx
->read_reg
= needs_frame_read_reg
;
399 ctx
->read_mem
= needs_frame_read_mem
;
400 ctx
->get_frame_base
= needs_frame_frame_base
;
401 ctx
->get_tls_address
= needs_frame_tls_address
;
403 dwarf_expr_eval (ctx
, data
, size
);
405 in_reg
= ctx
->in_reg
;
407 if (ctx
->num_pieces
> 0)
411 /* If the location has several pieces, and any of them are in
412 registers, then we will need a frame to fetch them from. */
413 for (i
= 0; i
< ctx
->num_pieces
; i
++)
414 if (ctx
->pieces
[i
].in_reg
)
418 free_dwarf_expr_context (ctx
);
420 return baton
.needs_frame
|| in_reg
;
424 dwarf2_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
425 struct axs_value
* value
, unsigned char *data
,
429 error (_("Symbol \"%s\" has been optimized out."),
430 SYMBOL_PRINT_NAME (symbol
));
433 && data
[0] >= DW_OP_reg0
434 && data
[0] <= DW_OP_reg31
)
436 value
->kind
= axs_lvalue_register
;
437 value
->u
.reg
= data
[0] - DW_OP_reg0
;
439 else if (data
[0] == DW_OP_regx
)
442 read_uleb128 (data
+ 1, data
+ size
, ®
);
443 value
->kind
= axs_lvalue_register
;
446 else if (data
[0] == DW_OP_fbreg
)
448 /* And this is worse than just minimal; we should honor the frame base
451 LONGEST frame_offset
;
452 unsigned char *buf_end
;
454 buf_end
= read_sleb128 (data
+ 1, data
+ size
, &frame_offset
);
455 if (buf_end
!= data
+ size
)
456 error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
457 SYMBOL_PRINT_NAME (symbol
));
459 TARGET_VIRTUAL_FRAME_POINTER (ax
->scope
, &frame_reg
, &frame_offset
);
460 ax_reg (ax
, frame_reg
);
461 ax_const_l (ax
, frame_offset
);
462 ax_simple (ax
, aop_add
);
464 ax_const_l (ax
, frame_offset
);
465 ax_simple (ax
, aop_add
);
466 value
->kind
= axs_lvalue_memory
;
469 error (_("Unsupported DWARF opcode in the location of \"%s\"."),
470 SYMBOL_PRINT_NAME (symbol
));
473 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
474 evaluator to calculate the location. */
475 static struct value
*
476 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
478 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
480 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, dlbaton
->data
, dlbaton
->size
,
486 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
488 locexpr_read_needs_frame (struct symbol
*symbol
)
490 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
491 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
);
494 /* Print a natural-language description of SYMBOL to STREAM. */
496 locexpr_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
498 /* FIXME: be more extensive. */
499 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
501 if (dlbaton
->size
== 1
502 && dlbaton
->data
[0] >= DW_OP_reg0
503 && dlbaton
->data
[0] <= DW_OP_reg31
)
505 int regno
= DWARF2_REG_TO_REGNUM (dlbaton
->data
[0] - DW_OP_reg0
);
506 fprintf_filtered (stream
,
507 "a variable in register %s", REGISTER_NAME (regno
));
511 /* The location expression for a TLS variable looks like this (on a
514 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
515 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
517 0x3 is the encoding for DW_OP_addr, which has an operand as long
518 as the size of an address on the target machine (here is 8
519 bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
520 The operand represents the offset at which the variable is within
521 the thread local storage. */
523 if (dlbaton
->size
> 1
524 && dlbaton
->data
[dlbaton
->size
- 1] == DW_OP_GNU_push_tls_address
)
525 if (dlbaton
->data
[0] == DW_OP_addr
)
528 CORE_ADDR offset
= dwarf2_read_address (&dlbaton
->data
[1],
529 &dlbaton
->data
[dlbaton
->size
- 1],
531 fprintf_filtered (stream
,
532 "a thread-local variable at offset %s in the "
533 "thread-local storage for `%s'",
534 paddr_nz (offset
), dlbaton
->objfile
->name
);
539 fprintf_filtered (stream
,
540 "a variable with complex or multiple locations (DWARF2)");
545 /* Describe the location of SYMBOL as an agent value in VALUE, generating
546 any necessary bytecode in AX.
548 NOTE drow/2003-02-26: This function is extremely minimal, because
549 doing it correctly is extremely complicated and there is no
550 publicly available stub with tracepoint support for me to test
551 against. When there is one this function should be revisited. */
554 locexpr_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
555 struct axs_value
* value
)
557 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
559 dwarf2_tracepoint_var_ref (symbol
, ax
, value
, dlbaton
->data
, dlbaton
->size
);
562 /* The set of location functions used with the DWARF-2 expression
564 const struct symbol_ops dwarf2_locexpr_funcs
= {
565 locexpr_read_variable
,
566 locexpr_read_needs_frame
,
567 locexpr_describe_location
,
568 locexpr_tracepoint_var_ref
572 /* Wrapper functions for location lists. These generally find
573 the appropriate location expression and call something above. */
575 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
576 evaluator to calculate the location. */
577 static struct value
*
578 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
580 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
585 data
= find_location_expression (dlbaton
, &size
,
586 frame
? get_frame_pc (frame
) : 0);
589 val
= allocate_value (SYMBOL_TYPE (symbol
));
590 VALUE_LVAL (val
) = not_lval
;
591 set_value_optimized_out (val
, 1);
594 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, data
, size
,
600 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
602 loclist_read_needs_frame (struct symbol
*symbol
)
604 /* If there's a location list, then assume we need to have a frame
605 to choose the appropriate location expression. With tracking of
606 global variables this is not necessarily true, but such tracking
607 is disabled in GCC at the moment until we figure out how to
613 /* Print a natural-language description of SYMBOL to STREAM. */
615 loclist_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
617 /* FIXME: Could print the entire list of locations. */
618 fprintf_filtered (stream
, "a variable with multiple locations");
622 /* Describe the location of SYMBOL as an agent value in VALUE, generating
623 any necessary bytecode in AX. */
625 loclist_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
626 struct axs_value
* value
)
628 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
632 data
= find_location_expression (dlbaton
, &size
, ax
->scope
);
634 error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol
));
636 dwarf2_tracepoint_var_ref (symbol
, ax
, value
, data
, size
);
639 /* The set of location functions used with the DWARF-2 expression
640 evaluator and location lists. */
641 const struct symbol_ops dwarf2_loclist_funcs
= {
642 loclist_read_variable
,
643 loclist_read_needs_frame
,
644 loclist_describe_location
,
645 loclist_tracepoint_var_ref