1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003-2013 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 #include "gdb_string.h"
43 #include "gdb_assert.h"
47 extern int dwarf2_always_disassemble
;
49 static void dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
50 const gdb_byte
**start
, size_t *length
);
52 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
;
54 static struct value
*dwarf2_evaluate_loc_desc_full (struct type
*type
,
55 struct frame_info
*frame
,
58 struct dwarf2_per_cu_data
*per_cu
,
61 /* Until these have formal names, we define these here.
62 ref: http://gcc.gnu.org/wiki/DebugFission
63 Each entry in .debug_loc.dwo begins with a byte that describes the entry,
64 and is then followed by data specific to that entry. */
68 /* Indicates the end of the list of entries. */
69 DEBUG_LOC_END_OF_LIST
= 0,
71 /* This is followed by an unsigned LEB128 number that is an index into
72 .debug_addr and specifies the base address for all following entries. */
73 DEBUG_LOC_BASE_ADDRESS
= 1,
75 /* This is followed by two unsigned LEB128 numbers that are indices into
76 .debug_addr and specify the beginning and ending addresses, and then
77 a normal location expression as in .debug_loc. */
78 DEBUG_LOC_START_END
= 2,
80 /* This is followed by an unsigned LEB128 number that is an index into
81 .debug_addr and specifies the beginning address, and a 4 byte unsigned
82 number that specifies the length, and then a normal location expression
84 DEBUG_LOC_START_LENGTH
= 3,
86 /* An internal value indicating there is insufficient data. */
87 DEBUG_LOC_BUFFER_OVERFLOW
= -1,
89 /* An internal value indicating an invalid kind of entry was found. */
90 DEBUG_LOC_INVALID_ENTRY
= -2
93 /* Helper function which throws an error if a synthetic pointer is
97 invalid_synthetic_pointer (void)
99 error (_("access outside bounds of object "
100 "referenced via synthetic pointer"));
103 /* Decode the addresses in a non-dwo .debug_loc entry.
104 A pointer to the next byte to examine is returned in *NEW_PTR.
105 The encoded low,high addresses are return in *LOW,*HIGH.
106 The result indicates the kind of entry found. */
108 static enum debug_loc_kind
109 decode_debug_loc_addresses (const gdb_byte
*loc_ptr
, const gdb_byte
*buf_end
,
110 const gdb_byte
**new_ptr
,
111 CORE_ADDR
*low
, CORE_ADDR
*high
,
112 enum bfd_endian byte_order
,
113 unsigned int addr_size
,
116 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
118 if (buf_end
- loc_ptr
< 2 * addr_size
)
119 return DEBUG_LOC_BUFFER_OVERFLOW
;
122 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
124 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
125 loc_ptr
+= addr_size
;
128 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
130 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
131 loc_ptr
+= addr_size
;
135 /* A base-address-selection entry. */
136 if ((*low
& base_mask
) == base_mask
)
137 return DEBUG_LOC_BASE_ADDRESS
;
139 /* An end-of-list entry. */
140 if (*low
== 0 && *high
== 0)
141 return DEBUG_LOC_END_OF_LIST
;
143 return DEBUG_LOC_START_END
;
146 /* Decode the addresses in .debug_loc.dwo entry.
147 A pointer to the next byte to examine is returned in *NEW_PTR.
148 The encoded low,high addresses are return in *LOW,*HIGH.
149 The result indicates the kind of entry found. */
151 static enum debug_loc_kind
152 decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data
*per_cu
,
153 const gdb_byte
*loc_ptr
,
154 const gdb_byte
*buf_end
,
155 const gdb_byte
**new_ptr
,
156 CORE_ADDR
*low
, CORE_ADDR
*high
,
157 enum bfd_endian byte_order
)
159 uint64_t low_index
, high_index
;
161 if (loc_ptr
== buf_end
)
162 return DEBUG_LOC_BUFFER_OVERFLOW
;
166 case DEBUG_LOC_END_OF_LIST
:
168 return DEBUG_LOC_END_OF_LIST
;
169 case DEBUG_LOC_BASE_ADDRESS
:
171 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
173 return DEBUG_LOC_BUFFER_OVERFLOW
;
174 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
176 return DEBUG_LOC_BASE_ADDRESS
;
177 case DEBUG_LOC_START_END
:
178 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
180 return DEBUG_LOC_BUFFER_OVERFLOW
;
181 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
182 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
184 return DEBUG_LOC_BUFFER_OVERFLOW
;
185 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
187 return DEBUG_LOC_START_END
;
188 case DEBUG_LOC_START_LENGTH
:
189 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
191 return DEBUG_LOC_BUFFER_OVERFLOW
;
192 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
193 if (loc_ptr
+ 4 > buf_end
)
194 return DEBUG_LOC_BUFFER_OVERFLOW
;
196 *high
+= extract_unsigned_integer (loc_ptr
, 4, byte_order
);
197 *new_ptr
= loc_ptr
+ 4;
198 return DEBUG_LOC_START_LENGTH
;
200 return DEBUG_LOC_INVALID_ENTRY
;
204 /* A function for dealing with location lists. Given a
205 symbol baton (BATON) and a pc value (PC), find the appropriate
206 location expression, set *LOCEXPR_LENGTH, and return a pointer
207 to the beginning of the expression. Returns NULL on failure.
209 For now, only return the first matching location expression; there
210 can be more than one in the list. */
213 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
214 size_t *locexpr_length
, CORE_ADDR pc
)
216 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
217 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
218 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
219 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
220 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
221 /* Adjust base_address for relocatable objects. */
222 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (baton
->per_cu
);
223 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
224 const gdb_byte
*loc_ptr
, *buf_end
;
226 loc_ptr
= baton
->data
;
227 buf_end
= baton
->data
+ baton
->size
;
231 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
233 enum debug_loc_kind kind
;
234 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
237 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
238 loc_ptr
, buf_end
, &new_ptr
,
239 &low
, &high
, byte_order
);
241 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
243 byte_order
, addr_size
,
248 case DEBUG_LOC_END_OF_LIST
:
251 case DEBUG_LOC_BASE_ADDRESS
:
252 base_address
= high
+ base_offset
;
254 case DEBUG_LOC_START_END
:
255 case DEBUG_LOC_START_LENGTH
:
257 case DEBUG_LOC_BUFFER_OVERFLOW
:
258 case DEBUG_LOC_INVALID_ENTRY
:
259 error (_("dwarf2_find_location_expression: "
260 "Corrupted DWARF expression."));
262 gdb_assert_not_reached ("bad debug_loc_kind");
265 /* Otherwise, a location expression entry.
266 If the entry is from a DWO, don't add base address: the entry is
267 from .debug_addr which has absolute addresses. */
268 if (! baton
->from_dwo
)
271 high
+= base_address
;
274 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
277 if (low
== high
&& pc
== low
)
279 /* This is entry PC record present only at entry point
280 of a function. Verify it is really the function entry point. */
282 struct block
*pc_block
= block_for_pc (pc
);
283 struct symbol
*pc_func
= NULL
;
286 pc_func
= block_linkage_function (pc_block
);
288 if (pc_func
&& pc
== BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func
)))
290 *locexpr_length
= length
;
295 if (pc
>= low
&& pc
< high
)
297 *locexpr_length
= length
;
305 /* This is the baton used when performing dwarf2 expression
307 struct dwarf_expr_baton
309 struct frame_info
*frame
;
310 struct dwarf2_per_cu_data
*per_cu
;
313 /* Helper functions for dwarf2_evaluate_loc_desc. */
315 /* Using the frame specified in BATON, return the value of register
316 REGNUM, treated as a pointer. */
318 dwarf_expr_read_reg (void *baton
, int dwarf_regnum
)
320 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
321 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
325 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
326 result
= address_from_register (builtin_type (gdbarch
)->builtin_data_ptr
,
327 regnum
, debaton
->frame
);
331 /* Read memory at ADDR (length LEN) into BUF. */
334 dwarf_expr_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
336 read_memory (addr
, buf
, len
);
339 /* Using the frame specified in BATON, find the location expression
340 describing the frame base. Return a pointer to it in START and
341 its length in LENGTH. */
343 dwarf_expr_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
345 /* FIXME: cagney/2003-03-26: This code should be using
346 get_frame_base_address(), and then implement a dwarf2 specific
348 struct symbol
*framefunc
;
349 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
350 struct block
*bl
= get_frame_block (debaton
->frame
, NULL
);
353 error (_("frame address is not available."));
355 /* Use block_linkage_function, which returns a real (not inlined)
356 function, instead of get_frame_function, which may return an
358 framefunc
= block_linkage_function (bl
);
360 /* If we found a frame-relative symbol then it was certainly within
361 some function associated with a frame. If we can't find the frame,
362 something has gone wrong. */
363 gdb_assert (framefunc
!= NULL
);
365 dwarf_expr_frame_base_1 (framefunc
,
366 get_frame_address_in_block (debaton
->frame
),
370 /* Implement find_frame_base_location method for LOC_BLOCK functions using
371 DWARF expression for its DW_AT_frame_base. */
374 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
375 const gdb_byte
**start
, size_t *length
)
377 struct dwarf2_locexpr_baton
*symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
379 *length
= symbaton
->size
;
380 *start
= symbaton
->data
;
383 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
384 function uses DWARF expression for its DW_AT_frame_base. */
386 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
388 locexpr_find_frame_base_location
391 /* Implement find_frame_base_location method for LOC_BLOCK functions using
392 DWARF location list for its DW_AT_frame_base. */
395 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
396 const gdb_byte
**start
, size_t *length
)
398 struct dwarf2_loclist_baton
*symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
400 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
403 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
404 function uses DWARF location list for its DW_AT_frame_base. */
406 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
408 loclist_find_frame_base_location
412 dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
413 const gdb_byte
**start
, size_t *length
)
415 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
417 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
419 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
425 error (_("Could not find the frame base for \"%s\"."),
426 SYMBOL_NATURAL_NAME (framefunc
));
429 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
430 the frame in BATON. */
433 dwarf_expr_frame_cfa (void *baton
)
435 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
437 return dwarf2_frame_cfa (debaton
->frame
);
440 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
441 the frame in BATON. */
444 dwarf_expr_frame_pc (void *baton
)
446 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
448 return get_frame_address_in_block (debaton
->frame
);
451 /* Using the objfile specified in BATON, find the address for the
452 current thread's thread-local storage with offset OFFSET. */
454 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
456 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
457 struct objfile
*objfile
= dwarf2_per_cu_objfile (debaton
->per_cu
);
459 return target_translate_tls_address (objfile
, offset
);
462 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
463 current CU (as is PER_CU). State of the CTX is not affected by the
467 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
468 struct dwarf2_per_cu_data
*per_cu
,
469 CORE_ADDR (*get_frame_pc
) (void *baton
),
472 struct dwarf2_locexpr_baton block
;
474 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
, get_frame_pc
, baton
);
476 /* DW_OP_call_ref is currently not supported. */
477 gdb_assert (block
.per_cu
== per_cu
);
479 dwarf_expr_eval (ctx
, block
.data
, block
.size
);
482 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
485 dwarf_expr_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
487 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
489 per_cu_dwarf_call (ctx
, die_offset
, debaton
->per_cu
,
490 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
493 /* Callback function for dwarf2_evaluate_loc_desc. */
496 dwarf_expr_get_base_type (struct dwarf_expr_context
*ctx
,
497 cu_offset die_offset
)
499 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
501 return dwarf2_get_die_type (die_offset
, debaton
->per_cu
);
504 /* See dwarf2loc.h. */
506 unsigned int entry_values_debug
= 0;
508 /* Helper to set entry_values_debug. */
511 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
512 struct cmd_list_element
*c
, const char *value
)
514 fprintf_filtered (file
,
515 _("Entry values and tail call frames debugging is %s.\n"),
519 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
520 CALLER_FRAME (for registers) can be NULL if it is not known. This function
521 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
524 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
525 struct call_site
*call_site
,
526 struct frame_info
*caller_frame
)
528 switch (FIELD_LOC_KIND (call_site
->target
))
530 case FIELD_LOC_KIND_DWARF_BLOCK
:
532 struct dwarf2_locexpr_baton
*dwarf_block
;
534 struct type
*caller_core_addr_type
;
535 struct gdbarch
*caller_arch
;
537 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
538 if (dwarf_block
== NULL
)
540 struct bound_minimal_symbol msym
;
542 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
543 throw_error (NO_ENTRY_VALUE_ERROR
,
544 _("DW_AT_GNU_call_site_target is not specified "
546 paddress (call_site_gdbarch
, call_site
->pc
),
547 (msym
.minsym
== NULL
? "???"
548 : SYMBOL_PRINT_NAME (msym
.minsym
)));
551 if (caller_frame
== NULL
)
553 struct bound_minimal_symbol msym
;
555 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
556 throw_error (NO_ENTRY_VALUE_ERROR
,
557 _("DW_AT_GNU_call_site_target DWARF block resolving "
558 "requires known frame which is currently not "
559 "available at %s in %s"),
560 paddress (call_site_gdbarch
, call_site
->pc
),
561 (msym
.minsym
== NULL
? "???"
562 : SYMBOL_PRINT_NAME (msym
.minsym
)));
565 caller_arch
= get_frame_arch (caller_frame
);
566 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
567 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
568 dwarf_block
->data
, dwarf_block
->size
,
569 dwarf_block
->per_cu
);
570 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
572 if (VALUE_LVAL (val
) == lval_memory
)
573 return value_address (val
);
575 return value_as_address (val
);
578 case FIELD_LOC_KIND_PHYSNAME
:
580 const char *physname
;
581 struct minimal_symbol
*msym
;
583 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
585 /* Handle both the mangled and demangled PHYSNAME. */
586 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
589 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1).minsym
;
590 throw_error (NO_ENTRY_VALUE_ERROR
,
591 _("Cannot find function \"%s\" for a call site target "
593 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
594 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
597 return SYMBOL_VALUE_ADDRESS (msym
);
600 case FIELD_LOC_KIND_PHYSADDR
:
601 return FIELD_STATIC_PHYSADDR (call_site
->target
);
604 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
608 /* Convert function entry point exact address ADDR to the function which is
609 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
610 NO_ENTRY_VALUE_ERROR otherwise. */
612 static struct symbol
*
613 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
615 struct symbol
*sym
= find_pc_function (addr
);
618 if (sym
== NULL
|| BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
619 throw_error (NO_ENTRY_VALUE_ERROR
,
620 _("DW_TAG_GNU_call_site resolving failed to find function "
621 "name for address %s"),
622 paddress (gdbarch
, addr
));
624 type
= SYMBOL_TYPE (sym
);
625 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
626 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
631 /* Verify function with entry point exact address ADDR can never call itself
632 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
633 can call itself via tail calls.
635 If a funtion can tail call itself its entry value based parameters are
636 unreliable. There is no verification whether the value of some/all
637 parameters is unchanged through the self tail call, we expect if there is
638 a self tail call all the parameters can be modified. */
641 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
643 struct obstack addr_obstack
;
644 struct cleanup
*old_chain
;
647 /* Track here CORE_ADDRs which were already visited. */
650 /* The verification is completely unordered. Track here function addresses
651 which still need to be iterated. */
652 VEC (CORE_ADDR
) *todo
= NULL
;
654 obstack_init (&addr_obstack
);
655 old_chain
= make_cleanup_obstack_free (&addr_obstack
);
656 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
657 &addr_obstack
, hashtab_obstack_allocate
,
659 make_cleanup_htab_delete (addr_hash
);
661 make_cleanup (VEC_cleanup (CORE_ADDR
), &todo
);
663 VEC_safe_push (CORE_ADDR
, todo
, verify_addr
);
664 while (!VEC_empty (CORE_ADDR
, todo
))
666 struct symbol
*func_sym
;
667 struct call_site
*call_site
;
669 addr
= VEC_pop (CORE_ADDR
, todo
);
671 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
673 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
674 call_site
; call_site
= call_site
->tail_call_next
)
676 CORE_ADDR target_addr
;
679 /* CALLER_FRAME with registers is not available for tail-call jumped
681 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
683 if (target_addr
== verify_addr
)
685 struct bound_minimal_symbol msym
;
687 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
688 throw_error (NO_ENTRY_VALUE_ERROR
,
689 _("DW_OP_GNU_entry_value resolving has found "
690 "function \"%s\" at %s can call itself via tail "
692 (msym
.minsym
== NULL
? "???"
693 : SYMBOL_PRINT_NAME (msym
.minsym
)),
694 paddress (gdbarch
, verify_addr
));
697 slot
= htab_find_slot (addr_hash
, &target_addr
, INSERT
);
700 *slot
= obstack_copy (&addr_obstack
, &target_addr
,
701 sizeof (target_addr
));
702 VEC_safe_push (CORE_ADDR
, todo
, target_addr
);
707 do_cleanups (old_chain
);
710 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
711 ENTRY_VALUES_DEBUG. */
714 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
716 CORE_ADDR addr
= call_site
->pc
;
717 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
719 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
720 (msym
.minsym
== NULL
? "???"
721 : SYMBOL_PRINT_NAME (msym
.minsym
)));
725 /* vec.h needs single word type name, typedef it. */
726 typedef struct call_site
*call_sitep
;
728 /* Define VEC (call_sitep) functions. */
729 DEF_VEC_P (call_sitep
);
731 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
732 only top callers and bottom callees which are present in both. GDBARCH is
733 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
734 no remaining possibilities to provide unambiguous non-trivial result.
735 RESULTP should point to NULL on the first (initialization) call. Caller is
736 responsible for xfree of any RESULTP data. */
739 chain_candidate (struct gdbarch
*gdbarch
, struct call_site_chain
**resultp
,
740 VEC (call_sitep
) *chain
)
742 struct call_site_chain
*result
= *resultp
;
743 long length
= VEC_length (call_sitep
, chain
);
744 int callers
, callees
, idx
;
748 /* Create the initial chain containing all the passed PCs. */
750 result
= xmalloc (sizeof (*result
) + sizeof (*result
->call_site
)
752 result
->length
= length
;
753 result
->callers
= result
->callees
= length
;
754 memcpy (result
->call_site
, VEC_address (call_sitep
, chain
),
755 sizeof (*result
->call_site
) * length
);
758 if (entry_values_debug
)
760 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
761 for (idx
= 0; idx
< length
; idx
++)
762 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
763 fputc_unfiltered ('\n', gdb_stdlog
);
769 if (entry_values_debug
)
771 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
772 for (idx
= 0; idx
< length
; idx
++)
773 tailcall_dump (gdbarch
, VEC_index (call_sitep
, chain
, idx
));
774 fputc_unfiltered ('\n', gdb_stdlog
);
777 /* Intersect callers. */
779 callers
= min (result
->callers
, length
);
780 for (idx
= 0; idx
< callers
; idx
++)
781 if (result
->call_site
[idx
] != VEC_index (call_sitep
, chain
, idx
))
783 result
->callers
= idx
;
787 /* Intersect callees. */
789 callees
= min (result
->callees
, length
);
790 for (idx
= 0; idx
< callees
; idx
++)
791 if (result
->call_site
[result
->length
- 1 - idx
]
792 != VEC_index (call_sitep
, chain
, length
- 1 - idx
))
794 result
->callees
= idx
;
798 if (entry_values_debug
)
800 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
801 for (idx
= 0; idx
< result
->callers
; idx
++)
802 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
803 fputs_unfiltered (" |", gdb_stdlog
);
804 for (idx
= 0; idx
< result
->callees
; idx
++)
805 tailcall_dump (gdbarch
, result
->call_site
[result
->length
806 - result
->callees
+ idx
]);
807 fputc_unfiltered ('\n', gdb_stdlog
);
810 if (result
->callers
== 0 && result
->callees
== 0)
812 /* There are no common callers or callees. It could be also a direct
813 call (which has length 0) with ambiguous possibility of an indirect
814 call - CALLERS == CALLEES == 0 is valid during the first allocation
815 but any subsequence processing of such entry means ambiguity. */
821 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
822 PC again. In such case there must be two different code paths to reach
823 it, therefore some of the former determined intermediate PCs must differ
824 and the unambiguous chain gets shortened. */
825 gdb_assert (result
->callers
+ result
->callees
< result
->length
);
828 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
829 assumed frames between them use GDBARCH. Use depth first search so we can
830 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
831 would have needless GDB stack overhead. Caller is responsible for xfree of
832 the returned result. Any unreliability results in thrown
833 NO_ENTRY_VALUE_ERROR. */
835 static struct call_site_chain
*
836 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
839 CORE_ADDR save_callee_pc
= callee_pc
;
840 struct obstack addr_obstack
;
841 struct cleanup
*back_to_retval
, *back_to_workdata
;
842 struct call_site_chain
*retval
= NULL
;
843 struct call_site
*call_site
;
845 /* Mark CALL_SITEs so we do not visit the same ones twice. */
848 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
849 call_site nor any possible call_site at CALLEE_PC's function is there.
850 Any CALL_SITE in CHAIN will be iterated to its siblings - via
851 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
852 VEC (call_sitep
) *chain
= NULL
;
854 /* We are not interested in the specific PC inside the callee function. */
855 callee_pc
= get_pc_function_start (callee_pc
);
857 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
858 paddress (gdbarch
, save_callee_pc
));
860 back_to_retval
= make_cleanup (free_current_contents
, &retval
);
862 obstack_init (&addr_obstack
);
863 back_to_workdata
= make_cleanup_obstack_free (&addr_obstack
);
864 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
865 &addr_obstack
, hashtab_obstack_allocate
,
867 make_cleanup_htab_delete (addr_hash
);
869 make_cleanup (VEC_cleanup (call_sitep
), &chain
);
871 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
872 at the target's function. All the possible tail call sites in the
873 target's function will get iterated as already pushed into CHAIN via their
875 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
879 CORE_ADDR target_func_addr
;
880 struct call_site
*target_call_site
;
882 /* CALLER_FRAME with registers is not available for tail-call jumped
884 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
886 if (target_func_addr
== callee_pc
)
888 chain_candidate (gdbarch
, &retval
, chain
);
892 /* There is no way to reach CALLEE_PC again as we would prevent
893 entering it twice as being already marked in ADDR_HASH. */
894 target_call_site
= NULL
;
898 struct symbol
*target_func
;
900 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
901 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
906 /* Attempt to visit TARGET_CALL_SITE. */
908 if (target_call_site
)
912 slot
= htab_find_slot (addr_hash
, &target_call_site
->pc
, INSERT
);
915 /* Successfully entered TARGET_CALL_SITE. */
917 *slot
= &target_call_site
->pc
;
918 VEC_safe_push (call_sitep
, chain
, target_call_site
);
923 /* Backtrack (without revisiting the originating call_site). Try the
924 callers's sibling; if there isn't any try the callers's callers's
927 target_call_site
= NULL
;
928 while (!VEC_empty (call_sitep
, chain
))
930 call_site
= VEC_pop (call_sitep
, chain
);
932 gdb_assert (htab_find_slot (addr_hash
, &call_site
->pc
,
934 htab_remove_elt (addr_hash
, &call_site
->pc
);
936 target_call_site
= call_site
->tail_call_next
;
937 if (target_call_site
)
941 while (target_call_site
);
943 if (VEC_empty (call_sitep
, chain
))
946 call_site
= VEC_last (call_sitep
, chain
);
951 struct bound_minimal_symbol msym_caller
, msym_callee
;
953 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
954 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
955 throw_error (NO_ENTRY_VALUE_ERROR
,
956 _("There are no unambiguously determinable intermediate "
957 "callers or callees between caller function \"%s\" at %s "
958 "and callee function \"%s\" at %s"),
959 (msym_caller
.minsym
== NULL
960 ? "???" : SYMBOL_PRINT_NAME (msym_caller
.minsym
)),
961 paddress (gdbarch
, caller_pc
),
962 (msym_callee
.minsym
== NULL
963 ? "???" : SYMBOL_PRINT_NAME (msym_callee
.minsym
)),
964 paddress (gdbarch
, callee_pc
));
967 do_cleanups (back_to_workdata
);
968 discard_cleanups (back_to_retval
);
972 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
973 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
974 constructed return NULL. Caller is responsible for xfree of the returned
977 struct call_site_chain
*
978 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
981 volatile struct gdb_exception e
;
982 struct call_site_chain
*retval
= NULL
;
984 TRY_CATCH (e
, RETURN_MASK_ERROR
)
986 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
990 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
992 if (entry_values_debug
)
993 exception_print (gdb_stdout
, e
);
1003 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1006 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1007 enum call_site_parameter_kind kind
,
1008 union call_site_parameter_u kind_u
)
1010 if (kind
== parameter
->kind
)
1013 case CALL_SITE_PARAMETER_DWARF_REG
:
1014 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1015 case CALL_SITE_PARAMETER_FB_OFFSET
:
1016 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1017 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1018 return kind_u
.param_offset
.cu_off
== parameter
->u
.param_offset
.cu_off
;
1023 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1024 FRAME is for callee.
1026 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1029 static struct call_site_parameter
*
1030 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1031 enum call_site_parameter_kind kind
,
1032 union call_site_parameter_u kind_u
,
1033 struct dwarf2_per_cu_data
**per_cu_return
)
1035 CORE_ADDR func_addr
, caller_pc
;
1036 struct gdbarch
*gdbarch
;
1037 struct frame_info
*caller_frame
;
1038 struct call_site
*call_site
;
1040 /* Initialize it just to avoid a GCC false warning. */
1041 struct call_site_parameter
*parameter
= NULL
;
1042 CORE_ADDR target_addr
;
1044 while (get_frame_type (frame
) == INLINE_FRAME
)
1046 frame
= get_prev_frame (frame
);
1047 gdb_assert (frame
!= NULL
);
1050 func_addr
= get_frame_func (frame
);
1051 gdbarch
= get_frame_arch (frame
);
1052 caller_frame
= get_prev_frame (frame
);
1053 if (gdbarch
!= frame_unwind_arch (frame
))
1055 struct bound_minimal_symbol msym
1056 = lookup_minimal_symbol_by_pc (func_addr
);
1057 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1059 throw_error (NO_ENTRY_VALUE_ERROR
,
1060 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1061 "(of %s (%s)) does not match caller gdbarch %s"),
1062 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1063 paddress (gdbarch
, func_addr
),
1064 (msym
.minsym
== NULL
? "???"
1065 : SYMBOL_PRINT_NAME (msym
.minsym
)),
1066 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1069 if (caller_frame
== NULL
)
1071 struct bound_minimal_symbol msym
1072 = lookup_minimal_symbol_by_pc (func_addr
);
1074 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_GNU_entry_value resolving "
1075 "requires caller of %s (%s)"),
1076 paddress (gdbarch
, func_addr
),
1077 (msym
.minsym
== NULL
? "???"
1078 : SYMBOL_PRINT_NAME (msym
.minsym
)));
1080 caller_pc
= get_frame_pc (caller_frame
);
1081 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1083 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1084 if (target_addr
!= func_addr
)
1086 struct minimal_symbol
*target_msym
, *func_msym
;
1088 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1089 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1090 throw_error (NO_ENTRY_VALUE_ERROR
,
1091 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1092 "but the called frame is for %s at %s"),
1093 (target_msym
== NULL
? "???"
1094 : SYMBOL_PRINT_NAME (target_msym
)),
1095 paddress (gdbarch
, target_addr
),
1096 func_msym
== NULL
? "???" : SYMBOL_PRINT_NAME (func_msym
),
1097 paddress (gdbarch
, func_addr
));
1100 /* No entry value based parameters would be reliable if this function can
1101 call itself via tail calls. */
1102 func_verify_no_selftailcall (gdbarch
, func_addr
);
1104 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1106 parameter
= &call_site
->parameter
[iparams
];
1107 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1110 if (iparams
== call_site
->parameter_count
)
1112 struct minimal_symbol
*msym
1113 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1115 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1116 determine its value. */
1117 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1118 "at DW_TAG_GNU_call_site %s at %s"),
1119 paddress (gdbarch
, caller_pc
),
1120 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
1123 *per_cu_return
= call_site
->per_cu
;
1127 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1128 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1129 DW_AT_GNU_call_site_data_value (dereferenced) block.
1131 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1134 Function always returns non-NULL, non-optimized out value. It throws
1135 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1137 static struct value
*
1138 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1139 CORE_ADDR deref_size
, struct type
*type
,
1140 struct frame_info
*caller_frame
,
1141 struct dwarf2_per_cu_data
*per_cu
)
1143 const gdb_byte
*data_src
;
1147 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1148 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1150 /* DEREF_SIZE size is not verified here. */
1151 if (data_src
== NULL
)
1152 throw_error (NO_ENTRY_VALUE_ERROR
,
1153 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1155 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1156 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1158 data
= alloca (size
+ 1);
1159 memcpy (data
, data_src
, size
);
1160 data
[size
] = DW_OP_stack_value
;
1162 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1165 /* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
1166 Choose DEREF_SIZE value of that parameter. Search caller of the CTX's
1167 frame. CTX must be of dwarf_expr_ctx_funcs kind.
1169 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1170 can be more simple as it does not support cross-CU DWARF executions. */
1173 dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
1174 enum call_site_parameter_kind kind
,
1175 union call_site_parameter_u kind_u
,
1178 struct dwarf_expr_baton
*debaton
;
1179 struct frame_info
*frame
, *caller_frame
;
1180 struct dwarf2_per_cu_data
*caller_per_cu
;
1181 struct dwarf_expr_baton baton_local
;
1182 struct dwarf_expr_context saved_ctx
;
1183 struct call_site_parameter
*parameter
;
1184 const gdb_byte
*data_src
;
1187 gdb_assert (ctx
->funcs
== &dwarf_expr_ctx_funcs
);
1188 debaton
= ctx
->baton
;
1189 frame
= debaton
->frame
;
1190 caller_frame
= get_prev_frame (frame
);
1192 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1194 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1195 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1197 /* DEREF_SIZE size is not verified here. */
1198 if (data_src
== NULL
)
1199 throw_error (NO_ENTRY_VALUE_ERROR
,
1200 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1202 baton_local
.frame
= caller_frame
;
1203 baton_local
.per_cu
= caller_per_cu
;
1205 saved_ctx
.gdbarch
= ctx
->gdbarch
;
1206 saved_ctx
.addr_size
= ctx
->addr_size
;
1207 saved_ctx
.offset
= ctx
->offset
;
1208 saved_ctx
.baton
= ctx
->baton
;
1209 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (baton_local
.per_cu
));
1210 ctx
->addr_size
= dwarf2_per_cu_addr_size (baton_local
.per_cu
);
1211 ctx
->offset
= dwarf2_per_cu_text_offset (baton_local
.per_cu
);
1212 ctx
->baton
= &baton_local
;
1214 dwarf_expr_eval (ctx
, data_src
, size
);
1216 ctx
->gdbarch
= saved_ctx
.gdbarch
;
1217 ctx
->addr_size
= saved_ctx
.addr_size
;
1218 ctx
->offset
= saved_ctx
.offset
;
1219 ctx
->baton
= saved_ctx
.baton
;
1222 /* Callback function for dwarf2_evaluate_loc_desc.
1223 Fetch the address indexed by DW_OP_GNU_addr_index. */
1226 dwarf_expr_get_addr_index (void *baton
, unsigned int index
)
1228 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
1230 return dwarf2_read_addr_index (debaton
->per_cu
, index
);
1233 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1234 the indirect method on it, that is use its stored target value, the sole
1235 purpose of entry_data_value_funcs.. */
1237 static struct value
*
1238 entry_data_value_coerce_ref (const struct value
*value
)
1240 struct type
*checked_type
= check_typedef (value_type (value
));
1241 struct value
*target_val
;
1243 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
)
1246 target_val
= value_computed_closure (value
);
1247 value_incref (target_val
);
1251 /* Implement copy_closure. */
1254 entry_data_value_copy_closure (const struct value
*v
)
1256 struct value
*target_val
= value_computed_closure (v
);
1258 value_incref (target_val
);
1262 /* Implement free_closure. */
1265 entry_data_value_free_closure (struct value
*v
)
1267 struct value
*target_val
= value_computed_closure (v
);
1269 value_free (target_val
);
1272 /* Vector for methods for an entry value reference where the referenced value
1273 is stored in the caller. On the first dereference use
1274 DW_AT_GNU_call_site_data_value in the caller. */
1276 static const struct lval_funcs entry_data_value_funcs
=
1280 NULL
, /* check_validity */
1281 NULL
, /* check_any_valid */
1282 NULL
, /* indirect */
1283 entry_data_value_coerce_ref
,
1284 NULL
, /* check_synthetic_pointer */
1285 entry_data_value_copy_closure
,
1286 entry_data_value_free_closure
1289 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1290 are used to match DW_AT_location at the caller's
1291 DW_TAG_GNU_call_site_parameter.
1293 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1294 cannot resolve the parameter for any reason. */
1296 static struct value
*
1297 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1298 enum call_site_parameter_kind kind
,
1299 union call_site_parameter_u kind_u
)
1301 struct type
*checked_type
= check_typedef (type
);
1302 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1303 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1304 struct value
*outer_val
, *target_val
, *val
;
1305 struct call_site_parameter
*parameter
;
1306 struct dwarf2_per_cu_data
*caller_per_cu
;
1309 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1312 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1316 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1317 used and it is not available do not fall back to OUTER_VAL - dereferencing
1318 TYPE_CODE_REF with non-entry data value would give current value - not the
1321 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
1322 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1325 target_val
= dwarf_entry_parameter_to_value (parameter
,
1326 TYPE_LENGTH (target_type
),
1327 target_type
, caller_frame
,
1330 /* value_as_address dereferences TYPE_CODE_REF. */
1331 addr
= extract_typed_address (value_contents (outer_val
), checked_type
);
1333 /* The target entry value has artificial address of the entry value
1335 VALUE_LVAL (target_val
) = lval_memory
;
1336 set_value_address (target_val
, addr
);
1338 release_value (target_val
);
1339 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1340 target_val
/* closure */);
1342 /* Copy the referencing pointer to the new computed value. */
1343 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1344 TYPE_LENGTH (checked_type
));
1345 set_value_lazy (val
, 0);
1350 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1351 SIZE are DWARF block used to match DW_AT_location at the caller's
1352 DW_TAG_GNU_call_site_parameter.
1354 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1355 cannot resolve the parameter for any reason. */
1357 static struct value
*
1358 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1359 const gdb_byte
*block
, size_t block_len
)
1361 union call_site_parameter_u kind_u
;
1363 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1364 if (kind_u
.dwarf_reg
!= -1)
1365 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1368 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1369 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1372 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1373 suppressed during normal operation. The expression can be arbitrary if
1374 there is no caller-callee entry value binding expected. */
1375 throw_error (NO_ENTRY_VALUE_ERROR
,
1376 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1377 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1380 struct piece_closure
1382 /* Reference count. */
1385 /* The CU from which this closure's expression came. */
1386 struct dwarf2_per_cu_data
*per_cu
;
1388 /* The number of pieces used to describe this variable. */
1391 /* The target address size, used only for DWARF_VALUE_STACK. */
1394 /* The pieces themselves. */
1395 struct dwarf_expr_piece
*pieces
;
1398 /* Allocate a closure for a value formed from separately-described
1401 static struct piece_closure
*
1402 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1403 int n_pieces
, struct dwarf_expr_piece
*pieces
,
1406 struct piece_closure
*c
= XZALLOC (struct piece_closure
);
1411 c
->n_pieces
= n_pieces
;
1412 c
->addr_size
= addr_size
;
1413 c
->pieces
= XCALLOC (n_pieces
, struct dwarf_expr_piece
);
1415 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
1416 for (i
= 0; i
< n_pieces
; ++i
)
1417 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1418 value_incref (c
->pieces
[i
].v
.value
);
1423 /* The lowest-level function to extract bits from a byte buffer.
1424 SOURCE is the buffer. It is updated if we read to the end of a
1426 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1427 updated to reflect the number of bits actually read.
1428 NBITS is the number of bits we want to read. It is updated to
1429 reflect the number of bits actually read. This function may read
1431 BITS_BIG_ENDIAN is taken directly from gdbarch.
1432 This function returns the extracted bits. */
1435 extract_bits_primitive (const gdb_byte
**source
,
1436 unsigned int *source_offset_bits
,
1437 int *nbits
, int bits_big_endian
)
1439 unsigned int avail
, mask
, datum
;
1441 gdb_assert (*source_offset_bits
< 8);
1443 avail
= 8 - *source_offset_bits
;
1447 mask
= (1 << avail
) - 1;
1449 if (bits_big_endian
)
1450 datum
>>= 8 - (*source_offset_bits
+ *nbits
);
1452 datum
>>= *source_offset_bits
;
1456 *source_offset_bits
+= avail
;
1457 if (*source_offset_bits
>= 8)
1459 *source_offset_bits
-= 8;
1466 /* Extract some bits from a source buffer and move forward in the
1469 SOURCE is the source buffer. It is updated as bytes are read.
1470 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1472 NBITS is the number of bits to read.
1473 BITS_BIG_ENDIAN is taken directly from gdbarch.
1475 This function returns the bits that were read. */
1478 extract_bits (const gdb_byte
**source
, unsigned int *source_offset_bits
,
1479 int nbits
, int bits_big_endian
)
1483 gdb_assert (nbits
> 0 && nbits
<= 8);
1485 datum
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1491 more
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1493 if (bits_big_endian
)
1503 /* Write some bits into a buffer and move forward in the buffer.
1505 DATUM is the bits to write. The low-order bits of DATUM are used.
1506 DEST is the destination buffer. It is updated as bytes are
1508 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1510 NBITS is the number of valid bits in DATUM.
1511 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1514 insert_bits (unsigned int datum
,
1515 gdb_byte
*dest
, unsigned int dest_offset_bits
,
1516 int nbits
, int bits_big_endian
)
1520 gdb_assert (dest_offset_bits
+ nbits
<= 8);
1522 mask
= (1 << nbits
) - 1;
1523 if (bits_big_endian
)
1525 datum
<<= 8 - (dest_offset_bits
+ nbits
);
1526 mask
<<= 8 - (dest_offset_bits
+ nbits
);
1530 datum
<<= dest_offset_bits
;
1531 mask
<<= dest_offset_bits
;
1534 gdb_assert ((datum
& ~mask
) == 0);
1536 *dest
= (*dest
& ~mask
) | datum
;
1539 /* Copy bits from a source to a destination.
1541 DEST is where the bits should be written.
1542 DEST_OFFSET_BITS is the bit offset into DEST.
1543 SOURCE is the source of bits.
1544 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1545 BIT_COUNT is the number of bits to copy.
1546 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1549 copy_bitwise (gdb_byte
*dest
, unsigned int dest_offset_bits
,
1550 const gdb_byte
*source
, unsigned int source_offset_bits
,
1551 unsigned int bit_count
,
1552 int bits_big_endian
)
1554 unsigned int dest_avail
;
1557 /* Reduce everything to byte-size pieces. */
1558 dest
+= dest_offset_bits
/ 8;
1559 dest_offset_bits
%= 8;
1560 source
+= source_offset_bits
/ 8;
1561 source_offset_bits
%= 8;
1563 dest_avail
= 8 - dest_offset_bits
% 8;
1565 /* See if we can fill the first destination byte. */
1566 if (dest_avail
< bit_count
)
1568 datum
= extract_bits (&source
, &source_offset_bits
, dest_avail
,
1570 insert_bits (datum
, dest
, dest_offset_bits
, dest_avail
, bits_big_endian
);
1572 dest_offset_bits
= 0;
1573 bit_count
-= dest_avail
;
1576 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1577 than 8 bits remaining. */
1578 gdb_assert (dest_offset_bits
% 8 == 0 || bit_count
< 8);
1579 for (; bit_count
>= 8; bit_count
-= 8)
1581 datum
= extract_bits (&source
, &source_offset_bits
, 8, bits_big_endian
);
1582 *dest
++ = (gdb_byte
) datum
;
1585 /* Finally, we may have a few leftover bits. */
1586 gdb_assert (bit_count
<= 8 - dest_offset_bits
% 8);
1589 datum
= extract_bits (&source
, &source_offset_bits
, bit_count
,
1591 insert_bits (datum
, dest
, dest_offset_bits
, bit_count
, bits_big_endian
);
1596 read_pieced_value (struct value
*v
)
1600 ULONGEST bits_to_skip
;
1602 struct piece_closure
*c
1603 = (struct piece_closure
*) value_computed_closure (v
);
1604 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (v
));
1606 size_t buffer_size
= 0;
1607 gdb_byte
*buffer
= NULL
;
1608 struct cleanup
*cleanup
;
1610 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1612 if (value_type (v
) != value_enclosing_type (v
))
1613 internal_error (__FILE__
, __LINE__
,
1614 _("Should not be able to create a lazy value with "
1615 "an enclosing type"));
1617 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1619 contents
= value_contents_raw (v
);
1620 bits_to_skip
= 8 * value_offset (v
);
1621 if (value_bitsize (v
))
1623 bits_to_skip
+= value_bitpos (v
);
1624 type_len
= value_bitsize (v
);
1627 type_len
= 8 * TYPE_LENGTH (value_type (v
));
1629 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1631 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1632 size_t this_size
, this_size_bits
;
1633 long dest_offset_bits
, source_offset_bits
, source_offset
;
1634 const gdb_byte
*intermediate_buffer
;
1636 /* Compute size, source, and destination offsets for copying, in
1638 this_size_bits
= p
->size
;
1639 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1641 bits_to_skip
-= this_size_bits
;
1644 if (this_size_bits
> type_len
- offset
)
1645 this_size_bits
= type_len
- offset
;
1646 if (bits_to_skip
> 0)
1648 dest_offset_bits
= 0;
1649 source_offset_bits
= bits_to_skip
;
1650 this_size_bits
-= bits_to_skip
;
1655 dest_offset_bits
= offset
;
1656 source_offset_bits
= 0;
1659 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1660 source_offset
= source_offset_bits
/ 8;
1661 if (buffer_size
< this_size
)
1663 buffer_size
= this_size
;
1664 buffer
= xrealloc (buffer
, buffer_size
);
1666 intermediate_buffer
= buffer
;
1668 /* Copy from the source to DEST_BUFFER. */
1669 switch (p
->location
)
1671 case DWARF_VALUE_REGISTER
:
1673 struct gdbarch
*arch
= get_frame_arch (frame
);
1674 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1675 int reg_offset
= source_offset
;
1677 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1678 && this_size
< register_size (arch
, gdb_regnum
))
1680 /* Big-endian, and we want less than full size. */
1681 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1682 /* We want the lower-order THIS_SIZE_BITS of the bytes
1683 we extract from the register. */
1684 source_offset_bits
+= 8 * this_size
- this_size_bits
;
1687 if (gdb_regnum
!= -1)
1691 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1695 /* Just so garbage doesn't ever shine through. */
1696 memset (buffer
, 0, this_size
);
1699 set_value_optimized_out (v
, 1);
1701 mark_value_bytes_unavailable (v
, offset
, this_size
);
1706 error (_("Unable to access DWARF register number %s"),
1707 paddress (arch
, p
->v
.regno
));
1712 case DWARF_VALUE_MEMORY
:
1713 read_value_memory (v
, offset
,
1714 p
->v
.mem
.in_stack_memory
,
1715 p
->v
.mem
.addr
+ source_offset
,
1719 case DWARF_VALUE_STACK
:
1721 size_t n
= this_size
;
1723 if (n
> c
->addr_size
- source_offset
)
1724 n
= (c
->addr_size
>= source_offset
1725 ? c
->addr_size
- source_offset
1733 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
1735 intermediate_buffer
= val_bytes
+ source_offset
;
1740 case DWARF_VALUE_LITERAL
:
1742 size_t n
= this_size
;
1744 if (n
> p
->v
.literal
.length
- source_offset
)
1745 n
= (p
->v
.literal
.length
>= source_offset
1746 ? p
->v
.literal
.length
- source_offset
1749 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
1753 /* These bits show up as zeros -- but do not cause the value
1754 to be considered optimized-out. */
1755 case DWARF_VALUE_IMPLICIT_POINTER
:
1758 case DWARF_VALUE_OPTIMIZED_OUT
:
1759 set_value_optimized_out (v
, 1);
1763 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1766 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
1767 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1768 copy_bitwise (contents
, dest_offset_bits
,
1769 intermediate_buffer
, source_offset_bits
% 8,
1770 this_size_bits
, bits_big_endian
);
1772 offset
+= this_size_bits
;
1775 do_cleanups (cleanup
);
1779 write_pieced_value (struct value
*to
, struct value
*from
)
1783 ULONGEST bits_to_skip
;
1784 const gdb_byte
*contents
;
1785 struct piece_closure
*c
1786 = (struct piece_closure
*) value_computed_closure (to
);
1787 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
1789 size_t buffer_size
= 0;
1790 gdb_byte
*buffer
= NULL
;
1791 struct cleanup
*cleanup
;
1793 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
1797 set_value_optimized_out (to
, 1);
1801 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1803 contents
= value_contents (from
);
1804 bits_to_skip
= 8 * value_offset (to
);
1805 if (value_bitsize (to
))
1807 bits_to_skip
+= value_bitpos (to
);
1808 type_len
= value_bitsize (to
);
1811 type_len
= 8 * TYPE_LENGTH (value_type (to
));
1813 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1815 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1816 size_t this_size_bits
, this_size
;
1817 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
1819 const gdb_byte
*source_buffer
;
1821 this_size_bits
= p
->size
;
1822 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1824 bits_to_skip
-= this_size_bits
;
1827 if (this_size_bits
> type_len
- offset
)
1828 this_size_bits
= type_len
- offset
;
1829 if (bits_to_skip
> 0)
1831 dest_offset_bits
= bits_to_skip
;
1832 source_offset_bits
= 0;
1833 this_size_bits
-= bits_to_skip
;
1838 dest_offset_bits
= 0;
1839 source_offset_bits
= offset
;
1842 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1843 source_offset
= source_offset_bits
/ 8;
1844 dest_offset
= dest_offset_bits
/ 8;
1845 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
1847 source_buffer
= contents
+ source_offset
;
1852 if (buffer_size
< this_size
)
1854 buffer_size
= this_size
;
1855 buffer
= xrealloc (buffer
, buffer_size
);
1857 source_buffer
= buffer
;
1861 switch (p
->location
)
1863 case DWARF_VALUE_REGISTER
:
1865 struct gdbarch
*arch
= get_frame_arch (frame
);
1866 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1867 int reg_offset
= dest_offset
;
1869 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1870 && this_size
<= register_size (arch
, gdb_regnum
))
1871 /* Big-endian, and we want less than full size. */
1872 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1874 if (gdb_regnum
!= -1)
1880 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1885 error (_("Can't do read-modify-write to "
1886 "update bitfield; containing word has been "
1889 throw_error (NOT_AVAILABLE_ERROR
,
1890 _("Can't do read-modify-write to update "
1891 "bitfield; containing word "
1894 copy_bitwise (buffer
, dest_offset_bits
,
1895 contents
, source_offset_bits
,
1900 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1901 this_size
, source_buffer
);
1905 error (_("Unable to write to DWARF register number %s"),
1906 paddress (arch
, p
->v
.regno
));
1910 case DWARF_VALUE_MEMORY
:
1913 /* Only the first and last bytes can possibly have any
1915 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
, 1);
1916 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
1917 buffer
+ this_size
- 1, 1);
1918 copy_bitwise (buffer
, dest_offset_bits
,
1919 contents
, source_offset_bits
,
1924 write_memory (p
->v
.mem
.addr
+ dest_offset
,
1925 source_buffer
, this_size
);
1928 set_value_optimized_out (to
, 1);
1931 offset
+= this_size_bits
;
1934 do_cleanups (cleanup
);
1937 /* A helper function that checks bit validity in a pieced value.
1938 CHECK_FOR indicates the kind of validity checking.
1939 DWARF_VALUE_MEMORY means to check whether any bit is valid.
1940 DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
1942 DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
1943 implicit pointer. */
1946 check_pieced_value_bits (const struct value
*value
, int bit_offset
,
1948 enum dwarf_value_location check_for
)
1950 struct piece_closure
*c
1951 = (struct piece_closure
*) value_computed_closure (value
);
1953 int validity
= (check_for
== DWARF_VALUE_MEMORY
1954 || check_for
== DWARF_VALUE_IMPLICIT_POINTER
);
1956 bit_offset
+= 8 * value_offset (value
);
1957 if (value_bitsize (value
))
1958 bit_offset
+= value_bitpos (value
);
1960 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
1962 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1963 size_t this_size_bits
= p
->size
;
1967 if (bit_offset
>= this_size_bits
)
1969 bit_offset
-= this_size_bits
;
1973 bit_length
-= this_size_bits
- bit_offset
;
1977 bit_length
-= this_size_bits
;
1979 if (check_for
== DWARF_VALUE_IMPLICIT_POINTER
)
1981 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1984 else if (p
->location
== DWARF_VALUE_OPTIMIZED_OUT
1985 || p
->location
== DWARF_VALUE_IMPLICIT_POINTER
)
2001 check_pieced_value_validity (const struct value
*value
, int bit_offset
,
2004 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
2005 DWARF_VALUE_MEMORY
);
2009 check_pieced_value_invalid (const struct value
*value
)
2011 return check_pieced_value_bits (value
, 0,
2012 8 * TYPE_LENGTH (value_type (value
)),
2013 DWARF_VALUE_OPTIMIZED_OUT
);
2016 /* An implementation of an lval_funcs method to see whether a value is
2017 a synthetic pointer. */
2020 check_pieced_synthetic_pointer (const struct value
*value
, int bit_offset
,
2023 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
2024 DWARF_VALUE_IMPLICIT_POINTER
);
2027 /* A wrapper function for get_frame_address_in_block. */
2030 get_frame_address_in_block_wrapper (void *baton
)
2032 return get_frame_address_in_block (baton
);
2035 /* An implementation of an lval_funcs method to indirect through a
2036 pointer. This handles the synthetic pointer case when needed. */
2038 static struct value
*
2039 indirect_pieced_value (struct value
*value
)
2041 struct piece_closure
*c
2042 = (struct piece_closure
*) value_computed_closure (value
);
2044 struct frame_info
*frame
;
2045 struct dwarf2_locexpr_baton baton
;
2046 int i
, bit_offset
, bit_length
;
2047 struct dwarf_expr_piece
*piece
= NULL
;
2048 LONGEST byte_offset
;
2050 type
= check_typedef (value_type (value
));
2051 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
2054 bit_length
= 8 * TYPE_LENGTH (type
);
2055 bit_offset
= 8 * value_offset (value
);
2056 if (value_bitsize (value
))
2057 bit_offset
+= value_bitpos (value
);
2059 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2061 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2062 size_t this_size_bits
= p
->size
;
2066 if (bit_offset
>= this_size_bits
)
2068 bit_offset
-= this_size_bits
;
2072 bit_length
-= this_size_bits
- bit_offset
;
2076 bit_length
-= this_size_bits
;
2078 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2081 if (bit_length
!= 0)
2082 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2088 frame
= get_selected_frame (_("No frame selected."));
2090 /* This is an offset requested by GDB, such as value subcripts. */
2091 byte_offset
= value_as_address (value
);
2095 = dwarf2_fetch_die_loc_sect_off (piece
->v
.ptr
.die
, c
->per_cu
,
2096 get_frame_address_in_block_wrapper
,
2099 if (baton
.data
!= NULL
)
2100 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
2101 baton
.data
, baton
.size
, baton
.per_cu
,
2102 piece
->v
.ptr
.offset
+ byte_offset
);
2105 struct obstack temp_obstack
;
2106 struct cleanup
*cleanup
;
2107 const gdb_byte
*bytes
;
2109 struct value
*result
;
2111 obstack_init (&temp_obstack
);
2112 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2114 bytes
= dwarf2_fetch_constant_bytes (piece
->v
.ptr
.die
, c
->per_cu
,
2115 &temp_obstack
, &len
);
2117 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
2121 || byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > len
)
2122 invalid_synthetic_pointer ();
2123 bytes
+= byte_offset
;
2124 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
2127 do_cleanups (cleanup
);
2133 copy_pieced_value_closure (const struct value
*v
)
2135 struct piece_closure
*c
2136 = (struct piece_closure
*) value_computed_closure (v
);
2143 free_pieced_value_closure (struct value
*v
)
2145 struct piece_closure
*c
2146 = (struct piece_closure
*) value_computed_closure (v
);
2153 for (i
= 0; i
< c
->n_pieces
; ++i
)
2154 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
2155 value_free (c
->pieces
[i
].v
.value
);
2162 /* Functions for accessing a variable described by DW_OP_piece. */
2163 static const struct lval_funcs pieced_value_funcs
= {
2166 check_pieced_value_validity
,
2167 check_pieced_value_invalid
,
2168 indirect_pieced_value
,
2169 NULL
, /* coerce_ref */
2170 check_pieced_synthetic_pointer
,
2171 copy_pieced_value_closure
,
2172 free_pieced_value_closure
2175 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2177 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
=
2179 dwarf_expr_read_reg
,
2180 dwarf_expr_read_mem
,
2181 dwarf_expr_frame_base
,
2182 dwarf_expr_frame_cfa
,
2183 dwarf_expr_frame_pc
,
2184 dwarf_expr_tls_address
,
2185 dwarf_expr_dwarf_call
,
2186 dwarf_expr_get_base_type
,
2187 dwarf_expr_push_dwarf_reg_entry_value
,
2188 dwarf_expr_get_addr_index
2191 /* Evaluate a location description, starting at DATA and with length
2192 SIZE, to find the current location of variable of TYPE in the
2193 context of FRAME. BYTE_OFFSET is applied after the contents are
2196 static struct value
*
2197 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2198 const gdb_byte
*data
, size_t size
,
2199 struct dwarf2_per_cu_data
*per_cu
,
2200 LONGEST byte_offset
)
2202 struct value
*retval
;
2203 struct dwarf_expr_baton baton
;
2204 struct dwarf_expr_context
*ctx
;
2205 struct cleanup
*old_chain
, *value_chain
;
2206 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2207 volatile struct gdb_exception ex
;
2209 if (byte_offset
< 0)
2210 invalid_synthetic_pointer ();
2213 return allocate_optimized_out_value (type
);
2215 baton
.frame
= frame
;
2216 baton
.per_cu
= per_cu
;
2218 ctx
= new_dwarf_expr_context ();
2219 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2220 value_chain
= make_cleanup_value_free_to_mark (value_mark ());
2222 ctx
->gdbarch
= get_objfile_arch (objfile
);
2223 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2224 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2225 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2226 ctx
->baton
= &baton
;
2227 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2229 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2231 dwarf_expr_eval (ctx
, data
, size
);
2235 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2237 do_cleanups (old_chain
);
2238 retval
= allocate_value (type
);
2239 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
2242 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2244 if (entry_values_debug
)
2245 exception_print (gdb_stdout
, ex
);
2246 do_cleanups (old_chain
);
2247 return allocate_optimized_out_value (type
);
2250 throw_exception (ex
);
2253 if (ctx
->num_pieces
> 0)
2255 struct piece_closure
*c
;
2256 struct frame_id frame_id
= get_frame_id (frame
);
2257 ULONGEST bit_size
= 0;
2260 for (i
= 0; i
< ctx
->num_pieces
; ++i
)
2261 bit_size
+= ctx
->pieces
[i
].size
;
2262 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
2263 invalid_synthetic_pointer ();
2265 c
= allocate_piece_closure (per_cu
, ctx
->num_pieces
, ctx
->pieces
,
2267 /* We must clean up the value chain after creating the piece
2268 closure but before allocating the result. */
2269 do_cleanups (value_chain
);
2270 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
2271 VALUE_FRAME_ID (retval
) = frame_id
;
2272 set_value_offset (retval
, byte_offset
);
2276 switch (ctx
->location
)
2278 case DWARF_VALUE_REGISTER
:
2280 struct gdbarch
*arch
= get_frame_arch (frame
);
2281 ULONGEST dwarf_regnum
= value_as_long (dwarf_expr_fetch (ctx
, 0));
2282 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
2284 if (byte_offset
!= 0)
2285 error (_("cannot use offset on synthetic pointer to register"));
2286 do_cleanups (value_chain
);
2287 if (gdb_regnum
!= -1)
2288 retval
= value_from_register (type
, gdb_regnum
, frame
);
2290 error (_("Unable to access DWARF register number %s"),
2291 paddress (arch
, dwarf_regnum
));
2295 case DWARF_VALUE_MEMORY
:
2297 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
2298 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
2300 do_cleanups (value_chain
);
2301 retval
= allocate_value_lazy (type
);
2302 VALUE_LVAL (retval
) = lval_memory
;
2303 if (in_stack_memory
)
2304 set_value_stack (retval
, 1);
2305 set_value_address (retval
, address
+ byte_offset
);
2309 case DWARF_VALUE_STACK
:
2311 struct value
*value
= dwarf_expr_fetch (ctx
, 0);
2313 const gdb_byte
*val_bytes
;
2314 size_t n
= TYPE_LENGTH (value_type (value
));
2316 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2317 invalid_synthetic_pointer ();
2319 val_bytes
= value_contents_all (value
);
2320 val_bytes
+= byte_offset
;
2323 /* Preserve VALUE because we are going to free values back
2324 to the mark, but we still need the value contents
2326 value_incref (value
);
2327 do_cleanups (value_chain
);
2328 make_cleanup_value_free (value
);
2330 retval
= allocate_value (type
);
2331 contents
= value_contents_raw (retval
);
2332 if (n
> TYPE_LENGTH (type
))
2334 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2336 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2337 val_bytes
+= n
- TYPE_LENGTH (type
);
2338 n
= TYPE_LENGTH (type
);
2340 memcpy (contents
, val_bytes
, n
);
2344 case DWARF_VALUE_LITERAL
:
2347 const bfd_byte
*ldata
;
2348 size_t n
= ctx
->len
;
2350 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2351 invalid_synthetic_pointer ();
2353 do_cleanups (value_chain
);
2354 retval
= allocate_value (type
);
2355 contents
= value_contents_raw (retval
);
2357 ldata
= ctx
->data
+ byte_offset
;
2360 if (n
> TYPE_LENGTH (type
))
2362 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2364 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2365 ldata
+= n
- TYPE_LENGTH (type
);
2366 n
= TYPE_LENGTH (type
);
2368 memcpy (contents
, ldata
, n
);
2372 case DWARF_VALUE_OPTIMIZED_OUT
:
2373 do_cleanups (value_chain
);
2374 retval
= allocate_optimized_out_value (type
);
2377 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2378 operation by execute_stack_op. */
2379 case DWARF_VALUE_IMPLICIT_POINTER
:
2380 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2381 it can only be encountered when making a piece. */
2383 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2387 set_value_initialized (retval
, ctx
->initialized
);
2389 do_cleanups (old_chain
);
2394 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2395 passes 0 as the byte_offset. */
2398 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2399 const gdb_byte
*data
, size_t size
,
2400 struct dwarf2_per_cu_data
*per_cu
)
2402 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
2406 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2408 struct needs_frame_baton
2411 struct dwarf2_per_cu_data
*per_cu
;
2414 /* Reads from registers do require a frame. */
2416 needs_frame_read_reg (void *baton
, int regnum
)
2418 struct needs_frame_baton
*nf_baton
= baton
;
2420 nf_baton
->needs_frame
= 1;
2424 /* Reads from memory do not require a frame. */
2426 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
2428 memset (buf
, 0, len
);
2431 /* Frame-relative accesses do require a frame. */
2433 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
2435 static gdb_byte lit0
= DW_OP_lit0
;
2436 struct needs_frame_baton
*nf_baton
= baton
;
2441 nf_baton
->needs_frame
= 1;
2444 /* CFA accesses require a frame. */
2447 needs_frame_frame_cfa (void *baton
)
2449 struct needs_frame_baton
*nf_baton
= baton
;
2451 nf_baton
->needs_frame
= 1;
2455 /* Thread-local accesses do require a frame. */
2457 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
2459 struct needs_frame_baton
*nf_baton
= baton
;
2461 nf_baton
->needs_frame
= 1;
2465 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2468 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
2470 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2472 per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
,
2473 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
2476 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2479 needs_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
2480 enum call_site_parameter_kind kind
,
2481 union call_site_parameter_u kind_u
, int deref_size
)
2483 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2485 nf_baton
->needs_frame
= 1;
2487 /* The expression may require some stub values on DWARF stack. */
2488 dwarf_expr_push_address (ctx
, 0, 0);
2491 /* DW_OP_GNU_addr_index doesn't require a frame. */
2494 needs_get_addr_index (void *baton
, unsigned int index
)
2496 /* Nothing to do. */
2500 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2502 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs
=
2504 needs_frame_read_reg
,
2505 needs_frame_read_mem
,
2506 needs_frame_frame_base
,
2507 needs_frame_frame_cfa
,
2508 needs_frame_frame_cfa
, /* get_frame_pc */
2509 needs_frame_tls_address
,
2510 needs_frame_dwarf_call
,
2511 NULL
, /* get_base_type */
2512 needs_dwarf_reg_entry_value
,
2513 needs_get_addr_index
2516 /* Return non-zero iff the location expression at DATA (length SIZE)
2517 requires a frame to evaluate. */
2520 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, size_t size
,
2521 struct dwarf2_per_cu_data
*per_cu
)
2523 struct needs_frame_baton baton
;
2524 struct dwarf_expr_context
*ctx
;
2526 struct cleanup
*old_chain
;
2527 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2529 baton
.needs_frame
= 0;
2530 baton
.per_cu
= per_cu
;
2532 ctx
= new_dwarf_expr_context ();
2533 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2534 make_cleanup_value_free_to_mark (value_mark ());
2536 ctx
->gdbarch
= get_objfile_arch (objfile
);
2537 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2538 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2539 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2540 ctx
->baton
= &baton
;
2541 ctx
->funcs
= &needs_frame_ctx_funcs
;
2543 dwarf_expr_eval (ctx
, data
, size
);
2545 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
2547 if (ctx
->num_pieces
> 0)
2551 /* If the location has several pieces, and any of them are in
2552 registers, then we will need a frame to fetch them from. */
2553 for (i
= 0; i
< ctx
->num_pieces
; i
++)
2554 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2558 do_cleanups (old_chain
);
2560 return baton
.needs_frame
|| in_reg
;
2563 /* A helper function that throws an unimplemented error mentioning a
2564 given DWARF operator. */
2567 unimplemented (unsigned int op
)
2569 const char *name
= get_DW_OP_name (op
);
2572 error (_("DWARF operator %s cannot be translated to an agent expression"),
2575 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2576 "to an agent expression"),
2580 /* A helper function to convert a DWARF register to an arch register.
2581 ARCH is the architecture.
2582 DWARF_REG is the register.
2583 This will throw an exception if the DWARF register cannot be
2584 translated to an architecture register. */
2587 translate_register (struct gdbarch
*arch
, int dwarf_reg
)
2589 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2591 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
2595 /* A helper function that emits an access to memory. ARCH is the
2596 target architecture. EXPR is the expression which we are building.
2597 NBITS is the number of bits we want to read. This emits the
2598 opcodes needed to read the memory and then extract the desired
2602 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2604 ULONGEST nbytes
= (nbits
+ 7) / 8;
2606 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2609 ax_trace_quick (expr
, nbytes
);
2612 ax_simple (expr
, aop_ref8
);
2613 else if (nbits
<= 16)
2614 ax_simple (expr
, aop_ref16
);
2615 else if (nbits
<= 32)
2616 ax_simple (expr
, aop_ref32
);
2618 ax_simple (expr
, aop_ref64
);
2620 /* If we read exactly the number of bytes we wanted, we're done. */
2621 if (8 * nbytes
== nbits
)
2624 if (gdbarch_bits_big_endian (arch
))
2626 /* On a bits-big-endian machine, we want the high-order
2628 ax_const_l (expr
, 8 * nbytes
- nbits
);
2629 ax_simple (expr
, aop_rsh_unsigned
);
2633 /* On a bits-little-endian box, we want the low-order NBITS. */
2634 ax_zero_ext (expr
, nbits
);
2638 /* A helper function to return the frame's PC. */
2641 get_ax_pc (void *baton
)
2643 struct agent_expr
*expr
= baton
;
2648 /* Compile a DWARF location expression to an agent expression.
2650 EXPR is the agent expression we are building.
2651 LOC is the agent value we modify.
2652 ARCH is the architecture.
2653 ADDR_SIZE is the size of addresses, in bytes.
2654 OP_PTR is the start of the location expression.
2655 OP_END is one past the last byte of the location expression.
2657 This will throw an exception for various kinds of errors -- for
2658 example, if the expression cannot be compiled, or if the expression
2662 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2663 struct gdbarch
*arch
, unsigned int addr_size
,
2664 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
2665 struct dwarf2_per_cu_data
*per_cu
)
2667 struct cleanup
*cleanups
;
2669 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
2670 const gdb_byte
* const base
= op_ptr
;
2671 const gdb_byte
*previous_piece
= op_ptr
;
2672 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2673 ULONGEST bits_collected
= 0;
2674 unsigned int addr_size_bits
= 8 * addr_size
;
2675 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
2677 offsets
= xmalloc ((op_end
- op_ptr
) * sizeof (int));
2678 cleanups
= make_cleanup (xfree
, offsets
);
2680 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
2683 make_cleanup (VEC_cleanup (int), &dw_labels
);
2684 make_cleanup (VEC_cleanup (int), &patches
);
2686 /* By default we are making an address. */
2687 loc
->kind
= axs_lvalue_memory
;
2689 while (op_ptr
< op_end
)
2691 enum dwarf_location_atom op
= *op_ptr
;
2692 uint64_t uoffset
, reg
;
2696 offsets
[op_ptr
- base
] = expr
->len
;
2699 /* Our basic approach to code generation is to map DWARF
2700 operations directly to AX operations. However, there are
2703 First, DWARF works on address-sized units, but AX always uses
2704 LONGEST. For most operations we simply ignore this
2705 difference; instead we generate sign extensions as needed
2706 before division and comparison operations. It would be nice
2707 to omit the sign extensions, but there is no way to determine
2708 the size of the target's LONGEST. (This code uses the size
2709 of the host LONGEST in some cases -- that is a bug but it is
2712 Second, some DWARF operations cannot be translated to AX.
2713 For these we simply fail. See
2714 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2749 ax_const_l (expr
, op
- DW_OP_lit0
);
2753 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
2754 op_ptr
+= addr_size
;
2755 /* Some versions of GCC emit DW_OP_addr before
2756 DW_OP_GNU_push_tls_address. In this case the value is an
2757 index, not an address. We don't support things like
2758 branching between the address and the TLS op. */
2759 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
2760 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
2761 ax_const_l (expr
, uoffset
);
2765 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
2769 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
2773 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
2777 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
2781 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
2785 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
2789 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
2793 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
2797 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
2798 ax_const_l (expr
, uoffset
);
2801 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2802 ax_const_l (expr
, offset
);
2837 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2838 loc
->u
.reg
= translate_register (arch
, op
- DW_OP_reg0
);
2839 loc
->kind
= axs_lvalue_register
;
2843 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2844 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2845 loc
->u
.reg
= translate_register (arch
, reg
);
2846 loc
->kind
= axs_lvalue_register
;
2849 case DW_OP_implicit_value
:
2853 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
2854 if (op_ptr
+ len
> op_end
)
2855 error (_("DW_OP_implicit_value: too few bytes available."));
2856 if (len
> sizeof (ULONGEST
))
2857 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
2860 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
2863 dwarf_expr_require_composition (op_ptr
, op_end
,
2864 "DW_OP_implicit_value");
2866 loc
->kind
= axs_rvalue
;
2870 case DW_OP_stack_value
:
2871 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
2872 loc
->kind
= axs_rvalue
;
2907 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2908 i
= translate_register (arch
, op
- DW_OP_breg0
);
2912 ax_const_l (expr
, offset
);
2913 ax_simple (expr
, aop_add
);
2918 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2919 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2920 i
= translate_register (arch
, reg
);
2924 ax_const_l (expr
, offset
);
2925 ax_simple (expr
, aop_add
);
2931 const gdb_byte
*datastart
;
2934 struct symbol
*framefunc
;
2936 b
= block_for_pc (expr
->scope
);
2939 error (_("No block found for address"));
2941 framefunc
= block_linkage_function (b
);
2944 error (_("No function found for block"));
2946 dwarf_expr_frame_base_1 (framefunc
, expr
->scope
,
2947 &datastart
, &datalen
);
2949 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2950 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
2951 datastart
+ datalen
, per_cu
);
2952 if (loc
->kind
== axs_lvalue_register
)
2953 require_rvalue (expr
, loc
);
2957 ax_const_l (expr
, offset
);
2958 ax_simple (expr
, aop_add
);
2961 loc
->kind
= axs_lvalue_memory
;
2966 ax_simple (expr
, aop_dup
);
2970 ax_simple (expr
, aop_pop
);
2975 ax_pick (expr
, offset
);
2979 ax_simple (expr
, aop_swap
);
2987 ax_simple (expr
, aop_rot
);
2991 case DW_OP_deref_size
:
2995 if (op
== DW_OP_deref_size
)
3000 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3001 error (_("Unsupported size %d in %s"),
3002 size
, get_DW_OP_name (op
));
3003 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3008 /* Sign extend the operand. */
3009 ax_ext (expr
, addr_size_bits
);
3010 ax_simple (expr
, aop_dup
);
3011 ax_const_l (expr
, 0);
3012 ax_simple (expr
, aop_less_signed
);
3013 ax_simple (expr
, aop_log_not
);
3014 i
= ax_goto (expr
, aop_if_goto
);
3015 /* We have to emit 0 - X. */
3016 ax_const_l (expr
, 0);
3017 ax_simple (expr
, aop_swap
);
3018 ax_simple (expr
, aop_sub
);
3019 ax_label (expr
, i
, expr
->len
);
3023 /* No need to sign extend here. */
3024 ax_const_l (expr
, 0);
3025 ax_simple (expr
, aop_swap
);
3026 ax_simple (expr
, aop_sub
);
3030 /* Sign extend the operand. */
3031 ax_ext (expr
, addr_size_bits
);
3032 ax_simple (expr
, aop_bit_not
);
3035 case DW_OP_plus_uconst
:
3036 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3037 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3038 but we micro-optimize anyhow. */
3041 ax_const_l (expr
, reg
);
3042 ax_simple (expr
, aop_add
);
3047 ax_simple (expr
, aop_bit_and
);
3051 /* Sign extend the operands. */
3052 ax_ext (expr
, addr_size_bits
);
3053 ax_simple (expr
, aop_swap
);
3054 ax_ext (expr
, addr_size_bits
);
3055 ax_simple (expr
, aop_swap
);
3056 ax_simple (expr
, aop_div_signed
);
3060 ax_simple (expr
, aop_sub
);
3064 ax_simple (expr
, aop_rem_unsigned
);
3068 ax_simple (expr
, aop_mul
);
3072 ax_simple (expr
, aop_bit_or
);
3076 ax_simple (expr
, aop_add
);
3080 ax_simple (expr
, aop_lsh
);
3084 ax_simple (expr
, aop_rsh_unsigned
);
3088 ax_simple (expr
, aop_rsh_signed
);
3092 ax_simple (expr
, aop_bit_xor
);
3096 /* Sign extend the operands. */
3097 ax_ext (expr
, addr_size_bits
);
3098 ax_simple (expr
, aop_swap
);
3099 ax_ext (expr
, addr_size_bits
);
3100 /* Note no swap here: A <= B is !(B < A). */
3101 ax_simple (expr
, aop_less_signed
);
3102 ax_simple (expr
, aop_log_not
);
3106 /* Sign extend the operands. */
3107 ax_ext (expr
, addr_size_bits
);
3108 ax_simple (expr
, aop_swap
);
3109 ax_ext (expr
, addr_size_bits
);
3110 ax_simple (expr
, aop_swap
);
3111 /* A >= B is !(A < B). */
3112 ax_simple (expr
, aop_less_signed
);
3113 ax_simple (expr
, aop_log_not
);
3117 /* Sign extend the operands. */
3118 ax_ext (expr
, addr_size_bits
);
3119 ax_simple (expr
, aop_swap
);
3120 ax_ext (expr
, addr_size_bits
);
3121 /* No need for a second swap here. */
3122 ax_simple (expr
, aop_equal
);
3126 /* Sign extend the operands. */
3127 ax_ext (expr
, addr_size_bits
);
3128 ax_simple (expr
, aop_swap
);
3129 ax_ext (expr
, addr_size_bits
);
3130 ax_simple (expr
, aop_swap
);
3131 ax_simple (expr
, aop_less_signed
);
3135 /* Sign extend the operands. */
3136 ax_ext (expr
, addr_size_bits
);
3137 ax_simple (expr
, aop_swap
);
3138 ax_ext (expr
, addr_size_bits
);
3139 /* Note no swap here: A > B is B < A. */
3140 ax_simple (expr
, aop_less_signed
);
3144 /* Sign extend the operands. */
3145 ax_ext (expr
, addr_size_bits
);
3146 ax_simple (expr
, aop_swap
);
3147 ax_ext (expr
, addr_size_bits
);
3148 /* No need for a swap here. */
3149 ax_simple (expr
, aop_equal
);
3150 ax_simple (expr
, aop_log_not
);
3153 case DW_OP_call_frame_cfa
:
3154 dwarf2_compile_cfa_to_ax (expr
, loc
, arch
, expr
->scope
, per_cu
);
3155 loc
->kind
= axs_lvalue_memory
;
3158 case DW_OP_GNU_push_tls_address
:
3163 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3165 i
= ax_goto (expr
, aop_goto
);
3166 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3167 VEC_safe_push (int, patches
, i
);
3171 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3173 /* Zero extend the operand. */
3174 ax_zero_ext (expr
, addr_size_bits
);
3175 i
= ax_goto (expr
, aop_if_goto
);
3176 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3177 VEC_safe_push (int, patches
, i
);
3184 case DW_OP_bit_piece
:
3186 uint64_t size
, offset
;
3188 if (op_ptr
- 1 == previous_piece
)
3189 error (_("Cannot translate empty pieces to agent expressions"));
3190 previous_piece
= op_ptr
- 1;
3192 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3193 if (op
== DW_OP_piece
)
3199 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
3201 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3202 error (_("Expression pieces exceed word size"));
3204 /* Access the bits. */
3207 case axs_lvalue_register
:
3208 ax_reg (expr
, loc
->u
.reg
);
3211 case axs_lvalue_memory
:
3212 /* Offset the pointer, if needed. */
3215 ax_const_l (expr
, offset
/ 8);
3216 ax_simple (expr
, aop_add
);
3219 access_memory (arch
, expr
, size
);
3223 /* For a bits-big-endian target, shift up what we already
3224 have. For a bits-little-endian target, shift up the
3225 new data. Note that there is a potential bug here if
3226 the DWARF expression leaves multiple values on the
3228 if (bits_collected
> 0)
3230 if (bits_big_endian
)
3232 ax_simple (expr
, aop_swap
);
3233 ax_const_l (expr
, size
);
3234 ax_simple (expr
, aop_lsh
);
3235 /* We don't need a second swap here, because
3236 aop_bit_or is symmetric. */
3240 ax_const_l (expr
, size
);
3241 ax_simple (expr
, aop_lsh
);
3243 ax_simple (expr
, aop_bit_or
);
3246 bits_collected
+= size
;
3247 loc
->kind
= axs_rvalue
;
3251 case DW_OP_GNU_uninit
:
3257 struct dwarf2_locexpr_baton block
;
3258 int size
= (op
== DW_OP_call2
? 2 : 4);
3261 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3264 offset
.cu_off
= uoffset
;
3265 block
= dwarf2_fetch_die_loc_cu_off (offset
, per_cu
,
3268 /* DW_OP_call_ref is currently not supported. */
3269 gdb_assert (block
.per_cu
== per_cu
);
3271 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3272 block
.data
, block
.data
+ block
.size
,
3277 case DW_OP_call_ref
:
3285 /* Patch all the branches we emitted. */
3286 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
3288 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
3290 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3291 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
3294 do_cleanups (cleanups
);
3298 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3299 evaluator to calculate the location. */
3300 static struct value
*
3301 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3303 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3306 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3307 dlbaton
->size
, dlbaton
->per_cu
);
3312 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3313 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3316 static struct value
*
3317 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3319 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3321 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3325 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3327 locexpr_read_needs_frame (struct symbol
*symbol
)
3329 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3331 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
3335 /* Return true if DATA points to the end of a piece. END is one past
3336 the last byte in the expression. */
3339 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3341 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3344 /* Helper for locexpr_describe_location_piece that finds the name of a
3348 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3352 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
3353 return gdbarch_register_name (gdbarch
, regnum
);
3356 /* Nicely describe a single piece of a location, returning an updated
3357 position in the bytecode sequence. This function cannot recognize
3358 all locations; if a location is not recognized, it simply returns
3359 DATA. If there is an error during reading, e.g. we run off the end
3360 of the buffer, an error is thrown. */
3362 static const gdb_byte
*
3363 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3364 CORE_ADDR addr
, struct objfile
*objfile
,
3365 struct dwarf2_per_cu_data
*per_cu
,
3366 const gdb_byte
*data
, const gdb_byte
*end
,
3367 unsigned int addr_size
)
3369 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3372 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3374 fprintf_filtered (stream
, _("a variable in $%s"),
3375 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3378 else if (data
[0] == DW_OP_regx
)
3382 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3383 fprintf_filtered (stream
, _("a variable in $%s"),
3384 locexpr_regname (gdbarch
, reg
));
3386 else if (data
[0] == DW_OP_fbreg
)
3389 struct symbol
*framefunc
;
3391 int64_t frame_offset
;
3392 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3394 int64_t base_offset
= 0;
3396 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3397 if (!piece_end_p (new_data
, end
))
3401 b
= block_for_pc (addr
);
3404 error (_("No block found for address for symbol \"%s\"."),
3405 SYMBOL_PRINT_NAME (symbol
));
3407 framefunc
= block_linkage_function (b
);
3410 error (_("No function found for block for symbol \"%s\"."),
3411 SYMBOL_PRINT_NAME (symbol
));
3413 dwarf_expr_frame_base_1 (framefunc
, addr
, &base_data
, &base_size
);
3415 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3417 const gdb_byte
*buf_end
;
3419 frame_reg
= base_data
[0] - DW_OP_breg0
;
3420 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3422 if (buf_end
!= base_data
+ base_size
)
3423 error (_("Unexpected opcode after "
3424 "DW_OP_breg%u for symbol \"%s\"."),
3425 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3427 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3429 /* The frame base is just the register, with no offset. */
3430 frame_reg
= base_data
[0] - DW_OP_reg0
;
3435 /* We don't know what to do with the frame base expression,
3436 so we can't trace this variable; give up. */
3440 fprintf_filtered (stream
,
3441 _("a variable at frame base reg $%s offset %s+%s"),
3442 locexpr_regname (gdbarch
, frame_reg
),
3443 plongest (base_offset
), plongest (frame_offset
));
3445 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3446 && piece_end_p (data
, end
))
3450 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3452 fprintf_filtered (stream
,
3453 _("a variable at offset %s from base reg $%s"),
3455 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3458 /* The location expression for a TLS variable looks like this (on a
3461 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3462 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3464 0x3 is the encoding for DW_OP_addr, which has an operand as long
3465 as the size of an address on the target machine (here is 8
3466 bytes). Note that more recent version of GCC emit DW_OP_const4u
3467 or DW_OP_const8u, depending on address size, rather than
3468 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3469 The operand represents the offset at which the variable is within
3470 the thread local storage. */
3472 else if (data
+ 1 + addr_size
< end
3473 && (data
[0] == DW_OP_addr
3474 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3475 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3476 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3477 && piece_end_p (data
+ 2 + addr_size
, end
))
3480 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3481 gdbarch_byte_order (gdbarch
));
3483 fprintf_filtered (stream
,
3484 _("a thread-local variable at offset 0x%s "
3485 "in the thread-local storage for `%s'"),
3486 phex_nz (offset
, addr_size
), objfile
->name
);
3488 data
+= 1 + addr_size
+ 1;
3491 /* With -gsplit-dwarf a TLS variable can also look like this:
3492 DW_AT_location : 3 byte block: fc 4 e0
3493 (DW_OP_GNU_const_index: 4;
3494 DW_OP_GNU_push_tls_address) */
3495 else if (data
+ 3 <= end
3496 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3497 && data
[0] == DW_OP_GNU_const_index
3499 && data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3500 && piece_end_p (data
+ 2 + leb128_size
, end
))
3504 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3505 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3506 fprintf_filtered (stream
,
3507 _("a thread-local variable at offset 0x%s "
3508 "in the thread-local storage for `%s'"),
3509 phex_nz (offset
, addr_size
), objfile
->name
);
3513 else if (data
[0] >= DW_OP_lit0
3514 && data
[0] <= DW_OP_lit31
3516 && data
[1] == DW_OP_stack_value
)
3518 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3525 /* Disassemble an expression, stopping at the end of a piece or at the
3526 end of the expression. Returns a pointer to the next unread byte
3527 in the input expression. If ALL is nonzero, then this function
3528 will keep going until it reaches the end of the expression.
3529 If there is an error during reading, e.g. we run off the end
3530 of the buffer, an error is thrown. */
3532 static const gdb_byte
*
3533 disassemble_dwarf_expression (struct ui_file
*stream
,
3534 struct gdbarch
*arch
, unsigned int addr_size
,
3535 int offset_size
, const gdb_byte
*start
,
3536 const gdb_byte
*data
, const gdb_byte
*end
,
3537 int indent
, int all
,
3538 struct dwarf2_per_cu_data
*per_cu
)
3542 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3544 enum dwarf_location_atom op
= *data
++;
3549 name
= get_DW_OP_name (op
);
3552 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3553 op
, (long) (data
- 1 - start
));
3554 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3555 (long) (data
- 1 - start
), name
);
3560 ul
= extract_unsigned_integer (data
, addr_size
,
3561 gdbarch_byte_order (arch
));
3563 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3567 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3569 fprintf_filtered (stream
, " %s", pulongest (ul
));
3572 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3574 fprintf_filtered (stream
, " %s", plongest (l
));
3577 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3579 fprintf_filtered (stream
, " %s", pulongest (ul
));
3582 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3584 fprintf_filtered (stream
, " %s", plongest (l
));
3587 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3589 fprintf_filtered (stream
, " %s", pulongest (ul
));
3592 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3594 fprintf_filtered (stream
, " %s", plongest (l
));
3597 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3599 fprintf_filtered (stream
, " %s", pulongest (ul
));
3602 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3604 fprintf_filtered (stream
, " %s", plongest (l
));
3607 data
= safe_read_uleb128 (data
, end
, &ul
);
3608 fprintf_filtered (stream
, " %s", pulongest (ul
));
3611 data
= safe_read_sleb128 (data
, end
, &l
);
3612 fprintf_filtered (stream
, " %s", plongest (l
));
3647 fprintf_filtered (stream
, " [$%s]",
3648 locexpr_regname (arch
, op
- DW_OP_reg0
));
3652 data
= safe_read_uleb128 (data
, end
, &ul
);
3653 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3654 locexpr_regname (arch
, (int) ul
));
3657 case DW_OP_implicit_value
:
3658 data
= safe_read_uleb128 (data
, end
, &ul
);
3660 fprintf_filtered (stream
, " %s", pulongest (ul
));
3695 data
= safe_read_sleb128 (data
, end
, &l
);
3696 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
3697 locexpr_regname (arch
, op
- DW_OP_breg0
));
3701 data
= safe_read_uleb128 (data
, end
, &ul
);
3702 data
= safe_read_sleb128 (data
, end
, &l
);
3703 fprintf_filtered (stream
, " register %s [$%s] offset %s",
3705 locexpr_regname (arch
, (int) ul
),
3710 data
= safe_read_sleb128 (data
, end
, &l
);
3711 fprintf_filtered (stream
, " %s", plongest (l
));
3714 case DW_OP_xderef_size
:
3715 case DW_OP_deref_size
:
3717 fprintf_filtered (stream
, " %d", *data
);
3721 case DW_OP_plus_uconst
:
3722 data
= safe_read_uleb128 (data
, end
, &ul
);
3723 fprintf_filtered (stream
, " %s", pulongest (ul
));
3727 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3729 fprintf_filtered (stream
, " to %ld",
3730 (long) (data
+ l
- start
));
3734 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3736 fprintf_filtered (stream
, " %ld",
3737 (long) (data
+ l
- start
));
3741 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3743 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
3747 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3749 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3752 case DW_OP_call_ref
:
3753 ul
= extract_unsigned_integer (data
, offset_size
,
3754 gdbarch_byte_order (arch
));
3755 data
+= offset_size
;
3756 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
3760 data
= safe_read_uleb128 (data
, end
, &ul
);
3761 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
3764 case DW_OP_bit_piece
:
3768 data
= safe_read_uleb128 (data
, end
, &ul
);
3769 data
= safe_read_uleb128 (data
, end
, &offset
);
3770 fprintf_filtered (stream
, " size %s offset %s (bits)",
3771 pulongest (ul
), pulongest (offset
));
3775 case DW_OP_GNU_implicit_pointer
:
3777 ul
= extract_unsigned_integer (data
, offset_size
,
3778 gdbarch_byte_order (arch
));
3779 data
+= offset_size
;
3781 data
= safe_read_sleb128 (data
, end
, &l
);
3783 fprintf_filtered (stream
, " DIE %s offset %s",
3784 phex_nz (ul
, offset_size
),
3789 case DW_OP_GNU_deref_type
:
3791 int addr_size
= *data
++;
3795 data
= safe_read_uleb128 (data
, end
, &ul
);
3797 type
= dwarf2_get_die_type (offset
, per_cu
);
3798 fprintf_filtered (stream
, "<");
3799 type_print (type
, "", stream
, -1);
3800 fprintf_filtered (stream
, " [0x%s]> %d", phex_nz (offset
.cu_off
, 0),
3805 case DW_OP_GNU_const_type
:
3810 data
= safe_read_uleb128 (data
, end
, &ul
);
3811 type_die
.cu_off
= ul
;
3812 type
= dwarf2_get_die_type (type_die
, per_cu
);
3813 fprintf_filtered (stream
, "<");
3814 type_print (type
, "", stream
, -1);
3815 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3819 case DW_OP_GNU_regval_type
:
3825 data
= safe_read_uleb128 (data
, end
, ®
);
3826 data
= safe_read_uleb128 (data
, end
, &ul
);
3827 type_die
.cu_off
= ul
;
3829 type
= dwarf2_get_die_type (type_die
, per_cu
);
3830 fprintf_filtered (stream
, "<");
3831 type_print (type
, "", stream
, -1);
3832 fprintf_filtered (stream
, " [0x%s]> [$%s]",
3833 phex_nz (type_die
.cu_off
, 0),
3834 locexpr_regname (arch
, reg
));
3838 case DW_OP_GNU_convert
:
3839 case DW_OP_GNU_reinterpret
:
3843 data
= safe_read_uleb128 (data
, end
, &ul
);
3844 type_die
.cu_off
= ul
;
3846 if (type_die
.cu_off
== 0)
3847 fprintf_filtered (stream
, "<0>");
3852 type
= dwarf2_get_die_type (type_die
, per_cu
);
3853 fprintf_filtered (stream
, "<");
3854 type_print (type
, "", stream
, -1);
3855 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3860 case DW_OP_GNU_entry_value
:
3861 data
= safe_read_uleb128 (data
, end
, &ul
);
3862 fputc_filtered ('\n', stream
);
3863 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
3864 start
, data
, data
+ ul
, indent
+ 2,
3869 case DW_OP_GNU_parameter_ref
:
3870 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3872 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3875 case DW_OP_GNU_addr_index
:
3876 data
= safe_read_uleb128 (data
, end
, &ul
);
3877 ul
= dwarf2_read_addr_index (per_cu
, ul
);
3878 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3880 case DW_OP_GNU_const_index
:
3881 data
= safe_read_uleb128 (data
, end
, &ul
);
3882 ul
= dwarf2_read_addr_index (per_cu
, ul
);
3883 fprintf_filtered (stream
, " %s", pulongest (ul
));
3887 fprintf_filtered (stream
, "\n");
3893 /* Describe a single location, which may in turn consist of multiple
3897 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
3898 struct ui_file
*stream
,
3899 const gdb_byte
*data
, size_t size
,
3900 struct objfile
*objfile
, unsigned int addr_size
,
3901 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
3903 const gdb_byte
*end
= data
+ size
;
3904 int first_piece
= 1, bad
= 0;
3908 const gdb_byte
*here
= data
;
3909 int disassemble
= 1;
3914 fprintf_filtered (stream
, _(", and "));
3916 if (!dwarf2_always_disassemble
)
3918 data
= locexpr_describe_location_piece (symbol
, stream
,
3919 addr
, objfile
, per_cu
,
3920 data
, end
, addr_size
);
3921 /* If we printed anything, or if we have an empty piece,
3922 then don't disassemble. */
3924 || data
[0] == DW_OP_piece
3925 || data
[0] == DW_OP_bit_piece
)
3930 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
3931 data
= disassemble_dwarf_expression (stream
,
3932 get_objfile_arch (objfile
),
3933 addr_size
, offset_size
, data
,
3935 dwarf2_always_disassemble
,
3941 int empty
= data
== here
;
3944 fprintf_filtered (stream
, " ");
3945 if (data
[0] == DW_OP_piece
)
3949 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
3952 fprintf_filtered (stream
, _("an empty %s-byte piece"),
3955 fprintf_filtered (stream
, _(" [%s-byte piece]"),
3958 else if (data
[0] == DW_OP_bit_piece
)
3960 uint64_t bits
, offset
;
3962 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
3963 data
= safe_read_uleb128 (data
, end
, &offset
);
3966 fprintf_filtered (stream
,
3967 _("an empty %s-bit piece"),
3970 fprintf_filtered (stream
,
3971 _(" [%s-bit piece, offset %s bits]"),
3972 pulongest (bits
), pulongest (offset
));
3982 if (bad
|| data
> end
)
3983 error (_("Corrupted DWARF2 expression for \"%s\"."),
3984 SYMBOL_PRINT_NAME (symbol
));
3987 /* Print a natural-language description of SYMBOL to STREAM. This
3988 version is for a symbol with a single location. */
3991 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
3992 struct ui_file
*stream
)
3994 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3995 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
3996 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
3997 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
3999 locexpr_describe_location_1 (symbol
, addr
, stream
,
4000 dlbaton
->data
, dlbaton
->size
,
4001 objfile
, addr_size
, offset_size
,
4005 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4006 any necessary bytecode in AX. */
4009 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4010 struct agent_expr
*ax
, struct axs_value
*value
)
4012 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4013 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4015 if (dlbaton
->size
== 0)
4016 value
->optimized_out
= 1;
4018 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
4019 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4023 /* The set of location functions used with the DWARF-2 expression
4025 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4026 locexpr_read_variable
,
4027 locexpr_read_variable_at_entry
,
4028 locexpr_read_needs_frame
,
4029 locexpr_describe_location
,
4030 0, /* location_has_loclist */
4031 locexpr_tracepoint_var_ref
4035 /* Wrapper functions for location lists. These generally find
4036 the appropriate location expression and call something above. */
4038 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4039 evaluator to calculate the location. */
4040 static struct value
*
4041 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4043 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4045 const gdb_byte
*data
;
4047 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4049 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4050 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4056 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4057 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4060 Function always returns non-NULL value, it may be marked optimized out if
4061 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4062 if it cannot resolve the parameter for any reason. */
4064 static struct value
*
4065 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4067 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4068 const gdb_byte
*data
;
4072 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4073 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4075 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4077 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4079 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4082 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
4084 loclist_read_needs_frame (struct symbol
*symbol
)
4086 /* If there's a location list, then assume we need to have a frame
4087 to choose the appropriate location expression. With tracking of
4088 global variables this is not necessarily true, but such tracking
4089 is disabled in GCC at the moment until we figure out how to
4095 /* Print a natural-language description of SYMBOL to STREAM. This
4096 version applies when there is a list of different locations, each
4097 with a specified address range. */
4100 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4101 struct ui_file
*stream
)
4103 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4104 const gdb_byte
*loc_ptr
, *buf_end
;
4105 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4106 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4107 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4108 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4109 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4110 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4111 /* Adjust base_address for relocatable objects. */
4112 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4113 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4116 loc_ptr
= dlbaton
->data
;
4117 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4119 fprintf_filtered (stream
, _("multi-location:\n"));
4121 /* Iterate through locations until we run out. */
4124 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4126 enum debug_loc_kind kind
;
4127 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4129 if (dlbaton
->from_dwo
)
4130 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4131 loc_ptr
, buf_end
, &new_ptr
,
4132 &low
, &high
, byte_order
);
4134 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4136 byte_order
, addr_size
,
4141 case DEBUG_LOC_END_OF_LIST
:
4144 case DEBUG_LOC_BASE_ADDRESS
:
4145 base_address
= high
+ base_offset
;
4146 fprintf_filtered (stream
, _(" Base address %s"),
4147 paddress (gdbarch
, base_address
));
4149 case DEBUG_LOC_START_END
:
4150 case DEBUG_LOC_START_LENGTH
:
4152 case DEBUG_LOC_BUFFER_OVERFLOW
:
4153 case DEBUG_LOC_INVALID_ENTRY
:
4154 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4155 SYMBOL_PRINT_NAME (symbol
));
4157 gdb_assert_not_reached ("bad debug_loc_kind");
4160 /* Otherwise, a location expression entry. */
4161 low
+= base_address
;
4162 high
+= base_address
;
4164 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4167 /* (It would improve readability to print only the minimum
4168 necessary digits of the second number of the range.) */
4169 fprintf_filtered (stream
, _(" Range %s-%s: "),
4170 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4172 /* Now describe this particular location. */
4173 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4174 objfile
, addr_size
, offset_size
,
4177 fprintf_filtered (stream
, "\n");
4183 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4184 any necessary bytecode in AX. */
4186 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4187 struct agent_expr
*ax
, struct axs_value
*value
)
4189 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4190 const gdb_byte
*data
;
4192 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4194 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4196 value
->optimized_out
= 1;
4198 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
4202 /* The set of location functions used with the DWARF-2 expression
4203 evaluator and location lists. */
4204 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4205 loclist_read_variable
,
4206 loclist_read_variable_at_entry
,
4207 loclist_read_needs_frame
,
4208 loclist_describe_location
,
4209 1, /* location_has_loclist */
4210 loclist_tracepoint_var_ref
4213 /* Provide a prototype to silence -Wmissing-prototypes. */
4214 extern initialize_file_ftype _initialize_dwarf2loc
;
4217 _initialize_dwarf2loc (void)
4219 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4220 &entry_values_debug
,
4221 _("Set entry values and tail call frames "
4223 _("Show entry values and tail call frames "
4225 _("When non-zero, the process of determining "
4226 "parameter values from function entry point "
4227 "and tail call frames will be printed."),
4229 show_entry_values_debug
,
4230 &setdebuglist
, &showdebuglist
);