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. */
33 #include "elf/dwarf2.h"
34 #include "dwarf2expr.h"
35 #include "dwarf2loc.h"
37 #include "gdb_string.h"
39 #ifndef DWARF2_REG_TO_REGNUM
40 #define DWARF2_REG_TO_REGNUM(REG) (REG)
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
)
55 CORE_ADDR base_address
= baton
->base_address
;
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));
61 loc_ptr
= baton
->data
;
62 buf_end
= baton
->data
+ baton
->size
;
66 low
= dwarf2_read_address (loc_ptr
, buf_end
, &length
);
68 high
= dwarf2_read_address (loc_ptr
, buf_end
, &length
);
71 /* An end-of-list entry. */
72 if (low
== 0 && high
== 0)
75 /* A base-address-selection entry. */
76 if ((low
& base_mask
) == base_mask
)
82 /* Otherwise, a location expression entry. */
86 length
= extract_unsigned_integer (loc_ptr
, 2);
89 if (pc
>= low
&& pc
< high
)
91 *locexpr_length
= length
;
99 /* This is the baton used when performing dwarf2 expression
101 struct dwarf_expr_baton
103 struct frame_info
*frame
;
104 struct objfile
*objfile
;
107 /* Helper functions for dwarf2_evaluate_loc_desc. */
109 /* Using the frame specified in BATON, read register REGNUM. The lval
110 type will be returned in LVALP, and for lval_memory the register
111 save address will be returned in ADDRP. */
113 dwarf_expr_read_reg (void *baton
, int dwarf_regnum
)
115 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
116 CORE_ADDR result
, save_addr
;
117 enum lval_type lval_type
;
119 int optimized
, regnum
, realnum
, regsize
;
121 regnum
= DWARF2_REG_TO_REGNUM (dwarf_regnum
);
122 regsize
= register_size (current_gdbarch
, regnum
);
123 buf
= (char *) alloca (regsize
);
125 frame_register (debaton
->frame
, regnum
, &optimized
, &lval_type
, &save_addr
,
127 /* NOTE: cagney/2003-05-22: This extract is assuming that a DWARF 2
128 address is always unsigned. That may or may not be true. */
129 result
= extract_unsigned_integer (buf
, regsize
);
134 /* Read memory at ADDR (length LEN) into BUF. */
137 dwarf_expr_read_mem (void *baton
, char *buf
, CORE_ADDR addr
, size_t len
)
139 read_memory (addr
, buf
, len
);
142 /* Using the frame specified in BATON, find the location expression
143 describing the frame base. Return a pointer to it in START and
144 its length in LENGTH. */
146 dwarf_expr_frame_base (void *baton
, unsigned char **start
, size_t * length
)
148 /* FIXME: cagney/2003-03-26: This code should be using
149 get_frame_base_address(), and then implement a dwarf2 specific
151 struct symbol
*framefunc
;
152 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
154 framefunc
= get_frame_function (debaton
->frame
);
156 if (SYMBOL_LOCATION_FUNCS (framefunc
) == &dwarf2_loclist_funcs
)
158 struct dwarf2_loclist_baton
*symbaton
;
159 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
160 *start
= find_location_expression (symbaton
, length
,
161 get_frame_pc (debaton
->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
;
184 if (target_get_thread_local_address_p ())
185 addr
= target_get_thread_local_address (inferior_ptid
,
189 error ("Cannot find thread-local variables on this target");
194 /* Evaluate a location description, starting at DATA and with length
195 SIZE, to find the current location of variable VAR in the context
197 static struct value
*
198 dwarf2_evaluate_loc_desc (struct symbol
*var
, struct frame_info
*frame
,
199 unsigned char *data
, unsigned short size
,
200 struct objfile
*objfile
)
203 struct value
*retval
;
204 struct dwarf_expr_baton baton
;
205 struct dwarf_expr_context
*ctx
;
209 retval
= allocate_value (SYMBOL_TYPE (var
));
210 VALUE_LVAL (retval
) = not_lval
;
211 VALUE_OPTIMIZED_OUT (retval
) = 1;
215 baton
.objfile
= objfile
;
217 ctx
= new_dwarf_expr_context ();
219 ctx
->read_reg
= dwarf_expr_read_reg
;
220 ctx
->read_mem
= dwarf_expr_read_mem
;
221 ctx
->get_frame_base
= dwarf_expr_frame_base
;
222 ctx
->get_tls_address
= dwarf_expr_tls_address
;
224 dwarf_expr_eval (ctx
, data
, size
);
225 result
= dwarf_expr_fetch (ctx
, 0);
229 int regnum
= DWARF2_REG_TO_REGNUM (result
);
230 retval
= value_from_register (SYMBOL_TYPE (var
), regnum
, frame
);
234 retval
= allocate_value (SYMBOL_TYPE (var
));
235 VALUE_BFD_SECTION (retval
) = SYMBOL_BFD_SECTION (var
);
237 VALUE_LVAL (retval
) = lval_memory
;
238 VALUE_LAZY (retval
) = 1;
239 VALUE_ADDRESS (retval
) = result
;
242 free_dwarf_expr_context (ctx
);
251 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
253 struct needs_frame_baton
258 /* Reads from registers do require a frame. */
260 needs_frame_read_reg (void *baton
, int regnum
)
262 struct needs_frame_baton
*nf_baton
= baton
;
263 nf_baton
->needs_frame
= 1;
267 /* Reads from memory do not require a frame. */
269 needs_frame_read_mem (void *baton
, char *buf
, CORE_ADDR addr
, size_t len
)
271 memset (buf
, 0, len
);
274 /* Frame-relative accesses do require a frame. */
276 needs_frame_frame_base (void *baton
, unsigned char **start
, size_t * length
)
278 static char lit0
= DW_OP_lit0
;
279 struct needs_frame_baton
*nf_baton
= baton
;
284 nf_baton
->needs_frame
= 1;
287 /* Thread-local accesses do require a frame. */
289 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
291 struct needs_frame_baton
*nf_baton
= baton
;
292 nf_baton
->needs_frame
= 1;
296 /* Return non-zero iff the location expression at DATA (length SIZE)
297 requires a frame to evaluate. */
300 dwarf2_loc_desc_needs_frame (unsigned char *data
, unsigned short size
)
302 struct needs_frame_baton baton
;
303 struct dwarf_expr_context
*ctx
;
305 baton
.needs_frame
= 0;
307 ctx
= new_dwarf_expr_context ();
309 ctx
->read_reg
= needs_frame_read_reg
;
310 ctx
->read_mem
= needs_frame_read_mem
;
311 ctx
->get_frame_base
= needs_frame_frame_base
;
312 ctx
->get_tls_address
= needs_frame_tls_address
;
314 dwarf_expr_eval (ctx
, data
, size
);
316 free_dwarf_expr_context (ctx
);
318 return baton
.needs_frame
;
322 dwarf2_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
323 struct axs_value
* value
, unsigned char *data
,
327 error ("Symbol \"%s\" has been optimized out.",
328 SYMBOL_PRINT_NAME (symbol
));
331 && data
[0] >= DW_OP_reg0
332 && data
[0] <= DW_OP_reg31
)
334 value
->kind
= axs_lvalue_register
;
335 value
->u
.reg
= data
[0] - DW_OP_reg0
;
337 else if (data
[0] == DW_OP_regx
)
340 read_uleb128 (data
+ 1, data
+ size
, ®
);
341 value
->kind
= axs_lvalue_register
;
344 else if (data
[0] == DW_OP_fbreg
)
346 /* And this is worse than just minimal; we should honor the frame base
349 LONGEST frame_offset
;
350 unsigned char *buf_end
;
352 buf_end
= read_sleb128 (data
+ 1, data
+ size
, &frame_offset
);
353 if (buf_end
!= data
+ size
)
354 error ("Unexpected opcode after DW_OP_fbreg for symbol \"%s\".",
355 SYMBOL_PRINT_NAME (symbol
));
357 TARGET_VIRTUAL_FRAME_POINTER (ax
->scope
, &frame_reg
, &frame_offset
);
358 ax_reg (ax
, frame_reg
);
359 ax_const_l (ax
, frame_offset
);
360 ax_simple (ax
, aop_add
);
362 ax_const_l (ax
, frame_offset
);
363 ax_simple (ax
, aop_add
);
364 value
->kind
= axs_lvalue_memory
;
367 error ("Unsupported DWARF opcode in the location of \"%s\".",
368 SYMBOL_PRINT_NAME (symbol
));
371 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
372 evaluator to calculate the location. */
373 static struct value
*
374 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
376 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
378 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, dlbaton
->data
, dlbaton
->size
,
384 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
386 locexpr_read_needs_frame (struct symbol
*symbol
)
388 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
389 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
);
392 /* Print a natural-language description of SYMBOL to STREAM. */
394 locexpr_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
396 /* FIXME: be more extensive. */
397 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
399 if (dlbaton
->size
== 1
400 && dlbaton
->data
[0] >= DW_OP_reg0
401 && dlbaton
->data
[0] <= DW_OP_reg31
)
403 int regno
= DWARF2_REG_TO_REGNUM (dlbaton
->data
[0] - DW_OP_reg0
);
404 fprintf_filtered (stream
,
405 "a variable in register %s", REGISTER_NAME (regno
));
409 fprintf_filtered (stream
,
410 "a variable with complex or multiple locations (DWARF2)");
415 /* Describe the location of SYMBOL as an agent value in VALUE, generating
416 any necessary bytecode in AX.
418 NOTE drow/2003-02-26: This function is extremely minimal, because
419 doing it correctly is extremely complicated and there is no
420 publicly available stub with tracepoint support for me to test
421 against. When there is one this function should be revisited. */
424 locexpr_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
425 struct axs_value
* value
)
427 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
429 dwarf2_tracepoint_var_ref (symbol
, ax
, value
, dlbaton
->data
, dlbaton
->size
);
432 /* The set of location functions used with the DWARF-2 expression
434 struct location_funcs dwarf2_locexpr_funcs
= {
435 locexpr_read_variable
,
436 locexpr_read_needs_frame
,
437 locexpr_describe_location
,
438 locexpr_tracepoint_var_ref
442 /* Wrapper functions for location lists. These generally find
443 the appropriate location expression and call something above. */
445 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
446 evaluator to calculate the location. */
447 static struct value
*
448 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
450 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
455 data
= find_location_expression (dlbaton
, &size
,
456 frame
? get_frame_pc (frame
) : 0);
458 error ("Variable \"%s\" is not available.", SYMBOL_NATURAL_NAME (symbol
));
460 val
= dwarf2_evaluate_loc_desc (symbol
, frame
, data
, size
, dlbaton
->objfile
);
465 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
467 loclist_read_needs_frame (struct symbol
*symbol
)
469 /* If there's a location list, then assume we need to have a frame
470 to choose the appropriate location expression. With tracking of
471 global variables this is not necessarily true, but such tracking
472 is disabled in GCC at the moment until we figure out how to
478 /* Print a natural-language description of SYMBOL to STREAM. */
480 loclist_describe_location (struct symbol
*symbol
, struct ui_file
*stream
)
482 /* FIXME: Could print the entire list of locations. */
483 fprintf_filtered (stream
, "a variable with multiple locations");
487 /* Describe the location of SYMBOL as an agent value in VALUE, generating
488 any necessary bytecode in AX. */
490 loclist_tracepoint_var_ref (struct symbol
* symbol
, struct agent_expr
* ax
,
491 struct axs_value
* value
)
493 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
497 data
= find_location_expression (dlbaton
, &size
, ax
->scope
);
499 error ("Variable \"%s\" is not available.", SYMBOL_NATURAL_NAME (symbol
));
501 dwarf2_tracepoint_var_ref (symbol
, ax
, value
, data
, size
);
504 /* The set of location functions used with the DWARF-2 expression
505 evaluator and location lists. */
506 struct location_funcs dwarf2_loclist_funcs
= {
507 loclist_read_variable
,
508 loclist_read_needs_frame
,
509 loclist_describe_location
,
510 loclist_tracepoint_var_ref