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;
308 /* Helper functions for dwarf2_evaluate_loc_desc. */
310 /* Using the frame specified in BATON, return the value of register
311 REGNUM, treated as a pointer. */
313 dwarf_expr_read_addr_from_reg (void *baton, int dwarf_regnum)
315 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
316 struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
317 int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
319 return address_from_register (regnum, debaton->frame);
322 /* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback. */
324 static struct value *
325 dwarf_expr_get_reg_value (void *baton, struct type *type, int dwarf_regnum)
327 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
328 struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
329 int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
331 return value_from_register (type, regnum, debaton->frame);
334 /* Read memory at ADDR (length LEN) into BUF. */
337 dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
339 read_memory (addr, buf, len);
342 /* Using the frame specified in BATON, find the location expression
343 describing the frame base. Return a pointer to it in START and
344 its length in LENGTH. */
346 dwarf_expr_frame_base (void *baton, const gdb_byte **start, size_t * length)
348 /* FIXME: cagney/2003-03-26: This code should be using
349 get_frame_base_address(), and then implement a dwarf2 specific
351 struct symbol *framefunc;
352 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
353 const struct block *bl = get_frame_block (debaton->frame, NULL);
356 error (_("frame address is not available."));
358 /* Use block_linkage_function, which returns a real (not inlined)
359 function, instead of get_frame_function, which may return an
361 framefunc = block_linkage_function (bl);
363 /* If we found a frame-relative symbol then it was certainly within
364 some function associated with a frame. If we can't find the frame,
365 something has gone wrong. */
366 gdb_assert (framefunc != NULL);
368 dwarf_expr_frame_base_1 (framefunc,
369 get_frame_address_in_block (debaton->frame),
373 /* Implement find_frame_base_location method for LOC_BLOCK functions using
374 DWARF expression for its DW_AT_frame_base. */
377 locexpr_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc,
378 const gdb_byte **start, size_t *length)
380 struct dwarf2_locexpr_baton *symbaton = SYMBOL_LOCATION_BATON (framefunc);
382 *length = symbaton->size;
383 *start = symbaton->data;
386 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
387 function uses DWARF expression for its DW_AT_frame_base. */
389 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs =
391 locexpr_find_frame_base_location
394 /* Implement find_frame_base_location method for LOC_BLOCK functions using
395 DWARF location list for its DW_AT_frame_base. */
398 loclist_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc,
399 const gdb_byte **start, size_t *length)
401 struct dwarf2_loclist_baton *symbaton = SYMBOL_LOCATION_BATON (framefunc);
403 *start = dwarf2_find_location_expression (symbaton, length, pc);
406 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
407 function uses DWARF location list for its DW_AT_frame_base. */
409 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs =
411 loclist_find_frame_base_location
415 dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
416 const gdb_byte **start, size_t *length)
418 if (SYMBOL_BLOCK_OPS (framefunc) != NULL)
420 const struct symbol_block_ops *ops_block = SYMBOL_BLOCK_OPS (framefunc);
422 ops_block->find_frame_base_location (framefunc, pc, start, length);
428 error (_("Could not find the frame base for \"%s\"."),
429 SYMBOL_NATURAL_NAME (framefunc));
432 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
433 the frame in BATON. */
436 dwarf_expr_frame_cfa (void *baton)
438 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
440 return dwarf2_frame_cfa (debaton->frame);
443 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
444 the frame in BATON. */
447 dwarf_expr_frame_pc (void *baton)
449 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
451 return get_frame_address_in_block (debaton->frame);
454 /* Using the objfile specified in BATON, find the address for the
455 current thread's thread-local storage with offset OFFSET. */
457 dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
459 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
460 struct objfile *objfile = dwarf2_per_cu_objfile (debaton->per_cu);
462 return target_translate_tls_address (objfile, offset);
465 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
466 current CU (as is PER_CU). State of the CTX is not affected by the
470 per_cu_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset,
471 struct dwarf2_per_cu_data *per_cu,
472 CORE_ADDR (*get_frame_pc) (void *baton),
475 struct dwarf2_locexpr_baton block;
477 block = dwarf2_fetch_die_loc_cu_off (die_offset, per_cu, get_frame_pc, baton);
479 /* DW_OP_call_ref is currently not supported. */
480 gdb_assert (block.per_cu == per_cu);
482 dwarf_expr_eval (ctx, block.data, block.size);
485 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
488 dwarf_expr_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
490 struct dwarf_expr_baton *debaton = ctx->baton;
492 per_cu_dwarf_call (ctx, die_offset, debaton->per_cu,
493 ctx->funcs->get_frame_pc, ctx->baton);
496 /* Callback function for dwarf2_evaluate_loc_desc. */
499 dwarf_expr_get_base_type (struct dwarf_expr_context *ctx,
500 cu_offset die_offset)
502 struct dwarf_expr_baton *debaton = ctx->baton;
504 return dwarf2_get_die_type (die_offset, debaton->per_cu);
507 /* See dwarf2loc.h. */
509 unsigned int entry_values_debug = 0;
511 /* Helper to set entry_values_debug. */
514 show_entry_values_debug (struct ui_file *file, int from_tty,
515 struct cmd_list_element *c, const char *value)
517 fprintf_filtered (file,
518 _("Entry values and tail call frames debugging is %s.\n"),
522 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
523 CALLER_FRAME (for registers) can be NULL if it is not known. This function
524 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
527 call_site_to_target_addr (struct gdbarch *call_site_gdbarch,
528 struct call_site *call_site,
529 struct frame_info *caller_frame)
531 switch (FIELD_LOC_KIND (call_site->target))
533 case FIELD_LOC_KIND_DWARF_BLOCK:
535 struct dwarf2_locexpr_baton *dwarf_block;
537 struct type *caller_core_addr_type;
538 struct gdbarch *caller_arch;
540 dwarf_block = FIELD_DWARF_BLOCK (call_site->target);
541 if (dwarf_block == NULL)
543 struct bound_minimal_symbol msym;
545 msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
546 throw_error (NO_ENTRY_VALUE_ERROR,
547 _("DW_AT_GNU_call_site_target is not specified "
549 paddress (call_site_gdbarch, call_site->pc),
550 (msym.minsym == NULL ? "???"
551 : MSYMBOL_PRINT_NAME (msym.minsym)));
554 if (caller_frame == NULL)
556 struct bound_minimal_symbol msym;
558 msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
559 throw_error (NO_ENTRY_VALUE_ERROR,
560 _("DW_AT_GNU_call_site_target DWARF block resolving "
561 "requires known frame which is currently not "
562 "available at %s in %s"),
563 paddress (call_site_gdbarch, call_site->pc),
564 (msym.minsym == NULL ? "???"
565 : MSYMBOL_PRINT_NAME (msym.minsym)));
568 caller_arch = get_frame_arch (caller_frame);
569 caller_core_addr_type = builtin_type (caller_arch)->builtin_func_ptr;
570 val = dwarf2_evaluate_loc_desc (caller_core_addr_type, caller_frame,
571 dwarf_block->data, dwarf_block->size,
572 dwarf_block->per_cu);
573 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
575 if (VALUE_LVAL (val) == lval_memory)
576 return value_address (val);
578 return value_as_address (val);
581 case FIELD_LOC_KIND_PHYSNAME:
583 const char *physname;
584 struct bound_minimal_symbol msym;
586 physname = FIELD_STATIC_PHYSNAME (call_site->target);
588 /* Handle both the mangled and demangled PHYSNAME. */
589 msym = lookup_minimal_symbol (physname, NULL, NULL);
590 if (msym.minsym == NULL)
592 msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
593 throw_error (NO_ENTRY_VALUE_ERROR,
594 _("Cannot find function \"%s\" for a call site target "
596 physname, paddress (call_site_gdbarch, call_site->pc),
597 (msym.minsym == NULL ? "???"
598 : MSYMBOL_PRINT_NAME (msym.minsym)));
601 return BMSYMBOL_VALUE_ADDRESS (msym);
604 case FIELD_LOC_KIND_PHYSADDR:
605 return FIELD_STATIC_PHYSADDR (call_site->target);
608 internal_error (__FILE__, __LINE__, _("invalid call site target kind"));
612 /* Convert function entry point exact address ADDR to the function which is
613 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
614 NO_ENTRY_VALUE_ERROR otherwise. */
616 static struct symbol *
617 func_addr_to_tail_call_list (struct gdbarch *gdbarch, CORE_ADDR addr)
619 struct symbol *sym = find_pc_function (addr);
622 if (sym == NULL || BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) != addr)
623 throw_error (NO_ENTRY_VALUE_ERROR,
624 _("DW_TAG_GNU_call_site resolving failed to find function "
625 "name for address %s"),
626 paddress (gdbarch, addr));
628 type = SYMBOL_TYPE (sym);
629 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FUNC);
630 gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_FUNC);
635 /* Verify function with entry point exact address ADDR can never call itself
636 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
637 can call itself via tail calls.
639 If a funtion can tail call itself its entry value based parameters are
640 unreliable. There is no verification whether the value of some/all
641 parameters is unchanged through the self tail call, we expect if there is
642 a self tail call all the parameters can be modified. */
645 func_verify_no_selftailcall (struct gdbarch *gdbarch, CORE_ADDR verify_addr)
647 struct obstack addr_obstack;
648 struct cleanup *old_chain;
651 /* Track here CORE_ADDRs which were already visited. */
654 /* The verification is completely unordered. Track here function addresses
655 which still need to be iterated. */
656 VEC (CORE_ADDR) *todo = NULL;
658 obstack_init (&addr_obstack);
659 old_chain = make_cleanup_obstack_free (&addr_obstack);
660 addr_hash = htab_create_alloc_ex (64, core_addr_hash, core_addr_eq, NULL,
661 &addr_obstack, hashtab_obstack_allocate,
663 make_cleanup_htab_delete (addr_hash);
665 make_cleanup (VEC_cleanup (CORE_ADDR), &todo);
667 VEC_safe_push (CORE_ADDR, todo, verify_addr);
668 while (!VEC_empty (CORE_ADDR, todo))
670 struct symbol *func_sym;
671 struct call_site *call_site;
673 addr = VEC_pop (CORE_ADDR, todo);
675 func_sym = func_addr_to_tail_call_list (gdbarch, addr);
677 for (call_site = TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym));
678 call_site; call_site = call_site->tail_call_next)
680 CORE_ADDR target_addr;
683 /* CALLER_FRAME with registers is not available for tail-call jumped
685 target_addr = call_site_to_target_addr (gdbarch, call_site, NULL);
687 if (target_addr == verify_addr)
689 struct bound_minimal_symbol msym;
691 msym = lookup_minimal_symbol_by_pc (verify_addr);
692 throw_error (NO_ENTRY_VALUE_ERROR,
693 _("DW_OP_GNU_entry_value resolving has found "
694 "function \"%s\" at %s can call itself via tail "
696 (msym.minsym == NULL ? "???"
697 : MSYMBOL_PRINT_NAME (msym.minsym)),
698 paddress (gdbarch, verify_addr));
701 slot = htab_find_slot (addr_hash, &target_addr, INSERT);
704 *slot = obstack_copy (&addr_obstack, &target_addr,
705 sizeof (target_addr));
706 VEC_safe_push (CORE_ADDR, todo, target_addr);
711 do_cleanups (old_chain);
714 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
715 ENTRY_VALUES_DEBUG. */
718 tailcall_dump (struct gdbarch *gdbarch, const struct call_site *call_site)
720 CORE_ADDR addr = call_site->pc;
721 struct bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (addr - 1);
723 fprintf_unfiltered (gdb_stdlog, " %s(%s)", paddress (gdbarch, addr),
724 (msym.minsym == NULL ? "???"
725 : MSYMBOL_PRINT_NAME (msym.minsym)));
729 /* vec.h needs single word type name, typedef it. */
730 typedef struct call_site *call_sitep;
732 /* Define VEC (call_sitep) functions. */
733 DEF_VEC_P (call_sitep);
735 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
736 only top callers and bottom callees which are present in both. GDBARCH is
737 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
738 no remaining possibilities to provide unambiguous non-trivial result.
739 RESULTP should point to NULL on the first (initialization) call. Caller is
740 responsible for xfree of any RESULTP data. */
743 chain_candidate (struct gdbarch *gdbarch, struct call_site_chain **resultp,
744 VEC (call_sitep) *chain)
746 struct call_site_chain *result = *resultp;
747 long length = VEC_length (call_sitep, chain);
748 int callers, callees, idx;
752 /* Create the initial chain containing all the passed PCs. */
754 result = xmalloc (sizeof (*result) + sizeof (*result->call_site)
756 result->length = length;
757 result->callers = result->callees = length;
758 if (!VEC_empty (call_sitep, chain))
759 memcpy (result->call_site, VEC_address (call_sitep, chain),
760 sizeof (*result->call_site) * length);
763 if (entry_values_debug)
765 fprintf_unfiltered (gdb_stdlog, "tailcall: initial:");
766 for (idx = 0; idx < length; idx++)
767 tailcall_dump (gdbarch, result->call_site[idx]);
768 fputc_unfiltered ('\n', gdb_stdlog);
774 if (entry_values_debug)
776 fprintf_unfiltered (gdb_stdlog, "tailcall: compare:");
777 for (idx = 0; idx < length; idx++)
778 tailcall_dump (gdbarch, VEC_index (call_sitep, chain, idx));
779 fputc_unfiltered ('\n', gdb_stdlog);
782 /* Intersect callers. */
784 callers = min (result->callers, length);
785 for (idx = 0; idx < callers; idx++)
786 if (result->call_site[idx] != VEC_index (call_sitep, chain, idx))
788 result->callers = idx;
792 /* Intersect callees. */
794 callees = min (result->callees, length);
795 for (idx = 0; idx < callees; idx++)
796 if (result->call_site[result->length - 1 - idx]
797 != VEC_index (call_sitep, chain, length - 1 - idx))
799 result->callees = idx;
803 if (entry_values_debug)
805 fprintf_unfiltered (gdb_stdlog, "tailcall: reduced:");
806 for (idx = 0; idx < result->callers; idx++)
807 tailcall_dump (gdbarch, result->call_site[idx]);
808 fputs_unfiltered (" |", gdb_stdlog);
809 for (idx = 0; idx < result->callees; idx++)
810 tailcall_dump (gdbarch, result->call_site[result->length
811 - result->callees + idx]);
812 fputc_unfiltered ('\n', gdb_stdlog);
815 if (result->callers == 0 && result->callees == 0)
817 /* There are no common callers or callees. It could be also a direct
818 call (which has length 0) with ambiguous possibility of an indirect
819 call - CALLERS == CALLEES == 0 is valid during the first allocation
820 but any subsequence processing of such entry means ambiguity. */
826 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
827 PC again. In such case there must be two different code paths to reach
828 it, therefore some of the former determined intermediate PCs must differ
829 and the unambiguous chain gets shortened. */
830 gdb_assert (result->callers + result->callees < result->length);
833 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
834 assumed frames between them use GDBARCH. Use depth first search so we can
835 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
836 would have needless GDB stack overhead. Caller is responsible for xfree of
837 the returned result. Any unreliability results in thrown
838 NO_ENTRY_VALUE_ERROR. */
840 static struct call_site_chain *
841 call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
844 CORE_ADDR save_callee_pc = callee_pc;
845 struct obstack addr_obstack;
846 struct cleanup *back_to_retval, *back_to_workdata;
847 struct call_site_chain *retval = NULL;
848 struct call_site *call_site;
850 /* Mark CALL_SITEs so we do not visit the same ones twice. */
853 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
854 call_site nor any possible call_site at CALLEE_PC's function is there.
855 Any CALL_SITE in CHAIN will be iterated to its siblings - via
856 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
857 VEC (call_sitep) *chain = NULL;
859 /* We are not interested in the specific PC inside the callee function. */
860 callee_pc = get_pc_function_start (callee_pc);
862 throw_error (NO_ENTRY_VALUE_ERROR, _("Unable to find function for PC %s"),
863 paddress (gdbarch, save_callee_pc));
865 back_to_retval = make_cleanup (free_current_contents, &retval);
867 obstack_init (&addr_obstack);
868 back_to_workdata = make_cleanup_obstack_free (&addr_obstack);
869 addr_hash = htab_create_alloc_ex (64, core_addr_hash, core_addr_eq, NULL,
870 &addr_obstack, hashtab_obstack_allocate,
872 make_cleanup_htab_delete (addr_hash);
874 make_cleanup (VEC_cleanup (call_sitep), &chain);
876 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
877 at the target's function. All the possible tail call sites in the
878 target's function will get iterated as already pushed into CHAIN via their
880 call_site = call_site_for_pc (gdbarch, caller_pc);
884 CORE_ADDR target_func_addr;
885 struct call_site *target_call_site;
887 /* CALLER_FRAME with registers is not available for tail-call jumped
889 target_func_addr = call_site_to_target_addr (gdbarch, call_site, NULL);
891 if (target_func_addr == callee_pc)
893 chain_candidate (gdbarch, &retval, chain);
897 /* There is no way to reach CALLEE_PC again as we would prevent
898 entering it twice as being already marked in ADDR_HASH. */
899 target_call_site = NULL;
903 struct symbol *target_func;
905 target_func = func_addr_to_tail_call_list (gdbarch, target_func_addr);
906 target_call_site = TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func));
911 /* Attempt to visit TARGET_CALL_SITE. */
913 if (target_call_site)
917 slot = htab_find_slot (addr_hash, &target_call_site->pc, INSERT);
920 /* Successfully entered TARGET_CALL_SITE. */
922 *slot = &target_call_site->pc;
923 VEC_safe_push (call_sitep, chain, target_call_site);
928 /* Backtrack (without revisiting the originating call_site). Try the
929 callers's sibling; if there isn't any try the callers's callers's
932 target_call_site = NULL;
933 while (!VEC_empty (call_sitep, chain))
935 call_site = VEC_pop (call_sitep, chain);
937 gdb_assert (htab_find_slot (addr_hash, &call_site->pc,
939 htab_remove_elt (addr_hash, &call_site->pc);
941 target_call_site = call_site->tail_call_next;
942 if (target_call_site)
946 while (target_call_site);
948 if (VEC_empty (call_sitep, chain))
951 call_site = VEC_last (call_sitep, chain);
956 struct bound_minimal_symbol msym_caller, msym_callee;
958 msym_caller = lookup_minimal_symbol_by_pc (caller_pc);
959 msym_callee = lookup_minimal_symbol_by_pc (callee_pc);
960 throw_error (NO_ENTRY_VALUE_ERROR,
961 _("There are no unambiguously determinable intermediate "
962 "callers or callees between caller function \"%s\" at %s "
963 "and callee function \"%s\" at %s"),
964 (msym_caller.minsym == NULL
965 ? "???" : MSYMBOL_PRINT_NAME (msym_caller.minsym)),
966 paddress (gdbarch, caller_pc),
967 (msym_callee.minsym == NULL
968 ? "???" : MSYMBOL_PRINT_NAME (msym_callee.minsym)),
969 paddress (gdbarch, callee_pc));
972 do_cleanups (back_to_workdata);
973 discard_cleanups (back_to_retval);
977 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
978 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
979 constructed return NULL. Caller is responsible for xfree of the returned
982 struct call_site_chain *
983 call_site_find_chain (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
986 volatile struct gdb_exception e;
987 struct call_site_chain *retval = NULL;
989 TRY_CATCH (e, RETURN_MASK_ERROR)
991 retval = call_site_find_chain_1 (gdbarch, caller_pc, callee_pc);
995 if (e.error == NO_ENTRY_VALUE_ERROR)
997 if (entry_values_debug)
998 exception_print (gdb_stdout, e);
1003 throw_exception (e);
1008 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1011 call_site_parameter_matches (struct call_site_parameter *parameter,
1012 enum call_site_parameter_kind kind,
1013 union call_site_parameter_u kind_u)
1015 if (kind == parameter->kind)
1018 case CALL_SITE_PARAMETER_DWARF_REG:
1019 return kind_u.dwarf_reg == parameter->u.dwarf_reg;
1020 case CALL_SITE_PARAMETER_FB_OFFSET:
1021 return kind_u.fb_offset == parameter->u.fb_offset;
1022 case CALL_SITE_PARAMETER_PARAM_OFFSET:
1023 return kind_u.param_offset.cu_off == parameter->u.param_offset.cu_off;
1028 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1029 FRAME is for callee.
1031 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1034 static struct call_site_parameter *
1035 dwarf_expr_reg_to_entry_parameter (struct frame_info *frame,
1036 enum call_site_parameter_kind kind,
1037 union call_site_parameter_u kind_u,
1038 struct dwarf2_per_cu_data **per_cu_return)
1040 CORE_ADDR func_addr, caller_pc;
1041 struct gdbarch *gdbarch;
1042 struct frame_info *caller_frame;
1043 struct call_site *call_site;
1045 /* Initialize it just to avoid a GCC false warning. */
1046 struct call_site_parameter *parameter = NULL;
1047 CORE_ADDR target_addr;
1049 while (get_frame_type (frame) == INLINE_FRAME)
1051 frame = get_prev_frame (frame);
1052 gdb_assert (frame != NULL);
1055 func_addr = get_frame_func (frame);
1056 gdbarch = get_frame_arch (frame);
1057 caller_frame = get_prev_frame (frame);
1058 if (gdbarch != frame_unwind_arch (frame))
1060 struct bound_minimal_symbol msym
1061 = lookup_minimal_symbol_by_pc (func_addr);
1062 struct gdbarch *caller_gdbarch = frame_unwind_arch (frame);
1064 throw_error (NO_ENTRY_VALUE_ERROR,
1065 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1066 "(of %s (%s)) does not match caller gdbarch %s"),
1067 gdbarch_bfd_arch_info (gdbarch)->printable_name,
1068 paddress (gdbarch, func_addr),
1069 (msym.minsym == NULL ? "???"
1070 : MSYMBOL_PRINT_NAME (msym.minsym)),
1071 gdbarch_bfd_arch_info (caller_gdbarch)->printable_name);
1074 if (caller_frame == NULL)
1076 struct bound_minimal_symbol msym
1077 = lookup_minimal_symbol_by_pc (func_addr);
1079 throw_error (NO_ENTRY_VALUE_ERROR, _("DW_OP_GNU_entry_value resolving "
1080 "requires caller of %s (%s)"),
1081 paddress (gdbarch, func_addr),
1082 (msym.minsym == NULL ? "???"
1083 : MSYMBOL_PRINT_NAME (msym.minsym)));
1085 caller_pc = get_frame_pc (caller_frame);
1086 call_site = call_site_for_pc (gdbarch, caller_pc);
1088 target_addr = call_site_to_target_addr (gdbarch, call_site, caller_frame);
1089 if (target_addr != func_addr)
1091 struct minimal_symbol *target_msym, *func_msym;
1093 target_msym = lookup_minimal_symbol_by_pc (target_addr).minsym;
1094 func_msym = lookup_minimal_symbol_by_pc (func_addr).minsym;
1095 throw_error (NO_ENTRY_VALUE_ERROR,
1096 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1097 "but the called frame is for %s at %s"),
1098 (target_msym == NULL ? "???"
1099 : MSYMBOL_PRINT_NAME (target_msym)),
1100 paddress (gdbarch, target_addr),
1101 func_msym == NULL ? "???" : MSYMBOL_PRINT_NAME (func_msym),
1102 paddress (gdbarch, func_addr));
1105 /* No entry value based parameters would be reliable if this function can
1106 call itself via tail calls. */
1107 func_verify_no_selftailcall (gdbarch, func_addr);
1109 for (iparams = 0; iparams < call_site->parameter_count; iparams++)
1111 parameter = &call_site->parameter[iparams];
1112 if (call_site_parameter_matches (parameter, kind, kind_u))
1115 if (iparams == call_site->parameter_count)
1117 struct minimal_symbol *msym
1118 = lookup_minimal_symbol_by_pc (caller_pc).minsym;
1120 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1121 determine its value. */
1122 throw_error (NO_ENTRY_VALUE_ERROR, _("Cannot find matching parameter "
1123 "at DW_TAG_GNU_call_site %s at %s"),
1124 paddress (gdbarch, caller_pc),
1125 msym == NULL ? "???" : MSYMBOL_PRINT_NAME (msym));
1128 *per_cu_return = call_site->per_cu;
1132 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1133 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1134 DW_AT_GNU_call_site_data_value (dereferenced) block.
1136 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1139 Function always returns non-NULL, non-optimized out value. It throws
1140 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1142 static struct value *
1143 dwarf_entry_parameter_to_value (struct call_site_parameter *parameter,
1144 CORE_ADDR deref_size, struct type *type,
1145 struct frame_info *caller_frame,
1146 struct dwarf2_per_cu_data *per_cu)
1148 const gdb_byte *data_src;
1152 data_src = deref_size == -1 ? parameter->value : parameter->data_value;
1153 size = deref_size == -1 ? parameter->value_size : parameter->data_value_size;
1155 /* DEREF_SIZE size is not verified here. */
1156 if (data_src == NULL)
1157 throw_error (NO_ENTRY_VALUE_ERROR,
1158 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1160 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1161 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1163 data = alloca (size + 1);
1164 memcpy (data, data_src, size);
1165 data[size] = DW_OP_stack_value;
1167 return dwarf2_evaluate_loc_desc (type, caller_frame, data, size + 1, per_cu);
1170 /* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
1171 Choose DEREF_SIZE value of that parameter. Search caller of the CTX's
1172 frame. CTX must be of dwarf_expr_ctx_funcs kind.
1174 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1175 can be more simple as it does not support cross-CU DWARF executions. */
1178 dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
1179 enum call_site_parameter_kind kind,
1180 union call_site_parameter_u kind_u,
1183 struct dwarf_expr_baton *debaton;
1184 struct frame_info *frame, *caller_frame;
1185 struct dwarf2_per_cu_data *caller_per_cu;
1186 struct dwarf_expr_baton baton_local;
1187 struct dwarf_expr_context saved_ctx;
1188 struct call_site_parameter *parameter;
1189 const gdb_byte *data_src;
1192 gdb_assert (ctx->funcs == &dwarf_expr_ctx_funcs);
1193 debaton = ctx->baton;
1194 frame = debaton->frame;
1195 caller_frame = get_prev_frame (frame);
1197 parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u,
1199 data_src = deref_size == -1 ? parameter->value : parameter->data_value;
1200 size = deref_size == -1 ? parameter->value_size : parameter->data_value_size;
1202 /* DEREF_SIZE size is not verified here. */
1203 if (data_src == NULL)
1204 throw_error (NO_ENTRY_VALUE_ERROR,
1205 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1207 baton_local.frame = caller_frame;
1208 baton_local.per_cu = caller_per_cu;
1210 saved_ctx.gdbarch = ctx->gdbarch;
1211 saved_ctx.addr_size = ctx->addr_size;
1212 saved_ctx.offset = ctx->offset;
1213 saved_ctx.baton = ctx->baton;
1214 ctx->gdbarch = get_objfile_arch (dwarf2_per_cu_objfile (baton_local.per_cu));
1215 ctx->addr_size = dwarf2_per_cu_addr_size (baton_local.per_cu);
1216 ctx->offset = dwarf2_per_cu_text_offset (baton_local.per_cu);
1217 ctx->baton = &baton_local;
1219 dwarf_expr_eval (ctx, data_src, size);
1221 ctx->gdbarch = saved_ctx.gdbarch;
1222 ctx->addr_size = saved_ctx.addr_size;
1223 ctx->offset = saved_ctx.offset;
1224 ctx->baton = saved_ctx.baton;
1227 /* Callback function for dwarf2_evaluate_loc_desc.
1228 Fetch the address indexed by DW_OP_GNU_addr_index. */
1231 dwarf_expr_get_addr_index (void *baton, unsigned int index)
1233 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
1235 return dwarf2_read_addr_index (debaton->per_cu, index);
1238 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1239 the indirect method on it, that is use its stored target value, the sole
1240 purpose of entry_data_value_funcs.. */
1242 static struct value *
1243 entry_data_value_coerce_ref (const struct value *value)
1245 struct type *checked_type = check_typedef (value_type (value));
1246 struct value *target_val;
1248 if (TYPE_CODE (checked_type) != TYPE_CODE_REF)
1251 target_val = value_computed_closure (value);
1252 value_incref (target_val);
1256 /* Implement copy_closure. */
1259 entry_data_value_copy_closure (const struct value *v)
1261 struct value *target_val = value_computed_closure (v);
1263 value_incref (target_val);
1267 /* Implement free_closure. */
1270 entry_data_value_free_closure (struct value *v)
1272 struct value *target_val = value_computed_closure (v);
1274 value_free (target_val);
1277 /* Vector for methods for an entry value reference where the referenced value
1278 is stored in the caller. On the first dereference use
1279 DW_AT_GNU_call_site_data_value in the caller. */
1281 static const struct lval_funcs entry_data_value_funcs =
1285 NULL, /* check_validity */
1286 NULL, /* check_any_valid */
1287 NULL, /* indirect */
1288 entry_data_value_coerce_ref,
1289 NULL, /* check_synthetic_pointer */
1290 entry_data_value_copy_closure,
1291 entry_data_value_free_closure
1294 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1295 are used to match DW_AT_location at the caller's
1296 DW_TAG_GNU_call_site_parameter.
1298 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1299 cannot resolve the parameter for any reason. */
1301 static struct value *
1302 value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame,
1303 enum call_site_parameter_kind kind,
1304 union call_site_parameter_u kind_u)
1306 struct type *checked_type = check_typedef (type);
1307 struct type *target_type = TYPE_TARGET_TYPE (checked_type);
1308 struct frame_info *caller_frame = get_prev_frame (frame);
1309 struct value *outer_val, *target_val, *val;
1310 struct call_site_parameter *parameter;
1311 struct dwarf2_per_cu_data *caller_per_cu;
1313 parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u,
1316 outer_val = dwarf_entry_parameter_to_value (parameter, -1 /* deref_size */,
1320 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1321 used and it is not available do not fall back to OUTER_VAL - dereferencing
1322 TYPE_CODE_REF with non-entry data value would give current value - not the
1325 if (TYPE_CODE (checked_type) != TYPE_CODE_REF
1326 || TYPE_TARGET_TYPE (checked_type) == NULL)
1329 target_val = dwarf_entry_parameter_to_value (parameter,
1330 TYPE_LENGTH (target_type),
1331 target_type, caller_frame,
1334 release_value (target_val);
1335 val = allocate_computed_value (type, &entry_data_value_funcs,
1336 target_val /* closure */);
1338 /* Copy the referencing pointer to the new computed value. */
1339 memcpy (value_contents_raw (val), value_contents_raw (outer_val),
1340 TYPE_LENGTH (checked_type));
1341 set_value_lazy (val, 0);
1346 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1347 SIZE are DWARF block used to match DW_AT_location at the caller's
1348 DW_TAG_GNU_call_site_parameter.
1350 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1351 cannot resolve the parameter for any reason. */
1353 static struct value *
1354 value_of_dwarf_block_entry (struct type *type, struct frame_info *frame,
1355 const gdb_byte *block, size_t block_len)
1357 union call_site_parameter_u kind_u;
1359 kind_u.dwarf_reg = dwarf_block_to_dwarf_reg (block, block + block_len);
1360 if (kind_u.dwarf_reg != -1)
1361 return value_of_dwarf_reg_entry (type, frame, CALL_SITE_PARAMETER_DWARF_REG,
1364 if (dwarf_block_to_fb_offset (block, block + block_len, &kind_u.fb_offset))
1365 return value_of_dwarf_reg_entry (type, frame, CALL_SITE_PARAMETER_FB_OFFSET,
1368 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1369 suppressed during normal operation. The expression can be arbitrary if
1370 there is no caller-callee entry value binding expected. */
1371 throw_error (NO_ENTRY_VALUE_ERROR,
1372 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1373 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1376 struct piece_closure
1378 /* Reference count. */
1381 /* The CU from which this closure's expression came. */
1382 struct dwarf2_per_cu_data *per_cu;
1384 /* The number of pieces used to describe this variable. */
1387 /* The target address size, used only for DWARF_VALUE_STACK. */
1390 /* The pieces themselves. */
1391 struct dwarf_expr_piece *pieces;
1394 /* Allocate a closure for a value formed from separately-described
1397 static struct piece_closure *
1398 allocate_piece_closure (struct dwarf2_per_cu_data *per_cu,
1399 int n_pieces, struct dwarf_expr_piece *pieces,
1402 struct piece_closure *c = XCNEW (struct piece_closure);
1407 c->n_pieces = n_pieces;
1408 c->addr_size = addr_size;
1409 c->pieces = XCNEWVEC (struct dwarf_expr_piece, n_pieces);
1411 memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
1412 for (i = 0; i < n_pieces; ++i)
1413 if (c->pieces[i].location == DWARF_VALUE_STACK)
1414 value_incref (c->pieces[i].v.value);
1419 /* The lowest-level function to extract bits from a byte buffer.
1420 SOURCE is the buffer. It is updated if we read to the end of a
1422 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1423 updated to reflect the number of bits actually read.
1424 NBITS is the number of bits we want to read. It is updated to
1425 reflect the number of bits actually read. This function may read
1427 BITS_BIG_ENDIAN is taken directly from gdbarch.
1428 This function returns the extracted bits. */
1431 extract_bits_primitive (const gdb_byte **source,
1432 unsigned int *source_offset_bits,
1433 int *nbits, int bits_big_endian)
1435 unsigned int avail, mask, datum;
1437 gdb_assert (*source_offset_bits < 8);
1439 avail = 8 - *source_offset_bits;
1443 mask = (1 << avail) - 1;
1445 if (bits_big_endian)
1446 datum >>= 8 - (*source_offset_bits + *nbits);
1448 datum >>= *source_offset_bits;
1452 *source_offset_bits += avail;
1453 if (*source_offset_bits >= 8)
1455 *source_offset_bits -= 8;
1462 /* Extract some bits from a source buffer and move forward in the
1465 SOURCE is the source buffer. It is updated as bytes are read.
1466 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1468 NBITS is the number of bits to read.
1469 BITS_BIG_ENDIAN is taken directly from gdbarch.
1471 This function returns the bits that were read. */
1474 extract_bits (const gdb_byte **source, unsigned int *source_offset_bits,
1475 int nbits, int bits_big_endian)
1479 gdb_assert (nbits > 0 && nbits <= 8);
1481 datum = extract_bits_primitive (source, source_offset_bits, &nbits,
1487 more = extract_bits_primitive (source, source_offset_bits, &nbits,
1489 if (bits_big_endian)
1499 /* Write some bits into a buffer and move forward in the buffer.
1501 DATUM is the bits to write. The low-order bits of DATUM are used.
1502 DEST is the destination buffer. It is updated as bytes are
1504 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1506 NBITS is the number of valid bits in DATUM.
1507 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1510 insert_bits (unsigned int datum,
1511 gdb_byte *dest, unsigned int dest_offset_bits,
1512 int nbits, int bits_big_endian)
1516 gdb_assert (dest_offset_bits + nbits <= 8);
1518 mask = (1 << nbits) - 1;
1519 if (bits_big_endian)
1521 datum <<= 8 - (dest_offset_bits + nbits);
1522 mask <<= 8 - (dest_offset_bits + nbits);
1526 datum <<= dest_offset_bits;
1527 mask <<= dest_offset_bits;
1530 gdb_assert ((datum & ~mask) == 0);
1532 *dest = (*dest & ~mask) | datum;
1535 /* Copy bits from a source to a destination.
1537 DEST is where the bits should be written.
1538 DEST_OFFSET_BITS is the bit offset into DEST.
1539 SOURCE is the source of bits.
1540 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1541 BIT_COUNT is the number of bits to copy.
1542 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1545 copy_bitwise (gdb_byte *dest, unsigned int dest_offset_bits,
1546 const gdb_byte *source, unsigned int source_offset_bits,
1547 unsigned int bit_count,
1548 int bits_big_endian)
1550 unsigned int dest_avail;
1553 /* Reduce everything to byte-size pieces. */
1554 dest += dest_offset_bits / 8;
1555 dest_offset_bits %= 8;
1556 source += source_offset_bits / 8;
1557 source_offset_bits %= 8;
1559 dest_avail = 8 - dest_offset_bits % 8;
1561 /* See if we can fill the first destination byte. */
1562 if (dest_avail < bit_count)
1564 datum = extract_bits (&source, &source_offset_bits, dest_avail,
1566 insert_bits (datum, dest, dest_offset_bits, dest_avail, bits_big_endian);
1568 dest_offset_bits = 0;
1569 bit_count -= dest_avail;
1572 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1573 than 8 bits remaining. */
1574 gdb_assert (dest_offset_bits % 8 == 0 || bit_count < 8);
1575 for (; bit_count >= 8; bit_count -= 8)
1577 datum = extract_bits (&source, &source_offset_bits, 8, bits_big_endian);
1578 *dest++ = (gdb_byte) datum;
1581 /* Finally, we may have a few leftover bits. */
1582 gdb_assert (bit_count <= 8 - dest_offset_bits % 8);
1585 datum = extract_bits (&source, &source_offset_bits, bit_count,
1587 insert_bits (datum, dest, dest_offset_bits, bit_count, bits_big_endian);
1592 read_pieced_value (struct value *v)
1596 ULONGEST bits_to_skip;
1598 struct piece_closure *c
1599 = (struct piece_closure *) value_computed_closure (v);
1600 struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
1602 size_t buffer_size = 0;
1603 gdb_byte *buffer = NULL;
1604 struct cleanup *cleanup;
1606 = gdbarch_bits_big_endian (get_type_arch (value_type (v)));
1608 if (value_type (v) != value_enclosing_type (v))
1609 internal_error (__FILE__, __LINE__,
1610 _("Should not be able to create a lazy value with "
1611 "an enclosing type"));
1613 cleanup = make_cleanup (free_current_contents, &buffer);
1615 contents = value_contents_raw (v);
1616 bits_to_skip = 8 * value_offset (v);
1617 if (value_bitsize (v))
1619 bits_to_skip += value_bitpos (v);
1620 type_len = value_bitsize (v);
1623 type_len = 8 * TYPE_LENGTH (value_type (v));
1625 for (i = 0; i < c->n_pieces && offset < type_len; i++)
1627 struct dwarf_expr_piece *p = &c->pieces[i];
1628 size_t this_size, this_size_bits;
1629 long dest_offset_bits, source_offset_bits, source_offset;
1630 const gdb_byte *intermediate_buffer;
1632 /* Compute size, source, and destination offsets for copying, in
1634 this_size_bits = p->size;
1635 if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
1637 bits_to_skip -= this_size_bits;
1640 if (bits_to_skip > 0)
1642 dest_offset_bits = 0;
1643 source_offset_bits = bits_to_skip;
1644 this_size_bits -= bits_to_skip;
1649 dest_offset_bits = offset;
1650 source_offset_bits = 0;
1652 if (this_size_bits > type_len - offset)
1653 this_size_bits = type_len - offset;
1655 this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
1656 source_offset = source_offset_bits / 8;
1657 if (buffer_size < this_size)
1659 buffer_size = this_size;
1660 buffer = xrealloc (buffer, buffer_size);
1662 intermediate_buffer = buffer;
1664 /* Copy from the source to DEST_BUFFER. */
1665 switch (p->location)
1667 case DWARF_VALUE_REGISTER:
1669 struct gdbarch *arch = get_frame_arch (frame);
1670 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
1671 int reg_offset = source_offset;
1673 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
1674 && this_size < register_size (arch, gdb_regnum))
1676 /* Big-endian, and we want less than full size. */
1677 reg_offset = register_size (arch, gdb_regnum) - this_size;
1678 /* We want the lower-order THIS_SIZE_BITS of the bytes
1679 we extract from the register. */
1680 source_offset_bits += 8 * this_size - this_size_bits;
1683 if (gdb_regnum != -1)
1687 if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
1691 /* Just so garbage doesn't ever shine through. */
1692 memset (buffer, 0, this_size);
1695 set_value_optimized_out (v, 1);
1697 mark_value_bits_unavailable (v, offset, this_size_bits);
1702 error (_("Unable to access DWARF register number %s"),
1703 paddress (arch, p->v.regno));
1708 case DWARF_VALUE_MEMORY:
1709 read_value_memory (v, offset,
1710 p->v.mem.in_stack_memory,
1711 p->v.mem.addr + source_offset,
1715 case DWARF_VALUE_STACK:
1717 size_t n = this_size;
1719 if (n > c->addr_size - source_offset)
1720 n = (c->addr_size >= source_offset
1721 ? c->addr_size - source_offset
1729 const gdb_byte *val_bytes = value_contents_all (p->v.value);
1731 intermediate_buffer = val_bytes + source_offset;
1736 case DWARF_VALUE_LITERAL:
1738 size_t n = this_size;
1740 if (n > p->v.literal.length - source_offset)
1741 n = (p->v.literal.length >= source_offset
1742 ? p->v.literal.length - source_offset
1745 intermediate_buffer = p->v.literal.data + source_offset;
1749 /* These bits show up as zeros -- but do not cause the value
1750 to be considered optimized-out. */
1751 case DWARF_VALUE_IMPLICIT_POINTER:
1754 case DWARF_VALUE_OPTIMIZED_OUT:
1755 set_value_optimized_out (v, 1);
1759 internal_error (__FILE__, __LINE__, _("invalid location type"));
1762 if (p->location != DWARF_VALUE_OPTIMIZED_OUT
1763 && p->location != DWARF_VALUE_IMPLICIT_POINTER)
1764 copy_bitwise (contents, dest_offset_bits,
1765 intermediate_buffer, source_offset_bits % 8,
1766 this_size_bits, bits_big_endian);
1768 offset += this_size_bits;
1771 do_cleanups (cleanup);
1775 write_pieced_value (struct value *to, struct value *from)
1779 ULONGEST bits_to_skip;
1780 const gdb_byte *contents;
1781 struct piece_closure *c
1782 = (struct piece_closure *) value_computed_closure (to);
1783 struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
1785 size_t buffer_size = 0;
1786 gdb_byte *buffer = NULL;
1787 struct cleanup *cleanup;
1789 = gdbarch_bits_big_endian (get_type_arch (value_type (to)));
1793 set_value_optimized_out (to, 1);
1797 cleanup = make_cleanup (free_current_contents, &buffer);
1799 contents = value_contents (from);
1800 bits_to_skip = 8 * value_offset (to);
1801 if (value_bitsize (to))
1803 bits_to_skip += value_bitpos (to);
1804 type_len = value_bitsize (to);
1807 type_len = 8 * TYPE_LENGTH (value_type (to));
1809 for (i = 0; i < c->n_pieces && offset < type_len; i++)
1811 struct dwarf_expr_piece *p = &c->pieces[i];
1812 size_t this_size_bits, this_size;
1813 long dest_offset_bits, source_offset_bits, dest_offset, source_offset;
1815 const gdb_byte *source_buffer;
1817 this_size_bits = p->size;
1818 if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
1820 bits_to_skip -= this_size_bits;
1823 if (this_size_bits > type_len - offset)
1824 this_size_bits = type_len - offset;
1825 if (bits_to_skip > 0)
1827 dest_offset_bits = bits_to_skip;
1828 source_offset_bits = 0;
1829 this_size_bits -= bits_to_skip;
1834 dest_offset_bits = 0;
1835 source_offset_bits = offset;
1838 this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
1839 source_offset = source_offset_bits / 8;
1840 dest_offset = dest_offset_bits / 8;
1841 if (dest_offset_bits % 8 == 0 && source_offset_bits % 8 == 0)
1843 source_buffer = contents + source_offset;
1848 if (buffer_size < this_size)
1850 buffer_size = this_size;
1851 buffer = xrealloc (buffer, buffer_size);
1853 source_buffer = buffer;
1857 switch (p->location)
1859 case DWARF_VALUE_REGISTER:
1861 struct gdbarch *arch = get_frame_arch (frame);
1862 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
1863 int reg_offset = dest_offset;
1865 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
1866 && this_size <= register_size (arch, gdb_regnum))
1867 /* Big-endian, and we want less than full size. */
1868 reg_offset = register_size (arch, gdb_regnum) - this_size;
1870 if (gdb_regnum != -1)
1876 if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
1881 throw_error (OPTIMIZED_OUT_ERROR,
1882 _("Can't do read-modify-write to "
1883 "update bitfield; containing word "
1884 "has been optimized out"));
1886 throw_error (NOT_AVAILABLE_ERROR,
1887 _("Can't do read-modify-write to update "
1888 "bitfield; containing word "
1891 copy_bitwise (buffer, dest_offset_bits,
1892 contents, source_offset_bits,
1897 put_frame_register_bytes (frame, gdb_regnum, reg_offset,
1898 this_size, source_buffer);
1902 error (_("Unable to write to DWARF register number %s"),
1903 paddress (arch, p->v.regno));
1907 case DWARF_VALUE_MEMORY:
1910 /* Only the first and last bytes can possibly have any
1912 read_memory (p->v.mem.addr + dest_offset, buffer, 1);
1913 read_memory (p->v.mem.addr + dest_offset + this_size - 1,
1914 buffer + this_size - 1, 1);
1915 copy_bitwise (buffer, dest_offset_bits,
1916 contents, source_offset_bits,
1921 write_memory (p->v.mem.addr + dest_offset,
1922 source_buffer, this_size);
1925 set_value_optimized_out (to, 1);
1928 offset += this_size_bits;
1931 do_cleanups (cleanup);
1934 /* A helper function that checks bit validity in a pieced value.
1935 CHECK_FOR indicates the kind of validity checking.
1936 DWARF_VALUE_MEMORY means to check whether any bit is valid.
1937 DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
1939 DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
1940 implicit pointer. */
1943 check_pieced_value_bits (const struct value *value, int bit_offset,
1945 enum dwarf_value_location check_for)
1947 struct piece_closure *c
1948 = (struct piece_closure *) value_computed_closure (value);
1950 int validity = (check_for == DWARF_VALUE_MEMORY
1951 || check_for == DWARF_VALUE_IMPLICIT_POINTER);
1953 bit_offset += 8 * value_offset (value);
1954 if (value_bitsize (value))
1955 bit_offset += value_bitpos (value);
1957 for (i = 0; i < c->n_pieces && bit_length > 0; i++)
1959 struct dwarf_expr_piece *p = &c->pieces[i];
1960 size_t this_size_bits = p->size;
1964 if (bit_offset >= this_size_bits)
1966 bit_offset -= this_size_bits;
1970 bit_length -= this_size_bits - bit_offset;
1974 bit_length -= this_size_bits;
1976 if (check_for == DWARF_VALUE_IMPLICIT_POINTER)
1978 if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
1981 else if (p->location == DWARF_VALUE_OPTIMIZED_OUT
1982 || p->location == DWARF_VALUE_IMPLICIT_POINTER)
1998 check_pieced_value_validity (const struct value *value, int bit_offset,
2001 return check_pieced_value_bits (value, bit_offset, bit_length,
2002 DWARF_VALUE_MEMORY);
2006 check_pieced_value_invalid (const struct value *value)
2008 return check_pieced_value_bits (value, 0,
2009 8 * TYPE_LENGTH (value_type (value)),
2010 DWARF_VALUE_OPTIMIZED_OUT);
2013 /* An implementation of an lval_funcs method to see whether a value is
2014 a synthetic pointer. */
2017 check_pieced_synthetic_pointer (const struct value *value, int bit_offset,
2020 return check_pieced_value_bits (value, bit_offset, bit_length,
2021 DWARF_VALUE_IMPLICIT_POINTER);
2024 /* A wrapper function for get_frame_address_in_block. */
2027 get_frame_address_in_block_wrapper (void *baton)
2029 return get_frame_address_in_block (baton);
2032 /* An implementation of an lval_funcs method to indirect through a
2033 pointer. This handles the synthetic pointer case when needed. */
2035 static struct value *
2036 indirect_pieced_value (struct value *value)
2038 struct piece_closure *c
2039 = (struct piece_closure *) value_computed_closure (value);
2041 struct frame_info *frame;
2042 struct dwarf2_locexpr_baton baton;
2043 int i, bit_offset, bit_length;
2044 struct dwarf_expr_piece *piece = NULL;
2045 LONGEST byte_offset;
2047 type = check_typedef (value_type (value));
2048 if (TYPE_CODE (type) != TYPE_CODE_PTR)
2051 bit_length = 8 * TYPE_LENGTH (type);
2052 bit_offset = 8 * value_offset (value);
2053 if (value_bitsize (value))
2054 bit_offset += value_bitpos (value);
2056 for (i = 0; i < c->n_pieces && bit_length > 0; i++)
2058 struct dwarf_expr_piece *p = &c->pieces[i];
2059 size_t this_size_bits = p->size;
2063 if (bit_offset >= this_size_bits)
2065 bit_offset -= this_size_bits;
2069 bit_length -= this_size_bits - bit_offset;
2073 bit_length -= this_size_bits;
2075 if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
2078 if (bit_length != 0)
2079 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2085 frame = get_selected_frame (_("No frame selected."));
2087 /* This is an offset requested by GDB, such as value subscripts.
2088 However, due to how synthetic pointers are implemented, this is
2089 always presented to us as a pointer type. This means we have to
2090 sign-extend it manually as appropriate. */
2091 byte_offset = value_as_address (value);
2092 if (TYPE_LENGTH (value_type (value)) < sizeof (LONGEST))
2093 byte_offset = gdb_sign_extend (byte_offset,
2094 8 * TYPE_LENGTH (value_type (value)));
2095 byte_offset += piece->v.ptr.offset;
2099 = dwarf2_fetch_die_loc_sect_off (piece->v.ptr.die, c->per_cu,
2100 get_frame_address_in_block_wrapper,
2103 if (baton.data != NULL)
2104 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
2105 baton.data, baton.size, baton.per_cu,
2109 struct obstack temp_obstack;
2110 struct cleanup *cleanup;
2111 const gdb_byte *bytes;
2113 struct value *result;
2115 obstack_init (&temp_obstack);
2116 cleanup = make_cleanup_obstack_free (&temp_obstack);
2118 bytes = dwarf2_fetch_constant_bytes (piece->v.ptr.die, c->per_cu,
2119 &temp_obstack, &len);
2121 result = allocate_optimized_out_value (TYPE_TARGET_TYPE (type));
2125 || byte_offset + TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > len)
2126 invalid_synthetic_pointer ();
2127 bytes += byte_offset;
2128 result = value_from_contents (TYPE_TARGET_TYPE (type), bytes);
2131 do_cleanups (cleanup);
2137 copy_pieced_value_closure (const struct value *v)
2139 struct piece_closure *c
2140 = (struct piece_closure *) value_computed_closure (v);
2147 free_pieced_value_closure (struct value *v)
2149 struct piece_closure *c
2150 = (struct piece_closure *) value_computed_closure (v);
2157 for (i = 0; i < c->n_pieces; ++i)
2158 if (c->pieces[i].location == DWARF_VALUE_STACK)
2159 value_free (c->pieces[i].v.value);
2166 /* Functions for accessing a variable described by DW_OP_piece. */
2167 static const struct lval_funcs pieced_value_funcs = {
2170 check_pieced_value_validity,
2171 check_pieced_value_invalid,
2172 indirect_pieced_value,
2173 NULL, /* coerce_ref */
2174 check_pieced_synthetic_pointer,
2175 copy_pieced_value_closure,
2176 free_pieced_value_closure
2179 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2181 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs =
2183 dwarf_expr_read_addr_from_reg,
2184 dwarf_expr_get_reg_value,
2185 dwarf_expr_read_mem,
2186 dwarf_expr_frame_base,
2187 dwarf_expr_frame_cfa,
2188 dwarf_expr_frame_pc,
2189 dwarf_expr_tls_address,
2190 dwarf_expr_dwarf_call,
2191 dwarf_expr_get_base_type,
2192 dwarf_expr_push_dwarf_reg_entry_value,
2193 dwarf_expr_get_addr_index
2196 /* Evaluate a location description, starting at DATA and with length
2197 SIZE, to find the current location of variable of TYPE in the
2198 context of FRAME. BYTE_OFFSET is applied after the contents are
2201 static struct value *
2202 dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
2203 const gdb_byte *data, size_t size,
2204 struct dwarf2_per_cu_data *per_cu,
2205 LONGEST byte_offset)
2207 struct value *retval;
2208 struct dwarf_expr_baton baton;
2209 struct dwarf_expr_context *ctx;
2210 struct cleanup *old_chain, *value_chain;
2211 struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
2212 volatile struct gdb_exception ex;
2214 if (byte_offset < 0)
2215 invalid_synthetic_pointer ();
2218 return allocate_optimized_out_value (type);
2220 baton.frame = frame;
2221 baton.per_cu = per_cu;
2223 ctx = new_dwarf_expr_context ();
2224 old_chain = make_cleanup_free_dwarf_expr_context (ctx);
2225 value_chain = make_cleanup_value_free_to_mark (value_mark ());
2227 ctx->gdbarch = get_objfile_arch (objfile);
2228 ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
2229 ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu);
2230 ctx->offset = dwarf2_per_cu_text_offset (per_cu);
2231 ctx->baton = &baton;
2232 ctx->funcs = &dwarf_expr_ctx_funcs;
2234 TRY_CATCH (ex, RETURN_MASK_ERROR)
2236 dwarf_expr_eval (ctx, data, size);
2240 if (ex.error == NOT_AVAILABLE_ERROR)
2242 do_cleanups (old_chain);
2243 retval = allocate_value (type);
2244 mark_value_bytes_unavailable (retval, 0, TYPE_LENGTH (type));
2247 else if (ex.error == NO_ENTRY_VALUE_ERROR)
2249 if (entry_values_debug)
2250 exception_print (gdb_stdout, ex);
2251 do_cleanups (old_chain);
2252 return allocate_optimized_out_value (type);
2255 throw_exception (ex);
2258 if (ctx->num_pieces > 0)
2260 struct piece_closure *c;
2261 struct frame_id frame_id = get_frame_id (frame);
2262 ULONGEST bit_size = 0;
2265 for (i = 0; i < ctx->num_pieces; ++i)
2266 bit_size += ctx->pieces[i].size;
2267 if (8 * (byte_offset + TYPE_LENGTH (type)) > bit_size)
2268 invalid_synthetic_pointer ();
2270 c = allocate_piece_closure (per_cu, ctx->num_pieces, ctx->pieces,
2272 /* We must clean up the value chain after creating the piece
2273 closure but before allocating the result. */
2274 do_cleanups (value_chain);
2275 retval = allocate_computed_value (type, &pieced_value_funcs, c);
2276 VALUE_FRAME_ID (retval) = frame_id;
2277 set_value_offset (retval, byte_offset);
2281 switch (ctx->location)
2283 case DWARF_VALUE_REGISTER:
2285 struct gdbarch *arch = get_frame_arch (frame);
2287 = longest_to_int (value_as_long (dwarf_expr_fetch (ctx, 0)));
2288 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
2290 if (byte_offset != 0)
2291 error (_("cannot use offset on synthetic pointer to register"));
2292 do_cleanups (value_chain);
2293 if (gdb_regnum == -1)
2294 error (_("Unable to access DWARF register number %d"),
2296 retval = value_from_register (type, gdb_regnum, frame);
2297 if (value_optimized_out (retval))
2299 /* This means the register has undefined value / was
2300 not saved. As we're computing the location of some
2301 variable etc. in the program, not a value for
2302 inspecting a register ($pc, $sp, etc.), return a
2303 generic optimized out value instead, so that we show
2304 <optimized out> instead of <not saved>. */
2305 do_cleanups (value_chain);
2306 retval = allocate_optimized_out_value (type);
2311 case DWARF_VALUE_MEMORY:
2313 CORE_ADDR address = dwarf_expr_fetch_address (ctx, 0);
2314 int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
2316 do_cleanups (value_chain);
2317 retval = value_at_lazy (type, address + byte_offset);
2318 if (in_stack_memory)
2319 set_value_stack (retval, 1);
2323 case DWARF_VALUE_STACK:
2325 struct value *value = dwarf_expr_fetch (ctx, 0);
2327 const gdb_byte *val_bytes;
2328 size_t n = TYPE_LENGTH (value_type (value));
2330 if (byte_offset + TYPE_LENGTH (type) > n)
2331 invalid_synthetic_pointer ();
2333 val_bytes = value_contents_all (value);
2334 val_bytes += byte_offset;
2337 /* Preserve VALUE because we are going to free values back
2338 to the mark, but we still need the value contents
2340 value_incref (value);
2341 do_cleanups (value_chain);
2342 make_cleanup_value_free (value);
2344 retval = allocate_value (type);
2345 contents = value_contents_raw (retval);
2346 if (n > TYPE_LENGTH (type))
2348 struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
2350 if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
2351 val_bytes += n - TYPE_LENGTH (type);
2352 n = TYPE_LENGTH (type);
2354 memcpy (contents, val_bytes, n);
2358 case DWARF_VALUE_LITERAL:
2361 const bfd_byte *ldata;
2362 size_t n = ctx->len;
2364 if (byte_offset + TYPE_LENGTH (type) > n)
2365 invalid_synthetic_pointer ();
2367 do_cleanups (value_chain);
2368 retval = allocate_value (type);
2369 contents = value_contents_raw (retval);
2371 ldata = ctx->data + byte_offset;
2374 if (n > TYPE_LENGTH (type))
2376 struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
2378 if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
2379 ldata += n - TYPE_LENGTH (type);
2380 n = TYPE_LENGTH (type);
2382 memcpy (contents, ldata, n);
2386 case DWARF_VALUE_OPTIMIZED_OUT:
2387 do_cleanups (value_chain);
2388 retval = allocate_optimized_out_value (type);
2391 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2392 operation by execute_stack_op. */
2393 case DWARF_VALUE_IMPLICIT_POINTER:
2394 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2395 it can only be encountered when making a piece. */
2397 internal_error (__FILE__, __LINE__, _("invalid location type"));
2401 set_value_initialized (retval, ctx->initialized);
2403 do_cleanups (old_chain);
2408 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2409 passes 0 as the byte_offset. */
2412 dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
2413 const gdb_byte *data, size_t size,
2414 struct dwarf2_per_cu_data *per_cu)
2416 return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu, 0);
2419 /* Evaluates a dwarf expression and stores the result in VAL, expecting
2420 that the dwarf expression only produces a single CORE_ADDR. ADDR is a
2421 context (location of a variable) and might be needed to evaluate the
2422 location expression.
2423 Returns 1 on success, 0 otherwise. */
2426 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton,
2429 struct dwarf_expr_context *ctx;
2430 struct dwarf_expr_baton baton;
2431 struct objfile *objfile;
2432 struct cleanup *cleanup;
2434 if (dlbaton == NULL || dlbaton->size == 0)
2437 ctx = new_dwarf_expr_context ();
2438 cleanup = make_cleanup_free_dwarf_expr_context (ctx);
2440 baton.frame = get_selected_frame (NULL);
2441 baton.per_cu = dlbaton->per_cu;
2443 objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
2445 ctx->gdbarch = get_objfile_arch (objfile);
2446 ctx->addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
2447 ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (dlbaton->per_cu);
2448 ctx->offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
2449 ctx->funcs = &dwarf_expr_ctx_funcs;
2450 ctx->baton = &baton;
2452 dwarf_expr_eval (ctx, dlbaton->data, dlbaton->size);
2454 switch (ctx->location)
2456 case DWARF_VALUE_REGISTER:
2457 case DWARF_VALUE_MEMORY:
2458 case DWARF_VALUE_STACK:
2459 *valp = dwarf_expr_fetch_address (ctx, 0);
2460 if (ctx->location == DWARF_VALUE_REGISTER)
2461 *valp = dwarf_expr_read_addr_from_reg (&baton, *valp);
2462 do_cleanups (cleanup);
2464 case DWARF_VALUE_LITERAL:
2465 *valp = extract_signed_integer (ctx->data, ctx->len,
2466 gdbarch_byte_order (ctx->gdbarch));
2467 do_cleanups (cleanup);
2469 /* Unsupported dwarf values. */
2470 case DWARF_VALUE_OPTIMIZED_OUT:
2471 case DWARF_VALUE_IMPLICIT_POINTER:
2475 do_cleanups (cleanup);
2479 /* See dwarf2loc.h. */
2482 dwarf2_evaluate_property (const struct dynamic_prop *prop, CORE_ADDR *value)
2491 const struct dwarf2_property_baton *baton = prop->data.baton;
2493 if (dwarf2_locexpr_baton_eval (&baton->locexpr, value))
2495 if (baton->referenced_type)
2497 struct value *val = value_at (baton->referenced_type, *value);
2499 *value = value_as_address (val);
2508 struct dwarf2_property_baton *baton = prop->data.baton;
2509 struct frame_info *frame = get_selected_frame (NULL);
2510 CORE_ADDR pc = get_frame_address_in_block (frame);
2511 const gdb_byte *data;
2515 data = dwarf2_find_location_expression (&baton->loclist, &size, pc);
2518 val = dwarf2_evaluate_loc_desc (baton->referenced_type, frame, data,
2519 size, baton->loclist.per_cu);
2520 if (!value_optimized_out (val))
2522 *value = value_as_address (val);
2530 *value = prop->data.const_val;
2538 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2540 struct needs_frame_baton
2543 struct dwarf2_per_cu_data *per_cu;
2546 /* Reads from registers do require a frame. */
2548 needs_frame_read_addr_from_reg (void *baton, int regnum)
2550 struct needs_frame_baton *nf_baton = baton;
2552 nf_baton->needs_frame = 1;
2556 /* struct dwarf_expr_context_funcs' "get_reg_value" callback:
2557 Reads from registers do require a frame. */
2559 static struct value *
2560 needs_frame_get_reg_value (void *baton, struct type *type, int regnum)
2562 struct needs_frame_baton *nf_baton = baton;
2564 nf_baton->needs_frame = 1;
2565 return value_zero (type, not_lval);
2568 /* Reads from memory do not require a frame. */
2570 needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
2572 memset (buf, 0, len);
2575 /* Frame-relative accesses do require a frame. */
2577 needs_frame_frame_base (void *baton, const gdb_byte **start, size_t * length)
2579 static gdb_byte lit0 = DW_OP_lit0;
2580 struct needs_frame_baton *nf_baton = baton;
2585 nf_baton->needs_frame = 1;
2588 /* CFA accesses require a frame. */
2591 needs_frame_frame_cfa (void *baton)
2593 struct needs_frame_baton *nf_baton = baton;
2595 nf_baton->needs_frame = 1;
2599 /* Thread-local accesses do require a frame. */
2601 needs_frame_tls_address (void *baton, CORE_ADDR offset)
2603 struct needs_frame_baton *nf_baton = baton;
2605 nf_baton->needs_frame = 1;
2609 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2612 needs_frame_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
2614 struct needs_frame_baton *nf_baton = ctx->baton;
2616 per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu,
2617 ctx->funcs->get_frame_pc, ctx->baton);
2620 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2623 needs_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
2624 enum call_site_parameter_kind kind,
2625 union call_site_parameter_u kind_u, int deref_size)
2627 struct needs_frame_baton *nf_baton = ctx->baton;
2629 nf_baton->needs_frame = 1;
2631 /* The expression may require some stub values on DWARF stack. */
2632 dwarf_expr_push_address (ctx, 0, 0);
2635 /* DW_OP_GNU_addr_index doesn't require a frame. */
2638 needs_get_addr_index (void *baton, unsigned int index)
2640 /* Nothing to do. */
2644 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2646 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs =
2648 needs_frame_read_addr_from_reg,
2649 needs_frame_get_reg_value,
2650 needs_frame_read_mem,
2651 needs_frame_frame_base,
2652 needs_frame_frame_cfa,
2653 needs_frame_frame_cfa, /* get_frame_pc */
2654 needs_frame_tls_address,
2655 needs_frame_dwarf_call,
2656 NULL, /* get_base_type */
2657 needs_dwarf_reg_entry_value,
2658 needs_get_addr_index
2661 /* Return non-zero iff the location expression at DATA (length SIZE)
2662 requires a frame to evaluate. */
2665 dwarf2_loc_desc_needs_frame (const gdb_byte *data, size_t size,
2666 struct dwarf2_per_cu_data *per_cu)
2668 struct needs_frame_baton baton;
2669 struct dwarf_expr_context *ctx;
2671 struct cleanup *old_chain;
2672 struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
2674 baton.needs_frame = 0;
2675 baton.per_cu = per_cu;
2677 ctx = new_dwarf_expr_context ();
2678 old_chain = make_cleanup_free_dwarf_expr_context (ctx);
2679 make_cleanup_value_free_to_mark (value_mark ());
2681 ctx->gdbarch = get_objfile_arch (objfile);
2682 ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
2683 ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu);
2684 ctx->offset = dwarf2_per_cu_text_offset (per_cu);
2685 ctx->baton = &baton;
2686 ctx->funcs = &needs_frame_ctx_funcs;
2688 dwarf_expr_eval (ctx, data, size);
2690 in_reg = ctx->location == DWARF_VALUE_REGISTER;
2692 if (ctx->num_pieces > 0)
2696 /* If the location has several pieces, and any of them are in
2697 registers, then we will need a frame to fetch them from. */
2698 for (i = 0; i < ctx->num_pieces; i++)
2699 if (ctx->pieces[i].location == DWARF_VALUE_REGISTER)
2703 do_cleanups (old_chain);
2705 return baton.needs_frame || in_reg;
2708 /* A helper function that throws an unimplemented error mentioning a
2709 given DWARF operator. */
2712 unimplemented (unsigned int op)
2714 const char *name = get_DW_OP_name (op);
2717 error (_("DWARF operator %s cannot be translated to an agent expression"),
2720 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2721 "to an agent expression"),
2725 /* A helper function to convert a DWARF register to an arch register.
2726 ARCH is the architecture.
2727 DWARF_REG is the register.
2728 This will throw an exception if the DWARF register cannot be
2729 translated to an architecture register. */
2732 translate_register (struct gdbarch *arch, int dwarf_reg)
2734 int reg = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_reg);
2736 error (_("Unable to access DWARF register number %d"), dwarf_reg);
2740 /* A helper function that emits an access to memory. ARCH is the
2741 target architecture. EXPR is the expression which we are building.
2742 NBITS is the number of bits we want to read. This emits the
2743 opcodes needed to read the memory and then extract the desired
2747 access_memory (struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits)
2749 ULONGEST nbytes = (nbits + 7) / 8;
2751 gdb_assert (nbytes > 0 && nbytes <= sizeof (LONGEST));
2754 ax_trace_quick (expr, nbytes);
2757 ax_simple (expr, aop_ref8);
2758 else if (nbits <= 16)
2759 ax_simple (expr, aop_ref16);
2760 else if (nbits <= 32)
2761 ax_simple (expr, aop_ref32);
2763 ax_simple (expr, aop_ref64);
2765 /* If we read exactly the number of bytes we wanted, we're done. */
2766 if (8 * nbytes == nbits)
2769 if (gdbarch_bits_big_endian (arch))
2771 /* On a bits-big-endian machine, we want the high-order
2773 ax_const_l (expr, 8 * nbytes - nbits);
2774 ax_simple (expr, aop_rsh_unsigned);
2778 /* On a bits-little-endian box, we want the low-order NBITS. */
2779 ax_zero_ext (expr, nbits);
2783 /* A helper function to return the frame's PC. */
2786 get_ax_pc (void *baton)
2788 struct agent_expr *expr = baton;
2793 /* Compile a DWARF location expression to an agent expression.
2795 EXPR is the agent expression we are building.
2796 LOC is the agent value we modify.
2797 ARCH is the architecture.
2798 ADDR_SIZE is the size of addresses, in bytes.
2799 OP_PTR is the start of the location expression.
2800 OP_END is one past the last byte of the location expression.
2802 This will throw an exception for various kinds of errors -- for
2803 example, if the expression cannot be compiled, or if the expression
2807 dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
2808 struct gdbarch *arch, unsigned int addr_size,
2809 const gdb_byte *op_ptr, const gdb_byte *op_end,
2810 struct dwarf2_per_cu_data *per_cu)
2812 struct cleanup *cleanups;
2814 VEC(int) *dw_labels = NULL, *patches = NULL;
2815 const gdb_byte * const base = op_ptr;
2816 const gdb_byte *previous_piece = op_ptr;
2817 enum bfd_endian byte_order = gdbarch_byte_order (arch);
2818 ULONGEST bits_collected = 0;
2819 unsigned int addr_size_bits = 8 * addr_size;
2820 int bits_big_endian = gdbarch_bits_big_endian (arch);
2822 offsets = xmalloc ((op_end - op_ptr) * sizeof (int));
2823 cleanups = make_cleanup (xfree, offsets);
2825 for (i = 0; i < op_end - op_ptr; ++i)
2828 make_cleanup (VEC_cleanup (int), &dw_labels);
2829 make_cleanup (VEC_cleanup (int), &patches);
2831 /* By default we are making an address. */
2832 loc->kind = axs_lvalue_memory;
2834 while (op_ptr < op_end)
2836 enum dwarf_location_atom op = *op_ptr;
2837 uint64_t uoffset, reg;
2841 offsets[op_ptr - base] = expr->len;
2844 /* Our basic approach to code generation is to map DWARF
2845 operations directly to AX operations. However, there are
2848 First, DWARF works on address-sized units, but AX always uses
2849 LONGEST. For most operations we simply ignore this
2850 difference; instead we generate sign extensions as needed
2851 before division and comparison operations. It would be nice
2852 to omit the sign extensions, but there is no way to determine
2853 the size of the target's LONGEST. (This code uses the size
2854 of the host LONGEST in some cases -- that is a bug but it is
2857 Second, some DWARF operations cannot be translated to AX.
2858 For these we simply fail. See
2859 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2894 ax_const_l (expr, op - DW_OP_lit0);
2898 uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order);
2899 op_ptr += addr_size;
2900 /* Some versions of GCC emit DW_OP_addr before
2901 DW_OP_GNU_push_tls_address. In this case the value is an
2902 index, not an address. We don't support things like
2903 branching between the address and the TLS op. */
2904 if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
2905 uoffset += dwarf2_per_cu_text_offset (per_cu);
2906 ax_const_l (expr, uoffset);
2910 ax_const_l (expr, extract_unsigned_integer (op_ptr, 1, byte_order));
2914 ax_const_l (expr, extract_signed_integer (op_ptr, 1, byte_order));
2918 ax_const_l (expr, extract_unsigned_integer (op_ptr, 2, byte_order));
2922 ax_const_l (expr, extract_signed_integer (op_ptr, 2, byte_order));
2926 ax_const_l (expr, extract_unsigned_integer (op_ptr, 4, byte_order));
2930 ax_const_l (expr, extract_signed_integer (op_ptr, 4, byte_order));
2934 ax_const_l (expr, extract_unsigned_integer (op_ptr, 8, byte_order));
2938 ax_const_l (expr, extract_signed_integer (op_ptr, 8, byte_order));
2942 op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
2943 ax_const_l (expr, uoffset);
2946 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
2947 ax_const_l (expr, offset);
2982 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
2983 loc->u.reg = translate_register (arch, op - DW_OP_reg0);
2984 loc->kind = axs_lvalue_register;
2988 op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
2989 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
2990 loc->u.reg = translate_register (arch, reg);
2991 loc->kind = axs_lvalue_register;
2994 case DW_OP_implicit_value:
2998 op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
2999 if (op_ptr + len > op_end)
3000 error (_("DW_OP_implicit_value: too few bytes available."));
3001 if (len > sizeof (ULONGEST))
3002 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
3005 ax_const_l (expr, extract_unsigned_integer (op_ptr, len,
3008 dwarf_expr_require_composition (op_ptr, op_end,
3009 "DW_OP_implicit_value");
3011 loc->kind = axs_rvalue;
3015 case DW_OP_stack_value:
3016 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
3017 loc->kind = axs_rvalue;
3052 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
3053 i = translate_register (arch, op - DW_OP_breg0);
3057 ax_const_l (expr, offset);
3058 ax_simple (expr, aop_add);
3063 op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
3064 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
3065 i = translate_register (arch, reg);
3069 ax_const_l (expr, offset);
3070 ax_simple (expr, aop_add);
3076 const gdb_byte *datastart;
3078 const struct block *b;
3079 struct symbol *framefunc;
3081 b = block_for_pc (expr->scope);
3084 error (_("No block found for address"));
3086 framefunc = block_linkage_function (b);
3089 error (_("No function found for block"));
3091 dwarf_expr_frame_base_1 (framefunc, expr->scope,
3092 &datastart, &datalen);
3094 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
3095 dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart,
3096 datastart + datalen, per_cu);
3097 if (loc->kind == axs_lvalue_register)
3098 require_rvalue (expr, loc);
3102 ax_const_l (expr, offset);
3103 ax_simple (expr, aop_add);
3106 loc->kind = axs_lvalue_memory;
3111 ax_simple (expr, aop_dup);
3115 ax_simple (expr, aop_pop);
3120 ax_pick (expr, offset);
3124 ax_simple (expr, aop_swap);
3132 ax_simple (expr, aop_rot);
3136 case DW_OP_deref_size:
3140 if (op == DW_OP_deref_size)
3145 if (size != 1 && size != 2 && size != 4 && size != 8)
3146 error (_("Unsupported size %d in %s"),
3147 size, get_DW_OP_name (op));
3148 access_memory (arch, expr, size * TARGET_CHAR_BIT);
3153 /* Sign extend the operand. */
3154 ax_ext (expr, addr_size_bits);
3155 ax_simple (expr, aop_dup);
3156 ax_const_l (expr, 0);
3157 ax_simple (expr, aop_less_signed);
3158 ax_simple (expr, aop_log_not);
3159 i = ax_goto (expr, aop_if_goto);
3160 /* We have to emit 0 - X. */
3161 ax_const_l (expr, 0);
3162 ax_simple (expr, aop_swap);
3163 ax_simple (expr, aop_sub);
3164 ax_label (expr, i, expr->len);
3168 /* No need to sign extend here. */
3169 ax_const_l (expr, 0);
3170 ax_simple (expr, aop_swap);
3171 ax_simple (expr, aop_sub);
3175 /* Sign extend the operand. */
3176 ax_ext (expr, addr_size_bits);
3177 ax_simple (expr, aop_bit_not);
3180 case DW_OP_plus_uconst:
3181 op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
3182 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3183 but we micro-optimize anyhow. */
3186 ax_const_l (expr, reg);
3187 ax_simple (expr, aop_add);
3192 ax_simple (expr, aop_bit_and);
3196 /* Sign extend the operands. */
3197 ax_ext (expr, addr_size_bits);
3198 ax_simple (expr, aop_swap);
3199 ax_ext (expr, addr_size_bits);
3200 ax_simple (expr, aop_swap);
3201 ax_simple (expr, aop_div_signed);
3205 ax_simple (expr, aop_sub);
3209 ax_simple (expr, aop_rem_unsigned);
3213 ax_simple (expr, aop_mul);
3217 ax_simple (expr, aop_bit_or);
3221 ax_simple (expr, aop_add);
3225 ax_simple (expr, aop_lsh);
3229 ax_simple (expr, aop_rsh_unsigned);
3233 ax_simple (expr, aop_rsh_signed);
3237 ax_simple (expr, aop_bit_xor);
3241 /* Sign extend the operands. */
3242 ax_ext (expr, addr_size_bits);
3243 ax_simple (expr, aop_swap);
3244 ax_ext (expr, addr_size_bits);
3245 /* Note no swap here: A <= B is !(B < A). */
3246 ax_simple (expr, aop_less_signed);
3247 ax_simple (expr, aop_log_not);
3251 /* Sign extend the operands. */
3252 ax_ext (expr, addr_size_bits);
3253 ax_simple (expr, aop_swap);
3254 ax_ext (expr, addr_size_bits);
3255 ax_simple (expr, aop_swap);
3256 /* A >= B is !(A < B). */
3257 ax_simple (expr, aop_less_signed);
3258 ax_simple (expr, aop_log_not);
3262 /* Sign extend the operands. */
3263 ax_ext (expr, addr_size_bits);
3264 ax_simple (expr, aop_swap);
3265 ax_ext (expr, addr_size_bits);
3266 /* No need for a second swap here. */
3267 ax_simple (expr, aop_equal);
3271 /* Sign extend the operands. */
3272 ax_ext (expr, addr_size_bits);
3273 ax_simple (expr, aop_swap);
3274 ax_ext (expr, addr_size_bits);
3275 ax_simple (expr, aop_swap);
3276 ax_simple (expr, aop_less_signed);
3280 /* Sign extend the operands. */
3281 ax_ext (expr, addr_size_bits);
3282 ax_simple (expr, aop_swap);
3283 ax_ext (expr, addr_size_bits);
3284 /* Note no swap here: A > B is B < A. */
3285 ax_simple (expr, aop_less_signed);
3289 /* Sign extend the operands. */
3290 ax_ext (expr, addr_size_bits);
3291 ax_simple (expr, aop_swap);
3292 ax_ext (expr, addr_size_bits);
3293 /* No need for a swap here. */
3294 ax_simple (expr, aop_equal);
3295 ax_simple (expr, aop_log_not);
3298 case DW_OP_call_frame_cfa:
3299 dwarf2_compile_cfa_to_ax (expr, loc, arch, expr->scope, per_cu);
3300 loc->kind = axs_lvalue_memory;
3303 case DW_OP_GNU_push_tls_address:
3308 offset = extract_signed_integer (op_ptr, 2, byte_order);
3310 i = ax_goto (expr, aop_goto);
3311 VEC_safe_push (int, dw_labels, op_ptr + offset - base);
3312 VEC_safe_push (int, patches, i);
3316 offset = extract_signed_integer (op_ptr, 2, byte_order);
3318 /* Zero extend the operand. */
3319 ax_zero_ext (expr, addr_size_bits);
3320 i = ax_goto (expr, aop_if_goto);
3321 VEC_safe_push (int, dw_labels, op_ptr + offset - base);
3322 VEC_safe_push (int, patches, i);
3329 case DW_OP_bit_piece:
3331 uint64_t size, offset;
3333 if (op_ptr - 1 == previous_piece)
3334 error (_("Cannot translate empty pieces to agent expressions"));
3335 previous_piece = op_ptr - 1;
3337 op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
3338 if (op == DW_OP_piece)
3344 op_ptr = safe_read_uleb128 (op_ptr, op_end, &offset);
3346 if (bits_collected + size > 8 * sizeof (LONGEST))
3347 error (_("Expression pieces exceed word size"));
3349 /* Access the bits. */
3352 case axs_lvalue_register:
3353 ax_reg (expr, loc->u.reg);
3356 case axs_lvalue_memory:
3357 /* Offset the pointer, if needed. */
3360 ax_const_l (expr, offset / 8);
3361 ax_simple (expr, aop_add);
3364 access_memory (arch, expr, size);
3368 /* For a bits-big-endian target, shift up what we already
3369 have. For a bits-little-endian target, shift up the
3370 new data. Note that there is a potential bug here if
3371 the DWARF expression leaves multiple values on the
3373 if (bits_collected > 0)
3375 if (bits_big_endian)
3377 ax_simple (expr, aop_swap);
3378 ax_const_l (expr, size);
3379 ax_simple (expr, aop_lsh);
3380 /* We don't need a second swap here, because
3381 aop_bit_or is symmetric. */
3385 ax_const_l (expr, size);
3386 ax_simple (expr, aop_lsh);
3388 ax_simple (expr, aop_bit_or);
3391 bits_collected += size;
3392 loc->kind = axs_rvalue;
3396 case DW_OP_GNU_uninit:
3402 struct dwarf2_locexpr_baton block;
3403 int size = (op == DW_OP_call2 ? 2 : 4);
3406 uoffset = extract_unsigned_integer (op_ptr, size, byte_order);
3409 offset.cu_off = uoffset;
3410 block = dwarf2_fetch_die_loc_cu_off (offset, per_cu,
3413 /* DW_OP_call_ref is currently not supported. */
3414 gdb_assert (block.per_cu == per_cu);
3416 dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
3417 block.data, block.data + block.size,
3422 case DW_OP_call_ref:
3430 /* Patch all the branches we emitted. */
3431 for (i = 0; i < VEC_length (int, patches); ++i)
3433 int targ = offsets[VEC_index (int, dw_labels, i)];
3435 internal_error (__FILE__, __LINE__, _("invalid label"));
3436 ax_label (expr, VEC_index (int, patches, i), targ);
3439 do_cleanups (cleanups);
3443 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3444 evaluator to calculate the location. */
3445 static struct value *
3446 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
3448 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3451 val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, dlbaton->data,
3452 dlbaton->size, dlbaton->per_cu);
3457 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3458 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3461 static struct value *
3462 locexpr_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
3464 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3466 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, dlbaton->data,
3470 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3472 locexpr_read_needs_frame (struct symbol *symbol)
3474 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3476 return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
3480 /* Return true if DATA points to the end of a piece. END is one past
3481 the last byte in the expression. */
3484 piece_end_p (const gdb_byte *data, const gdb_byte *end)
3486 return data == end || data[0] == DW_OP_piece || data[0] == DW_OP_bit_piece;
3489 /* Helper for locexpr_describe_location_piece that finds the name of a
3493 locexpr_regname (struct gdbarch *gdbarch, int dwarf_regnum)
3497 regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
3498 return gdbarch_register_name (gdbarch, regnum);
3501 /* Nicely describe a single piece of a location, returning an updated
3502 position in the bytecode sequence. This function cannot recognize
3503 all locations; if a location is not recognized, it simply returns
3504 DATA. If there is an error during reading, e.g. we run off the end
3505 of the buffer, an error is thrown. */
3507 static const gdb_byte *
3508 locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
3509 CORE_ADDR addr, struct objfile *objfile,
3510 struct dwarf2_per_cu_data *per_cu,
3511 const gdb_byte *data, const gdb_byte *end,
3512 unsigned int addr_size)
3514 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3517 if (data[0] >= DW_OP_reg0 && data[0] <= DW_OP_reg31)
3519 fprintf_filtered (stream, _("a variable in $%s"),
3520 locexpr_regname (gdbarch, data[0] - DW_OP_reg0));
3523 else if (data[0] == DW_OP_regx)
3527 data = safe_read_uleb128 (data + 1, end, ®);
3528 fprintf_filtered (stream, _("a variable in $%s"),
3529 locexpr_regname (gdbarch, reg));
3531 else if (data[0] == DW_OP_fbreg)
3533 const struct block *b;
3534 struct symbol *framefunc;
3536 int64_t frame_offset;
3537 const gdb_byte *base_data, *new_data, *save_data = data;
3539 int64_t base_offset = 0;
3541 new_data = safe_read_sleb128 (data + 1, end, &frame_offset);
3542 if (!piece_end_p (new_data, end))
3546 b = block_for_pc (addr);
3549 error (_("No block found for address for symbol \"%s\"."),
3550 SYMBOL_PRINT_NAME (symbol));
3552 framefunc = block_linkage_function (b);
3555 error (_("No function found for block for symbol \"%s\"."),
3556 SYMBOL_PRINT_NAME (symbol));
3558 dwarf_expr_frame_base_1 (framefunc, addr, &base_data, &base_size);
3560 if (base_data[0] >= DW_OP_breg0 && base_data[0] <= DW_OP_breg31)
3562 const gdb_byte *buf_end;
3564 frame_reg = base_data[0] - DW_OP_breg0;
3565 buf_end = safe_read_sleb128 (base_data + 1, base_data + base_size,
3567 if (buf_end != base_data + base_size)
3568 error (_("Unexpected opcode after "
3569 "DW_OP_breg%u for symbol \"%s\"."),
3570 frame_reg, SYMBOL_PRINT_NAME (symbol));
3572 else if (base_data[0] >= DW_OP_reg0 && base_data[0] <= DW_OP_reg31)
3574 /* The frame base is just the register, with no offset. */
3575 frame_reg = base_data[0] - DW_OP_reg0;
3580 /* We don't know what to do with the frame base expression,
3581 so we can't trace this variable; give up. */
3585 fprintf_filtered (stream,
3586 _("a variable at frame base reg $%s offset %s+%s"),
3587 locexpr_regname (gdbarch, frame_reg),
3588 plongest (base_offset), plongest (frame_offset));
3590 else if (data[0] >= DW_OP_breg0 && data[0] <= DW_OP_breg31
3591 && piece_end_p (data, end))
3595 data = safe_read_sleb128 (data + 1, end, &offset);
3597 fprintf_filtered (stream,
3598 _("a variable at offset %s from base reg $%s"),
3600 locexpr_regname (gdbarch, data[0] - DW_OP_breg0));
3603 /* The location expression for a TLS variable looks like this (on a
3606 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3607 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3609 0x3 is the encoding for DW_OP_addr, which has an operand as long
3610 as the size of an address on the target machine (here is 8
3611 bytes). Note that more recent version of GCC emit DW_OP_const4u
3612 or DW_OP_const8u, depending on address size, rather than
3613 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3614 The operand represents the offset at which the variable is within
3615 the thread local storage. */
3617 else if (data + 1 + addr_size < end
3618 && (data[0] == DW_OP_addr
3619 || (addr_size == 4 && data[0] == DW_OP_const4u)
3620 || (addr_size == 8 && data[0] == DW_OP_const8u))
3621 && data[1 + addr_size] == DW_OP_GNU_push_tls_address
3622 && piece_end_p (data + 2 + addr_size, end))
3625 offset = extract_unsigned_integer (data + 1, addr_size,
3626 gdbarch_byte_order (gdbarch));
3628 fprintf_filtered (stream,
3629 _("a thread-local variable at offset 0x%s "
3630 "in the thread-local storage for `%s'"),
3631 phex_nz (offset, addr_size), objfile_name (objfile));
3633 data += 1 + addr_size + 1;
3636 /* With -gsplit-dwarf a TLS variable can also look like this:
3637 DW_AT_location : 3 byte block: fc 4 e0
3638 (DW_OP_GNU_const_index: 4;
3639 DW_OP_GNU_push_tls_address) */
3640 else if (data + 3 <= end
3641 && data + 1 + (leb128_size = skip_leb128 (data + 1, end)) < end
3642 && data[0] == DW_OP_GNU_const_index
3644 && data[1 + leb128_size] == DW_OP_GNU_push_tls_address
3645 && piece_end_p (data + 2 + leb128_size, end))
3649 data = safe_read_uleb128 (data + 1, end, &offset);
3650 offset = dwarf2_read_addr_index (per_cu, offset);
3651 fprintf_filtered (stream,
3652 _("a thread-local variable at offset 0x%s "
3653 "in the thread-local storage for `%s'"),
3654 phex_nz (offset, addr_size), objfile_name (objfile));
3658 else if (data[0] >= DW_OP_lit0
3659 && data[0] <= DW_OP_lit31
3661 && data[1] == DW_OP_stack_value)
3663 fprintf_filtered (stream, _("the constant %d"), data[0] - DW_OP_lit0);
3670 /* Disassemble an expression, stopping at the end of a piece or at the
3671 end of the expression. Returns a pointer to the next unread byte
3672 in the input expression. If ALL is nonzero, then this function
3673 will keep going until it reaches the end of the expression.
3674 If there is an error during reading, e.g. we run off the end
3675 of the buffer, an error is thrown. */
3677 static const gdb_byte *
3678 disassemble_dwarf_expression (struct ui_file *stream,
3679 struct gdbarch *arch, unsigned int addr_size,
3680 int offset_size, const gdb_byte *start,
3681 const gdb_byte *data, const gdb_byte *end,
3682 int indent, int all,
3683 struct dwarf2_per_cu_data *per_cu)
3687 || (data[0] != DW_OP_piece && data[0] != DW_OP_bit_piece)))
3689 enum dwarf_location_atom op = *data++;
3694 name = get_DW_OP_name (op);
3697 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3698 op, (long) (data - 1 - start));
3699 fprintf_filtered (stream, " %*ld: %s", indent + 4,
3700 (long) (data - 1 - start), name);
3705 ul = extract_unsigned_integer (data, addr_size,
3706 gdbarch_byte_order (arch));
3708 fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size));
3712 ul = extract_unsigned_integer (data, 1, gdbarch_byte_order (arch));
3714 fprintf_filtered (stream, " %s", pulongest (ul));
3717 l = extract_signed_integer (data, 1, gdbarch_byte_order (arch));
3719 fprintf_filtered (stream, " %s", plongest (l));
3722 ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
3724 fprintf_filtered (stream, " %s", pulongest (ul));
3727 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3729 fprintf_filtered (stream, " %s", plongest (l));
3732 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
3734 fprintf_filtered (stream, " %s", pulongest (ul));
3737 l = extract_signed_integer (data, 4, gdbarch_byte_order (arch));
3739 fprintf_filtered (stream, " %s", plongest (l));
3742 ul = extract_unsigned_integer (data, 8, gdbarch_byte_order (arch));
3744 fprintf_filtered (stream, " %s", pulongest (ul));
3747 l = extract_signed_integer (data, 8, gdbarch_byte_order (arch));
3749 fprintf_filtered (stream, " %s", plongest (l));
3752 data = safe_read_uleb128 (data, end, &ul);
3753 fprintf_filtered (stream, " %s", pulongest (ul));
3756 data = safe_read_sleb128 (data, end, &l);
3757 fprintf_filtered (stream, " %s", plongest (l));
3792 fprintf_filtered (stream, " [$%s]",
3793 locexpr_regname (arch, op - DW_OP_reg0));
3797 data = safe_read_uleb128 (data, end, &ul);
3798 fprintf_filtered (stream, " %s [$%s]", pulongest (ul),
3799 locexpr_regname (arch, (int) ul));
3802 case DW_OP_implicit_value:
3803 data = safe_read_uleb128 (data, end, &ul);
3805 fprintf_filtered (stream, " %s", pulongest (ul));
3840 data = safe_read_sleb128 (data, end, &l);
3841 fprintf_filtered (stream, " %s [$%s]", plongest (l),
3842 locexpr_regname (arch, op - DW_OP_breg0));
3846 data = safe_read_uleb128 (data, end, &ul);
3847 data = safe_read_sleb128 (data, end, &l);
3848 fprintf_filtered (stream, " register %s [$%s] offset %s",
3850 locexpr_regname (arch, (int) ul),
3855 data = safe_read_sleb128 (data, end, &l);
3856 fprintf_filtered (stream, " %s", plongest (l));
3859 case DW_OP_xderef_size:
3860 case DW_OP_deref_size:
3862 fprintf_filtered (stream, " %d", *data);
3866 case DW_OP_plus_uconst:
3867 data = safe_read_uleb128 (data, end, &ul);
3868 fprintf_filtered (stream, " %s", pulongest (ul));
3872 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3874 fprintf_filtered (stream, " to %ld",
3875 (long) (data + l - start));
3879 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3881 fprintf_filtered (stream, " %ld",
3882 (long) (data + l - start));
3886 ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
3888 fprintf_filtered (stream, " offset %s", phex_nz (ul, 2));
3892 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
3894 fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
3897 case DW_OP_call_ref:
3898 ul = extract_unsigned_integer (data, offset_size,
3899 gdbarch_byte_order (arch));
3900 data += offset_size;
3901 fprintf_filtered (stream, " offset %s", phex_nz (ul, offset_size));
3905 data = safe_read_uleb128 (data, end, &ul);
3906 fprintf_filtered (stream, " %s (bytes)", pulongest (ul));
3909 case DW_OP_bit_piece:
3913 data = safe_read_uleb128 (data, end, &ul);
3914 data = safe_read_uleb128 (data, end, &offset);
3915 fprintf_filtered (stream, " size %s offset %s (bits)",
3916 pulongest (ul), pulongest (offset));
3920 case DW_OP_GNU_implicit_pointer:
3922 ul = extract_unsigned_integer (data, offset_size,
3923 gdbarch_byte_order (arch));
3924 data += offset_size;
3926 data = safe_read_sleb128 (data, end, &l);
3928 fprintf_filtered (stream, " DIE %s offset %s",
3929 phex_nz (ul, offset_size),
3934 case DW_OP_GNU_deref_type:
3936 int addr_size = *data++;
3940 data = safe_read_uleb128 (data, end, &ul);
3942 type = dwarf2_get_die_type (offset, per_cu);
3943 fprintf_filtered (stream, "<");
3944 type_print (type, "", stream, -1);
3945 fprintf_filtered (stream, " [0x%s]> %d", phex_nz (offset.cu_off, 0),
3950 case DW_OP_GNU_const_type:
3955 data = safe_read_uleb128 (data, end, &ul);
3956 type_die.cu_off = ul;
3957 type = dwarf2_get_die_type (type_die, per_cu);
3958 fprintf_filtered (stream, "<");
3959 type_print (type, "", stream, -1);
3960 fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die.cu_off, 0));
3964 case DW_OP_GNU_regval_type:
3970 data = safe_read_uleb128 (data, end, ®);
3971 data = safe_read_uleb128 (data, end, &ul);
3972 type_die.cu_off = ul;
3974 type = dwarf2_get_die_type (type_die, per_cu);
3975 fprintf_filtered (stream, "<");
3976 type_print (type, "", stream, -1);
3977 fprintf_filtered (stream, " [0x%s]> [$%s]",
3978 phex_nz (type_die.cu_off, 0),
3979 locexpr_regname (arch, reg));
3983 case DW_OP_GNU_convert:
3984 case DW_OP_GNU_reinterpret:
3988 data = safe_read_uleb128 (data, end, &ul);
3989 type_die.cu_off = ul;
3991 if (type_die.cu_off == 0)
3992 fprintf_filtered (stream, "<0>");
3997 type = dwarf2_get_die_type (type_die, per_cu);
3998 fprintf_filtered (stream, "<");
3999 type_print (type, "", stream, -1);
4000 fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die.cu_off, 0));
4005 case DW_OP_GNU_entry_value:
4006 data = safe_read_uleb128 (data, end, &ul);
4007 fputc_filtered ('\n', stream);
4008 disassemble_dwarf_expression (stream, arch, addr_size, offset_size,
4009 start, data, data + ul, indent + 2,
4014 case DW_OP_GNU_parameter_ref:
4015 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
4017 fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
4020 case DW_OP_GNU_addr_index:
4021 data = safe_read_uleb128 (data, end, &ul);
4022 ul = dwarf2_read_addr_index (per_cu, ul);
4023 fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size));
4025 case DW_OP_GNU_const_index:
4026 data = safe_read_uleb128 (data, end, &ul);
4027 ul = dwarf2_read_addr_index (per_cu, ul);
4028 fprintf_filtered (stream, " %s", pulongest (ul));
4032 fprintf_filtered (stream, "\n");
4038 /* Describe a single location, which may in turn consist of multiple
4042 locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr,
4043 struct ui_file *stream,
4044 const gdb_byte *data, size_t size,
4045 struct objfile *objfile, unsigned int addr_size,
4046 int offset_size, struct dwarf2_per_cu_data *per_cu)
4048 const gdb_byte *end = data + size;
4049 int first_piece = 1, bad = 0;
4053 const gdb_byte *here = data;
4054 int disassemble = 1;
4059 fprintf_filtered (stream, _(", and "));
4061 if (!dwarf2_always_disassemble)
4063 data = locexpr_describe_location_piece (symbol, stream,
4064 addr, objfile, per_cu,
4065 data, end, addr_size);
4066 /* If we printed anything, or if we have an empty piece,
4067 then don't disassemble. */
4069 || data[0] == DW_OP_piece
4070 || data[0] == DW_OP_bit_piece)
4075 fprintf_filtered (stream, _("a complex DWARF expression:\n"));
4076 data = disassemble_dwarf_expression (stream,
4077 get_objfile_arch (objfile),
4078 addr_size, offset_size, data,
4080 dwarf2_always_disassemble,
4086 int empty = data == here;
4089 fprintf_filtered (stream, " ");
4090 if (data[0] == DW_OP_piece)
4094 data = safe_read_uleb128 (data + 1, end, &bytes);
4097 fprintf_filtered (stream, _("an empty %s-byte piece"),
4100 fprintf_filtered (stream, _(" [%s-byte piece]"),
4103 else if (data[0] == DW_OP_bit_piece)
4105 uint64_t bits, offset;
4107 data = safe_read_uleb128 (data + 1, end, &bits);
4108 data = safe_read_uleb128 (data, end, &offset);
4111 fprintf_filtered (stream,
4112 _("an empty %s-bit piece"),
4115 fprintf_filtered (stream,
4116 _(" [%s-bit piece, offset %s bits]"),
4117 pulongest (bits), pulongest (offset));
4127 if (bad || data > end)
4128 error (_("Corrupted DWARF2 expression for \"%s\"."),
4129 SYMBOL_PRINT_NAME (symbol));
4132 /* Print a natural-language description of SYMBOL to STREAM. This
4133 version is for a symbol with a single location. */
4136 locexpr_describe_location (struct symbol *symbol, CORE_ADDR addr,
4137 struct ui_file *stream)
4139 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4140 struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
4141 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4142 int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
4144 locexpr_describe_location_1 (symbol, addr, stream,
4145 dlbaton->data, dlbaton->size,
4146 objfile, addr_size, offset_size,
4150 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4151 any necessary bytecode in AX. */
4154 locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
4155 struct agent_expr *ax, struct axs_value *value)
4157 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4158 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4160 if (dlbaton->size == 0)
4161 value->optimized_out = 1;
4163 dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size,
4164 dlbaton->data, dlbaton->data + dlbaton->size,
4168 /* The set of location functions used with the DWARF-2 expression
4170 const struct symbol_computed_ops dwarf2_locexpr_funcs = {
4171 locexpr_read_variable,
4172 locexpr_read_variable_at_entry,
4173 locexpr_read_needs_frame,
4174 locexpr_describe_location,
4175 0, /* location_has_loclist */
4176 locexpr_tracepoint_var_ref
4180 /* Wrapper functions for location lists. These generally find
4181 the appropriate location expression and call something above. */
4183 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4184 evaluator to calculate the location. */
4185 static struct value *
4186 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
4188 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4190 const gdb_byte *data;
4192 CORE_ADDR pc = frame ? get_frame_address_in_block (frame) : 0;
4194 data = dwarf2_find_location_expression (dlbaton, &size, pc);
4195 val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, data, size,
4201 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4202 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4205 Function always returns non-NULL value, it may be marked optimized out if
4206 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4207 if it cannot resolve the parameter for any reason. */
4209 static struct value *
4210 loclist_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
4212 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4213 const gdb_byte *data;
4217 if (frame == NULL || !get_frame_func_if_available (frame, &pc))
4218 return allocate_optimized_out_value (SYMBOL_TYPE (symbol));
4220 data = dwarf2_find_location_expression (dlbaton, &size, pc);
4222 return allocate_optimized_out_value (SYMBOL_TYPE (symbol));
4224 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, data, size);
4227 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
4229 loclist_read_needs_frame (struct symbol *symbol)
4231 /* If there's a location list, then assume we need to have a frame
4232 to choose the appropriate location expression. With tracking of
4233 global variables this is not necessarily true, but such tracking
4234 is disabled in GCC at the moment until we figure out how to
4240 /* Print a natural-language description of SYMBOL to STREAM. This
4241 version applies when there is a list of different locations, each
4242 with a specified address range. */
4245 loclist_describe_location (struct symbol *symbol, CORE_ADDR addr,
4246 struct ui_file *stream)
4248 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4249 const gdb_byte *loc_ptr, *buf_end;
4250 struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
4251 struct gdbarch *gdbarch = get_objfile_arch (objfile);
4252 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4253 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4254 int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
4255 int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
4256 /* Adjust base_address for relocatable objects. */
4257 CORE_ADDR base_offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
4258 CORE_ADDR base_address = dlbaton->base_address + base_offset;
4261 loc_ptr = dlbaton->data;
4262 buf_end = dlbaton->data + dlbaton->size;
4264 fprintf_filtered (stream, _("multi-location:\n"));
4266 /* Iterate through locations until we run out. */
4269 CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */
4271 enum debug_loc_kind kind;
4272 const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */
4274 if (dlbaton->from_dwo)
4275 kind = decode_debug_loc_dwo_addresses (dlbaton->per_cu,
4276 loc_ptr, buf_end, &new_ptr,
4277 &low, &high, byte_order);
4279 kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
4281 byte_order, addr_size,
4286 case DEBUG_LOC_END_OF_LIST:
4289 case DEBUG_LOC_BASE_ADDRESS:
4290 base_address = high + base_offset;
4291 fprintf_filtered (stream, _(" Base address %s"),
4292 paddress (gdbarch, base_address));
4294 case DEBUG_LOC_START_END:
4295 case DEBUG_LOC_START_LENGTH:
4297 case DEBUG_LOC_BUFFER_OVERFLOW:
4298 case DEBUG_LOC_INVALID_ENTRY:
4299 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4300 SYMBOL_PRINT_NAME (symbol));
4302 gdb_assert_not_reached ("bad debug_loc_kind");
4305 /* Otherwise, a location expression entry. */
4306 low += base_address;
4307 high += base_address;
4309 length = extract_unsigned_integer (loc_ptr, 2, byte_order);
4312 /* (It would improve readability to print only the minimum
4313 necessary digits of the second number of the range.) */
4314 fprintf_filtered (stream, _(" Range %s-%s: "),
4315 paddress (gdbarch, low), paddress (gdbarch, high));
4317 /* Now describe this particular location. */
4318 locexpr_describe_location_1 (symbol, low, stream, loc_ptr, length,
4319 objfile, addr_size, offset_size,
4322 fprintf_filtered (stream, "\n");
4328 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4329 any necessary bytecode in AX. */
4331 loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
4332 struct agent_expr *ax, struct axs_value *value)
4334 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4335 const gdb_byte *data;
4337 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4339 data = dwarf2_find_location_expression (dlbaton, &size, ax->scope);
4341 value->optimized_out = 1;
4343 dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size, data, data + size,
4347 /* The set of location functions used with the DWARF-2 expression
4348 evaluator and location lists. */
4349 const struct symbol_computed_ops dwarf2_loclist_funcs = {
4350 loclist_read_variable,
4351 loclist_read_variable_at_entry,
4352 loclist_read_needs_frame,
4353 loclist_describe_location,
4354 1, /* location_has_loclist */
4355 loclist_tracepoint_var_ref
4358 /* Provide a prototype to silence -Wmissing-prototypes. */
4359 extern initialize_file_ftype _initialize_dwarf2loc;
4362 _initialize_dwarf2loc (void)
4364 add_setshow_zuinteger_cmd ("entry-values", class_maintenance,
4365 &entry_values_debug,
4366 _("Set entry values and tail call frames "
4368 _("Show entry values and tail call frames "
4370 _("When non-zero, the process of determining "
4371 "parameter values from function entry point "
4372 "and tail call frames will be printed."),
4374 show_entry_values_debug,
4375 &setdebuglist, &showdebuglist);