1 /* DWARF 2 location expression support for GDB.
2 Copyright 2003 Free Software Foundation, Inc.
3 Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or (at
10 your option) any later version.
12 This program is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
34 #include "elf/dwarf2.h"
35 #include "dwarf2expr.h"
36 #include "dwarf2loc.h"
38 #include "gdb_string.h"
40 #ifndef DWARF2_REG_TO_REGNUM
41 #define DWARF2_REG_TO_REGNUM(REG) (REG)
44 /* A helper function for dealing with location lists. Given a
45 symbol baton (BATON) and a pc value (PC), find the appropriate
46 location expression, set *LOCEXPR_LENGTH, and return a pointer
47 to the beginning of the expression. Returns NULL on failure.
49 For now, only return the first matching location expression; there
50 can be more than one in the list. */
53 find_location_expression (struct dwarf2_loclist_baton
*baton
,
54 size_t *locexpr_length
, CORE_ADDR pc
)
57 char *loc_ptr
, *buf_end
;
58 unsigned int addr_size
= TARGET_ADDR_BIT
/ TARGET_CHAR_BIT
, length
;
59 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
60 /* Adjust base_address for relocatable objects. */
61 CORE_ADDR base_offset
= ANOFFSET (baton
->objfile
->section_offsets
,
62 SECT_OFF_TEXT (baton
->objfile
));
63 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
65 loc_ptr
= baton
->data
;
66 buf_end
= baton
->data
+ baton
->size
;
70 low
= dwarf2_read_address (loc_ptr
, buf_end
, &length
);
72 high
= dwarf2_read_address (loc_ptr
, buf_end
, &length
);
75 /* An end-of-list entry. */
76 if (low
== 0 && high
== 0)
79 /* A base-address-selection entry. */
80 if ((low
& base_mask
) == base_mask
)
86 /* Otherwise, a location expression entry. */
90 length
= extract_unsigned_integer (loc_ptr
, 2);
93 if (pc
>= low
&& pc
< high
)
95 *locexpr_length
= length
;
103 /* This is the baton used when performing dwarf2 expression
105 struct dwarf_expr_baton
107 struct frame_info
*frame
;
108 struct objfile
*objfile
;
111 /* Helper functions for dwarf2_evaluate_loc_desc. */
113 /* Using the frame specified in BATON, read register REGNUM. The lval
114 type will be returned in LVALP, and for lval_memory the register
115 save address will be returned in ADDRP. */
117 dwarf_expr_read_reg (void *baton
, int dwarf_regnum
)
119 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
120 CORE_ADDR result
, save_addr
;
121 enum lval_type lval_type
;
123 int optimized
, regnum
, realnum
, regsize
;
125 regnum
= DWARF2_REG_TO_REGNUM (dwarf_regnum
);
126 regsize
= register_size (current_gdbarch
, regnum
);
127 buf
= (char *) alloca (regsize
);
129 frame_register (debaton
->frame
, regnum
, &optimized
, &lval_type
, &save_addr
,
131 /* NOTE: cagney/2003-05-22: This extract is assuming that a DWARF 2
132 address is always unsigned. That may or may not be true. */
133 result
= extract_unsigned_integer (buf
, regsize
);
138 /* Read memory at ADDR (length LEN) into BUF. */
141 dwarf_expr_read_mem (void *baton
, char *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
, unsigned char **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 framefunc
= get_frame_function (debaton
->frame
);
160 if (SYMBOL_OPS (framefunc
) == &dwarf2_loclist_funcs
)
162 struct dwarf2_loclist_baton
*symbaton
;
163 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
164 *start
= find_location_expression (symbaton
, length
,
165 get_frame_pc (debaton
->frame
));
169 struct dwarf2_locexpr_baton
*symbaton
;
170 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
171 *length
= symbaton
->size
;
172 *start
= symbaton
->data
;
176 error ("Could not find the frame base for \"%s\".",
177 SYMBOL_NATURAL_NAME (framefunc
));
180 /* Using the objfile specified in BATON, find the address for the
181 current thread's thread-local storage with offset OFFSET. */
183 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
185 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
188 if (target_get_thread_local_address_p ())
189 addr
= target_get_thread_local_address (inferior_ptid
,
192 /* It wouldn't be wrong here to try a gdbarch method, too; finding
193 TLS is an ABI-specific thing. But we don't do that yet. */
195 error ("Cannot find thread-local variables on this target");
200 /* Evaluate a location description, starting at DATA and with length
201 SIZE, to find the current location of variable VAR in the context
203 static struct value
*
204 dwarf2_evaluate_loc_desc (struct symbol
*var
, struct frame_info
*frame
,
205 unsigned char *data
, unsigned short size
,
206 struct objfile
*objfile
)
208 struct gdbarch
*arch
= get_frame_arch (frame
);
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 VALUE_OPTIMIZED_OUT (retval
) = 1;
221 baton
.objfile
= objfile
;
223 ctx
= new_dwarf_expr_context ();
225 ctx
->read_reg
= dwarf_expr_read_reg
;
226 ctx
->read_mem
= dwarf_expr_read_mem
;
227 ctx
->get_frame_base
= dwarf_expr_frame_base
;
228 ctx
->get_tls_address
= dwarf_expr_tls_address
;
230 dwarf_expr_eval (ctx
, data
, size
);
231 if (ctx
->num_pieces
> 0)
233 /* We haven't implemented splicing together pieces from
234 arbitrary sources yet. */
235 error ("The value of variable '%s' is distributed across several\n"
236 "locations, and GDB cannot access its value.\n",
237 SYMBOL_NATURAL_NAME (var
));
239 else if (ctx
->in_reg
)
241 CORE_ADDR dwarf_regnum
= dwarf_expr_fetch (ctx
, 0);
242 int gdb_regnum
= DWARF2_REG_TO_REGNUM (dwarf_regnum
);
243 retval
= value_from_register (SYMBOL_TYPE (var
), gdb_regnum
, frame
);
247 CORE_ADDR address
= dwarf_expr_fetch (ctx
, 0);
249 retval
= allocate_value (SYMBOL_TYPE (var
));
250 VALUE_LVAL (retval
) = lval_memory
;
251 VALUE_LAZY (retval
) = 1;
252 VALUE_ADDRESS (retval
) = address
;
255 free_dwarf_expr_context (ctx
);
264 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
266 struct needs_frame_baton
271 /* Reads from registers do require a frame. */
273 needs_frame_read_reg (void *baton
, int regnum
)
275 struct needs_frame_baton
*nf_baton
= baton
;
276 nf_baton
->needs_frame
= 1;
280 /* Reads from memory do not require a frame. */
282 needs_frame_read_mem (void *baton
, char *buf
, CORE_ADDR addr
, size_t len
)
284 memset (buf
, 0, len
);
287 /* Frame-relative accesses do require a frame. */
289 needs_frame_frame_base (void *baton
, unsigned char **start
, size_t * length
)
291 static char lit0
= DW_OP_lit0
;
292 struct needs_frame_baton
*nf_baton
= baton
;
297 nf_baton
->needs_frame
= 1;
300 /* Thread-local accesses do require a frame. */
302 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
304 struct needs_frame_baton
*nf_baton
= baton
;
305 nf_baton
->needs_frame
= 1;
309 /* Return non-zero iff the location expression at DATA (length SIZE)
310 requires a frame to evaluate. */
313 dwarf2_loc_desc_needs_frame (unsigned char *data
, unsigned short size
)
315 struct needs_frame_baton baton
;
316 struct dwarf_expr_context
*ctx
;
319 baton
.needs_frame
= 0;
321 ctx
= new_dwarf_expr_context ();
323 ctx
->read_reg
= needs_frame_read_reg
;
324 ctx
->read_mem
= needs_frame_read_mem
;
325 ctx
->get_frame_base
= needs_frame_frame_base
;
326 ctx
->get_tls_address
= needs_frame_tls_address
;
328 dwarf_expr_eval (ctx
, data
, size
);
330 in_reg
= ctx
->in_reg
;
332 if (ctx
->num_pieces
> 0)
336 /* If the location has several pieces, and any of them are in
337 registers, then we will need a frame to fetch them from. */
338 for (i
= 0; i
< ctx
->num_pieces
; i
++)
339 if (ctx
->pieces
[i
].in_reg
)
343 free_dwarf_expr_context (ctx
);
345 return baton
.needs_frame
|| in_reg
;
349 dwarf2_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
350 struct axs_value
* value
, unsigned char *data
,
354 error ("Symbol \"%s\" has been optimized out.",
355 SYMBOL_PRINT_NAME (symbol
));
358 && data
[0] >= DW_OP_reg0
359 && data
[0] <= DW_OP_reg31
)
361 value
->kind
= axs_lvalue_register
;
362 value
->u
.reg
= data
[0] - DW_OP_reg0
;
364 else if (data
[0] == DW_OP_regx
)
367 read_uleb128 (data
+ 1, data
+ size
, ®
);
368 value
->kind
= axs_lvalue_register
;
371 else if (data
[0] == DW_OP_fbreg
)
373 /* And this is worse than just minimal; we should honor the frame base
376 LONGEST frame_offset
;
377 unsigned char *buf_end
;
379 buf_end
= read_sleb128 (data
+ 1, data
+ size
, &frame_offset
);
380 if (buf_end
!= data
+ size
)
381 error ("Unexpected opcode after DW_OP_fbreg for symbol \"%s\".",
382 SYMBOL_PRINT_NAME (symbol
));
384 TARGET_VIRTUAL_FRAME_POINTER (ax
->scope
, &frame_reg
, &frame_offset
);
385 ax_reg (ax
, frame_reg
);
386 ax_const_l (ax
, frame_offset
);
387 ax_simple (ax
, aop_add
);
389 ax_const_l (ax
, frame_offset
);
390 ax_simple (ax
, aop_add
);
391 value
->kind
= axs_lvalue_memory
;
394 error ("Unsupported DWARF opcode in the location of \"%s\".",
395 SYMBOL_PRINT_NAME (symbol
));
398 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
399 evaluator to calculate the location. */
400 static struct value
*
401 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
403 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
405 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, dlbaton
->data
, dlbaton
->size
,
411 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
413 locexpr_read_needs_frame (struct symbol
*symbol
)
415 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
416 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
);
419 /* Print a natural-language description of SYMBOL to STREAM. */
421 locexpr_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
423 /* FIXME: be more extensive. */
424 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
426 if (dlbaton
->size
== 1
427 && dlbaton
->data
[0] >= DW_OP_reg0
428 && dlbaton
->data
[0] <= DW_OP_reg31
)
430 int regno
= DWARF2_REG_TO_REGNUM (dlbaton
->data
[0] - DW_OP_reg0
);
431 fprintf_filtered (stream
,
432 "a variable in register %s", REGISTER_NAME (regno
));
436 /* The location expression for a TLS variable looks like this (on a
439 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
440 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
442 0x3 is the encoding for DW_OP_addr, which has an operand as long
443 as the size of an address on the target machine (here is 8
444 bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
445 The operand represents the offset at which the variable is within
446 the thread local storage. */
448 if (dlbaton
->size
> 1
449 && dlbaton
->data
[dlbaton
->size
- 1] == DW_OP_GNU_push_tls_address
)
450 if (dlbaton
->data
[0] == DW_OP_addr
)
453 CORE_ADDR offset
= dwarf2_read_address (&dlbaton
->data
[1],
454 &dlbaton
->data
[dlbaton
->size
- 1],
456 fprintf_filtered (stream
,
457 "a thread-local variable at offset %s in the "
458 "thread-local storage for `%s'",
459 paddr_nz (offset
), dlbaton
->objfile
->name
);
464 fprintf_filtered (stream
,
465 "a variable with complex or multiple locations (DWARF2)");
470 /* Describe the location of SYMBOL as an agent value in VALUE, generating
471 any necessary bytecode in AX.
473 NOTE drow/2003-02-26: This function is extremely minimal, because
474 doing it correctly is extremely complicated and there is no
475 publicly available stub with tracepoint support for me to test
476 against. When there is one this function should be revisited. */
479 locexpr_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
480 struct axs_value
* value
)
482 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
484 dwarf2_tracepoint_var_ref (symbol
, ax
, value
, dlbaton
->data
, dlbaton
->size
);
487 /* The set of location functions used with the DWARF-2 expression
489 const struct symbol_ops dwarf2_locexpr_funcs
= {
490 locexpr_read_variable
,
491 locexpr_read_needs_frame
,
492 locexpr_describe_location
,
493 locexpr_tracepoint_var_ref
497 /* Wrapper functions for location lists. These generally find
498 the appropriate location expression and call something above. */
500 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
501 evaluator to calculate the location. */
502 static struct value
*
503 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
505 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
510 data
= find_location_expression (dlbaton
, &size
,
511 frame
? get_frame_pc (frame
) : 0);
513 error ("Variable \"%s\" is not available.", SYMBOL_NATURAL_NAME (symbol
));
515 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, data
, size
, dlbaton
->objfile
);
520 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
522 loclist_read_needs_frame (struct symbol
*symbol
)
524 /* If there's a location list, then assume we need to have a frame
525 to choose the appropriate location expression. With tracking of
526 global variables this is not necessarily true, but such tracking
527 is disabled in GCC at the moment until we figure out how to
533 /* Print a natural-language description of SYMBOL to STREAM. */
535 loclist_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
537 /* FIXME: Could print the entire list of locations. */
538 fprintf_filtered (stream
, "a variable with multiple locations");
542 /* Describe the location of SYMBOL as an agent value in VALUE, generating
543 any necessary bytecode in AX. */
545 loclist_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
546 struct axs_value
* value
)
548 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
552 data
= find_location_expression (dlbaton
, &size
, ax
->scope
);
554 error ("Variable \"%s\" is not available.", SYMBOL_NATURAL_NAME (symbol
));
556 dwarf2_tracepoint_var_ref (symbol
, ax
, value
, data
, size
);
559 /* The set of location functions used with the DWARF-2 expression
560 evaluator and location lists. */
561 const struct symbol_ops dwarf2_loclist_funcs
= {
562 loclist_read_variable
,
563 loclist_read_needs_frame
,
564 loclist_describe_location
,
565 loclist_tracepoint_var_ref