1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003, 2005, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
34 #include "exceptions.h"
39 #include "dwarf2expr.h"
40 #include "dwarf2loc.h"
41 #include "dwarf2-frame.h"
43 #include "gdb_string.h"
44 #include "gdb_assert.h"
46 extern int dwarf2_always_disassemble
;
48 static void dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
49 const gdb_byte
**start
, size_t *length
);
51 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
;
53 static struct value
*dwarf2_evaluate_loc_desc_full (struct type
*type
,
54 struct frame_info
*frame
,
57 struct dwarf2_per_cu_data
*per_cu
,
60 /* A function for dealing with location lists. Given a
61 symbol baton (BATON) and a pc value (PC), find the appropriate
62 location expression, set *LOCEXPR_LENGTH, and return a pointer
63 to the beginning of the expression. Returns NULL on failure.
65 For now, only return the first matching location expression; there
66 can be more than one in the list. */
69 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
70 size_t *locexpr_length
, CORE_ADDR pc
)
73 const gdb_byte
*loc_ptr
, *buf_end
;
75 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
76 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
77 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
78 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
79 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
80 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
81 /* Adjust base_address for relocatable objects. */
82 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (baton
->per_cu
);
83 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
85 loc_ptr
= baton
->data
;
86 buf_end
= baton
->data
+ baton
->size
;
90 if (buf_end
- loc_ptr
< 2 * addr_size
)
91 error (_("dwarf2_find_location_expression: "
92 "Corrupted DWARF expression."));
95 low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
97 low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
101 high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
103 high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
104 loc_ptr
+= addr_size
;
106 /* A base-address-selection entry. */
107 if ((low
& base_mask
) == base_mask
)
109 base_address
= high
+ base_offset
;
113 /* An end-of-list entry. */
114 if (low
== 0 && high
== 0)
120 /* Otherwise, a location expression entry. */
122 high
+= base_address
;
124 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
127 if (low
== high
&& pc
== low
)
129 /* This is entry PC record present only at entry point
130 of a function. Verify it is really the function entry point. */
132 struct block
*pc_block
= block_for_pc (pc
);
133 struct symbol
*pc_func
= NULL
;
136 pc_func
= block_linkage_function (pc_block
);
138 if (pc_func
&& pc
== BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func
)))
140 *locexpr_length
= length
;
145 if (pc
>= low
&& pc
< high
)
147 *locexpr_length
= length
;
155 /* This is the baton used when performing dwarf2 expression
157 struct dwarf_expr_baton
159 struct frame_info
*frame
;
160 struct dwarf2_per_cu_data
*per_cu
;
163 /* Helper functions for dwarf2_evaluate_loc_desc. */
165 /* Using the frame specified in BATON, return the value of register
166 REGNUM, treated as a pointer. */
168 dwarf_expr_read_reg (void *baton
, int dwarf_regnum
)
170 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
171 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
175 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
176 result
= address_from_register (builtin_type (gdbarch
)->builtin_data_ptr
,
177 regnum
, debaton
->frame
);
181 /* Read memory at ADDR (length LEN) into BUF. */
184 dwarf_expr_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
186 read_memory (addr
, buf
, len
);
189 /* Using the frame specified in BATON, find the location expression
190 describing the frame base. Return a pointer to it in START and
191 its length in LENGTH. */
193 dwarf_expr_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
195 /* FIXME: cagney/2003-03-26: This code should be using
196 get_frame_base_address(), and then implement a dwarf2 specific
198 struct symbol
*framefunc
;
199 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
201 /* Use block_linkage_function, which returns a real (not inlined)
202 function, instead of get_frame_function, which may return an
204 framefunc
= block_linkage_function (get_frame_block (debaton
->frame
, NULL
));
206 /* If we found a frame-relative symbol then it was certainly within
207 some function associated with a frame. If we can't find the frame,
208 something has gone wrong. */
209 gdb_assert (framefunc
!= NULL
);
211 dwarf_expr_frame_base_1 (framefunc
,
212 get_frame_address_in_block (debaton
->frame
),
217 dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
218 const gdb_byte
**start
, size_t *length
)
220 if (SYMBOL_LOCATION_BATON (framefunc
) == NULL
)
222 else if (SYMBOL_COMPUTED_OPS (framefunc
) == &dwarf2_loclist_funcs
)
224 struct dwarf2_loclist_baton
*symbaton
;
226 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
227 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
231 struct dwarf2_locexpr_baton
*symbaton
;
233 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
234 if (symbaton
!= NULL
)
236 *length
= symbaton
->size
;
237 *start
= symbaton
->data
;
244 error (_("Could not find the frame base for \"%s\"."),
245 SYMBOL_NATURAL_NAME (framefunc
));
248 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
249 the frame in BATON. */
252 dwarf_expr_frame_cfa (void *baton
)
254 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
256 return dwarf2_frame_cfa (debaton
->frame
);
259 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
260 the frame in BATON. */
263 dwarf_expr_frame_pc (void *baton
)
265 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
267 return get_frame_address_in_block (debaton
->frame
);
270 /* Using the objfile specified in BATON, find the address for the
271 current thread's thread-local storage with offset OFFSET. */
273 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
275 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
276 struct objfile
*objfile
= dwarf2_per_cu_objfile (debaton
->per_cu
);
278 return target_translate_tls_address (objfile
, offset
);
281 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
282 current CU (as is PER_CU). State of the CTX is not affected by the
286 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, size_t die_offset
,
287 struct dwarf2_per_cu_data
*per_cu
,
288 CORE_ADDR (*get_frame_pc
) (void *baton
),
291 struct dwarf2_locexpr_baton block
;
293 block
= dwarf2_fetch_die_location_block (die_offset
, per_cu
,
294 get_frame_pc
, baton
);
296 /* DW_OP_call_ref is currently not supported. */
297 gdb_assert (block
.per_cu
== per_cu
);
299 dwarf_expr_eval (ctx
, block
.data
, block
.size
);
302 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
305 dwarf_expr_dwarf_call (struct dwarf_expr_context
*ctx
, size_t die_offset
)
307 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
309 per_cu_dwarf_call (ctx
, die_offset
, debaton
->per_cu
,
310 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
313 /* Callback function for dwarf2_evaluate_loc_desc. */
316 dwarf_expr_get_base_type (struct dwarf_expr_context
*ctx
, size_t die_offset
)
318 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
320 return dwarf2_get_die_type (die_offset
, debaton
->per_cu
);
323 /* See dwarf2loc.h. */
325 int entry_values_debug
= 0;
327 /* Helper to set entry_values_debug. */
330 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
331 struct cmd_list_element
*c
, const char *value
)
333 fprintf_filtered (file
,
334 _("Entry values and tail call frames debugging is %s.\n"),
338 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
339 CALLER_FRAME (for registers) can be NULL if it is not known. This function
340 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
343 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
344 struct call_site
*call_site
,
345 struct frame_info
*caller_frame
)
347 switch (FIELD_LOC_KIND (call_site
->target
))
349 case FIELD_LOC_KIND_DWARF_BLOCK
:
351 struct dwarf2_locexpr_baton
*dwarf_block
;
353 struct type
*caller_core_addr_type
;
354 struct gdbarch
*caller_arch
;
356 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
357 if (dwarf_block
== NULL
)
359 struct minimal_symbol
*msym
;
361 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
362 throw_error (NO_ENTRY_VALUE_ERROR
,
363 _("DW_AT_GNU_call_site_target is not specified "
365 paddress (call_site_gdbarch
, call_site
->pc
),
366 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
369 if (caller_frame
== NULL
)
371 struct minimal_symbol
*msym
;
373 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
374 throw_error (NO_ENTRY_VALUE_ERROR
,
375 _("DW_AT_GNU_call_site_target DWARF block resolving "
376 "requires known frame which is currently not "
377 "available at %s in %s"),
378 paddress (call_site_gdbarch
, call_site
->pc
),
379 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
382 caller_arch
= get_frame_arch (caller_frame
);
383 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
384 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
385 dwarf_block
->data
, dwarf_block
->size
,
386 dwarf_block
->per_cu
);
387 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
389 if (VALUE_LVAL (val
) == lval_memory
)
390 return value_address (val
);
392 return value_as_address (val
);
395 case FIELD_LOC_KIND_PHYSNAME
:
397 const char *physname
;
398 struct minimal_symbol
*msym
;
400 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
401 msym
= lookup_minimal_symbol_text (physname
, NULL
);
404 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
405 throw_error (NO_ENTRY_VALUE_ERROR
,
406 _("Cannot find function \"%s\" for a call site target "
408 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
409 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
412 return SYMBOL_VALUE_ADDRESS (msym
);
415 case FIELD_LOC_KIND_PHYSADDR
:
416 return FIELD_STATIC_PHYSADDR (call_site
->target
);
419 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
423 /* Convert function entry point exact address ADDR to the function which is
424 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
425 NO_ENTRY_VALUE_ERROR otherwise. */
427 static struct symbol
*
428 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
430 struct symbol
*sym
= find_pc_function (addr
);
433 if (sym
== NULL
|| BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
434 throw_error (NO_ENTRY_VALUE_ERROR
,
435 _("DW_TAG_GNU_call_site resolving failed to find function "
436 "name for address %s"),
437 paddress (gdbarch
, addr
));
439 type
= SYMBOL_TYPE (sym
);
440 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
441 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
446 /* Verify function with entry point exact address ADDR can never call itself
447 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
448 can call itself via tail calls.
450 If a funtion can tail call itself its entry value based parameters are
451 unreliable. There is no verification whether the value of some/all
452 parameters is unchanged through the self tail call, we expect if there is
453 a self tail call all the parameters can be modified. */
456 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
458 struct obstack addr_obstack
;
459 struct cleanup
*old_chain
;
462 /* Track here CORE_ADDRs which were already visited. */
465 /* The verification is completely unordered. Track here function addresses
466 which still need to be iterated. */
467 VEC (CORE_ADDR
) *todo
= NULL
;
469 obstack_init (&addr_obstack
);
470 old_chain
= make_cleanup_obstack_free (&addr_obstack
);
471 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
472 &addr_obstack
, hashtab_obstack_allocate
,
474 make_cleanup_htab_delete (addr_hash
);
476 make_cleanup (VEC_cleanup (CORE_ADDR
), &todo
);
478 VEC_safe_push (CORE_ADDR
, todo
, verify_addr
);
479 while (!VEC_empty (CORE_ADDR
, todo
))
481 struct symbol
*func_sym
;
482 struct call_site
*call_site
;
484 addr
= VEC_pop (CORE_ADDR
, todo
);
486 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
488 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
489 call_site
; call_site
= call_site
->tail_call_next
)
491 CORE_ADDR target_addr
;
494 /* CALLER_FRAME with registers is not available for tail-call jumped
496 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
498 if (target_addr
== verify_addr
)
500 struct minimal_symbol
*msym
;
502 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
503 throw_error (NO_ENTRY_VALUE_ERROR
,
504 _("DW_OP_GNU_entry_value resolving has found "
505 "function \"%s\" at %s can call itself via tail "
507 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
),
508 paddress (gdbarch
, verify_addr
));
511 slot
= htab_find_slot (addr_hash
, &target_addr
, INSERT
);
514 *slot
= obstack_copy (&addr_obstack
, &target_addr
,
515 sizeof (target_addr
));
516 VEC_safe_push (CORE_ADDR
, todo
, target_addr
);
521 do_cleanups (old_chain
);
524 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
525 ENTRY_VALUES_DEBUG. */
528 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
530 CORE_ADDR addr
= call_site
->pc
;
531 struct minimal_symbol
*msym
= lookup_minimal_symbol_by_pc (addr
- 1);
533 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
534 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
538 /* vec.h needs single word type name, typedef it. */
539 typedef struct call_site
*call_sitep
;
541 /* Define VEC (call_sitep) functions. */
542 DEF_VEC_P (call_sitep
);
544 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
545 only top callers and bottom callees which are present in both. GDBARCH is
546 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
547 no remaining possibilities to provide unambiguous non-trivial result.
548 RESULTP should point to NULL on the first (initialization) call. Caller is
549 responsible for xfree of any RESULTP data. */
552 chain_candidate (struct gdbarch
*gdbarch
, struct call_site_chain
**resultp
,
553 VEC (call_sitep
) *chain
)
555 struct call_site_chain
*result
= *resultp
;
556 long length
= VEC_length (call_sitep
, chain
);
557 int callers
, callees
, idx
;
561 /* Create the initial chain containing all the passed PCs. */
563 result
= xmalloc (sizeof (*result
) + sizeof (*result
->call_site
)
565 result
->length
= length
;
566 result
->callers
= result
->callees
= length
;
567 memcpy (result
->call_site
, VEC_address (call_sitep
, chain
),
568 sizeof (*result
->call_site
) * length
);
571 if (entry_values_debug
)
573 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
574 for (idx
= 0; idx
< length
; idx
++)
575 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
576 fputc_unfiltered ('\n', gdb_stdlog
);
582 if (entry_values_debug
)
584 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
585 for (idx
= 0; idx
< length
; idx
++)
586 tailcall_dump (gdbarch
, VEC_index (call_sitep
, chain
, idx
));
587 fputc_unfiltered ('\n', gdb_stdlog
);
590 /* Intersect callers. */
592 callers
= min (result
->callers
, length
);
593 for (idx
= 0; idx
< callers
; idx
++)
594 if (result
->call_site
[idx
] != VEC_index (call_sitep
, chain
, idx
))
596 result
->callers
= idx
;
600 /* Intersect callees. */
602 callees
= min (result
->callees
, length
);
603 for (idx
= 0; idx
< callees
; idx
++)
604 if (result
->call_site
[result
->length
- 1 - idx
]
605 != VEC_index (call_sitep
, chain
, length
- 1 - idx
))
607 result
->callees
= idx
;
611 if (entry_values_debug
)
613 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
614 for (idx
= 0; idx
< result
->callers
; idx
++)
615 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
616 fputs_unfiltered (" |", gdb_stdlog
);
617 for (idx
= 0; idx
< result
->callees
; idx
++)
618 tailcall_dump (gdbarch
, result
->call_site
[result
->length
619 - result
->callees
+ idx
]);
620 fputc_unfiltered ('\n', gdb_stdlog
);
623 if (result
->callers
== 0 && result
->callees
== 0)
625 /* There are no common callers or callees. It could be also a direct
626 call (which has length 0) with ambiguous possibility of an indirect
627 call - CALLERS == CALLEES == 0 is valid during the first allocation
628 but any subsequence processing of such entry means ambiguity. */
634 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
635 PC again. In such case there must be two different code paths to reach
636 it, therefore some of the former determined intermediate PCs must differ
637 and the unambiguous chain gets shortened. */
638 gdb_assert (result
->callers
+ result
->callees
< result
->length
);
641 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
642 assumed frames between them use GDBARCH. Use depth first search so we can
643 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
644 would have needless GDB stack overhead. Caller is responsible for xfree of
645 the returned result. Any unreliability results in thrown
646 NO_ENTRY_VALUE_ERROR. */
648 static struct call_site_chain
*
649 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
652 struct func_type
*func_specific
;
653 struct obstack addr_obstack
;
654 struct cleanup
*back_to_retval
, *back_to_workdata
;
655 struct call_site_chain
*retval
= NULL
;
656 struct call_site
*call_site
;
658 /* Mark CALL_SITEs so we do not visit the same ones twice. */
661 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
662 call_site nor any possible call_site at CALLEE_PC's function is there.
663 Any CALL_SITE in CHAIN will be iterated to its siblings - via
664 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
665 VEC (call_sitep
) *chain
= NULL
;
667 /* We are not interested in the specific PC inside the callee function. */
668 callee_pc
= get_pc_function_start (callee_pc
);
670 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
671 paddress (gdbarch
, callee_pc
));
673 back_to_retval
= make_cleanup (free_current_contents
, &retval
);
675 obstack_init (&addr_obstack
);
676 back_to_workdata
= make_cleanup_obstack_free (&addr_obstack
);
677 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
678 &addr_obstack
, hashtab_obstack_allocate
,
680 make_cleanup_htab_delete (addr_hash
);
682 make_cleanup (VEC_cleanup (call_sitep
), &chain
);
684 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
685 at the target's function. All the possible tail call sites in the
686 target's function will get iterated as already pushed into CHAIN via their
688 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
692 CORE_ADDR target_func_addr
;
693 struct call_site
*target_call_site
;
695 /* CALLER_FRAME with registers is not available for tail-call jumped
697 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
699 if (target_func_addr
== callee_pc
)
701 chain_candidate (gdbarch
, &retval
, chain
);
705 /* There is no way to reach CALLEE_PC again as we would prevent
706 entering it twice as being already marked in ADDR_HASH. */
707 target_call_site
= NULL
;
711 struct symbol
*target_func
;
713 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
714 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
719 /* Attempt to visit TARGET_CALL_SITE. */
721 if (target_call_site
)
725 slot
= htab_find_slot (addr_hash
, &target_call_site
->pc
, INSERT
);
728 /* Successfully entered TARGET_CALL_SITE. */
730 *slot
= &target_call_site
->pc
;
731 VEC_safe_push (call_sitep
, chain
, target_call_site
);
736 /* Backtrack (without revisiting the originating call_site). Try the
737 callers's sibling; if there isn't any try the callers's callers's
740 target_call_site
= NULL
;
741 while (!VEC_empty (call_sitep
, chain
))
743 call_site
= VEC_pop (call_sitep
, chain
);
745 gdb_assert (htab_find_slot (addr_hash
, &call_site
->pc
,
747 htab_remove_elt (addr_hash
, &call_site
->pc
);
749 target_call_site
= call_site
->tail_call_next
;
750 if (target_call_site
)
754 while (target_call_site
);
756 if (VEC_empty (call_sitep
, chain
))
759 call_site
= VEC_last (call_sitep
, chain
);
764 struct minimal_symbol
*msym_caller
, *msym_callee
;
766 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
767 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
768 throw_error (NO_ENTRY_VALUE_ERROR
,
769 _("There are no unambiguously determinable intermediate "
770 "callers or callees between caller function \"%s\" at %s "
771 "and callee function \"%s\" at %s"),
773 ? "???" : SYMBOL_PRINT_NAME (msym_caller
)),
774 paddress (gdbarch
, caller_pc
),
776 ? "???" : SYMBOL_PRINT_NAME (msym_callee
)),
777 paddress (gdbarch
, callee_pc
));
780 do_cleanups (back_to_workdata
);
781 discard_cleanups (back_to_retval
);
785 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
786 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
787 constructed return NULL. Caller is responsible for xfree of the returned
790 struct call_site_chain
*
791 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
794 volatile struct gdb_exception e
;
795 struct call_site_chain
*retval
= NULL
;
797 TRY_CATCH (e
, RETURN_MASK_ERROR
)
799 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
803 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
805 if (entry_values_debug
)
806 exception_print (gdb_stdout
, e
);
816 /* Fetch call_site_parameter from caller matching the parameters. FRAME is for
817 callee. See DWARF_REG and FB_OFFSET description at struct
818 dwarf_expr_context_funcs->push_dwarf_reg_entry_value.
820 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
823 static struct call_site_parameter
*
824 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
, int dwarf_reg
,
826 struct dwarf2_per_cu_data
**per_cu_return
)
828 CORE_ADDR func_addr
= get_frame_func (frame
);
830 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
831 struct frame_info
*caller_frame
= get_prev_frame (frame
);
832 struct call_site
*call_site
;
835 struct dwarf2_locexpr_baton
*dwarf_block
;
836 /* Initialize it just to avoid a GCC false warning. */
837 struct call_site_parameter
*parameter
= NULL
;
838 CORE_ADDR target_addr
;
840 if (gdbarch
!= frame_unwind_arch (frame
))
842 struct minimal_symbol
*msym
= lookup_minimal_symbol_by_pc (func_addr
);
843 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
845 throw_error (NO_ENTRY_VALUE_ERROR
,
846 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
847 "(of %s (%s)) does not match caller gdbarch %s"),
848 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
849 paddress (gdbarch
, func_addr
),
850 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
),
851 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
854 if (caller_frame
== NULL
)
856 struct minimal_symbol
*msym
= lookup_minimal_symbol_by_pc (func_addr
);
858 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_GNU_entry_value resolving "
859 "requires caller of %s (%s)"),
860 paddress (gdbarch
, func_addr
),
861 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
863 caller_pc
= get_frame_pc (caller_frame
);
864 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
866 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
867 if (target_addr
!= func_addr
)
869 struct minimal_symbol
*target_msym
, *func_msym
;
871 target_msym
= lookup_minimal_symbol_by_pc (target_addr
);
872 func_msym
= lookup_minimal_symbol_by_pc (func_addr
);
873 throw_error (NO_ENTRY_VALUE_ERROR
,
874 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
875 "but the called frame is for %s at %s"),
876 (target_msym
== NULL
? "???"
877 : SYMBOL_PRINT_NAME (target_msym
)),
878 paddress (gdbarch
, target_addr
),
879 func_msym
== NULL
? "???" : SYMBOL_PRINT_NAME (func_msym
),
880 paddress (gdbarch
, func_addr
));
883 /* No entry value based parameters would be reliable if this function can
884 call itself via tail calls. */
885 func_verify_no_selftailcall (gdbarch
, func_addr
);
887 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
889 parameter
= &call_site
->parameter
[iparams
];
890 if (parameter
->dwarf_reg
== -1 && dwarf_reg
== -1)
892 if (parameter
->fb_offset
== fb_offset
)
895 else if (parameter
->dwarf_reg
== dwarf_reg
)
898 if (iparams
== call_site
->parameter_count
)
900 struct minimal_symbol
*msym
= lookup_minimal_symbol_by_pc (caller_pc
);
902 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
903 determine its value. */
904 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
905 "at DW_TAG_GNU_call_site %s at %s"),
906 paddress (gdbarch
, caller_pc
),
907 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
910 *per_cu_return
= call_site
->per_cu
;
914 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
915 the normal DW_AT_GNU_call_site_value block. Otherwise return the
916 DW_AT_GNU_call_site_data_value (dereferenced) block.
918 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
921 Function always returns non-NULL, non-optimized out value. It throws
922 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
924 static struct value
*
925 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
926 CORE_ADDR deref_size
, struct type
*type
,
927 struct frame_info
*caller_frame
,
928 struct dwarf2_per_cu_data
*per_cu
)
930 const gdb_byte
*data_src
;
934 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
935 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
937 /* DEREF_SIZE size is not verified here. */
938 if (data_src
== NULL
)
939 throw_error (NO_ENTRY_VALUE_ERROR
,
940 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
942 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
943 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
945 data
= alloca (size
+ 1);
946 memcpy (data
, data_src
, size
);
947 data
[size
] = DW_OP_stack_value
;
949 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
952 /* Execute call_site_parameter's DWARF block matching DEREF_SIZE for caller of
953 the CTX's frame. CTX must be of dwarf_expr_ctx_funcs kind. See DWARF_REG
954 and FB_OFFSET description at struct
955 dwarf_expr_context_funcs->push_dwarf_reg_entry_value.
957 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
958 can be more simple as it does not support cross-CU DWARF executions. */
961 dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
962 int dwarf_reg
, CORE_ADDR fb_offset
,
965 struct dwarf_expr_baton
*debaton
;
966 struct frame_info
*frame
, *caller_frame
;
967 struct dwarf2_per_cu_data
*caller_per_cu
;
968 struct dwarf_expr_baton baton_local
;
969 struct dwarf_expr_context saved_ctx
;
970 struct call_site_parameter
*parameter
;
971 const gdb_byte
*data_src
;
974 gdb_assert (ctx
->funcs
== &dwarf_expr_ctx_funcs
);
975 debaton
= ctx
->baton
;
976 frame
= debaton
->frame
;
977 caller_frame
= get_prev_frame (frame
);
979 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, dwarf_reg
, fb_offset
,
981 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
982 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
984 /* DEREF_SIZE size is not verified here. */
985 if (data_src
== NULL
)
986 throw_error (NO_ENTRY_VALUE_ERROR
,
987 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
989 baton_local
.frame
= caller_frame
;
990 baton_local
.per_cu
= caller_per_cu
;
992 saved_ctx
.gdbarch
= ctx
->gdbarch
;
993 saved_ctx
.addr_size
= ctx
->addr_size
;
994 saved_ctx
.offset
= ctx
->offset
;
995 saved_ctx
.baton
= ctx
->baton
;
996 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (baton_local
.per_cu
));
997 ctx
->addr_size
= dwarf2_per_cu_addr_size (baton_local
.per_cu
);
998 ctx
->offset
= dwarf2_per_cu_text_offset (baton_local
.per_cu
);
999 ctx
->baton
= &baton_local
;
1001 dwarf_expr_eval (ctx
, data_src
, size
);
1003 ctx
->gdbarch
= saved_ctx
.gdbarch
;
1004 ctx
->addr_size
= saved_ctx
.addr_size
;
1005 ctx
->offset
= saved_ctx
.offset
;
1006 ctx
->baton
= saved_ctx
.baton
;
1009 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1010 the indirect method on it, that is use its stored target value, the sole
1011 purpose of entry_data_value_funcs.. */
1013 static struct value
*
1014 entry_data_value_coerce_ref (const struct value
*value
)
1016 struct type
*checked_type
= check_typedef (value_type (value
));
1017 struct value
*target_val
;
1019 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
)
1022 target_val
= value_computed_closure (value
);
1023 value_incref (target_val
);
1027 /* Implement copy_closure. */
1030 entry_data_value_copy_closure (const struct value
*v
)
1032 struct value
*target_val
= value_computed_closure (v
);
1034 value_incref (target_val
);
1038 /* Implement free_closure. */
1041 entry_data_value_free_closure (struct value
*v
)
1043 struct value
*target_val
= value_computed_closure (v
);
1045 value_free (target_val
);
1048 /* Vector for methods for an entry value reference where the referenced value
1049 is stored in the caller. On the first dereference use
1050 DW_AT_GNU_call_site_data_value in the caller. */
1052 static const struct lval_funcs entry_data_value_funcs
=
1056 NULL
, /* check_validity */
1057 NULL
, /* check_any_valid */
1058 NULL
, /* indirect */
1059 entry_data_value_coerce_ref
,
1060 NULL
, /* check_synthetic_pointer */
1061 entry_data_value_copy_closure
,
1062 entry_data_value_free_closure
1065 /* Read parameter of TYPE at (callee) FRAME's function entry. DWARF_REG and
1066 FB_OFFSET are used to match DW_AT_location at the caller's
1067 DW_TAG_GNU_call_site_parameter. See DWARF_REG and FB_OFFSET description at
1068 struct dwarf_expr_context_funcs->push_dwarf_reg_entry_value.
1070 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1071 cannot resolve the parameter for any reason. */
1073 static struct value
*
1074 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1075 int dwarf_reg
, CORE_ADDR fb_offset
)
1077 struct type
*checked_type
= check_typedef (type
);
1078 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1079 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1080 struct value
*outer_val
, *target_val
, *val
;
1081 struct call_site_parameter
*parameter
;
1082 struct dwarf2_per_cu_data
*caller_per_cu
;
1085 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, dwarf_reg
, fb_offset
,
1088 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1092 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1093 used and it is not available do not fall back to OUTER_VAL - dereferencing
1094 TYPE_CODE_REF with non-entry data value would give current value - not the
1097 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
1098 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1101 target_val
= dwarf_entry_parameter_to_value (parameter
,
1102 TYPE_LENGTH (target_type
),
1103 target_type
, caller_frame
,
1106 /* value_as_address dereferences TYPE_CODE_REF. */
1107 addr
= extract_typed_address (value_contents (outer_val
), checked_type
);
1109 /* The target entry value has artificial address of the entry value
1111 VALUE_LVAL (target_val
) = lval_memory
;
1112 set_value_address (target_val
, addr
);
1114 release_value (target_val
);
1115 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1116 target_val
/* closure */);
1118 /* Copy the referencing pointer to the new computed value. */
1119 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1120 TYPE_LENGTH (checked_type
));
1121 set_value_lazy (val
, 0);
1126 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1127 SIZE are DWARF block used to match DW_AT_location at the caller's
1128 DW_TAG_GNU_call_site_parameter.
1130 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1131 cannot resolve the parameter for any reason. */
1133 static struct value
*
1134 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1135 const gdb_byte
*block
, size_t block_len
)
1138 CORE_ADDR fb_offset
;
1140 dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1141 if (dwarf_reg
!= -1)
1142 return value_of_dwarf_reg_entry (type
, frame
, dwarf_reg
, 0 /* unused */);
1144 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &fb_offset
))
1145 return value_of_dwarf_reg_entry (type
, frame
, -1, fb_offset
);
1147 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1148 suppressed during normal operation. The expression can be arbitrary if
1149 there is no caller-callee entry value binding expected. */
1150 throw_error (NO_ENTRY_VALUE_ERROR
,
1151 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1152 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1155 struct piece_closure
1157 /* Reference count. */
1160 /* The CU from which this closure's expression came. */
1161 struct dwarf2_per_cu_data
*per_cu
;
1163 /* The number of pieces used to describe this variable. */
1166 /* The target address size, used only for DWARF_VALUE_STACK. */
1169 /* The pieces themselves. */
1170 struct dwarf_expr_piece
*pieces
;
1173 /* Allocate a closure for a value formed from separately-described
1176 static struct piece_closure
*
1177 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1178 int n_pieces
, struct dwarf_expr_piece
*pieces
,
1181 struct piece_closure
*c
= XZALLOC (struct piece_closure
);
1186 c
->n_pieces
= n_pieces
;
1187 c
->addr_size
= addr_size
;
1188 c
->pieces
= XCALLOC (n_pieces
, struct dwarf_expr_piece
);
1190 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
1191 for (i
= 0; i
< n_pieces
; ++i
)
1192 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1193 value_incref (c
->pieces
[i
].v
.value
);
1198 /* The lowest-level function to extract bits from a byte buffer.
1199 SOURCE is the buffer. It is updated if we read to the end of a
1201 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1202 updated to reflect the number of bits actually read.
1203 NBITS is the number of bits we want to read. It is updated to
1204 reflect the number of bits actually read. This function may read
1206 BITS_BIG_ENDIAN is taken directly from gdbarch.
1207 This function returns the extracted bits. */
1210 extract_bits_primitive (const gdb_byte
**source
,
1211 unsigned int *source_offset_bits
,
1212 int *nbits
, int bits_big_endian
)
1214 unsigned int avail
, mask
, datum
;
1216 gdb_assert (*source_offset_bits
< 8);
1218 avail
= 8 - *source_offset_bits
;
1222 mask
= (1 << avail
) - 1;
1224 if (bits_big_endian
)
1225 datum
>>= 8 - (*source_offset_bits
+ *nbits
);
1227 datum
>>= *source_offset_bits
;
1231 *source_offset_bits
+= avail
;
1232 if (*source_offset_bits
>= 8)
1234 *source_offset_bits
-= 8;
1241 /* Extract some bits from a source buffer and move forward in the
1244 SOURCE is the source buffer. It is updated as bytes are read.
1245 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1247 NBITS is the number of bits to read.
1248 BITS_BIG_ENDIAN is taken directly from gdbarch.
1250 This function returns the bits that were read. */
1253 extract_bits (const gdb_byte
**source
, unsigned int *source_offset_bits
,
1254 int nbits
, int bits_big_endian
)
1258 gdb_assert (nbits
> 0 && nbits
<= 8);
1260 datum
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1266 more
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1268 if (bits_big_endian
)
1278 /* Write some bits into a buffer and move forward in the buffer.
1280 DATUM is the bits to write. The low-order bits of DATUM are used.
1281 DEST is the destination buffer. It is updated as bytes are
1283 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1285 NBITS is the number of valid bits in DATUM.
1286 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1289 insert_bits (unsigned int datum
,
1290 gdb_byte
*dest
, unsigned int dest_offset_bits
,
1291 int nbits
, int bits_big_endian
)
1295 gdb_assert (dest_offset_bits
+ nbits
<= 8);
1297 mask
= (1 << nbits
) - 1;
1298 if (bits_big_endian
)
1300 datum
<<= 8 - (dest_offset_bits
+ nbits
);
1301 mask
<<= 8 - (dest_offset_bits
+ nbits
);
1305 datum
<<= dest_offset_bits
;
1306 mask
<<= dest_offset_bits
;
1309 gdb_assert ((datum
& ~mask
) == 0);
1311 *dest
= (*dest
& ~mask
) | datum
;
1314 /* Copy bits from a source to a destination.
1316 DEST is where the bits should be written.
1317 DEST_OFFSET_BITS is the bit offset into DEST.
1318 SOURCE is the source of bits.
1319 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1320 BIT_COUNT is the number of bits to copy.
1321 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1324 copy_bitwise (gdb_byte
*dest
, unsigned int dest_offset_bits
,
1325 const gdb_byte
*source
, unsigned int source_offset_bits
,
1326 unsigned int bit_count
,
1327 int bits_big_endian
)
1329 unsigned int dest_avail
;
1332 /* Reduce everything to byte-size pieces. */
1333 dest
+= dest_offset_bits
/ 8;
1334 dest_offset_bits
%= 8;
1335 source
+= source_offset_bits
/ 8;
1336 source_offset_bits
%= 8;
1338 dest_avail
= 8 - dest_offset_bits
% 8;
1340 /* See if we can fill the first destination byte. */
1341 if (dest_avail
< bit_count
)
1343 datum
= extract_bits (&source
, &source_offset_bits
, dest_avail
,
1345 insert_bits (datum
, dest
, dest_offset_bits
, dest_avail
, bits_big_endian
);
1347 dest_offset_bits
= 0;
1348 bit_count
-= dest_avail
;
1351 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1352 than 8 bits remaining. */
1353 gdb_assert (dest_offset_bits
% 8 == 0 || bit_count
< 8);
1354 for (; bit_count
>= 8; bit_count
-= 8)
1356 datum
= extract_bits (&source
, &source_offset_bits
, 8, bits_big_endian
);
1357 *dest
++ = (gdb_byte
) datum
;
1360 /* Finally, we may have a few leftover bits. */
1361 gdb_assert (bit_count
<= 8 - dest_offset_bits
% 8);
1364 datum
= extract_bits (&source
, &source_offset_bits
, bit_count
,
1366 insert_bits (datum
, dest
, dest_offset_bits
, bit_count
, bits_big_endian
);
1371 read_pieced_value (struct value
*v
)
1375 ULONGEST bits_to_skip
;
1377 struct piece_closure
*c
1378 = (struct piece_closure
*) value_computed_closure (v
);
1379 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (v
));
1381 size_t buffer_size
= 0;
1382 char *buffer
= NULL
;
1383 struct cleanup
*cleanup
;
1385 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1387 if (value_type (v
) != value_enclosing_type (v
))
1388 internal_error (__FILE__
, __LINE__
,
1389 _("Should not be able to create a lazy value with "
1390 "an enclosing type"));
1392 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1394 contents
= value_contents_raw (v
);
1395 bits_to_skip
= 8 * value_offset (v
);
1396 if (value_bitsize (v
))
1398 bits_to_skip
+= value_bitpos (v
);
1399 type_len
= value_bitsize (v
);
1402 type_len
= 8 * TYPE_LENGTH (value_type (v
));
1404 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1406 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1407 size_t this_size
, this_size_bits
;
1408 long dest_offset_bits
, source_offset_bits
, source_offset
;
1409 const gdb_byte
*intermediate_buffer
;
1411 /* Compute size, source, and destination offsets for copying, in
1413 this_size_bits
= p
->size
;
1414 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1416 bits_to_skip
-= this_size_bits
;
1419 if (this_size_bits
> type_len
- offset
)
1420 this_size_bits
= type_len
- offset
;
1421 if (bits_to_skip
> 0)
1423 dest_offset_bits
= 0;
1424 source_offset_bits
= bits_to_skip
;
1425 this_size_bits
-= bits_to_skip
;
1430 dest_offset_bits
= offset
;
1431 source_offset_bits
= 0;
1434 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1435 source_offset
= source_offset_bits
/ 8;
1436 if (buffer_size
< this_size
)
1438 buffer_size
= this_size
;
1439 buffer
= xrealloc (buffer
, buffer_size
);
1441 intermediate_buffer
= buffer
;
1443 /* Copy from the source to DEST_BUFFER. */
1444 switch (p
->location
)
1446 case DWARF_VALUE_REGISTER
:
1448 struct gdbarch
*arch
= get_frame_arch (frame
);
1449 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1450 int reg_offset
= source_offset
;
1452 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1453 && this_size
< register_size (arch
, gdb_regnum
))
1455 /* Big-endian, and we want less than full size. */
1456 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1457 /* We want the lower-order THIS_SIZE_BITS of the bytes
1458 we extract from the register. */
1459 source_offset_bits
+= 8 * this_size
- this_size_bits
;
1462 if (gdb_regnum
!= -1)
1466 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1470 /* Just so garbage doesn't ever shine through. */
1471 memset (buffer
, 0, this_size
);
1474 set_value_optimized_out (v
, 1);
1476 mark_value_bytes_unavailable (v
, offset
, this_size
);
1481 error (_("Unable to access DWARF register number %s"),
1482 paddress (arch
, p
->v
.regno
));
1487 case DWARF_VALUE_MEMORY
:
1488 read_value_memory (v
, offset
,
1489 p
->v
.mem
.in_stack_memory
,
1490 p
->v
.mem
.addr
+ source_offset
,
1494 case DWARF_VALUE_STACK
:
1496 size_t n
= this_size
;
1498 if (n
> c
->addr_size
- source_offset
)
1499 n
= (c
->addr_size
>= source_offset
1500 ? c
->addr_size
- source_offset
1508 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
1510 intermediate_buffer
= val_bytes
+ source_offset
;
1515 case DWARF_VALUE_LITERAL
:
1517 size_t n
= this_size
;
1519 if (n
> p
->v
.literal
.length
- source_offset
)
1520 n
= (p
->v
.literal
.length
>= source_offset
1521 ? p
->v
.literal
.length
- source_offset
1524 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
1528 /* These bits show up as zeros -- but do not cause the value
1529 to be considered optimized-out. */
1530 case DWARF_VALUE_IMPLICIT_POINTER
:
1533 case DWARF_VALUE_OPTIMIZED_OUT
:
1534 set_value_optimized_out (v
, 1);
1538 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1541 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
1542 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1543 copy_bitwise (contents
, dest_offset_bits
,
1544 intermediate_buffer
, source_offset_bits
% 8,
1545 this_size_bits
, bits_big_endian
);
1547 offset
+= this_size_bits
;
1550 do_cleanups (cleanup
);
1554 write_pieced_value (struct value
*to
, struct value
*from
)
1558 ULONGEST bits_to_skip
;
1559 const gdb_byte
*contents
;
1560 struct piece_closure
*c
1561 = (struct piece_closure
*) value_computed_closure (to
);
1562 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
1564 size_t buffer_size
= 0;
1565 char *buffer
= NULL
;
1566 struct cleanup
*cleanup
;
1568 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
1572 set_value_optimized_out (to
, 1);
1576 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1578 contents
= value_contents (from
);
1579 bits_to_skip
= 8 * value_offset (to
);
1580 if (value_bitsize (to
))
1582 bits_to_skip
+= value_bitpos (to
);
1583 type_len
= value_bitsize (to
);
1586 type_len
= 8 * TYPE_LENGTH (value_type (to
));
1588 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1590 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1591 size_t this_size_bits
, this_size
;
1592 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
1594 const gdb_byte
*source_buffer
;
1596 this_size_bits
= p
->size
;
1597 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1599 bits_to_skip
-= this_size_bits
;
1602 if (this_size_bits
> type_len
- offset
)
1603 this_size_bits
= type_len
- offset
;
1604 if (bits_to_skip
> 0)
1606 dest_offset_bits
= bits_to_skip
;
1607 source_offset_bits
= 0;
1608 this_size_bits
-= bits_to_skip
;
1613 dest_offset_bits
= 0;
1614 source_offset_bits
= offset
;
1617 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1618 source_offset
= source_offset_bits
/ 8;
1619 dest_offset
= dest_offset_bits
/ 8;
1620 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
1622 source_buffer
= contents
+ source_offset
;
1627 if (buffer_size
< this_size
)
1629 buffer_size
= this_size
;
1630 buffer
= xrealloc (buffer
, buffer_size
);
1632 source_buffer
= buffer
;
1636 switch (p
->location
)
1638 case DWARF_VALUE_REGISTER
:
1640 struct gdbarch
*arch
= get_frame_arch (frame
);
1641 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1642 int reg_offset
= dest_offset
;
1644 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1645 && this_size
<= register_size (arch
, gdb_regnum
))
1646 /* Big-endian, and we want less than full size. */
1647 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1649 if (gdb_regnum
!= -1)
1655 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1660 error (_("Can't do read-modify-write to "
1661 "update bitfield; containing word has been "
1664 throw_error (NOT_AVAILABLE_ERROR
,
1665 _("Can't do read-modify-write to update "
1666 "bitfield; containing word "
1669 copy_bitwise (buffer
, dest_offset_bits
,
1670 contents
, source_offset_bits
,
1675 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1676 this_size
, source_buffer
);
1680 error (_("Unable to write to DWARF register number %s"),
1681 paddress (arch
, p
->v
.regno
));
1685 case DWARF_VALUE_MEMORY
:
1688 /* Only the first and last bytes can possibly have any
1690 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
, 1);
1691 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
1692 buffer
+ this_size
- 1, 1);
1693 copy_bitwise (buffer
, dest_offset_bits
,
1694 contents
, source_offset_bits
,
1699 write_memory (p
->v
.mem
.addr
+ dest_offset
,
1700 source_buffer
, this_size
);
1703 set_value_optimized_out (to
, 1);
1706 offset
+= this_size_bits
;
1709 do_cleanups (cleanup
);
1712 /* A helper function that checks bit validity in a pieced value.
1713 CHECK_FOR indicates the kind of validity checking.
1714 DWARF_VALUE_MEMORY means to check whether any bit is valid.
1715 DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
1717 DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
1718 implicit pointer. */
1721 check_pieced_value_bits (const struct value
*value
, int bit_offset
,
1723 enum dwarf_value_location check_for
)
1725 struct piece_closure
*c
1726 = (struct piece_closure
*) value_computed_closure (value
);
1728 int validity
= (check_for
== DWARF_VALUE_MEMORY
1729 || check_for
== DWARF_VALUE_IMPLICIT_POINTER
);
1731 bit_offset
+= 8 * value_offset (value
);
1732 if (value_bitsize (value
))
1733 bit_offset
+= value_bitpos (value
);
1735 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
1737 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1738 size_t this_size_bits
= p
->size
;
1742 if (bit_offset
>= this_size_bits
)
1744 bit_offset
-= this_size_bits
;
1748 bit_length
-= this_size_bits
- bit_offset
;
1752 bit_length
-= this_size_bits
;
1754 if (check_for
== DWARF_VALUE_IMPLICIT_POINTER
)
1756 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1759 else if (p
->location
== DWARF_VALUE_OPTIMIZED_OUT
1760 || p
->location
== DWARF_VALUE_IMPLICIT_POINTER
)
1776 check_pieced_value_validity (const struct value
*value
, int bit_offset
,
1779 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
1780 DWARF_VALUE_MEMORY
);
1784 check_pieced_value_invalid (const struct value
*value
)
1786 return check_pieced_value_bits (value
, 0,
1787 8 * TYPE_LENGTH (value_type (value
)),
1788 DWARF_VALUE_OPTIMIZED_OUT
);
1791 /* An implementation of an lval_funcs method to see whether a value is
1792 a synthetic pointer. */
1795 check_pieced_synthetic_pointer (const struct value
*value
, int bit_offset
,
1798 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
1799 DWARF_VALUE_IMPLICIT_POINTER
);
1802 /* A wrapper function for get_frame_address_in_block. */
1805 get_frame_address_in_block_wrapper (void *baton
)
1807 return get_frame_address_in_block (baton
);
1810 /* An implementation of an lval_funcs method to indirect through a
1811 pointer. This handles the synthetic pointer case when needed. */
1813 static struct value
*
1814 indirect_pieced_value (struct value
*value
)
1816 struct piece_closure
*c
1817 = (struct piece_closure
*) value_computed_closure (value
);
1819 struct frame_info
*frame
;
1820 struct dwarf2_locexpr_baton baton
;
1821 int i
, bit_offset
, bit_length
;
1822 struct dwarf_expr_piece
*piece
= NULL
;
1823 LONGEST byte_offset
;
1825 type
= check_typedef (value_type (value
));
1826 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
1829 bit_length
= 8 * TYPE_LENGTH (type
);
1830 bit_offset
= 8 * value_offset (value
);
1831 if (value_bitsize (value
))
1832 bit_offset
+= value_bitpos (value
);
1834 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
1836 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1837 size_t this_size_bits
= p
->size
;
1841 if (bit_offset
>= this_size_bits
)
1843 bit_offset
-= this_size_bits
;
1847 bit_length
-= this_size_bits
- bit_offset
;
1851 bit_length
-= this_size_bits
;
1853 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1856 if (bit_length
!= 0)
1857 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
1863 frame
= get_selected_frame (_("No frame selected."));
1865 /* This is an offset requested by GDB, such as value subcripts. */
1866 byte_offset
= value_as_address (value
);
1869 baton
= dwarf2_fetch_die_location_block (piece
->v
.ptr
.die
, c
->per_cu
,
1870 get_frame_address_in_block_wrapper
,
1873 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
1874 baton
.data
, baton
.size
, baton
.per_cu
,
1875 piece
->v
.ptr
.offset
+ byte_offset
);
1879 copy_pieced_value_closure (const struct value
*v
)
1881 struct piece_closure
*c
1882 = (struct piece_closure
*) value_computed_closure (v
);
1889 free_pieced_value_closure (struct value
*v
)
1891 struct piece_closure
*c
1892 = (struct piece_closure
*) value_computed_closure (v
);
1899 for (i
= 0; i
< c
->n_pieces
; ++i
)
1900 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1901 value_free (c
->pieces
[i
].v
.value
);
1908 /* Functions for accessing a variable described by DW_OP_piece. */
1909 static const struct lval_funcs pieced_value_funcs
= {
1912 check_pieced_value_validity
,
1913 check_pieced_value_invalid
,
1914 indirect_pieced_value
,
1915 NULL
, /* coerce_ref */
1916 check_pieced_synthetic_pointer
,
1917 copy_pieced_value_closure
,
1918 free_pieced_value_closure
1921 /* Helper function which throws an error if a synthetic pointer is
1925 invalid_synthetic_pointer (void)
1927 error (_("access outside bounds of object "
1928 "referenced via synthetic pointer"));
1931 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
1933 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
=
1935 dwarf_expr_read_reg
,
1936 dwarf_expr_read_mem
,
1937 dwarf_expr_frame_base
,
1938 dwarf_expr_frame_cfa
,
1939 dwarf_expr_frame_pc
,
1940 dwarf_expr_tls_address
,
1941 dwarf_expr_dwarf_call
,
1942 dwarf_expr_get_base_type
,
1943 dwarf_expr_push_dwarf_reg_entry_value
1946 /* Evaluate a location description, starting at DATA and with length
1947 SIZE, to find the current location of variable of TYPE in the
1948 context of FRAME. BYTE_OFFSET is applied after the contents are
1951 static struct value
*
1952 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
1953 const gdb_byte
*data
, unsigned short size
,
1954 struct dwarf2_per_cu_data
*per_cu
,
1955 LONGEST byte_offset
)
1957 struct value
*retval
;
1958 struct dwarf_expr_baton baton
;
1959 struct dwarf_expr_context
*ctx
;
1960 struct cleanup
*old_chain
, *value_chain
;
1961 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
1962 volatile struct gdb_exception ex
;
1964 if (byte_offset
< 0)
1965 invalid_synthetic_pointer ();
1968 return allocate_optimized_out_value (type
);
1970 baton
.frame
= frame
;
1971 baton
.per_cu
= per_cu
;
1973 ctx
= new_dwarf_expr_context ();
1974 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
1975 value_chain
= make_cleanup_value_free_to_mark (value_mark ());
1977 ctx
->gdbarch
= get_objfile_arch (objfile
);
1978 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
1979 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
1980 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
1981 ctx
->baton
= &baton
;
1982 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
1984 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
1986 dwarf_expr_eval (ctx
, data
, size
);
1990 if (ex
.error
== NOT_AVAILABLE_ERROR
)
1992 do_cleanups (old_chain
);
1993 retval
= allocate_value (type
);
1994 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
1997 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
1999 if (entry_values_debug
)
2000 exception_print (gdb_stdout
, ex
);
2001 do_cleanups (old_chain
);
2002 return allocate_optimized_out_value (type
);
2005 throw_exception (ex
);
2008 if (ctx
->num_pieces
> 0)
2010 struct piece_closure
*c
;
2011 struct frame_id frame_id
= get_frame_id (frame
);
2012 ULONGEST bit_size
= 0;
2015 for (i
= 0; i
< ctx
->num_pieces
; ++i
)
2016 bit_size
+= ctx
->pieces
[i
].size
;
2017 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
2018 invalid_synthetic_pointer ();
2020 c
= allocate_piece_closure (per_cu
, ctx
->num_pieces
, ctx
->pieces
,
2022 /* We must clean up the value chain after creating the piece
2023 closure but before allocating the result. */
2024 do_cleanups (value_chain
);
2025 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
2026 VALUE_FRAME_ID (retval
) = frame_id
;
2027 set_value_offset (retval
, byte_offset
);
2031 switch (ctx
->location
)
2033 case DWARF_VALUE_REGISTER
:
2035 struct gdbarch
*arch
= get_frame_arch (frame
);
2036 ULONGEST dwarf_regnum
= value_as_long (dwarf_expr_fetch (ctx
, 0));
2037 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
2039 if (byte_offset
!= 0)
2040 error (_("cannot use offset on synthetic pointer to register"));
2041 do_cleanups (value_chain
);
2042 if (gdb_regnum
!= -1)
2043 retval
= value_from_register (type
, gdb_regnum
, frame
);
2045 error (_("Unable to access DWARF register number %s"),
2046 paddress (arch
, dwarf_regnum
));
2050 case DWARF_VALUE_MEMORY
:
2052 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
2053 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
2055 do_cleanups (value_chain
);
2056 retval
= allocate_value_lazy (type
);
2057 VALUE_LVAL (retval
) = lval_memory
;
2058 if (in_stack_memory
)
2059 set_value_stack (retval
, 1);
2060 set_value_address (retval
, address
+ byte_offset
);
2064 case DWARF_VALUE_STACK
:
2066 struct value
*value
= dwarf_expr_fetch (ctx
, 0);
2068 const gdb_byte
*val_bytes
;
2069 size_t n
= TYPE_LENGTH (value_type (value
));
2071 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2072 invalid_synthetic_pointer ();
2074 val_bytes
= value_contents_all (value
);
2075 val_bytes
+= byte_offset
;
2078 /* Preserve VALUE because we are going to free values back
2079 to the mark, but we still need the value contents
2081 value_incref (value
);
2082 do_cleanups (value_chain
);
2083 make_cleanup_value_free (value
);
2085 retval
= allocate_value (type
);
2086 contents
= value_contents_raw (retval
);
2087 if (n
> TYPE_LENGTH (type
))
2089 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2091 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2092 val_bytes
+= n
- TYPE_LENGTH (type
);
2093 n
= TYPE_LENGTH (type
);
2095 memcpy (contents
, val_bytes
, n
);
2099 case DWARF_VALUE_LITERAL
:
2102 const bfd_byte
*ldata
;
2103 size_t n
= ctx
->len
;
2105 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2106 invalid_synthetic_pointer ();
2108 do_cleanups (value_chain
);
2109 retval
= allocate_value (type
);
2110 contents
= value_contents_raw (retval
);
2112 ldata
= ctx
->data
+ byte_offset
;
2115 if (n
> TYPE_LENGTH (type
))
2117 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2119 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2120 ldata
+= n
- TYPE_LENGTH (type
);
2121 n
= TYPE_LENGTH (type
);
2123 memcpy (contents
, ldata
, n
);
2127 case DWARF_VALUE_OPTIMIZED_OUT
:
2128 do_cleanups (value_chain
);
2129 retval
= allocate_optimized_out_value (type
);
2132 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2133 operation by execute_stack_op. */
2134 case DWARF_VALUE_IMPLICIT_POINTER
:
2135 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2136 it can only be encountered when making a piece. */
2138 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2142 set_value_initialized (retval
, ctx
->initialized
);
2144 do_cleanups (old_chain
);
2149 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2150 passes 0 as the byte_offset. */
2153 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2154 const gdb_byte
*data
, unsigned short size
,
2155 struct dwarf2_per_cu_data
*per_cu
)
2157 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
2161 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2163 struct needs_frame_baton
2166 struct dwarf2_per_cu_data
*per_cu
;
2169 /* Reads from registers do require a frame. */
2171 needs_frame_read_reg (void *baton
, int regnum
)
2173 struct needs_frame_baton
*nf_baton
= baton
;
2175 nf_baton
->needs_frame
= 1;
2179 /* Reads from memory do not require a frame. */
2181 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
2183 memset (buf
, 0, len
);
2186 /* Frame-relative accesses do require a frame. */
2188 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
2190 static gdb_byte lit0
= DW_OP_lit0
;
2191 struct needs_frame_baton
*nf_baton
= baton
;
2196 nf_baton
->needs_frame
= 1;
2199 /* CFA accesses require a frame. */
2202 needs_frame_frame_cfa (void *baton
)
2204 struct needs_frame_baton
*nf_baton
= baton
;
2206 nf_baton
->needs_frame
= 1;
2210 /* Thread-local accesses do require a frame. */
2212 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
2214 struct needs_frame_baton
*nf_baton
= baton
;
2216 nf_baton
->needs_frame
= 1;
2220 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2223 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, size_t die_offset
)
2225 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2227 per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
,
2228 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
2231 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2234 needs_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
2235 int dwarf_reg
, CORE_ADDR fb_offset
, int deref_size
)
2237 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2239 nf_baton
->needs_frame
= 1;
2242 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2244 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs
=
2246 needs_frame_read_reg
,
2247 needs_frame_read_mem
,
2248 needs_frame_frame_base
,
2249 needs_frame_frame_cfa
,
2250 needs_frame_frame_cfa
, /* get_frame_pc */
2251 needs_frame_tls_address
,
2252 needs_frame_dwarf_call
,
2253 NULL
, /* get_base_type */
2254 needs_dwarf_reg_entry_value
2257 /* Return non-zero iff the location expression at DATA (length SIZE)
2258 requires a frame to evaluate. */
2261 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, unsigned short size
,
2262 struct dwarf2_per_cu_data
*per_cu
)
2264 struct needs_frame_baton baton
;
2265 struct dwarf_expr_context
*ctx
;
2267 struct cleanup
*old_chain
;
2268 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2270 baton
.needs_frame
= 0;
2271 baton
.per_cu
= per_cu
;
2273 ctx
= new_dwarf_expr_context ();
2274 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2275 make_cleanup_value_free_to_mark (value_mark ());
2277 ctx
->gdbarch
= get_objfile_arch (objfile
);
2278 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2279 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2280 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2281 ctx
->baton
= &baton
;
2282 ctx
->funcs
= &needs_frame_ctx_funcs
;
2284 dwarf_expr_eval (ctx
, data
, size
);
2286 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
2288 if (ctx
->num_pieces
> 0)
2292 /* If the location has several pieces, and any of them are in
2293 registers, then we will need a frame to fetch them from. */
2294 for (i
= 0; i
< ctx
->num_pieces
; i
++)
2295 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2299 do_cleanups (old_chain
);
2301 return baton
.needs_frame
|| in_reg
;
2304 /* A helper function that throws an unimplemented error mentioning a
2305 given DWARF operator. */
2308 unimplemented (unsigned int op
)
2310 const char *name
= dwarf_stack_op_name (op
);
2313 error (_("DWARF operator %s cannot be translated to an agent expression"),
2316 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2317 "to an agent expression"),
2321 /* A helper function to convert a DWARF register to an arch register.
2322 ARCH is the architecture.
2323 DWARF_REG is the register.
2324 This will throw an exception if the DWARF register cannot be
2325 translated to an architecture register. */
2328 translate_register (struct gdbarch
*arch
, int dwarf_reg
)
2330 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2332 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
2336 /* A helper function that emits an access to memory. ARCH is the
2337 target architecture. EXPR is the expression which we are building.
2338 NBITS is the number of bits we want to read. This emits the
2339 opcodes needed to read the memory and then extract the desired
2343 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2345 ULONGEST nbytes
= (nbits
+ 7) / 8;
2347 gdb_assert (nbits
> 0 && nbits
<= sizeof (LONGEST
));
2350 ax_trace_quick (expr
, nbytes
);
2353 ax_simple (expr
, aop_ref8
);
2354 else if (nbits
<= 16)
2355 ax_simple (expr
, aop_ref16
);
2356 else if (nbits
<= 32)
2357 ax_simple (expr
, aop_ref32
);
2359 ax_simple (expr
, aop_ref64
);
2361 /* If we read exactly the number of bytes we wanted, we're done. */
2362 if (8 * nbytes
== nbits
)
2365 if (gdbarch_bits_big_endian (arch
))
2367 /* On a bits-big-endian machine, we want the high-order
2369 ax_const_l (expr
, 8 * nbytes
- nbits
);
2370 ax_simple (expr
, aop_rsh_unsigned
);
2374 /* On a bits-little-endian box, we want the low-order NBITS. */
2375 ax_zero_ext (expr
, nbits
);
2379 /* A helper function to return the frame's PC. */
2382 get_ax_pc (void *baton
)
2384 struct agent_expr
*expr
= baton
;
2389 /* Compile a DWARF location expression to an agent expression.
2391 EXPR is the agent expression we are building.
2392 LOC is the agent value we modify.
2393 ARCH is the architecture.
2394 ADDR_SIZE is the size of addresses, in bytes.
2395 OP_PTR is the start of the location expression.
2396 OP_END is one past the last byte of the location expression.
2398 This will throw an exception for various kinds of errors -- for
2399 example, if the expression cannot be compiled, or if the expression
2403 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2404 struct gdbarch
*arch
, unsigned int addr_size
,
2405 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
2406 struct dwarf2_per_cu_data
*per_cu
)
2408 struct cleanup
*cleanups
;
2410 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
2411 const gdb_byte
* const base
= op_ptr
;
2412 const gdb_byte
*previous_piece
= op_ptr
;
2413 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2414 ULONGEST bits_collected
= 0;
2415 unsigned int addr_size_bits
= 8 * addr_size
;
2416 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
2418 offsets
= xmalloc ((op_end
- op_ptr
) * sizeof (int));
2419 cleanups
= make_cleanup (xfree
, offsets
);
2421 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
2424 make_cleanup (VEC_cleanup (int), &dw_labels
);
2425 make_cleanup (VEC_cleanup (int), &patches
);
2427 /* By default we are making an address. */
2428 loc
->kind
= axs_lvalue_memory
;
2430 while (op_ptr
< op_end
)
2432 enum dwarf_location_atom op
= *op_ptr
;
2433 ULONGEST uoffset
, reg
;
2437 offsets
[op_ptr
- base
] = expr
->len
;
2440 /* Our basic approach to code generation is to map DWARF
2441 operations directly to AX operations. However, there are
2444 First, DWARF works on address-sized units, but AX always uses
2445 LONGEST. For most operations we simply ignore this
2446 difference; instead we generate sign extensions as needed
2447 before division and comparison operations. It would be nice
2448 to omit the sign extensions, but there is no way to determine
2449 the size of the target's LONGEST. (This code uses the size
2450 of the host LONGEST in some cases -- that is a bug but it is
2453 Second, some DWARF operations cannot be translated to AX.
2454 For these we simply fail. See
2455 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2490 ax_const_l (expr
, op
- DW_OP_lit0
);
2494 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
2495 op_ptr
+= addr_size
;
2496 /* Some versions of GCC emit DW_OP_addr before
2497 DW_OP_GNU_push_tls_address. In this case the value is an
2498 index, not an address. We don't support things like
2499 branching between the address and the TLS op. */
2500 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
2501 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
2502 ax_const_l (expr
, uoffset
);
2506 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
2510 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
2514 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
2518 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
2522 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
2526 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
2530 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
2534 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
2538 op_ptr
= read_uleb128 (op_ptr
, op_end
, &uoffset
);
2539 ax_const_l (expr
, uoffset
);
2542 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
2543 ax_const_l (expr
, offset
);
2578 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2579 loc
->u
.reg
= translate_register (arch
, op
- DW_OP_reg0
);
2580 loc
->kind
= axs_lvalue_register
;
2584 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
2585 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2586 loc
->u
.reg
= translate_register (arch
, reg
);
2587 loc
->kind
= axs_lvalue_register
;
2590 case DW_OP_implicit_value
:
2594 op_ptr
= read_uleb128 (op_ptr
, op_end
, &len
);
2595 if (op_ptr
+ len
> op_end
)
2596 error (_("DW_OP_implicit_value: too few bytes available."));
2597 if (len
> sizeof (ULONGEST
))
2598 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
2601 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
2604 dwarf_expr_require_composition (op_ptr
, op_end
,
2605 "DW_OP_implicit_value");
2607 loc
->kind
= axs_rvalue
;
2611 case DW_OP_stack_value
:
2612 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
2613 loc
->kind
= axs_rvalue
;
2648 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
2649 i
= translate_register (arch
, op
- DW_OP_breg0
);
2653 ax_const_l (expr
, offset
);
2654 ax_simple (expr
, aop_add
);
2659 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
2660 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
2661 i
= translate_register (arch
, reg
);
2665 ax_const_l (expr
, offset
);
2666 ax_simple (expr
, aop_add
);
2672 const gdb_byte
*datastart
;
2674 unsigned int before_stack_len
;
2676 struct symbol
*framefunc
;
2677 LONGEST base_offset
= 0;
2679 b
= block_for_pc (expr
->scope
);
2682 error (_("No block found for address"));
2684 framefunc
= block_linkage_function (b
);
2687 error (_("No function found for block"));
2689 dwarf_expr_frame_base_1 (framefunc
, expr
->scope
,
2690 &datastart
, &datalen
);
2692 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
2693 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
2694 datastart
+ datalen
, per_cu
);
2698 ax_const_l (expr
, offset
);
2699 ax_simple (expr
, aop_add
);
2702 loc
->kind
= axs_lvalue_memory
;
2707 ax_simple (expr
, aop_dup
);
2711 ax_simple (expr
, aop_pop
);
2716 ax_pick (expr
, offset
);
2720 ax_simple (expr
, aop_swap
);
2728 ax_simple (expr
, aop_rot
);
2732 case DW_OP_deref_size
:
2736 if (op
== DW_OP_deref_size
)
2744 ax_simple (expr
, aop_ref8
);
2747 ax_simple (expr
, aop_ref16
);
2750 ax_simple (expr
, aop_ref32
);
2753 ax_simple (expr
, aop_ref64
);
2756 /* Note that dwarf_stack_op_name will never return
2758 error (_("Unsupported size %d in %s"),
2759 size
, dwarf_stack_op_name (op
));
2765 /* Sign extend the operand. */
2766 ax_ext (expr
, addr_size_bits
);
2767 ax_simple (expr
, aop_dup
);
2768 ax_const_l (expr
, 0);
2769 ax_simple (expr
, aop_less_signed
);
2770 ax_simple (expr
, aop_log_not
);
2771 i
= ax_goto (expr
, aop_if_goto
);
2772 /* We have to emit 0 - X. */
2773 ax_const_l (expr
, 0);
2774 ax_simple (expr
, aop_swap
);
2775 ax_simple (expr
, aop_sub
);
2776 ax_label (expr
, i
, expr
->len
);
2780 /* No need to sign extend here. */
2781 ax_const_l (expr
, 0);
2782 ax_simple (expr
, aop_swap
);
2783 ax_simple (expr
, aop_sub
);
2787 /* Sign extend the operand. */
2788 ax_ext (expr
, addr_size_bits
);
2789 ax_simple (expr
, aop_bit_not
);
2792 case DW_OP_plus_uconst
:
2793 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
2794 /* It would be really weird to emit `DW_OP_plus_uconst 0',
2795 but we micro-optimize anyhow. */
2798 ax_const_l (expr
, reg
);
2799 ax_simple (expr
, aop_add
);
2804 ax_simple (expr
, aop_bit_and
);
2808 /* Sign extend the operands. */
2809 ax_ext (expr
, addr_size_bits
);
2810 ax_simple (expr
, aop_swap
);
2811 ax_ext (expr
, addr_size_bits
);
2812 ax_simple (expr
, aop_swap
);
2813 ax_simple (expr
, aop_div_signed
);
2817 ax_simple (expr
, aop_sub
);
2821 ax_simple (expr
, aop_rem_unsigned
);
2825 ax_simple (expr
, aop_mul
);
2829 ax_simple (expr
, aop_bit_or
);
2833 ax_simple (expr
, aop_add
);
2837 ax_simple (expr
, aop_lsh
);
2841 ax_simple (expr
, aop_rsh_unsigned
);
2845 ax_simple (expr
, aop_rsh_signed
);
2849 ax_simple (expr
, aop_bit_xor
);
2853 /* Sign extend the operands. */
2854 ax_ext (expr
, addr_size_bits
);
2855 ax_simple (expr
, aop_swap
);
2856 ax_ext (expr
, addr_size_bits
);
2857 /* Note no swap here: A <= B is !(B < A). */
2858 ax_simple (expr
, aop_less_signed
);
2859 ax_simple (expr
, aop_log_not
);
2863 /* Sign extend the operands. */
2864 ax_ext (expr
, addr_size_bits
);
2865 ax_simple (expr
, aop_swap
);
2866 ax_ext (expr
, addr_size_bits
);
2867 ax_simple (expr
, aop_swap
);
2868 /* A >= B is !(A < B). */
2869 ax_simple (expr
, aop_less_signed
);
2870 ax_simple (expr
, aop_log_not
);
2874 /* Sign extend the operands. */
2875 ax_ext (expr
, addr_size_bits
);
2876 ax_simple (expr
, aop_swap
);
2877 ax_ext (expr
, addr_size_bits
);
2878 /* No need for a second swap here. */
2879 ax_simple (expr
, aop_equal
);
2883 /* Sign extend the operands. */
2884 ax_ext (expr
, addr_size_bits
);
2885 ax_simple (expr
, aop_swap
);
2886 ax_ext (expr
, addr_size_bits
);
2887 ax_simple (expr
, aop_swap
);
2888 ax_simple (expr
, aop_less_signed
);
2892 /* Sign extend the operands. */
2893 ax_ext (expr
, addr_size_bits
);
2894 ax_simple (expr
, aop_swap
);
2895 ax_ext (expr
, addr_size_bits
);
2896 /* Note no swap here: A > B is B < A. */
2897 ax_simple (expr
, aop_less_signed
);
2901 /* Sign extend the operands. */
2902 ax_ext (expr
, addr_size_bits
);
2903 ax_simple (expr
, aop_swap
);
2904 ax_ext (expr
, addr_size_bits
);
2905 /* No need for a swap here. */
2906 ax_simple (expr
, aop_equal
);
2907 ax_simple (expr
, aop_log_not
);
2910 case DW_OP_call_frame_cfa
:
2911 dwarf2_compile_cfa_to_ax (expr
, loc
, arch
, expr
->scope
, per_cu
);
2912 loc
->kind
= axs_lvalue_memory
;
2915 case DW_OP_GNU_push_tls_address
:
2920 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
2922 i
= ax_goto (expr
, aop_goto
);
2923 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
2924 VEC_safe_push (int, patches
, i
);
2928 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
2930 /* Zero extend the operand. */
2931 ax_zero_ext (expr
, addr_size_bits
);
2932 i
= ax_goto (expr
, aop_if_goto
);
2933 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
2934 VEC_safe_push (int, patches
, i
);
2941 case DW_OP_bit_piece
:
2943 ULONGEST size
, offset
;
2945 if (op_ptr
- 1 == previous_piece
)
2946 error (_("Cannot translate empty pieces to agent expressions"));
2947 previous_piece
= op_ptr
- 1;
2949 op_ptr
= read_uleb128 (op_ptr
, op_end
, &size
);
2950 if (op
== DW_OP_piece
)
2956 op_ptr
= read_uleb128 (op_ptr
, op_end
, &offset
);
2958 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
2959 error (_("Expression pieces exceed word size"));
2961 /* Access the bits. */
2964 case axs_lvalue_register
:
2965 ax_reg (expr
, loc
->u
.reg
);
2968 case axs_lvalue_memory
:
2969 /* Offset the pointer, if needed. */
2972 ax_const_l (expr
, offset
/ 8);
2973 ax_simple (expr
, aop_add
);
2976 access_memory (arch
, expr
, size
);
2980 /* For a bits-big-endian target, shift up what we already
2981 have. For a bits-little-endian target, shift up the
2982 new data. Note that there is a potential bug here if
2983 the DWARF expression leaves multiple values on the
2985 if (bits_collected
> 0)
2987 if (bits_big_endian
)
2989 ax_simple (expr
, aop_swap
);
2990 ax_const_l (expr
, size
);
2991 ax_simple (expr
, aop_lsh
);
2992 /* We don't need a second swap here, because
2993 aop_bit_or is symmetric. */
2997 ax_const_l (expr
, size
);
2998 ax_simple (expr
, aop_lsh
);
3000 ax_simple (expr
, aop_bit_or
);
3003 bits_collected
+= size
;
3004 loc
->kind
= axs_rvalue
;
3008 case DW_OP_GNU_uninit
:
3014 struct dwarf2_locexpr_baton block
;
3015 int size
= (op
== DW_OP_call2
? 2 : 4);
3017 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3020 block
= dwarf2_fetch_die_location_block (uoffset
, per_cu
,
3023 /* DW_OP_call_ref is currently not supported. */
3024 gdb_assert (block
.per_cu
== per_cu
);
3026 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3027 block
.data
, block
.data
+ block
.size
,
3032 case DW_OP_call_ref
:
3040 /* Patch all the branches we emitted. */
3041 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
3043 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
3045 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3046 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
3049 do_cleanups (cleanups
);
3053 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3054 evaluator to calculate the location. */
3055 static struct value
*
3056 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3058 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3061 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3062 dlbaton
->size
, dlbaton
->per_cu
);
3067 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3068 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3071 static struct value
*
3072 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3074 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3076 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3080 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3082 locexpr_read_needs_frame (struct symbol
*symbol
)
3084 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3086 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
3090 /* Return true if DATA points to the end of a piece. END is one past
3091 the last byte in the expression. */
3094 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3096 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3099 /* Helper for locexpr_describe_location_piece that finds the name of a
3103 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3107 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
3108 return gdbarch_register_name (gdbarch
, regnum
);
3111 /* Nicely describe a single piece of a location, returning an updated
3112 position in the bytecode sequence. This function cannot recognize
3113 all locations; if a location is not recognized, it simply returns
3116 static const gdb_byte
*
3117 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3118 CORE_ADDR addr
, struct objfile
*objfile
,
3119 const gdb_byte
*data
, const gdb_byte
*end
,
3120 unsigned int addr_size
)
3122 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3124 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3126 fprintf_filtered (stream
, _("a variable in $%s"),
3127 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3130 else if (data
[0] == DW_OP_regx
)
3134 data
= read_uleb128 (data
+ 1, end
, ®
);
3135 fprintf_filtered (stream
, _("a variable in $%s"),
3136 locexpr_regname (gdbarch
, reg
));
3138 else if (data
[0] == DW_OP_fbreg
)
3141 struct symbol
*framefunc
;
3143 LONGEST frame_offset
;
3144 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3146 LONGEST base_offset
= 0;
3148 new_data
= read_sleb128 (data
+ 1, end
, &frame_offset
);
3149 if (!piece_end_p (new_data
, end
))
3153 b
= block_for_pc (addr
);
3156 error (_("No block found for address for symbol \"%s\"."),
3157 SYMBOL_PRINT_NAME (symbol
));
3159 framefunc
= block_linkage_function (b
);
3162 error (_("No function found for block for symbol \"%s\"."),
3163 SYMBOL_PRINT_NAME (symbol
));
3165 dwarf_expr_frame_base_1 (framefunc
, addr
, &base_data
, &base_size
);
3167 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3169 const gdb_byte
*buf_end
;
3171 frame_reg
= base_data
[0] - DW_OP_breg0
;
3172 buf_end
= read_sleb128 (base_data
+ 1,
3173 base_data
+ base_size
, &base_offset
);
3174 if (buf_end
!= base_data
+ base_size
)
3175 error (_("Unexpected opcode after "
3176 "DW_OP_breg%u for symbol \"%s\"."),
3177 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3179 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3181 /* The frame base is just the register, with no offset. */
3182 frame_reg
= base_data
[0] - DW_OP_reg0
;
3187 /* We don't know what to do with the frame base expression,
3188 so we can't trace this variable; give up. */
3192 fprintf_filtered (stream
,
3193 _("a variable at frame base reg $%s offset %s+%s"),
3194 locexpr_regname (gdbarch
, frame_reg
),
3195 plongest (base_offset
), plongest (frame_offset
));
3197 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3198 && piece_end_p (data
, end
))
3202 data
= read_sleb128 (data
+ 1, end
, &offset
);
3204 fprintf_filtered (stream
,
3205 _("a variable at offset %s from base reg $%s"),
3207 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3210 /* The location expression for a TLS variable looks like this (on a
3213 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3214 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3216 0x3 is the encoding for DW_OP_addr, which has an operand as long
3217 as the size of an address on the target machine (here is 8
3218 bytes). Note that more recent version of GCC emit DW_OP_const4u
3219 or DW_OP_const8u, depending on address size, rather than
3220 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3221 The operand represents the offset at which the variable is within
3222 the thread local storage. */
3224 else if (data
+ 1 + addr_size
< end
3225 && (data
[0] == DW_OP_addr
3226 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3227 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3228 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3229 && piece_end_p (data
+ 2 + addr_size
, end
))
3232 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3233 gdbarch_byte_order (gdbarch
));
3235 fprintf_filtered (stream
,
3236 _("a thread-local variable at offset 0x%s "
3237 "in the thread-local storage for `%s'"),
3238 phex_nz (offset
, addr_size
), objfile
->name
);
3240 data
+= 1 + addr_size
+ 1;
3242 else if (data
[0] >= DW_OP_lit0
3243 && data
[0] <= DW_OP_lit31
3245 && data
[1] == DW_OP_stack_value
)
3247 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3254 /* Disassemble an expression, stopping at the end of a piece or at the
3255 end of the expression. Returns a pointer to the next unread byte
3256 in the input expression. If ALL is nonzero, then this function
3257 will keep going until it reaches the end of the expression. */
3259 static const gdb_byte
*
3260 disassemble_dwarf_expression (struct ui_file
*stream
,
3261 struct gdbarch
*arch
, unsigned int addr_size
,
3262 int offset_size
, const gdb_byte
*start
,
3263 const gdb_byte
*data
, const gdb_byte
*end
,
3264 int indent
, int all
,
3265 struct dwarf2_per_cu_data
*per_cu
)
3269 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3271 enum dwarf_location_atom op
= *data
++;
3276 name
= dwarf_stack_op_name (op
);
3279 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3280 op
, (long) (data
- 1 - start
));
3281 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3282 (long) (data
- 1 - start
), name
);
3287 ul
= extract_unsigned_integer (data
, addr_size
,
3288 gdbarch_byte_order (arch
));
3290 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3294 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3296 fprintf_filtered (stream
, " %s", pulongest (ul
));
3299 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3301 fprintf_filtered (stream
, " %s", plongest (l
));
3304 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3306 fprintf_filtered (stream
, " %s", pulongest (ul
));
3309 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3311 fprintf_filtered (stream
, " %s", plongest (l
));
3314 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3316 fprintf_filtered (stream
, " %s", pulongest (ul
));
3319 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3321 fprintf_filtered (stream
, " %s", plongest (l
));
3324 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3326 fprintf_filtered (stream
, " %s", pulongest (ul
));
3329 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3331 fprintf_filtered (stream
, " %s", plongest (l
));
3334 data
= read_uleb128 (data
, end
, &ul
);
3335 fprintf_filtered (stream
, " %s", pulongest (ul
));
3338 data
= read_sleb128 (data
, end
, &l
);
3339 fprintf_filtered (stream
, " %s", plongest (l
));
3374 fprintf_filtered (stream
, " [$%s]",
3375 locexpr_regname (arch
, op
- DW_OP_reg0
));
3379 data
= read_uleb128 (data
, end
, &ul
);
3380 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3381 locexpr_regname (arch
, (int) ul
));
3384 case DW_OP_implicit_value
:
3385 data
= read_uleb128 (data
, end
, &ul
);
3387 fprintf_filtered (stream
, " %s", pulongest (ul
));
3422 data
= read_sleb128 (data
, end
, &l
);
3423 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
3424 locexpr_regname (arch
, op
- DW_OP_breg0
));
3428 data
= read_uleb128 (data
, end
, &ul
);
3429 data
= read_sleb128 (data
, end
, &l
);
3430 fprintf_filtered (stream
, " register %s [$%s] offset %s",
3432 locexpr_regname (arch
, (int) ul
),
3437 data
= read_sleb128 (data
, end
, &l
);
3438 fprintf_filtered (stream
, " %s", plongest (l
));
3441 case DW_OP_xderef_size
:
3442 case DW_OP_deref_size
:
3444 fprintf_filtered (stream
, " %d", *data
);
3448 case DW_OP_plus_uconst
:
3449 data
= read_uleb128 (data
, end
, &ul
);
3450 fprintf_filtered (stream
, " %s", pulongest (ul
));
3454 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3456 fprintf_filtered (stream
, " to %ld",
3457 (long) (data
+ l
- start
));
3461 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3463 fprintf_filtered (stream
, " %ld",
3464 (long) (data
+ l
- start
));
3468 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3470 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
3474 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3476 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3479 case DW_OP_call_ref
:
3480 ul
= extract_unsigned_integer (data
, offset_size
,
3481 gdbarch_byte_order (arch
));
3482 data
+= offset_size
;
3483 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
3487 data
= read_uleb128 (data
, end
, &ul
);
3488 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
3491 case DW_OP_bit_piece
:
3495 data
= read_uleb128 (data
, end
, &ul
);
3496 data
= read_uleb128 (data
, end
, &offset
);
3497 fprintf_filtered (stream
, " size %s offset %s (bits)",
3498 pulongest (ul
), pulongest (offset
));
3502 case DW_OP_GNU_implicit_pointer
:
3504 ul
= extract_unsigned_integer (data
, offset_size
,
3505 gdbarch_byte_order (arch
));
3506 data
+= offset_size
;
3508 data
= read_sleb128 (data
, end
, &l
);
3510 fprintf_filtered (stream
, " DIE %s offset %s",
3511 phex_nz (ul
, offset_size
),
3516 case DW_OP_GNU_deref_type
:
3518 int addr_size
= *data
++;
3522 data
= read_uleb128 (data
, end
, &offset
);
3523 type
= dwarf2_get_die_type (offset
, per_cu
);
3524 fprintf_filtered (stream
, "<");
3525 type_print (type
, "", stream
, -1);
3526 fprintf_filtered (stream
, " [0x%s]> %d", phex_nz (offset
, 0),
3531 case DW_OP_GNU_const_type
:
3536 data
= read_uleb128 (data
, end
, &type_die
);
3537 type
= dwarf2_get_die_type (type_die
, per_cu
);
3538 fprintf_filtered (stream
, "<");
3539 type_print (type
, "", stream
, -1);
3540 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
, 0));
3544 case DW_OP_GNU_regval_type
:
3546 ULONGEST type_die
, reg
;
3549 data
= read_uleb128 (data
, end
, ®
);
3550 data
= read_uleb128 (data
, end
, &type_die
);
3552 type
= dwarf2_get_die_type (type_die
, per_cu
);
3553 fprintf_filtered (stream
, "<");
3554 type_print (type
, "", stream
, -1);
3555 fprintf_filtered (stream
, " [0x%s]> [$%s]", phex_nz (type_die
, 0),
3556 locexpr_regname (arch
, reg
));
3560 case DW_OP_GNU_convert
:
3561 case DW_OP_GNU_reinterpret
:
3565 data
= read_uleb128 (data
, end
, &type_die
);
3568 fprintf_filtered (stream
, "<0>");
3573 type
= dwarf2_get_die_type (type_die
, per_cu
);
3574 fprintf_filtered (stream
, "<");
3575 type_print (type
, "", stream
, -1);
3576 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
, 0));
3581 case DW_OP_GNU_entry_value
:
3582 data
= read_uleb128 (data
, end
, &ul
);
3583 fputc_filtered ('\n', stream
);
3584 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
3585 start
, data
, data
+ ul
, indent
+ 2,
3591 fprintf_filtered (stream
, "\n");
3597 /* Describe a single location, which may in turn consist of multiple
3601 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
3602 struct ui_file
*stream
,
3603 const gdb_byte
*data
, int size
,
3604 struct objfile
*objfile
, unsigned int addr_size
,
3605 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
3607 const gdb_byte
*end
= data
+ size
;
3608 int first_piece
= 1, bad
= 0;
3612 const gdb_byte
*here
= data
;
3613 int disassemble
= 1;
3618 fprintf_filtered (stream
, _(", and "));
3620 if (!dwarf2_always_disassemble
)
3622 data
= locexpr_describe_location_piece (symbol
, stream
,
3624 data
, end
, addr_size
);
3625 /* If we printed anything, or if we have an empty piece,
3626 then don't disassemble. */
3628 || data
[0] == DW_OP_piece
3629 || data
[0] == DW_OP_bit_piece
)
3634 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
3635 data
= disassemble_dwarf_expression (stream
,
3636 get_objfile_arch (objfile
),
3637 addr_size
, offset_size
, data
,
3639 dwarf2_always_disassemble
,
3645 int empty
= data
== here
;
3648 fprintf_filtered (stream
, " ");
3649 if (data
[0] == DW_OP_piece
)
3653 data
= read_uleb128 (data
+ 1, end
, &bytes
);
3656 fprintf_filtered (stream
, _("an empty %s-byte piece"),
3659 fprintf_filtered (stream
, _(" [%s-byte piece]"),
3662 else if (data
[0] == DW_OP_bit_piece
)
3664 ULONGEST bits
, offset
;
3666 data
= read_uleb128 (data
+ 1, end
, &bits
);
3667 data
= read_uleb128 (data
, end
, &offset
);
3670 fprintf_filtered (stream
,
3671 _("an empty %s-bit piece"),
3674 fprintf_filtered (stream
,
3675 _(" [%s-bit piece, offset %s bits]"),
3676 pulongest (bits
), pulongest (offset
));
3686 if (bad
|| data
> end
)
3687 error (_("Corrupted DWARF2 expression for \"%s\"."),
3688 SYMBOL_PRINT_NAME (symbol
));
3691 /* Print a natural-language description of SYMBOL to STREAM. This
3692 version is for a symbol with a single location. */
3695 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
3696 struct ui_file
*stream
)
3698 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3699 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
3700 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
3701 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
3703 locexpr_describe_location_1 (symbol
, addr
, stream
,
3704 dlbaton
->data
, dlbaton
->size
,
3705 objfile
, addr_size
, offset_size
,
3709 /* Describe the location of SYMBOL as an agent value in VALUE, generating
3710 any necessary bytecode in AX. */
3713 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
3714 struct agent_expr
*ax
, struct axs_value
*value
)
3716 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3717 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
3719 if (dlbaton
->size
== 0)
3720 value
->optimized_out
= 1;
3722 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
3723 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
3727 /* The set of location functions used with the DWARF-2 expression
3729 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
3730 locexpr_read_variable
,
3731 locexpr_read_variable_at_entry
,
3732 locexpr_read_needs_frame
,
3733 locexpr_describe_location
,
3734 locexpr_tracepoint_var_ref
3738 /* Wrapper functions for location lists. These generally find
3739 the appropriate location expression and call something above. */
3741 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3742 evaluator to calculate the location. */
3743 static struct value
*
3744 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3746 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3748 const gdb_byte
*data
;
3750 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
3752 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
3753 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
3759 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
3760 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3763 Function always returns non-NULL value, it may be marked optimized out if
3764 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
3765 if it cannot resolve the parameter for any reason. */
3767 static struct value
*
3768 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3770 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3771 const gdb_byte
*data
;
3775 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
3776 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
3778 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
3780 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
3782 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
3785 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3787 loclist_read_needs_frame (struct symbol
*symbol
)
3789 /* If there's a location list, then assume we need to have a frame
3790 to choose the appropriate location expression. With tracking of
3791 global variables this is not necessarily true, but such tracking
3792 is disabled in GCC at the moment until we figure out how to
3798 /* Print a natural-language description of SYMBOL to STREAM. This
3799 version applies when there is a list of different locations, each
3800 with a specified address range. */
3803 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
3804 struct ui_file
*stream
)
3806 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3807 CORE_ADDR low
, high
;
3808 const gdb_byte
*loc_ptr
, *buf_end
;
3809 int length
, first
= 1;
3810 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
3811 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3812 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3813 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
3814 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
3815 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
3816 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3817 /* Adjust base_address for relocatable objects. */
3818 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
3819 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
3821 loc_ptr
= dlbaton
->data
;
3822 buf_end
= dlbaton
->data
+ dlbaton
->size
;
3824 fprintf_filtered (stream
, _("multi-location:\n"));
3826 /* Iterate through locations until we run out. */
3829 if (buf_end
- loc_ptr
< 2 * addr_size
)
3830 error (_("Corrupted DWARF expression for symbol \"%s\"."),
3831 SYMBOL_PRINT_NAME (symbol
));
3834 low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
3836 low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
3837 loc_ptr
+= addr_size
;
3840 high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
3842 high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
3843 loc_ptr
+= addr_size
;
3845 /* A base-address-selection entry. */
3846 if ((low
& base_mask
) == base_mask
)
3848 base_address
= high
+ base_offset
;
3849 fprintf_filtered (stream
, _(" Base address %s"),
3850 paddress (gdbarch
, base_address
));
3854 /* An end-of-list entry. */
3855 if (low
== 0 && high
== 0)
3858 /* Otherwise, a location expression entry. */
3859 low
+= base_address
;
3860 high
+= base_address
;
3862 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
3865 /* (It would improve readability to print only the minimum
3866 necessary digits of the second number of the range.) */
3867 fprintf_filtered (stream
, _(" Range %s-%s: "),
3868 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
3870 /* Now describe this particular location. */
3871 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
3872 objfile
, addr_size
, offset_size
,
3875 fprintf_filtered (stream
, "\n");
3881 /* Describe the location of SYMBOL as an agent value in VALUE, generating
3882 any necessary bytecode in AX. */
3884 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
3885 struct agent_expr
*ax
, struct axs_value
*value
)
3887 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3888 const gdb_byte
*data
;
3890 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
3892 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
3894 value
->optimized_out
= 1;
3896 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
3900 /* The set of location functions used with the DWARF-2 expression
3901 evaluator and location lists. */
3902 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
3903 loclist_read_variable
,
3904 loclist_read_variable_at_entry
,
3905 loclist_read_needs_frame
,
3906 loclist_describe_location
,
3907 loclist_tracepoint_var_ref
3911 _initialize_dwarf2loc (void)
3913 add_setshow_zinteger_cmd ("entry-values", class_maintenance
,
3914 &entry_values_debug
,
3915 _("Set entry values and tail call frames "
3917 _("Show entry values and tail call frames "
3919 _("When non-zero, the process of determining "
3920 "parameter values from function entry point "
3921 "and tail call frames will be printed."),
3923 show_entry_values_debug
,
3924 &setdebuglist
, &showdebuglist
);