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)
117 /* Otherwise, a location expression entry. */
119 high += base_address;
121 length = extract_unsigned_integer (loc_ptr, 2, byte_order);
124 if (low == high && pc == low)
126 /* This is entry PC record present only at entry point
127 of a function. Verify it is really the function entry point. */
129 struct block *pc_block = block_for_pc (pc);
130 struct symbol *pc_func = NULL;
133 pc_func = block_linkage_function (pc_block);
135 if (pc_func && pc == BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func)))
137 *locexpr_length = length;
142 if (pc >= low && pc < high)
144 *locexpr_length = length;
152 /* This is the baton used when performing dwarf2 expression
154 struct dwarf_expr_baton
156 struct frame_info *frame;
157 struct dwarf2_per_cu_data *per_cu;
160 /* Helper functions for dwarf2_evaluate_loc_desc. */
162 /* Using the frame specified in BATON, return the value of register
163 REGNUM, treated as a pointer. */
165 dwarf_expr_read_reg (void *baton, int dwarf_regnum)
167 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
168 struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
172 regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
173 result = address_from_register (builtin_type (gdbarch)->builtin_data_ptr,
174 regnum, debaton->frame);
178 /* Read memory at ADDR (length LEN) into BUF. */
181 dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
183 read_memory (addr, buf, len);
186 /* Using the frame specified in BATON, find the location expression
187 describing the frame base. Return a pointer to it in START and
188 its length in LENGTH. */
190 dwarf_expr_frame_base (void *baton, const gdb_byte **start, size_t * length)
192 /* FIXME: cagney/2003-03-26: This code should be using
193 get_frame_base_address(), and then implement a dwarf2 specific
195 struct symbol *framefunc;
196 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
198 /* Use block_linkage_function, which returns a real (not inlined)
199 function, instead of get_frame_function, which may return an
201 framefunc = block_linkage_function (get_frame_block (debaton->frame, NULL));
203 /* If we found a frame-relative symbol then it was certainly within
204 some function associated with a frame. If we can't find the frame,
205 something has gone wrong. */
206 gdb_assert (framefunc != NULL);
208 dwarf_expr_frame_base_1 (framefunc,
209 get_frame_address_in_block (debaton->frame),
214 dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
215 const gdb_byte **start, size_t *length)
217 if (SYMBOL_LOCATION_BATON (framefunc) == NULL)
219 else if (SYMBOL_COMPUTED_OPS (framefunc) == &dwarf2_loclist_funcs)
221 struct dwarf2_loclist_baton *symbaton;
223 symbaton = SYMBOL_LOCATION_BATON (framefunc);
224 *start = dwarf2_find_location_expression (symbaton, length, pc);
228 struct dwarf2_locexpr_baton *symbaton;
230 symbaton = SYMBOL_LOCATION_BATON (framefunc);
231 if (symbaton != NULL)
233 *length = symbaton->size;
234 *start = symbaton->data;
241 error (_("Could not find the frame base for \"%s\"."),
242 SYMBOL_NATURAL_NAME (framefunc));
245 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
246 the frame in BATON. */
249 dwarf_expr_frame_cfa (void *baton)
251 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
253 return dwarf2_frame_cfa (debaton->frame);
256 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
257 the frame in BATON. */
260 dwarf_expr_frame_pc (void *baton)
262 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
264 return get_frame_address_in_block (debaton->frame);
267 /* Using the objfile specified in BATON, find the address for the
268 current thread's thread-local storage with offset OFFSET. */
270 dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
272 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
273 struct objfile *objfile = dwarf2_per_cu_objfile (debaton->per_cu);
275 return target_translate_tls_address (objfile, offset);
278 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
279 current CU (as is PER_CU). State of the CTX is not affected by the
283 per_cu_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset,
284 struct dwarf2_per_cu_data *per_cu,
285 CORE_ADDR (*get_frame_pc) (void *baton),
288 struct dwarf2_locexpr_baton block;
290 block = dwarf2_fetch_die_location_block (die_offset, per_cu,
291 get_frame_pc, baton);
293 /* DW_OP_call_ref is currently not supported. */
294 gdb_assert (block.per_cu == per_cu);
296 dwarf_expr_eval (ctx, block.data, block.size);
299 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
302 dwarf_expr_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset)
304 struct dwarf_expr_baton *debaton = ctx->baton;
306 per_cu_dwarf_call (ctx, die_offset, debaton->per_cu,
307 ctx->funcs->get_frame_pc, ctx->baton);
310 /* Callback function for dwarf2_evaluate_loc_desc. */
313 dwarf_expr_get_base_type (struct dwarf_expr_context *ctx, size_t die_offset)
315 struct dwarf_expr_baton *debaton = ctx->baton;
317 return dwarf2_get_die_type (die_offset, debaton->per_cu);
320 /* See dwarf2loc.h. */
322 int entry_values_debug = 0;
324 /* Helper to set entry_values_debug. */
327 show_entry_values_debug (struct ui_file *file, int from_tty,
328 struct cmd_list_element *c, const char *value)
330 fprintf_filtered (file,
331 _("Entry values and tail call frames debugging is %s.\n"),
335 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
336 CALLER_FRAME (for registers) can be NULL if it is not known. This function
337 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
340 call_site_to_target_addr (struct gdbarch *call_site_gdbarch,
341 struct call_site *call_site,
342 struct frame_info *caller_frame)
344 switch (FIELD_LOC_KIND (call_site->target))
346 case FIELD_LOC_KIND_DWARF_BLOCK:
348 struct dwarf2_locexpr_baton *dwarf_block;
350 struct type *caller_core_addr_type;
351 struct gdbarch *caller_arch;
353 dwarf_block = FIELD_DWARF_BLOCK (call_site->target);
354 if (dwarf_block == NULL)
356 struct minimal_symbol *msym;
358 msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
359 throw_error (NO_ENTRY_VALUE_ERROR,
360 _("DW_AT_GNU_call_site_target is not specified "
362 paddress (call_site_gdbarch, call_site->pc),
363 msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
366 if (caller_frame == NULL)
368 struct minimal_symbol *msym;
370 msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
371 throw_error (NO_ENTRY_VALUE_ERROR,
372 _("DW_AT_GNU_call_site_target DWARF block resolving "
373 "requires known frame which is currently not "
374 "available at %s in %s"),
375 paddress (call_site_gdbarch, call_site->pc),
376 msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
379 caller_arch = get_frame_arch (caller_frame);
380 caller_core_addr_type = builtin_type (caller_arch)->builtin_func_ptr;
381 val = dwarf2_evaluate_loc_desc (caller_core_addr_type, caller_frame,
382 dwarf_block->data, dwarf_block->size,
383 dwarf_block->per_cu);
384 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
386 if (VALUE_LVAL (val) == lval_memory)
387 return value_address (val);
389 return value_as_address (val);
392 case FIELD_LOC_KIND_PHYSNAME:
394 const char *physname;
395 struct minimal_symbol *msym;
397 physname = FIELD_STATIC_PHYSNAME (call_site->target);
398 msym = lookup_minimal_symbol_text (physname, NULL);
401 msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
402 throw_error (NO_ENTRY_VALUE_ERROR,
403 _("Cannot find function \"%s\" for a call site target "
405 physname, paddress (call_site_gdbarch, call_site->pc),
406 msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
409 return SYMBOL_VALUE_ADDRESS (msym);
412 case FIELD_LOC_KIND_PHYSADDR:
413 return FIELD_STATIC_PHYSADDR (call_site->target);
416 internal_error (__FILE__, __LINE__, _("invalid call site target kind"));
420 /* Convert function entry point exact address ADDR to the function which is
421 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
422 NO_ENTRY_VALUE_ERROR otherwise. */
424 static struct symbol *
425 func_addr_to_tail_call_list (struct gdbarch *gdbarch, CORE_ADDR addr)
427 struct symbol *sym = find_pc_function (addr);
430 if (sym == NULL || BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) != addr)
431 throw_error (NO_ENTRY_VALUE_ERROR,
432 _("DW_TAG_GNU_call_site resolving failed to find function "
433 "name for address %s"),
434 paddress (gdbarch, addr));
436 type = SYMBOL_TYPE (sym);
437 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FUNC);
438 gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_FUNC);
443 /* Define VEC (CORE_ADDR) functions. */
444 DEF_VEC_I (CORE_ADDR);
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 struct call_site_parameter *parameter;
837 CORE_ADDR target_addr;
839 if (gdbarch != frame_unwind_arch (frame))
841 struct minimal_symbol *msym = lookup_minimal_symbol_by_pc (func_addr);
842 struct gdbarch *caller_gdbarch = frame_unwind_arch (frame);
844 throw_error (NO_ENTRY_VALUE_ERROR,
845 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
846 "(of %s (%s)) does not match caller gdbarch %s"),
847 gdbarch_bfd_arch_info (gdbarch)->printable_name,
848 paddress (gdbarch, func_addr),
849 msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym),
850 gdbarch_bfd_arch_info (caller_gdbarch)->printable_name);
853 if (caller_frame == NULL)
855 struct minimal_symbol *msym = lookup_minimal_symbol_by_pc (func_addr);
857 throw_error (NO_ENTRY_VALUE_ERROR, _("DW_OP_GNU_entry_value resolving "
858 "requires caller of %s (%s)"),
859 paddress (gdbarch, func_addr),
860 msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
862 caller_pc = get_frame_pc (caller_frame);
863 call_site = call_site_for_pc (gdbarch, caller_pc);
865 target_addr = call_site_to_target_addr (gdbarch, call_site, caller_frame);
866 if (target_addr != func_addr)
868 struct minimal_symbol *target_msym, *func_msym;
870 target_msym = lookup_minimal_symbol_by_pc (target_addr);
871 func_msym = lookup_minimal_symbol_by_pc (func_addr);
872 throw_error (NO_ENTRY_VALUE_ERROR,
873 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
874 "but the called frame is for %s at %s"),
875 (target_msym == NULL ? "???"
876 : SYMBOL_PRINT_NAME (target_msym)),
877 paddress (gdbarch, target_addr),
878 func_msym == NULL ? "???" : SYMBOL_PRINT_NAME (func_msym),
879 paddress (gdbarch, func_addr));
882 /* No entry value based parameters would be reliable if this function can
883 call itself via tail calls. */
884 func_verify_no_selftailcall (gdbarch, func_addr);
886 for (iparams = 0; iparams < call_site->parameter_count; iparams++)
888 parameter = &call_site->parameter[iparams];
889 if (parameter->dwarf_reg == -1 && dwarf_reg == -1)
891 if (parameter->fb_offset == fb_offset)
894 else if (parameter->dwarf_reg == dwarf_reg)
897 if (iparams == call_site->parameter_count)
899 struct minimal_symbol *msym = lookup_minimal_symbol_by_pc (caller_pc);
901 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
902 determine its value. */
903 throw_error (NO_ENTRY_VALUE_ERROR, _("Cannot find matching parameter "
904 "at DW_TAG_GNU_call_site %s at %s"),
905 paddress (gdbarch, caller_pc),
906 msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
909 *per_cu_return = call_site->per_cu;
913 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
914 the normal DW_AT_GNU_call_site_value block. Otherwise return the
915 DW_AT_GNU_call_site_data_value (dereferenced) block.
917 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
920 Function always returns non-NULL, non-optimized out value. It throws
921 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
923 static struct value *
924 dwarf_entry_parameter_to_value (struct call_site_parameter *parameter,
925 CORE_ADDR deref_size, struct type *type,
926 struct frame_info *caller_frame,
927 struct dwarf2_per_cu_data *per_cu)
929 const gdb_byte *data_src;
933 data_src = deref_size == -1 ? parameter->value : parameter->data_value;
934 size = deref_size == -1 ? parameter->value_size : parameter->data_value_size;
936 /* DEREF_SIZE size is not verified here. */
937 if (data_src == NULL)
938 throw_error (NO_ENTRY_VALUE_ERROR,
939 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
941 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
942 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
944 data = alloca (size + 1);
945 memcpy (data, data_src, size);
946 data[size] = DW_OP_stack_value;
948 return dwarf2_evaluate_loc_desc (type, caller_frame, data, size + 1, per_cu);
951 /* Execute call_site_parameter's DWARF block matching DEREF_SIZE for caller of
952 the CTX's frame. CTX must be of dwarf_expr_ctx_funcs kind. See DWARF_REG
953 and FB_OFFSET description at struct
954 dwarf_expr_context_funcs->push_dwarf_reg_entry_value.
956 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
957 can be more simple as it does not support cross-CU DWARF executions. */
960 dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
961 int dwarf_reg, CORE_ADDR fb_offset,
964 struct dwarf_expr_baton *debaton;
965 struct frame_info *frame, *caller_frame;
966 struct dwarf2_per_cu_data *caller_per_cu;
967 struct dwarf_expr_baton baton_local;
968 struct dwarf_expr_context saved_ctx;
969 struct call_site_parameter *parameter;
970 const gdb_byte *data_src;
973 gdb_assert (ctx->funcs == &dwarf_expr_ctx_funcs);
974 debaton = ctx->baton;
975 frame = debaton->frame;
976 caller_frame = get_prev_frame (frame);
978 parameter = dwarf_expr_reg_to_entry_parameter (frame, dwarf_reg, fb_offset,
980 data_src = deref_size == -1 ? parameter->value : parameter->data_value;
981 size = deref_size == -1 ? parameter->value_size : parameter->data_value_size;
983 /* DEREF_SIZE size is not verified here. */
984 if (data_src == NULL)
985 throw_error (NO_ENTRY_VALUE_ERROR,
986 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
988 baton_local.frame = caller_frame;
989 baton_local.per_cu = caller_per_cu;
991 saved_ctx.gdbarch = ctx->gdbarch;
992 saved_ctx.addr_size = ctx->addr_size;
993 saved_ctx.offset = ctx->offset;
994 saved_ctx.baton = ctx->baton;
995 ctx->gdbarch = get_objfile_arch (dwarf2_per_cu_objfile (baton_local.per_cu));
996 ctx->addr_size = dwarf2_per_cu_addr_size (baton_local.per_cu);
997 ctx->offset = dwarf2_per_cu_text_offset (baton_local.per_cu);
998 ctx->baton = &baton_local;
1000 dwarf_expr_eval (ctx, data_src, size);
1002 ctx->gdbarch = saved_ctx.gdbarch;
1003 ctx->addr_size = saved_ctx.addr_size;
1004 ctx->offset = saved_ctx.offset;
1005 ctx->baton = saved_ctx.baton;
1008 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1009 the indirect method on it, that is use its stored target value, the sole
1010 purpose of entry_data_value_funcs.. */
1012 static struct value *
1013 entry_data_value_coerce_ref (const struct value *value)
1015 struct type *checked_type = check_typedef (value_type (value));
1016 struct value *target_val;
1018 if (TYPE_CODE (checked_type) != TYPE_CODE_REF)
1021 target_val = value_computed_closure (value);
1022 value_incref (target_val);
1026 /* Implement copy_closure. */
1029 entry_data_value_copy_closure (const struct value *v)
1031 struct value *target_val = value_computed_closure (v);
1033 value_incref (target_val);
1037 /* Implement free_closure. */
1040 entry_data_value_free_closure (struct value *v)
1042 struct value *target_val = value_computed_closure (v);
1044 value_free (target_val);
1047 /* Vector for methods for an entry value reference where the referenced value
1048 is stored in the caller. On the first dereference use
1049 DW_AT_GNU_call_site_data_value in the caller. */
1051 static const struct lval_funcs entry_data_value_funcs =
1055 NULL, /* check_validity */
1056 NULL, /* check_any_valid */
1057 NULL, /* indirect */
1058 entry_data_value_coerce_ref,
1059 NULL, /* check_synthetic_pointer */
1060 entry_data_value_copy_closure,
1061 entry_data_value_free_closure
1064 /* Read parameter of TYPE at (callee) FRAME's function entry. DWARF_REG and
1065 FB_OFFSET are used to match DW_AT_location at the caller's
1066 DW_TAG_GNU_call_site_parameter. See DWARF_REG and FB_OFFSET description at
1067 struct dwarf_expr_context_funcs->push_dwarf_reg_entry_value.
1069 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1070 cannot resolve the parameter for any reason. */
1072 static struct value *
1073 value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame,
1074 int dwarf_reg, CORE_ADDR fb_offset)
1076 struct type *checked_type = check_typedef (type);
1077 struct type *target_type = TYPE_TARGET_TYPE (checked_type);
1078 struct frame_info *caller_frame = get_prev_frame (frame);
1079 struct value *outer_val, *target_val, *val;
1080 struct call_site_parameter *parameter;
1081 struct dwarf2_per_cu_data *caller_per_cu;
1084 parameter = dwarf_expr_reg_to_entry_parameter (frame, dwarf_reg, fb_offset,
1087 outer_val = dwarf_entry_parameter_to_value (parameter, -1 /* deref_size */,
1091 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1092 used and it is not available do not fall back to OUTER_VAL - dereferencing
1093 TYPE_CODE_REF with non-entry data value would give current value - not the
1096 if (TYPE_CODE (checked_type) != TYPE_CODE_REF
1097 || TYPE_TARGET_TYPE (checked_type) == NULL)
1100 target_val = dwarf_entry_parameter_to_value (parameter,
1101 TYPE_LENGTH (target_type),
1102 target_type, caller_frame,
1105 /* value_as_address dereferences TYPE_CODE_REF. */
1106 addr = extract_typed_address (value_contents (outer_val), checked_type);
1108 /* The target entry value has artificial address of the entry value
1110 VALUE_LVAL (target_val) = lval_memory;
1111 set_value_address (target_val, addr);
1113 release_value (target_val);
1114 val = allocate_computed_value (type, &entry_data_value_funcs,
1115 target_val /* closure */);
1117 /* Copy the referencing pointer to the new computed value. */
1118 memcpy (value_contents_raw (val), value_contents_raw (outer_val),
1119 TYPE_LENGTH (checked_type));
1120 set_value_lazy (val, 0);
1125 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1126 SIZE are DWARF block used to match DW_AT_location at the caller's
1127 DW_TAG_GNU_call_site_parameter.
1129 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1130 cannot resolve the parameter for any reason. */
1132 static struct value *
1133 value_of_dwarf_block_entry (struct type *type, struct frame_info *frame,
1134 const gdb_byte *block, size_t block_len)
1137 CORE_ADDR fb_offset;
1139 dwarf_reg = dwarf_block_to_dwarf_reg (block, block + block_len);
1140 if (dwarf_reg != -1)
1141 return value_of_dwarf_reg_entry (type, frame, dwarf_reg, 0 /* unused */);
1143 if (dwarf_block_to_fb_offset (block, block + block_len, &fb_offset))
1144 return value_of_dwarf_reg_entry (type, frame, -1, fb_offset);
1146 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1147 suppressed during normal operation. The expression can be arbitrary if
1148 there is no caller-callee entry value binding expected. */
1149 throw_error (NO_ENTRY_VALUE_ERROR,
1150 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1151 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1154 struct piece_closure
1156 /* Reference count. */
1159 /* The CU from which this closure's expression came. */
1160 struct dwarf2_per_cu_data *per_cu;
1162 /* The number of pieces used to describe this variable. */
1165 /* The target address size, used only for DWARF_VALUE_STACK. */
1168 /* The pieces themselves. */
1169 struct dwarf_expr_piece *pieces;
1172 /* Allocate a closure for a value formed from separately-described
1175 static struct piece_closure *
1176 allocate_piece_closure (struct dwarf2_per_cu_data *per_cu,
1177 int n_pieces, struct dwarf_expr_piece *pieces,
1180 struct piece_closure *c = XZALLOC (struct piece_closure);
1185 c->n_pieces = n_pieces;
1186 c->addr_size = addr_size;
1187 c->pieces = XCALLOC (n_pieces, struct dwarf_expr_piece);
1189 memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
1190 for (i = 0; i < n_pieces; ++i)
1191 if (c->pieces[i].location == DWARF_VALUE_STACK)
1192 value_incref (c->pieces[i].v.value);
1197 /* The lowest-level function to extract bits from a byte buffer.
1198 SOURCE is the buffer. It is updated if we read to the end of a
1200 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1201 updated to reflect the number of bits actually read.
1202 NBITS is the number of bits we want to read. It is updated to
1203 reflect the number of bits actually read. This function may read
1205 BITS_BIG_ENDIAN is taken directly from gdbarch.
1206 This function returns the extracted bits. */
1209 extract_bits_primitive (const gdb_byte **source,
1210 unsigned int *source_offset_bits,
1211 int *nbits, int bits_big_endian)
1213 unsigned int avail, mask, datum;
1215 gdb_assert (*source_offset_bits < 8);
1217 avail = 8 - *source_offset_bits;
1221 mask = (1 << avail) - 1;
1223 if (bits_big_endian)
1224 datum >>= 8 - (*source_offset_bits + *nbits);
1226 datum >>= *source_offset_bits;
1230 *source_offset_bits += avail;
1231 if (*source_offset_bits >= 8)
1233 *source_offset_bits -= 8;
1240 /* Extract some bits from a source buffer and move forward in the
1243 SOURCE is the source buffer. It is updated as bytes are read.
1244 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1246 NBITS is the number of bits to read.
1247 BITS_BIG_ENDIAN is taken directly from gdbarch.
1249 This function returns the bits that were read. */
1252 extract_bits (const gdb_byte **source, unsigned int *source_offset_bits,
1253 int nbits, int bits_big_endian)
1257 gdb_assert (nbits > 0 && nbits <= 8);
1259 datum = extract_bits_primitive (source, source_offset_bits, &nbits,
1265 more = extract_bits_primitive (source, source_offset_bits, &nbits,
1267 if (bits_big_endian)
1277 /* Write some bits into a buffer and move forward in the buffer.
1279 DATUM is the bits to write. The low-order bits of DATUM are used.
1280 DEST is the destination buffer. It is updated as bytes are
1282 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1284 NBITS is the number of valid bits in DATUM.
1285 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1288 insert_bits (unsigned int datum,
1289 gdb_byte *dest, unsigned int dest_offset_bits,
1290 int nbits, int bits_big_endian)
1294 gdb_assert (dest_offset_bits + nbits <= 8);
1296 mask = (1 << nbits) - 1;
1297 if (bits_big_endian)
1299 datum <<= 8 - (dest_offset_bits + nbits);
1300 mask <<= 8 - (dest_offset_bits + nbits);
1304 datum <<= dest_offset_bits;
1305 mask <<= dest_offset_bits;
1308 gdb_assert ((datum & ~mask) == 0);
1310 *dest = (*dest & ~mask) | datum;
1313 /* Copy bits from a source to a destination.
1315 DEST is where the bits should be written.
1316 DEST_OFFSET_BITS is the bit offset into DEST.
1317 SOURCE is the source of bits.
1318 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1319 BIT_COUNT is the number of bits to copy.
1320 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1323 copy_bitwise (gdb_byte *dest, unsigned int dest_offset_bits,
1324 const gdb_byte *source, unsigned int source_offset_bits,
1325 unsigned int bit_count,
1326 int bits_big_endian)
1328 unsigned int dest_avail;
1331 /* Reduce everything to byte-size pieces. */
1332 dest += dest_offset_bits / 8;
1333 dest_offset_bits %= 8;
1334 source += source_offset_bits / 8;
1335 source_offset_bits %= 8;
1337 dest_avail = 8 - dest_offset_bits % 8;
1339 /* See if we can fill the first destination byte. */
1340 if (dest_avail < bit_count)
1342 datum = extract_bits (&source, &source_offset_bits, dest_avail,
1344 insert_bits (datum, dest, dest_offset_bits, dest_avail, bits_big_endian);
1346 dest_offset_bits = 0;
1347 bit_count -= dest_avail;
1350 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1351 than 8 bits remaining. */
1352 gdb_assert (dest_offset_bits % 8 == 0 || bit_count < 8);
1353 for (; bit_count >= 8; bit_count -= 8)
1355 datum = extract_bits (&source, &source_offset_bits, 8, bits_big_endian);
1356 *dest++ = (gdb_byte) datum;
1359 /* Finally, we may have a few leftover bits. */
1360 gdb_assert (bit_count <= 8 - dest_offset_bits % 8);
1363 datum = extract_bits (&source, &source_offset_bits, bit_count,
1365 insert_bits (datum, dest, dest_offset_bits, bit_count, bits_big_endian);
1370 read_pieced_value (struct value *v)
1374 ULONGEST bits_to_skip;
1376 struct piece_closure *c
1377 = (struct piece_closure *) value_computed_closure (v);
1378 struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
1380 size_t buffer_size = 0;
1381 char *buffer = NULL;
1382 struct cleanup *cleanup;
1384 = gdbarch_bits_big_endian (get_type_arch (value_type (v)));
1386 if (value_type (v) != value_enclosing_type (v))
1387 internal_error (__FILE__, __LINE__,
1388 _("Should not be able to create a lazy value with "
1389 "an enclosing type"));
1391 cleanup = make_cleanup (free_current_contents, &buffer);
1393 contents = value_contents_raw (v);
1394 bits_to_skip = 8 * value_offset (v);
1395 if (value_bitsize (v))
1397 bits_to_skip += value_bitpos (v);
1398 type_len = value_bitsize (v);
1401 type_len = 8 * TYPE_LENGTH (value_type (v));
1403 for (i = 0; i < c->n_pieces && offset < type_len; i++)
1405 struct dwarf_expr_piece *p = &c->pieces[i];
1406 size_t this_size, this_size_bits;
1407 long dest_offset_bits, source_offset_bits, source_offset;
1408 const gdb_byte *intermediate_buffer;
1410 /* Compute size, source, and destination offsets for copying, in
1412 this_size_bits = p->size;
1413 if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
1415 bits_to_skip -= this_size_bits;
1418 if (this_size_bits > type_len - offset)
1419 this_size_bits = type_len - offset;
1420 if (bits_to_skip > 0)
1422 dest_offset_bits = 0;
1423 source_offset_bits = bits_to_skip;
1424 this_size_bits -= bits_to_skip;
1429 dest_offset_bits = offset;
1430 source_offset_bits = 0;
1433 this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
1434 source_offset = source_offset_bits / 8;
1435 if (buffer_size < this_size)
1437 buffer_size = this_size;
1438 buffer = xrealloc (buffer, buffer_size);
1440 intermediate_buffer = buffer;
1442 /* Copy from the source to DEST_BUFFER. */
1443 switch (p->location)
1445 case DWARF_VALUE_REGISTER:
1447 struct gdbarch *arch = get_frame_arch (frame);
1448 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
1449 int reg_offset = source_offset;
1451 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
1452 && this_size < register_size (arch, gdb_regnum))
1454 /* Big-endian, and we want less than full size. */
1455 reg_offset = register_size (arch, gdb_regnum) - this_size;
1456 /* We want the lower-order THIS_SIZE_BITS of the bytes
1457 we extract from the register. */
1458 source_offset_bits += 8 * this_size - this_size_bits;
1461 if (gdb_regnum != -1)
1465 if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
1469 /* Just so garbage doesn't ever shine through. */
1470 memset (buffer, 0, this_size);
1473 set_value_optimized_out (v, 1);
1475 mark_value_bytes_unavailable (v, offset, this_size);
1480 error (_("Unable to access DWARF register number %s"),
1481 paddress (arch, p->v.regno));
1486 case DWARF_VALUE_MEMORY:
1487 read_value_memory (v, offset,
1488 p->v.mem.in_stack_memory,
1489 p->v.mem.addr + source_offset,
1493 case DWARF_VALUE_STACK:
1495 size_t n = this_size;
1497 if (n > c->addr_size - source_offset)
1498 n = (c->addr_size >= source_offset
1499 ? c->addr_size - source_offset
1507 const gdb_byte *val_bytes = value_contents_all (p->v.value);
1509 intermediate_buffer = val_bytes + source_offset;
1514 case DWARF_VALUE_LITERAL:
1516 size_t n = this_size;
1518 if (n > p->v.literal.length - source_offset)
1519 n = (p->v.literal.length >= source_offset
1520 ? p->v.literal.length - source_offset
1523 intermediate_buffer = p->v.literal.data + source_offset;
1527 /* These bits show up as zeros -- but do not cause the value
1528 to be considered optimized-out. */
1529 case DWARF_VALUE_IMPLICIT_POINTER:
1532 case DWARF_VALUE_OPTIMIZED_OUT:
1533 set_value_optimized_out (v, 1);
1537 internal_error (__FILE__, __LINE__, _("invalid location type"));
1540 if (p->location != DWARF_VALUE_OPTIMIZED_OUT
1541 && p->location != DWARF_VALUE_IMPLICIT_POINTER)
1542 copy_bitwise (contents, dest_offset_bits,
1543 intermediate_buffer, source_offset_bits % 8,
1544 this_size_bits, bits_big_endian);
1546 offset += this_size_bits;
1549 do_cleanups (cleanup);
1553 write_pieced_value (struct value *to, struct value *from)
1557 ULONGEST bits_to_skip;
1558 const gdb_byte *contents;
1559 struct piece_closure *c
1560 = (struct piece_closure *) value_computed_closure (to);
1561 struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
1563 size_t buffer_size = 0;
1564 char *buffer = NULL;
1565 struct cleanup *cleanup;
1567 = gdbarch_bits_big_endian (get_type_arch (value_type (to)));
1571 set_value_optimized_out (to, 1);
1575 cleanup = make_cleanup (free_current_contents, &buffer);
1577 contents = value_contents (from);
1578 bits_to_skip = 8 * value_offset (to);
1579 if (value_bitsize (to))
1581 bits_to_skip += value_bitpos (to);
1582 type_len = value_bitsize (to);
1585 type_len = 8 * TYPE_LENGTH (value_type (to));
1587 for (i = 0; i < c->n_pieces && offset < type_len; i++)
1589 struct dwarf_expr_piece *p = &c->pieces[i];
1590 size_t this_size_bits, this_size;
1591 long dest_offset_bits, source_offset_bits, dest_offset, source_offset;
1593 const gdb_byte *source_buffer;
1595 this_size_bits = p->size;
1596 if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
1598 bits_to_skip -= this_size_bits;
1601 if (this_size_bits > type_len - offset)
1602 this_size_bits = type_len - offset;
1603 if (bits_to_skip > 0)
1605 dest_offset_bits = bits_to_skip;
1606 source_offset_bits = 0;
1607 this_size_bits -= bits_to_skip;
1612 dest_offset_bits = 0;
1613 source_offset_bits = offset;
1616 this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
1617 source_offset = source_offset_bits / 8;
1618 dest_offset = dest_offset_bits / 8;
1619 if (dest_offset_bits % 8 == 0 && source_offset_bits % 8 == 0)
1621 source_buffer = contents + source_offset;
1626 if (buffer_size < this_size)
1628 buffer_size = this_size;
1629 buffer = xrealloc (buffer, buffer_size);
1631 source_buffer = buffer;
1635 switch (p->location)
1637 case DWARF_VALUE_REGISTER:
1639 struct gdbarch *arch = get_frame_arch (frame);
1640 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
1641 int reg_offset = dest_offset;
1643 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
1644 && this_size <= register_size (arch, gdb_regnum))
1645 /* Big-endian, and we want less than full size. */
1646 reg_offset = register_size (arch, gdb_regnum) - this_size;
1648 if (gdb_regnum != -1)
1654 if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
1659 error (_("Can't do read-modify-write to "
1660 "update bitfield; containing word has been "
1663 throw_error (NOT_AVAILABLE_ERROR,
1664 _("Can't do read-modify-write to update "
1665 "bitfield; containing word "
1668 copy_bitwise (buffer, dest_offset_bits,
1669 contents, source_offset_bits,
1674 put_frame_register_bytes (frame, gdb_regnum, reg_offset,
1675 this_size, source_buffer);
1679 error (_("Unable to write to DWARF register number %s"),
1680 paddress (arch, p->v.regno));
1684 case DWARF_VALUE_MEMORY:
1687 /* Only the first and last bytes can possibly have any
1689 read_memory (p->v.mem.addr + dest_offset, buffer, 1);
1690 read_memory (p->v.mem.addr + dest_offset + this_size - 1,
1691 buffer + this_size - 1, 1);
1692 copy_bitwise (buffer, dest_offset_bits,
1693 contents, source_offset_bits,
1698 write_memory (p->v.mem.addr + dest_offset,
1699 source_buffer, this_size);
1702 set_value_optimized_out (to, 1);
1705 offset += this_size_bits;
1708 do_cleanups (cleanup);
1711 /* A helper function that checks bit validity in a pieced value.
1712 CHECK_FOR indicates the kind of validity checking.
1713 DWARF_VALUE_MEMORY means to check whether any bit is valid.
1714 DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
1716 DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
1717 implicit pointer. */
1720 check_pieced_value_bits (const struct value *value, int bit_offset,
1722 enum dwarf_value_location check_for)
1724 struct piece_closure *c
1725 = (struct piece_closure *) value_computed_closure (value);
1727 int validity = (check_for == DWARF_VALUE_MEMORY
1728 || check_for == DWARF_VALUE_IMPLICIT_POINTER);
1730 bit_offset += 8 * value_offset (value);
1731 if (value_bitsize (value))
1732 bit_offset += value_bitpos (value);
1734 for (i = 0; i < c->n_pieces && bit_length > 0; i++)
1736 struct dwarf_expr_piece *p = &c->pieces[i];
1737 size_t this_size_bits = p->size;
1741 if (bit_offset >= this_size_bits)
1743 bit_offset -= this_size_bits;
1747 bit_length -= this_size_bits - bit_offset;
1751 bit_length -= this_size_bits;
1753 if (check_for == DWARF_VALUE_IMPLICIT_POINTER)
1755 if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
1758 else if (p->location == DWARF_VALUE_OPTIMIZED_OUT
1759 || p->location == DWARF_VALUE_IMPLICIT_POINTER)
1775 check_pieced_value_validity (const struct value *value, int bit_offset,
1778 return check_pieced_value_bits (value, bit_offset, bit_length,
1779 DWARF_VALUE_MEMORY);
1783 check_pieced_value_invalid (const struct value *value)
1785 return check_pieced_value_bits (value, 0,
1786 8 * TYPE_LENGTH (value_type (value)),
1787 DWARF_VALUE_OPTIMIZED_OUT);
1790 /* An implementation of an lval_funcs method to see whether a value is
1791 a synthetic pointer. */
1794 check_pieced_synthetic_pointer (const struct value *value, int bit_offset,
1797 return check_pieced_value_bits (value, bit_offset, bit_length,
1798 DWARF_VALUE_IMPLICIT_POINTER);
1801 /* A wrapper function for get_frame_address_in_block. */
1804 get_frame_address_in_block_wrapper (void *baton)
1806 return get_frame_address_in_block (baton);
1809 /* An implementation of an lval_funcs method to indirect through a
1810 pointer. This handles the synthetic pointer case when needed. */
1812 static struct value *
1813 indirect_pieced_value (struct value *value)
1815 struct piece_closure *c
1816 = (struct piece_closure *) value_computed_closure (value);
1818 struct frame_info *frame;
1819 struct dwarf2_locexpr_baton baton;
1820 int i, bit_offset, bit_length;
1821 struct dwarf_expr_piece *piece = NULL;
1822 LONGEST byte_offset;
1824 type = check_typedef (value_type (value));
1825 if (TYPE_CODE (type) != TYPE_CODE_PTR)
1828 bit_length = 8 * TYPE_LENGTH (type);
1829 bit_offset = 8 * value_offset (value);
1830 if (value_bitsize (value))
1831 bit_offset += value_bitpos (value);
1833 for (i = 0; i < c->n_pieces && bit_length > 0; i++)
1835 struct dwarf_expr_piece *p = &c->pieces[i];
1836 size_t this_size_bits = p->size;
1840 if (bit_offset >= this_size_bits)
1842 bit_offset -= this_size_bits;
1846 bit_length -= this_size_bits - bit_offset;
1850 bit_length -= this_size_bits;
1852 if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
1855 if (bit_length != 0)
1856 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
1862 frame = get_selected_frame (_("No frame selected."));
1864 /* This is an offset requested by GDB, such as value subcripts. */
1865 byte_offset = value_as_address (value);
1868 baton = dwarf2_fetch_die_location_block (piece->v.ptr.die, c->per_cu,
1869 get_frame_address_in_block_wrapper,
1872 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
1873 baton.data, baton.size, baton.per_cu,
1874 piece->v.ptr.offset + byte_offset);
1878 copy_pieced_value_closure (const struct value *v)
1880 struct piece_closure *c
1881 = (struct piece_closure *) value_computed_closure (v);
1888 free_pieced_value_closure (struct value *v)
1890 struct piece_closure *c
1891 = (struct piece_closure *) value_computed_closure (v);
1898 for (i = 0; i < c->n_pieces; ++i)
1899 if (c->pieces[i].location == DWARF_VALUE_STACK)
1900 value_free (c->pieces[i].v.value);
1907 /* Functions for accessing a variable described by DW_OP_piece. */
1908 static const struct lval_funcs pieced_value_funcs = {
1911 check_pieced_value_validity,
1912 check_pieced_value_invalid,
1913 indirect_pieced_value,
1914 NULL, /* coerce_ref */
1915 check_pieced_synthetic_pointer,
1916 copy_pieced_value_closure,
1917 free_pieced_value_closure
1920 /* Helper function which throws an error if a synthetic pointer is
1924 invalid_synthetic_pointer (void)
1926 error (_("access outside bounds of object "
1927 "referenced via synthetic pointer"));
1930 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
1932 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs =
1934 dwarf_expr_read_reg,
1935 dwarf_expr_read_mem,
1936 dwarf_expr_frame_base,
1937 dwarf_expr_frame_cfa,
1938 dwarf_expr_frame_pc,
1939 dwarf_expr_tls_address,
1940 dwarf_expr_dwarf_call,
1941 dwarf_expr_get_base_type,
1942 dwarf_expr_push_dwarf_reg_entry_value
1945 /* Evaluate a location description, starting at DATA and with length
1946 SIZE, to find the current location of variable of TYPE in the
1947 context of FRAME. BYTE_OFFSET is applied after the contents are
1950 static struct value *
1951 dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
1952 const gdb_byte *data, unsigned short size,
1953 struct dwarf2_per_cu_data *per_cu,
1954 LONGEST byte_offset)
1956 struct value *retval;
1957 struct dwarf_expr_baton baton;
1958 struct dwarf_expr_context *ctx;
1959 struct cleanup *old_chain, *value_chain;
1960 struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
1961 volatile struct gdb_exception ex;
1963 if (byte_offset < 0)
1964 invalid_synthetic_pointer ();
1967 return allocate_optimized_out_value (type);
1969 baton.frame = frame;
1970 baton.per_cu = per_cu;
1972 ctx = new_dwarf_expr_context ();
1973 old_chain = make_cleanup_free_dwarf_expr_context (ctx);
1974 value_chain = make_cleanup_value_free_to_mark (value_mark ());
1976 ctx->gdbarch = get_objfile_arch (objfile);
1977 ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
1978 ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu);
1979 ctx->offset = dwarf2_per_cu_text_offset (per_cu);
1980 ctx->baton = &baton;
1981 ctx->funcs = &dwarf_expr_ctx_funcs;
1983 TRY_CATCH (ex, RETURN_MASK_ERROR)
1985 dwarf_expr_eval (ctx, data, size);
1989 if (ex.error == NOT_AVAILABLE_ERROR)
1991 do_cleanups (old_chain);
1992 retval = allocate_value (type);
1993 mark_value_bytes_unavailable (retval, 0, TYPE_LENGTH (type));
1996 else if (ex.error == NO_ENTRY_VALUE_ERROR)
1998 if (entry_values_debug)
1999 exception_print (gdb_stdout, ex);
2000 do_cleanups (old_chain);
2001 return allocate_optimized_out_value (type);
2004 throw_exception (ex);
2007 if (ctx->num_pieces > 0)
2009 struct piece_closure *c;
2010 struct frame_id frame_id = get_frame_id (frame);
2011 ULONGEST bit_size = 0;
2014 for (i = 0; i < ctx->num_pieces; ++i)
2015 bit_size += ctx->pieces[i].size;
2016 if (8 * (byte_offset + TYPE_LENGTH (type)) > bit_size)
2017 invalid_synthetic_pointer ();
2019 c = allocate_piece_closure (per_cu, ctx->num_pieces, ctx->pieces,
2021 /* We must clean up the value chain after creating the piece
2022 closure but before allocating the result. */
2023 do_cleanups (value_chain);
2024 retval = allocate_computed_value (type, &pieced_value_funcs, c);
2025 VALUE_FRAME_ID (retval) = frame_id;
2026 set_value_offset (retval, byte_offset);
2030 switch (ctx->location)
2032 case DWARF_VALUE_REGISTER:
2034 struct gdbarch *arch = get_frame_arch (frame);
2035 ULONGEST dwarf_regnum = value_as_long (dwarf_expr_fetch (ctx, 0));
2036 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
2038 if (byte_offset != 0)
2039 error (_("cannot use offset on synthetic pointer to register"));
2040 do_cleanups (value_chain);
2041 if (gdb_regnum != -1)
2042 retval = value_from_register (type, gdb_regnum, frame);
2044 error (_("Unable to access DWARF register number %s"),
2045 paddress (arch, dwarf_regnum));
2049 case DWARF_VALUE_MEMORY:
2051 CORE_ADDR address = dwarf_expr_fetch_address (ctx, 0);
2052 int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
2054 do_cleanups (value_chain);
2055 retval = allocate_value_lazy (type);
2056 VALUE_LVAL (retval) = lval_memory;
2057 if (in_stack_memory)
2058 set_value_stack (retval, 1);
2059 set_value_address (retval, address + byte_offset);
2063 case DWARF_VALUE_STACK:
2065 struct value *value = dwarf_expr_fetch (ctx, 0);
2067 const gdb_byte *val_bytes;
2068 size_t n = TYPE_LENGTH (value_type (value));
2070 if (byte_offset + TYPE_LENGTH (type) > n)
2071 invalid_synthetic_pointer ();
2073 val_bytes = value_contents_all (value);
2074 val_bytes += byte_offset;
2077 /* Preserve VALUE because we are going to free values back
2078 to the mark, but we still need the value contents
2080 value_incref (value);
2081 do_cleanups (value_chain);
2082 make_cleanup_value_free (value);
2084 retval = allocate_value (type);
2085 contents = value_contents_raw (retval);
2086 if (n > TYPE_LENGTH (type))
2088 struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
2090 if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
2091 val_bytes += n - TYPE_LENGTH (type);
2092 n = TYPE_LENGTH (type);
2094 memcpy (contents, val_bytes, n);
2098 case DWARF_VALUE_LITERAL:
2101 const bfd_byte *ldata;
2102 size_t n = ctx->len;
2104 if (byte_offset + TYPE_LENGTH (type) > n)
2105 invalid_synthetic_pointer ();
2107 do_cleanups (value_chain);
2108 retval = allocate_value (type);
2109 contents = value_contents_raw (retval);
2111 ldata = ctx->data + byte_offset;
2114 if (n > TYPE_LENGTH (type))
2116 struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
2118 if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
2119 ldata += n - TYPE_LENGTH (type);
2120 n = TYPE_LENGTH (type);
2122 memcpy (contents, ldata, n);
2126 case DWARF_VALUE_OPTIMIZED_OUT:
2127 do_cleanups (value_chain);
2128 retval = allocate_optimized_out_value (type);
2131 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2132 operation by execute_stack_op. */
2133 case DWARF_VALUE_IMPLICIT_POINTER:
2134 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2135 it can only be encountered when making a piece. */
2137 internal_error (__FILE__, __LINE__, _("invalid location type"));
2141 set_value_initialized (retval, ctx->initialized);
2143 do_cleanups (old_chain);
2148 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2149 passes 0 as the byte_offset. */
2152 dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
2153 const gdb_byte *data, unsigned short size,
2154 struct dwarf2_per_cu_data *per_cu)
2156 return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu, 0);
2160 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2162 struct needs_frame_baton
2165 struct dwarf2_per_cu_data *per_cu;
2168 /* Reads from registers do require a frame. */
2170 needs_frame_read_reg (void *baton, int regnum)
2172 struct needs_frame_baton *nf_baton = baton;
2174 nf_baton->needs_frame = 1;
2178 /* Reads from memory do not require a frame. */
2180 needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
2182 memset (buf, 0, len);
2185 /* Frame-relative accesses do require a frame. */
2187 needs_frame_frame_base (void *baton, const gdb_byte **start, size_t * length)
2189 static gdb_byte lit0 = DW_OP_lit0;
2190 struct needs_frame_baton *nf_baton = baton;
2195 nf_baton->needs_frame = 1;
2198 /* CFA accesses require a frame. */
2201 needs_frame_frame_cfa (void *baton)
2203 struct needs_frame_baton *nf_baton = baton;
2205 nf_baton->needs_frame = 1;
2209 /* Thread-local accesses do require a frame. */
2211 needs_frame_tls_address (void *baton, CORE_ADDR offset)
2213 struct needs_frame_baton *nf_baton = baton;
2215 nf_baton->needs_frame = 1;
2219 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2222 needs_frame_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset)
2224 struct needs_frame_baton *nf_baton = ctx->baton;
2226 per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu,
2227 ctx->funcs->get_frame_pc, ctx->baton);
2230 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2233 needs_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
2234 int dwarf_reg, CORE_ADDR fb_offset, int deref_size)
2236 struct needs_frame_baton *nf_baton = ctx->baton;
2238 nf_baton->needs_frame = 1;
2241 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2243 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs =
2245 needs_frame_read_reg,
2246 needs_frame_read_mem,
2247 needs_frame_frame_base,
2248 needs_frame_frame_cfa,
2249 needs_frame_frame_cfa, /* get_frame_pc */
2250 needs_frame_tls_address,
2251 needs_frame_dwarf_call,
2252 NULL, /* get_base_type */
2253 needs_dwarf_reg_entry_value
2256 /* Return non-zero iff the location expression at DATA (length SIZE)
2257 requires a frame to evaluate. */
2260 dwarf2_loc_desc_needs_frame (const gdb_byte *data, unsigned short size,
2261 struct dwarf2_per_cu_data *per_cu)
2263 struct needs_frame_baton baton;
2264 struct dwarf_expr_context *ctx;
2266 struct cleanup *old_chain;
2267 struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
2269 baton.needs_frame = 0;
2270 baton.per_cu = per_cu;
2272 ctx = new_dwarf_expr_context ();
2273 old_chain = make_cleanup_free_dwarf_expr_context (ctx);
2274 make_cleanup_value_free_to_mark (value_mark ());
2276 ctx->gdbarch = get_objfile_arch (objfile);
2277 ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
2278 ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu);
2279 ctx->offset = dwarf2_per_cu_text_offset (per_cu);
2280 ctx->baton = &baton;
2281 ctx->funcs = &needs_frame_ctx_funcs;
2283 dwarf_expr_eval (ctx, data, size);
2285 in_reg = ctx->location == DWARF_VALUE_REGISTER;
2287 if (ctx->num_pieces > 0)
2291 /* If the location has several pieces, and any of them are in
2292 registers, then we will need a frame to fetch them from. */
2293 for (i = 0; i < ctx->num_pieces; i++)
2294 if (ctx->pieces[i].location == DWARF_VALUE_REGISTER)
2298 do_cleanups (old_chain);
2300 return baton.needs_frame || in_reg;
2303 /* A helper function that throws an unimplemented error mentioning a
2304 given DWARF operator. */
2307 unimplemented (unsigned int op)
2309 const char *name = dwarf_stack_op_name (op);
2312 error (_("DWARF operator %s cannot be translated to an agent expression"),
2315 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2316 "to an agent expression"),
2320 /* A helper function to convert a DWARF register to an arch register.
2321 ARCH is the architecture.
2322 DWARF_REG is the register.
2323 This will throw an exception if the DWARF register cannot be
2324 translated to an architecture register. */
2327 translate_register (struct gdbarch *arch, int dwarf_reg)
2329 int reg = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_reg);
2331 error (_("Unable to access DWARF register number %d"), dwarf_reg);
2335 /* A helper function that emits an access to memory. ARCH is the
2336 target architecture. EXPR is the expression which we are building.
2337 NBITS is the number of bits we want to read. This emits the
2338 opcodes needed to read the memory and then extract the desired
2342 access_memory (struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits)
2344 ULONGEST nbytes = (nbits + 7) / 8;
2346 gdb_assert (nbits > 0 && nbits <= sizeof (LONGEST));
2349 ax_trace_quick (expr, nbytes);
2352 ax_simple (expr, aop_ref8);
2353 else if (nbits <= 16)
2354 ax_simple (expr, aop_ref16);
2355 else if (nbits <= 32)
2356 ax_simple (expr, aop_ref32);
2358 ax_simple (expr, aop_ref64);
2360 /* If we read exactly the number of bytes we wanted, we're done. */
2361 if (8 * nbytes == nbits)
2364 if (gdbarch_bits_big_endian (arch))
2366 /* On a bits-big-endian machine, we want the high-order
2368 ax_const_l (expr, 8 * nbytes - nbits);
2369 ax_simple (expr, aop_rsh_unsigned);
2373 /* On a bits-little-endian box, we want the low-order NBITS. */
2374 ax_zero_ext (expr, nbits);
2378 /* A helper function to return the frame's PC. */
2381 get_ax_pc (void *baton)
2383 struct agent_expr *expr = baton;
2388 /* Compile a DWARF location expression to an agent expression.
2390 EXPR is the agent expression we are building.
2391 LOC is the agent value we modify.
2392 ARCH is the architecture.
2393 ADDR_SIZE is the size of addresses, in bytes.
2394 OP_PTR is the start of the location expression.
2395 OP_END is one past the last byte of the location expression.
2397 This will throw an exception for various kinds of errors -- for
2398 example, if the expression cannot be compiled, or if the expression
2402 dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
2403 struct gdbarch *arch, unsigned int addr_size,
2404 const gdb_byte *op_ptr, const gdb_byte *op_end,
2405 struct dwarf2_per_cu_data *per_cu)
2407 struct cleanup *cleanups;
2409 VEC(int) *dw_labels = NULL, *patches = NULL;
2410 const gdb_byte * const base = op_ptr;
2411 const gdb_byte *previous_piece = op_ptr;
2412 enum bfd_endian byte_order = gdbarch_byte_order (arch);
2413 ULONGEST bits_collected = 0;
2414 unsigned int addr_size_bits = 8 * addr_size;
2415 int bits_big_endian = gdbarch_bits_big_endian (arch);
2417 offsets = xmalloc ((op_end - op_ptr) * sizeof (int));
2418 cleanups = make_cleanup (xfree, offsets);
2420 for (i = 0; i < op_end - op_ptr; ++i)
2423 make_cleanup (VEC_cleanup (int), &dw_labels);
2424 make_cleanup (VEC_cleanup (int), &patches);
2426 /* By default we are making an address. */
2427 loc->kind = axs_lvalue_memory;
2429 while (op_ptr < op_end)
2431 enum dwarf_location_atom op = *op_ptr;
2432 ULONGEST uoffset, reg;
2436 offsets[op_ptr - base] = expr->len;
2439 /* Our basic approach to code generation is to map DWARF
2440 operations directly to AX operations. However, there are
2443 First, DWARF works on address-sized units, but AX always uses
2444 LONGEST. For most operations we simply ignore this
2445 difference; instead we generate sign extensions as needed
2446 before division and comparison operations. It would be nice
2447 to omit the sign extensions, but there is no way to determine
2448 the size of the target's LONGEST. (This code uses the size
2449 of the host LONGEST in some cases -- that is a bug but it is
2452 Second, some DWARF operations cannot be translated to AX.
2453 For these we simply fail. See
2454 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2489 ax_const_l (expr, op - DW_OP_lit0);
2493 uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order);
2494 op_ptr += addr_size;
2495 /* Some versions of GCC emit DW_OP_addr before
2496 DW_OP_GNU_push_tls_address. In this case the value is an
2497 index, not an address. We don't support things like
2498 branching between the address and the TLS op. */
2499 if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
2500 uoffset += dwarf2_per_cu_text_offset (per_cu);
2501 ax_const_l (expr, uoffset);
2505 ax_const_l (expr, extract_unsigned_integer (op_ptr, 1, byte_order));
2509 ax_const_l (expr, extract_signed_integer (op_ptr, 1, byte_order));
2513 ax_const_l (expr, extract_unsigned_integer (op_ptr, 2, byte_order));
2517 ax_const_l (expr, extract_signed_integer (op_ptr, 2, byte_order));
2521 ax_const_l (expr, extract_unsigned_integer (op_ptr, 4, byte_order));
2525 ax_const_l (expr, extract_signed_integer (op_ptr, 4, byte_order));
2529 ax_const_l (expr, extract_unsigned_integer (op_ptr, 8, byte_order));
2533 ax_const_l (expr, extract_signed_integer (op_ptr, 8, byte_order));
2537 op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
2538 ax_const_l (expr, uoffset);
2541 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
2542 ax_const_l (expr, offset);
2577 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
2578 loc->u.reg = translate_register (arch, op - DW_OP_reg0);
2579 loc->kind = axs_lvalue_register;
2583 op_ptr = read_uleb128 (op_ptr, op_end, ®);
2584 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
2585 loc->u.reg = translate_register (arch, reg);
2586 loc->kind = axs_lvalue_register;
2589 case DW_OP_implicit_value:
2593 op_ptr = read_uleb128 (op_ptr, op_end, &len);
2594 if (op_ptr + len > op_end)
2595 error (_("DW_OP_implicit_value: too few bytes available."));
2596 if (len > sizeof (ULONGEST))
2597 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
2600 ax_const_l (expr, extract_unsigned_integer (op_ptr, len,
2603 dwarf_expr_require_composition (op_ptr, op_end,
2604 "DW_OP_implicit_value");
2606 loc->kind = axs_rvalue;
2610 case DW_OP_stack_value:
2611 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
2612 loc->kind = axs_rvalue;
2647 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
2648 i = translate_register (arch, op - DW_OP_breg0);
2652 ax_const_l (expr, offset);
2653 ax_simple (expr, aop_add);
2658 op_ptr = read_uleb128 (op_ptr, op_end, ®);
2659 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
2660 i = translate_register (arch, reg);
2664 ax_const_l (expr, offset);
2665 ax_simple (expr, aop_add);
2671 const gdb_byte *datastart;
2673 unsigned int before_stack_len;
2675 struct symbol *framefunc;
2676 LONGEST base_offset = 0;
2678 b = block_for_pc (expr->scope);
2681 error (_("No block found for address"));
2683 framefunc = block_linkage_function (b);
2686 error (_("No function found for block"));
2688 dwarf_expr_frame_base_1 (framefunc, expr->scope,
2689 &datastart, &datalen);
2691 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
2692 dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart,
2693 datastart + datalen, per_cu);
2697 ax_const_l (expr, offset);
2698 ax_simple (expr, aop_add);
2701 loc->kind = axs_lvalue_memory;
2706 ax_simple (expr, aop_dup);
2710 ax_simple (expr, aop_pop);
2715 ax_pick (expr, offset);
2719 ax_simple (expr, aop_swap);
2727 ax_simple (expr, aop_rot);
2731 case DW_OP_deref_size:
2735 if (op == DW_OP_deref_size)
2743 ax_simple (expr, aop_ref8);
2746 ax_simple (expr, aop_ref16);
2749 ax_simple (expr, aop_ref32);
2752 ax_simple (expr, aop_ref64);
2755 /* Note that dwarf_stack_op_name will never return
2757 error (_("Unsupported size %d in %s"),
2758 size, dwarf_stack_op_name (op));
2764 /* Sign extend the operand. */
2765 ax_ext (expr, addr_size_bits);
2766 ax_simple (expr, aop_dup);
2767 ax_const_l (expr, 0);
2768 ax_simple (expr, aop_less_signed);
2769 ax_simple (expr, aop_log_not);
2770 i = ax_goto (expr, aop_if_goto);
2771 /* We have to emit 0 - X. */
2772 ax_const_l (expr, 0);
2773 ax_simple (expr, aop_swap);
2774 ax_simple (expr, aop_sub);
2775 ax_label (expr, i, expr->len);
2779 /* No need to sign extend here. */
2780 ax_const_l (expr, 0);
2781 ax_simple (expr, aop_swap);
2782 ax_simple (expr, aop_sub);
2786 /* Sign extend the operand. */
2787 ax_ext (expr, addr_size_bits);
2788 ax_simple (expr, aop_bit_not);
2791 case DW_OP_plus_uconst:
2792 op_ptr = read_uleb128 (op_ptr, op_end, ®);
2793 /* It would be really weird to emit `DW_OP_plus_uconst 0',
2794 but we micro-optimize anyhow. */
2797 ax_const_l (expr, reg);
2798 ax_simple (expr, aop_add);
2803 ax_simple (expr, aop_bit_and);
2807 /* Sign extend the operands. */
2808 ax_ext (expr, addr_size_bits);
2809 ax_simple (expr, aop_swap);
2810 ax_ext (expr, addr_size_bits);
2811 ax_simple (expr, aop_swap);
2812 ax_simple (expr, aop_div_signed);
2816 ax_simple (expr, aop_sub);
2820 ax_simple (expr, aop_rem_unsigned);
2824 ax_simple (expr, aop_mul);
2828 ax_simple (expr, aop_bit_or);
2832 ax_simple (expr, aop_add);
2836 ax_simple (expr, aop_lsh);
2840 ax_simple (expr, aop_rsh_unsigned);
2844 ax_simple (expr, aop_rsh_signed);
2848 ax_simple (expr, aop_bit_xor);
2852 /* Sign extend the operands. */
2853 ax_ext (expr, addr_size_bits);
2854 ax_simple (expr, aop_swap);
2855 ax_ext (expr, addr_size_bits);
2856 /* Note no swap here: A <= B is !(B < A). */
2857 ax_simple (expr, aop_less_signed);
2858 ax_simple (expr, aop_log_not);
2862 /* Sign extend the operands. */
2863 ax_ext (expr, addr_size_bits);
2864 ax_simple (expr, aop_swap);
2865 ax_ext (expr, addr_size_bits);
2866 ax_simple (expr, aop_swap);
2867 /* A >= B is !(A < B). */
2868 ax_simple (expr, aop_less_signed);
2869 ax_simple (expr, aop_log_not);
2873 /* Sign extend the operands. */
2874 ax_ext (expr, addr_size_bits);
2875 ax_simple (expr, aop_swap);
2876 ax_ext (expr, addr_size_bits);
2877 /* No need for a second swap here. */
2878 ax_simple (expr, aop_equal);
2882 /* Sign extend the operands. */
2883 ax_ext (expr, addr_size_bits);
2884 ax_simple (expr, aop_swap);
2885 ax_ext (expr, addr_size_bits);
2886 ax_simple (expr, aop_swap);
2887 ax_simple (expr, aop_less_signed);
2891 /* Sign extend the operands. */
2892 ax_ext (expr, addr_size_bits);
2893 ax_simple (expr, aop_swap);
2894 ax_ext (expr, addr_size_bits);
2895 /* Note no swap here: A > B is B < A. */
2896 ax_simple (expr, aop_less_signed);
2900 /* Sign extend the operands. */
2901 ax_ext (expr, addr_size_bits);
2902 ax_simple (expr, aop_swap);
2903 ax_ext (expr, addr_size_bits);
2904 /* No need for a swap here. */
2905 ax_simple (expr, aop_equal);
2906 ax_simple (expr, aop_log_not);
2909 case DW_OP_call_frame_cfa:
2910 dwarf2_compile_cfa_to_ax (expr, loc, arch, expr->scope, per_cu);
2911 loc->kind = axs_lvalue_memory;
2914 case DW_OP_GNU_push_tls_address:
2919 offset = extract_signed_integer (op_ptr, 2, byte_order);
2921 i = ax_goto (expr, aop_goto);
2922 VEC_safe_push (int, dw_labels, op_ptr + offset - base);
2923 VEC_safe_push (int, patches, i);
2927 offset = extract_signed_integer (op_ptr, 2, byte_order);
2929 /* Zero extend the operand. */
2930 ax_zero_ext (expr, addr_size_bits);
2931 i = ax_goto (expr, aop_if_goto);
2932 VEC_safe_push (int, dw_labels, op_ptr + offset - base);
2933 VEC_safe_push (int, patches, i);
2940 case DW_OP_bit_piece:
2942 ULONGEST size, offset;
2944 if (op_ptr - 1 == previous_piece)
2945 error (_("Cannot translate empty pieces to agent expressions"));
2946 previous_piece = op_ptr - 1;
2948 op_ptr = read_uleb128 (op_ptr, op_end, &size);
2949 if (op == DW_OP_piece)
2955 op_ptr = read_uleb128 (op_ptr, op_end, &offset);
2957 if (bits_collected + size > 8 * sizeof (LONGEST))
2958 error (_("Expression pieces exceed word size"));
2960 /* Access the bits. */
2963 case axs_lvalue_register:
2964 ax_reg (expr, loc->u.reg);
2967 case axs_lvalue_memory:
2968 /* Offset the pointer, if needed. */
2971 ax_const_l (expr, offset / 8);
2972 ax_simple (expr, aop_add);
2975 access_memory (arch, expr, size);
2979 /* For a bits-big-endian target, shift up what we already
2980 have. For a bits-little-endian target, shift up the
2981 new data. Note that there is a potential bug here if
2982 the DWARF expression leaves multiple values on the
2984 if (bits_collected > 0)
2986 if (bits_big_endian)
2988 ax_simple (expr, aop_swap);
2989 ax_const_l (expr, size);
2990 ax_simple (expr, aop_lsh);
2991 /* We don't need a second swap here, because
2992 aop_bit_or is symmetric. */
2996 ax_const_l (expr, size);
2997 ax_simple (expr, aop_lsh);
2999 ax_simple (expr, aop_bit_or);
3002 bits_collected += size;
3003 loc->kind = axs_rvalue;
3007 case DW_OP_GNU_uninit:
3013 struct dwarf2_locexpr_baton block;
3014 int size = (op == DW_OP_call2 ? 2 : 4);
3016 uoffset = extract_unsigned_integer (op_ptr, size, byte_order);
3019 block = dwarf2_fetch_die_location_block (uoffset, per_cu,
3022 /* DW_OP_call_ref is currently not supported. */
3023 gdb_assert (block.per_cu == per_cu);
3025 dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
3026 block.data, block.data + block.size,
3031 case DW_OP_call_ref:
3039 /* Patch all the branches we emitted. */
3040 for (i = 0; i < VEC_length (int, patches); ++i)
3042 int targ = offsets[VEC_index (int, dw_labels, i)];
3044 internal_error (__FILE__, __LINE__, _("invalid label"));
3045 ax_label (expr, VEC_index (int, patches, i), targ);
3048 do_cleanups (cleanups);
3052 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3053 evaluator to calculate the location. */
3054 static struct value *
3055 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
3057 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3060 val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, dlbaton->data,
3061 dlbaton->size, dlbaton->per_cu);
3066 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3067 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3070 static struct value *
3071 locexpr_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
3073 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3075 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, dlbaton->data,
3079 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3081 locexpr_read_needs_frame (struct symbol *symbol)
3083 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3085 return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
3089 /* Return true if DATA points to the end of a piece. END is one past
3090 the last byte in the expression. */
3093 piece_end_p (const gdb_byte *data, const gdb_byte *end)
3095 return data == end || data[0] == DW_OP_piece || data[0] == DW_OP_bit_piece;
3098 /* Helper for locexpr_describe_location_piece that finds the name of a
3102 locexpr_regname (struct gdbarch *gdbarch, int dwarf_regnum)
3106 regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
3107 return gdbarch_register_name (gdbarch, regnum);
3110 /* Nicely describe a single piece of a location, returning an updated
3111 position in the bytecode sequence. This function cannot recognize
3112 all locations; if a location is not recognized, it simply returns
3115 static const gdb_byte *
3116 locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
3117 CORE_ADDR addr, struct objfile *objfile,
3118 const gdb_byte *data, const gdb_byte *end,
3119 unsigned int addr_size)
3121 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3123 if (data[0] >= DW_OP_reg0 && data[0] <= DW_OP_reg31)
3125 fprintf_filtered (stream, _("a variable in $%s"),
3126 locexpr_regname (gdbarch, data[0] - DW_OP_reg0));
3129 else if (data[0] == DW_OP_regx)
3133 data = read_uleb128 (data + 1, end, ®);
3134 fprintf_filtered (stream, _("a variable in $%s"),
3135 locexpr_regname (gdbarch, reg));
3137 else if (data[0] == DW_OP_fbreg)
3140 struct symbol *framefunc;
3142 LONGEST frame_offset;
3143 const gdb_byte *base_data, *new_data, *save_data = data;
3145 LONGEST base_offset = 0;
3147 new_data = read_sleb128 (data + 1, end, &frame_offset);
3148 if (!piece_end_p (new_data, end))
3152 b = block_for_pc (addr);
3155 error (_("No block found for address for symbol \"%s\"."),
3156 SYMBOL_PRINT_NAME (symbol));
3158 framefunc = block_linkage_function (b);
3161 error (_("No function found for block for symbol \"%s\"."),
3162 SYMBOL_PRINT_NAME (symbol));
3164 dwarf_expr_frame_base_1 (framefunc, addr, &base_data, &base_size);
3166 if (base_data[0] >= DW_OP_breg0 && base_data[0] <= DW_OP_breg31)
3168 const gdb_byte *buf_end;
3170 frame_reg = base_data[0] - DW_OP_breg0;
3171 buf_end = read_sleb128 (base_data + 1,
3172 base_data + base_size, &base_offset);
3173 if (buf_end != base_data + base_size)
3174 error (_("Unexpected opcode after "
3175 "DW_OP_breg%u for symbol \"%s\"."),
3176 frame_reg, SYMBOL_PRINT_NAME (symbol));
3178 else if (base_data[0] >= DW_OP_reg0 && base_data[0] <= DW_OP_reg31)
3180 /* The frame base is just the register, with no offset. */
3181 frame_reg = base_data[0] - DW_OP_reg0;
3186 /* We don't know what to do with the frame base expression,
3187 so we can't trace this variable; give up. */
3191 fprintf_filtered (stream,
3192 _("a variable at frame base reg $%s offset %s+%s"),
3193 locexpr_regname (gdbarch, frame_reg),
3194 plongest (base_offset), plongest (frame_offset));
3196 else if (data[0] >= DW_OP_breg0 && data[0] <= DW_OP_breg31
3197 && piece_end_p (data, end))
3201 data = read_sleb128 (data + 1, end, &offset);
3203 fprintf_filtered (stream,
3204 _("a variable at offset %s from base reg $%s"),
3206 locexpr_regname (gdbarch, data[0] - DW_OP_breg0));
3209 /* The location expression for a TLS variable looks like this (on a
3212 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3213 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3215 0x3 is the encoding for DW_OP_addr, which has an operand as long
3216 as the size of an address on the target machine (here is 8
3217 bytes). Note that more recent version of GCC emit DW_OP_const4u
3218 or DW_OP_const8u, depending on address size, rather than
3219 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3220 The operand represents the offset at which the variable is within
3221 the thread local storage. */
3223 else if (data + 1 + addr_size < end
3224 && (data[0] == DW_OP_addr
3225 || (addr_size == 4 && data[0] == DW_OP_const4u)
3226 || (addr_size == 8 && data[0] == DW_OP_const8u))
3227 && data[1 + addr_size] == DW_OP_GNU_push_tls_address
3228 && piece_end_p (data + 2 + addr_size, end))
3231 offset = extract_unsigned_integer (data + 1, addr_size,
3232 gdbarch_byte_order (gdbarch));
3234 fprintf_filtered (stream,
3235 _("a thread-local variable at offset 0x%s "
3236 "in the thread-local storage for `%s'"),
3237 phex_nz (offset, addr_size), objfile->name);
3239 data += 1 + addr_size + 1;
3241 else if (data[0] >= DW_OP_lit0
3242 && data[0] <= DW_OP_lit31
3244 && data[1] == DW_OP_stack_value)
3246 fprintf_filtered (stream, _("the constant %d"), data[0] - DW_OP_lit0);
3253 /* Disassemble an expression, stopping at the end of a piece or at the
3254 end of the expression. Returns a pointer to the next unread byte
3255 in the input expression. If ALL is nonzero, then this function
3256 will keep going until it reaches the end of the expression. */
3258 static const gdb_byte *
3259 disassemble_dwarf_expression (struct ui_file *stream,
3260 struct gdbarch *arch, unsigned int addr_size,
3262 const gdb_byte *data, const gdb_byte *end,
3264 struct dwarf2_per_cu_data *per_cu)
3266 const gdb_byte *start = data;
3268 fprintf_filtered (stream, _("a complex DWARF expression:\n"));
3272 || (data[0] != DW_OP_piece && data[0] != DW_OP_bit_piece)))
3274 enum dwarf_location_atom op = *data++;
3279 name = dwarf_stack_op_name (op);
3282 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3283 op, (long) (data - 1 - start));
3284 fprintf_filtered (stream, " % 4ld: %s", (long) (data - 1 - start), name);
3289 ul = extract_unsigned_integer (data, addr_size,
3290 gdbarch_byte_order (arch));
3292 fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size));
3296 ul = extract_unsigned_integer (data, 1, gdbarch_byte_order (arch));
3298 fprintf_filtered (stream, " %s", pulongest (ul));
3301 l = extract_signed_integer (data, 1, gdbarch_byte_order (arch));
3303 fprintf_filtered (stream, " %s", plongest (l));
3306 ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
3308 fprintf_filtered (stream, " %s", pulongest (ul));
3311 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3313 fprintf_filtered (stream, " %s", plongest (l));
3316 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
3318 fprintf_filtered (stream, " %s", pulongest (ul));
3321 l = extract_signed_integer (data, 4, gdbarch_byte_order (arch));
3323 fprintf_filtered (stream, " %s", plongest (l));
3326 ul = extract_unsigned_integer (data, 8, gdbarch_byte_order (arch));
3328 fprintf_filtered (stream, " %s", pulongest (ul));
3331 l = extract_signed_integer (data, 8, gdbarch_byte_order (arch));
3333 fprintf_filtered (stream, " %s", plongest (l));
3336 data = read_uleb128 (data, end, &ul);
3337 fprintf_filtered (stream, " %s", pulongest (ul));
3340 data = read_sleb128 (data, end, &l);
3341 fprintf_filtered (stream, " %s", plongest (l));
3376 fprintf_filtered (stream, " [$%s]",
3377 locexpr_regname (arch, op - DW_OP_reg0));
3381 data = read_uleb128 (data, end, &ul);
3382 fprintf_filtered (stream, " %s [$%s]", pulongest (ul),
3383 locexpr_regname (arch, (int) ul));
3386 case DW_OP_implicit_value:
3387 data = read_uleb128 (data, end, &ul);
3389 fprintf_filtered (stream, " %s", pulongest (ul));
3424 data = read_sleb128 (data, end, &l);
3425 fprintf_filtered (stream, " %s [$%s]", plongest (l),
3426 locexpr_regname (arch, op - DW_OP_breg0));
3430 data = read_uleb128 (data, end, &ul);
3431 data = read_sleb128 (data, end, &l);
3432 fprintf_filtered (stream, " register %s [$%s] offset %s",
3434 locexpr_regname (arch, (int) ul),
3439 data = read_sleb128 (data, end, &l);
3440 fprintf_filtered (stream, " %s", plongest (l));
3443 case DW_OP_xderef_size:
3444 case DW_OP_deref_size:
3446 fprintf_filtered (stream, " %d", *data);
3450 case DW_OP_plus_uconst:
3451 data = read_uleb128 (data, end, &ul);
3452 fprintf_filtered (stream, " %s", pulongest (ul));
3456 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3458 fprintf_filtered (stream, " to %ld",
3459 (long) (data + l - start));
3463 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3465 fprintf_filtered (stream, " %ld",
3466 (long) (data + l - start));
3470 ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
3472 fprintf_filtered (stream, " offset %s", phex_nz (ul, 2));
3476 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
3478 fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
3481 case DW_OP_call_ref:
3482 ul = extract_unsigned_integer (data, offset_size,
3483 gdbarch_byte_order (arch));
3484 data += offset_size;
3485 fprintf_filtered (stream, " offset %s", phex_nz (ul, offset_size));
3489 data = read_uleb128 (data, end, &ul);
3490 fprintf_filtered (stream, " %s (bytes)", pulongest (ul));
3493 case DW_OP_bit_piece:
3497 data = read_uleb128 (data, end, &ul);
3498 data = read_uleb128 (data, end, &offset);
3499 fprintf_filtered (stream, " size %s offset %s (bits)",
3500 pulongest (ul), pulongest (offset));
3504 case DW_OP_GNU_implicit_pointer:
3506 ul = extract_unsigned_integer (data, offset_size,
3507 gdbarch_byte_order (arch));
3508 data += offset_size;
3510 data = read_sleb128 (data, end, &l);
3512 fprintf_filtered (stream, " DIE %s offset %s",
3513 phex_nz (ul, offset_size),
3518 case DW_OP_GNU_deref_type:
3520 int addr_size = *data++;
3524 data = read_uleb128 (data, end, &offset);
3525 type = dwarf2_get_die_type (offset, per_cu);
3526 fprintf_filtered (stream, "<");
3527 type_print (type, "", stream, -1);
3528 fprintf_filtered (stream, " [0x%s]> %d", phex_nz (offset, 0),
3533 case DW_OP_GNU_const_type:
3538 data = read_uleb128 (data, end, &type_die);
3539 type = dwarf2_get_die_type (type_die, per_cu);
3540 fprintf_filtered (stream, "<");
3541 type_print (type, "", stream, -1);
3542 fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die, 0));
3546 case DW_OP_GNU_regval_type:
3548 ULONGEST type_die, reg;
3551 data = read_uleb128 (data, end, ®);
3552 data = read_uleb128 (data, end, &type_die);
3554 type = dwarf2_get_die_type (type_die, per_cu);
3555 fprintf_filtered (stream, "<");
3556 type_print (type, "", stream, -1);
3557 fprintf_filtered (stream, " [0x%s]> [$%s]", phex_nz (type_die, 0),
3558 locexpr_regname (arch, reg));
3562 case DW_OP_GNU_convert:
3563 case DW_OP_GNU_reinterpret:
3567 data = read_uleb128 (data, end, &type_die);
3570 fprintf_filtered (stream, "<0>");
3575 type = dwarf2_get_die_type (type_die, per_cu);
3576 fprintf_filtered (stream, "<");
3577 type_print (type, "", stream, -1);
3578 fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die, 0));
3584 fprintf_filtered (stream, "\n");
3590 /* Describe a single location, which may in turn consist of multiple
3594 locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr,
3595 struct ui_file *stream,
3596 const gdb_byte *data, int size,
3597 struct objfile *objfile, unsigned int addr_size,
3598 int offset_size, struct dwarf2_per_cu_data *per_cu)
3600 const gdb_byte *end = data + size;
3601 int first_piece = 1, bad = 0;
3605 const gdb_byte *here = data;
3606 int disassemble = 1;
3611 fprintf_filtered (stream, _(", and "));
3613 if (!dwarf2_always_disassemble)
3615 data = locexpr_describe_location_piece (symbol, stream,
3617 data, end, addr_size);
3618 /* If we printed anything, or if we have an empty piece,
3619 then don't disassemble. */
3621 || data[0] == DW_OP_piece
3622 || data[0] == DW_OP_bit_piece)
3626 data = disassemble_dwarf_expression (stream,
3627 get_objfile_arch (objfile),
3628 addr_size, offset_size, data, end,
3629 dwarf2_always_disassemble,
3634 int empty = data == here;
3637 fprintf_filtered (stream, " ");
3638 if (data[0] == DW_OP_piece)
3642 data = read_uleb128 (data + 1, end, &bytes);
3645 fprintf_filtered (stream, _("an empty %s-byte piece"),
3648 fprintf_filtered (stream, _(" [%s-byte piece]"),
3651 else if (data[0] == DW_OP_bit_piece)
3653 ULONGEST bits, offset;
3655 data = read_uleb128 (data + 1, end, &bits);
3656 data = read_uleb128 (data, end, &offset);
3659 fprintf_filtered (stream,
3660 _("an empty %s-bit piece"),
3663 fprintf_filtered (stream,
3664 _(" [%s-bit piece, offset %s bits]"),
3665 pulongest (bits), pulongest (offset));
3675 if (bad || data > end)
3676 error (_("Corrupted DWARF2 expression for \"%s\"."),
3677 SYMBOL_PRINT_NAME (symbol));
3680 /* Print a natural-language description of SYMBOL to STREAM. This
3681 version is for a symbol with a single location. */
3684 locexpr_describe_location (struct symbol *symbol, CORE_ADDR addr,
3685 struct ui_file *stream)
3687 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3688 struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
3689 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
3690 int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
3692 locexpr_describe_location_1 (symbol, addr, stream,
3693 dlbaton->data, dlbaton->size,
3694 objfile, addr_size, offset_size,
3698 /* Describe the location of SYMBOL as an agent value in VALUE, generating
3699 any necessary bytecode in AX. */
3702 locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
3703 struct agent_expr *ax, struct axs_value *value)
3705 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3706 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
3708 if (dlbaton->data == NULL || dlbaton->size == 0)
3709 value->optimized_out = 1;
3711 dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size,
3712 dlbaton->data, dlbaton->data + dlbaton->size,
3716 /* The set of location functions used with the DWARF-2 expression
3718 const struct symbol_computed_ops dwarf2_locexpr_funcs = {
3719 locexpr_read_variable,
3720 locexpr_read_variable_at_entry,
3721 locexpr_read_needs_frame,
3722 locexpr_describe_location,
3723 locexpr_tracepoint_var_ref
3727 /* Wrapper functions for location lists. These generally find
3728 the appropriate location expression and call something above. */
3730 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3731 evaluator to calculate the location. */
3732 static struct value *
3733 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
3735 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3737 const gdb_byte *data;
3739 CORE_ADDR pc = frame ? get_frame_address_in_block (frame) : 0;
3741 data = dwarf2_find_location_expression (dlbaton, &size, pc);
3743 val = allocate_optimized_out_value (SYMBOL_TYPE (symbol));
3745 val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, data, size,
3751 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
3752 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3755 Function always returns non-NULL value, it may be marked optimized out if
3756 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
3757 if it cannot resolve the parameter for any reason. */
3759 static struct value *
3760 loclist_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
3762 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3763 const gdb_byte *data;
3767 if (frame == NULL || !get_frame_func_if_available (frame, &pc))
3768 return allocate_optimized_out_value (SYMBOL_TYPE (symbol));
3770 data = dwarf2_find_location_expression (dlbaton, &size, pc);
3772 return allocate_optimized_out_value (SYMBOL_TYPE (symbol));
3774 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, data, size);
3777 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3779 loclist_read_needs_frame (struct symbol *symbol)
3781 /* If there's a location list, then assume we need to have a frame
3782 to choose the appropriate location expression. With tracking of
3783 global variables this is not necessarily true, but such tracking
3784 is disabled in GCC at the moment until we figure out how to
3790 /* Print a natural-language description of SYMBOL to STREAM. This
3791 version applies when there is a list of different locations, each
3792 with a specified address range. */
3795 loclist_describe_location (struct symbol *symbol, CORE_ADDR addr,
3796 struct ui_file *stream)
3798 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3799 CORE_ADDR low, high;
3800 const gdb_byte *loc_ptr, *buf_end;
3801 int length, first = 1;
3802 struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
3803 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3804 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3805 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
3806 int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
3807 int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
3808 CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
3809 /* Adjust base_address for relocatable objects. */
3810 CORE_ADDR base_offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
3811 CORE_ADDR base_address = dlbaton->base_address + base_offset;
3813 loc_ptr = dlbaton->data;
3814 buf_end = dlbaton->data + dlbaton->size;
3816 fprintf_filtered (stream, _("multi-location:\n"));
3818 /* Iterate through locations until we run out. */
3821 if (buf_end - loc_ptr < 2 * addr_size)
3822 error (_("Corrupted DWARF expression for symbol \"%s\"."),
3823 SYMBOL_PRINT_NAME (symbol));
3826 low = extract_signed_integer (loc_ptr, addr_size, byte_order);
3828 low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
3829 loc_ptr += addr_size;
3832 high = extract_signed_integer (loc_ptr, addr_size, byte_order);
3834 high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
3835 loc_ptr += addr_size;
3837 /* A base-address-selection entry. */
3838 if ((low & base_mask) == base_mask)
3840 base_address = high + base_offset;
3841 fprintf_filtered (stream, _(" Base address %s"),
3842 paddress (gdbarch, base_address));
3846 /* An end-of-list entry. */
3847 if (low == 0 && high == 0)
3850 /* Otherwise, a location expression entry. */
3851 low += base_address;
3852 high += base_address;
3854 length = extract_unsigned_integer (loc_ptr, 2, byte_order);
3857 /* (It would improve readability to print only the minimum
3858 necessary digits of the second number of the range.) */
3859 fprintf_filtered (stream, _(" Range %s-%s: "),
3860 paddress (gdbarch, low), paddress (gdbarch, high));
3862 /* Now describe this particular location. */
3863 locexpr_describe_location_1 (symbol, low, stream, loc_ptr, length,
3864 objfile, addr_size, offset_size,
3867 fprintf_filtered (stream, "\n");
3873 /* Describe the location of SYMBOL as an agent value in VALUE, generating
3874 any necessary bytecode in AX. */
3876 loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
3877 struct agent_expr *ax, struct axs_value *value)
3879 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3880 const gdb_byte *data;
3882 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
3884 data = dwarf2_find_location_expression (dlbaton, &size, ax->scope);
3885 if (data == NULL || size == 0)
3886 value->optimized_out = 1;
3888 dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size, data, data + size,
3892 /* The set of location functions used with the DWARF-2 expression
3893 evaluator and location lists. */
3894 const struct symbol_computed_ops dwarf2_loclist_funcs = {
3895 loclist_read_variable,
3896 loclist_read_variable_at_entry,
3897 loclist_read_needs_frame,
3898 loclist_describe_location,
3899 loclist_tracepoint_var_ref
3903 _initialize_dwarf2loc (void)
3905 add_setshow_zinteger_cmd ("entry-values", class_maintenance,
3906 &entry_values_debug,
3907 _("Set entry values and tail call frames "
3909 _("Show entry values and tail call frames "
3911 _("When non-zero, the process of determining "
3912 "parameter values from function entry point "
3913 "and tail call frames will be printed."),
3915 show_entry_values_debug,
3916 &setdebuglist, &showdebuglist);