1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003-2014 Free Software Foundation, Inc.
5 Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
33 #include "exceptions.h"
38 #include "dwarf2expr.h"
39 #include "dwarf2loc.h"
40 #include "dwarf2-frame.h"
42 extern int dwarf2_always_disassemble
;
44 static void dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
45 const gdb_byte
**start
, size_t *length
);
47 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
;
49 static struct value
*dwarf2_evaluate_loc_desc_full (struct type
*type
,
50 struct frame_info
*frame
,
53 struct dwarf2_per_cu_data
*per_cu
,
56 /* Until these have formal names, we define these here.
57 ref: http://gcc.gnu.org/wiki/DebugFission
58 Each entry in .debug_loc.dwo begins with a byte that describes the entry,
59 and is then followed by data specific to that entry. */
63 /* Indicates the end of the list of entries. */
64 DEBUG_LOC_END_OF_LIST
= 0,
66 /* This is followed by an unsigned LEB128 number that is an index into
67 .debug_addr and specifies the base address for all following entries. */
68 DEBUG_LOC_BASE_ADDRESS
= 1,
70 /* This is followed by two unsigned LEB128 numbers that are indices into
71 .debug_addr and specify the beginning and ending addresses, and then
72 a normal location expression as in .debug_loc. */
73 DEBUG_LOC_START_END
= 2,
75 /* This is followed by an unsigned LEB128 number that is an index into
76 .debug_addr and specifies the beginning address, and a 4 byte unsigned
77 number that specifies the length, and then a normal location expression
79 DEBUG_LOC_START_LENGTH
= 3,
81 /* An internal value indicating there is insufficient data. */
82 DEBUG_LOC_BUFFER_OVERFLOW
= -1,
84 /* An internal value indicating an invalid kind of entry was found. */
85 DEBUG_LOC_INVALID_ENTRY
= -2
88 /* Helper function which throws an error if a synthetic pointer is
92 invalid_synthetic_pointer (void)
94 error (_("access outside bounds of object "
95 "referenced via synthetic pointer"));
98 /* Decode the addresses in a non-dwo .debug_loc entry.
99 A pointer to the next byte to examine is returned in *NEW_PTR.
100 The encoded low,high addresses are return in *LOW,*HIGH.
101 The result indicates the kind of entry found. */
103 static enum debug_loc_kind
104 decode_debug_loc_addresses (const gdb_byte
*loc_ptr
, const gdb_byte
*buf_end
,
105 const gdb_byte
**new_ptr
,
106 CORE_ADDR
*low
, CORE_ADDR
*high
,
107 enum bfd_endian byte_order
,
108 unsigned int addr_size
,
111 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
113 if (buf_end
- loc_ptr
< 2 * addr_size
)
114 return DEBUG_LOC_BUFFER_OVERFLOW
;
117 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
119 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
120 loc_ptr
+= addr_size
;
123 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
125 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
126 loc_ptr
+= addr_size
;
130 /* A base-address-selection entry. */
131 if ((*low
& base_mask
) == base_mask
)
132 return DEBUG_LOC_BASE_ADDRESS
;
134 /* An end-of-list entry. */
135 if (*low
== 0 && *high
== 0)
136 return DEBUG_LOC_END_OF_LIST
;
138 return DEBUG_LOC_START_END
;
141 /* Decode the addresses in .debug_loc.dwo entry.
142 A pointer to the next byte to examine is returned in *NEW_PTR.
143 The encoded low,high addresses are return in *LOW,*HIGH.
144 The result indicates the kind of entry found. */
146 static enum debug_loc_kind
147 decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data
*per_cu
,
148 const gdb_byte
*loc_ptr
,
149 const gdb_byte
*buf_end
,
150 const gdb_byte
**new_ptr
,
151 CORE_ADDR
*low
, CORE_ADDR
*high
,
152 enum bfd_endian byte_order
)
154 uint64_t low_index
, high_index
;
156 if (loc_ptr
== buf_end
)
157 return DEBUG_LOC_BUFFER_OVERFLOW
;
161 case DEBUG_LOC_END_OF_LIST
:
163 return DEBUG_LOC_END_OF_LIST
;
164 case DEBUG_LOC_BASE_ADDRESS
:
166 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
168 return DEBUG_LOC_BUFFER_OVERFLOW
;
169 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
171 return DEBUG_LOC_BASE_ADDRESS
;
172 case DEBUG_LOC_START_END
:
173 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
175 return DEBUG_LOC_BUFFER_OVERFLOW
;
176 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
177 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
179 return DEBUG_LOC_BUFFER_OVERFLOW
;
180 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
182 return DEBUG_LOC_START_END
;
183 case DEBUG_LOC_START_LENGTH
:
184 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
186 return DEBUG_LOC_BUFFER_OVERFLOW
;
187 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
188 if (loc_ptr
+ 4 > buf_end
)
189 return DEBUG_LOC_BUFFER_OVERFLOW
;
191 *high
+= extract_unsigned_integer (loc_ptr
, 4, byte_order
);
192 *new_ptr
= loc_ptr
+ 4;
193 return DEBUG_LOC_START_LENGTH
;
195 return DEBUG_LOC_INVALID_ENTRY
;
199 /* A function for dealing with location lists. Given a
200 symbol baton (BATON) and a pc value (PC), find the appropriate
201 location expression, set *LOCEXPR_LENGTH, and return a pointer
202 to the beginning of the expression. Returns NULL on failure.
204 For now, only return the first matching location expression; there
205 can be more than one in the list. */
208 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
209 size_t *locexpr_length
, CORE_ADDR pc
)
211 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
212 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
213 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
214 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
215 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
216 /* Adjust base_address for relocatable objects. */
217 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (baton
->per_cu
);
218 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
219 const gdb_byte
*loc_ptr
, *buf_end
;
221 loc_ptr
= baton
->data
;
222 buf_end
= baton
->data
+ baton
->size
;
226 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
228 enum debug_loc_kind kind
;
229 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
232 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
233 loc_ptr
, buf_end
, &new_ptr
,
234 &low
, &high
, byte_order
);
236 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
238 byte_order
, addr_size
,
243 case DEBUG_LOC_END_OF_LIST
:
246 case DEBUG_LOC_BASE_ADDRESS
:
247 base_address
= high
+ base_offset
;
249 case DEBUG_LOC_START_END
:
250 case DEBUG_LOC_START_LENGTH
:
252 case DEBUG_LOC_BUFFER_OVERFLOW
:
253 case DEBUG_LOC_INVALID_ENTRY
:
254 error (_("dwarf2_find_location_expression: "
255 "Corrupted DWARF expression."));
257 gdb_assert_not_reached ("bad debug_loc_kind");
260 /* Otherwise, a location expression entry.
261 If the entry is from a DWO, don't add base address: the entry is
262 from .debug_addr which has absolute addresses. */
263 if (! baton
->from_dwo
)
266 high
+= base_address
;
269 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
272 if (low
== high
&& pc
== low
)
274 /* This is entry PC record present only at entry point
275 of a function. Verify it is really the function entry point. */
277 const struct block
*pc_block
= block_for_pc (pc
);
278 struct symbol
*pc_func
= NULL
;
281 pc_func
= block_linkage_function (pc_block
);
283 if (pc_func
&& pc
== BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func
)))
285 *locexpr_length
= length
;
290 if (pc
>= low
&& pc
< high
)
292 *locexpr_length
= length
;
300 /* This is the baton used when performing dwarf2 expression
302 struct dwarf_expr_baton
304 struct frame_info
*frame
;
305 struct dwarf2_per_cu_data
*per_cu
;
306 CORE_ADDR obj_address
;
309 /* Helper functions for dwarf2_evaluate_loc_desc. */
311 /* Using the frame specified in BATON, return the value of register
312 REGNUM, treated as a pointer. */
314 dwarf_expr_read_addr_from_reg (void *baton
, int dwarf_regnum
)
316 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
317 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
318 int regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
320 return address_from_register (regnum
, debaton
->frame
);
323 /* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback. */
325 static struct value
*
326 dwarf_expr_get_reg_value (void *baton
, struct type
*type
, int dwarf_regnum
)
328 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
329 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
330 int regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
332 return value_from_register (type
, regnum
, debaton
->frame
);
335 /* Read memory at ADDR (length LEN) into BUF. */
338 dwarf_expr_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
340 read_memory (addr
, buf
, len
);
343 /* Using the frame specified in BATON, find the location expression
344 describing the frame base. Return a pointer to it in START and
345 its length in LENGTH. */
347 dwarf_expr_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
349 /* FIXME: cagney/2003-03-26: This code should be using
350 get_frame_base_address(), and then implement a dwarf2 specific
352 struct symbol
*framefunc
;
353 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
354 const struct block
*bl
= get_frame_block (debaton
->frame
, NULL
);
357 error (_("frame address is not available."));
359 /* Use block_linkage_function, which returns a real (not inlined)
360 function, instead of get_frame_function, which may return an
362 framefunc
= block_linkage_function (bl
);
364 /* If we found a frame-relative symbol then it was certainly within
365 some function associated with a frame. If we can't find the frame,
366 something has gone wrong. */
367 gdb_assert (framefunc
!= NULL
);
369 dwarf_expr_frame_base_1 (framefunc
,
370 get_frame_address_in_block (debaton
->frame
),
374 /* Implement find_frame_base_location method for LOC_BLOCK functions using
375 DWARF expression for its DW_AT_frame_base. */
378 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
379 const gdb_byte
**start
, size_t *length
)
381 struct dwarf2_locexpr_baton
*symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
383 *length
= symbaton
->size
;
384 *start
= symbaton
->data
;
387 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
388 function uses DWARF expression for its DW_AT_frame_base. */
390 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
392 locexpr_find_frame_base_location
395 /* Implement find_frame_base_location method for LOC_BLOCK functions using
396 DWARF location list for its DW_AT_frame_base. */
399 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
400 const gdb_byte
**start
, size_t *length
)
402 struct dwarf2_loclist_baton
*symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
404 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
407 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
408 function uses DWARF location list for its DW_AT_frame_base. */
410 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
412 loclist_find_frame_base_location
416 dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
417 const gdb_byte
**start
, size_t *length
)
419 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
421 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
423 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
429 error (_("Could not find the frame base for \"%s\"."),
430 SYMBOL_NATURAL_NAME (framefunc
));
433 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
434 the frame in BATON. */
437 dwarf_expr_frame_cfa (void *baton
)
439 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
441 return dwarf2_frame_cfa (debaton
->frame
);
444 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
445 the frame in BATON. */
448 dwarf_expr_frame_pc (void *baton
)
450 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
452 return get_frame_address_in_block (debaton
->frame
);
455 /* Using the objfile specified in BATON, find the address for the
456 current thread's thread-local storage with offset OFFSET. */
458 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
460 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
461 struct objfile
*objfile
= dwarf2_per_cu_objfile (debaton
->per_cu
);
463 return target_translate_tls_address (objfile
, offset
);
466 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
467 current CU (as is PER_CU). State of the CTX is not affected by the
471 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
472 struct dwarf2_per_cu_data
*per_cu
,
473 CORE_ADDR (*get_frame_pc
) (void *baton
),
476 struct dwarf2_locexpr_baton block
;
478 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
, get_frame_pc
, baton
);
480 /* DW_OP_call_ref is currently not supported. */
481 gdb_assert (block
.per_cu
== per_cu
);
483 dwarf_expr_eval (ctx
, block
.data
, block
.size
);
486 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
489 dwarf_expr_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
491 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
493 per_cu_dwarf_call (ctx
, die_offset
, debaton
->per_cu
,
494 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
497 /* Callback function for dwarf2_evaluate_loc_desc. */
500 dwarf_expr_get_base_type (struct dwarf_expr_context
*ctx
,
501 cu_offset die_offset
)
503 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
505 return dwarf2_get_die_type (die_offset
, debaton
->per_cu
);
508 /* See dwarf2loc.h. */
510 unsigned int entry_values_debug
= 0;
512 /* Helper to set entry_values_debug. */
515 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
516 struct cmd_list_element
*c
, const char *value
)
518 fprintf_filtered (file
,
519 _("Entry values and tail call frames debugging is %s.\n"),
523 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
524 CALLER_FRAME (for registers) can be NULL if it is not known. This function
525 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
528 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
529 struct call_site
*call_site
,
530 struct frame_info
*caller_frame
)
532 switch (FIELD_LOC_KIND (call_site
->target
))
534 case FIELD_LOC_KIND_DWARF_BLOCK
:
536 struct dwarf2_locexpr_baton
*dwarf_block
;
538 struct type
*caller_core_addr_type
;
539 struct gdbarch
*caller_arch
;
541 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
542 if (dwarf_block
== NULL
)
544 struct bound_minimal_symbol msym
;
546 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
547 throw_error (NO_ENTRY_VALUE_ERROR
,
548 _("DW_AT_GNU_call_site_target is not specified "
550 paddress (call_site_gdbarch
, call_site
->pc
),
551 (msym
.minsym
== NULL
? "???"
552 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
555 if (caller_frame
== NULL
)
557 struct bound_minimal_symbol msym
;
559 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
560 throw_error (NO_ENTRY_VALUE_ERROR
,
561 _("DW_AT_GNU_call_site_target DWARF block resolving "
562 "requires known frame which is currently not "
563 "available at %s in %s"),
564 paddress (call_site_gdbarch
, call_site
->pc
),
565 (msym
.minsym
== NULL
? "???"
566 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
569 caller_arch
= get_frame_arch (caller_frame
);
570 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
571 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
572 dwarf_block
->data
, dwarf_block
->size
,
573 dwarf_block
->per_cu
);
574 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
576 if (VALUE_LVAL (val
) == lval_memory
)
577 return value_address (val
);
579 return value_as_address (val
);
582 case FIELD_LOC_KIND_PHYSNAME
:
584 const char *physname
;
585 struct bound_minimal_symbol msym
;
587 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
589 /* Handle both the mangled and demangled PHYSNAME. */
590 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
591 if (msym
.minsym
== NULL
)
593 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
594 throw_error (NO_ENTRY_VALUE_ERROR
,
595 _("Cannot find function \"%s\" for a call site target "
597 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
598 (msym
.minsym
== NULL
? "???"
599 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
602 return BMSYMBOL_VALUE_ADDRESS (msym
);
605 case FIELD_LOC_KIND_PHYSADDR
:
606 return FIELD_STATIC_PHYSADDR (call_site
->target
);
609 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
613 /* Convert function entry point exact address ADDR to the function which is
614 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
615 NO_ENTRY_VALUE_ERROR otherwise. */
617 static struct symbol
*
618 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
620 struct symbol
*sym
= find_pc_function (addr
);
623 if (sym
== NULL
|| BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
624 throw_error (NO_ENTRY_VALUE_ERROR
,
625 _("DW_TAG_GNU_call_site resolving failed to find function "
626 "name for address %s"),
627 paddress (gdbarch
, addr
));
629 type
= SYMBOL_TYPE (sym
);
630 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
631 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
636 /* Verify function with entry point exact address ADDR can never call itself
637 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
638 can call itself via tail calls.
640 If a funtion can tail call itself its entry value based parameters are
641 unreliable. There is no verification whether the value of some/all
642 parameters is unchanged through the self tail call, we expect if there is
643 a self tail call all the parameters can be modified. */
646 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
648 struct obstack addr_obstack
;
649 struct cleanup
*old_chain
;
652 /* Track here CORE_ADDRs which were already visited. */
655 /* The verification is completely unordered. Track here function addresses
656 which still need to be iterated. */
657 VEC (CORE_ADDR
) *todo
= NULL
;
659 obstack_init (&addr_obstack
);
660 old_chain
= make_cleanup_obstack_free (&addr_obstack
);
661 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
662 &addr_obstack
, hashtab_obstack_allocate
,
664 make_cleanup_htab_delete (addr_hash
);
666 make_cleanup (VEC_cleanup (CORE_ADDR
), &todo
);
668 VEC_safe_push (CORE_ADDR
, todo
, verify_addr
);
669 while (!VEC_empty (CORE_ADDR
, todo
))
671 struct symbol
*func_sym
;
672 struct call_site
*call_site
;
674 addr
= VEC_pop (CORE_ADDR
, todo
);
676 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
678 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
679 call_site
; call_site
= call_site
->tail_call_next
)
681 CORE_ADDR target_addr
;
684 /* CALLER_FRAME with registers is not available for tail-call jumped
686 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
688 if (target_addr
== verify_addr
)
690 struct bound_minimal_symbol msym
;
692 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
693 throw_error (NO_ENTRY_VALUE_ERROR
,
694 _("DW_OP_GNU_entry_value resolving has found "
695 "function \"%s\" at %s can call itself via tail "
697 (msym
.minsym
== NULL
? "???"
698 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
699 paddress (gdbarch
, verify_addr
));
702 slot
= htab_find_slot (addr_hash
, &target_addr
, INSERT
);
705 *slot
= obstack_copy (&addr_obstack
, &target_addr
,
706 sizeof (target_addr
));
707 VEC_safe_push (CORE_ADDR
, todo
, target_addr
);
712 do_cleanups (old_chain
);
715 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
716 ENTRY_VALUES_DEBUG. */
719 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
721 CORE_ADDR addr
= call_site
->pc
;
722 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
724 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
725 (msym
.minsym
== NULL
? "???"
726 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
730 /* vec.h needs single word type name, typedef it. */
731 typedef struct call_site
*call_sitep
;
733 /* Define VEC (call_sitep) functions. */
734 DEF_VEC_P (call_sitep
);
736 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
737 only top callers and bottom callees which are present in both. GDBARCH is
738 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
739 no remaining possibilities to provide unambiguous non-trivial result.
740 RESULTP should point to NULL on the first (initialization) call. Caller is
741 responsible for xfree of any RESULTP data. */
744 chain_candidate (struct gdbarch
*gdbarch
, struct call_site_chain
**resultp
,
745 VEC (call_sitep
) *chain
)
747 struct call_site_chain
*result
= *resultp
;
748 long length
= VEC_length (call_sitep
, chain
);
749 int callers
, callees
, idx
;
753 /* Create the initial chain containing all the passed PCs. */
755 result
= xmalloc (sizeof (*result
) + sizeof (*result
->call_site
)
757 result
->length
= length
;
758 result
->callers
= result
->callees
= length
;
759 if (!VEC_empty (call_sitep
, chain
))
760 memcpy (result
->call_site
, VEC_address (call_sitep
, chain
),
761 sizeof (*result
->call_site
) * length
);
764 if (entry_values_debug
)
766 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
767 for (idx
= 0; idx
< length
; idx
++)
768 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
769 fputc_unfiltered ('\n', gdb_stdlog
);
775 if (entry_values_debug
)
777 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
778 for (idx
= 0; idx
< length
; idx
++)
779 tailcall_dump (gdbarch
, VEC_index (call_sitep
, chain
, idx
));
780 fputc_unfiltered ('\n', gdb_stdlog
);
783 /* Intersect callers. */
785 callers
= min (result
->callers
, length
);
786 for (idx
= 0; idx
< callers
; idx
++)
787 if (result
->call_site
[idx
] != VEC_index (call_sitep
, chain
, idx
))
789 result
->callers
= idx
;
793 /* Intersect callees. */
795 callees
= min (result
->callees
, length
);
796 for (idx
= 0; idx
< callees
; idx
++)
797 if (result
->call_site
[result
->length
- 1 - idx
]
798 != VEC_index (call_sitep
, chain
, length
- 1 - idx
))
800 result
->callees
= idx
;
804 if (entry_values_debug
)
806 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
807 for (idx
= 0; idx
< result
->callers
; idx
++)
808 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
809 fputs_unfiltered (" |", gdb_stdlog
);
810 for (idx
= 0; idx
< result
->callees
; idx
++)
811 tailcall_dump (gdbarch
, result
->call_site
[result
->length
812 - result
->callees
+ idx
]);
813 fputc_unfiltered ('\n', gdb_stdlog
);
816 if (result
->callers
== 0 && result
->callees
== 0)
818 /* There are no common callers or callees. It could be also a direct
819 call (which has length 0) with ambiguous possibility of an indirect
820 call - CALLERS == CALLEES == 0 is valid during the first allocation
821 but any subsequence processing of such entry means ambiguity. */
827 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
828 PC again. In such case there must be two different code paths to reach
829 it, therefore some of the former determined intermediate PCs must differ
830 and the unambiguous chain gets shortened. */
831 gdb_assert (result
->callers
+ result
->callees
< result
->length
);
834 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
835 assumed frames between them use GDBARCH. Use depth first search so we can
836 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
837 would have needless GDB stack overhead. Caller is responsible for xfree of
838 the returned result. Any unreliability results in thrown
839 NO_ENTRY_VALUE_ERROR. */
841 static struct call_site_chain
*
842 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
845 CORE_ADDR save_callee_pc
= callee_pc
;
846 struct obstack addr_obstack
;
847 struct cleanup
*back_to_retval
, *back_to_workdata
;
848 struct call_site_chain
*retval
= NULL
;
849 struct call_site
*call_site
;
851 /* Mark CALL_SITEs so we do not visit the same ones twice. */
854 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
855 call_site nor any possible call_site at CALLEE_PC's function is there.
856 Any CALL_SITE in CHAIN will be iterated to its siblings - via
857 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
858 VEC (call_sitep
) *chain
= NULL
;
860 /* We are not interested in the specific PC inside the callee function. */
861 callee_pc
= get_pc_function_start (callee_pc
);
863 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
864 paddress (gdbarch
, save_callee_pc
));
866 back_to_retval
= make_cleanup (free_current_contents
, &retval
);
868 obstack_init (&addr_obstack
);
869 back_to_workdata
= make_cleanup_obstack_free (&addr_obstack
);
870 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
871 &addr_obstack
, hashtab_obstack_allocate
,
873 make_cleanup_htab_delete (addr_hash
);
875 make_cleanup (VEC_cleanup (call_sitep
), &chain
);
877 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
878 at the target's function. All the possible tail call sites in the
879 target's function will get iterated as already pushed into CHAIN via their
881 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
885 CORE_ADDR target_func_addr
;
886 struct call_site
*target_call_site
;
888 /* CALLER_FRAME with registers is not available for tail-call jumped
890 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
892 if (target_func_addr
== callee_pc
)
894 chain_candidate (gdbarch
, &retval
, chain
);
898 /* There is no way to reach CALLEE_PC again as we would prevent
899 entering it twice as being already marked in ADDR_HASH. */
900 target_call_site
= NULL
;
904 struct symbol
*target_func
;
906 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
907 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
912 /* Attempt to visit TARGET_CALL_SITE. */
914 if (target_call_site
)
918 slot
= htab_find_slot (addr_hash
, &target_call_site
->pc
, INSERT
);
921 /* Successfully entered TARGET_CALL_SITE. */
923 *slot
= &target_call_site
->pc
;
924 VEC_safe_push (call_sitep
, chain
, target_call_site
);
929 /* Backtrack (without revisiting the originating call_site). Try the
930 callers's sibling; if there isn't any try the callers's callers's
933 target_call_site
= NULL
;
934 while (!VEC_empty (call_sitep
, chain
))
936 call_site
= VEC_pop (call_sitep
, chain
);
938 gdb_assert (htab_find_slot (addr_hash
, &call_site
->pc
,
940 htab_remove_elt (addr_hash
, &call_site
->pc
);
942 target_call_site
= call_site
->tail_call_next
;
943 if (target_call_site
)
947 while (target_call_site
);
949 if (VEC_empty (call_sitep
, chain
))
952 call_site
= VEC_last (call_sitep
, chain
);
957 struct bound_minimal_symbol msym_caller
, msym_callee
;
959 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
960 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
961 throw_error (NO_ENTRY_VALUE_ERROR
,
962 _("There are no unambiguously determinable intermediate "
963 "callers or callees between caller function \"%s\" at %s "
964 "and callee function \"%s\" at %s"),
965 (msym_caller
.minsym
== NULL
966 ? "???" : MSYMBOL_PRINT_NAME (msym_caller
.minsym
)),
967 paddress (gdbarch
, caller_pc
),
968 (msym_callee
.minsym
== NULL
969 ? "???" : MSYMBOL_PRINT_NAME (msym_callee
.minsym
)),
970 paddress (gdbarch
, callee_pc
));
973 do_cleanups (back_to_workdata
);
974 discard_cleanups (back_to_retval
);
978 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
979 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
980 constructed return NULL. Caller is responsible for xfree of the returned
983 struct call_site_chain
*
984 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
987 volatile struct gdb_exception e
;
988 struct call_site_chain
*retval
= NULL
;
990 TRY_CATCH (e
, RETURN_MASK_ERROR
)
992 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
996 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
998 if (entry_values_debug
)
999 exception_print (gdb_stdout
, e
);
1004 throw_exception (e
);
1009 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1012 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1013 enum call_site_parameter_kind kind
,
1014 union call_site_parameter_u kind_u
)
1016 if (kind
== parameter
->kind
)
1019 case CALL_SITE_PARAMETER_DWARF_REG
:
1020 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1021 case CALL_SITE_PARAMETER_FB_OFFSET
:
1022 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1023 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1024 return kind_u
.param_offset
.cu_off
== parameter
->u
.param_offset
.cu_off
;
1029 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1030 FRAME is for callee.
1032 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1035 static struct call_site_parameter
*
1036 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1037 enum call_site_parameter_kind kind
,
1038 union call_site_parameter_u kind_u
,
1039 struct dwarf2_per_cu_data
**per_cu_return
)
1041 CORE_ADDR func_addr
, caller_pc
;
1042 struct gdbarch
*gdbarch
;
1043 struct frame_info
*caller_frame
;
1044 struct call_site
*call_site
;
1046 /* Initialize it just to avoid a GCC false warning. */
1047 struct call_site_parameter
*parameter
= NULL
;
1048 CORE_ADDR target_addr
;
1050 while (get_frame_type (frame
) == INLINE_FRAME
)
1052 frame
= get_prev_frame (frame
);
1053 gdb_assert (frame
!= NULL
);
1056 func_addr
= get_frame_func (frame
);
1057 gdbarch
= get_frame_arch (frame
);
1058 caller_frame
= get_prev_frame (frame
);
1059 if (gdbarch
!= frame_unwind_arch (frame
))
1061 struct bound_minimal_symbol msym
1062 = lookup_minimal_symbol_by_pc (func_addr
);
1063 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1065 throw_error (NO_ENTRY_VALUE_ERROR
,
1066 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1067 "(of %s (%s)) does not match caller gdbarch %s"),
1068 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1069 paddress (gdbarch
, func_addr
),
1070 (msym
.minsym
== NULL
? "???"
1071 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
1072 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1075 if (caller_frame
== NULL
)
1077 struct bound_minimal_symbol msym
1078 = lookup_minimal_symbol_by_pc (func_addr
);
1080 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_GNU_entry_value resolving "
1081 "requires caller of %s (%s)"),
1082 paddress (gdbarch
, func_addr
),
1083 (msym
.minsym
== NULL
? "???"
1084 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
1086 caller_pc
= get_frame_pc (caller_frame
);
1087 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1089 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1090 if (target_addr
!= func_addr
)
1092 struct minimal_symbol
*target_msym
, *func_msym
;
1094 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1095 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1096 throw_error (NO_ENTRY_VALUE_ERROR
,
1097 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1098 "but the called frame is for %s at %s"),
1099 (target_msym
== NULL
? "???"
1100 : MSYMBOL_PRINT_NAME (target_msym
)),
1101 paddress (gdbarch
, target_addr
),
1102 func_msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (func_msym
),
1103 paddress (gdbarch
, func_addr
));
1106 /* No entry value based parameters would be reliable if this function can
1107 call itself via tail calls. */
1108 func_verify_no_selftailcall (gdbarch
, func_addr
);
1110 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1112 parameter
= &call_site
->parameter
[iparams
];
1113 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1116 if (iparams
== call_site
->parameter_count
)
1118 struct minimal_symbol
*msym
1119 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1121 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1122 determine its value. */
1123 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1124 "at DW_TAG_GNU_call_site %s at %s"),
1125 paddress (gdbarch
, caller_pc
),
1126 msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (msym
));
1129 *per_cu_return
= call_site
->per_cu
;
1133 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1134 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1135 DW_AT_GNU_call_site_data_value (dereferenced) block.
1137 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1140 Function always returns non-NULL, non-optimized out value. It throws
1141 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1143 static struct value
*
1144 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1145 CORE_ADDR deref_size
, struct type
*type
,
1146 struct frame_info
*caller_frame
,
1147 struct dwarf2_per_cu_data
*per_cu
)
1149 const gdb_byte
*data_src
;
1153 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1154 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1156 /* DEREF_SIZE size is not verified here. */
1157 if (data_src
== NULL
)
1158 throw_error (NO_ENTRY_VALUE_ERROR
,
1159 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1161 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1162 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1164 data
= alloca (size
+ 1);
1165 memcpy (data
, data_src
, size
);
1166 data
[size
] = DW_OP_stack_value
;
1168 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1171 /* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
1172 Choose DEREF_SIZE value of that parameter. Search caller of the CTX's
1173 frame. CTX must be of dwarf_expr_ctx_funcs kind.
1175 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1176 can be more simple as it does not support cross-CU DWARF executions. */
1179 dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
1180 enum call_site_parameter_kind kind
,
1181 union call_site_parameter_u kind_u
,
1184 struct dwarf_expr_baton
*debaton
;
1185 struct frame_info
*frame
, *caller_frame
;
1186 struct dwarf2_per_cu_data
*caller_per_cu
;
1187 struct dwarf_expr_baton baton_local
;
1188 struct dwarf_expr_context saved_ctx
;
1189 struct call_site_parameter
*parameter
;
1190 const gdb_byte
*data_src
;
1193 gdb_assert (ctx
->funcs
== &dwarf_expr_ctx_funcs
);
1194 debaton
= ctx
->baton
;
1195 frame
= debaton
->frame
;
1196 caller_frame
= get_prev_frame (frame
);
1198 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1200 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1201 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1203 /* DEREF_SIZE size is not verified here. */
1204 if (data_src
== NULL
)
1205 throw_error (NO_ENTRY_VALUE_ERROR
,
1206 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1208 baton_local
.frame
= caller_frame
;
1209 baton_local
.per_cu
= caller_per_cu
;
1210 baton_local
.obj_address
= 0;
1212 saved_ctx
.gdbarch
= ctx
->gdbarch
;
1213 saved_ctx
.addr_size
= ctx
->addr_size
;
1214 saved_ctx
.offset
= ctx
->offset
;
1215 saved_ctx
.baton
= ctx
->baton
;
1216 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (baton_local
.per_cu
));
1217 ctx
->addr_size
= dwarf2_per_cu_addr_size (baton_local
.per_cu
);
1218 ctx
->offset
= dwarf2_per_cu_text_offset (baton_local
.per_cu
);
1219 ctx
->baton
= &baton_local
;
1221 dwarf_expr_eval (ctx
, data_src
, size
);
1223 ctx
->gdbarch
= saved_ctx
.gdbarch
;
1224 ctx
->addr_size
= saved_ctx
.addr_size
;
1225 ctx
->offset
= saved_ctx
.offset
;
1226 ctx
->baton
= saved_ctx
.baton
;
1229 /* Callback function for dwarf2_evaluate_loc_desc.
1230 Fetch the address indexed by DW_OP_GNU_addr_index. */
1233 dwarf_expr_get_addr_index (void *baton
, unsigned int index
)
1235 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
1237 return dwarf2_read_addr_index (debaton
->per_cu
, index
);
1240 /* Callback function for get_object_address. Return the address of the VLA
1244 dwarf_expr_get_obj_addr (void *baton
)
1246 struct dwarf_expr_baton
*debaton
= baton
;
1248 gdb_assert (debaton
!= NULL
);
1250 if (debaton
->obj_address
== 0)
1251 error (_("Location address is not set."));
1253 return debaton
->obj_address
;
1256 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1257 the indirect method on it, that is use its stored target value, the sole
1258 purpose of entry_data_value_funcs.. */
1260 static struct value
*
1261 entry_data_value_coerce_ref (const struct value
*value
)
1263 struct type
*checked_type
= check_typedef (value_type (value
));
1264 struct value
*target_val
;
1266 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
)
1269 target_val
= value_computed_closure (value
);
1270 value_incref (target_val
);
1274 /* Implement copy_closure. */
1277 entry_data_value_copy_closure (const struct value
*v
)
1279 struct value
*target_val
= value_computed_closure (v
);
1281 value_incref (target_val
);
1285 /* Implement free_closure. */
1288 entry_data_value_free_closure (struct value
*v
)
1290 struct value
*target_val
= value_computed_closure (v
);
1292 value_free (target_val
);
1295 /* Vector for methods for an entry value reference where the referenced value
1296 is stored in the caller. On the first dereference use
1297 DW_AT_GNU_call_site_data_value in the caller. */
1299 static const struct lval_funcs entry_data_value_funcs
=
1303 NULL
, /* indirect */
1304 entry_data_value_coerce_ref
,
1305 NULL
, /* check_synthetic_pointer */
1306 entry_data_value_copy_closure
,
1307 entry_data_value_free_closure
1310 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1311 are used to match DW_AT_location at the caller's
1312 DW_TAG_GNU_call_site_parameter.
1314 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1315 cannot resolve the parameter for any reason. */
1317 static struct value
*
1318 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1319 enum call_site_parameter_kind kind
,
1320 union call_site_parameter_u kind_u
)
1322 struct type
*checked_type
= check_typedef (type
);
1323 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1324 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1325 struct value
*outer_val
, *target_val
, *val
;
1326 struct call_site_parameter
*parameter
;
1327 struct dwarf2_per_cu_data
*caller_per_cu
;
1329 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1332 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1336 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1337 used and it is not available do not fall back to OUTER_VAL - dereferencing
1338 TYPE_CODE_REF with non-entry data value would give current value - not the
1341 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
1342 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1345 target_val
= dwarf_entry_parameter_to_value (parameter
,
1346 TYPE_LENGTH (target_type
),
1347 target_type
, caller_frame
,
1350 release_value (target_val
);
1351 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1352 target_val
/* closure */);
1354 /* Copy the referencing pointer to the new computed value. */
1355 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1356 TYPE_LENGTH (checked_type
));
1357 set_value_lazy (val
, 0);
1362 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1363 SIZE are DWARF block used to match DW_AT_location at the caller's
1364 DW_TAG_GNU_call_site_parameter.
1366 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1367 cannot resolve the parameter for any reason. */
1369 static struct value
*
1370 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1371 const gdb_byte
*block
, size_t block_len
)
1373 union call_site_parameter_u kind_u
;
1375 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1376 if (kind_u
.dwarf_reg
!= -1)
1377 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1380 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1381 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1384 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1385 suppressed during normal operation. The expression can be arbitrary if
1386 there is no caller-callee entry value binding expected. */
1387 throw_error (NO_ENTRY_VALUE_ERROR
,
1388 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1389 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1392 struct piece_closure
1394 /* Reference count. */
1397 /* The CU from which this closure's expression came. */
1398 struct dwarf2_per_cu_data
*per_cu
;
1400 /* The number of pieces used to describe this variable. */
1403 /* The target address size, used only for DWARF_VALUE_STACK. */
1406 /* The pieces themselves. */
1407 struct dwarf_expr_piece
*pieces
;
1410 /* Allocate a closure for a value formed from separately-described
1413 static struct piece_closure
*
1414 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1415 int n_pieces
, struct dwarf_expr_piece
*pieces
,
1418 struct piece_closure
*c
= XCNEW (struct piece_closure
);
1423 c
->n_pieces
= n_pieces
;
1424 c
->addr_size
= addr_size
;
1425 c
->pieces
= XCNEWVEC (struct dwarf_expr_piece
, n_pieces
);
1427 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
1428 for (i
= 0; i
< n_pieces
; ++i
)
1429 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1430 value_incref (c
->pieces
[i
].v
.value
);
1435 /* The lowest-level function to extract bits from a byte buffer.
1436 SOURCE is the buffer. It is updated if we read to the end of a
1438 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1439 updated to reflect the number of bits actually read.
1440 NBITS is the number of bits we want to read. It is updated to
1441 reflect the number of bits actually read. This function may read
1443 BITS_BIG_ENDIAN is taken directly from gdbarch.
1444 This function returns the extracted bits. */
1447 extract_bits_primitive (const gdb_byte
**source
,
1448 unsigned int *source_offset_bits
,
1449 int *nbits
, int bits_big_endian
)
1451 unsigned int avail
, mask
, datum
;
1453 gdb_assert (*source_offset_bits
< 8);
1455 avail
= 8 - *source_offset_bits
;
1459 mask
= (1 << avail
) - 1;
1461 if (bits_big_endian
)
1462 datum
>>= 8 - (*source_offset_bits
+ *nbits
);
1464 datum
>>= *source_offset_bits
;
1468 *source_offset_bits
+= avail
;
1469 if (*source_offset_bits
>= 8)
1471 *source_offset_bits
-= 8;
1478 /* Extract some bits from a source buffer and move forward in the
1481 SOURCE is the source buffer. It is updated as bytes are read.
1482 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1484 NBITS is the number of bits to read.
1485 BITS_BIG_ENDIAN is taken directly from gdbarch.
1487 This function returns the bits that were read. */
1490 extract_bits (const gdb_byte
**source
, unsigned int *source_offset_bits
,
1491 int nbits
, int bits_big_endian
)
1495 gdb_assert (nbits
> 0 && nbits
<= 8);
1497 datum
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1503 more
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1505 if (bits_big_endian
)
1515 /* Write some bits into a buffer and move forward in the buffer.
1517 DATUM is the bits to write. The low-order bits of DATUM are used.
1518 DEST is the destination buffer. It is updated as bytes are
1520 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1522 NBITS is the number of valid bits in DATUM.
1523 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1526 insert_bits (unsigned int datum
,
1527 gdb_byte
*dest
, unsigned int dest_offset_bits
,
1528 int nbits
, int bits_big_endian
)
1532 gdb_assert (dest_offset_bits
+ nbits
<= 8);
1534 mask
= (1 << nbits
) - 1;
1535 if (bits_big_endian
)
1537 datum
<<= 8 - (dest_offset_bits
+ nbits
);
1538 mask
<<= 8 - (dest_offset_bits
+ nbits
);
1542 datum
<<= dest_offset_bits
;
1543 mask
<<= dest_offset_bits
;
1546 gdb_assert ((datum
& ~mask
) == 0);
1548 *dest
= (*dest
& ~mask
) | datum
;
1551 /* Copy bits from a source to a destination.
1553 DEST is where the bits should be written.
1554 DEST_OFFSET_BITS is the bit offset into DEST.
1555 SOURCE is the source of bits.
1556 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1557 BIT_COUNT is the number of bits to copy.
1558 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1561 copy_bitwise (gdb_byte
*dest
, unsigned int dest_offset_bits
,
1562 const gdb_byte
*source
, unsigned int source_offset_bits
,
1563 unsigned int bit_count
,
1564 int bits_big_endian
)
1566 unsigned int dest_avail
;
1569 /* Reduce everything to byte-size pieces. */
1570 dest
+= dest_offset_bits
/ 8;
1571 dest_offset_bits
%= 8;
1572 source
+= source_offset_bits
/ 8;
1573 source_offset_bits
%= 8;
1575 dest_avail
= 8 - dest_offset_bits
% 8;
1577 /* See if we can fill the first destination byte. */
1578 if (dest_avail
< bit_count
)
1580 datum
= extract_bits (&source
, &source_offset_bits
, dest_avail
,
1582 insert_bits (datum
, dest
, dest_offset_bits
, dest_avail
, bits_big_endian
);
1584 dest_offset_bits
= 0;
1585 bit_count
-= dest_avail
;
1588 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1589 than 8 bits remaining. */
1590 gdb_assert (dest_offset_bits
% 8 == 0 || bit_count
< 8);
1591 for (; bit_count
>= 8; bit_count
-= 8)
1593 datum
= extract_bits (&source
, &source_offset_bits
, 8, bits_big_endian
);
1594 *dest
++ = (gdb_byte
) datum
;
1597 /* Finally, we may have a few leftover bits. */
1598 gdb_assert (bit_count
<= 8 - dest_offset_bits
% 8);
1601 datum
= extract_bits (&source
, &source_offset_bits
, bit_count
,
1603 insert_bits (datum
, dest
, dest_offset_bits
, bit_count
, bits_big_endian
);
1608 read_pieced_value (struct value
*v
)
1612 ULONGEST bits_to_skip
;
1614 struct piece_closure
*c
1615 = (struct piece_closure
*) value_computed_closure (v
);
1616 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (v
));
1618 size_t buffer_size
= 0;
1619 gdb_byte
*buffer
= NULL
;
1620 struct cleanup
*cleanup
;
1622 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1624 if (value_type (v
) != value_enclosing_type (v
))
1625 internal_error (__FILE__
, __LINE__
,
1626 _("Should not be able to create a lazy value with "
1627 "an enclosing type"));
1629 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1631 contents
= value_contents_raw (v
);
1632 bits_to_skip
= 8 * value_offset (v
);
1633 if (value_bitsize (v
))
1635 bits_to_skip
+= value_bitpos (v
);
1636 type_len
= value_bitsize (v
);
1639 type_len
= 8 * TYPE_LENGTH (value_type (v
));
1641 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1643 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1644 size_t this_size
, this_size_bits
;
1645 long dest_offset_bits
, source_offset_bits
, source_offset
;
1646 const gdb_byte
*intermediate_buffer
;
1648 /* Compute size, source, and destination offsets for copying, in
1650 this_size_bits
= p
->size
;
1651 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1653 bits_to_skip
-= this_size_bits
;
1656 if (bits_to_skip
> 0)
1658 dest_offset_bits
= 0;
1659 source_offset_bits
= bits_to_skip
;
1660 this_size_bits
-= bits_to_skip
;
1665 dest_offset_bits
= offset
;
1666 source_offset_bits
= 0;
1668 if (this_size_bits
> type_len
- offset
)
1669 this_size_bits
= type_len
- offset
;
1671 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1672 source_offset
= source_offset_bits
/ 8;
1673 if (buffer_size
< this_size
)
1675 buffer_size
= this_size
;
1676 buffer
= xrealloc (buffer
, buffer_size
);
1678 intermediate_buffer
= buffer
;
1680 /* Copy from the source to DEST_BUFFER. */
1681 switch (p
->location
)
1683 case DWARF_VALUE_REGISTER
:
1685 struct gdbarch
*arch
= get_frame_arch (frame
);
1686 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1687 int reg_offset
= source_offset
;
1689 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1690 && this_size
< register_size (arch
, gdb_regnum
))
1692 /* Big-endian, and we want less than full size. */
1693 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1694 /* We want the lower-order THIS_SIZE_BITS of the bytes
1695 we extract from the register. */
1696 source_offset_bits
+= 8 * this_size
- this_size_bits
;
1699 if (gdb_regnum
!= -1)
1703 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1707 /* Just so garbage doesn't ever shine through. */
1708 memset (buffer
, 0, this_size
);
1711 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1713 mark_value_bits_unavailable (v
, offset
, this_size_bits
);
1718 error (_("Unable to access DWARF register number %s"),
1719 paddress (arch
, p
->v
.regno
));
1724 case DWARF_VALUE_MEMORY
:
1725 read_value_memory (v
, offset
,
1726 p
->v
.mem
.in_stack_memory
,
1727 p
->v
.mem
.addr
+ source_offset
,
1731 case DWARF_VALUE_STACK
:
1733 size_t n
= this_size
;
1735 if (n
> c
->addr_size
- source_offset
)
1736 n
= (c
->addr_size
>= source_offset
1737 ? c
->addr_size
- source_offset
1745 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
1747 intermediate_buffer
= val_bytes
+ source_offset
;
1752 case DWARF_VALUE_LITERAL
:
1754 size_t n
= this_size
;
1756 if (n
> p
->v
.literal
.length
- source_offset
)
1757 n
= (p
->v
.literal
.length
>= source_offset
1758 ? p
->v
.literal
.length
- source_offset
1761 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
1765 /* These bits show up as zeros -- but do not cause the value
1766 to be considered optimized-out. */
1767 case DWARF_VALUE_IMPLICIT_POINTER
:
1770 case DWARF_VALUE_OPTIMIZED_OUT
:
1771 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1775 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1778 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
1779 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1780 copy_bitwise (contents
, dest_offset_bits
,
1781 intermediate_buffer
, source_offset_bits
% 8,
1782 this_size_bits
, bits_big_endian
);
1784 offset
+= this_size_bits
;
1787 do_cleanups (cleanup
);
1791 write_pieced_value (struct value
*to
, struct value
*from
)
1795 ULONGEST bits_to_skip
;
1796 const gdb_byte
*contents
;
1797 struct piece_closure
*c
1798 = (struct piece_closure
*) value_computed_closure (to
);
1799 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
1801 size_t buffer_size
= 0;
1802 gdb_byte
*buffer
= NULL
;
1803 struct cleanup
*cleanup
;
1805 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
1809 mark_value_bytes_optimized_out (to
, 0, TYPE_LENGTH (value_type (to
)));
1813 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1815 contents
= value_contents (from
);
1816 bits_to_skip
= 8 * value_offset (to
);
1817 if (value_bitsize (to
))
1819 bits_to_skip
+= value_bitpos (to
);
1820 type_len
= value_bitsize (to
);
1823 type_len
= 8 * TYPE_LENGTH (value_type (to
));
1825 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1827 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1828 size_t this_size_bits
, this_size
;
1829 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
1831 const gdb_byte
*source_buffer
;
1833 this_size_bits
= p
->size
;
1834 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1836 bits_to_skip
-= this_size_bits
;
1839 if (this_size_bits
> type_len
- offset
)
1840 this_size_bits
= type_len
- offset
;
1841 if (bits_to_skip
> 0)
1843 dest_offset_bits
= bits_to_skip
;
1844 source_offset_bits
= 0;
1845 this_size_bits
-= bits_to_skip
;
1850 dest_offset_bits
= 0;
1851 source_offset_bits
= offset
;
1854 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1855 source_offset
= source_offset_bits
/ 8;
1856 dest_offset
= dest_offset_bits
/ 8;
1857 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
1859 source_buffer
= contents
+ source_offset
;
1864 if (buffer_size
< this_size
)
1866 buffer_size
= this_size
;
1867 buffer
= xrealloc (buffer
, buffer_size
);
1869 source_buffer
= buffer
;
1873 switch (p
->location
)
1875 case DWARF_VALUE_REGISTER
:
1877 struct gdbarch
*arch
= get_frame_arch (frame
);
1878 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1879 int reg_offset
= dest_offset
;
1881 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1882 && this_size
<= register_size (arch
, gdb_regnum
))
1883 /* Big-endian, and we want less than full size. */
1884 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1886 if (gdb_regnum
!= -1)
1892 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1897 throw_error (OPTIMIZED_OUT_ERROR
,
1898 _("Can't do read-modify-write to "
1899 "update bitfield; containing word "
1900 "has been optimized out"));
1902 throw_error (NOT_AVAILABLE_ERROR
,
1903 _("Can't do read-modify-write to update "
1904 "bitfield; containing word "
1907 copy_bitwise (buffer
, dest_offset_bits
,
1908 contents
, source_offset_bits
,
1913 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1914 this_size
, source_buffer
);
1918 error (_("Unable to write to DWARF register number %s"),
1919 paddress (arch
, p
->v
.regno
));
1923 case DWARF_VALUE_MEMORY
:
1926 /* Only the first and last bytes can possibly have any
1928 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
, 1);
1929 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
1930 buffer
+ this_size
- 1, 1);
1931 copy_bitwise (buffer
, dest_offset_bits
,
1932 contents
, source_offset_bits
,
1937 write_memory (p
->v
.mem
.addr
+ dest_offset
,
1938 source_buffer
, this_size
);
1941 mark_value_bytes_optimized_out (to
, 0, TYPE_LENGTH (value_type (to
)));
1944 offset
+= this_size_bits
;
1947 do_cleanups (cleanup
);
1950 /* An implementation of an lval_funcs method to see whether a value is
1951 a synthetic pointer. */
1954 check_pieced_synthetic_pointer (const struct value
*value
, int bit_offset
,
1957 struct piece_closure
*c
1958 = (struct piece_closure
*) value_computed_closure (value
);
1961 bit_offset
+= 8 * value_offset (value
);
1962 if (value_bitsize (value
))
1963 bit_offset
+= value_bitpos (value
);
1965 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
1967 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1968 size_t this_size_bits
= p
->size
;
1972 if (bit_offset
>= this_size_bits
)
1974 bit_offset
-= this_size_bits
;
1978 bit_length
-= this_size_bits
- bit_offset
;
1982 bit_length
-= this_size_bits
;
1984 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1991 /* A wrapper function for get_frame_address_in_block. */
1994 get_frame_address_in_block_wrapper (void *baton
)
1996 return get_frame_address_in_block (baton
);
1999 /* An implementation of an lval_funcs method to indirect through a
2000 pointer. This handles the synthetic pointer case when needed. */
2002 static struct value
*
2003 indirect_pieced_value (struct value
*value
)
2005 struct piece_closure
*c
2006 = (struct piece_closure
*) value_computed_closure (value
);
2008 struct frame_info
*frame
;
2009 struct dwarf2_locexpr_baton baton
;
2010 int i
, bit_offset
, bit_length
;
2011 struct dwarf_expr_piece
*piece
= NULL
;
2012 LONGEST byte_offset
;
2014 type
= check_typedef (value_type (value
));
2015 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
2018 bit_length
= 8 * TYPE_LENGTH (type
);
2019 bit_offset
= 8 * value_offset (value
);
2020 if (value_bitsize (value
))
2021 bit_offset
+= value_bitpos (value
);
2023 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2025 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2026 size_t this_size_bits
= p
->size
;
2030 if (bit_offset
>= this_size_bits
)
2032 bit_offset
-= this_size_bits
;
2036 bit_length
-= this_size_bits
- bit_offset
;
2040 bit_length
-= this_size_bits
;
2042 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2045 if (bit_length
!= 0)
2046 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2052 frame
= get_selected_frame (_("No frame selected."));
2054 /* This is an offset requested by GDB, such as value subscripts.
2055 However, due to how synthetic pointers are implemented, this is
2056 always presented to us as a pointer type. This means we have to
2057 sign-extend it manually as appropriate. */
2058 byte_offset
= value_as_address (value
);
2059 if (TYPE_LENGTH (value_type (value
)) < sizeof (LONGEST
))
2060 byte_offset
= gdb_sign_extend (byte_offset
,
2061 8 * TYPE_LENGTH (value_type (value
)));
2062 byte_offset
+= piece
->v
.ptr
.offset
;
2066 = dwarf2_fetch_die_loc_sect_off (piece
->v
.ptr
.die
, c
->per_cu
,
2067 get_frame_address_in_block_wrapper
,
2070 if (baton
.data
!= NULL
)
2071 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
2072 baton
.data
, baton
.size
, baton
.per_cu
,
2076 struct obstack temp_obstack
;
2077 struct cleanup
*cleanup
;
2078 const gdb_byte
*bytes
;
2080 struct value
*result
;
2082 obstack_init (&temp_obstack
);
2083 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2085 bytes
= dwarf2_fetch_constant_bytes (piece
->v
.ptr
.die
, c
->per_cu
,
2086 &temp_obstack
, &len
);
2088 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
2092 || byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > len
)
2093 invalid_synthetic_pointer ();
2094 bytes
+= byte_offset
;
2095 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
2098 do_cleanups (cleanup
);
2104 copy_pieced_value_closure (const struct value
*v
)
2106 struct piece_closure
*c
2107 = (struct piece_closure
*) value_computed_closure (v
);
2114 free_pieced_value_closure (struct value
*v
)
2116 struct piece_closure
*c
2117 = (struct piece_closure
*) value_computed_closure (v
);
2124 for (i
= 0; i
< c
->n_pieces
; ++i
)
2125 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
2126 value_free (c
->pieces
[i
].v
.value
);
2133 /* Functions for accessing a variable described by DW_OP_piece. */
2134 static const struct lval_funcs pieced_value_funcs
= {
2137 indirect_pieced_value
,
2138 NULL
, /* coerce_ref */
2139 check_pieced_synthetic_pointer
,
2140 copy_pieced_value_closure
,
2141 free_pieced_value_closure
2144 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2146 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
=
2148 dwarf_expr_read_addr_from_reg
,
2149 dwarf_expr_get_reg_value
,
2150 dwarf_expr_read_mem
,
2151 dwarf_expr_frame_base
,
2152 dwarf_expr_frame_cfa
,
2153 dwarf_expr_frame_pc
,
2154 dwarf_expr_tls_address
,
2155 dwarf_expr_dwarf_call
,
2156 dwarf_expr_get_base_type
,
2157 dwarf_expr_push_dwarf_reg_entry_value
,
2158 dwarf_expr_get_addr_index
,
2159 dwarf_expr_get_obj_addr
2162 /* Evaluate a location description, starting at DATA and with length
2163 SIZE, to find the current location of variable of TYPE in the
2164 context of FRAME. BYTE_OFFSET is applied after the contents are
2167 static struct value
*
2168 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2169 const gdb_byte
*data
, size_t size
,
2170 struct dwarf2_per_cu_data
*per_cu
,
2171 LONGEST byte_offset
)
2173 struct value
*retval
;
2174 struct dwarf_expr_baton baton
;
2175 struct dwarf_expr_context
*ctx
;
2176 struct cleanup
*old_chain
, *value_chain
;
2177 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2178 volatile struct gdb_exception ex
;
2180 if (byte_offset
< 0)
2181 invalid_synthetic_pointer ();
2184 return allocate_optimized_out_value (type
);
2186 baton
.frame
= frame
;
2187 baton
.per_cu
= per_cu
;
2188 baton
.obj_address
= 0;
2190 ctx
= new_dwarf_expr_context ();
2191 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2192 value_chain
= make_cleanup_value_free_to_mark (value_mark ());
2194 ctx
->gdbarch
= get_objfile_arch (objfile
);
2195 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2196 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2197 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2198 ctx
->baton
= &baton
;
2199 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2201 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2203 dwarf_expr_eval (ctx
, data
, size
);
2207 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2209 do_cleanups (old_chain
);
2210 retval
= allocate_value (type
);
2211 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
2214 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2216 if (entry_values_debug
)
2217 exception_print (gdb_stdout
, ex
);
2218 do_cleanups (old_chain
);
2219 return allocate_optimized_out_value (type
);
2222 throw_exception (ex
);
2225 if (ctx
->num_pieces
> 0)
2227 struct piece_closure
*c
;
2228 struct frame_id frame_id
= get_frame_id (frame
);
2229 ULONGEST bit_size
= 0;
2232 for (i
= 0; i
< ctx
->num_pieces
; ++i
)
2233 bit_size
+= ctx
->pieces
[i
].size
;
2234 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
2235 invalid_synthetic_pointer ();
2237 c
= allocate_piece_closure (per_cu
, ctx
->num_pieces
, ctx
->pieces
,
2239 /* We must clean up the value chain after creating the piece
2240 closure but before allocating the result. */
2241 do_cleanups (value_chain
);
2242 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
2243 VALUE_FRAME_ID (retval
) = frame_id
;
2244 set_value_offset (retval
, byte_offset
);
2248 switch (ctx
->location
)
2250 case DWARF_VALUE_REGISTER
:
2252 struct gdbarch
*arch
= get_frame_arch (frame
);
2254 = longest_to_int (value_as_long (dwarf_expr_fetch (ctx
, 0)));
2255 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
2257 if (byte_offset
!= 0)
2258 error (_("cannot use offset on synthetic pointer to register"));
2259 do_cleanups (value_chain
);
2260 if (gdb_regnum
== -1)
2261 error (_("Unable to access DWARF register number %d"),
2263 retval
= value_from_register (type
, gdb_regnum
, frame
);
2264 if (value_optimized_out (retval
))
2268 /* This means the register has undefined value / was
2269 not saved. As we're computing the location of some
2270 variable etc. in the program, not a value for
2271 inspecting a register ($pc, $sp, etc.), return a
2272 generic optimized out value instead, so that we show
2273 <optimized out> instead of <not saved>. */
2274 do_cleanups (value_chain
);
2275 tmp
= allocate_value (type
);
2276 value_contents_copy (tmp
, 0, retval
, 0, TYPE_LENGTH (type
));
2282 case DWARF_VALUE_MEMORY
:
2284 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
2285 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
2287 do_cleanups (value_chain
);
2288 retval
= value_at_lazy (type
, address
+ byte_offset
);
2289 if (in_stack_memory
)
2290 set_value_stack (retval
, 1);
2294 case DWARF_VALUE_STACK
:
2296 struct value
*value
= dwarf_expr_fetch (ctx
, 0);
2298 const gdb_byte
*val_bytes
;
2299 size_t n
= TYPE_LENGTH (value_type (value
));
2301 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2302 invalid_synthetic_pointer ();
2304 val_bytes
= value_contents_all (value
);
2305 val_bytes
+= byte_offset
;
2308 /* Preserve VALUE because we are going to free values back
2309 to the mark, but we still need the value contents
2311 value_incref (value
);
2312 do_cleanups (value_chain
);
2313 make_cleanup_value_free (value
);
2315 retval
= allocate_value (type
);
2316 contents
= value_contents_raw (retval
);
2317 if (n
> TYPE_LENGTH (type
))
2319 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2321 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2322 val_bytes
+= n
- TYPE_LENGTH (type
);
2323 n
= TYPE_LENGTH (type
);
2325 memcpy (contents
, val_bytes
, n
);
2329 case DWARF_VALUE_LITERAL
:
2332 const bfd_byte
*ldata
;
2333 size_t n
= ctx
->len
;
2335 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2336 invalid_synthetic_pointer ();
2338 do_cleanups (value_chain
);
2339 retval
= allocate_value (type
);
2340 contents
= value_contents_raw (retval
);
2342 ldata
= ctx
->data
+ byte_offset
;
2345 if (n
> TYPE_LENGTH (type
))
2347 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2349 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2350 ldata
+= n
- TYPE_LENGTH (type
);
2351 n
= TYPE_LENGTH (type
);
2353 memcpy (contents
, ldata
, n
);
2357 case DWARF_VALUE_OPTIMIZED_OUT
:
2358 do_cleanups (value_chain
);
2359 retval
= allocate_optimized_out_value (type
);
2362 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2363 operation by execute_stack_op. */
2364 case DWARF_VALUE_IMPLICIT_POINTER
:
2365 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2366 it can only be encountered when making a piece. */
2368 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2372 set_value_initialized (retval
, ctx
->initialized
);
2374 do_cleanups (old_chain
);
2379 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2380 passes 0 as the byte_offset. */
2383 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2384 const gdb_byte
*data
, size_t size
,
2385 struct dwarf2_per_cu_data
*per_cu
)
2387 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
2390 /* Evaluates a dwarf expression and stores the result in VAL, expecting
2391 that the dwarf expression only produces a single CORE_ADDR. ADDR is a
2392 context (location of a variable) and might be needed to evaluate the
2393 location expression.
2394 Returns 1 on success, 0 otherwise. */
2397 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton
*dlbaton
,
2401 struct dwarf_expr_context
*ctx
;
2402 struct dwarf_expr_baton baton
;
2403 struct objfile
*objfile
;
2404 struct cleanup
*cleanup
;
2406 if (dlbaton
== NULL
|| dlbaton
->size
== 0)
2409 ctx
= new_dwarf_expr_context ();
2410 cleanup
= make_cleanup_free_dwarf_expr_context (ctx
);
2412 baton
.frame
= get_selected_frame (NULL
);
2413 baton
.per_cu
= dlbaton
->per_cu
;
2414 baton
.obj_address
= addr
;
2416 objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2418 ctx
->gdbarch
= get_objfile_arch (objfile
);
2419 ctx
->addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2420 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (dlbaton
->per_cu
);
2421 ctx
->offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
2422 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2423 ctx
->baton
= &baton
;
2425 dwarf_expr_eval (ctx
, dlbaton
->data
, dlbaton
->size
);
2427 switch (ctx
->location
)
2429 case DWARF_VALUE_REGISTER
:
2430 case DWARF_VALUE_MEMORY
:
2431 case DWARF_VALUE_STACK
:
2432 *valp
= dwarf_expr_fetch_address (ctx
, 0);
2433 if (ctx
->location
== DWARF_VALUE_REGISTER
)
2434 *valp
= dwarf_expr_read_addr_from_reg (&baton
, *valp
);
2435 do_cleanups (cleanup
);
2437 case DWARF_VALUE_LITERAL
:
2438 *valp
= extract_signed_integer (ctx
->data
, ctx
->len
,
2439 gdbarch_byte_order (ctx
->gdbarch
));
2440 do_cleanups (cleanup
);
2442 /* Unsupported dwarf values. */
2443 case DWARF_VALUE_OPTIMIZED_OUT
:
2444 case DWARF_VALUE_IMPLICIT_POINTER
:
2448 do_cleanups (cleanup
);
2452 /* See dwarf2loc.h. */
2455 dwarf2_evaluate_property (const struct dynamic_prop
*prop
,
2456 CORE_ADDR address
, CORE_ADDR
*value
)
2465 const struct dwarf2_property_baton
*baton
= prop
->data
.baton
;
2467 if (dwarf2_locexpr_baton_eval (&baton
->locexpr
, address
, value
))
2469 if (baton
->referenced_type
)
2471 struct value
*val
= value_at (baton
->referenced_type
, *value
);
2473 *value
= value_as_address (val
);
2482 struct dwarf2_property_baton
*baton
= prop
->data
.baton
;
2483 struct frame_info
*frame
= get_selected_frame (NULL
);
2484 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2485 const gdb_byte
*data
;
2489 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2492 val
= dwarf2_evaluate_loc_desc (baton
->referenced_type
, frame
, data
,
2493 size
, baton
->loclist
.per_cu
);
2494 if (!value_optimized_out (val
))
2496 *value
= value_as_address (val
);
2504 *value
= prop
->data
.const_val
;
2512 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2514 struct needs_frame_baton
2517 struct dwarf2_per_cu_data
*per_cu
;
2520 /* Reads from registers do require a frame. */
2522 needs_frame_read_addr_from_reg (void *baton
, int regnum
)
2524 struct needs_frame_baton
*nf_baton
= baton
;
2526 nf_baton
->needs_frame
= 1;
2530 /* struct dwarf_expr_context_funcs' "get_reg_value" callback:
2531 Reads from registers do require a frame. */
2533 static struct value
*
2534 needs_frame_get_reg_value (void *baton
, struct type
*type
, int regnum
)
2536 struct needs_frame_baton
*nf_baton
= baton
;
2538 nf_baton
->needs_frame
= 1;
2539 return value_zero (type
, not_lval
);
2542 /* Reads from memory do not require a frame. */
2544 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
2546 memset (buf
, 0, len
);
2549 /* Frame-relative accesses do require a frame. */
2551 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
2553 static gdb_byte lit0
= DW_OP_lit0
;
2554 struct needs_frame_baton
*nf_baton
= baton
;
2559 nf_baton
->needs_frame
= 1;
2562 /* CFA accesses require a frame. */
2565 needs_frame_frame_cfa (void *baton
)
2567 struct needs_frame_baton
*nf_baton
= baton
;
2569 nf_baton
->needs_frame
= 1;
2573 /* Thread-local accesses do require a frame. */
2575 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
2577 struct needs_frame_baton
*nf_baton
= baton
;
2579 nf_baton
->needs_frame
= 1;
2583 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2586 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
2588 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2590 per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
,
2591 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
2594 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2597 needs_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
2598 enum call_site_parameter_kind kind
,
2599 union call_site_parameter_u kind_u
, int deref_size
)
2601 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2603 nf_baton
->needs_frame
= 1;
2605 /* The expression may require some stub values on DWARF stack. */
2606 dwarf_expr_push_address (ctx
, 0, 0);
2609 /* DW_OP_GNU_addr_index doesn't require a frame. */
2612 needs_get_addr_index (void *baton
, unsigned int index
)
2614 /* Nothing to do. */
2618 /* DW_OP_push_object_address has a frame already passed through. */
2621 needs_get_obj_addr (void *baton
)
2623 /* Nothing to do. */
2627 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2629 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs
=
2631 needs_frame_read_addr_from_reg
,
2632 needs_frame_get_reg_value
,
2633 needs_frame_read_mem
,
2634 needs_frame_frame_base
,
2635 needs_frame_frame_cfa
,
2636 needs_frame_frame_cfa
, /* get_frame_pc */
2637 needs_frame_tls_address
,
2638 needs_frame_dwarf_call
,
2639 NULL
, /* get_base_type */
2640 needs_dwarf_reg_entry_value
,
2641 needs_get_addr_index
,
2645 /* Return non-zero iff the location expression at DATA (length SIZE)
2646 requires a frame to evaluate. */
2649 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, size_t size
,
2650 struct dwarf2_per_cu_data
*per_cu
)
2652 struct needs_frame_baton baton
;
2653 struct dwarf_expr_context
*ctx
;
2655 struct cleanup
*old_chain
;
2656 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2658 baton
.needs_frame
= 0;
2659 baton
.per_cu
= per_cu
;
2661 ctx
= new_dwarf_expr_context ();
2662 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2663 make_cleanup_value_free_to_mark (value_mark ());
2665 ctx
->gdbarch
= get_objfile_arch (objfile
);
2666 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2667 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2668 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2669 ctx
->baton
= &baton
;
2670 ctx
->funcs
= &needs_frame_ctx_funcs
;
2672 dwarf_expr_eval (ctx
, data
, size
);
2674 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
2676 if (ctx
->num_pieces
> 0)
2680 /* If the location has several pieces, and any of them are in
2681 registers, then we will need a frame to fetch them from. */
2682 for (i
= 0; i
< ctx
->num_pieces
; i
++)
2683 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2687 do_cleanups (old_chain
);
2689 return baton
.needs_frame
|| in_reg
;
2692 /* A helper function that throws an unimplemented error mentioning a
2693 given DWARF operator. */
2696 unimplemented (unsigned int op
)
2698 const char *name
= get_DW_OP_name (op
);
2701 error (_("DWARF operator %s cannot be translated to an agent expression"),
2704 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2705 "to an agent expression"),
2709 /* A helper function to convert a DWARF register to an arch register.
2710 ARCH is the architecture.
2711 DWARF_REG is the register.
2712 This will throw an exception if the DWARF register cannot be
2713 translated to an architecture register. */
2716 translate_register (struct gdbarch
*arch
, int dwarf_reg
)
2718 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2720 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
2724 /* A helper function that emits an access to memory. ARCH is the
2725 target architecture. EXPR is the expression which we are building.
2726 NBITS is the number of bits we want to read. This emits the
2727 opcodes needed to read the memory and then extract the desired
2731 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2733 ULONGEST nbytes
= (nbits
+ 7) / 8;
2735 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2738 ax_trace_quick (expr
, nbytes
);
2741 ax_simple (expr
, aop_ref8
);
2742 else if (nbits
<= 16)
2743 ax_simple (expr
, aop_ref16
);
2744 else if (nbits
<= 32)
2745 ax_simple (expr
, aop_ref32
);
2747 ax_simple (expr
, aop_ref64
);
2749 /* If we read exactly the number of bytes we wanted, we're done. */
2750 if (8 * nbytes
== nbits
)
2753 if (gdbarch_bits_big_endian (arch
))
2755 /* On a bits-big-endian machine, we want the high-order
2757 ax_const_l (expr
, 8 * nbytes
- nbits
);
2758 ax_simple (expr
, aop_rsh_unsigned
);
2762 /* On a bits-little-endian box, we want the low-order NBITS. */
2763 ax_zero_ext (expr
, nbits
);
2767 /* A helper function to return the frame's PC. */
2770 get_ax_pc (void *baton
)
2772 struct agent_expr
*expr
= baton
;
2777 /* Compile a DWARF location expression to an agent expression.
2779 EXPR is the agent expression we are building.
2780 LOC is the agent value we modify.
2781 ARCH is the architecture.
2782 ADDR_SIZE is the size of addresses, in bytes.
2783 OP_PTR is the start of the location expression.
2784 OP_END is one past the last byte of the location expression.
2786 This will throw an exception for various kinds of errors -- for
2787 example, if the expression cannot be compiled, or if the expression
2791 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2792 struct gdbarch
*arch
, unsigned int addr_size
,
2793 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
2794 struct dwarf2_per_cu_data
*per_cu
)
2796 struct cleanup
*cleanups
;
2798 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
2799 const gdb_byte
* const base
= op_ptr
;
2800 const gdb_byte
*previous_piece
= op_ptr
;
2801 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2802 ULONGEST bits_collected
= 0;
2803 unsigned int addr_size_bits
= 8 * addr_size
;
2804 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
2806 offsets
= xmalloc ((op_end
- op_ptr
) * sizeof (int));
2807 cleanups
= make_cleanup (xfree
, offsets
);
2809 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
2812 make_cleanup (VEC_cleanup (int), &dw_labels
);
2813 make_cleanup (VEC_cleanup (int), &patches
);
2815 /* By default we are making an address. */
2816 loc
->kind
= axs_lvalue_memory
;
2818 while (op_ptr
< op_end
)
2820 enum dwarf_location_atom op
= *op_ptr
;
2821 uint64_t uoffset
, reg
;
2825 offsets
[op_ptr
- base
] = expr
->len
;
2828 /* Our basic approach to code generation is to map DWARF
2829 operations directly to AX operations. However, there are
2832 First, DWARF works on address-sized units, but AX always uses
2833 LONGEST. For most operations we simply ignore this
2834 difference; instead we generate sign extensions as needed
2835 before division and comparison operations. It would be nice
2836 to omit the sign extensions, but there is no way to determine
2837 the size of the target's LONGEST. (This code uses the size
2838 of the host LONGEST in some cases -- that is a bug but it is
2841 Second, some DWARF operations cannot be translated to AX.
2842 For these we simply fail. See
2843 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2878 ax_const_l (expr
, op
- DW_OP_lit0
);
2882 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
2883 op_ptr
+= addr_size
;
2884 /* Some versions of GCC emit DW_OP_addr before
2885 DW_OP_GNU_push_tls_address. In this case the value is an
2886 index, not an address. We don't support things like
2887 branching between the address and the TLS op. */
2888 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
2889 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
2890 ax_const_l (expr
, uoffset
);
2894 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
2898 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
2902 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
2906 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
2910 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
2914 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
2918 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
2922 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
2926 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
2927 ax_const_l (expr
, uoffset
);
2930 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2931 ax_const_l (expr
, offset
);
2966 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2967 loc
->u
.reg
= translate_register (arch
, op
- DW_OP_reg0
);
2968 loc
->kind
= axs_lvalue_register
;
2972 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2973 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2974 loc
->u
.reg
= translate_register (arch
, reg
);
2975 loc
->kind
= axs_lvalue_register
;
2978 case DW_OP_implicit_value
:
2982 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
2983 if (op_ptr
+ len
> op_end
)
2984 error (_("DW_OP_implicit_value: too few bytes available."));
2985 if (len
> sizeof (ULONGEST
))
2986 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
2989 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
2992 dwarf_expr_require_composition (op_ptr
, op_end
,
2993 "DW_OP_implicit_value");
2995 loc
->kind
= axs_rvalue
;
2999 case DW_OP_stack_value
:
3000 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
3001 loc
->kind
= axs_rvalue
;
3036 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3037 i
= translate_register (arch
, op
- DW_OP_breg0
);
3041 ax_const_l (expr
, offset
);
3042 ax_simple (expr
, aop_add
);
3047 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3048 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3049 i
= translate_register (arch
, reg
);
3053 ax_const_l (expr
, offset
);
3054 ax_simple (expr
, aop_add
);
3060 const gdb_byte
*datastart
;
3062 const struct block
*b
;
3063 struct symbol
*framefunc
;
3065 b
= block_for_pc (expr
->scope
);
3068 error (_("No block found for address"));
3070 framefunc
= block_linkage_function (b
);
3073 error (_("No function found for block"));
3075 dwarf_expr_frame_base_1 (framefunc
, expr
->scope
,
3076 &datastart
, &datalen
);
3078 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3079 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
3080 datastart
+ datalen
, per_cu
);
3081 if (loc
->kind
== axs_lvalue_register
)
3082 require_rvalue (expr
, loc
);
3086 ax_const_l (expr
, offset
);
3087 ax_simple (expr
, aop_add
);
3090 loc
->kind
= axs_lvalue_memory
;
3095 ax_simple (expr
, aop_dup
);
3099 ax_simple (expr
, aop_pop
);
3104 ax_pick (expr
, offset
);
3108 ax_simple (expr
, aop_swap
);
3116 ax_simple (expr
, aop_rot
);
3120 case DW_OP_deref_size
:
3124 if (op
== DW_OP_deref_size
)
3129 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3130 error (_("Unsupported size %d in %s"),
3131 size
, get_DW_OP_name (op
));
3132 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3137 /* Sign extend the operand. */
3138 ax_ext (expr
, addr_size_bits
);
3139 ax_simple (expr
, aop_dup
);
3140 ax_const_l (expr
, 0);
3141 ax_simple (expr
, aop_less_signed
);
3142 ax_simple (expr
, aop_log_not
);
3143 i
= ax_goto (expr
, aop_if_goto
);
3144 /* We have to emit 0 - X. */
3145 ax_const_l (expr
, 0);
3146 ax_simple (expr
, aop_swap
);
3147 ax_simple (expr
, aop_sub
);
3148 ax_label (expr
, i
, expr
->len
);
3152 /* No need to sign extend here. */
3153 ax_const_l (expr
, 0);
3154 ax_simple (expr
, aop_swap
);
3155 ax_simple (expr
, aop_sub
);
3159 /* Sign extend the operand. */
3160 ax_ext (expr
, addr_size_bits
);
3161 ax_simple (expr
, aop_bit_not
);
3164 case DW_OP_plus_uconst
:
3165 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3166 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3167 but we micro-optimize anyhow. */
3170 ax_const_l (expr
, reg
);
3171 ax_simple (expr
, aop_add
);
3176 ax_simple (expr
, aop_bit_and
);
3180 /* Sign extend the operands. */
3181 ax_ext (expr
, addr_size_bits
);
3182 ax_simple (expr
, aop_swap
);
3183 ax_ext (expr
, addr_size_bits
);
3184 ax_simple (expr
, aop_swap
);
3185 ax_simple (expr
, aop_div_signed
);
3189 ax_simple (expr
, aop_sub
);
3193 ax_simple (expr
, aop_rem_unsigned
);
3197 ax_simple (expr
, aop_mul
);
3201 ax_simple (expr
, aop_bit_or
);
3205 ax_simple (expr
, aop_add
);
3209 ax_simple (expr
, aop_lsh
);
3213 ax_simple (expr
, aop_rsh_unsigned
);
3217 ax_simple (expr
, aop_rsh_signed
);
3221 ax_simple (expr
, aop_bit_xor
);
3225 /* Sign extend the operands. */
3226 ax_ext (expr
, addr_size_bits
);
3227 ax_simple (expr
, aop_swap
);
3228 ax_ext (expr
, addr_size_bits
);
3229 /* Note no swap here: A <= B is !(B < A). */
3230 ax_simple (expr
, aop_less_signed
);
3231 ax_simple (expr
, aop_log_not
);
3235 /* Sign extend the operands. */
3236 ax_ext (expr
, addr_size_bits
);
3237 ax_simple (expr
, aop_swap
);
3238 ax_ext (expr
, addr_size_bits
);
3239 ax_simple (expr
, aop_swap
);
3240 /* A >= B is !(A < B). */
3241 ax_simple (expr
, aop_less_signed
);
3242 ax_simple (expr
, aop_log_not
);
3246 /* Sign extend the operands. */
3247 ax_ext (expr
, addr_size_bits
);
3248 ax_simple (expr
, aop_swap
);
3249 ax_ext (expr
, addr_size_bits
);
3250 /* No need for a second swap here. */
3251 ax_simple (expr
, aop_equal
);
3255 /* Sign extend the operands. */
3256 ax_ext (expr
, addr_size_bits
);
3257 ax_simple (expr
, aop_swap
);
3258 ax_ext (expr
, addr_size_bits
);
3259 ax_simple (expr
, aop_swap
);
3260 ax_simple (expr
, aop_less_signed
);
3264 /* Sign extend the operands. */
3265 ax_ext (expr
, addr_size_bits
);
3266 ax_simple (expr
, aop_swap
);
3267 ax_ext (expr
, addr_size_bits
);
3268 /* Note no swap here: A > B is B < A. */
3269 ax_simple (expr
, aop_less_signed
);
3273 /* Sign extend the operands. */
3274 ax_ext (expr
, addr_size_bits
);
3275 ax_simple (expr
, aop_swap
);
3276 ax_ext (expr
, addr_size_bits
);
3277 /* No need for a swap here. */
3278 ax_simple (expr
, aop_equal
);
3279 ax_simple (expr
, aop_log_not
);
3282 case DW_OP_call_frame_cfa
:
3283 dwarf2_compile_cfa_to_ax (expr
, loc
, arch
, expr
->scope
, per_cu
);
3284 loc
->kind
= axs_lvalue_memory
;
3287 case DW_OP_GNU_push_tls_address
:
3291 case DW_OP_push_object_address
:
3296 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3298 i
= ax_goto (expr
, aop_goto
);
3299 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3300 VEC_safe_push (int, patches
, i
);
3304 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3306 /* Zero extend the operand. */
3307 ax_zero_ext (expr
, addr_size_bits
);
3308 i
= ax_goto (expr
, aop_if_goto
);
3309 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3310 VEC_safe_push (int, patches
, i
);
3317 case DW_OP_bit_piece
:
3319 uint64_t size
, offset
;
3321 if (op_ptr
- 1 == previous_piece
)
3322 error (_("Cannot translate empty pieces to agent expressions"));
3323 previous_piece
= op_ptr
- 1;
3325 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3326 if (op
== DW_OP_piece
)
3332 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
3334 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3335 error (_("Expression pieces exceed word size"));
3337 /* Access the bits. */
3340 case axs_lvalue_register
:
3341 ax_reg (expr
, loc
->u
.reg
);
3344 case axs_lvalue_memory
:
3345 /* Offset the pointer, if needed. */
3348 ax_const_l (expr
, offset
/ 8);
3349 ax_simple (expr
, aop_add
);
3352 access_memory (arch
, expr
, size
);
3356 /* For a bits-big-endian target, shift up what we already
3357 have. For a bits-little-endian target, shift up the
3358 new data. Note that there is a potential bug here if
3359 the DWARF expression leaves multiple values on the
3361 if (bits_collected
> 0)
3363 if (bits_big_endian
)
3365 ax_simple (expr
, aop_swap
);
3366 ax_const_l (expr
, size
);
3367 ax_simple (expr
, aop_lsh
);
3368 /* We don't need a second swap here, because
3369 aop_bit_or is symmetric. */
3373 ax_const_l (expr
, size
);
3374 ax_simple (expr
, aop_lsh
);
3376 ax_simple (expr
, aop_bit_or
);
3379 bits_collected
+= size
;
3380 loc
->kind
= axs_rvalue
;
3384 case DW_OP_GNU_uninit
:
3390 struct dwarf2_locexpr_baton block
;
3391 int size
= (op
== DW_OP_call2
? 2 : 4);
3394 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3397 offset
.cu_off
= uoffset
;
3398 block
= dwarf2_fetch_die_loc_cu_off (offset
, per_cu
,
3401 /* DW_OP_call_ref is currently not supported. */
3402 gdb_assert (block
.per_cu
== per_cu
);
3404 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3405 block
.data
, block
.data
+ block
.size
,
3410 case DW_OP_call_ref
:
3418 /* Patch all the branches we emitted. */
3419 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
3421 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
3423 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3424 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
3427 do_cleanups (cleanups
);
3431 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3432 evaluator to calculate the location. */
3433 static struct value
*
3434 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3436 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3439 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3440 dlbaton
->size
, dlbaton
->per_cu
);
3445 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3446 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3449 static struct value
*
3450 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3452 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3454 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3458 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3460 locexpr_read_needs_frame (struct symbol
*symbol
)
3462 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3464 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
3468 /* Return true if DATA points to the end of a piece. END is one past
3469 the last byte in the expression. */
3472 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3474 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3477 /* Helper for locexpr_describe_location_piece that finds the name of a
3481 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3485 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
3486 return gdbarch_register_name (gdbarch
, regnum
);
3489 /* Nicely describe a single piece of a location, returning an updated
3490 position in the bytecode sequence. This function cannot recognize
3491 all locations; if a location is not recognized, it simply returns
3492 DATA. If there is an error during reading, e.g. we run off the end
3493 of the buffer, an error is thrown. */
3495 static const gdb_byte
*
3496 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3497 CORE_ADDR addr
, struct objfile
*objfile
,
3498 struct dwarf2_per_cu_data
*per_cu
,
3499 const gdb_byte
*data
, const gdb_byte
*end
,
3500 unsigned int addr_size
)
3502 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3505 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3507 fprintf_filtered (stream
, _("a variable in $%s"),
3508 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3511 else if (data
[0] == DW_OP_regx
)
3515 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3516 fprintf_filtered (stream
, _("a variable in $%s"),
3517 locexpr_regname (gdbarch
, reg
));
3519 else if (data
[0] == DW_OP_fbreg
)
3521 const struct block
*b
;
3522 struct symbol
*framefunc
;
3524 int64_t frame_offset
;
3525 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3527 int64_t base_offset
= 0;
3529 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3530 if (!piece_end_p (new_data
, end
))
3534 b
= block_for_pc (addr
);
3537 error (_("No block found for address for symbol \"%s\"."),
3538 SYMBOL_PRINT_NAME (symbol
));
3540 framefunc
= block_linkage_function (b
);
3543 error (_("No function found for block for symbol \"%s\"."),
3544 SYMBOL_PRINT_NAME (symbol
));
3546 dwarf_expr_frame_base_1 (framefunc
, addr
, &base_data
, &base_size
);
3548 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3550 const gdb_byte
*buf_end
;
3552 frame_reg
= base_data
[0] - DW_OP_breg0
;
3553 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3555 if (buf_end
!= base_data
+ base_size
)
3556 error (_("Unexpected opcode after "
3557 "DW_OP_breg%u for symbol \"%s\"."),
3558 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3560 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3562 /* The frame base is just the register, with no offset. */
3563 frame_reg
= base_data
[0] - DW_OP_reg0
;
3568 /* We don't know what to do with the frame base expression,
3569 so we can't trace this variable; give up. */
3573 fprintf_filtered (stream
,
3574 _("a variable at frame base reg $%s offset %s+%s"),
3575 locexpr_regname (gdbarch
, frame_reg
),
3576 plongest (base_offset
), plongest (frame_offset
));
3578 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3579 && piece_end_p (data
, end
))
3583 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3585 fprintf_filtered (stream
,
3586 _("a variable at offset %s from base reg $%s"),
3588 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3591 /* The location expression for a TLS variable looks like this (on a
3594 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3595 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3597 0x3 is the encoding for DW_OP_addr, which has an operand as long
3598 as the size of an address on the target machine (here is 8
3599 bytes). Note that more recent version of GCC emit DW_OP_const4u
3600 or DW_OP_const8u, depending on address size, rather than
3601 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3602 The operand represents the offset at which the variable is within
3603 the thread local storage. */
3605 else if (data
+ 1 + addr_size
< end
3606 && (data
[0] == DW_OP_addr
3607 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3608 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3609 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3610 && piece_end_p (data
+ 2 + addr_size
, end
))
3613 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3614 gdbarch_byte_order (gdbarch
));
3616 fprintf_filtered (stream
,
3617 _("a thread-local variable at offset 0x%s "
3618 "in the thread-local storage for `%s'"),
3619 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3621 data
+= 1 + addr_size
+ 1;
3624 /* With -gsplit-dwarf a TLS variable can also look like this:
3625 DW_AT_location : 3 byte block: fc 4 e0
3626 (DW_OP_GNU_const_index: 4;
3627 DW_OP_GNU_push_tls_address) */
3628 else if (data
+ 3 <= end
3629 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3630 && data
[0] == DW_OP_GNU_const_index
3632 && data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3633 && piece_end_p (data
+ 2 + leb128_size
, end
))
3637 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3638 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3639 fprintf_filtered (stream
,
3640 _("a thread-local variable at offset 0x%s "
3641 "in the thread-local storage for `%s'"),
3642 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3646 else if (data
[0] >= DW_OP_lit0
3647 && data
[0] <= DW_OP_lit31
3649 && data
[1] == DW_OP_stack_value
)
3651 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3658 /* Disassemble an expression, stopping at the end of a piece or at the
3659 end of the expression. Returns a pointer to the next unread byte
3660 in the input expression. If ALL is nonzero, then this function
3661 will keep going until it reaches the end of the expression.
3662 If there is an error during reading, e.g. we run off the end
3663 of the buffer, an error is thrown. */
3665 static const gdb_byte
*
3666 disassemble_dwarf_expression (struct ui_file
*stream
,
3667 struct gdbarch
*arch
, unsigned int addr_size
,
3668 int offset_size
, const gdb_byte
*start
,
3669 const gdb_byte
*data
, const gdb_byte
*end
,
3670 int indent
, int all
,
3671 struct dwarf2_per_cu_data
*per_cu
)
3675 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3677 enum dwarf_location_atom op
= *data
++;
3682 name
= get_DW_OP_name (op
);
3685 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3686 op
, (long) (data
- 1 - start
));
3687 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3688 (long) (data
- 1 - start
), name
);
3693 ul
= extract_unsigned_integer (data
, addr_size
,
3694 gdbarch_byte_order (arch
));
3696 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3700 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3702 fprintf_filtered (stream
, " %s", pulongest (ul
));
3705 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3707 fprintf_filtered (stream
, " %s", plongest (l
));
3710 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3712 fprintf_filtered (stream
, " %s", pulongest (ul
));
3715 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3717 fprintf_filtered (stream
, " %s", plongest (l
));
3720 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3722 fprintf_filtered (stream
, " %s", pulongest (ul
));
3725 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3727 fprintf_filtered (stream
, " %s", plongest (l
));
3730 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3732 fprintf_filtered (stream
, " %s", pulongest (ul
));
3735 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3737 fprintf_filtered (stream
, " %s", plongest (l
));
3740 data
= safe_read_uleb128 (data
, end
, &ul
);
3741 fprintf_filtered (stream
, " %s", pulongest (ul
));
3744 data
= safe_read_sleb128 (data
, end
, &l
);
3745 fprintf_filtered (stream
, " %s", plongest (l
));
3780 fprintf_filtered (stream
, " [$%s]",
3781 locexpr_regname (arch
, op
- DW_OP_reg0
));
3785 data
= safe_read_uleb128 (data
, end
, &ul
);
3786 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3787 locexpr_regname (arch
, (int) ul
));
3790 case DW_OP_implicit_value
:
3791 data
= safe_read_uleb128 (data
, end
, &ul
);
3793 fprintf_filtered (stream
, " %s", pulongest (ul
));
3828 data
= safe_read_sleb128 (data
, end
, &l
);
3829 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
3830 locexpr_regname (arch
, op
- DW_OP_breg0
));
3834 data
= safe_read_uleb128 (data
, end
, &ul
);
3835 data
= safe_read_sleb128 (data
, end
, &l
);
3836 fprintf_filtered (stream
, " register %s [$%s] offset %s",
3838 locexpr_regname (arch
, (int) ul
),
3843 data
= safe_read_sleb128 (data
, end
, &l
);
3844 fprintf_filtered (stream
, " %s", plongest (l
));
3847 case DW_OP_xderef_size
:
3848 case DW_OP_deref_size
:
3850 fprintf_filtered (stream
, " %d", *data
);
3854 case DW_OP_plus_uconst
:
3855 data
= safe_read_uleb128 (data
, end
, &ul
);
3856 fprintf_filtered (stream
, " %s", pulongest (ul
));
3860 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3862 fprintf_filtered (stream
, " to %ld",
3863 (long) (data
+ l
- start
));
3867 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3869 fprintf_filtered (stream
, " %ld",
3870 (long) (data
+ l
- start
));
3874 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3876 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
3880 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3882 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3885 case DW_OP_call_ref
:
3886 ul
= extract_unsigned_integer (data
, offset_size
,
3887 gdbarch_byte_order (arch
));
3888 data
+= offset_size
;
3889 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
3893 data
= safe_read_uleb128 (data
, end
, &ul
);
3894 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
3897 case DW_OP_bit_piece
:
3901 data
= safe_read_uleb128 (data
, end
, &ul
);
3902 data
= safe_read_uleb128 (data
, end
, &offset
);
3903 fprintf_filtered (stream
, " size %s offset %s (bits)",
3904 pulongest (ul
), pulongest (offset
));
3908 case DW_OP_GNU_implicit_pointer
:
3910 ul
= extract_unsigned_integer (data
, offset_size
,
3911 gdbarch_byte_order (arch
));
3912 data
+= offset_size
;
3914 data
= safe_read_sleb128 (data
, end
, &l
);
3916 fprintf_filtered (stream
, " DIE %s offset %s",
3917 phex_nz (ul
, offset_size
),
3922 case DW_OP_GNU_deref_type
:
3924 int addr_size
= *data
++;
3928 data
= safe_read_uleb128 (data
, end
, &ul
);
3930 type
= dwarf2_get_die_type (offset
, per_cu
);
3931 fprintf_filtered (stream
, "<");
3932 type_print (type
, "", stream
, -1);
3933 fprintf_filtered (stream
, " [0x%s]> %d", phex_nz (offset
.cu_off
, 0),
3938 case DW_OP_GNU_const_type
:
3943 data
= safe_read_uleb128 (data
, end
, &ul
);
3944 type_die
.cu_off
= ul
;
3945 type
= dwarf2_get_die_type (type_die
, per_cu
);
3946 fprintf_filtered (stream
, "<");
3947 type_print (type
, "", stream
, -1);
3948 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3952 case DW_OP_GNU_regval_type
:
3958 data
= safe_read_uleb128 (data
, end
, ®
);
3959 data
= safe_read_uleb128 (data
, end
, &ul
);
3960 type_die
.cu_off
= ul
;
3962 type
= dwarf2_get_die_type (type_die
, per_cu
);
3963 fprintf_filtered (stream
, "<");
3964 type_print (type
, "", stream
, -1);
3965 fprintf_filtered (stream
, " [0x%s]> [$%s]",
3966 phex_nz (type_die
.cu_off
, 0),
3967 locexpr_regname (arch
, reg
));
3971 case DW_OP_GNU_convert
:
3972 case DW_OP_GNU_reinterpret
:
3976 data
= safe_read_uleb128 (data
, end
, &ul
);
3977 type_die
.cu_off
= ul
;
3979 if (type_die
.cu_off
== 0)
3980 fprintf_filtered (stream
, "<0>");
3985 type
= dwarf2_get_die_type (type_die
, per_cu
);
3986 fprintf_filtered (stream
, "<");
3987 type_print (type
, "", stream
, -1);
3988 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3993 case DW_OP_GNU_entry_value
:
3994 data
= safe_read_uleb128 (data
, end
, &ul
);
3995 fputc_filtered ('\n', stream
);
3996 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
3997 start
, data
, data
+ ul
, indent
+ 2,
4002 case DW_OP_GNU_parameter_ref
:
4003 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4005 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4008 case DW_OP_GNU_addr_index
:
4009 data
= safe_read_uleb128 (data
, end
, &ul
);
4010 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4011 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
4013 case DW_OP_GNU_const_index
:
4014 data
= safe_read_uleb128 (data
, end
, &ul
);
4015 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4016 fprintf_filtered (stream
, " %s", pulongest (ul
));
4020 fprintf_filtered (stream
, "\n");
4026 /* Describe a single location, which may in turn consist of multiple
4030 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
4031 struct ui_file
*stream
,
4032 const gdb_byte
*data
, size_t size
,
4033 struct objfile
*objfile
, unsigned int addr_size
,
4034 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
4036 const gdb_byte
*end
= data
+ size
;
4037 int first_piece
= 1, bad
= 0;
4041 const gdb_byte
*here
= data
;
4042 int disassemble
= 1;
4047 fprintf_filtered (stream
, _(", and "));
4049 if (!dwarf2_always_disassemble
)
4051 data
= locexpr_describe_location_piece (symbol
, stream
,
4052 addr
, objfile
, per_cu
,
4053 data
, end
, addr_size
);
4054 /* If we printed anything, or if we have an empty piece,
4055 then don't disassemble. */
4057 || data
[0] == DW_OP_piece
4058 || data
[0] == DW_OP_bit_piece
)
4063 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
4064 data
= disassemble_dwarf_expression (stream
,
4065 get_objfile_arch (objfile
),
4066 addr_size
, offset_size
, data
,
4068 dwarf2_always_disassemble
,
4074 int empty
= data
== here
;
4077 fprintf_filtered (stream
, " ");
4078 if (data
[0] == DW_OP_piece
)
4082 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
4085 fprintf_filtered (stream
, _("an empty %s-byte piece"),
4088 fprintf_filtered (stream
, _(" [%s-byte piece]"),
4091 else if (data
[0] == DW_OP_bit_piece
)
4093 uint64_t bits
, offset
;
4095 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
4096 data
= safe_read_uleb128 (data
, end
, &offset
);
4099 fprintf_filtered (stream
,
4100 _("an empty %s-bit piece"),
4103 fprintf_filtered (stream
,
4104 _(" [%s-bit piece, offset %s bits]"),
4105 pulongest (bits
), pulongest (offset
));
4115 if (bad
|| data
> end
)
4116 error (_("Corrupted DWARF2 expression for \"%s\"."),
4117 SYMBOL_PRINT_NAME (symbol
));
4120 /* Print a natural-language description of SYMBOL to STREAM. This
4121 version is for a symbol with a single location. */
4124 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4125 struct ui_file
*stream
)
4127 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4128 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4129 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4130 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4132 locexpr_describe_location_1 (symbol
, addr
, stream
,
4133 dlbaton
->data
, dlbaton
->size
,
4134 objfile
, addr_size
, offset_size
,
4138 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4139 any necessary bytecode in AX. */
4142 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4143 struct agent_expr
*ax
, struct axs_value
*value
)
4145 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4146 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4148 if (dlbaton
->size
== 0)
4149 value
->optimized_out
= 1;
4151 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
4152 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4156 /* The set of location functions used with the DWARF-2 expression
4158 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4159 locexpr_read_variable
,
4160 locexpr_read_variable_at_entry
,
4161 locexpr_read_needs_frame
,
4162 locexpr_describe_location
,
4163 0, /* location_has_loclist */
4164 locexpr_tracepoint_var_ref
4168 /* Wrapper functions for location lists. These generally find
4169 the appropriate location expression and call something above. */
4171 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4172 evaluator to calculate the location. */
4173 static struct value
*
4174 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4176 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4178 const gdb_byte
*data
;
4180 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4182 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4183 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4189 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4190 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4193 Function always returns non-NULL value, it may be marked optimized out if
4194 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4195 if it cannot resolve the parameter for any reason. */
4197 static struct value
*
4198 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4200 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4201 const gdb_byte
*data
;
4205 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4206 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4208 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4210 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4212 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4215 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
4217 loclist_read_needs_frame (struct symbol
*symbol
)
4219 /* If there's a location list, then assume we need to have a frame
4220 to choose the appropriate location expression. With tracking of
4221 global variables this is not necessarily true, but such tracking
4222 is disabled in GCC at the moment until we figure out how to
4228 /* Print a natural-language description of SYMBOL to STREAM. This
4229 version applies when there is a list of different locations, each
4230 with a specified address range. */
4233 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4234 struct ui_file
*stream
)
4236 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4237 const gdb_byte
*loc_ptr
, *buf_end
;
4238 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4239 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4240 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4241 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4242 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4243 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4244 /* Adjust base_address for relocatable objects. */
4245 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4246 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4249 loc_ptr
= dlbaton
->data
;
4250 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4252 fprintf_filtered (stream
, _("multi-location:\n"));
4254 /* Iterate through locations until we run out. */
4257 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4259 enum debug_loc_kind kind
;
4260 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4262 if (dlbaton
->from_dwo
)
4263 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4264 loc_ptr
, buf_end
, &new_ptr
,
4265 &low
, &high
, byte_order
);
4267 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4269 byte_order
, addr_size
,
4274 case DEBUG_LOC_END_OF_LIST
:
4277 case DEBUG_LOC_BASE_ADDRESS
:
4278 base_address
= high
+ base_offset
;
4279 fprintf_filtered (stream
, _(" Base address %s"),
4280 paddress (gdbarch
, base_address
));
4282 case DEBUG_LOC_START_END
:
4283 case DEBUG_LOC_START_LENGTH
:
4285 case DEBUG_LOC_BUFFER_OVERFLOW
:
4286 case DEBUG_LOC_INVALID_ENTRY
:
4287 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4288 SYMBOL_PRINT_NAME (symbol
));
4290 gdb_assert_not_reached ("bad debug_loc_kind");
4293 /* Otherwise, a location expression entry. */
4294 low
+= base_address
;
4295 high
+= base_address
;
4297 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4300 /* (It would improve readability to print only the minimum
4301 necessary digits of the second number of the range.) */
4302 fprintf_filtered (stream
, _(" Range %s-%s: "),
4303 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4305 /* Now describe this particular location. */
4306 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4307 objfile
, addr_size
, offset_size
,
4310 fprintf_filtered (stream
, "\n");
4316 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4317 any necessary bytecode in AX. */
4319 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4320 struct agent_expr
*ax
, struct axs_value
*value
)
4322 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4323 const gdb_byte
*data
;
4325 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4327 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4329 value
->optimized_out
= 1;
4331 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
4335 /* The set of location functions used with the DWARF-2 expression
4336 evaluator and location lists. */
4337 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4338 loclist_read_variable
,
4339 loclist_read_variable_at_entry
,
4340 loclist_read_needs_frame
,
4341 loclist_describe_location
,
4342 1, /* location_has_loclist */
4343 loclist_tracepoint_var_ref
4346 /* Provide a prototype to silence -Wmissing-prototypes. */
4347 extern initialize_file_ftype _initialize_dwarf2loc
;
4350 _initialize_dwarf2loc (void)
4352 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4353 &entry_values_debug
,
4354 _("Set entry values and tail call frames "
4356 _("Show entry values and tail call frames "
4358 _("When non-zero, the process of determining "
4359 "parameter values from function entry point "
4360 "and tail call frames will be printed."),
4362 show_entry_values_debug
,
4363 &setdebuglist
, &showdebuglist
);