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/>. */
37 #include "dwarf2expr.h"
38 #include "dwarf2loc.h"
39 #include "dwarf2-frame.h"
41 extern int dwarf2_always_disassemble;
43 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs;
45 static struct value *dwarf2_evaluate_loc_desc_full (struct type *type,
46 struct frame_info *frame,
49 struct dwarf2_per_cu_data *per_cu,
52 /* Until these have formal names, we define these here.
53 ref: http://gcc.gnu.org/wiki/DebugFission
54 Each entry in .debug_loc.dwo begins with a byte that describes the entry,
55 and is then followed by data specific to that entry. */
59 /* Indicates the end of the list of entries. */
60 DEBUG_LOC_END_OF_LIST = 0,
62 /* This is followed by an unsigned LEB128 number that is an index into
63 .debug_addr and specifies the base address for all following entries. */
64 DEBUG_LOC_BASE_ADDRESS = 1,
66 /* This is followed by two unsigned LEB128 numbers that are indices into
67 .debug_addr and specify the beginning and ending addresses, and then
68 a normal location expression as in .debug_loc. */
69 DEBUG_LOC_START_END = 2,
71 /* This is followed by an unsigned LEB128 number that is an index into
72 .debug_addr and specifies the beginning address, and a 4 byte unsigned
73 number that specifies the length, and then a normal location expression
75 DEBUG_LOC_START_LENGTH = 3,
77 /* An internal value indicating there is insufficient data. */
78 DEBUG_LOC_BUFFER_OVERFLOW = -1,
80 /* An internal value indicating an invalid kind of entry was found. */
81 DEBUG_LOC_INVALID_ENTRY = -2
84 /* Helper function which throws an error if a synthetic pointer is
88 invalid_synthetic_pointer (void)
90 error (_("access outside bounds of object "
91 "referenced via synthetic pointer"));
94 /* Decode the addresses in a non-dwo .debug_loc entry.
95 A pointer to the next byte to examine is returned in *NEW_PTR.
96 The encoded low,high addresses are return in *LOW,*HIGH.
97 The result indicates the kind of entry found. */
99 static enum debug_loc_kind
100 decode_debug_loc_addresses (const gdb_byte *loc_ptr, const gdb_byte *buf_end,
101 const gdb_byte **new_ptr,
102 CORE_ADDR *low, CORE_ADDR *high,
103 enum bfd_endian byte_order,
104 unsigned int addr_size,
107 CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
109 if (buf_end - loc_ptr < 2 * addr_size)
110 return DEBUG_LOC_BUFFER_OVERFLOW;
113 *low = extract_signed_integer (loc_ptr, addr_size, byte_order);
115 *low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
116 loc_ptr += addr_size;
119 *high = extract_signed_integer (loc_ptr, addr_size, byte_order);
121 *high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
122 loc_ptr += addr_size;
126 /* A base-address-selection entry. */
127 if ((*low & base_mask) == base_mask)
128 return DEBUG_LOC_BASE_ADDRESS;
130 /* An end-of-list entry. */
131 if (*low == 0 && *high == 0)
132 return DEBUG_LOC_END_OF_LIST;
134 return DEBUG_LOC_START_END;
137 /* Decode the addresses in .debug_loc.dwo entry.
138 A pointer to the next byte to examine is returned in *NEW_PTR.
139 The encoded low,high addresses are return in *LOW,*HIGH.
140 The result indicates the kind of entry found. */
142 static enum debug_loc_kind
143 decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data *per_cu,
144 const gdb_byte *loc_ptr,
145 const gdb_byte *buf_end,
146 const gdb_byte **new_ptr,
147 CORE_ADDR *low, CORE_ADDR *high,
148 enum bfd_endian byte_order)
150 uint64_t low_index, high_index;
152 if (loc_ptr == buf_end)
153 return DEBUG_LOC_BUFFER_OVERFLOW;
157 case DEBUG_LOC_END_OF_LIST:
159 return DEBUG_LOC_END_OF_LIST;
160 case DEBUG_LOC_BASE_ADDRESS:
162 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
164 return DEBUG_LOC_BUFFER_OVERFLOW;
165 *high = dwarf2_read_addr_index (per_cu, high_index);
167 return DEBUG_LOC_BASE_ADDRESS;
168 case DEBUG_LOC_START_END:
169 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index);
171 return DEBUG_LOC_BUFFER_OVERFLOW;
172 *low = dwarf2_read_addr_index (per_cu, low_index);
173 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
175 return DEBUG_LOC_BUFFER_OVERFLOW;
176 *high = dwarf2_read_addr_index (per_cu, high_index);
178 return DEBUG_LOC_START_END;
179 case DEBUG_LOC_START_LENGTH:
180 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index);
182 return DEBUG_LOC_BUFFER_OVERFLOW;
183 *low = dwarf2_read_addr_index (per_cu, low_index);
184 if (loc_ptr + 4 > buf_end)
185 return DEBUG_LOC_BUFFER_OVERFLOW;
187 *high += extract_unsigned_integer (loc_ptr, 4, byte_order);
188 *new_ptr = loc_ptr + 4;
189 return DEBUG_LOC_START_LENGTH;
191 return DEBUG_LOC_INVALID_ENTRY;
195 /* A function for dealing with location lists. Given a
196 symbol baton (BATON) and a pc value (PC), find the appropriate
197 location expression, set *LOCEXPR_LENGTH, and return a pointer
198 to the beginning of the expression. Returns NULL on failure.
200 For now, only return the first matching location expression; there
201 can be more than one in the list. */
204 dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton,
205 size_t *locexpr_length, CORE_ADDR pc)
207 struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu);
208 struct gdbarch *gdbarch = get_objfile_arch (objfile);
209 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
210 unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu);
211 int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
212 /* Adjust base_address for relocatable objects. */
213 CORE_ADDR base_offset = dwarf2_per_cu_text_offset (baton->per_cu);
214 CORE_ADDR base_address = baton->base_address + base_offset;
215 const gdb_byte *loc_ptr, *buf_end;
217 loc_ptr = baton->data;
218 buf_end = baton->data + baton->size;
222 CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */
224 enum debug_loc_kind kind;
225 const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */
228 kind = decode_debug_loc_dwo_addresses (baton->per_cu,
229 loc_ptr, buf_end, &new_ptr,
230 &low, &high, byte_order);
232 kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
234 byte_order, addr_size,
239 case DEBUG_LOC_END_OF_LIST:
242 case DEBUG_LOC_BASE_ADDRESS:
243 base_address = high + base_offset;
245 case DEBUG_LOC_START_END:
246 case DEBUG_LOC_START_LENGTH:
248 case DEBUG_LOC_BUFFER_OVERFLOW:
249 case DEBUG_LOC_INVALID_ENTRY:
250 error (_("dwarf2_find_location_expression: "
251 "Corrupted DWARF expression."));
253 gdb_assert_not_reached ("bad debug_loc_kind");
256 /* Otherwise, a location expression entry.
257 If the entry is from a DWO, don't add base address: the entry is
258 from .debug_addr which has absolute addresses. */
259 if (! baton->from_dwo)
262 high += base_address;
265 length = extract_unsigned_integer (loc_ptr, 2, byte_order);
268 if (low == high && pc == low)
270 /* This is entry PC record present only at entry point
271 of a function. Verify it is really the function entry point. */
273 const struct block *pc_block = block_for_pc (pc);
274 struct symbol *pc_func = NULL;
277 pc_func = block_linkage_function (pc_block);
279 if (pc_func && pc == BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func)))
281 *locexpr_length = length;
286 if (pc >= low && pc < high)
288 *locexpr_length = length;
296 /* This is the baton used when performing dwarf2 expression
298 struct dwarf_expr_baton
300 struct frame_info *frame;
301 struct dwarf2_per_cu_data *per_cu;
302 CORE_ADDR obj_address;
305 /* Helper functions for dwarf2_evaluate_loc_desc. */
307 /* Using the frame specified in BATON, return the value of register
308 REGNUM, treated as a pointer. */
310 dwarf_expr_read_addr_from_reg (void *baton, int dwarf_regnum)
312 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
313 struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
314 int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
316 return address_from_register (regnum, debaton->frame);
319 /* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback. */
321 static struct value *
322 dwarf_expr_get_reg_value (void *baton, struct type *type, int dwarf_regnum)
324 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
325 struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
326 int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
328 return value_from_register (type, regnum, debaton->frame);
331 /* Read memory at ADDR (length LEN) into BUF. */
334 dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
336 read_memory (addr, buf, len);
339 /* Using the frame specified in BATON, find the location expression
340 describing the frame base. Return a pointer to it in START and
341 its length in LENGTH. */
343 dwarf_expr_frame_base (void *baton, const gdb_byte **start, size_t * length)
345 /* FIXME: cagney/2003-03-26: This code should be using
346 get_frame_base_address(), and then implement a dwarf2 specific
348 struct symbol *framefunc;
349 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
350 const struct block *bl = get_frame_block (debaton->frame, NULL);
353 error (_("frame address is not available."));
355 /* Use block_linkage_function, which returns a real (not inlined)
356 function, instead of get_frame_function, which may return an
358 framefunc = block_linkage_function (bl);
360 /* If we found a frame-relative symbol then it was certainly within
361 some function associated with a frame. If we can't find the frame,
362 something has gone wrong. */
363 gdb_assert (framefunc != NULL);
365 func_get_frame_base_dwarf_block (framefunc,
366 get_frame_address_in_block (debaton->frame),
370 /* Implement find_frame_base_location method for LOC_BLOCK functions using
371 DWARF expression for its DW_AT_frame_base. */
374 locexpr_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc,
375 const gdb_byte **start, size_t *length)
377 struct dwarf2_locexpr_baton *symbaton = SYMBOL_LOCATION_BATON (framefunc);
379 *length = symbaton->size;
380 *start = symbaton->data;
383 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
384 function uses DWARF expression for its DW_AT_frame_base. */
386 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs =
388 locexpr_find_frame_base_location
391 /* Implement find_frame_base_location method for LOC_BLOCK functions using
392 DWARF location list for its DW_AT_frame_base. */
395 loclist_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc,
396 const gdb_byte **start, size_t *length)
398 struct dwarf2_loclist_baton *symbaton = SYMBOL_LOCATION_BATON (framefunc);
400 *start = dwarf2_find_location_expression (symbaton, length, pc);
403 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
404 function uses DWARF location list for its DW_AT_frame_base. */
406 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs =
408 loclist_find_frame_base_location
411 /* See dwarf2loc.h. */
414 func_get_frame_base_dwarf_block (struct symbol *framefunc, CORE_ADDR pc,
415 const gdb_byte **start, size_t *length)
417 if (SYMBOL_BLOCK_OPS (framefunc) != NULL)
419 const struct symbol_block_ops *ops_block = SYMBOL_BLOCK_OPS (framefunc);
421 ops_block->find_frame_base_location (framefunc, pc, start, length);
427 error (_("Could not find the frame base for \"%s\"."),
428 SYMBOL_NATURAL_NAME (framefunc));
431 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
432 the frame in BATON. */
435 dwarf_expr_frame_cfa (void *baton)
437 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
439 return dwarf2_frame_cfa (debaton->frame);
442 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
443 the frame in BATON. */
446 dwarf_expr_frame_pc (void *baton)
448 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
450 return get_frame_address_in_block (debaton->frame);
453 /* Using the objfile specified in BATON, find the address for the
454 current thread's thread-local storage with offset OFFSET. */
456 dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
458 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
459 struct objfile *objfile = dwarf2_per_cu_objfile (debaton->per_cu);
461 return target_translate_tls_address (objfile, offset);
464 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
465 current CU (as is PER_CU). State of the CTX is not affected by the
469 per_cu_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset,
470 struct dwarf2_per_cu_data *per_cu,
471 CORE_ADDR (*get_frame_pc) (void *baton),
474 struct dwarf2_locexpr_baton block;
476 block = dwarf2_fetch_die_loc_cu_off (die_offset, per_cu, get_frame_pc, baton);
478 /* DW_OP_call_ref is currently not supported. */
479 gdb_assert (block.per_cu == per_cu);
481 dwarf_expr_eval (ctx, block.data, block.size);
484 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
487 dwarf_expr_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
489 struct dwarf_expr_baton *debaton = ctx->baton;
491 per_cu_dwarf_call (ctx, die_offset, debaton->per_cu,
492 ctx->funcs->get_frame_pc, ctx->baton);
495 /* Callback function for dwarf2_evaluate_loc_desc. */
498 dwarf_expr_get_base_type (struct dwarf_expr_context *ctx,
499 cu_offset die_offset)
501 struct dwarf_expr_baton *debaton = ctx->baton;
503 return dwarf2_get_die_type (die_offset, debaton->per_cu);
506 /* See dwarf2loc.h. */
508 unsigned int entry_values_debug = 0;
510 /* Helper to set entry_values_debug. */
513 show_entry_values_debug (struct ui_file *file, int from_tty,
514 struct cmd_list_element *c, const char *value)
516 fprintf_filtered (file,
517 _("Entry values and tail call frames debugging is %s.\n"),
521 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
522 CALLER_FRAME (for registers) can be NULL if it is not known. This function
523 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
526 call_site_to_target_addr (struct gdbarch *call_site_gdbarch,
527 struct call_site *call_site,
528 struct frame_info *caller_frame)
530 switch (FIELD_LOC_KIND (call_site->target))
532 case FIELD_LOC_KIND_DWARF_BLOCK:
534 struct dwarf2_locexpr_baton *dwarf_block;
536 struct type *caller_core_addr_type;
537 struct gdbarch *caller_arch;
539 dwarf_block = FIELD_DWARF_BLOCK (call_site->target);
540 if (dwarf_block == NULL)
542 struct bound_minimal_symbol msym;
544 msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
545 throw_error (NO_ENTRY_VALUE_ERROR,
546 _("DW_AT_GNU_call_site_target is not specified "
548 paddress (call_site_gdbarch, call_site->pc),
549 (msym.minsym == NULL ? "???"
550 : MSYMBOL_PRINT_NAME (msym.minsym)));
553 if (caller_frame == NULL)
555 struct bound_minimal_symbol msym;
557 msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
558 throw_error (NO_ENTRY_VALUE_ERROR,
559 _("DW_AT_GNU_call_site_target DWARF block resolving "
560 "requires known frame which is currently not "
561 "available at %s in %s"),
562 paddress (call_site_gdbarch, call_site->pc),
563 (msym.minsym == NULL ? "???"
564 : MSYMBOL_PRINT_NAME (msym.minsym)));
567 caller_arch = get_frame_arch (caller_frame);
568 caller_core_addr_type = builtin_type (caller_arch)->builtin_func_ptr;
569 val = dwarf2_evaluate_loc_desc (caller_core_addr_type, caller_frame,
570 dwarf_block->data, dwarf_block->size,
571 dwarf_block->per_cu);
572 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
574 if (VALUE_LVAL (val) == lval_memory)
575 return value_address (val);
577 return value_as_address (val);
580 case FIELD_LOC_KIND_PHYSNAME:
582 const char *physname;
583 struct bound_minimal_symbol msym;
585 physname = FIELD_STATIC_PHYSNAME (call_site->target);
587 /* Handle both the mangled and demangled PHYSNAME. */
588 msym = lookup_minimal_symbol (physname, NULL, NULL);
589 if (msym.minsym == NULL)
591 msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
592 throw_error (NO_ENTRY_VALUE_ERROR,
593 _("Cannot find function \"%s\" for a call site target "
595 physname, paddress (call_site_gdbarch, call_site->pc),
596 (msym.minsym == NULL ? "???"
597 : MSYMBOL_PRINT_NAME (msym.minsym)));
600 return BMSYMBOL_VALUE_ADDRESS (msym);
603 case FIELD_LOC_KIND_PHYSADDR:
604 return FIELD_STATIC_PHYSADDR (call_site->target);
607 internal_error (__FILE__, __LINE__, _("invalid call site target kind"));
611 /* Convert function entry point exact address ADDR to the function which is
612 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
613 NO_ENTRY_VALUE_ERROR otherwise. */
615 static struct symbol *
616 func_addr_to_tail_call_list (struct gdbarch *gdbarch, CORE_ADDR addr)
618 struct symbol *sym = find_pc_function (addr);
621 if (sym == NULL || BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) != addr)
622 throw_error (NO_ENTRY_VALUE_ERROR,
623 _("DW_TAG_GNU_call_site resolving failed to find function "
624 "name for address %s"),
625 paddress (gdbarch, addr));
627 type = SYMBOL_TYPE (sym);
628 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FUNC);
629 gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_FUNC);
634 /* Verify function with entry point exact address ADDR can never call itself
635 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
636 can call itself via tail calls.
638 If a funtion can tail call itself its entry value based parameters are
639 unreliable. There is no verification whether the value of some/all
640 parameters is unchanged through the self tail call, we expect if there is
641 a self tail call all the parameters can be modified. */
644 func_verify_no_selftailcall (struct gdbarch *gdbarch, CORE_ADDR verify_addr)
646 struct obstack addr_obstack;
647 struct cleanup *old_chain;
650 /* Track here CORE_ADDRs which were already visited. */
653 /* The verification is completely unordered. Track here function addresses
654 which still need to be iterated. */
655 VEC (CORE_ADDR) *todo = NULL;
657 obstack_init (&addr_obstack);
658 old_chain = make_cleanup_obstack_free (&addr_obstack);
659 addr_hash = htab_create_alloc_ex (64, core_addr_hash, core_addr_eq, NULL,
660 &addr_obstack, hashtab_obstack_allocate,
662 make_cleanup_htab_delete (addr_hash);
664 make_cleanup (VEC_cleanup (CORE_ADDR), &todo);
666 VEC_safe_push (CORE_ADDR, todo, verify_addr);
667 while (!VEC_empty (CORE_ADDR, todo))
669 struct symbol *func_sym;
670 struct call_site *call_site;
672 addr = VEC_pop (CORE_ADDR, todo);
674 func_sym = func_addr_to_tail_call_list (gdbarch, addr);
676 for (call_site = TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym));
677 call_site; call_site = call_site->tail_call_next)
679 CORE_ADDR target_addr;
682 /* CALLER_FRAME with registers is not available for tail-call jumped
684 target_addr = call_site_to_target_addr (gdbarch, call_site, NULL);
686 if (target_addr == verify_addr)
688 struct bound_minimal_symbol msym;
690 msym = lookup_minimal_symbol_by_pc (verify_addr);
691 throw_error (NO_ENTRY_VALUE_ERROR,
692 _("DW_OP_GNU_entry_value resolving has found "
693 "function \"%s\" at %s can call itself via tail "
695 (msym.minsym == NULL ? "???"
696 : MSYMBOL_PRINT_NAME (msym.minsym)),
697 paddress (gdbarch, verify_addr));
700 slot = htab_find_slot (addr_hash, &target_addr, INSERT);
703 *slot = obstack_copy (&addr_obstack, &target_addr,
704 sizeof (target_addr));
705 VEC_safe_push (CORE_ADDR, todo, target_addr);
710 do_cleanups (old_chain);
713 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
714 ENTRY_VALUES_DEBUG. */
717 tailcall_dump (struct gdbarch *gdbarch, const struct call_site *call_site)
719 CORE_ADDR addr = call_site->pc;
720 struct bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (addr - 1);
722 fprintf_unfiltered (gdb_stdlog, " %s(%s)", paddress (gdbarch, addr),
723 (msym.minsym == NULL ? "???"
724 : MSYMBOL_PRINT_NAME (msym.minsym)));
728 /* vec.h needs single word type name, typedef it. */
729 typedef struct call_site *call_sitep;
731 /* Define VEC (call_sitep) functions. */
732 DEF_VEC_P (call_sitep);
734 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
735 only top callers and bottom callees which are present in both. GDBARCH is
736 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
737 no remaining possibilities to provide unambiguous non-trivial result.
738 RESULTP should point to NULL on the first (initialization) call. Caller is
739 responsible for xfree of any RESULTP data. */
742 chain_candidate (struct gdbarch *gdbarch, struct call_site_chain **resultp,
743 VEC (call_sitep) *chain)
745 struct call_site_chain *result = *resultp;
746 long length = VEC_length (call_sitep, chain);
747 int callers, callees, idx;
751 /* Create the initial chain containing all the passed PCs. */
753 result = xmalloc (sizeof (*result) + sizeof (*result->call_site)
755 result->length = length;
756 result->callers = result->callees = length;
757 if (!VEC_empty (call_sitep, chain))
758 memcpy (result->call_site, VEC_address (call_sitep, chain),
759 sizeof (*result->call_site) * length);
762 if (entry_values_debug)
764 fprintf_unfiltered (gdb_stdlog, "tailcall: initial:");
765 for (idx = 0; idx < length; idx++)
766 tailcall_dump (gdbarch, result->call_site[idx]);
767 fputc_unfiltered ('\n', gdb_stdlog);
773 if (entry_values_debug)
775 fprintf_unfiltered (gdb_stdlog, "tailcall: compare:");
776 for (idx = 0; idx < length; idx++)
777 tailcall_dump (gdbarch, VEC_index (call_sitep, chain, idx));
778 fputc_unfiltered ('\n', gdb_stdlog);
781 /* Intersect callers. */
783 callers = min (result->callers, length);
784 for (idx = 0; idx < callers; idx++)
785 if (result->call_site[idx] != VEC_index (call_sitep, chain, idx))
787 result->callers = idx;
791 /* Intersect callees. */
793 callees = min (result->callees, length);
794 for (idx = 0; idx < callees; idx++)
795 if (result->call_site[result->length - 1 - idx]
796 != VEC_index (call_sitep, chain, length - 1 - idx))
798 result->callees = idx;
802 if (entry_values_debug)
804 fprintf_unfiltered (gdb_stdlog, "tailcall: reduced:");
805 for (idx = 0; idx < result->callers; idx++)
806 tailcall_dump (gdbarch, result->call_site[idx]);
807 fputs_unfiltered (" |", gdb_stdlog);
808 for (idx = 0; idx < result->callees; idx++)
809 tailcall_dump (gdbarch, result->call_site[result->length
810 - result->callees + idx]);
811 fputc_unfiltered ('\n', gdb_stdlog);
814 if (result->callers == 0 && result->callees == 0)
816 /* There are no common callers or callees. It could be also a direct
817 call (which has length 0) with ambiguous possibility of an indirect
818 call - CALLERS == CALLEES == 0 is valid during the first allocation
819 but any subsequence processing of such entry means ambiguity. */
825 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
826 PC again. In such case there must be two different code paths to reach
827 it, therefore some of the former determined intermediate PCs must differ
828 and the unambiguous chain gets shortened. */
829 gdb_assert (result->callers + result->callees < result->length);
832 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
833 assumed frames between them use GDBARCH. Use depth first search so we can
834 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
835 would have needless GDB stack overhead. Caller is responsible for xfree of
836 the returned result. Any unreliability results in thrown
837 NO_ENTRY_VALUE_ERROR. */
839 static struct call_site_chain *
840 call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
843 CORE_ADDR save_callee_pc = callee_pc;
844 struct obstack addr_obstack;
845 struct cleanup *back_to_retval, *back_to_workdata;
846 struct call_site_chain *retval = NULL;
847 struct call_site *call_site;
849 /* Mark CALL_SITEs so we do not visit the same ones twice. */
852 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
853 call_site nor any possible call_site at CALLEE_PC's function is there.
854 Any CALL_SITE in CHAIN will be iterated to its siblings - via
855 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
856 VEC (call_sitep) *chain = NULL;
858 /* We are not interested in the specific PC inside the callee function. */
859 callee_pc = get_pc_function_start (callee_pc);
861 throw_error (NO_ENTRY_VALUE_ERROR, _("Unable to find function for PC %s"),
862 paddress (gdbarch, save_callee_pc));
864 back_to_retval = make_cleanup (free_current_contents, &retval);
866 obstack_init (&addr_obstack);
867 back_to_workdata = make_cleanup_obstack_free (&addr_obstack);
868 addr_hash = htab_create_alloc_ex (64, core_addr_hash, core_addr_eq, NULL,
869 &addr_obstack, hashtab_obstack_allocate,
871 make_cleanup_htab_delete (addr_hash);
873 make_cleanup (VEC_cleanup (call_sitep), &chain);
875 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
876 at the target's function. All the possible tail call sites in the
877 target's function will get iterated as already pushed into CHAIN via their
879 call_site = call_site_for_pc (gdbarch, caller_pc);
883 CORE_ADDR target_func_addr;
884 struct call_site *target_call_site;
886 /* CALLER_FRAME with registers is not available for tail-call jumped
888 target_func_addr = call_site_to_target_addr (gdbarch, call_site, NULL);
890 if (target_func_addr == callee_pc)
892 chain_candidate (gdbarch, &retval, chain);
896 /* There is no way to reach CALLEE_PC again as we would prevent
897 entering it twice as being already marked in ADDR_HASH. */
898 target_call_site = NULL;
902 struct symbol *target_func;
904 target_func = func_addr_to_tail_call_list (gdbarch, target_func_addr);
905 target_call_site = TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func));
910 /* Attempt to visit TARGET_CALL_SITE. */
912 if (target_call_site)
916 slot = htab_find_slot (addr_hash, &target_call_site->pc, INSERT);
919 /* Successfully entered TARGET_CALL_SITE. */
921 *slot = &target_call_site->pc;
922 VEC_safe_push (call_sitep, chain, target_call_site);
927 /* Backtrack (without revisiting the originating call_site). Try the
928 callers's sibling; if there isn't any try the callers's callers's
931 target_call_site = NULL;
932 while (!VEC_empty (call_sitep, chain))
934 call_site = VEC_pop (call_sitep, chain);
936 gdb_assert (htab_find_slot (addr_hash, &call_site->pc,
938 htab_remove_elt (addr_hash, &call_site->pc);
940 target_call_site = call_site->tail_call_next;
941 if (target_call_site)
945 while (target_call_site);
947 if (VEC_empty (call_sitep, chain))
950 call_site = VEC_last (call_sitep, chain);
955 struct bound_minimal_symbol msym_caller, msym_callee;
957 msym_caller = lookup_minimal_symbol_by_pc (caller_pc);
958 msym_callee = lookup_minimal_symbol_by_pc (callee_pc);
959 throw_error (NO_ENTRY_VALUE_ERROR,
960 _("There are no unambiguously determinable intermediate "
961 "callers or callees between caller function \"%s\" at %s "
962 "and callee function \"%s\" at %s"),
963 (msym_caller.minsym == NULL
964 ? "???" : MSYMBOL_PRINT_NAME (msym_caller.minsym)),
965 paddress (gdbarch, caller_pc),
966 (msym_callee.minsym == NULL
967 ? "???" : MSYMBOL_PRINT_NAME (msym_callee.minsym)),
968 paddress (gdbarch, callee_pc));
971 do_cleanups (back_to_workdata);
972 discard_cleanups (back_to_retval);
976 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
977 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
978 constructed return NULL. Caller is responsible for xfree of the returned
981 struct call_site_chain *
982 call_site_find_chain (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
985 volatile struct gdb_exception e;
986 struct call_site_chain *retval = NULL;
988 TRY_CATCH (e, RETURN_MASK_ERROR)
990 retval = call_site_find_chain_1 (gdbarch, caller_pc, callee_pc);
994 if (e.error == NO_ENTRY_VALUE_ERROR)
996 if (entry_values_debug)
997 exception_print (gdb_stdout, e);
1002 throw_exception (e);
1007 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1010 call_site_parameter_matches (struct call_site_parameter *parameter,
1011 enum call_site_parameter_kind kind,
1012 union call_site_parameter_u kind_u)
1014 if (kind == parameter->kind)
1017 case CALL_SITE_PARAMETER_DWARF_REG:
1018 return kind_u.dwarf_reg == parameter->u.dwarf_reg;
1019 case CALL_SITE_PARAMETER_FB_OFFSET:
1020 return kind_u.fb_offset == parameter->u.fb_offset;
1021 case CALL_SITE_PARAMETER_PARAM_OFFSET:
1022 return kind_u.param_offset.cu_off == parameter->u.param_offset.cu_off;
1027 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1028 FRAME is for callee.
1030 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1033 static struct call_site_parameter *
1034 dwarf_expr_reg_to_entry_parameter (struct frame_info *frame,
1035 enum call_site_parameter_kind kind,
1036 union call_site_parameter_u kind_u,
1037 struct dwarf2_per_cu_data **per_cu_return)
1039 CORE_ADDR func_addr, caller_pc;
1040 struct gdbarch *gdbarch;
1041 struct frame_info *caller_frame;
1042 struct call_site *call_site;
1044 /* Initialize it just to avoid a GCC false warning. */
1045 struct call_site_parameter *parameter = NULL;
1046 CORE_ADDR target_addr;
1048 while (get_frame_type (frame) == INLINE_FRAME)
1050 frame = get_prev_frame (frame);
1051 gdb_assert (frame != NULL);
1054 func_addr = get_frame_func (frame);
1055 gdbarch = get_frame_arch (frame);
1056 caller_frame = get_prev_frame (frame);
1057 if (gdbarch != frame_unwind_arch (frame))
1059 struct bound_minimal_symbol msym
1060 = lookup_minimal_symbol_by_pc (func_addr);
1061 struct gdbarch *caller_gdbarch = frame_unwind_arch (frame);
1063 throw_error (NO_ENTRY_VALUE_ERROR,
1064 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1065 "(of %s (%s)) does not match caller gdbarch %s"),
1066 gdbarch_bfd_arch_info (gdbarch)->printable_name,
1067 paddress (gdbarch, func_addr),
1068 (msym.minsym == NULL ? "???"
1069 : MSYMBOL_PRINT_NAME (msym.minsym)),
1070 gdbarch_bfd_arch_info (caller_gdbarch)->printable_name);
1073 if (caller_frame == NULL)
1075 struct bound_minimal_symbol msym
1076 = lookup_minimal_symbol_by_pc (func_addr);
1078 throw_error (NO_ENTRY_VALUE_ERROR, _("DW_OP_GNU_entry_value resolving "
1079 "requires caller of %s (%s)"),
1080 paddress (gdbarch, func_addr),
1081 (msym.minsym == NULL ? "???"
1082 : MSYMBOL_PRINT_NAME (msym.minsym)));
1084 caller_pc = get_frame_pc (caller_frame);
1085 call_site = call_site_for_pc (gdbarch, caller_pc);
1087 target_addr = call_site_to_target_addr (gdbarch, call_site, caller_frame);
1088 if (target_addr != func_addr)
1090 struct minimal_symbol *target_msym, *func_msym;
1092 target_msym = lookup_minimal_symbol_by_pc (target_addr).minsym;
1093 func_msym = lookup_minimal_symbol_by_pc (func_addr).minsym;
1094 throw_error (NO_ENTRY_VALUE_ERROR,
1095 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1096 "but the called frame is for %s at %s"),
1097 (target_msym == NULL ? "???"
1098 : MSYMBOL_PRINT_NAME (target_msym)),
1099 paddress (gdbarch, target_addr),
1100 func_msym == NULL ? "???" : MSYMBOL_PRINT_NAME (func_msym),
1101 paddress (gdbarch, func_addr));
1104 /* No entry value based parameters would be reliable if this function can
1105 call itself via tail calls. */
1106 func_verify_no_selftailcall (gdbarch, func_addr);
1108 for (iparams = 0; iparams < call_site->parameter_count; iparams++)
1110 parameter = &call_site->parameter[iparams];
1111 if (call_site_parameter_matches (parameter, kind, kind_u))
1114 if (iparams == call_site->parameter_count)
1116 struct minimal_symbol *msym
1117 = lookup_minimal_symbol_by_pc (caller_pc).minsym;
1119 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1120 determine its value. */
1121 throw_error (NO_ENTRY_VALUE_ERROR, _("Cannot find matching parameter "
1122 "at DW_TAG_GNU_call_site %s at %s"),
1123 paddress (gdbarch, caller_pc),
1124 msym == NULL ? "???" : MSYMBOL_PRINT_NAME (msym));
1127 *per_cu_return = call_site->per_cu;
1131 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1132 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1133 DW_AT_GNU_call_site_data_value (dereferenced) block.
1135 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1138 Function always returns non-NULL, non-optimized out value. It throws
1139 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1141 static struct value *
1142 dwarf_entry_parameter_to_value (struct call_site_parameter *parameter,
1143 CORE_ADDR deref_size, struct type *type,
1144 struct frame_info *caller_frame,
1145 struct dwarf2_per_cu_data *per_cu)
1147 const gdb_byte *data_src;
1151 data_src = deref_size == -1 ? parameter->value : parameter->data_value;
1152 size = deref_size == -1 ? parameter->value_size : parameter->data_value_size;
1154 /* DEREF_SIZE size is not verified here. */
1155 if (data_src == NULL)
1156 throw_error (NO_ENTRY_VALUE_ERROR,
1157 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1159 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1160 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1162 data = alloca (size + 1);
1163 memcpy (data, data_src, size);
1164 data[size] = DW_OP_stack_value;
1166 return dwarf2_evaluate_loc_desc (type, caller_frame, data, size + 1, per_cu);
1169 /* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
1170 Choose DEREF_SIZE value of that parameter. Search caller of the CTX's
1171 frame. CTX must be of dwarf_expr_ctx_funcs kind.
1173 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1174 can be more simple as it does not support cross-CU DWARF executions. */
1177 dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
1178 enum call_site_parameter_kind kind,
1179 union call_site_parameter_u kind_u,
1182 struct dwarf_expr_baton *debaton;
1183 struct frame_info *frame, *caller_frame;
1184 struct dwarf2_per_cu_data *caller_per_cu;
1185 struct dwarf_expr_baton baton_local;
1186 struct dwarf_expr_context saved_ctx;
1187 struct call_site_parameter *parameter;
1188 const gdb_byte *data_src;
1191 gdb_assert (ctx->funcs == &dwarf_expr_ctx_funcs);
1192 debaton = ctx->baton;
1193 frame = debaton->frame;
1194 caller_frame = get_prev_frame (frame);
1196 parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u,
1198 data_src = deref_size == -1 ? parameter->value : parameter->data_value;
1199 size = deref_size == -1 ? parameter->value_size : parameter->data_value_size;
1201 /* DEREF_SIZE size is not verified here. */
1202 if (data_src == NULL)
1203 throw_error (NO_ENTRY_VALUE_ERROR,
1204 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1206 baton_local.frame = caller_frame;
1207 baton_local.per_cu = caller_per_cu;
1208 baton_local.obj_address = 0;
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 /* Callback function for get_object_address. Return the address of the VLA
1242 dwarf_expr_get_obj_addr (void *baton)
1244 struct dwarf_expr_baton *debaton = baton;
1246 gdb_assert (debaton != NULL);
1248 if (debaton->obj_address == 0)
1249 error (_("Location address is not set."));
1251 return debaton->obj_address;
1254 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1255 the indirect method on it, that is use its stored target value, the sole
1256 purpose of entry_data_value_funcs.. */
1258 static struct value *
1259 entry_data_value_coerce_ref (const struct value *value)
1261 struct type *checked_type = check_typedef (value_type (value));
1262 struct value *target_val;
1264 if (TYPE_CODE (checked_type) != TYPE_CODE_REF)
1267 target_val = value_computed_closure (value);
1268 value_incref (target_val);
1272 /* Implement copy_closure. */
1275 entry_data_value_copy_closure (const struct value *v)
1277 struct value *target_val = value_computed_closure (v);
1279 value_incref (target_val);
1283 /* Implement free_closure. */
1286 entry_data_value_free_closure (struct value *v)
1288 struct value *target_val = value_computed_closure (v);
1290 value_free (target_val);
1293 /* Vector for methods for an entry value reference where the referenced value
1294 is stored in the caller. On the first dereference use
1295 DW_AT_GNU_call_site_data_value in the caller. */
1297 static const struct lval_funcs entry_data_value_funcs =
1301 NULL, /* indirect */
1302 entry_data_value_coerce_ref,
1303 NULL, /* check_synthetic_pointer */
1304 entry_data_value_copy_closure,
1305 entry_data_value_free_closure
1308 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1309 are used to match DW_AT_location at the caller's
1310 DW_TAG_GNU_call_site_parameter.
1312 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1313 cannot resolve the parameter for any reason. */
1315 static struct value *
1316 value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame,
1317 enum call_site_parameter_kind kind,
1318 union call_site_parameter_u kind_u)
1320 struct type *checked_type = check_typedef (type);
1321 struct type *target_type = TYPE_TARGET_TYPE (checked_type);
1322 struct frame_info *caller_frame = get_prev_frame (frame);
1323 struct value *outer_val, *target_val, *val;
1324 struct call_site_parameter *parameter;
1325 struct dwarf2_per_cu_data *caller_per_cu;
1327 parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u,
1330 outer_val = dwarf_entry_parameter_to_value (parameter, -1 /* deref_size */,
1334 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1335 used and it is not available do not fall back to OUTER_VAL - dereferencing
1336 TYPE_CODE_REF with non-entry data value would give current value - not the
1339 if (TYPE_CODE (checked_type) != TYPE_CODE_REF
1340 || TYPE_TARGET_TYPE (checked_type) == NULL)
1343 target_val = dwarf_entry_parameter_to_value (parameter,
1344 TYPE_LENGTH (target_type),
1345 target_type, caller_frame,
1348 release_value (target_val);
1349 val = allocate_computed_value (type, &entry_data_value_funcs,
1350 target_val /* closure */);
1352 /* Copy the referencing pointer to the new computed value. */
1353 memcpy (value_contents_raw (val), value_contents_raw (outer_val),
1354 TYPE_LENGTH (checked_type));
1355 set_value_lazy (val, 0);
1360 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1361 SIZE are DWARF block used to match DW_AT_location at the caller's
1362 DW_TAG_GNU_call_site_parameter.
1364 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1365 cannot resolve the parameter for any reason. */
1367 static struct value *
1368 value_of_dwarf_block_entry (struct type *type, struct frame_info *frame,
1369 const gdb_byte *block, size_t block_len)
1371 union call_site_parameter_u kind_u;
1373 kind_u.dwarf_reg = dwarf_block_to_dwarf_reg (block, block + block_len);
1374 if (kind_u.dwarf_reg != -1)
1375 return value_of_dwarf_reg_entry (type, frame, CALL_SITE_PARAMETER_DWARF_REG,
1378 if (dwarf_block_to_fb_offset (block, block + block_len, &kind_u.fb_offset))
1379 return value_of_dwarf_reg_entry (type, frame, CALL_SITE_PARAMETER_FB_OFFSET,
1382 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1383 suppressed during normal operation. The expression can be arbitrary if
1384 there is no caller-callee entry value binding expected. */
1385 throw_error (NO_ENTRY_VALUE_ERROR,
1386 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1387 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1390 struct piece_closure
1392 /* Reference count. */
1395 /* The CU from which this closure's expression came. */
1396 struct dwarf2_per_cu_data *per_cu;
1398 /* The number of pieces used to describe this variable. */
1401 /* The target address size, used only for DWARF_VALUE_STACK. */
1404 /* The pieces themselves. */
1405 struct dwarf_expr_piece *pieces;
1408 /* Allocate a closure for a value formed from separately-described
1411 static struct piece_closure *
1412 allocate_piece_closure (struct dwarf2_per_cu_data *per_cu,
1413 int n_pieces, struct dwarf_expr_piece *pieces,
1416 struct piece_closure *c = XCNEW (struct piece_closure);
1421 c->n_pieces = n_pieces;
1422 c->addr_size = addr_size;
1423 c->pieces = XCNEWVEC (struct dwarf_expr_piece, n_pieces);
1425 memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
1426 for (i = 0; i < n_pieces; ++i)
1427 if (c->pieces[i].location == DWARF_VALUE_STACK)
1428 value_incref (c->pieces[i].v.value);
1433 /* The lowest-level function to extract bits from a byte buffer.
1434 SOURCE is the buffer. It is updated if we read to the end of a
1436 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1437 updated to reflect the number of bits actually read.
1438 NBITS is the number of bits we want to read. It is updated to
1439 reflect the number of bits actually read. This function may read
1441 BITS_BIG_ENDIAN is taken directly from gdbarch.
1442 This function returns the extracted bits. */
1445 extract_bits_primitive (const gdb_byte **source,
1446 unsigned int *source_offset_bits,
1447 int *nbits, int bits_big_endian)
1449 unsigned int avail, mask, datum;
1451 gdb_assert (*source_offset_bits < 8);
1453 avail = 8 - *source_offset_bits;
1457 mask = (1 << avail) - 1;
1459 if (bits_big_endian)
1460 datum >>= 8 - (*source_offset_bits + *nbits);
1462 datum >>= *source_offset_bits;
1466 *source_offset_bits += avail;
1467 if (*source_offset_bits >= 8)
1469 *source_offset_bits -= 8;
1476 /* Extract some bits from a source buffer and move forward in the
1479 SOURCE is the source buffer. It is updated as bytes are read.
1480 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1482 NBITS is the number of bits to read.
1483 BITS_BIG_ENDIAN is taken directly from gdbarch.
1485 This function returns the bits that were read. */
1488 extract_bits (const gdb_byte **source, unsigned int *source_offset_bits,
1489 int nbits, int bits_big_endian)
1493 gdb_assert (nbits > 0 && nbits <= 8);
1495 datum = extract_bits_primitive (source, source_offset_bits, &nbits,
1501 more = extract_bits_primitive (source, source_offset_bits, &nbits,
1503 if (bits_big_endian)
1513 /* Write some bits into a buffer and move forward in the buffer.
1515 DATUM is the bits to write. The low-order bits of DATUM are used.
1516 DEST is the destination buffer. It is updated as bytes are
1518 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1520 NBITS is the number of valid bits in DATUM.
1521 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1524 insert_bits (unsigned int datum,
1525 gdb_byte *dest, unsigned int dest_offset_bits,
1526 int nbits, int bits_big_endian)
1530 gdb_assert (dest_offset_bits + nbits <= 8);
1532 mask = (1 << nbits) - 1;
1533 if (bits_big_endian)
1535 datum <<= 8 - (dest_offset_bits + nbits);
1536 mask <<= 8 - (dest_offset_bits + nbits);
1540 datum <<= dest_offset_bits;
1541 mask <<= dest_offset_bits;
1544 gdb_assert ((datum & ~mask) == 0);
1546 *dest = (*dest & ~mask) | datum;
1549 /* Copy bits from a source to a destination.
1551 DEST is where the bits should be written.
1552 DEST_OFFSET_BITS is the bit offset into DEST.
1553 SOURCE is the source of bits.
1554 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1555 BIT_COUNT is the number of bits to copy.
1556 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1559 copy_bitwise (gdb_byte *dest, unsigned int dest_offset_bits,
1560 const gdb_byte *source, unsigned int source_offset_bits,
1561 unsigned int bit_count,
1562 int bits_big_endian)
1564 unsigned int dest_avail;
1567 /* Reduce everything to byte-size pieces. */
1568 dest += dest_offset_bits / 8;
1569 dest_offset_bits %= 8;
1570 source += source_offset_bits / 8;
1571 source_offset_bits %= 8;
1573 dest_avail = 8 - dest_offset_bits % 8;
1575 /* See if we can fill the first destination byte. */
1576 if (dest_avail < bit_count)
1578 datum = extract_bits (&source, &source_offset_bits, dest_avail,
1580 insert_bits (datum, dest, dest_offset_bits, dest_avail, bits_big_endian);
1582 dest_offset_bits = 0;
1583 bit_count -= dest_avail;
1586 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1587 than 8 bits remaining. */
1588 gdb_assert (dest_offset_bits % 8 == 0 || bit_count < 8);
1589 for (; bit_count >= 8; bit_count -= 8)
1591 datum = extract_bits (&source, &source_offset_bits, 8, bits_big_endian);
1592 *dest++ = (gdb_byte) datum;
1595 /* Finally, we may have a few leftover bits. */
1596 gdb_assert (bit_count <= 8 - dest_offset_bits % 8);
1599 datum = extract_bits (&source, &source_offset_bits, bit_count,
1601 insert_bits (datum, dest, dest_offset_bits, bit_count, bits_big_endian);
1606 read_pieced_value (struct value *v)
1610 ULONGEST bits_to_skip;
1612 struct piece_closure *c
1613 = (struct piece_closure *) value_computed_closure (v);
1614 struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
1616 size_t buffer_size = 0;
1617 gdb_byte *buffer = NULL;
1618 struct cleanup *cleanup;
1620 = gdbarch_bits_big_endian (get_type_arch (value_type (v)));
1622 if (value_type (v) != value_enclosing_type (v))
1623 internal_error (__FILE__, __LINE__,
1624 _("Should not be able to create a lazy value with "
1625 "an enclosing type"));
1627 cleanup = make_cleanup (free_current_contents, &buffer);
1629 contents = value_contents_raw (v);
1630 bits_to_skip = 8 * value_offset (v);
1631 if (value_bitsize (v))
1633 bits_to_skip += value_bitpos (v);
1634 type_len = value_bitsize (v);
1637 type_len = 8 * TYPE_LENGTH (value_type (v));
1639 for (i = 0; i < c->n_pieces && offset < type_len; i++)
1641 struct dwarf_expr_piece *p = &c->pieces[i];
1642 size_t this_size, this_size_bits;
1643 long dest_offset_bits, source_offset_bits, source_offset;
1644 const gdb_byte *intermediate_buffer;
1646 /* Compute size, source, and destination offsets for copying, in
1648 this_size_bits = p->size;
1649 if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
1651 bits_to_skip -= this_size_bits;
1654 if (bits_to_skip > 0)
1656 dest_offset_bits = 0;
1657 source_offset_bits = bits_to_skip;
1658 this_size_bits -= bits_to_skip;
1663 dest_offset_bits = offset;
1664 source_offset_bits = 0;
1666 if (this_size_bits > type_len - offset)
1667 this_size_bits = type_len - offset;
1669 this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
1670 source_offset = source_offset_bits / 8;
1671 if (buffer_size < this_size)
1673 buffer_size = this_size;
1674 buffer = xrealloc (buffer, buffer_size);
1676 intermediate_buffer = buffer;
1678 /* Copy from the source to DEST_BUFFER. */
1679 switch (p->location)
1681 case DWARF_VALUE_REGISTER:
1683 struct gdbarch *arch = get_frame_arch (frame);
1684 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
1686 if (gdb_regnum != -1)
1689 int reg_offset = source_offset;
1691 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
1692 && this_size < register_size (arch, gdb_regnum))
1694 /* Big-endian, and we want less than full size. */
1695 reg_offset = register_size (arch, gdb_regnum) - this_size;
1696 /* We want the lower-order THIS_SIZE_BITS of the bytes
1697 we extract from the register. */
1698 source_offset_bits += 8 * this_size - this_size_bits;
1701 if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
1705 /* Just so garbage doesn't ever shine through. */
1706 memset (buffer, 0, this_size);
1709 mark_value_bits_optimized_out (v, offset, this_size_bits);
1711 mark_value_bits_unavailable (v, offset, this_size_bits);
1716 error (_("Unable to access DWARF register number %s"),
1717 paddress (arch, p->v.regno));
1722 case DWARF_VALUE_MEMORY:
1723 read_value_memory (v, offset,
1724 p->v.mem.in_stack_memory,
1725 p->v.mem.addr + source_offset,
1729 case DWARF_VALUE_STACK:
1731 size_t n = this_size;
1733 if (n > c->addr_size - source_offset)
1734 n = (c->addr_size >= source_offset
1735 ? c->addr_size - source_offset
1743 const gdb_byte *val_bytes = value_contents_all (p->v.value);
1745 intermediate_buffer = val_bytes + source_offset;
1750 case DWARF_VALUE_LITERAL:
1752 size_t n = this_size;
1754 if (n > p->v.literal.length - source_offset)
1755 n = (p->v.literal.length >= source_offset
1756 ? p->v.literal.length - source_offset
1759 intermediate_buffer = p->v.literal.data + source_offset;
1763 /* These bits show up as zeros -- but do not cause the value
1764 to be considered optimized-out. */
1765 case DWARF_VALUE_IMPLICIT_POINTER:
1768 case DWARF_VALUE_OPTIMIZED_OUT:
1769 mark_value_bits_optimized_out (v, offset, this_size_bits);
1773 internal_error (__FILE__, __LINE__, _("invalid location type"));
1776 if (p->location != DWARF_VALUE_OPTIMIZED_OUT
1777 && p->location != DWARF_VALUE_IMPLICIT_POINTER)
1778 copy_bitwise (contents, dest_offset_bits,
1779 intermediate_buffer, source_offset_bits % 8,
1780 this_size_bits, bits_big_endian);
1782 offset += this_size_bits;
1785 do_cleanups (cleanup);
1789 write_pieced_value (struct value *to, struct value *from)
1793 ULONGEST bits_to_skip;
1794 const gdb_byte *contents;
1795 struct piece_closure *c
1796 = (struct piece_closure *) value_computed_closure (to);
1797 struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
1799 size_t buffer_size = 0;
1800 gdb_byte *buffer = NULL;
1801 struct cleanup *cleanup;
1803 = gdbarch_bits_big_endian (get_type_arch (value_type (to)));
1807 mark_value_bytes_optimized_out (to, 0, TYPE_LENGTH (value_type (to)));
1811 cleanup = make_cleanup (free_current_contents, &buffer);
1813 contents = value_contents (from);
1814 bits_to_skip = 8 * value_offset (to);
1815 if (value_bitsize (to))
1817 bits_to_skip += value_bitpos (to);
1818 type_len = value_bitsize (to);
1821 type_len = 8 * TYPE_LENGTH (value_type (to));
1823 for (i = 0; i < c->n_pieces && offset < type_len; i++)
1825 struct dwarf_expr_piece *p = &c->pieces[i];
1826 size_t this_size_bits, this_size;
1827 long dest_offset_bits, source_offset_bits, dest_offset, source_offset;
1829 const gdb_byte *source_buffer;
1831 this_size_bits = p->size;
1832 if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
1834 bits_to_skip -= this_size_bits;
1837 if (this_size_bits > type_len - offset)
1838 this_size_bits = type_len - offset;
1839 if (bits_to_skip > 0)
1841 dest_offset_bits = bits_to_skip;
1842 source_offset_bits = 0;
1843 this_size_bits -= bits_to_skip;
1848 dest_offset_bits = 0;
1849 source_offset_bits = offset;
1852 this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
1853 source_offset = source_offset_bits / 8;
1854 dest_offset = dest_offset_bits / 8;
1855 if (dest_offset_bits % 8 == 0 && source_offset_bits % 8 == 0)
1857 source_buffer = contents + source_offset;
1862 if (buffer_size < this_size)
1864 buffer_size = this_size;
1865 buffer = xrealloc (buffer, buffer_size);
1867 source_buffer = buffer;
1871 switch (p->location)
1873 case DWARF_VALUE_REGISTER:
1875 struct gdbarch *arch = get_frame_arch (frame);
1876 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
1878 if (gdb_regnum != -1)
1880 int reg_offset = dest_offset;
1882 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
1883 && this_size <= register_size (arch, gdb_regnum))
1885 /* Big-endian, and we want less than full size. */
1886 reg_offset = register_size (arch, gdb_regnum) - this_size;
1893 if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
1898 throw_error (OPTIMIZED_OUT_ERROR,
1899 _("Can't do read-modify-write to "
1900 "update bitfield; containing word "
1901 "has been optimized out"));
1903 throw_error (NOT_AVAILABLE_ERROR,
1904 _("Can't do read-modify-write to update "
1905 "bitfield; containing word "
1908 copy_bitwise (buffer, dest_offset_bits,
1909 contents, source_offset_bits,
1914 put_frame_register_bytes (frame, gdb_regnum, reg_offset,
1915 this_size, source_buffer);
1919 error (_("Unable to write to DWARF register number %s"),
1920 paddress (arch, p->v.regno));
1924 case DWARF_VALUE_MEMORY:
1927 /* Only the first and last bytes can possibly have any
1929 read_memory (p->v.mem.addr + dest_offset, buffer, 1);
1930 read_memory (p->v.mem.addr + dest_offset + this_size - 1,
1931 buffer + this_size - 1, 1);
1932 copy_bitwise (buffer, dest_offset_bits,
1933 contents, source_offset_bits,
1938 write_memory (p->v.mem.addr + dest_offset,
1939 source_buffer, this_size);
1942 mark_value_bytes_optimized_out (to, 0, TYPE_LENGTH (value_type (to)));
1945 offset += this_size_bits;
1948 do_cleanups (cleanup);
1951 /* An implementation of an lval_funcs method to see whether a value is
1952 a synthetic pointer. */
1955 check_pieced_synthetic_pointer (const struct value *value, int bit_offset,
1958 struct piece_closure *c
1959 = (struct piece_closure *) value_computed_closure (value);
1962 bit_offset += 8 * value_offset (value);
1963 if (value_bitsize (value))
1964 bit_offset += value_bitpos (value);
1966 for (i = 0; i < c->n_pieces && bit_length > 0; i++)
1968 struct dwarf_expr_piece *p = &c->pieces[i];
1969 size_t this_size_bits = p->size;
1973 if (bit_offset >= this_size_bits)
1975 bit_offset -= this_size_bits;
1979 bit_length -= this_size_bits - bit_offset;
1983 bit_length -= this_size_bits;
1985 if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
1992 /* A wrapper function for get_frame_address_in_block. */
1995 get_frame_address_in_block_wrapper (void *baton)
1997 return get_frame_address_in_block (baton);
2000 /* An implementation of an lval_funcs method to indirect through a
2001 pointer. This handles the synthetic pointer case when needed. */
2003 static struct value *
2004 indirect_pieced_value (struct value *value)
2006 struct piece_closure *c
2007 = (struct piece_closure *) value_computed_closure (value);
2009 struct frame_info *frame;
2010 struct dwarf2_locexpr_baton baton;
2011 int i, bit_offset, bit_length;
2012 struct dwarf_expr_piece *piece = NULL;
2013 LONGEST byte_offset;
2015 type = check_typedef (value_type (value));
2016 if (TYPE_CODE (type) != TYPE_CODE_PTR)
2019 bit_length = 8 * TYPE_LENGTH (type);
2020 bit_offset = 8 * value_offset (value);
2021 if (value_bitsize (value))
2022 bit_offset += value_bitpos (value);
2024 for (i = 0; i < c->n_pieces && bit_length > 0; i++)
2026 struct dwarf_expr_piece *p = &c->pieces[i];
2027 size_t this_size_bits = p->size;
2031 if (bit_offset >= this_size_bits)
2033 bit_offset -= this_size_bits;
2037 bit_length -= this_size_bits - bit_offset;
2041 bit_length -= this_size_bits;
2043 if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
2046 if (bit_length != 0)
2047 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2053 frame = get_selected_frame (_("No frame selected."));
2055 /* This is an offset requested by GDB, such as value subscripts.
2056 However, due to how synthetic pointers are implemented, this is
2057 always presented to us as a pointer type. This means we have to
2058 sign-extend it manually as appropriate. */
2059 byte_offset = value_as_address (value);
2060 if (TYPE_LENGTH (value_type (value)) < sizeof (LONGEST))
2061 byte_offset = gdb_sign_extend (byte_offset,
2062 8 * TYPE_LENGTH (value_type (value)));
2063 byte_offset += piece->v.ptr.offset;
2067 = dwarf2_fetch_die_loc_sect_off (piece->v.ptr.die, c->per_cu,
2068 get_frame_address_in_block_wrapper,
2071 if (baton.data != NULL)
2072 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
2073 baton.data, baton.size, baton.per_cu,
2077 struct obstack temp_obstack;
2078 struct cleanup *cleanup;
2079 const gdb_byte *bytes;
2081 struct value *result;
2083 obstack_init (&temp_obstack);
2084 cleanup = make_cleanup_obstack_free (&temp_obstack);
2086 bytes = dwarf2_fetch_constant_bytes (piece->v.ptr.die, c->per_cu,
2087 &temp_obstack, &len);
2089 result = allocate_optimized_out_value (TYPE_TARGET_TYPE (type));
2093 || byte_offset + TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > len)
2094 invalid_synthetic_pointer ();
2095 bytes += byte_offset;
2096 result = value_from_contents (TYPE_TARGET_TYPE (type), bytes);
2099 do_cleanups (cleanup);
2105 copy_pieced_value_closure (const struct value *v)
2107 struct piece_closure *c
2108 = (struct piece_closure *) value_computed_closure (v);
2115 free_pieced_value_closure (struct value *v)
2117 struct piece_closure *c
2118 = (struct piece_closure *) value_computed_closure (v);
2125 for (i = 0; i < c->n_pieces; ++i)
2126 if (c->pieces[i].location == DWARF_VALUE_STACK)
2127 value_free (c->pieces[i].v.value);
2134 /* Functions for accessing a variable described by DW_OP_piece. */
2135 static const struct lval_funcs pieced_value_funcs = {
2138 indirect_pieced_value,
2139 NULL, /* coerce_ref */
2140 check_pieced_synthetic_pointer,
2141 copy_pieced_value_closure,
2142 free_pieced_value_closure
2145 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2147 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs =
2149 dwarf_expr_read_addr_from_reg,
2150 dwarf_expr_get_reg_value,
2151 dwarf_expr_read_mem,
2152 dwarf_expr_frame_base,
2153 dwarf_expr_frame_cfa,
2154 dwarf_expr_frame_pc,
2155 dwarf_expr_tls_address,
2156 dwarf_expr_dwarf_call,
2157 dwarf_expr_get_base_type,
2158 dwarf_expr_push_dwarf_reg_entry_value,
2159 dwarf_expr_get_addr_index,
2160 dwarf_expr_get_obj_addr
2163 /* Evaluate a location description, starting at DATA and with length
2164 SIZE, to find the current location of variable of TYPE in the
2165 context of FRAME. BYTE_OFFSET is applied after the contents are
2168 static struct value *
2169 dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
2170 const gdb_byte *data, size_t size,
2171 struct dwarf2_per_cu_data *per_cu,
2172 LONGEST byte_offset)
2174 struct value *retval;
2175 struct dwarf_expr_baton baton;
2176 struct dwarf_expr_context *ctx;
2177 struct cleanup *old_chain, *value_chain;
2178 struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
2179 volatile struct gdb_exception ex;
2181 if (byte_offset < 0)
2182 invalid_synthetic_pointer ();
2185 return allocate_optimized_out_value (type);
2187 baton.frame = frame;
2188 baton.per_cu = per_cu;
2189 baton.obj_address = 0;
2191 ctx = new_dwarf_expr_context ();
2192 old_chain = make_cleanup_free_dwarf_expr_context (ctx);
2193 value_chain = make_cleanup_value_free_to_mark (value_mark ());
2195 ctx->gdbarch = get_objfile_arch (objfile);
2196 ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
2197 ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu);
2198 ctx->offset = dwarf2_per_cu_text_offset (per_cu);
2199 ctx->baton = &baton;
2200 ctx->funcs = &dwarf_expr_ctx_funcs;
2202 TRY_CATCH (ex, RETURN_MASK_ERROR)
2204 dwarf_expr_eval (ctx, data, size);
2208 if (ex.error == NOT_AVAILABLE_ERROR)
2210 do_cleanups (old_chain);
2211 retval = allocate_value (type);
2212 mark_value_bytes_unavailable (retval, 0, TYPE_LENGTH (type));
2215 else if (ex.error == NO_ENTRY_VALUE_ERROR)
2217 if (entry_values_debug)
2218 exception_print (gdb_stdout, ex);
2219 do_cleanups (old_chain);
2220 return allocate_optimized_out_value (type);
2223 throw_exception (ex);
2226 if (ctx->num_pieces > 0)
2228 struct piece_closure *c;
2229 struct frame_id frame_id = get_frame_id (frame);
2230 ULONGEST bit_size = 0;
2233 for (i = 0; i < ctx->num_pieces; ++i)
2234 bit_size += ctx->pieces[i].size;
2235 if (8 * (byte_offset + TYPE_LENGTH (type)) > bit_size)
2236 invalid_synthetic_pointer ();
2238 c = allocate_piece_closure (per_cu, ctx->num_pieces, ctx->pieces,
2240 /* We must clean up the value chain after creating the piece
2241 closure but before allocating the result. */
2242 do_cleanups (value_chain);
2243 retval = allocate_computed_value (type, &pieced_value_funcs, c);
2244 VALUE_FRAME_ID (retval) = frame_id;
2245 set_value_offset (retval, byte_offset);
2249 switch (ctx->location)
2251 case DWARF_VALUE_REGISTER:
2253 struct gdbarch *arch = get_frame_arch (frame);
2255 = longest_to_int (value_as_long (dwarf_expr_fetch (ctx, 0)));
2256 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
2258 if (byte_offset != 0)
2259 error (_("cannot use offset on synthetic pointer to register"));
2260 do_cleanups (value_chain);
2261 if (gdb_regnum == -1)
2262 error (_("Unable to access DWARF register number %d"),
2264 retval = value_from_register (type, gdb_regnum, frame);
2265 if (value_optimized_out (retval))
2269 /* This means the register has undefined value / was
2270 not saved. As we're computing the location of some
2271 variable etc. in the program, not a value for
2272 inspecting a register ($pc, $sp, etc.), return a
2273 generic optimized out value instead, so that we show
2274 <optimized out> instead of <not saved>. */
2275 do_cleanups (value_chain);
2276 tmp = allocate_value (type);
2277 value_contents_copy (tmp, 0, retval, 0, TYPE_LENGTH (type));
2283 case DWARF_VALUE_MEMORY:
2285 CORE_ADDR address = dwarf_expr_fetch_address (ctx, 0);
2286 int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
2288 do_cleanups (value_chain);
2289 retval = value_at_lazy (type, address + byte_offset);
2290 if (in_stack_memory)
2291 set_value_stack (retval, 1);
2295 case DWARF_VALUE_STACK:
2297 struct value *value = dwarf_expr_fetch (ctx, 0);
2299 const gdb_byte *val_bytes;
2300 size_t n = TYPE_LENGTH (value_type (value));
2302 if (byte_offset + TYPE_LENGTH (type) > n)
2303 invalid_synthetic_pointer ();
2305 val_bytes = value_contents_all (value);
2306 val_bytes += byte_offset;
2309 /* Preserve VALUE because we are going to free values back
2310 to the mark, but we still need the value contents
2312 value_incref (value);
2313 do_cleanups (value_chain);
2314 make_cleanup_value_free (value);
2316 retval = allocate_value (type);
2317 contents = value_contents_raw (retval);
2318 if (n > TYPE_LENGTH (type))
2320 struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
2322 if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
2323 val_bytes += n - TYPE_LENGTH (type);
2324 n = TYPE_LENGTH (type);
2326 memcpy (contents, val_bytes, n);
2330 case DWARF_VALUE_LITERAL:
2333 const bfd_byte *ldata;
2334 size_t n = ctx->len;
2336 if (byte_offset + TYPE_LENGTH (type) > n)
2337 invalid_synthetic_pointer ();
2339 do_cleanups (value_chain);
2340 retval = allocate_value (type);
2341 contents = value_contents_raw (retval);
2343 ldata = ctx->data + byte_offset;
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 ldata += n - TYPE_LENGTH (type);
2352 n = TYPE_LENGTH (type);
2354 memcpy (contents, ldata, n);
2358 case DWARF_VALUE_OPTIMIZED_OUT:
2359 do_cleanups (value_chain);
2360 retval = allocate_optimized_out_value (type);
2363 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2364 operation by execute_stack_op. */
2365 case DWARF_VALUE_IMPLICIT_POINTER:
2366 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2367 it can only be encountered when making a piece. */
2369 internal_error (__FILE__, __LINE__, _("invalid location type"));
2373 set_value_initialized (retval, ctx->initialized);
2375 do_cleanups (old_chain);
2380 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2381 passes 0 as the byte_offset. */
2384 dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
2385 const gdb_byte *data, size_t size,
2386 struct dwarf2_per_cu_data *per_cu)
2388 return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu, 0);
2391 /* Evaluates a dwarf expression and stores the result in VAL, expecting
2392 that the dwarf expression only produces a single CORE_ADDR. ADDR is a
2393 context (location of a variable) and might be needed to evaluate the
2394 location expression.
2395 Returns 1 on success, 0 otherwise. */
2398 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton,
2402 struct dwarf_expr_context *ctx;
2403 struct dwarf_expr_baton baton;
2404 struct objfile *objfile;
2405 struct cleanup *cleanup;
2407 if (dlbaton == NULL || dlbaton->size == 0)
2410 ctx = new_dwarf_expr_context ();
2411 cleanup = make_cleanup_free_dwarf_expr_context (ctx);
2413 baton.frame = get_selected_frame (NULL);
2414 baton.per_cu = dlbaton->per_cu;
2415 baton.obj_address = addr;
2417 objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
2419 ctx->gdbarch = get_objfile_arch (objfile);
2420 ctx->addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
2421 ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (dlbaton->per_cu);
2422 ctx->offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
2423 ctx->funcs = &dwarf_expr_ctx_funcs;
2424 ctx->baton = &baton;
2426 dwarf_expr_eval (ctx, dlbaton->data, dlbaton->size);
2428 switch (ctx->location)
2430 case DWARF_VALUE_REGISTER:
2431 case DWARF_VALUE_MEMORY:
2432 case DWARF_VALUE_STACK:
2433 *valp = dwarf_expr_fetch_address (ctx, 0);
2434 if (ctx->location == DWARF_VALUE_REGISTER)
2435 *valp = dwarf_expr_read_addr_from_reg (&baton, *valp);
2436 do_cleanups (cleanup);
2438 case DWARF_VALUE_LITERAL:
2439 *valp = extract_signed_integer (ctx->data, ctx->len,
2440 gdbarch_byte_order (ctx->gdbarch));
2441 do_cleanups (cleanup);
2443 /* Unsupported dwarf values. */
2444 case DWARF_VALUE_OPTIMIZED_OUT:
2445 case DWARF_VALUE_IMPLICIT_POINTER:
2449 do_cleanups (cleanup);
2453 /* See dwarf2loc.h. */
2456 dwarf2_evaluate_property (const struct dynamic_prop *prop,
2457 CORE_ADDR address, CORE_ADDR *value)
2466 const struct dwarf2_property_baton *baton = prop->data.baton;
2468 if (dwarf2_locexpr_baton_eval (&baton->locexpr, address, value))
2470 if (baton->referenced_type)
2472 struct value *val = value_at (baton->referenced_type, *value);
2474 *value = value_as_address (val);
2483 struct dwarf2_property_baton *baton = prop->data.baton;
2484 struct frame_info *frame = get_selected_frame (NULL);
2485 CORE_ADDR pc = get_frame_address_in_block (frame);
2486 const gdb_byte *data;
2490 data = dwarf2_find_location_expression (&baton->loclist, &size, pc);
2493 val = dwarf2_evaluate_loc_desc (baton->referenced_type, frame, data,
2494 size, baton->loclist.per_cu);
2495 if (!value_optimized_out (val))
2497 *value = value_as_address (val);
2505 *value = prop->data.const_val;
2513 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2515 struct needs_frame_baton
2518 struct dwarf2_per_cu_data *per_cu;
2521 /* Reads from registers do require a frame. */
2523 needs_frame_read_addr_from_reg (void *baton, int regnum)
2525 struct needs_frame_baton *nf_baton = baton;
2527 nf_baton->needs_frame = 1;
2531 /* struct dwarf_expr_context_funcs' "get_reg_value" callback:
2532 Reads from registers do require a frame. */
2534 static struct value *
2535 needs_frame_get_reg_value (void *baton, struct type *type, int regnum)
2537 struct needs_frame_baton *nf_baton = baton;
2539 nf_baton->needs_frame = 1;
2540 return value_zero (type, not_lval);
2543 /* Reads from memory do not require a frame. */
2545 needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
2547 memset (buf, 0, len);
2550 /* Frame-relative accesses do require a frame. */
2552 needs_frame_frame_base (void *baton, const gdb_byte **start, size_t * length)
2554 static gdb_byte lit0 = DW_OP_lit0;
2555 struct needs_frame_baton *nf_baton = baton;
2560 nf_baton->needs_frame = 1;
2563 /* CFA accesses require a frame. */
2566 needs_frame_frame_cfa (void *baton)
2568 struct needs_frame_baton *nf_baton = baton;
2570 nf_baton->needs_frame = 1;
2574 /* Thread-local accesses do require a frame. */
2576 needs_frame_tls_address (void *baton, CORE_ADDR offset)
2578 struct needs_frame_baton *nf_baton = baton;
2580 nf_baton->needs_frame = 1;
2584 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2587 needs_frame_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
2589 struct needs_frame_baton *nf_baton = ctx->baton;
2591 per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu,
2592 ctx->funcs->get_frame_pc, ctx->baton);
2595 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2598 needs_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
2599 enum call_site_parameter_kind kind,
2600 union call_site_parameter_u kind_u, int deref_size)
2602 struct needs_frame_baton *nf_baton = ctx->baton;
2604 nf_baton->needs_frame = 1;
2606 /* The expression may require some stub values on DWARF stack. */
2607 dwarf_expr_push_address (ctx, 0, 0);
2610 /* DW_OP_GNU_addr_index doesn't require a frame. */
2613 needs_get_addr_index (void *baton, unsigned int index)
2615 /* Nothing to do. */
2619 /* DW_OP_push_object_address has a frame already passed through. */
2622 needs_get_obj_addr (void *baton)
2624 /* Nothing to do. */
2628 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2630 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs =
2632 needs_frame_read_addr_from_reg,
2633 needs_frame_get_reg_value,
2634 needs_frame_read_mem,
2635 needs_frame_frame_base,
2636 needs_frame_frame_cfa,
2637 needs_frame_frame_cfa, /* get_frame_pc */
2638 needs_frame_tls_address,
2639 needs_frame_dwarf_call,
2640 NULL, /* get_base_type */
2641 needs_dwarf_reg_entry_value,
2642 needs_get_addr_index,
2646 /* Return non-zero iff the location expression at DATA (length SIZE)
2647 requires a frame to evaluate. */
2650 dwarf2_loc_desc_needs_frame (const gdb_byte *data, size_t size,
2651 struct dwarf2_per_cu_data *per_cu)
2653 struct needs_frame_baton baton;
2654 struct dwarf_expr_context *ctx;
2656 struct cleanup *old_chain;
2657 struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
2659 baton.needs_frame = 0;
2660 baton.per_cu = per_cu;
2662 ctx = new_dwarf_expr_context ();
2663 old_chain = make_cleanup_free_dwarf_expr_context (ctx);
2664 make_cleanup_value_free_to_mark (value_mark ());
2666 ctx->gdbarch = get_objfile_arch (objfile);
2667 ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
2668 ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu);
2669 ctx->offset = dwarf2_per_cu_text_offset (per_cu);
2670 ctx->baton = &baton;
2671 ctx->funcs = &needs_frame_ctx_funcs;
2673 dwarf_expr_eval (ctx, data, size);
2675 in_reg = ctx->location == DWARF_VALUE_REGISTER;
2677 if (ctx->num_pieces > 0)
2681 /* If the location has several pieces, and any of them are in
2682 registers, then we will need a frame to fetch them from. */
2683 for (i = 0; i < ctx->num_pieces; i++)
2684 if (ctx->pieces[i].location == DWARF_VALUE_REGISTER)
2688 do_cleanups (old_chain);
2690 return baton.needs_frame || in_reg;
2693 /* A helper function that throws an unimplemented error mentioning a
2694 given DWARF operator. */
2697 unimplemented (unsigned int op)
2699 const char *name = get_DW_OP_name (op);
2702 error (_("DWARF operator %s cannot be translated to an agent expression"),
2705 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2706 "to an agent expression"),
2710 /* A helper function to convert a DWARF register to an arch register.
2711 ARCH is the architecture.
2712 DWARF_REG is the register.
2713 This will throw an exception if the DWARF register cannot be
2714 translated to an architecture register. */
2717 translate_register (struct gdbarch *arch, int dwarf_reg)
2719 int reg = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_reg);
2721 error (_("Unable to access DWARF register number %d"), dwarf_reg);
2725 /* A helper function that emits an access to memory. ARCH is the
2726 target architecture. EXPR is the expression which we are building.
2727 NBITS is the number of bits we want to read. This emits the
2728 opcodes needed to read the memory and then extract the desired
2732 access_memory (struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits)
2734 ULONGEST nbytes = (nbits + 7) / 8;
2736 gdb_assert (nbytes > 0 && nbytes <= sizeof (LONGEST));
2739 ax_trace_quick (expr, nbytes);
2742 ax_simple (expr, aop_ref8);
2743 else if (nbits <= 16)
2744 ax_simple (expr, aop_ref16);
2745 else if (nbits <= 32)
2746 ax_simple (expr, aop_ref32);
2748 ax_simple (expr, aop_ref64);
2750 /* If we read exactly the number of bytes we wanted, we're done. */
2751 if (8 * nbytes == nbits)
2754 if (gdbarch_bits_big_endian (arch))
2756 /* On a bits-big-endian machine, we want the high-order
2758 ax_const_l (expr, 8 * nbytes - nbits);
2759 ax_simple (expr, aop_rsh_unsigned);
2763 /* On a bits-little-endian box, we want the low-order NBITS. */
2764 ax_zero_ext (expr, nbits);
2768 /* A helper function to return the frame's PC. */
2771 get_ax_pc (void *baton)
2773 struct agent_expr *expr = baton;
2778 /* Compile a DWARF location expression to an agent expression.
2780 EXPR is the agent expression we are building.
2781 LOC is the agent value we modify.
2782 ARCH is the architecture.
2783 ADDR_SIZE is the size of addresses, in bytes.
2784 OP_PTR is the start of the location expression.
2785 OP_END is one past the last byte of the location expression.
2787 This will throw an exception for various kinds of errors -- for
2788 example, if the expression cannot be compiled, or if the expression
2792 dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
2793 struct gdbarch *arch, unsigned int addr_size,
2794 const gdb_byte *op_ptr, const gdb_byte *op_end,
2795 struct dwarf2_per_cu_data *per_cu)
2797 struct cleanup *cleanups;
2799 VEC(int) *dw_labels = NULL, *patches = NULL;
2800 const gdb_byte * const base = op_ptr;
2801 const gdb_byte *previous_piece = op_ptr;
2802 enum bfd_endian byte_order = gdbarch_byte_order (arch);
2803 ULONGEST bits_collected = 0;
2804 unsigned int addr_size_bits = 8 * addr_size;
2805 int bits_big_endian = gdbarch_bits_big_endian (arch);
2807 offsets = xmalloc ((op_end - op_ptr) * sizeof (int));
2808 cleanups = make_cleanup (xfree, offsets);
2810 for (i = 0; i < op_end - op_ptr; ++i)
2813 make_cleanup (VEC_cleanup (int), &dw_labels);
2814 make_cleanup (VEC_cleanup (int), &patches);
2816 /* By default we are making an address. */
2817 loc->kind = axs_lvalue_memory;
2819 while (op_ptr < op_end)
2821 enum dwarf_location_atom op = *op_ptr;
2822 uint64_t uoffset, reg;
2826 offsets[op_ptr - base] = expr->len;
2829 /* Our basic approach to code generation is to map DWARF
2830 operations directly to AX operations. However, there are
2833 First, DWARF works on address-sized units, but AX always uses
2834 LONGEST. For most operations we simply ignore this
2835 difference; instead we generate sign extensions as needed
2836 before division and comparison operations. It would be nice
2837 to omit the sign extensions, but there is no way to determine
2838 the size of the target's LONGEST. (This code uses the size
2839 of the host LONGEST in some cases -- that is a bug but it is
2842 Second, some DWARF operations cannot be translated to AX.
2843 For these we simply fail. See
2844 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2879 ax_const_l (expr, op - DW_OP_lit0);
2883 uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order);
2884 op_ptr += addr_size;
2885 /* Some versions of GCC emit DW_OP_addr before
2886 DW_OP_GNU_push_tls_address. In this case the value is an
2887 index, not an address. We don't support things like
2888 branching between the address and the TLS op. */
2889 if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
2890 uoffset += dwarf2_per_cu_text_offset (per_cu);
2891 ax_const_l (expr, uoffset);
2895 ax_const_l (expr, extract_unsigned_integer (op_ptr, 1, byte_order));
2899 ax_const_l (expr, extract_signed_integer (op_ptr, 1, byte_order));
2903 ax_const_l (expr, extract_unsigned_integer (op_ptr, 2, byte_order));
2907 ax_const_l (expr, extract_signed_integer (op_ptr, 2, byte_order));
2911 ax_const_l (expr, extract_unsigned_integer (op_ptr, 4, byte_order));
2915 ax_const_l (expr, extract_signed_integer (op_ptr, 4, byte_order));
2919 ax_const_l (expr, extract_unsigned_integer (op_ptr, 8, byte_order));
2923 ax_const_l (expr, extract_signed_integer (op_ptr, 8, byte_order));
2927 op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
2928 ax_const_l (expr, uoffset);
2931 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
2932 ax_const_l (expr, offset);
2967 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
2968 loc->u.reg = translate_register (arch, op - DW_OP_reg0);
2969 loc->kind = axs_lvalue_register;
2973 op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
2974 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
2975 loc->u.reg = translate_register (arch, reg);
2976 loc->kind = axs_lvalue_register;
2979 case DW_OP_implicit_value:
2983 op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
2984 if (op_ptr + len > op_end)
2985 error (_("DW_OP_implicit_value: too few bytes available."));
2986 if (len > sizeof (ULONGEST))
2987 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
2990 ax_const_l (expr, extract_unsigned_integer (op_ptr, len,
2993 dwarf_expr_require_composition (op_ptr, op_end,
2994 "DW_OP_implicit_value");
2996 loc->kind = axs_rvalue;
3000 case DW_OP_stack_value:
3001 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
3002 loc->kind = axs_rvalue;
3037 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
3038 i = translate_register (arch, op - DW_OP_breg0);
3042 ax_const_l (expr, offset);
3043 ax_simple (expr, aop_add);
3048 op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
3049 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
3050 i = translate_register (arch, reg);
3054 ax_const_l (expr, offset);
3055 ax_simple (expr, aop_add);
3061 const gdb_byte *datastart;
3063 const struct block *b;
3064 struct symbol *framefunc;
3066 b = block_for_pc (expr->scope);
3069 error (_("No block found for address"));
3071 framefunc = block_linkage_function (b);
3074 error (_("No function found for block"));
3076 func_get_frame_base_dwarf_block (framefunc, expr->scope,
3077 &datastart, &datalen);
3079 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
3080 dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart,
3081 datastart + datalen, per_cu);
3082 if (loc->kind == axs_lvalue_register)
3083 require_rvalue (expr, loc);
3087 ax_const_l (expr, offset);
3088 ax_simple (expr, aop_add);
3091 loc->kind = axs_lvalue_memory;
3096 ax_simple (expr, aop_dup);
3100 ax_simple (expr, aop_pop);
3105 ax_pick (expr, offset);
3109 ax_simple (expr, aop_swap);
3117 ax_simple (expr, aop_rot);
3121 case DW_OP_deref_size:
3125 if (op == DW_OP_deref_size)
3130 if (size != 1 && size != 2 && size != 4 && size != 8)
3131 error (_("Unsupported size %d in %s"),
3132 size, get_DW_OP_name (op));
3133 access_memory (arch, expr, size * TARGET_CHAR_BIT);
3138 /* Sign extend the operand. */
3139 ax_ext (expr, addr_size_bits);
3140 ax_simple (expr, aop_dup);
3141 ax_const_l (expr, 0);
3142 ax_simple (expr, aop_less_signed);
3143 ax_simple (expr, aop_log_not);
3144 i = ax_goto (expr, aop_if_goto);
3145 /* We have to emit 0 - X. */
3146 ax_const_l (expr, 0);
3147 ax_simple (expr, aop_swap);
3148 ax_simple (expr, aop_sub);
3149 ax_label (expr, i, expr->len);
3153 /* No need to sign extend here. */
3154 ax_const_l (expr, 0);
3155 ax_simple (expr, aop_swap);
3156 ax_simple (expr, aop_sub);
3160 /* Sign extend the operand. */
3161 ax_ext (expr, addr_size_bits);
3162 ax_simple (expr, aop_bit_not);
3165 case DW_OP_plus_uconst:
3166 op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
3167 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3168 but we micro-optimize anyhow. */
3171 ax_const_l (expr, reg);
3172 ax_simple (expr, aop_add);
3177 ax_simple (expr, aop_bit_and);
3181 /* Sign extend the operands. */
3182 ax_ext (expr, addr_size_bits);
3183 ax_simple (expr, aop_swap);
3184 ax_ext (expr, addr_size_bits);
3185 ax_simple (expr, aop_swap);
3186 ax_simple (expr, aop_div_signed);
3190 ax_simple (expr, aop_sub);
3194 ax_simple (expr, aop_rem_unsigned);
3198 ax_simple (expr, aop_mul);
3202 ax_simple (expr, aop_bit_or);
3206 ax_simple (expr, aop_add);
3210 ax_simple (expr, aop_lsh);
3214 ax_simple (expr, aop_rsh_unsigned);
3218 ax_simple (expr, aop_rsh_signed);
3222 ax_simple (expr, aop_bit_xor);
3226 /* Sign extend the operands. */
3227 ax_ext (expr, addr_size_bits);
3228 ax_simple (expr, aop_swap);
3229 ax_ext (expr, addr_size_bits);
3230 /* Note no swap here: A <= B is !(B < A). */
3231 ax_simple (expr, aop_less_signed);
3232 ax_simple (expr, aop_log_not);
3236 /* Sign extend the operands. */
3237 ax_ext (expr, addr_size_bits);
3238 ax_simple (expr, aop_swap);
3239 ax_ext (expr, addr_size_bits);
3240 ax_simple (expr, aop_swap);
3241 /* A >= B is !(A < B). */
3242 ax_simple (expr, aop_less_signed);
3243 ax_simple (expr, aop_log_not);
3247 /* Sign extend the operands. */
3248 ax_ext (expr, addr_size_bits);
3249 ax_simple (expr, aop_swap);
3250 ax_ext (expr, addr_size_bits);
3251 /* No need for a second swap here. */
3252 ax_simple (expr, aop_equal);
3256 /* Sign extend the operands. */
3257 ax_ext (expr, addr_size_bits);
3258 ax_simple (expr, aop_swap);
3259 ax_ext (expr, addr_size_bits);
3260 ax_simple (expr, aop_swap);
3261 ax_simple (expr, aop_less_signed);
3265 /* Sign extend the operands. */
3266 ax_ext (expr, addr_size_bits);
3267 ax_simple (expr, aop_swap);
3268 ax_ext (expr, addr_size_bits);
3269 /* Note no swap here: A > B is B < A. */
3270 ax_simple (expr, aop_less_signed);
3274 /* Sign extend the operands. */
3275 ax_ext (expr, addr_size_bits);
3276 ax_simple (expr, aop_swap);
3277 ax_ext (expr, addr_size_bits);
3278 /* No need for a swap here. */
3279 ax_simple (expr, aop_equal);
3280 ax_simple (expr, aop_log_not);
3283 case DW_OP_call_frame_cfa:
3286 CORE_ADDR text_offset;
3288 const gdb_byte *cfa_start, *cfa_end;
3290 if (dwarf2_fetch_cfa_info (arch, expr->scope, per_cu,
3292 &text_offset, &cfa_start, &cfa_end))
3295 ax_reg (expr, regnum);
3298 ax_const_l (expr, off);
3299 ax_simple (expr, aop_add);
3304 /* Another expression. */
3305 ax_const_l (expr, text_offset);
3306 dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
3307 cfa_start, cfa_end, per_cu);
3310 loc->kind = axs_lvalue_memory;
3314 case DW_OP_GNU_push_tls_address:
3318 case DW_OP_push_object_address:
3323 offset = extract_signed_integer (op_ptr, 2, byte_order);
3325 i = ax_goto (expr, aop_goto);
3326 VEC_safe_push (int, dw_labels, op_ptr + offset - base);
3327 VEC_safe_push (int, patches, i);
3331 offset = extract_signed_integer (op_ptr, 2, byte_order);
3333 /* Zero extend the operand. */
3334 ax_zero_ext (expr, addr_size_bits);
3335 i = ax_goto (expr, aop_if_goto);
3336 VEC_safe_push (int, dw_labels, op_ptr + offset - base);
3337 VEC_safe_push (int, patches, i);
3344 case DW_OP_bit_piece:
3346 uint64_t size, offset;
3348 if (op_ptr - 1 == previous_piece)
3349 error (_("Cannot translate empty pieces to agent expressions"));
3350 previous_piece = op_ptr - 1;
3352 op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
3353 if (op == DW_OP_piece)
3359 op_ptr = safe_read_uleb128 (op_ptr, op_end, &offset);
3361 if (bits_collected + size > 8 * sizeof (LONGEST))
3362 error (_("Expression pieces exceed word size"));
3364 /* Access the bits. */
3367 case axs_lvalue_register:
3368 ax_reg (expr, loc->u.reg);
3371 case axs_lvalue_memory:
3372 /* Offset the pointer, if needed. */
3375 ax_const_l (expr, offset / 8);
3376 ax_simple (expr, aop_add);
3379 access_memory (arch, expr, size);
3383 /* For a bits-big-endian target, shift up what we already
3384 have. For a bits-little-endian target, shift up the
3385 new data. Note that there is a potential bug here if
3386 the DWARF expression leaves multiple values on the
3388 if (bits_collected > 0)
3390 if (bits_big_endian)
3392 ax_simple (expr, aop_swap);
3393 ax_const_l (expr, size);
3394 ax_simple (expr, aop_lsh);
3395 /* We don't need a second swap here, because
3396 aop_bit_or is symmetric. */
3400 ax_const_l (expr, size);
3401 ax_simple (expr, aop_lsh);
3403 ax_simple (expr, aop_bit_or);
3406 bits_collected += size;
3407 loc->kind = axs_rvalue;
3411 case DW_OP_GNU_uninit:
3417 struct dwarf2_locexpr_baton block;
3418 int size = (op == DW_OP_call2 ? 2 : 4);
3421 uoffset = extract_unsigned_integer (op_ptr, size, byte_order);
3424 offset.cu_off = uoffset;
3425 block = dwarf2_fetch_die_loc_cu_off (offset, per_cu,
3428 /* DW_OP_call_ref is currently not supported. */
3429 gdb_assert (block.per_cu == per_cu);
3431 dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
3432 block.data, block.data + block.size,
3437 case DW_OP_call_ref:
3445 /* Patch all the branches we emitted. */
3446 for (i = 0; i < VEC_length (int, patches); ++i)
3448 int targ = offsets[VEC_index (int, dw_labels, i)];
3450 internal_error (__FILE__, __LINE__, _("invalid label"));
3451 ax_label (expr, VEC_index (int, patches, i), targ);
3454 do_cleanups (cleanups);
3458 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3459 evaluator to calculate the location. */
3460 static struct value *
3461 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
3463 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3466 val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, dlbaton->data,
3467 dlbaton->size, dlbaton->per_cu);
3472 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3473 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3476 static struct value *
3477 locexpr_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
3479 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3481 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, dlbaton->data,
3485 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3487 locexpr_read_needs_frame (struct symbol *symbol)
3489 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3491 return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
3495 /* Return true if DATA points to the end of a piece. END is one past
3496 the last byte in the expression. */
3499 piece_end_p (const gdb_byte *data, const gdb_byte *end)
3501 return data == end || data[0] == DW_OP_piece || data[0] == DW_OP_bit_piece;
3504 /* Helper for locexpr_describe_location_piece that finds the name of a
3508 locexpr_regname (struct gdbarch *gdbarch, int dwarf_regnum)
3512 regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
3513 return gdbarch_register_name (gdbarch, regnum);
3516 /* Nicely describe a single piece of a location, returning an updated
3517 position in the bytecode sequence. This function cannot recognize
3518 all locations; if a location is not recognized, it simply returns
3519 DATA. If there is an error during reading, e.g. we run off the end
3520 of the buffer, an error is thrown. */
3522 static const gdb_byte *
3523 locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
3524 CORE_ADDR addr, struct objfile *objfile,
3525 struct dwarf2_per_cu_data *per_cu,
3526 const gdb_byte *data, const gdb_byte *end,
3527 unsigned int addr_size)
3529 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3532 if (data[0] >= DW_OP_reg0 && data[0] <= DW_OP_reg31)
3534 fprintf_filtered (stream, _("a variable in $%s"),
3535 locexpr_regname (gdbarch, data[0] - DW_OP_reg0));
3538 else if (data[0] == DW_OP_regx)
3542 data = safe_read_uleb128 (data + 1, end, ®);
3543 fprintf_filtered (stream, _("a variable in $%s"),
3544 locexpr_regname (gdbarch, reg));
3546 else if (data[0] == DW_OP_fbreg)
3548 const struct block *b;
3549 struct symbol *framefunc;
3551 int64_t frame_offset;
3552 const gdb_byte *base_data, *new_data, *save_data = data;
3554 int64_t base_offset = 0;
3556 new_data = safe_read_sleb128 (data + 1, end, &frame_offset);
3557 if (!piece_end_p (new_data, end))
3561 b = block_for_pc (addr);
3564 error (_("No block found for address for symbol \"%s\"."),
3565 SYMBOL_PRINT_NAME (symbol));
3567 framefunc = block_linkage_function (b);
3570 error (_("No function found for block for symbol \"%s\"."),
3571 SYMBOL_PRINT_NAME (symbol));
3573 func_get_frame_base_dwarf_block (framefunc, addr, &base_data, &base_size);
3575 if (base_data[0] >= DW_OP_breg0 && base_data[0] <= DW_OP_breg31)
3577 const gdb_byte *buf_end;
3579 frame_reg = base_data[0] - DW_OP_breg0;
3580 buf_end = safe_read_sleb128 (base_data + 1, base_data + base_size,
3582 if (buf_end != base_data + base_size)
3583 error (_("Unexpected opcode after "
3584 "DW_OP_breg%u for symbol \"%s\"."),
3585 frame_reg, SYMBOL_PRINT_NAME (symbol));
3587 else if (base_data[0] >= DW_OP_reg0 && base_data[0] <= DW_OP_reg31)
3589 /* The frame base is just the register, with no offset. */
3590 frame_reg = base_data[0] - DW_OP_reg0;
3595 /* We don't know what to do with the frame base expression,
3596 so we can't trace this variable; give up. */
3600 fprintf_filtered (stream,
3601 _("a variable at frame base reg $%s offset %s+%s"),
3602 locexpr_regname (gdbarch, frame_reg),
3603 plongest (base_offset), plongest (frame_offset));
3605 else if (data[0] >= DW_OP_breg0 && data[0] <= DW_OP_breg31
3606 && piece_end_p (data, end))
3610 data = safe_read_sleb128 (data + 1, end, &offset);
3612 fprintf_filtered (stream,
3613 _("a variable at offset %s from base reg $%s"),
3615 locexpr_regname (gdbarch, data[0] - DW_OP_breg0));
3618 /* The location expression for a TLS variable looks like this (on a
3621 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3622 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3624 0x3 is the encoding for DW_OP_addr, which has an operand as long
3625 as the size of an address on the target machine (here is 8
3626 bytes). Note that more recent version of GCC emit DW_OP_const4u
3627 or DW_OP_const8u, depending on address size, rather than
3628 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3629 The operand represents the offset at which the variable is within
3630 the thread local storage. */
3632 else if (data + 1 + addr_size < end
3633 && (data[0] == DW_OP_addr
3634 || (addr_size == 4 && data[0] == DW_OP_const4u)
3635 || (addr_size == 8 && data[0] == DW_OP_const8u))
3636 && data[1 + addr_size] == DW_OP_GNU_push_tls_address
3637 && piece_end_p (data + 2 + addr_size, end))
3640 offset = extract_unsigned_integer (data + 1, addr_size,
3641 gdbarch_byte_order (gdbarch));
3643 fprintf_filtered (stream,
3644 _("a thread-local variable at offset 0x%s "
3645 "in the thread-local storage for `%s'"),
3646 phex_nz (offset, addr_size), objfile_name (objfile));
3648 data += 1 + addr_size + 1;
3651 /* With -gsplit-dwarf a TLS variable can also look like this:
3652 DW_AT_location : 3 byte block: fc 4 e0
3653 (DW_OP_GNU_const_index: 4;
3654 DW_OP_GNU_push_tls_address) */
3655 else if (data + 3 <= end
3656 && data + 1 + (leb128_size = skip_leb128 (data + 1, end)) < end
3657 && data[0] == DW_OP_GNU_const_index
3659 && data[1 + leb128_size] == DW_OP_GNU_push_tls_address
3660 && piece_end_p (data + 2 + leb128_size, end))
3664 data = safe_read_uleb128 (data + 1, end, &offset);
3665 offset = dwarf2_read_addr_index (per_cu, offset);
3666 fprintf_filtered (stream,
3667 _("a thread-local variable at offset 0x%s "
3668 "in the thread-local storage for `%s'"),
3669 phex_nz (offset, addr_size), objfile_name (objfile));
3673 else if (data[0] >= DW_OP_lit0
3674 && data[0] <= DW_OP_lit31
3676 && data[1] == DW_OP_stack_value)
3678 fprintf_filtered (stream, _("the constant %d"), data[0] - DW_OP_lit0);
3685 /* Disassemble an expression, stopping at the end of a piece or at the
3686 end of the expression. Returns a pointer to the next unread byte
3687 in the input expression. If ALL is nonzero, then this function
3688 will keep going until it reaches the end of the expression.
3689 If there is an error during reading, e.g. we run off the end
3690 of the buffer, an error is thrown. */
3692 static const gdb_byte *
3693 disassemble_dwarf_expression (struct ui_file *stream,
3694 struct gdbarch *arch, unsigned int addr_size,
3695 int offset_size, const gdb_byte *start,
3696 const gdb_byte *data, const gdb_byte *end,
3697 int indent, int all,
3698 struct dwarf2_per_cu_data *per_cu)
3702 || (data[0] != DW_OP_piece && data[0] != DW_OP_bit_piece)))
3704 enum dwarf_location_atom op = *data++;
3709 name = get_DW_OP_name (op);
3712 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3713 op, (long) (data - 1 - start));
3714 fprintf_filtered (stream, " %*ld: %s", indent + 4,
3715 (long) (data - 1 - start), name);
3720 ul = extract_unsigned_integer (data, addr_size,
3721 gdbarch_byte_order (arch));
3723 fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size));
3727 ul = extract_unsigned_integer (data, 1, gdbarch_byte_order (arch));
3729 fprintf_filtered (stream, " %s", pulongest (ul));
3732 l = extract_signed_integer (data, 1, gdbarch_byte_order (arch));
3734 fprintf_filtered (stream, " %s", plongest (l));
3737 ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
3739 fprintf_filtered (stream, " %s", pulongest (ul));
3742 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3744 fprintf_filtered (stream, " %s", plongest (l));
3747 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
3749 fprintf_filtered (stream, " %s", pulongest (ul));
3752 l = extract_signed_integer (data, 4, gdbarch_byte_order (arch));
3754 fprintf_filtered (stream, " %s", plongest (l));
3757 ul = extract_unsigned_integer (data, 8, gdbarch_byte_order (arch));
3759 fprintf_filtered (stream, " %s", pulongest (ul));
3762 l = extract_signed_integer (data, 8, gdbarch_byte_order (arch));
3764 fprintf_filtered (stream, " %s", plongest (l));
3767 data = safe_read_uleb128 (data, end, &ul);
3768 fprintf_filtered (stream, " %s", pulongest (ul));
3771 data = safe_read_sleb128 (data, end, &l);
3772 fprintf_filtered (stream, " %s", plongest (l));
3807 fprintf_filtered (stream, " [$%s]",
3808 locexpr_regname (arch, op - DW_OP_reg0));
3812 data = safe_read_uleb128 (data, end, &ul);
3813 fprintf_filtered (stream, " %s [$%s]", pulongest (ul),
3814 locexpr_regname (arch, (int) ul));
3817 case DW_OP_implicit_value:
3818 data = safe_read_uleb128 (data, end, &ul);
3820 fprintf_filtered (stream, " %s", pulongest (ul));
3855 data = safe_read_sleb128 (data, end, &l);
3856 fprintf_filtered (stream, " %s [$%s]", plongest (l),
3857 locexpr_regname (arch, op - DW_OP_breg0));
3861 data = safe_read_uleb128 (data, end, &ul);
3862 data = safe_read_sleb128 (data, end, &l);
3863 fprintf_filtered (stream, " register %s [$%s] offset %s",
3865 locexpr_regname (arch, (int) ul),
3870 data = safe_read_sleb128 (data, end, &l);
3871 fprintf_filtered (stream, " %s", plongest (l));
3874 case DW_OP_xderef_size:
3875 case DW_OP_deref_size:
3877 fprintf_filtered (stream, " %d", *data);
3881 case DW_OP_plus_uconst:
3882 data = safe_read_uleb128 (data, end, &ul);
3883 fprintf_filtered (stream, " %s", pulongest (ul));
3887 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3889 fprintf_filtered (stream, " to %ld",
3890 (long) (data + l - start));
3894 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3896 fprintf_filtered (stream, " %ld",
3897 (long) (data + l - start));
3901 ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
3903 fprintf_filtered (stream, " offset %s", phex_nz (ul, 2));
3907 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
3909 fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
3912 case DW_OP_call_ref:
3913 ul = extract_unsigned_integer (data, offset_size,
3914 gdbarch_byte_order (arch));
3915 data += offset_size;
3916 fprintf_filtered (stream, " offset %s", phex_nz (ul, offset_size));
3920 data = safe_read_uleb128 (data, end, &ul);
3921 fprintf_filtered (stream, " %s (bytes)", pulongest (ul));
3924 case DW_OP_bit_piece:
3928 data = safe_read_uleb128 (data, end, &ul);
3929 data = safe_read_uleb128 (data, end, &offset);
3930 fprintf_filtered (stream, " size %s offset %s (bits)",
3931 pulongest (ul), pulongest (offset));
3935 case DW_OP_GNU_implicit_pointer:
3937 ul = extract_unsigned_integer (data, offset_size,
3938 gdbarch_byte_order (arch));
3939 data += offset_size;
3941 data = safe_read_sleb128 (data, end, &l);
3943 fprintf_filtered (stream, " DIE %s offset %s",
3944 phex_nz (ul, offset_size),
3949 case DW_OP_GNU_deref_type:
3951 int addr_size = *data++;
3955 data = safe_read_uleb128 (data, end, &ul);
3957 type = dwarf2_get_die_type (offset, per_cu);
3958 fprintf_filtered (stream, "<");
3959 type_print (type, "", stream, -1);
3960 fprintf_filtered (stream, " [0x%s]> %d", phex_nz (offset.cu_off, 0),
3965 case DW_OP_GNU_const_type:
3970 data = safe_read_uleb128 (data, end, &ul);
3971 type_die.cu_off = ul;
3972 type = dwarf2_get_die_type (type_die, per_cu);
3973 fprintf_filtered (stream, "<");
3974 type_print (type, "", stream, -1);
3975 fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die.cu_off, 0));
3979 case DW_OP_GNU_regval_type:
3985 data = safe_read_uleb128 (data, end, ®);
3986 data = safe_read_uleb128 (data, end, &ul);
3987 type_die.cu_off = ul;
3989 type = dwarf2_get_die_type (type_die, per_cu);
3990 fprintf_filtered (stream, "<");
3991 type_print (type, "", stream, -1);
3992 fprintf_filtered (stream, " [0x%s]> [$%s]",
3993 phex_nz (type_die.cu_off, 0),
3994 locexpr_regname (arch, reg));
3998 case DW_OP_GNU_convert:
3999 case DW_OP_GNU_reinterpret:
4003 data = safe_read_uleb128 (data, end, &ul);
4004 type_die.cu_off = ul;
4006 if (type_die.cu_off == 0)
4007 fprintf_filtered (stream, "<0>");
4012 type = dwarf2_get_die_type (type_die, per_cu);
4013 fprintf_filtered (stream, "<");
4014 type_print (type, "", stream, -1);
4015 fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die.cu_off, 0));
4020 case DW_OP_GNU_entry_value:
4021 data = safe_read_uleb128 (data, end, &ul);
4022 fputc_filtered ('\n', stream);
4023 disassemble_dwarf_expression (stream, arch, addr_size, offset_size,
4024 start, data, data + ul, indent + 2,
4029 case DW_OP_GNU_parameter_ref:
4030 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
4032 fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
4035 case DW_OP_GNU_addr_index:
4036 data = safe_read_uleb128 (data, end, &ul);
4037 ul = dwarf2_read_addr_index (per_cu, ul);
4038 fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size));
4040 case DW_OP_GNU_const_index:
4041 data = safe_read_uleb128 (data, end, &ul);
4042 ul = dwarf2_read_addr_index (per_cu, ul);
4043 fprintf_filtered (stream, " %s", pulongest (ul));
4047 fprintf_filtered (stream, "\n");
4053 /* Describe a single location, which may in turn consist of multiple
4057 locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr,
4058 struct ui_file *stream,
4059 const gdb_byte *data, size_t size,
4060 struct objfile *objfile, unsigned int addr_size,
4061 int offset_size, struct dwarf2_per_cu_data *per_cu)
4063 const gdb_byte *end = data + size;
4064 int first_piece = 1, bad = 0;
4068 const gdb_byte *here = data;
4069 int disassemble = 1;
4074 fprintf_filtered (stream, _(", and "));
4076 if (!dwarf2_always_disassemble)
4078 data = locexpr_describe_location_piece (symbol, stream,
4079 addr, objfile, per_cu,
4080 data, end, addr_size);
4081 /* If we printed anything, or if we have an empty piece,
4082 then don't disassemble. */
4084 || data[0] == DW_OP_piece
4085 || data[0] == DW_OP_bit_piece)
4090 fprintf_filtered (stream, _("a complex DWARF expression:\n"));
4091 data = disassemble_dwarf_expression (stream,
4092 get_objfile_arch (objfile),
4093 addr_size, offset_size, data,
4095 dwarf2_always_disassemble,
4101 int empty = data == here;
4104 fprintf_filtered (stream, " ");
4105 if (data[0] == DW_OP_piece)
4109 data = safe_read_uleb128 (data + 1, end, &bytes);
4112 fprintf_filtered (stream, _("an empty %s-byte piece"),
4115 fprintf_filtered (stream, _(" [%s-byte piece]"),
4118 else if (data[0] == DW_OP_bit_piece)
4120 uint64_t bits, offset;
4122 data = safe_read_uleb128 (data + 1, end, &bits);
4123 data = safe_read_uleb128 (data, end, &offset);
4126 fprintf_filtered (stream,
4127 _("an empty %s-bit piece"),
4130 fprintf_filtered (stream,
4131 _(" [%s-bit piece, offset %s bits]"),
4132 pulongest (bits), pulongest (offset));
4142 if (bad || data > end)
4143 error (_("Corrupted DWARF2 expression for \"%s\"."),
4144 SYMBOL_PRINT_NAME (symbol));
4147 /* Print a natural-language description of SYMBOL to STREAM. This
4148 version is for a symbol with a single location. */
4151 locexpr_describe_location (struct symbol *symbol, CORE_ADDR addr,
4152 struct ui_file *stream)
4154 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4155 struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
4156 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4157 int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
4159 locexpr_describe_location_1 (symbol, addr, stream,
4160 dlbaton->data, dlbaton->size,
4161 objfile, addr_size, offset_size,
4165 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4166 any necessary bytecode in AX. */
4169 locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
4170 struct agent_expr *ax, struct axs_value *value)
4172 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4173 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4175 if (dlbaton->size == 0)
4176 value->optimized_out = 1;
4178 dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size,
4179 dlbaton->data, dlbaton->data + dlbaton->size,
4183 /* The set of location functions used with the DWARF-2 expression
4185 const struct symbol_computed_ops dwarf2_locexpr_funcs = {
4186 locexpr_read_variable,
4187 locexpr_read_variable_at_entry,
4188 locexpr_read_needs_frame,
4189 locexpr_describe_location,
4190 0, /* location_has_loclist */
4191 locexpr_tracepoint_var_ref
4195 /* Wrapper functions for location lists. These generally find
4196 the appropriate location expression and call something above. */
4198 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4199 evaluator to calculate the location. */
4200 static struct value *
4201 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
4203 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4205 const gdb_byte *data;
4207 CORE_ADDR pc = frame ? get_frame_address_in_block (frame) : 0;
4209 data = dwarf2_find_location_expression (dlbaton, &size, pc);
4210 val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, data, size,
4216 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4217 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4220 Function always returns non-NULL value, it may be marked optimized out if
4221 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4222 if it cannot resolve the parameter for any reason. */
4224 static struct value *
4225 loclist_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
4227 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4228 const gdb_byte *data;
4232 if (frame == NULL || !get_frame_func_if_available (frame, &pc))
4233 return allocate_optimized_out_value (SYMBOL_TYPE (symbol));
4235 data = dwarf2_find_location_expression (dlbaton, &size, pc);
4237 return allocate_optimized_out_value (SYMBOL_TYPE (symbol));
4239 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, data, size);
4242 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
4244 loclist_read_needs_frame (struct symbol *symbol)
4246 /* If there's a location list, then assume we need to have a frame
4247 to choose the appropriate location expression. With tracking of
4248 global variables this is not necessarily true, but such tracking
4249 is disabled in GCC at the moment until we figure out how to
4255 /* Print a natural-language description of SYMBOL to STREAM. This
4256 version applies when there is a list of different locations, each
4257 with a specified address range. */
4260 loclist_describe_location (struct symbol *symbol, CORE_ADDR addr,
4261 struct ui_file *stream)
4263 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4264 const gdb_byte *loc_ptr, *buf_end;
4265 struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
4266 struct gdbarch *gdbarch = get_objfile_arch (objfile);
4267 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4268 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4269 int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
4270 int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
4271 /* Adjust base_address for relocatable objects. */
4272 CORE_ADDR base_offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
4273 CORE_ADDR base_address = dlbaton->base_address + base_offset;
4276 loc_ptr = dlbaton->data;
4277 buf_end = dlbaton->data + dlbaton->size;
4279 fprintf_filtered (stream, _("multi-location:\n"));
4281 /* Iterate through locations until we run out. */
4284 CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */
4286 enum debug_loc_kind kind;
4287 const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */
4289 if (dlbaton->from_dwo)
4290 kind = decode_debug_loc_dwo_addresses (dlbaton->per_cu,
4291 loc_ptr, buf_end, &new_ptr,
4292 &low, &high, byte_order);
4294 kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
4296 byte_order, addr_size,
4301 case DEBUG_LOC_END_OF_LIST:
4304 case DEBUG_LOC_BASE_ADDRESS:
4305 base_address = high + base_offset;
4306 fprintf_filtered (stream, _(" Base address %s"),
4307 paddress (gdbarch, base_address));
4309 case DEBUG_LOC_START_END:
4310 case DEBUG_LOC_START_LENGTH:
4312 case DEBUG_LOC_BUFFER_OVERFLOW:
4313 case DEBUG_LOC_INVALID_ENTRY:
4314 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4315 SYMBOL_PRINT_NAME (symbol));
4317 gdb_assert_not_reached ("bad debug_loc_kind");
4320 /* Otherwise, a location expression entry. */
4321 low += base_address;
4322 high += base_address;
4324 low = gdbarch_adjust_dwarf2_addr (gdbarch, low);
4325 high = gdbarch_adjust_dwarf2_addr (gdbarch, high);
4327 length = extract_unsigned_integer (loc_ptr, 2, byte_order);
4330 /* (It would improve readability to print only the minimum
4331 necessary digits of the second number of the range.) */
4332 fprintf_filtered (stream, _(" Range %s-%s: "),
4333 paddress (gdbarch, low), paddress (gdbarch, high));
4335 /* Now describe this particular location. */
4336 locexpr_describe_location_1 (symbol, low, stream, loc_ptr, length,
4337 objfile, addr_size, offset_size,
4340 fprintf_filtered (stream, "\n");
4346 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4347 any necessary bytecode in AX. */
4349 loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
4350 struct agent_expr *ax, struct axs_value *value)
4352 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4353 const gdb_byte *data;
4355 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4357 data = dwarf2_find_location_expression (dlbaton, &size, ax->scope);
4359 value->optimized_out = 1;
4361 dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size, data, data + size,
4365 /* The set of location functions used with the DWARF-2 expression
4366 evaluator and location lists. */
4367 const struct symbol_computed_ops dwarf2_loclist_funcs = {
4368 loclist_read_variable,
4369 loclist_read_variable_at_entry,
4370 loclist_read_needs_frame,
4371 loclist_describe_location,
4372 1, /* location_has_loclist */
4373 loclist_tracepoint_var_ref
4376 /* Provide a prototype to silence -Wmissing-prototypes. */
4377 extern initialize_file_ftype _initialize_dwarf2loc;
4380 _initialize_dwarf2loc (void)
4382 add_setshow_zuinteger_cmd ("entry-values", class_maintenance,
4383 &entry_values_debug,
4384 _("Set entry values and tail call frames "
4386 _("Show entry values and tail call frames "
4388 _("When non-zero, the process of determining "
4389 "parameter values from function entry point "
4390 "and tail call frames will be printed."),
4392 show_entry_values_debug,
4393 &setdebuglist, &showdebuglist);