1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003-2014 Free Software Foundation, Inc.
5 Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
33 #include "exceptions.h"
38 #include "dwarf2expr.h"
39 #include "dwarf2loc.h"
40 #include "dwarf2-frame.h"
42 extern int dwarf2_always_disassemble;
44 static void dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
45 const gdb_byte **start, size_t *length);
47 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs;
49 static struct value *dwarf2_evaluate_loc_desc_full (struct type *type,
50 struct frame_info *frame,
53 struct dwarf2_per_cu_data *per_cu,
56 /* Until these have formal names, we define these here.
57 ref: http://gcc.gnu.org/wiki/DebugFission
58 Each entry in .debug_loc.dwo begins with a byte that describes the entry,
59 and is then followed by data specific to that entry. */
63 /* Indicates the end of the list of entries. */
64 DEBUG_LOC_END_OF_LIST = 0,
66 /* This is followed by an unsigned LEB128 number that is an index into
67 .debug_addr and specifies the base address for all following entries. */
68 DEBUG_LOC_BASE_ADDRESS = 1,
70 /* This is followed by two unsigned LEB128 numbers that are indices into
71 .debug_addr and specify the beginning and ending addresses, and then
72 a normal location expression as in .debug_loc. */
73 DEBUG_LOC_START_END = 2,
75 /* This is followed by an unsigned LEB128 number that is an index into
76 .debug_addr and specifies the beginning address, and a 4 byte unsigned
77 number that specifies the length, and then a normal location expression
79 DEBUG_LOC_START_LENGTH = 3,
81 /* An internal value indicating there is insufficient data. */
82 DEBUG_LOC_BUFFER_OVERFLOW = -1,
84 /* An internal value indicating an invalid kind of entry was found. */
85 DEBUG_LOC_INVALID_ENTRY = -2
88 /* Helper function which throws an error if a synthetic pointer is
92 invalid_synthetic_pointer (void)
94 error (_("access outside bounds of object "
95 "referenced via synthetic pointer"));
98 /* Decode the addresses in a non-dwo .debug_loc entry.
99 A pointer to the next byte to examine is returned in *NEW_PTR.
100 The encoded low,high addresses are return in *LOW,*HIGH.
101 The result indicates the kind of entry found. */
103 static enum debug_loc_kind
104 decode_debug_loc_addresses (const gdb_byte *loc_ptr, const gdb_byte *buf_end,
105 const gdb_byte **new_ptr,
106 CORE_ADDR *low, CORE_ADDR *high,
107 enum bfd_endian byte_order,
108 unsigned int addr_size,
111 CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
113 if (buf_end - loc_ptr < 2 * addr_size)
114 return DEBUG_LOC_BUFFER_OVERFLOW;
117 *low = extract_signed_integer (loc_ptr, addr_size, byte_order);
119 *low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
120 loc_ptr += addr_size;
123 *high = extract_signed_integer (loc_ptr, addr_size, byte_order);
125 *high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
126 loc_ptr += addr_size;
130 /* A base-address-selection entry. */
131 if ((*low & base_mask) == base_mask)
132 return DEBUG_LOC_BASE_ADDRESS;
134 /* An end-of-list entry. */
135 if (*low == 0 && *high == 0)
136 return DEBUG_LOC_END_OF_LIST;
138 return DEBUG_LOC_START_END;
141 /* Decode the addresses in .debug_loc.dwo entry.
142 A pointer to the next byte to examine is returned in *NEW_PTR.
143 The encoded low,high addresses are return in *LOW,*HIGH.
144 The result indicates the kind of entry found. */
146 static enum debug_loc_kind
147 decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data *per_cu,
148 const gdb_byte *loc_ptr,
149 const gdb_byte *buf_end,
150 const gdb_byte **new_ptr,
151 CORE_ADDR *low, CORE_ADDR *high,
152 enum bfd_endian byte_order)
154 uint64_t low_index, high_index;
156 if (loc_ptr == buf_end)
157 return DEBUG_LOC_BUFFER_OVERFLOW;
161 case DEBUG_LOC_END_OF_LIST:
163 return DEBUG_LOC_END_OF_LIST;
164 case DEBUG_LOC_BASE_ADDRESS:
166 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
168 return DEBUG_LOC_BUFFER_OVERFLOW;
169 *high = dwarf2_read_addr_index (per_cu, high_index);
171 return DEBUG_LOC_BASE_ADDRESS;
172 case DEBUG_LOC_START_END:
173 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index);
175 return DEBUG_LOC_BUFFER_OVERFLOW;
176 *low = dwarf2_read_addr_index (per_cu, low_index);
177 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
179 return DEBUG_LOC_BUFFER_OVERFLOW;
180 *high = dwarf2_read_addr_index (per_cu, high_index);
182 return DEBUG_LOC_START_END;
183 case DEBUG_LOC_START_LENGTH:
184 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index);
186 return DEBUG_LOC_BUFFER_OVERFLOW;
187 *low = dwarf2_read_addr_index (per_cu, low_index);
188 if (loc_ptr + 4 > buf_end)
189 return DEBUG_LOC_BUFFER_OVERFLOW;
191 *high += extract_unsigned_integer (loc_ptr, 4, byte_order);
192 *new_ptr = loc_ptr + 4;
193 return DEBUG_LOC_START_LENGTH;
195 return DEBUG_LOC_INVALID_ENTRY;
199 /* A function for dealing with location lists. Given a
200 symbol baton (BATON) and a pc value (PC), find the appropriate
201 location expression, set *LOCEXPR_LENGTH, and return a pointer
202 to the beginning of the expression. Returns NULL on failure.
204 For now, only return the first matching location expression; there
205 can be more than one in the list. */
208 dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton,
209 size_t *locexpr_length, CORE_ADDR pc)
211 struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu);
212 struct gdbarch *gdbarch = get_objfile_arch (objfile);
213 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
214 unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu);
215 int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
216 /* Adjust base_address for relocatable objects. */
217 CORE_ADDR base_offset = dwarf2_per_cu_text_offset (baton->per_cu);
218 CORE_ADDR base_address = baton->base_address + base_offset;
219 const gdb_byte *loc_ptr, *buf_end;
221 loc_ptr = baton->data;
222 buf_end = baton->data + baton->size;
226 CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */
228 enum debug_loc_kind kind;
229 const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */
232 kind = decode_debug_loc_dwo_addresses (baton->per_cu,
233 loc_ptr, buf_end, &new_ptr,
234 &low, &high, byte_order);
236 kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
238 byte_order, addr_size,
243 case DEBUG_LOC_END_OF_LIST:
246 case DEBUG_LOC_BASE_ADDRESS:
247 base_address = high + base_offset;
249 case DEBUG_LOC_START_END:
250 case DEBUG_LOC_START_LENGTH:
252 case DEBUG_LOC_BUFFER_OVERFLOW:
253 case DEBUG_LOC_INVALID_ENTRY:
254 error (_("dwarf2_find_location_expression: "
255 "Corrupted DWARF expression."));
257 gdb_assert_not_reached ("bad debug_loc_kind");
260 /* Otherwise, a location expression entry.
261 If the entry is from a DWO, don't add base address: the entry is
262 from .debug_addr which has absolute addresses. */
263 if (! baton->from_dwo)
266 high += base_address;
269 length = extract_unsigned_integer (loc_ptr, 2, byte_order);
272 if (low == high && pc == low)
274 /* This is entry PC record present only at entry point
275 of a function. Verify it is really the function entry point. */
277 const struct block *pc_block = block_for_pc (pc);
278 struct symbol *pc_func = NULL;
281 pc_func = block_linkage_function (pc_block);
283 if (pc_func && pc == BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func)))
285 *locexpr_length = length;
290 if (pc >= low && pc < high)
292 *locexpr_length = length;
300 /* This is the baton used when performing dwarf2 expression
302 struct dwarf_expr_baton
304 struct frame_info *frame;
305 struct dwarf2_per_cu_data *per_cu;
306 CORE_ADDR obj_address;
309 /* Helper functions for dwarf2_evaluate_loc_desc. */
311 /* Using the frame specified in BATON, return the value of register
312 REGNUM, treated as a pointer. */
314 dwarf_expr_read_addr_from_reg (void *baton, int dwarf_regnum)
316 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
317 struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
318 int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
320 return address_from_register (regnum, debaton->frame);
323 /* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback. */
325 static struct value *
326 dwarf_expr_get_reg_value (void *baton, struct type *type, int dwarf_regnum)
328 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
329 struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
330 int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
332 return value_from_register (type, regnum, debaton->frame);
335 /* Read memory at ADDR (length LEN) into BUF. */
338 dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
340 read_memory (addr, buf, len);
343 /* Using the frame specified in BATON, find the location expression
344 describing the frame base. Return a pointer to it in START and
345 its length in LENGTH. */
347 dwarf_expr_frame_base (void *baton, const gdb_byte **start, size_t * length)
349 /* FIXME: cagney/2003-03-26: This code should be using
350 get_frame_base_address(), and then implement a dwarf2 specific
352 struct symbol *framefunc;
353 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
354 const struct block *bl = get_frame_block (debaton->frame, NULL);
357 error (_("frame address is not available."));
359 /* Use block_linkage_function, which returns a real (not inlined)
360 function, instead of get_frame_function, which may return an
362 framefunc = block_linkage_function (bl);
364 /* If we found a frame-relative symbol then it was certainly within
365 some function associated with a frame. If we can't find the frame,
366 something has gone wrong. */
367 gdb_assert (framefunc != NULL);
369 dwarf_expr_frame_base_1 (framefunc,
370 get_frame_address_in_block (debaton->frame),
374 /* Implement find_frame_base_location method for LOC_BLOCK functions using
375 DWARF expression for its DW_AT_frame_base. */
378 locexpr_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc,
379 const gdb_byte **start, size_t *length)
381 struct dwarf2_locexpr_baton *symbaton = SYMBOL_LOCATION_BATON (framefunc);
383 *length = symbaton->size;
384 *start = symbaton->data;
387 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
388 function uses DWARF expression for its DW_AT_frame_base. */
390 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs =
392 locexpr_find_frame_base_location
395 /* Implement find_frame_base_location method for LOC_BLOCK functions using
396 DWARF location list for its DW_AT_frame_base. */
399 loclist_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc,
400 const gdb_byte **start, size_t *length)
402 struct dwarf2_loclist_baton *symbaton = SYMBOL_LOCATION_BATON (framefunc);
404 *start = dwarf2_find_location_expression (symbaton, length, pc);
407 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
408 function uses DWARF location list for its DW_AT_frame_base. */
410 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs =
412 loclist_find_frame_base_location
416 dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
417 const gdb_byte **start, size_t *length)
419 if (SYMBOL_BLOCK_OPS (framefunc) != NULL)
421 const struct symbol_block_ops *ops_block = SYMBOL_BLOCK_OPS (framefunc);
423 ops_block->find_frame_base_location (framefunc, pc, start, length);
429 error (_("Could not find the frame base for \"%s\"."),
430 SYMBOL_NATURAL_NAME (framefunc));
433 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
434 the frame in BATON. */
437 dwarf_expr_frame_cfa (void *baton)
439 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
441 return dwarf2_frame_cfa (debaton->frame);
444 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
445 the frame in BATON. */
448 dwarf_expr_frame_pc (void *baton)
450 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
452 return get_frame_address_in_block (debaton->frame);
455 /* Using the objfile specified in BATON, find the address for the
456 current thread's thread-local storage with offset OFFSET. */
458 dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
460 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
461 struct objfile *objfile = dwarf2_per_cu_objfile (debaton->per_cu);
463 return target_translate_tls_address (objfile, offset);
466 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
467 current CU (as is PER_CU). State of the CTX is not affected by the
471 per_cu_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset,
472 struct dwarf2_per_cu_data *per_cu,
473 CORE_ADDR (*get_frame_pc) (void *baton),
476 struct dwarf2_locexpr_baton block;
478 block = dwarf2_fetch_die_loc_cu_off (die_offset, per_cu, get_frame_pc, baton);
480 /* DW_OP_call_ref is currently not supported. */
481 gdb_assert (block.per_cu == per_cu);
483 dwarf_expr_eval (ctx, block.data, block.size);
486 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
489 dwarf_expr_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
491 struct dwarf_expr_baton *debaton = ctx->baton;
493 per_cu_dwarf_call (ctx, die_offset, debaton->per_cu,
494 ctx->funcs->get_frame_pc, ctx->baton);
497 /* Callback function for dwarf2_evaluate_loc_desc. */
500 dwarf_expr_get_base_type (struct dwarf_expr_context *ctx,
501 cu_offset die_offset)
503 struct dwarf_expr_baton *debaton = ctx->baton;
505 return dwarf2_get_die_type (die_offset, debaton->per_cu);
508 /* See dwarf2loc.h. */
510 unsigned int entry_values_debug = 0;
512 /* Helper to set entry_values_debug. */
515 show_entry_values_debug (struct ui_file *file, int from_tty,
516 struct cmd_list_element *c, const char *value)
518 fprintf_filtered (file,
519 _("Entry values and tail call frames debugging is %s.\n"),
523 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
524 CALLER_FRAME (for registers) can be NULL if it is not known. This function
525 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
528 call_site_to_target_addr (struct gdbarch *call_site_gdbarch,
529 struct call_site *call_site,
530 struct frame_info *caller_frame)
532 switch (FIELD_LOC_KIND (call_site->target))
534 case FIELD_LOC_KIND_DWARF_BLOCK:
536 struct dwarf2_locexpr_baton *dwarf_block;
538 struct type *caller_core_addr_type;
539 struct gdbarch *caller_arch;
541 dwarf_block = FIELD_DWARF_BLOCK (call_site->target);
542 if (dwarf_block == NULL)
544 struct bound_minimal_symbol msym;
546 msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
547 throw_error (NO_ENTRY_VALUE_ERROR,
548 _("DW_AT_GNU_call_site_target is not specified "
550 paddress (call_site_gdbarch, call_site->pc),
551 (msym.minsym == NULL ? "???"
552 : MSYMBOL_PRINT_NAME (msym.minsym)));
555 if (caller_frame == NULL)
557 struct bound_minimal_symbol msym;
559 msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
560 throw_error (NO_ENTRY_VALUE_ERROR,
561 _("DW_AT_GNU_call_site_target DWARF block resolving "
562 "requires known frame which is currently not "
563 "available at %s in %s"),
564 paddress (call_site_gdbarch, call_site->pc),
565 (msym.minsym == NULL ? "???"
566 : MSYMBOL_PRINT_NAME (msym.minsym)));
569 caller_arch = get_frame_arch (caller_frame);
570 caller_core_addr_type = builtin_type (caller_arch)->builtin_func_ptr;
571 val = dwarf2_evaluate_loc_desc (caller_core_addr_type, caller_frame,
572 dwarf_block->data, dwarf_block->size,
573 dwarf_block->per_cu);
574 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
576 if (VALUE_LVAL (val) == lval_memory)
577 return value_address (val);
579 return value_as_address (val);
582 case FIELD_LOC_KIND_PHYSNAME:
584 const char *physname;
585 struct bound_minimal_symbol msym;
587 physname = FIELD_STATIC_PHYSNAME (call_site->target);
589 /* Handle both the mangled and demangled PHYSNAME. */
590 msym = lookup_minimal_symbol (physname, NULL, NULL);
591 if (msym.minsym == NULL)
593 msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
594 throw_error (NO_ENTRY_VALUE_ERROR,
595 _("Cannot find function \"%s\" for a call site target "
597 physname, paddress (call_site_gdbarch, call_site->pc),
598 (msym.minsym == NULL ? "???"
599 : MSYMBOL_PRINT_NAME (msym.minsym)));
602 return BMSYMBOL_VALUE_ADDRESS (msym);
605 case FIELD_LOC_KIND_PHYSADDR:
606 return FIELD_STATIC_PHYSADDR (call_site->target);
609 internal_error (__FILE__, __LINE__, _("invalid call site target kind"));
613 /* Convert function entry point exact address ADDR to the function which is
614 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
615 NO_ENTRY_VALUE_ERROR otherwise. */
617 static struct symbol *
618 func_addr_to_tail_call_list (struct gdbarch *gdbarch, CORE_ADDR addr)
620 struct symbol *sym = find_pc_function (addr);
623 if (sym == NULL || BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) != addr)
624 throw_error (NO_ENTRY_VALUE_ERROR,
625 _("DW_TAG_GNU_call_site resolving failed to find function "
626 "name for address %s"),
627 paddress (gdbarch, addr));
629 type = SYMBOL_TYPE (sym);
630 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FUNC);
631 gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_FUNC);
636 /* Verify function with entry point exact address ADDR can never call itself
637 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
638 can call itself via tail calls.
640 If a funtion can tail call itself its entry value based parameters are
641 unreliable. There is no verification whether the value of some/all
642 parameters is unchanged through the self tail call, we expect if there is
643 a self tail call all the parameters can be modified. */
646 func_verify_no_selftailcall (struct gdbarch *gdbarch, CORE_ADDR verify_addr)
648 struct obstack addr_obstack;
649 struct cleanup *old_chain;
652 /* Track here CORE_ADDRs which were already visited. */
655 /* The verification is completely unordered. Track here function addresses
656 which still need to be iterated. */
657 VEC (CORE_ADDR) *todo = NULL;
659 obstack_init (&addr_obstack);
660 old_chain = make_cleanup_obstack_free (&addr_obstack);
661 addr_hash = htab_create_alloc_ex (64, core_addr_hash, core_addr_eq, NULL,
662 &addr_obstack, hashtab_obstack_allocate,
664 make_cleanup_htab_delete (addr_hash);
666 make_cleanup (VEC_cleanup (CORE_ADDR), &todo);
668 VEC_safe_push (CORE_ADDR, todo, verify_addr);
669 while (!VEC_empty (CORE_ADDR, todo))
671 struct symbol *func_sym;
672 struct call_site *call_site;
674 addr = VEC_pop (CORE_ADDR, todo);
676 func_sym = func_addr_to_tail_call_list (gdbarch, addr);
678 for (call_site = TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym));
679 call_site; call_site = call_site->tail_call_next)
681 CORE_ADDR target_addr;
684 /* CALLER_FRAME with registers is not available for tail-call jumped
686 target_addr = call_site_to_target_addr (gdbarch, call_site, NULL);
688 if (target_addr == verify_addr)
690 struct bound_minimal_symbol msym;
692 msym = lookup_minimal_symbol_by_pc (verify_addr);
693 throw_error (NO_ENTRY_VALUE_ERROR,
694 _("DW_OP_GNU_entry_value resolving has found "
695 "function \"%s\" at %s can call itself via tail "
697 (msym.minsym == NULL ? "???"
698 : MSYMBOL_PRINT_NAME (msym.minsym)),
699 paddress (gdbarch, verify_addr));
702 slot = htab_find_slot (addr_hash, &target_addr, INSERT);
705 *slot = obstack_copy (&addr_obstack, &target_addr,
706 sizeof (target_addr));
707 VEC_safe_push (CORE_ADDR, todo, target_addr);
712 do_cleanups (old_chain);
715 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
716 ENTRY_VALUES_DEBUG. */
719 tailcall_dump (struct gdbarch *gdbarch, const struct call_site *call_site)
721 CORE_ADDR addr = call_site->pc;
722 struct bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (addr - 1);
724 fprintf_unfiltered (gdb_stdlog, " %s(%s)", paddress (gdbarch, addr),
725 (msym.minsym == NULL ? "???"
726 : MSYMBOL_PRINT_NAME (msym.minsym)));
730 /* vec.h needs single word type name, typedef it. */
731 typedef struct call_site *call_sitep;
733 /* Define VEC (call_sitep) functions. */
734 DEF_VEC_P (call_sitep);
736 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
737 only top callers and bottom callees which are present in both. GDBARCH is
738 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
739 no remaining possibilities to provide unambiguous non-trivial result.
740 RESULTP should point to NULL on the first (initialization) call. Caller is
741 responsible for xfree of any RESULTP data. */
744 chain_candidate (struct gdbarch *gdbarch, struct call_site_chain **resultp,
745 VEC (call_sitep) *chain)
747 struct call_site_chain *result = *resultp;
748 long length = VEC_length (call_sitep, chain);
749 int callers, callees, idx;
753 /* Create the initial chain containing all the passed PCs. */
755 result = xmalloc (sizeof (*result) + sizeof (*result->call_site)
757 result->length = length;
758 result->callers = result->callees = length;
759 if (!VEC_empty (call_sitep, chain))
760 memcpy (result->call_site, VEC_address (call_sitep, chain),
761 sizeof (*result->call_site) * length);
764 if (entry_values_debug)
766 fprintf_unfiltered (gdb_stdlog, "tailcall: initial:");
767 for (idx = 0; idx < length; idx++)
768 tailcall_dump (gdbarch, result->call_site[idx]);
769 fputc_unfiltered ('\n', gdb_stdlog);
775 if (entry_values_debug)
777 fprintf_unfiltered (gdb_stdlog, "tailcall: compare:");
778 for (idx = 0; idx < length; idx++)
779 tailcall_dump (gdbarch, VEC_index (call_sitep, chain, idx));
780 fputc_unfiltered ('\n', gdb_stdlog);
783 /* Intersect callers. */
785 callers = min (result->callers, length);
786 for (idx = 0; idx < callers; idx++)
787 if (result->call_site[idx] != VEC_index (call_sitep, chain, idx))
789 result->callers = idx;
793 /* Intersect callees. */
795 callees = min (result->callees, length);
796 for (idx = 0; idx < callees; idx++)
797 if (result->call_site[result->length - 1 - idx]
798 != VEC_index (call_sitep, chain, length - 1 - idx))
800 result->callees = idx;
804 if (entry_values_debug)
806 fprintf_unfiltered (gdb_stdlog, "tailcall: reduced:");
807 for (idx = 0; idx < result->callers; idx++)
808 tailcall_dump (gdbarch, result->call_site[idx]);
809 fputs_unfiltered (" |", gdb_stdlog);
810 for (idx = 0; idx < result->callees; idx++)
811 tailcall_dump (gdbarch, result->call_site[result->length
812 - result->callees + idx]);
813 fputc_unfiltered ('\n', gdb_stdlog);
816 if (result->callers == 0 && result->callees == 0)
818 /* There are no common callers or callees. It could be also a direct
819 call (which has length 0) with ambiguous possibility of an indirect
820 call - CALLERS == CALLEES == 0 is valid during the first allocation
821 but any subsequence processing of such entry means ambiguity. */
827 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
828 PC again. In such case there must be two different code paths to reach
829 it, therefore some of the former determined intermediate PCs must differ
830 and the unambiguous chain gets shortened. */
831 gdb_assert (result->callers + result->callees < result->length);
834 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
835 assumed frames between them use GDBARCH. Use depth first search so we can
836 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
837 would have needless GDB stack overhead. Caller is responsible for xfree of
838 the returned result. Any unreliability results in thrown
839 NO_ENTRY_VALUE_ERROR. */
841 static struct call_site_chain *
842 call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
845 CORE_ADDR save_callee_pc = callee_pc;
846 struct obstack addr_obstack;
847 struct cleanup *back_to_retval, *back_to_workdata;
848 struct call_site_chain *retval = NULL;
849 struct call_site *call_site;
851 /* Mark CALL_SITEs so we do not visit the same ones twice. */
854 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
855 call_site nor any possible call_site at CALLEE_PC's function is there.
856 Any CALL_SITE in CHAIN will be iterated to its siblings - via
857 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
858 VEC (call_sitep) *chain = NULL;
860 /* We are not interested in the specific PC inside the callee function. */
861 callee_pc = get_pc_function_start (callee_pc);
863 throw_error (NO_ENTRY_VALUE_ERROR, _("Unable to find function for PC %s"),
864 paddress (gdbarch, save_callee_pc));
866 back_to_retval = make_cleanup (free_current_contents, &retval);
868 obstack_init (&addr_obstack);
869 back_to_workdata = make_cleanup_obstack_free (&addr_obstack);
870 addr_hash = htab_create_alloc_ex (64, core_addr_hash, core_addr_eq, NULL,
871 &addr_obstack, hashtab_obstack_allocate,
873 make_cleanup_htab_delete (addr_hash);
875 make_cleanup (VEC_cleanup (call_sitep), &chain);
877 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
878 at the target's function. All the possible tail call sites in the
879 target's function will get iterated as already pushed into CHAIN via their
881 call_site = call_site_for_pc (gdbarch, caller_pc);
885 CORE_ADDR target_func_addr;
886 struct call_site *target_call_site;
888 /* CALLER_FRAME with registers is not available for tail-call jumped
890 target_func_addr = call_site_to_target_addr (gdbarch, call_site, NULL);
892 if (target_func_addr == callee_pc)
894 chain_candidate (gdbarch, &retval, chain);
898 /* There is no way to reach CALLEE_PC again as we would prevent
899 entering it twice as being already marked in ADDR_HASH. */
900 target_call_site = NULL;
904 struct symbol *target_func;
906 target_func = func_addr_to_tail_call_list (gdbarch, target_func_addr);
907 target_call_site = TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func));
912 /* Attempt to visit TARGET_CALL_SITE. */
914 if (target_call_site)
918 slot = htab_find_slot (addr_hash, &target_call_site->pc, INSERT);
921 /* Successfully entered TARGET_CALL_SITE. */
923 *slot = &target_call_site->pc;
924 VEC_safe_push (call_sitep, chain, target_call_site);
929 /* Backtrack (without revisiting the originating call_site). Try the
930 callers's sibling; if there isn't any try the callers's callers's
933 target_call_site = NULL;
934 while (!VEC_empty (call_sitep, chain))
936 call_site = VEC_pop (call_sitep, chain);
938 gdb_assert (htab_find_slot (addr_hash, &call_site->pc,
940 htab_remove_elt (addr_hash, &call_site->pc);
942 target_call_site = call_site->tail_call_next;
943 if (target_call_site)
947 while (target_call_site);
949 if (VEC_empty (call_sitep, chain))
952 call_site = VEC_last (call_sitep, chain);
957 struct bound_minimal_symbol msym_caller, msym_callee;
959 msym_caller = lookup_minimal_symbol_by_pc (caller_pc);
960 msym_callee = lookup_minimal_symbol_by_pc (callee_pc);
961 throw_error (NO_ENTRY_VALUE_ERROR,
962 _("There are no unambiguously determinable intermediate "
963 "callers or callees between caller function \"%s\" at %s "
964 "and callee function \"%s\" at %s"),
965 (msym_caller.minsym == NULL
966 ? "???" : MSYMBOL_PRINT_NAME (msym_caller.minsym)),
967 paddress (gdbarch, caller_pc),
968 (msym_callee.minsym == NULL
969 ? "???" : MSYMBOL_PRINT_NAME (msym_callee.minsym)),
970 paddress (gdbarch, callee_pc));
973 do_cleanups (back_to_workdata);
974 discard_cleanups (back_to_retval);
978 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
979 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
980 constructed return NULL. Caller is responsible for xfree of the returned
983 struct call_site_chain *
984 call_site_find_chain (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
987 volatile struct gdb_exception e;
988 struct call_site_chain *retval = NULL;
990 TRY_CATCH (e, RETURN_MASK_ERROR)
992 retval = call_site_find_chain_1 (gdbarch, caller_pc, callee_pc);
996 if (e.error == NO_ENTRY_VALUE_ERROR)
998 if (entry_values_debug)
999 exception_print (gdb_stdout, e);
1004 throw_exception (e);
1009 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1012 call_site_parameter_matches (struct call_site_parameter *parameter,
1013 enum call_site_parameter_kind kind,
1014 union call_site_parameter_u kind_u)
1016 if (kind == parameter->kind)
1019 case CALL_SITE_PARAMETER_DWARF_REG:
1020 return kind_u.dwarf_reg == parameter->u.dwarf_reg;
1021 case CALL_SITE_PARAMETER_FB_OFFSET:
1022 return kind_u.fb_offset == parameter->u.fb_offset;
1023 case CALL_SITE_PARAMETER_PARAM_OFFSET:
1024 return kind_u.param_offset.cu_off == parameter->u.param_offset.cu_off;
1029 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1030 FRAME is for callee.
1032 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1035 static struct call_site_parameter *
1036 dwarf_expr_reg_to_entry_parameter (struct frame_info *frame,
1037 enum call_site_parameter_kind kind,
1038 union call_site_parameter_u kind_u,
1039 struct dwarf2_per_cu_data **per_cu_return)
1041 CORE_ADDR func_addr, caller_pc;
1042 struct gdbarch *gdbarch;
1043 struct frame_info *caller_frame;
1044 struct call_site *call_site;
1046 /* Initialize it just to avoid a GCC false warning. */
1047 struct call_site_parameter *parameter = NULL;
1048 CORE_ADDR target_addr;
1050 while (get_frame_type (frame) == INLINE_FRAME)
1052 frame = get_prev_frame (frame);
1053 gdb_assert (frame != NULL);
1056 func_addr = get_frame_func (frame);
1057 gdbarch = get_frame_arch (frame);
1058 caller_frame = get_prev_frame (frame);
1059 if (gdbarch != frame_unwind_arch (frame))
1061 struct bound_minimal_symbol msym
1062 = lookup_minimal_symbol_by_pc (func_addr);
1063 struct gdbarch *caller_gdbarch = frame_unwind_arch (frame);
1065 throw_error (NO_ENTRY_VALUE_ERROR,
1066 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1067 "(of %s (%s)) does not match caller gdbarch %s"),
1068 gdbarch_bfd_arch_info (gdbarch)->printable_name,
1069 paddress (gdbarch, func_addr),
1070 (msym.minsym == NULL ? "???"
1071 : MSYMBOL_PRINT_NAME (msym.minsym)),
1072 gdbarch_bfd_arch_info (caller_gdbarch)->printable_name);
1075 if (caller_frame == NULL)
1077 struct bound_minimal_symbol msym
1078 = lookup_minimal_symbol_by_pc (func_addr);
1080 throw_error (NO_ENTRY_VALUE_ERROR, _("DW_OP_GNU_entry_value resolving "
1081 "requires caller of %s (%s)"),
1082 paddress (gdbarch, func_addr),
1083 (msym.minsym == NULL ? "???"
1084 : MSYMBOL_PRINT_NAME (msym.minsym)));
1086 caller_pc = get_frame_pc (caller_frame);
1087 call_site = call_site_for_pc (gdbarch, caller_pc);
1089 target_addr = call_site_to_target_addr (gdbarch, call_site, caller_frame);
1090 if (target_addr != func_addr)
1092 struct minimal_symbol *target_msym, *func_msym;
1094 target_msym = lookup_minimal_symbol_by_pc (target_addr).minsym;
1095 func_msym = lookup_minimal_symbol_by_pc (func_addr).minsym;
1096 throw_error (NO_ENTRY_VALUE_ERROR,
1097 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1098 "but the called frame is for %s at %s"),
1099 (target_msym == NULL ? "???"
1100 : MSYMBOL_PRINT_NAME (target_msym)),
1101 paddress (gdbarch, target_addr),
1102 func_msym == NULL ? "???" : MSYMBOL_PRINT_NAME (func_msym),
1103 paddress (gdbarch, func_addr));
1106 /* No entry value based parameters would be reliable if this function can
1107 call itself via tail calls. */
1108 func_verify_no_selftailcall (gdbarch, func_addr);
1110 for (iparams = 0; iparams < call_site->parameter_count; iparams++)
1112 parameter = &call_site->parameter[iparams];
1113 if (call_site_parameter_matches (parameter, kind, kind_u))
1116 if (iparams == call_site->parameter_count)
1118 struct minimal_symbol *msym
1119 = lookup_minimal_symbol_by_pc (caller_pc).minsym;
1121 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1122 determine its value. */
1123 throw_error (NO_ENTRY_VALUE_ERROR, _("Cannot find matching parameter "
1124 "at DW_TAG_GNU_call_site %s at %s"),
1125 paddress (gdbarch, caller_pc),
1126 msym == NULL ? "???" : MSYMBOL_PRINT_NAME (msym));
1129 *per_cu_return = call_site->per_cu;
1133 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1134 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1135 DW_AT_GNU_call_site_data_value (dereferenced) block.
1137 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1140 Function always returns non-NULL, non-optimized out value. It throws
1141 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1143 static struct value *
1144 dwarf_entry_parameter_to_value (struct call_site_parameter *parameter,
1145 CORE_ADDR deref_size, struct type *type,
1146 struct frame_info *caller_frame,
1147 struct dwarf2_per_cu_data *per_cu)
1149 const gdb_byte *data_src;
1153 data_src = deref_size == -1 ? parameter->value : parameter->data_value;
1154 size = deref_size == -1 ? parameter->value_size : parameter->data_value_size;
1156 /* DEREF_SIZE size is not verified here. */
1157 if (data_src == NULL)
1158 throw_error (NO_ENTRY_VALUE_ERROR,
1159 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1161 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1162 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1164 data = alloca (size + 1);
1165 memcpy (data, data_src, size);
1166 data[size] = DW_OP_stack_value;
1168 return dwarf2_evaluate_loc_desc (type, caller_frame, data, size + 1, per_cu);
1171 /* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
1172 Choose DEREF_SIZE value of that parameter. Search caller of the CTX's
1173 frame. CTX must be of dwarf_expr_ctx_funcs kind.
1175 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1176 can be more simple as it does not support cross-CU DWARF executions. */
1179 dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
1180 enum call_site_parameter_kind kind,
1181 union call_site_parameter_u kind_u,
1184 struct dwarf_expr_baton *debaton;
1185 struct frame_info *frame, *caller_frame;
1186 struct dwarf2_per_cu_data *caller_per_cu;
1187 struct dwarf_expr_baton baton_local;
1188 struct dwarf_expr_context saved_ctx;
1189 struct call_site_parameter *parameter;
1190 const gdb_byte *data_src;
1193 gdb_assert (ctx->funcs == &dwarf_expr_ctx_funcs);
1194 debaton = ctx->baton;
1195 frame = debaton->frame;
1196 caller_frame = get_prev_frame (frame);
1198 parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u,
1200 data_src = deref_size == -1 ? parameter->value : parameter->data_value;
1201 size = deref_size == -1 ? parameter->value_size : parameter->data_value_size;
1203 /* DEREF_SIZE size is not verified here. */
1204 if (data_src == NULL)
1205 throw_error (NO_ENTRY_VALUE_ERROR,
1206 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1208 baton_local.frame = caller_frame;
1209 baton_local.per_cu = caller_per_cu;
1210 baton_local.obj_address = 0;
1212 saved_ctx.gdbarch = ctx->gdbarch;
1213 saved_ctx.addr_size = ctx->addr_size;
1214 saved_ctx.offset = ctx->offset;
1215 saved_ctx.baton = ctx->baton;
1216 ctx->gdbarch = get_objfile_arch (dwarf2_per_cu_objfile (baton_local.per_cu));
1217 ctx->addr_size = dwarf2_per_cu_addr_size (baton_local.per_cu);
1218 ctx->offset = dwarf2_per_cu_text_offset (baton_local.per_cu);
1219 ctx->baton = &baton_local;
1221 dwarf_expr_eval (ctx, data_src, size);
1223 ctx->gdbarch = saved_ctx.gdbarch;
1224 ctx->addr_size = saved_ctx.addr_size;
1225 ctx->offset = saved_ctx.offset;
1226 ctx->baton = saved_ctx.baton;
1229 /* Callback function for dwarf2_evaluate_loc_desc.
1230 Fetch the address indexed by DW_OP_GNU_addr_index. */
1233 dwarf_expr_get_addr_index (void *baton, unsigned int index)
1235 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
1237 return dwarf2_read_addr_index (debaton->per_cu, index);
1240 /* Callback function for get_object_address. Return the address of the VLA
1244 dwarf_expr_get_obj_addr (void *baton)
1246 struct dwarf_expr_baton *debaton = baton;
1248 gdb_assert (debaton != NULL);
1250 if (debaton->obj_address == 0)
1251 error (_("Location address is not set."));
1253 return debaton->obj_address;
1256 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1257 the indirect method on it, that is use its stored target value, the sole
1258 purpose of entry_data_value_funcs.. */
1260 static struct value *
1261 entry_data_value_coerce_ref (const struct value *value)
1263 struct type *checked_type = check_typedef (value_type (value));
1264 struct value *target_val;
1266 if (TYPE_CODE (checked_type) != TYPE_CODE_REF)
1269 target_val = value_computed_closure (value);
1270 value_incref (target_val);
1274 /* Implement copy_closure. */
1277 entry_data_value_copy_closure (const struct value *v)
1279 struct value *target_val = value_computed_closure (v);
1281 value_incref (target_val);
1285 /* Implement free_closure. */
1288 entry_data_value_free_closure (struct value *v)
1290 struct value *target_val = value_computed_closure (v);
1292 value_free (target_val);
1295 /* Vector for methods for an entry value reference where the referenced value
1296 is stored in the caller. On the first dereference use
1297 DW_AT_GNU_call_site_data_value in the caller. */
1299 static const struct lval_funcs entry_data_value_funcs =
1303 NULL, /* check_validity */
1304 NULL, /* check_any_valid */
1305 NULL, /* indirect */
1306 entry_data_value_coerce_ref,
1307 NULL, /* check_synthetic_pointer */
1308 entry_data_value_copy_closure,
1309 entry_data_value_free_closure
1312 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1313 are used to match DW_AT_location at the caller's
1314 DW_TAG_GNU_call_site_parameter.
1316 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1317 cannot resolve the parameter for any reason. */
1319 static struct value *
1320 value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame,
1321 enum call_site_parameter_kind kind,
1322 union call_site_parameter_u kind_u)
1324 struct type *checked_type = check_typedef (type);
1325 struct type *target_type = TYPE_TARGET_TYPE (checked_type);
1326 struct frame_info *caller_frame = get_prev_frame (frame);
1327 struct value *outer_val, *target_val, *val;
1328 struct call_site_parameter *parameter;
1329 struct dwarf2_per_cu_data *caller_per_cu;
1331 parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u,
1334 outer_val = dwarf_entry_parameter_to_value (parameter, -1 /* deref_size */,
1338 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1339 used and it is not available do not fall back to OUTER_VAL - dereferencing
1340 TYPE_CODE_REF with non-entry data value would give current value - not the
1343 if (TYPE_CODE (checked_type) != TYPE_CODE_REF
1344 || TYPE_TARGET_TYPE (checked_type) == NULL)
1347 target_val = dwarf_entry_parameter_to_value (parameter,
1348 TYPE_LENGTH (target_type),
1349 target_type, caller_frame,
1352 release_value (target_val);
1353 val = allocate_computed_value (type, &entry_data_value_funcs,
1354 target_val /* closure */);
1356 /* Copy the referencing pointer to the new computed value. */
1357 memcpy (value_contents_raw (val), value_contents_raw (outer_val),
1358 TYPE_LENGTH (checked_type));
1359 set_value_lazy (val, 0);
1364 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1365 SIZE are DWARF block used to match DW_AT_location at the caller's
1366 DW_TAG_GNU_call_site_parameter.
1368 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1369 cannot resolve the parameter for any reason. */
1371 static struct value *
1372 value_of_dwarf_block_entry (struct type *type, struct frame_info *frame,
1373 const gdb_byte *block, size_t block_len)
1375 union call_site_parameter_u kind_u;
1377 kind_u.dwarf_reg = dwarf_block_to_dwarf_reg (block, block + block_len);
1378 if (kind_u.dwarf_reg != -1)
1379 return value_of_dwarf_reg_entry (type, frame, CALL_SITE_PARAMETER_DWARF_REG,
1382 if (dwarf_block_to_fb_offset (block, block + block_len, &kind_u.fb_offset))
1383 return value_of_dwarf_reg_entry (type, frame, CALL_SITE_PARAMETER_FB_OFFSET,
1386 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1387 suppressed during normal operation. The expression can be arbitrary if
1388 there is no caller-callee entry value binding expected. */
1389 throw_error (NO_ENTRY_VALUE_ERROR,
1390 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1391 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1394 struct piece_closure
1396 /* Reference count. */
1399 /* The CU from which this closure's expression came. */
1400 struct dwarf2_per_cu_data *per_cu;
1402 /* The number of pieces used to describe this variable. */
1405 /* The target address size, used only for DWARF_VALUE_STACK. */
1408 /* The pieces themselves. */
1409 struct dwarf_expr_piece *pieces;
1412 /* Allocate a closure for a value formed from separately-described
1415 static struct piece_closure *
1416 allocate_piece_closure (struct dwarf2_per_cu_data *per_cu,
1417 int n_pieces, struct dwarf_expr_piece *pieces,
1420 struct piece_closure *c = XCNEW (struct piece_closure);
1425 c->n_pieces = n_pieces;
1426 c->addr_size = addr_size;
1427 c->pieces = XCNEWVEC (struct dwarf_expr_piece, n_pieces);
1429 memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
1430 for (i = 0; i < n_pieces; ++i)
1431 if (c->pieces[i].location == DWARF_VALUE_STACK)
1432 value_incref (c->pieces[i].v.value);
1437 /* The lowest-level function to extract bits from a byte buffer.
1438 SOURCE is the buffer. It is updated if we read to the end of a
1440 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1441 updated to reflect the number of bits actually read.
1442 NBITS is the number of bits we want to read. It is updated to
1443 reflect the number of bits actually read. This function may read
1445 BITS_BIG_ENDIAN is taken directly from gdbarch.
1446 This function returns the extracted bits. */
1449 extract_bits_primitive (const gdb_byte **source,
1450 unsigned int *source_offset_bits,
1451 int *nbits, int bits_big_endian)
1453 unsigned int avail, mask, datum;
1455 gdb_assert (*source_offset_bits < 8);
1457 avail = 8 - *source_offset_bits;
1461 mask = (1 << avail) - 1;
1463 if (bits_big_endian)
1464 datum >>= 8 - (*source_offset_bits + *nbits);
1466 datum >>= *source_offset_bits;
1470 *source_offset_bits += avail;
1471 if (*source_offset_bits >= 8)
1473 *source_offset_bits -= 8;
1480 /* Extract some bits from a source buffer and move forward in the
1483 SOURCE is the source buffer. It is updated as bytes are read.
1484 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1486 NBITS is the number of bits to read.
1487 BITS_BIG_ENDIAN is taken directly from gdbarch.
1489 This function returns the bits that were read. */
1492 extract_bits (const gdb_byte **source, unsigned int *source_offset_bits,
1493 int nbits, int bits_big_endian)
1497 gdb_assert (nbits > 0 && nbits <= 8);
1499 datum = extract_bits_primitive (source, source_offset_bits, &nbits,
1505 more = extract_bits_primitive (source, source_offset_bits, &nbits,
1507 if (bits_big_endian)
1517 /* Write some bits into a buffer and move forward in the buffer.
1519 DATUM is the bits to write. The low-order bits of DATUM are used.
1520 DEST is the destination buffer. It is updated as bytes are
1522 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1524 NBITS is the number of valid bits in DATUM.
1525 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1528 insert_bits (unsigned int datum,
1529 gdb_byte *dest, unsigned int dest_offset_bits,
1530 int nbits, int bits_big_endian)
1534 gdb_assert (dest_offset_bits + nbits <= 8);
1536 mask = (1 << nbits) - 1;
1537 if (bits_big_endian)
1539 datum <<= 8 - (dest_offset_bits + nbits);
1540 mask <<= 8 - (dest_offset_bits + nbits);
1544 datum <<= dest_offset_bits;
1545 mask <<= dest_offset_bits;
1548 gdb_assert ((datum & ~mask) == 0);
1550 *dest = (*dest & ~mask) | datum;
1553 /* Copy bits from a source to a destination.
1555 DEST is where the bits should be written.
1556 DEST_OFFSET_BITS is the bit offset into DEST.
1557 SOURCE is the source of bits.
1558 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1559 BIT_COUNT is the number of bits to copy.
1560 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1563 copy_bitwise (gdb_byte *dest, unsigned int dest_offset_bits,
1564 const gdb_byte *source, unsigned int source_offset_bits,
1565 unsigned int bit_count,
1566 int bits_big_endian)
1568 unsigned int dest_avail;
1571 /* Reduce everything to byte-size pieces. */
1572 dest += dest_offset_bits / 8;
1573 dest_offset_bits %= 8;
1574 source += source_offset_bits / 8;
1575 source_offset_bits %= 8;
1577 dest_avail = 8 - dest_offset_bits % 8;
1579 /* See if we can fill the first destination byte. */
1580 if (dest_avail < bit_count)
1582 datum = extract_bits (&source, &source_offset_bits, dest_avail,
1584 insert_bits (datum, dest, dest_offset_bits, dest_avail, bits_big_endian);
1586 dest_offset_bits = 0;
1587 bit_count -= dest_avail;
1590 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1591 than 8 bits remaining. */
1592 gdb_assert (dest_offset_bits % 8 == 0 || bit_count < 8);
1593 for (; bit_count >= 8; bit_count -= 8)
1595 datum = extract_bits (&source, &source_offset_bits, 8, bits_big_endian);
1596 *dest++ = (gdb_byte) datum;
1599 /* Finally, we may have a few leftover bits. */
1600 gdb_assert (bit_count <= 8 - dest_offset_bits % 8);
1603 datum = extract_bits (&source, &source_offset_bits, bit_count,
1605 insert_bits (datum, dest, dest_offset_bits, bit_count, bits_big_endian);
1610 read_pieced_value (struct value *v)
1614 ULONGEST bits_to_skip;
1616 struct piece_closure *c
1617 = (struct piece_closure *) value_computed_closure (v);
1618 struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
1620 size_t buffer_size = 0;
1621 gdb_byte *buffer = NULL;
1622 struct cleanup *cleanup;
1624 = gdbarch_bits_big_endian (get_type_arch (value_type (v)));
1626 if (value_type (v) != value_enclosing_type (v))
1627 internal_error (__FILE__, __LINE__,
1628 _("Should not be able to create a lazy value with "
1629 "an enclosing type"));
1631 cleanup = make_cleanup (free_current_contents, &buffer);
1633 contents = value_contents_raw (v);
1634 bits_to_skip = 8 * value_offset (v);
1635 if (value_bitsize (v))
1637 bits_to_skip += value_bitpos (v);
1638 type_len = value_bitsize (v);
1641 type_len = 8 * TYPE_LENGTH (value_type (v));
1643 for (i = 0; i < c->n_pieces && offset < type_len; i++)
1645 struct dwarf_expr_piece *p = &c->pieces[i];
1646 size_t this_size, this_size_bits;
1647 long dest_offset_bits, source_offset_bits, source_offset;
1648 const gdb_byte *intermediate_buffer;
1650 /* Compute size, source, and destination offsets for copying, in
1652 this_size_bits = p->size;
1653 if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
1655 bits_to_skip -= this_size_bits;
1658 if (bits_to_skip > 0)
1660 dest_offset_bits = 0;
1661 source_offset_bits = bits_to_skip;
1662 this_size_bits -= bits_to_skip;
1667 dest_offset_bits = offset;
1668 source_offset_bits = 0;
1670 if (this_size_bits > type_len - offset)
1671 this_size_bits = type_len - offset;
1673 this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
1674 source_offset = source_offset_bits / 8;
1675 if (buffer_size < this_size)
1677 buffer_size = this_size;
1678 buffer = xrealloc (buffer, buffer_size);
1680 intermediate_buffer = buffer;
1682 /* Copy from the source to DEST_BUFFER. */
1683 switch (p->location)
1685 case DWARF_VALUE_REGISTER:
1687 struct gdbarch *arch = get_frame_arch (frame);
1688 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
1689 int reg_offset = source_offset;
1691 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
1692 && this_size < register_size (arch, gdb_regnum))
1694 /* Big-endian, and we want less than full size. */
1695 reg_offset = register_size (arch, gdb_regnum) - this_size;
1696 /* We want the lower-order THIS_SIZE_BITS of the bytes
1697 we extract from the register. */
1698 source_offset_bits += 8 * this_size - this_size_bits;
1701 if (gdb_regnum != -1)
1705 if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
1709 /* Just so garbage doesn't ever shine through. */
1710 memset (buffer, 0, this_size);
1713 set_value_optimized_out (v, 1);
1715 mark_value_bits_unavailable (v, offset, this_size_bits);
1720 error (_("Unable to access DWARF register number %s"),
1721 paddress (arch, p->v.regno));
1726 case DWARF_VALUE_MEMORY:
1727 read_value_memory (v, offset,
1728 p->v.mem.in_stack_memory,
1729 p->v.mem.addr + source_offset,
1733 case DWARF_VALUE_STACK:
1735 size_t n = this_size;
1737 if (n > c->addr_size - source_offset)
1738 n = (c->addr_size >= source_offset
1739 ? c->addr_size - source_offset
1747 const gdb_byte *val_bytes = value_contents_all (p->v.value);
1749 intermediate_buffer = val_bytes + source_offset;
1754 case DWARF_VALUE_LITERAL:
1756 size_t n = this_size;
1758 if (n > p->v.literal.length - source_offset)
1759 n = (p->v.literal.length >= source_offset
1760 ? p->v.literal.length - source_offset
1763 intermediate_buffer = p->v.literal.data + source_offset;
1767 /* These bits show up as zeros -- but do not cause the value
1768 to be considered optimized-out. */
1769 case DWARF_VALUE_IMPLICIT_POINTER:
1772 case DWARF_VALUE_OPTIMIZED_OUT:
1773 set_value_optimized_out (v, 1);
1777 internal_error (__FILE__, __LINE__, _("invalid location type"));
1780 if (p->location != DWARF_VALUE_OPTIMIZED_OUT
1781 && p->location != DWARF_VALUE_IMPLICIT_POINTER)
1782 copy_bitwise (contents, dest_offset_bits,
1783 intermediate_buffer, source_offset_bits % 8,
1784 this_size_bits, bits_big_endian);
1786 offset += this_size_bits;
1789 do_cleanups (cleanup);
1793 write_pieced_value (struct value *to, struct value *from)
1797 ULONGEST bits_to_skip;
1798 const gdb_byte *contents;
1799 struct piece_closure *c
1800 = (struct piece_closure *) value_computed_closure (to);
1801 struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
1803 size_t buffer_size = 0;
1804 gdb_byte *buffer = NULL;
1805 struct cleanup *cleanup;
1807 = gdbarch_bits_big_endian (get_type_arch (value_type (to)));
1811 set_value_optimized_out (to, 1);
1815 cleanup = make_cleanup (free_current_contents, &buffer);
1817 contents = value_contents (from);
1818 bits_to_skip = 8 * value_offset (to);
1819 if (value_bitsize (to))
1821 bits_to_skip += value_bitpos (to);
1822 type_len = value_bitsize (to);
1825 type_len = 8 * TYPE_LENGTH (value_type (to));
1827 for (i = 0; i < c->n_pieces && offset < type_len; i++)
1829 struct dwarf_expr_piece *p = &c->pieces[i];
1830 size_t this_size_bits, this_size;
1831 long dest_offset_bits, source_offset_bits, dest_offset, source_offset;
1833 const gdb_byte *source_buffer;
1835 this_size_bits = p->size;
1836 if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
1838 bits_to_skip -= this_size_bits;
1841 if (this_size_bits > type_len - offset)
1842 this_size_bits = type_len - offset;
1843 if (bits_to_skip > 0)
1845 dest_offset_bits = bits_to_skip;
1846 source_offset_bits = 0;
1847 this_size_bits -= bits_to_skip;
1852 dest_offset_bits = 0;
1853 source_offset_bits = offset;
1856 this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
1857 source_offset = source_offset_bits / 8;
1858 dest_offset = dest_offset_bits / 8;
1859 if (dest_offset_bits % 8 == 0 && source_offset_bits % 8 == 0)
1861 source_buffer = contents + source_offset;
1866 if (buffer_size < this_size)
1868 buffer_size = this_size;
1869 buffer = xrealloc (buffer, buffer_size);
1871 source_buffer = buffer;
1875 switch (p->location)
1877 case DWARF_VALUE_REGISTER:
1879 struct gdbarch *arch = get_frame_arch (frame);
1880 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
1881 int reg_offset = dest_offset;
1883 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
1884 && this_size <= register_size (arch, gdb_regnum))
1885 /* Big-endian, and we want less than full size. */
1886 reg_offset = register_size (arch, gdb_regnum) - this_size;
1888 if (gdb_regnum != -1)
1894 if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
1899 throw_error (OPTIMIZED_OUT_ERROR,
1900 _("Can't do read-modify-write to "
1901 "update bitfield; containing word "
1902 "has been optimized out"));
1904 throw_error (NOT_AVAILABLE_ERROR,
1905 _("Can't do read-modify-write to update "
1906 "bitfield; containing word "
1909 copy_bitwise (buffer, dest_offset_bits,
1910 contents, source_offset_bits,
1915 put_frame_register_bytes (frame, gdb_regnum, reg_offset,
1916 this_size, source_buffer);
1920 error (_("Unable to write to DWARF register number %s"),
1921 paddress (arch, p->v.regno));
1925 case DWARF_VALUE_MEMORY:
1928 /* Only the first and last bytes can possibly have any
1930 read_memory (p->v.mem.addr + dest_offset, buffer, 1);
1931 read_memory (p->v.mem.addr + dest_offset + this_size - 1,
1932 buffer + this_size - 1, 1);
1933 copy_bitwise (buffer, dest_offset_bits,
1934 contents, source_offset_bits,
1939 write_memory (p->v.mem.addr + dest_offset,
1940 source_buffer, this_size);
1943 set_value_optimized_out (to, 1);
1946 offset += this_size_bits;
1949 do_cleanups (cleanup);
1952 /* A helper function that checks bit validity in a pieced value.
1953 CHECK_FOR indicates the kind of validity checking.
1954 DWARF_VALUE_MEMORY means to check whether any bit is valid.
1955 DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
1957 DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
1958 implicit pointer. */
1961 check_pieced_value_bits (const struct value *value, int bit_offset,
1963 enum dwarf_value_location check_for)
1965 struct piece_closure *c
1966 = (struct piece_closure *) value_computed_closure (value);
1968 int validity = (check_for == DWARF_VALUE_MEMORY
1969 || check_for == DWARF_VALUE_IMPLICIT_POINTER);
1971 bit_offset += 8 * value_offset (value);
1972 if (value_bitsize (value))
1973 bit_offset += value_bitpos (value);
1975 for (i = 0; i < c->n_pieces && bit_length > 0; i++)
1977 struct dwarf_expr_piece *p = &c->pieces[i];
1978 size_t this_size_bits = p->size;
1982 if (bit_offset >= this_size_bits)
1984 bit_offset -= this_size_bits;
1988 bit_length -= this_size_bits - bit_offset;
1992 bit_length -= this_size_bits;
1994 if (check_for == DWARF_VALUE_IMPLICIT_POINTER)
1996 if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
1999 else if (p->location == DWARF_VALUE_OPTIMIZED_OUT
2000 || p->location == DWARF_VALUE_IMPLICIT_POINTER)
2016 check_pieced_value_validity (const struct value *value, int bit_offset,
2019 return check_pieced_value_bits (value, bit_offset, bit_length,
2020 DWARF_VALUE_MEMORY);
2024 check_pieced_value_invalid (const struct value *value)
2026 return check_pieced_value_bits (value, 0,
2027 8 * TYPE_LENGTH (value_type (value)),
2028 DWARF_VALUE_OPTIMIZED_OUT);
2031 /* An implementation of an lval_funcs method to see whether a value is
2032 a synthetic pointer. */
2035 check_pieced_synthetic_pointer (const struct value *value, int bit_offset,
2038 return check_pieced_value_bits (value, bit_offset, bit_length,
2039 DWARF_VALUE_IMPLICIT_POINTER);
2042 /* A wrapper function for get_frame_address_in_block. */
2045 get_frame_address_in_block_wrapper (void *baton)
2047 return get_frame_address_in_block (baton);
2050 /* An implementation of an lval_funcs method to indirect through a
2051 pointer. This handles the synthetic pointer case when needed. */
2053 static struct value *
2054 indirect_pieced_value (struct value *value)
2056 struct piece_closure *c
2057 = (struct piece_closure *) value_computed_closure (value);
2059 struct frame_info *frame;
2060 struct dwarf2_locexpr_baton baton;
2061 int i, bit_offset, bit_length;
2062 struct dwarf_expr_piece *piece = NULL;
2063 LONGEST byte_offset;
2065 type = check_typedef (value_type (value));
2066 if (TYPE_CODE (type) != TYPE_CODE_PTR)
2069 bit_length = 8 * TYPE_LENGTH (type);
2070 bit_offset = 8 * value_offset (value);
2071 if (value_bitsize (value))
2072 bit_offset += value_bitpos (value);
2074 for (i = 0; i < c->n_pieces && bit_length > 0; i++)
2076 struct dwarf_expr_piece *p = &c->pieces[i];
2077 size_t this_size_bits = p->size;
2081 if (bit_offset >= this_size_bits)
2083 bit_offset -= this_size_bits;
2087 bit_length -= this_size_bits - bit_offset;
2091 bit_length -= this_size_bits;
2093 if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
2096 if (bit_length != 0)
2097 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2103 frame = get_selected_frame (_("No frame selected."));
2105 /* This is an offset requested by GDB, such as value subscripts.
2106 However, due to how synthetic pointers are implemented, this is
2107 always presented to us as a pointer type. This means we have to
2108 sign-extend it manually as appropriate. */
2109 byte_offset = value_as_address (value);
2110 if (TYPE_LENGTH (value_type (value)) < sizeof (LONGEST))
2111 byte_offset = gdb_sign_extend (byte_offset,
2112 8 * TYPE_LENGTH (value_type (value)));
2113 byte_offset += piece->v.ptr.offset;
2117 = dwarf2_fetch_die_loc_sect_off (piece->v.ptr.die, c->per_cu,
2118 get_frame_address_in_block_wrapper,
2121 if (baton.data != NULL)
2122 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
2123 baton.data, baton.size, baton.per_cu,
2127 struct obstack temp_obstack;
2128 struct cleanup *cleanup;
2129 const gdb_byte *bytes;
2131 struct value *result;
2133 obstack_init (&temp_obstack);
2134 cleanup = make_cleanup_obstack_free (&temp_obstack);
2136 bytes = dwarf2_fetch_constant_bytes (piece->v.ptr.die, c->per_cu,
2137 &temp_obstack, &len);
2139 result = allocate_optimized_out_value (TYPE_TARGET_TYPE (type));
2143 || byte_offset + TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > len)
2144 invalid_synthetic_pointer ();
2145 bytes += byte_offset;
2146 result = value_from_contents (TYPE_TARGET_TYPE (type), bytes);
2149 do_cleanups (cleanup);
2155 copy_pieced_value_closure (const struct value *v)
2157 struct piece_closure *c
2158 = (struct piece_closure *) value_computed_closure (v);
2165 free_pieced_value_closure (struct value *v)
2167 struct piece_closure *c
2168 = (struct piece_closure *) value_computed_closure (v);
2175 for (i = 0; i < c->n_pieces; ++i)
2176 if (c->pieces[i].location == DWARF_VALUE_STACK)
2177 value_free (c->pieces[i].v.value);
2184 /* Functions for accessing a variable described by DW_OP_piece. */
2185 static const struct lval_funcs pieced_value_funcs = {
2188 check_pieced_value_validity,
2189 check_pieced_value_invalid,
2190 indirect_pieced_value,
2191 NULL, /* coerce_ref */
2192 check_pieced_synthetic_pointer,
2193 copy_pieced_value_closure,
2194 free_pieced_value_closure
2197 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2199 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs =
2201 dwarf_expr_read_addr_from_reg,
2202 dwarf_expr_get_reg_value,
2203 dwarf_expr_read_mem,
2204 dwarf_expr_frame_base,
2205 dwarf_expr_frame_cfa,
2206 dwarf_expr_frame_pc,
2207 dwarf_expr_tls_address,
2208 dwarf_expr_dwarf_call,
2209 dwarf_expr_get_base_type,
2210 dwarf_expr_push_dwarf_reg_entry_value,
2211 dwarf_expr_get_addr_index,
2212 dwarf_expr_get_obj_addr
2215 /* Evaluate a location description, starting at DATA and with length
2216 SIZE, to find the current location of variable of TYPE in the
2217 context of FRAME. BYTE_OFFSET is applied after the contents are
2220 static struct value *
2221 dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
2222 const gdb_byte *data, size_t size,
2223 struct dwarf2_per_cu_data *per_cu,
2224 LONGEST byte_offset)
2226 struct value *retval;
2227 struct dwarf_expr_baton baton;
2228 struct dwarf_expr_context *ctx;
2229 struct cleanup *old_chain, *value_chain;
2230 struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
2231 volatile struct gdb_exception ex;
2233 if (byte_offset < 0)
2234 invalid_synthetic_pointer ();
2237 return allocate_optimized_out_value (type);
2239 baton.frame = frame;
2240 baton.per_cu = per_cu;
2241 baton.obj_address = 0;
2243 ctx = new_dwarf_expr_context ();
2244 old_chain = make_cleanup_free_dwarf_expr_context (ctx);
2245 value_chain = make_cleanup_value_free_to_mark (value_mark ());
2247 ctx->gdbarch = get_objfile_arch (objfile);
2248 ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
2249 ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu);
2250 ctx->offset = dwarf2_per_cu_text_offset (per_cu);
2251 ctx->baton = &baton;
2252 ctx->funcs = &dwarf_expr_ctx_funcs;
2254 TRY_CATCH (ex, RETURN_MASK_ERROR)
2256 dwarf_expr_eval (ctx, data, size);
2260 if (ex.error == NOT_AVAILABLE_ERROR)
2262 do_cleanups (old_chain);
2263 retval = allocate_value (type);
2264 mark_value_bytes_unavailable (retval, 0, TYPE_LENGTH (type));
2267 else if (ex.error == NO_ENTRY_VALUE_ERROR)
2269 if (entry_values_debug)
2270 exception_print (gdb_stdout, ex);
2271 do_cleanups (old_chain);
2272 return allocate_optimized_out_value (type);
2275 throw_exception (ex);
2278 if (ctx->num_pieces > 0)
2280 struct piece_closure *c;
2281 struct frame_id frame_id = get_frame_id (frame);
2282 ULONGEST bit_size = 0;
2285 for (i = 0; i < ctx->num_pieces; ++i)
2286 bit_size += ctx->pieces[i].size;
2287 if (8 * (byte_offset + TYPE_LENGTH (type)) > bit_size)
2288 invalid_synthetic_pointer ();
2290 c = allocate_piece_closure (per_cu, ctx->num_pieces, ctx->pieces,
2292 /* We must clean up the value chain after creating the piece
2293 closure but before allocating the result. */
2294 do_cleanups (value_chain);
2295 retval = allocate_computed_value (type, &pieced_value_funcs, c);
2296 VALUE_FRAME_ID (retval) = frame_id;
2297 set_value_offset (retval, byte_offset);
2301 switch (ctx->location)
2303 case DWARF_VALUE_REGISTER:
2305 struct gdbarch *arch = get_frame_arch (frame);
2307 = longest_to_int (value_as_long (dwarf_expr_fetch (ctx, 0)));
2308 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
2310 if (byte_offset != 0)
2311 error (_("cannot use offset on synthetic pointer to register"));
2312 do_cleanups (value_chain);
2313 if (gdb_regnum == -1)
2314 error (_("Unable to access DWARF register number %d"),
2316 retval = value_from_register (type, gdb_regnum, frame);
2317 if (value_optimized_out (retval))
2319 /* This means the register has undefined value / was
2320 not saved. As we're computing the location of some
2321 variable etc. in the program, not a value for
2322 inspecting a register ($pc, $sp, etc.), return a
2323 generic optimized out value instead, so that we show
2324 <optimized out> instead of <not saved>. */
2325 do_cleanups (value_chain);
2326 retval = allocate_optimized_out_value (type);
2331 case DWARF_VALUE_MEMORY:
2333 CORE_ADDR address = dwarf_expr_fetch_address (ctx, 0);
2334 int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
2336 do_cleanups (value_chain);
2337 retval = value_at_lazy (type, address + byte_offset);
2338 if (in_stack_memory)
2339 set_value_stack (retval, 1);
2343 case DWARF_VALUE_STACK:
2345 struct value *value = dwarf_expr_fetch (ctx, 0);
2347 const gdb_byte *val_bytes;
2348 size_t n = TYPE_LENGTH (value_type (value));
2350 if (byte_offset + TYPE_LENGTH (type) > n)
2351 invalid_synthetic_pointer ();
2353 val_bytes = value_contents_all (value);
2354 val_bytes += byte_offset;
2357 /* Preserve VALUE because we are going to free values back
2358 to the mark, but we still need the value contents
2360 value_incref (value);
2361 do_cleanups (value_chain);
2362 make_cleanup_value_free (value);
2364 retval = allocate_value (type);
2365 contents = value_contents_raw (retval);
2366 if (n > TYPE_LENGTH (type))
2368 struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
2370 if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
2371 val_bytes += n - TYPE_LENGTH (type);
2372 n = TYPE_LENGTH (type);
2374 memcpy (contents, val_bytes, n);
2378 case DWARF_VALUE_LITERAL:
2381 const bfd_byte *ldata;
2382 size_t n = ctx->len;
2384 if (byte_offset + TYPE_LENGTH (type) > n)
2385 invalid_synthetic_pointer ();
2387 do_cleanups (value_chain);
2388 retval = allocate_value (type);
2389 contents = value_contents_raw (retval);
2391 ldata = ctx->data + byte_offset;
2394 if (n > TYPE_LENGTH (type))
2396 struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
2398 if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
2399 ldata += n - TYPE_LENGTH (type);
2400 n = TYPE_LENGTH (type);
2402 memcpy (contents, ldata, n);
2406 case DWARF_VALUE_OPTIMIZED_OUT:
2407 do_cleanups (value_chain);
2408 retval = allocate_optimized_out_value (type);
2411 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2412 operation by execute_stack_op. */
2413 case DWARF_VALUE_IMPLICIT_POINTER:
2414 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2415 it can only be encountered when making a piece. */
2417 internal_error (__FILE__, __LINE__, _("invalid location type"));
2421 set_value_initialized (retval, ctx->initialized);
2423 do_cleanups (old_chain);
2428 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2429 passes 0 as the byte_offset. */
2432 dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
2433 const gdb_byte *data, size_t size,
2434 struct dwarf2_per_cu_data *per_cu)
2436 return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu, 0);
2439 /* Evaluates a dwarf expression and stores the result in VAL, expecting
2440 that the dwarf expression only produces a single CORE_ADDR. ADDR is a
2441 context (location of a variable) and might be needed to evaluate the
2442 location expression.
2443 Returns 1 on success, 0 otherwise. */
2446 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton,
2450 struct dwarf_expr_context *ctx;
2451 struct dwarf_expr_baton baton;
2452 struct objfile *objfile;
2453 struct cleanup *cleanup;
2455 if (dlbaton == NULL || dlbaton->size == 0)
2458 ctx = new_dwarf_expr_context ();
2459 cleanup = make_cleanup_free_dwarf_expr_context (ctx);
2461 baton.frame = get_selected_frame (NULL);
2462 baton.per_cu = dlbaton->per_cu;
2463 baton.obj_address = addr;
2465 objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
2467 ctx->gdbarch = get_objfile_arch (objfile);
2468 ctx->addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
2469 ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (dlbaton->per_cu);
2470 ctx->offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
2471 ctx->funcs = &dwarf_expr_ctx_funcs;
2472 ctx->baton = &baton;
2474 dwarf_expr_eval (ctx, dlbaton->data, dlbaton->size);
2476 switch (ctx->location)
2478 case DWARF_VALUE_REGISTER:
2479 case DWARF_VALUE_MEMORY:
2480 case DWARF_VALUE_STACK:
2481 *valp = dwarf_expr_fetch_address (ctx, 0);
2482 if (ctx->location == DWARF_VALUE_REGISTER)
2483 *valp = dwarf_expr_read_addr_from_reg (&baton, *valp);
2484 do_cleanups (cleanup);
2486 case DWARF_VALUE_LITERAL:
2487 *valp = extract_signed_integer (ctx->data, ctx->len,
2488 gdbarch_byte_order (ctx->gdbarch));
2489 do_cleanups (cleanup);
2491 /* Unsupported dwarf values. */
2492 case DWARF_VALUE_OPTIMIZED_OUT:
2493 case DWARF_VALUE_IMPLICIT_POINTER:
2497 do_cleanups (cleanup);
2501 /* See dwarf2loc.h. */
2504 dwarf2_evaluate_property (const struct dynamic_prop *prop,
2505 CORE_ADDR address, CORE_ADDR *value)
2514 const struct dwarf2_property_baton *baton = prop->data.baton;
2516 if (dwarf2_locexpr_baton_eval (&baton->locexpr, address, value))
2518 if (baton->referenced_type)
2520 struct value *val = value_at (baton->referenced_type, *value);
2522 *value = value_as_address (val);
2531 struct dwarf2_property_baton *baton = prop->data.baton;
2532 struct frame_info *frame = get_selected_frame (NULL);
2533 CORE_ADDR pc = get_frame_address_in_block (frame);
2534 const gdb_byte *data;
2538 data = dwarf2_find_location_expression (&baton->loclist, &size, pc);
2541 val = dwarf2_evaluate_loc_desc (baton->referenced_type, frame, data,
2542 size, baton->loclist.per_cu);
2543 if (!value_optimized_out (val))
2545 *value = value_as_address (val);
2553 *value = prop->data.const_val;
2561 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2563 struct needs_frame_baton
2566 struct dwarf2_per_cu_data *per_cu;
2569 /* Reads from registers do require a frame. */
2571 needs_frame_read_addr_from_reg (void *baton, int regnum)
2573 struct needs_frame_baton *nf_baton = baton;
2575 nf_baton->needs_frame = 1;
2579 /* struct dwarf_expr_context_funcs' "get_reg_value" callback:
2580 Reads from registers do require a frame. */
2582 static struct value *
2583 needs_frame_get_reg_value (void *baton, struct type *type, int regnum)
2585 struct needs_frame_baton *nf_baton = baton;
2587 nf_baton->needs_frame = 1;
2588 return value_zero (type, not_lval);
2591 /* Reads from memory do not require a frame. */
2593 needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
2595 memset (buf, 0, len);
2598 /* Frame-relative accesses do require a frame. */
2600 needs_frame_frame_base (void *baton, const gdb_byte **start, size_t * length)
2602 static gdb_byte lit0 = DW_OP_lit0;
2603 struct needs_frame_baton *nf_baton = baton;
2608 nf_baton->needs_frame = 1;
2611 /* CFA accesses require a frame. */
2614 needs_frame_frame_cfa (void *baton)
2616 struct needs_frame_baton *nf_baton = baton;
2618 nf_baton->needs_frame = 1;
2622 /* Thread-local accesses do require a frame. */
2624 needs_frame_tls_address (void *baton, CORE_ADDR offset)
2626 struct needs_frame_baton *nf_baton = baton;
2628 nf_baton->needs_frame = 1;
2632 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2635 needs_frame_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
2637 struct needs_frame_baton *nf_baton = ctx->baton;
2639 per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu,
2640 ctx->funcs->get_frame_pc, ctx->baton);
2643 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2646 needs_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
2647 enum call_site_parameter_kind kind,
2648 union call_site_parameter_u kind_u, int deref_size)
2650 struct needs_frame_baton *nf_baton = ctx->baton;
2652 nf_baton->needs_frame = 1;
2654 /* The expression may require some stub values on DWARF stack. */
2655 dwarf_expr_push_address (ctx, 0, 0);
2658 /* DW_OP_GNU_addr_index doesn't require a frame. */
2661 needs_get_addr_index (void *baton, unsigned int index)
2663 /* Nothing to do. */
2667 /* DW_OP_push_object_address has a frame already passed through. */
2670 needs_get_obj_addr (void *baton)
2672 /* Nothing to do. */
2676 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2678 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs =
2680 needs_frame_read_addr_from_reg,
2681 needs_frame_get_reg_value,
2682 needs_frame_read_mem,
2683 needs_frame_frame_base,
2684 needs_frame_frame_cfa,
2685 needs_frame_frame_cfa, /* get_frame_pc */
2686 needs_frame_tls_address,
2687 needs_frame_dwarf_call,
2688 NULL, /* get_base_type */
2689 needs_dwarf_reg_entry_value,
2690 needs_get_addr_index,
2694 /* Return non-zero iff the location expression at DATA (length SIZE)
2695 requires a frame to evaluate. */
2698 dwarf2_loc_desc_needs_frame (const gdb_byte *data, size_t size,
2699 struct dwarf2_per_cu_data *per_cu)
2701 struct needs_frame_baton baton;
2702 struct dwarf_expr_context *ctx;
2704 struct cleanup *old_chain;
2705 struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
2707 baton.needs_frame = 0;
2708 baton.per_cu = per_cu;
2710 ctx = new_dwarf_expr_context ();
2711 old_chain = make_cleanup_free_dwarf_expr_context (ctx);
2712 make_cleanup_value_free_to_mark (value_mark ());
2714 ctx->gdbarch = get_objfile_arch (objfile);
2715 ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
2716 ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu);
2717 ctx->offset = dwarf2_per_cu_text_offset (per_cu);
2718 ctx->baton = &baton;
2719 ctx->funcs = &needs_frame_ctx_funcs;
2721 dwarf_expr_eval (ctx, data, size);
2723 in_reg = ctx->location == DWARF_VALUE_REGISTER;
2725 if (ctx->num_pieces > 0)
2729 /* If the location has several pieces, and any of them are in
2730 registers, then we will need a frame to fetch them from. */
2731 for (i = 0; i < ctx->num_pieces; i++)
2732 if (ctx->pieces[i].location == DWARF_VALUE_REGISTER)
2736 do_cleanups (old_chain);
2738 return baton.needs_frame || in_reg;
2741 /* A helper function that throws an unimplemented error mentioning a
2742 given DWARF operator. */
2745 unimplemented (unsigned int op)
2747 const char *name = get_DW_OP_name (op);
2750 error (_("DWARF operator %s cannot be translated to an agent expression"),
2753 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2754 "to an agent expression"),
2758 /* A helper function to convert a DWARF register to an arch register.
2759 ARCH is the architecture.
2760 DWARF_REG is the register.
2761 This will throw an exception if the DWARF register cannot be
2762 translated to an architecture register. */
2765 translate_register (struct gdbarch *arch, int dwarf_reg)
2767 int reg = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_reg);
2769 error (_("Unable to access DWARF register number %d"), dwarf_reg);
2773 /* A helper function that emits an access to memory. ARCH is the
2774 target architecture. EXPR is the expression which we are building.
2775 NBITS is the number of bits we want to read. This emits the
2776 opcodes needed to read the memory and then extract the desired
2780 access_memory (struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits)
2782 ULONGEST nbytes = (nbits + 7) / 8;
2784 gdb_assert (nbytes > 0 && nbytes <= sizeof (LONGEST));
2787 ax_trace_quick (expr, nbytes);
2790 ax_simple (expr, aop_ref8);
2791 else if (nbits <= 16)
2792 ax_simple (expr, aop_ref16);
2793 else if (nbits <= 32)
2794 ax_simple (expr, aop_ref32);
2796 ax_simple (expr, aop_ref64);
2798 /* If we read exactly the number of bytes we wanted, we're done. */
2799 if (8 * nbytes == nbits)
2802 if (gdbarch_bits_big_endian (arch))
2804 /* On a bits-big-endian machine, we want the high-order
2806 ax_const_l (expr, 8 * nbytes - nbits);
2807 ax_simple (expr, aop_rsh_unsigned);
2811 /* On a bits-little-endian box, we want the low-order NBITS. */
2812 ax_zero_ext (expr, nbits);
2816 /* A helper function to return the frame's PC. */
2819 get_ax_pc (void *baton)
2821 struct agent_expr *expr = baton;
2826 /* Compile a DWARF location expression to an agent expression.
2828 EXPR is the agent expression we are building.
2829 LOC is the agent value we modify.
2830 ARCH is the architecture.
2831 ADDR_SIZE is the size of addresses, in bytes.
2832 OP_PTR is the start of the location expression.
2833 OP_END is one past the last byte of the location expression.
2835 This will throw an exception for various kinds of errors -- for
2836 example, if the expression cannot be compiled, or if the expression
2840 dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
2841 struct gdbarch *arch, unsigned int addr_size,
2842 const gdb_byte *op_ptr, const gdb_byte *op_end,
2843 struct dwarf2_per_cu_data *per_cu)
2845 struct cleanup *cleanups;
2847 VEC(int) *dw_labels = NULL, *patches = NULL;
2848 const gdb_byte * const base = op_ptr;
2849 const gdb_byte *previous_piece = op_ptr;
2850 enum bfd_endian byte_order = gdbarch_byte_order (arch);
2851 ULONGEST bits_collected = 0;
2852 unsigned int addr_size_bits = 8 * addr_size;
2853 int bits_big_endian = gdbarch_bits_big_endian (arch);
2855 offsets = xmalloc ((op_end - op_ptr) * sizeof (int));
2856 cleanups = make_cleanup (xfree, offsets);
2858 for (i = 0; i < op_end - op_ptr; ++i)
2861 make_cleanup (VEC_cleanup (int), &dw_labels);
2862 make_cleanup (VEC_cleanup (int), &patches);
2864 /* By default we are making an address. */
2865 loc->kind = axs_lvalue_memory;
2867 while (op_ptr < op_end)
2869 enum dwarf_location_atom op = *op_ptr;
2870 uint64_t uoffset, reg;
2874 offsets[op_ptr - base] = expr->len;
2877 /* Our basic approach to code generation is to map DWARF
2878 operations directly to AX operations. However, there are
2881 First, DWARF works on address-sized units, but AX always uses
2882 LONGEST. For most operations we simply ignore this
2883 difference; instead we generate sign extensions as needed
2884 before division and comparison operations. It would be nice
2885 to omit the sign extensions, but there is no way to determine
2886 the size of the target's LONGEST. (This code uses the size
2887 of the host LONGEST in some cases -- that is a bug but it is
2890 Second, some DWARF operations cannot be translated to AX.
2891 For these we simply fail. See
2892 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2927 ax_const_l (expr, op - DW_OP_lit0);
2931 uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order);
2932 op_ptr += addr_size;
2933 /* Some versions of GCC emit DW_OP_addr before
2934 DW_OP_GNU_push_tls_address. In this case the value is an
2935 index, not an address. We don't support things like
2936 branching between the address and the TLS op. */
2937 if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
2938 uoffset += dwarf2_per_cu_text_offset (per_cu);
2939 ax_const_l (expr, uoffset);
2943 ax_const_l (expr, extract_unsigned_integer (op_ptr, 1, byte_order));
2947 ax_const_l (expr, extract_signed_integer (op_ptr, 1, byte_order));
2951 ax_const_l (expr, extract_unsigned_integer (op_ptr, 2, byte_order));
2955 ax_const_l (expr, extract_signed_integer (op_ptr, 2, byte_order));
2959 ax_const_l (expr, extract_unsigned_integer (op_ptr, 4, byte_order));
2963 ax_const_l (expr, extract_signed_integer (op_ptr, 4, byte_order));
2967 ax_const_l (expr, extract_unsigned_integer (op_ptr, 8, byte_order));
2971 ax_const_l (expr, extract_signed_integer (op_ptr, 8, byte_order));
2975 op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
2976 ax_const_l (expr, uoffset);
2979 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
2980 ax_const_l (expr, offset);
3015 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
3016 loc->u.reg = translate_register (arch, op - DW_OP_reg0);
3017 loc->kind = axs_lvalue_register;
3021 op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
3022 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
3023 loc->u.reg = translate_register (arch, reg);
3024 loc->kind = axs_lvalue_register;
3027 case DW_OP_implicit_value:
3031 op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
3032 if (op_ptr + len > op_end)
3033 error (_("DW_OP_implicit_value: too few bytes available."));
3034 if (len > sizeof (ULONGEST))
3035 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
3038 ax_const_l (expr, extract_unsigned_integer (op_ptr, len,
3041 dwarf_expr_require_composition (op_ptr, op_end,
3042 "DW_OP_implicit_value");
3044 loc->kind = axs_rvalue;
3048 case DW_OP_stack_value:
3049 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
3050 loc->kind = axs_rvalue;
3085 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
3086 i = translate_register (arch, op - DW_OP_breg0);
3090 ax_const_l (expr, offset);
3091 ax_simple (expr, aop_add);
3096 op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
3097 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
3098 i = translate_register (arch, reg);
3102 ax_const_l (expr, offset);
3103 ax_simple (expr, aop_add);
3109 const gdb_byte *datastart;
3111 const struct block *b;
3112 struct symbol *framefunc;
3114 b = block_for_pc (expr->scope);
3117 error (_("No block found for address"));
3119 framefunc = block_linkage_function (b);
3122 error (_("No function found for block"));
3124 dwarf_expr_frame_base_1 (framefunc, expr->scope,
3125 &datastart, &datalen);
3127 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
3128 dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart,
3129 datastart + datalen, per_cu);
3130 if (loc->kind == axs_lvalue_register)
3131 require_rvalue (expr, loc);
3135 ax_const_l (expr, offset);
3136 ax_simple (expr, aop_add);
3139 loc->kind = axs_lvalue_memory;
3144 ax_simple (expr, aop_dup);
3148 ax_simple (expr, aop_pop);
3153 ax_pick (expr, offset);
3157 ax_simple (expr, aop_swap);
3165 ax_simple (expr, aop_rot);
3169 case DW_OP_deref_size:
3173 if (op == DW_OP_deref_size)
3178 if (size != 1 && size != 2 && size != 4 && size != 8)
3179 error (_("Unsupported size %d in %s"),
3180 size, get_DW_OP_name (op));
3181 access_memory (arch, expr, size * TARGET_CHAR_BIT);
3186 /* Sign extend the operand. */
3187 ax_ext (expr, addr_size_bits);
3188 ax_simple (expr, aop_dup);
3189 ax_const_l (expr, 0);
3190 ax_simple (expr, aop_less_signed);
3191 ax_simple (expr, aop_log_not);
3192 i = ax_goto (expr, aop_if_goto);
3193 /* We have to emit 0 - X. */
3194 ax_const_l (expr, 0);
3195 ax_simple (expr, aop_swap);
3196 ax_simple (expr, aop_sub);
3197 ax_label (expr, i, expr->len);
3201 /* No need to sign extend here. */
3202 ax_const_l (expr, 0);
3203 ax_simple (expr, aop_swap);
3204 ax_simple (expr, aop_sub);
3208 /* Sign extend the operand. */
3209 ax_ext (expr, addr_size_bits);
3210 ax_simple (expr, aop_bit_not);
3213 case DW_OP_plus_uconst:
3214 op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
3215 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3216 but we micro-optimize anyhow. */
3219 ax_const_l (expr, reg);
3220 ax_simple (expr, aop_add);
3225 ax_simple (expr, aop_bit_and);
3229 /* Sign extend the operands. */
3230 ax_ext (expr, addr_size_bits);
3231 ax_simple (expr, aop_swap);
3232 ax_ext (expr, addr_size_bits);
3233 ax_simple (expr, aop_swap);
3234 ax_simple (expr, aop_div_signed);
3238 ax_simple (expr, aop_sub);
3242 ax_simple (expr, aop_rem_unsigned);
3246 ax_simple (expr, aop_mul);
3250 ax_simple (expr, aop_bit_or);
3254 ax_simple (expr, aop_add);
3258 ax_simple (expr, aop_lsh);
3262 ax_simple (expr, aop_rsh_unsigned);
3266 ax_simple (expr, aop_rsh_signed);
3270 ax_simple (expr, aop_bit_xor);
3274 /* Sign extend the operands. */
3275 ax_ext (expr, addr_size_bits);
3276 ax_simple (expr, aop_swap);
3277 ax_ext (expr, addr_size_bits);
3278 /* Note no swap here: A <= B is !(B < A). */
3279 ax_simple (expr, aop_less_signed);
3280 ax_simple (expr, aop_log_not);
3284 /* Sign extend the operands. */
3285 ax_ext (expr, addr_size_bits);
3286 ax_simple (expr, aop_swap);
3287 ax_ext (expr, addr_size_bits);
3288 ax_simple (expr, aop_swap);
3289 /* A >= B is !(A < B). */
3290 ax_simple (expr, aop_less_signed);
3291 ax_simple (expr, aop_log_not);
3295 /* Sign extend the operands. */
3296 ax_ext (expr, addr_size_bits);
3297 ax_simple (expr, aop_swap);
3298 ax_ext (expr, addr_size_bits);
3299 /* No need for a second swap here. */
3300 ax_simple (expr, aop_equal);
3304 /* Sign extend the operands. */
3305 ax_ext (expr, addr_size_bits);
3306 ax_simple (expr, aop_swap);
3307 ax_ext (expr, addr_size_bits);
3308 ax_simple (expr, aop_swap);
3309 ax_simple (expr, aop_less_signed);
3313 /* Sign extend the operands. */
3314 ax_ext (expr, addr_size_bits);
3315 ax_simple (expr, aop_swap);
3316 ax_ext (expr, addr_size_bits);
3317 /* Note no swap here: A > B is B < A. */
3318 ax_simple (expr, aop_less_signed);
3322 /* Sign extend the operands. */
3323 ax_ext (expr, addr_size_bits);
3324 ax_simple (expr, aop_swap);
3325 ax_ext (expr, addr_size_bits);
3326 /* No need for a swap here. */
3327 ax_simple (expr, aop_equal);
3328 ax_simple (expr, aop_log_not);
3331 case DW_OP_call_frame_cfa:
3332 dwarf2_compile_cfa_to_ax (expr, loc, arch, expr->scope, per_cu);
3333 loc->kind = axs_lvalue_memory;
3336 case DW_OP_GNU_push_tls_address:
3340 case DW_OP_push_object_address:
3345 offset = extract_signed_integer (op_ptr, 2, byte_order);
3347 i = ax_goto (expr, aop_goto);
3348 VEC_safe_push (int, dw_labels, op_ptr + offset - base);
3349 VEC_safe_push (int, patches, i);
3353 offset = extract_signed_integer (op_ptr, 2, byte_order);
3355 /* Zero extend the operand. */
3356 ax_zero_ext (expr, addr_size_bits);
3357 i = ax_goto (expr, aop_if_goto);
3358 VEC_safe_push (int, dw_labels, op_ptr + offset - base);
3359 VEC_safe_push (int, patches, i);
3366 case DW_OP_bit_piece:
3368 uint64_t size, offset;
3370 if (op_ptr - 1 == previous_piece)
3371 error (_("Cannot translate empty pieces to agent expressions"));
3372 previous_piece = op_ptr - 1;
3374 op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
3375 if (op == DW_OP_piece)
3381 op_ptr = safe_read_uleb128 (op_ptr, op_end, &offset);
3383 if (bits_collected + size > 8 * sizeof (LONGEST))
3384 error (_("Expression pieces exceed word size"));
3386 /* Access the bits. */
3389 case axs_lvalue_register:
3390 ax_reg (expr, loc->u.reg);
3393 case axs_lvalue_memory:
3394 /* Offset the pointer, if needed. */
3397 ax_const_l (expr, offset / 8);
3398 ax_simple (expr, aop_add);
3401 access_memory (arch, expr, size);
3405 /* For a bits-big-endian target, shift up what we already
3406 have. For a bits-little-endian target, shift up the
3407 new data. Note that there is a potential bug here if
3408 the DWARF expression leaves multiple values on the
3410 if (bits_collected > 0)
3412 if (bits_big_endian)
3414 ax_simple (expr, aop_swap);
3415 ax_const_l (expr, size);
3416 ax_simple (expr, aop_lsh);
3417 /* We don't need a second swap here, because
3418 aop_bit_or is symmetric. */
3422 ax_const_l (expr, size);
3423 ax_simple (expr, aop_lsh);
3425 ax_simple (expr, aop_bit_or);
3428 bits_collected += size;
3429 loc->kind = axs_rvalue;
3433 case DW_OP_GNU_uninit:
3439 struct dwarf2_locexpr_baton block;
3440 int size = (op == DW_OP_call2 ? 2 : 4);
3443 uoffset = extract_unsigned_integer (op_ptr, size, byte_order);
3446 offset.cu_off = uoffset;
3447 block = dwarf2_fetch_die_loc_cu_off (offset, per_cu,
3450 /* DW_OP_call_ref is currently not supported. */
3451 gdb_assert (block.per_cu == per_cu);
3453 dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
3454 block.data, block.data + block.size,
3459 case DW_OP_call_ref:
3467 /* Patch all the branches we emitted. */
3468 for (i = 0; i < VEC_length (int, patches); ++i)
3470 int targ = offsets[VEC_index (int, dw_labels, i)];
3472 internal_error (__FILE__, __LINE__, _("invalid label"));
3473 ax_label (expr, VEC_index (int, patches, i), targ);
3476 do_cleanups (cleanups);
3480 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3481 evaluator to calculate the location. */
3482 static struct value *
3483 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
3485 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3488 val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, dlbaton->data,
3489 dlbaton->size, dlbaton->per_cu);
3494 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3495 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3498 static struct value *
3499 locexpr_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
3501 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3503 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, dlbaton->data,
3507 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3509 locexpr_read_needs_frame (struct symbol *symbol)
3511 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3513 return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
3517 /* Return true if DATA points to the end of a piece. END is one past
3518 the last byte in the expression. */
3521 piece_end_p (const gdb_byte *data, const gdb_byte *end)
3523 return data == end || data[0] == DW_OP_piece || data[0] == DW_OP_bit_piece;
3526 /* Helper for locexpr_describe_location_piece that finds the name of a
3530 locexpr_regname (struct gdbarch *gdbarch, int dwarf_regnum)
3534 regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
3535 return gdbarch_register_name (gdbarch, regnum);
3538 /* Nicely describe a single piece of a location, returning an updated
3539 position in the bytecode sequence. This function cannot recognize
3540 all locations; if a location is not recognized, it simply returns
3541 DATA. If there is an error during reading, e.g. we run off the end
3542 of the buffer, an error is thrown. */
3544 static const gdb_byte *
3545 locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
3546 CORE_ADDR addr, struct objfile *objfile,
3547 struct dwarf2_per_cu_data *per_cu,
3548 const gdb_byte *data, const gdb_byte *end,
3549 unsigned int addr_size)
3551 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3554 if (data[0] >= DW_OP_reg0 && data[0] <= DW_OP_reg31)
3556 fprintf_filtered (stream, _("a variable in $%s"),
3557 locexpr_regname (gdbarch, data[0] - DW_OP_reg0));
3560 else if (data[0] == DW_OP_regx)
3564 data = safe_read_uleb128 (data + 1, end, ®);
3565 fprintf_filtered (stream, _("a variable in $%s"),
3566 locexpr_regname (gdbarch, reg));
3568 else if (data[0] == DW_OP_fbreg)
3570 const struct block *b;
3571 struct symbol *framefunc;
3573 int64_t frame_offset;
3574 const gdb_byte *base_data, *new_data, *save_data = data;
3576 int64_t base_offset = 0;
3578 new_data = safe_read_sleb128 (data + 1, end, &frame_offset);
3579 if (!piece_end_p (new_data, end))
3583 b = block_for_pc (addr);
3586 error (_("No block found for address for symbol \"%s\"."),
3587 SYMBOL_PRINT_NAME (symbol));
3589 framefunc = block_linkage_function (b);
3592 error (_("No function found for block for symbol \"%s\"."),
3593 SYMBOL_PRINT_NAME (symbol));
3595 dwarf_expr_frame_base_1 (framefunc, addr, &base_data, &base_size);
3597 if (base_data[0] >= DW_OP_breg0 && base_data[0] <= DW_OP_breg31)
3599 const gdb_byte *buf_end;
3601 frame_reg = base_data[0] - DW_OP_breg0;
3602 buf_end = safe_read_sleb128 (base_data + 1, base_data + base_size,
3604 if (buf_end != base_data + base_size)
3605 error (_("Unexpected opcode after "
3606 "DW_OP_breg%u for symbol \"%s\"."),
3607 frame_reg, SYMBOL_PRINT_NAME (symbol));
3609 else if (base_data[0] >= DW_OP_reg0 && base_data[0] <= DW_OP_reg31)
3611 /* The frame base is just the register, with no offset. */
3612 frame_reg = base_data[0] - DW_OP_reg0;
3617 /* We don't know what to do with the frame base expression,
3618 so we can't trace this variable; give up. */
3622 fprintf_filtered (stream,
3623 _("a variable at frame base reg $%s offset %s+%s"),
3624 locexpr_regname (gdbarch, frame_reg),
3625 plongest (base_offset), plongest (frame_offset));
3627 else if (data[0] >= DW_OP_breg0 && data[0] <= DW_OP_breg31
3628 && piece_end_p (data, end))
3632 data = safe_read_sleb128 (data + 1, end, &offset);
3634 fprintf_filtered (stream,
3635 _("a variable at offset %s from base reg $%s"),
3637 locexpr_regname (gdbarch, data[0] - DW_OP_breg0));
3640 /* The location expression for a TLS variable looks like this (on a
3643 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3644 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3646 0x3 is the encoding for DW_OP_addr, which has an operand as long
3647 as the size of an address on the target machine (here is 8
3648 bytes). Note that more recent version of GCC emit DW_OP_const4u
3649 or DW_OP_const8u, depending on address size, rather than
3650 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3651 The operand represents the offset at which the variable is within
3652 the thread local storage. */
3654 else if (data + 1 + addr_size < end
3655 && (data[0] == DW_OP_addr
3656 || (addr_size == 4 && data[0] == DW_OP_const4u)
3657 || (addr_size == 8 && data[0] == DW_OP_const8u))
3658 && data[1 + addr_size] == DW_OP_GNU_push_tls_address
3659 && piece_end_p (data + 2 + addr_size, end))
3662 offset = extract_unsigned_integer (data + 1, addr_size,
3663 gdbarch_byte_order (gdbarch));
3665 fprintf_filtered (stream,
3666 _("a thread-local variable at offset 0x%s "
3667 "in the thread-local storage for `%s'"),
3668 phex_nz (offset, addr_size), objfile_name (objfile));
3670 data += 1 + addr_size + 1;
3673 /* With -gsplit-dwarf a TLS variable can also look like this:
3674 DW_AT_location : 3 byte block: fc 4 e0
3675 (DW_OP_GNU_const_index: 4;
3676 DW_OP_GNU_push_tls_address) */
3677 else if (data + 3 <= end
3678 && data + 1 + (leb128_size = skip_leb128 (data + 1, end)) < end
3679 && data[0] == DW_OP_GNU_const_index
3681 && data[1 + leb128_size] == DW_OP_GNU_push_tls_address
3682 && piece_end_p (data + 2 + leb128_size, end))
3686 data = safe_read_uleb128 (data + 1, end, &offset);
3687 offset = dwarf2_read_addr_index (per_cu, offset);
3688 fprintf_filtered (stream,
3689 _("a thread-local variable at offset 0x%s "
3690 "in the thread-local storage for `%s'"),
3691 phex_nz (offset, addr_size), objfile_name (objfile));
3695 else if (data[0] >= DW_OP_lit0
3696 && data[0] <= DW_OP_lit31
3698 && data[1] == DW_OP_stack_value)
3700 fprintf_filtered (stream, _("the constant %d"), data[0] - DW_OP_lit0);
3707 /* Disassemble an expression, stopping at the end of a piece or at the
3708 end of the expression. Returns a pointer to the next unread byte
3709 in the input expression. If ALL is nonzero, then this function
3710 will keep going until it reaches the end of the expression.
3711 If there is an error during reading, e.g. we run off the end
3712 of the buffer, an error is thrown. */
3714 static const gdb_byte *
3715 disassemble_dwarf_expression (struct ui_file *stream,
3716 struct gdbarch *arch, unsigned int addr_size,
3717 int offset_size, const gdb_byte *start,
3718 const gdb_byte *data, const gdb_byte *end,
3719 int indent, int all,
3720 struct dwarf2_per_cu_data *per_cu)
3724 || (data[0] != DW_OP_piece && data[0] != DW_OP_bit_piece)))
3726 enum dwarf_location_atom op = *data++;
3731 name = get_DW_OP_name (op);
3734 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3735 op, (long) (data - 1 - start));
3736 fprintf_filtered (stream, " %*ld: %s", indent + 4,
3737 (long) (data - 1 - start), name);
3742 ul = extract_unsigned_integer (data, addr_size,
3743 gdbarch_byte_order (arch));
3745 fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size));
3749 ul = extract_unsigned_integer (data, 1, gdbarch_byte_order (arch));
3751 fprintf_filtered (stream, " %s", pulongest (ul));
3754 l = extract_signed_integer (data, 1, gdbarch_byte_order (arch));
3756 fprintf_filtered (stream, " %s", plongest (l));
3759 ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
3761 fprintf_filtered (stream, " %s", pulongest (ul));
3764 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3766 fprintf_filtered (stream, " %s", plongest (l));
3769 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
3771 fprintf_filtered (stream, " %s", pulongest (ul));
3774 l = extract_signed_integer (data, 4, gdbarch_byte_order (arch));
3776 fprintf_filtered (stream, " %s", plongest (l));
3779 ul = extract_unsigned_integer (data, 8, gdbarch_byte_order (arch));
3781 fprintf_filtered (stream, " %s", pulongest (ul));
3784 l = extract_signed_integer (data, 8, gdbarch_byte_order (arch));
3786 fprintf_filtered (stream, " %s", plongest (l));
3789 data = safe_read_uleb128 (data, end, &ul);
3790 fprintf_filtered (stream, " %s", pulongest (ul));
3793 data = safe_read_sleb128 (data, end, &l);
3794 fprintf_filtered (stream, " %s", plongest (l));
3829 fprintf_filtered (stream, " [$%s]",
3830 locexpr_regname (arch, op - DW_OP_reg0));
3834 data = safe_read_uleb128 (data, end, &ul);
3835 fprintf_filtered (stream, " %s [$%s]", pulongest (ul),
3836 locexpr_regname (arch, (int) ul));
3839 case DW_OP_implicit_value:
3840 data = safe_read_uleb128 (data, end, &ul);
3842 fprintf_filtered (stream, " %s", pulongest (ul));
3877 data = safe_read_sleb128 (data, end, &l);
3878 fprintf_filtered (stream, " %s [$%s]", plongest (l),
3879 locexpr_regname (arch, op - DW_OP_breg0));
3883 data = safe_read_uleb128 (data, end, &ul);
3884 data = safe_read_sleb128 (data, end, &l);
3885 fprintf_filtered (stream, " register %s [$%s] offset %s",
3887 locexpr_regname (arch, (int) ul),
3892 data = safe_read_sleb128 (data, end, &l);
3893 fprintf_filtered (stream, " %s", plongest (l));
3896 case DW_OP_xderef_size:
3897 case DW_OP_deref_size:
3899 fprintf_filtered (stream, " %d", *data);
3903 case DW_OP_plus_uconst:
3904 data = safe_read_uleb128 (data, end, &ul);
3905 fprintf_filtered (stream, " %s", pulongest (ul));
3909 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3911 fprintf_filtered (stream, " to %ld",
3912 (long) (data + l - start));
3916 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3918 fprintf_filtered (stream, " %ld",
3919 (long) (data + l - start));
3923 ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
3925 fprintf_filtered (stream, " offset %s", phex_nz (ul, 2));
3929 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
3931 fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
3934 case DW_OP_call_ref:
3935 ul = extract_unsigned_integer (data, offset_size,
3936 gdbarch_byte_order (arch));
3937 data += offset_size;
3938 fprintf_filtered (stream, " offset %s", phex_nz (ul, offset_size));
3942 data = safe_read_uleb128 (data, end, &ul);
3943 fprintf_filtered (stream, " %s (bytes)", pulongest (ul));
3946 case DW_OP_bit_piece:
3950 data = safe_read_uleb128 (data, end, &ul);
3951 data = safe_read_uleb128 (data, end, &offset);
3952 fprintf_filtered (stream, " size %s offset %s (bits)",
3953 pulongest (ul), pulongest (offset));
3957 case DW_OP_GNU_implicit_pointer:
3959 ul = extract_unsigned_integer (data, offset_size,
3960 gdbarch_byte_order (arch));
3961 data += offset_size;
3963 data = safe_read_sleb128 (data, end, &l);
3965 fprintf_filtered (stream, " DIE %s offset %s",
3966 phex_nz (ul, offset_size),
3971 case DW_OP_GNU_deref_type:
3973 int addr_size = *data++;
3977 data = safe_read_uleb128 (data, end, &ul);
3979 type = dwarf2_get_die_type (offset, per_cu);
3980 fprintf_filtered (stream, "<");
3981 type_print (type, "", stream, -1);
3982 fprintf_filtered (stream, " [0x%s]> %d", phex_nz (offset.cu_off, 0),
3987 case DW_OP_GNU_const_type:
3992 data = safe_read_uleb128 (data, end, &ul);
3993 type_die.cu_off = ul;
3994 type = dwarf2_get_die_type (type_die, per_cu);
3995 fprintf_filtered (stream, "<");
3996 type_print (type, "", stream, -1);
3997 fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die.cu_off, 0));
4001 case DW_OP_GNU_regval_type:
4007 data = safe_read_uleb128 (data, end, ®);
4008 data = safe_read_uleb128 (data, end, &ul);
4009 type_die.cu_off = ul;
4011 type = dwarf2_get_die_type (type_die, per_cu);
4012 fprintf_filtered (stream, "<");
4013 type_print (type, "", stream, -1);
4014 fprintf_filtered (stream, " [0x%s]> [$%s]",
4015 phex_nz (type_die.cu_off, 0),
4016 locexpr_regname (arch, reg));
4020 case DW_OP_GNU_convert:
4021 case DW_OP_GNU_reinterpret:
4025 data = safe_read_uleb128 (data, end, &ul);
4026 type_die.cu_off = ul;
4028 if (type_die.cu_off == 0)
4029 fprintf_filtered (stream, "<0>");
4034 type = dwarf2_get_die_type (type_die, per_cu);
4035 fprintf_filtered (stream, "<");
4036 type_print (type, "", stream, -1);
4037 fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die.cu_off, 0));
4042 case DW_OP_GNU_entry_value:
4043 data = safe_read_uleb128 (data, end, &ul);
4044 fputc_filtered ('\n', stream);
4045 disassemble_dwarf_expression (stream, arch, addr_size, offset_size,
4046 start, data, data + ul, indent + 2,
4051 case DW_OP_GNU_parameter_ref:
4052 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
4054 fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
4057 case DW_OP_GNU_addr_index:
4058 data = safe_read_uleb128 (data, end, &ul);
4059 ul = dwarf2_read_addr_index (per_cu, ul);
4060 fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size));
4062 case DW_OP_GNU_const_index:
4063 data = safe_read_uleb128 (data, end, &ul);
4064 ul = dwarf2_read_addr_index (per_cu, ul);
4065 fprintf_filtered (stream, " %s", pulongest (ul));
4069 fprintf_filtered (stream, "\n");
4075 /* Describe a single location, which may in turn consist of multiple
4079 locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr,
4080 struct ui_file *stream,
4081 const gdb_byte *data, size_t size,
4082 struct objfile *objfile, unsigned int addr_size,
4083 int offset_size, struct dwarf2_per_cu_data *per_cu)
4085 const gdb_byte *end = data + size;
4086 int first_piece = 1, bad = 0;
4090 const gdb_byte *here = data;
4091 int disassemble = 1;
4096 fprintf_filtered (stream, _(", and "));
4098 if (!dwarf2_always_disassemble)
4100 data = locexpr_describe_location_piece (symbol, stream,
4101 addr, objfile, per_cu,
4102 data, end, addr_size);
4103 /* If we printed anything, or if we have an empty piece,
4104 then don't disassemble. */
4106 || data[0] == DW_OP_piece
4107 || data[0] == DW_OP_bit_piece)
4112 fprintf_filtered (stream, _("a complex DWARF expression:\n"));
4113 data = disassemble_dwarf_expression (stream,
4114 get_objfile_arch (objfile),
4115 addr_size, offset_size, data,
4117 dwarf2_always_disassemble,
4123 int empty = data == here;
4126 fprintf_filtered (stream, " ");
4127 if (data[0] == DW_OP_piece)
4131 data = safe_read_uleb128 (data + 1, end, &bytes);
4134 fprintf_filtered (stream, _("an empty %s-byte piece"),
4137 fprintf_filtered (stream, _(" [%s-byte piece]"),
4140 else if (data[0] == DW_OP_bit_piece)
4142 uint64_t bits, offset;
4144 data = safe_read_uleb128 (data + 1, end, &bits);
4145 data = safe_read_uleb128 (data, end, &offset);
4148 fprintf_filtered (stream,
4149 _("an empty %s-bit piece"),
4152 fprintf_filtered (stream,
4153 _(" [%s-bit piece, offset %s bits]"),
4154 pulongest (bits), pulongest (offset));
4164 if (bad || data > end)
4165 error (_("Corrupted DWARF2 expression for \"%s\"."),
4166 SYMBOL_PRINT_NAME (symbol));
4169 /* Print a natural-language description of SYMBOL to STREAM. This
4170 version is for a symbol with a single location. */
4173 locexpr_describe_location (struct symbol *symbol, CORE_ADDR addr,
4174 struct ui_file *stream)
4176 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4177 struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
4178 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4179 int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
4181 locexpr_describe_location_1 (symbol, addr, stream,
4182 dlbaton->data, dlbaton->size,
4183 objfile, addr_size, offset_size,
4187 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4188 any necessary bytecode in AX. */
4191 locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
4192 struct agent_expr *ax, struct axs_value *value)
4194 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4195 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4197 if (dlbaton->size == 0)
4198 value->optimized_out = 1;
4200 dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size,
4201 dlbaton->data, dlbaton->data + dlbaton->size,
4205 /* The set of location functions used with the DWARF-2 expression
4207 const struct symbol_computed_ops dwarf2_locexpr_funcs = {
4208 locexpr_read_variable,
4209 locexpr_read_variable_at_entry,
4210 locexpr_read_needs_frame,
4211 locexpr_describe_location,
4212 0, /* location_has_loclist */
4213 locexpr_tracepoint_var_ref
4217 /* Wrapper functions for location lists. These generally find
4218 the appropriate location expression and call something above. */
4220 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4221 evaluator to calculate the location. */
4222 static struct value *
4223 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
4225 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4227 const gdb_byte *data;
4229 CORE_ADDR pc = frame ? get_frame_address_in_block (frame) : 0;
4231 data = dwarf2_find_location_expression (dlbaton, &size, pc);
4232 val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, data, size,
4238 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4239 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4242 Function always returns non-NULL value, it may be marked optimized out if
4243 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4244 if it cannot resolve the parameter for any reason. */
4246 static struct value *
4247 loclist_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
4249 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4250 const gdb_byte *data;
4254 if (frame == NULL || !get_frame_func_if_available (frame, &pc))
4255 return allocate_optimized_out_value (SYMBOL_TYPE (symbol));
4257 data = dwarf2_find_location_expression (dlbaton, &size, pc);
4259 return allocate_optimized_out_value (SYMBOL_TYPE (symbol));
4261 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, data, size);
4264 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
4266 loclist_read_needs_frame (struct symbol *symbol)
4268 /* If there's a location list, then assume we need to have a frame
4269 to choose the appropriate location expression. With tracking of
4270 global variables this is not necessarily true, but such tracking
4271 is disabled in GCC at the moment until we figure out how to
4277 /* Print a natural-language description of SYMBOL to STREAM. This
4278 version applies when there is a list of different locations, each
4279 with a specified address range. */
4282 loclist_describe_location (struct symbol *symbol, CORE_ADDR addr,
4283 struct ui_file *stream)
4285 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4286 const gdb_byte *loc_ptr, *buf_end;
4287 struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
4288 struct gdbarch *gdbarch = get_objfile_arch (objfile);
4289 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4290 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4291 int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
4292 int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
4293 /* Adjust base_address for relocatable objects. */
4294 CORE_ADDR base_offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
4295 CORE_ADDR base_address = dlbaton->base_address + base_offset;
4298 loc_ptr = dlbaton->data;
4299 buf_end = dlbaton->data + dlbaton->size;
4301 fprintf_filtered (stream, _("multi-location:\n"));
4303 /* Iterate through locations until we run out. */
4306 CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */
4308 enum debug_loc_kind kind;
4309 const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */
4311 if (dlbaton->from_dwo)
4312 kind = decode_debug_loc_dwo_addresses (dlbaton->per_cu,
4313 loc_ptr, buf_end, &new_ptr,
4314 &low, &high, byte_order);
4316 kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
4318 byte_order, addr_size,
4323 case DEBUG_LOC_END_OF_LIST:
4326 case DEBUG_LOC_BASE_ADDRESS:
4327 base_address = high + base_offset;
4328 fprintf_filtered (stream, _(" Base address %s"),
4329 paddress (gdbarch, base_address));
4331 case DEBUG_LOC_START_END:
4332 case DEBUG_LOC_START_LENGTH:
4334 case DEBUG_LOC_BUFFER_OVERFLOW:
4335 case DEBUG_LOC_INVALID_ENTRY:
4336 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4337 SYMBOL_PRINT_NAME (symbol));
4339 gdb_assert_not_reached ("bad debug_loc_kind");
4342 /* Otherwise, a location expression entry. */
4343 low += base_address;
4344 high += base_address;
4346 length = extract_unsigned_integer (loc_ptr, 2, byte_order);
4349 /* (It would improve readability to print only the minimum
4350 necessary digits of the second number of the range.) */
4351 fprintf_filtered (stream, _(" Range %s-%s: "),
4352 paddress (gdbarch, low), paddress (gdbarch, high));
4354 /* Now describe this particular location. */
4355 locexpr_describe_location_1 (symbol, low, stream, loc_ptr, length,
4356 objfile, addr_size, offset_size,
4359 fprintf_filtered (stream, "\n");
4365 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4366 any necessary bytecode in AX. */
4368 loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
4369 struct agent_expr *ax, struct axs_value *value)
4371 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4372 const gdb_byte *data;
4374 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4376 data = dwarf2_find_location_expression (dlbaton, &size, ax->scope);
4378 value->optimized_out = 1;
4380 dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size, data, data + size,
4384 /* The set of location functions used with the DWARF-2 expression
4385 evaluator and location lists. */
4386 const struct symbol_computed_ops dwarf2_loclist_funcs = {
4387 loclist_read_variable,
4388 loclist_read_variable_at_entry,
4389 loclist_read_needs_frame,
4390 loclist_describe_location,
4391 1, /* location_has_loclist */
4392 loclist_tracepoint_var_ref
4395 /* Provide a prototype to silence -Wmissing-prototypes. */
4396 extern initialize_file_ftype _initialize_dwarf2loc;
4399 _initialize_dwarf2loc (void)
4401 add_setshow_zuinteger_cmd ("entry-values", class_maintenance,
4402 &entry_values_debug,
4403 _("Set entry values and tail call frames "
4405 _("Show entry values and tail call frames "
4407 _("When non-zero, the process of determining "
4408 "parameter values from function entry point "
4409 "and tail call frames will be printed."),
4411 show_entry_values_debug,
4412 &setdebuglist, &showdebuglist);