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"
45 extern int dwarf2_always_disassemble
;
47 static void dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
48 const gdb_byte
**start
, size_t *length
);
50 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
;
52 static struct value
*dwarf2_evaluate_loc_desc_full (struct type
*type
,
53 struct frame_info
*frame
,
56 struct dwarf2_per_cu_data
*per_cu
,
59 /* Until these have formal names, we define these here.
60 ref: http://gcc.gnu.org/wiki/DebugFission
61 Each entry in .debug_loc.dwo begins with a byte that describes the entry,
62 and is then followed by data specific to that entry. */
66 /* Indicates the end of the list of entries. */
67 DEBUG_LOC_END_OF_LIST
= 0,
69 /* This is followed by an unsigned LEB128 number that is an index into
70 .debug_addr and specifies the base address for all following entries. */
71 DEBUG_LOC_BASE_ADDRESS
= 1,
73 /* This is followed by two unsigned LEB128 numbers that are indices into
74 .debug_addr and specify the beginning and ending addresses, and then
75 a normal location expression as in .debug_loc. */
76 DEBUG_LOC_START_END
= 2,
78 /* This is followed by an unsigned LEB128 number that is an index into
79 .debug_addr and specifies the beginning address, and a 4 byte unsigned
80 number that specifies the length, and then a normal location expression
82 DEBUG_LOC_START_LENGTH
= 3,
84 /* An internal value indicating there is insufficient data. */
85 DEBUG_LOC_BUFFER_OVERFLOW
= -1,
87 /* An internal value indicating an invalid kind of entry was found. */
88 DEBUG_LOC_INVALID_ENTRY
= -2
91 /* Helper function which throws an error if a synthetic pointer is
95 invalid_synthetic_pointer (void)
97 error (_("access outside bounds of object "
98 "referenced via synthetic pointer"));
101 /* Decode the addresses in a non-dwo .debug_loc entry.
102 A pointer to the next byte to examine is returned in *NEW_PTR.
103 The encoded low,high addresses are return in *LOW,*HIGH.
104 The result indicates the kind of entry found. */
106 static enum debug_loc_kind
107 decode_debug_loc_addresses (const gdb_byte
*loc_ptr
, const gdb_byte
*buf_end
,
108 const gdb_byte
**new_ptr
,
109 CORE_ADDR
*low
, CORE_ADDR
*high
,
110 enum bfd_endian byte_order
,
111 unsigned int addr_size
,
114 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
116 if (buf_end
- loc_ptr
< 2 * addr_size
)
117 return DEBUG_LOC_BUFFER_OVERFLOW
;
120 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
122 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
123 loc_ptr
+= addr_size
;
126 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
128 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
129 loc_ptr
+= addr_size
;
133 /* A base-address-selection entry. */
134 if ((*low
& base_mask
) == base_mask
)
135 return DEBUG_LOC_BASE_ADDRESS
;
137 /* An end-of-list entry. */
138 if (*low
== 0 && *high
== 0)
139 return DEBUG_LOC_END_OF_LIST
;
141 return DEBUG_LOC_START_END
;
144 /* Decode the addresses in .debug_loc.dwo entry.
145 A pointer to the next byte to examine is returned in *NEW_PTR.
146 The encoded low,high addresses are return in *LOW,*HIGH.
147 The result indicates the kind of entry found. */
149 static enum debug_loc_kind
150 decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data
*per_cu
,
151 const gdb_byte
*loc_ptr
,
152 const gdb_byte
*buf_end
,
153 const gdb_byte
**new_ptr
,
154 CORE_ADDR
*low
, CORE_ADDR
*high
,
155 enum bfd_endian byte_order
)
157 uint64_t low_index
, high_index
;
159 if (loc_ptr
== buf_end
)
160 return DEBUG_LOC_BUFFER_OVERFLOW
;
164 case DEBUG_LOC_END_OF_LIST
:
166 return DEBUG_LOC_END_OF_LIST
;
167 case DEBUG_LOC_BASE_ADDRESS
:
169 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
171 return DEBUG_LOC_BUFFER_OVERFLOW
;
172 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
174 return DEBUG_LOC_BASE_ADDRESS
;
175 case DEBUG_LOC_START_END
:
176 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
178 return DEBUG_LOC_BUFFER_OVERFLOW
;
179 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
180 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
182 return DEBUG_LOC_BUFFER_OVERFLOW
;
183 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
185 return DEBUG_LOC_START_END
;
186 case DEBUG_LOC_START_LENGTH
:
187 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
189 return DEBUG_LOC_BUFFER_OVERFLOW
;
190 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
191 if (loc_ptr
+ 4 > buf_end
)
192 return DEBUG_LOC_BUFFER_OVERFLOW
;
194 *high
+= extract_unsigned_integer (loc_ptr
, 4, byte_order
);
195 *new_ptr
= loc_ptr
+ 4;
196 return DEBUG_LOC_START_LENGTH
;
198 return DEBUG_LOC_INVALID_ENTRY
;
202 /* A function for dealing with location lists. Given a
203 symbol baton (BATON) and a pc value (PC), find the appropriate
204 location expression, set *LOCEXPR_LENGTH, and return a pointer
205 to the beginning of the expression. Returns NULL on failure.
207 For now, only return the first matching location expression; there
208 can be more than one in the list. */
211 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
212 size_t *locexpr_length
, CORE_ADDR pc
)
214 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
215 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
216 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
217 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
218 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
219 /* Adjust base_address for relocatable objects. */
220 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (baton
->per_cu
);
221 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
222 const gdb_byte
*loc_ptr
, *buf_end
;
224 loc_ptr
= baton
->data
;
225 buf_end
= baton
->data
+ baton
->size
;
229 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
231 enum debug_loc_kind kind
;
232 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
235 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
236 loc_ptr
, buf_end
, &new_ptr
,
237 &low
, &high
, byte_order
);
239 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
241 byte_order
, addr_size
,
246 case DEBUG_LOC_END_OF_LIST
:
249 case DEBUG_LOC_BASE_ADDRESS
:
250 base_address
= high
+ base_offset
;
252 case DEBUG_LOC_START_END
:
253 case DEBUG_LOC_START_LENGTH
:
255 case DEBUG_LOC_BUFFER_OVERFLOW
:
256 case DEBUG_LOC_INVALID_ENTRY
:
257 error (_("dwarf2_find_location_expression: "
258 "Corrupted DWARF expression."));
260 gdb_assert_not_reached ("bad debug_loc_kind");
263 /* Otherwise, a location expression entry.
264 If the entry is from a DWO, don't add base address: the entry is
265 from .debug_addr which has absolute addresses. */
266 if (! baton
->from_dwo
)
269 high
+= base_address
;
272 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
275 if (low
== high
&& pc
== low
)
277 /* This is entry PC record present only at entry point
278 of a function. Verify it is really the function entry point. */
280 struct block
*pc_block
= block_for_pc (pc
);
281 struct symbol
*pc_func
= NULL
;
284 pc_func
= block_linkage_function (pc_block
);
286 if (pc_func
&& pc
== BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func
)))
288 *locexpr_length
= length
;
293 if (pc
>= low
&& pc
< high
)
295 *locexpr_length
= length
;
303 /* This is the baton used when performing dwarf2 expression
305 struct dwarf_expr_baton
307 struct frame_info
*frame
;
308 struct dwarf2_per_cu_data
*per_cu
;
311 /* Helper functions for dwarf2_evaluate_loc_desc. */
313 /* Using the frame specified in BATON, return the value of register
314 REGNUM, treated as a pointer. */
316 dwarf_expr_read_reg (void *baton
, int dwarf_regnum
)
318 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
319 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
323 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
324 result
= address_from_register (builtin_type (gdbarch
)->builtin_data_ptr
,
325 regnum
, debaton
->frame
);
329 /* Read memory at ADDR (length LEN) into BUF. */
332 dwarf_expr_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
334 read_memory (addr
, buf
, len
);
337 /* Using the frame specified in BATON, find the location expression
338 describing the frame base. Return a pointer to it in START and
339 its length in LENGTH. */
341 dwarf_expr_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
343 /* FIXME: cagney/2003-03-26: This code should be using
344 get_frame_base_address(), and then implement a dwarf2 specific
346 struct symbol
*framefunc
;
347 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
348 struct block
*bl
= get_frame_block (debaton
->frame
, NULL
);
351 error (_("frame address is not available."));
353 /* Use block_linkage_function, which returns a real (not inlined)
354 function, instead of get_frame_function, which may return an
356 framefunc
= block_linkage_function (bl
);
358 /* If we found a frame-relative symbol then it was certainly within
359 some function associated with a frame. If we can't find the frame,
360 something has gone wrong. */
361 gdb_assert (framefunc
!= NULL
);
363 dwarf_expr_frame_base_1 (framefunc
,
364 get_frame_address_in_block (debaton
->frame
),
368 /* Implement find_frame_base_location method for LOC_BLOCK functions using
369 DWARF expression for its DW_AT_frame_base. */
372 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
373 const gdb_byte
**start
, size_t *length
)
375 struct dwarf2_locexpr_baton
*symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
377 *length
= symbaton
->size
;
378 *start
= symbaton
->data
;
381 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
382 function uses DWARF expression for its DW_AT_frame_base. */
384 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
386 locexpr_find_frame_base_location
389 /* Implement find_frame_base_location method for LOC_BLOCK functions using
390 DWARF location list for its DW_AT_frame_base. */
393 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
394 const gdb_byte
**start
, size_t *length
)
396 struct dwarf2_loclist_baton
*symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
398 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
401 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
402 function uses DWARF location list for its DW_AT_frame_base. */
404 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
406 loclist_find_frame_base_location
410 dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
411 const gdb_byte
**start
, size_t *length
)
413 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
415 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
417 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
423 error (_("Could not find the frame base for \"%s\"."),
424 SYMBOL_NATURAL_NAME (framefunc
));
427 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
428 the frame in BATON. */
431 dwarf_expr_frame_cfa (void *baton
)
433 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
435 return dwarf2_frame_cfa (debaton
->frame
);
438 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
439 the frame in BATON. */
442 dwarf_expr_frame_pc (void *baton
)
444 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
446 return get_frame_address_in_block (debaton
->frame
);
449 /* Using the objfile specified in BATON, find the address for the
450 current thread's thread-local storage with offset OFFSET. */
452 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
454 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
455 struct objfile
*objfile
= dwarf2_per_cu_objfile (debaton
->per_cu
);
457 return target_translate_tls_address (objfile
, offset
);
460 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
461 current CU (as is PER_CU). State of the CTX is not affected by the
465 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
466 struct dwarf2_per_cu_data
*per_cu
,
467 CORE_ADDR (*get_frame_pc
) (void *baton
),
470 struct dwarf2_locexpr_baton block
;
472 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
, get_frame_pc
, baton
);
474 /* DW_OP_call_ref is currently not supported. */
475 gdb_assert (block
.per_cu
== per_cu
);
477 dwarf_expr_eval (ctx
, block
.data
, block
.size
);
480 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
483 dwarf_expr_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
485 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
487 per_cu_dwarf_call (ctx
, die_offset
, debaton
->per_cu
,
488 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
491 /* Callback function for dwarf2_evaluate_loc_desc. */
494 dwarf_expr_get_base_type (struct dwarf_expr_context
*ctx
,
495 cu_offset die_offset
)
497 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
499 return dwarf2_get_die_type (die_offset
, debaton
->per_cu
);
502 /* See dwarf2loc.h. */
504 unsigned int entry_values_debug
= 0;
506 /* Helper to set entry_values_debug. */
509 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
510 struct cmd_list_element
*c
, const char *value
)
512 fprintf_filtered (file
,
513 _("Entry values and tail call frames debugging is %s.\n"),
517 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
518 CALLER_FRAME (for registers) can be NULL if it is not known. This function
519 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
522 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
523 struct call_site
*call_site
,
524 struct frame_info
*caller_frame
)
526 switch (FIELD_LOC_KIND (call_site
->target
))
528 case FIELD_LOC_KIND_DWARF_BLOCK
:
530 struct dwarf2_locexpr_baton
*dwarf_block
;
532 struct type
*caller_core_addr_type
;
533 struct gdbarch
*caller_arch
;
535 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
536 if (dwarf_block
== NULL
)
538 struct bound_minimal_symbol msym
;
540 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
541 throw_error (NO_ENTRY_VALUE_ERROR
,
542 _("DW_AT_GNU_call_site_target is not specified "
544 paddress (call_site_gdbarch
, call_site
->pc
),
545 (msym
.minsym
== NULL
? "???"
546 : SYMBOL_PRINT_NAME (msym
.minsym
)));
549 if (caller_frame
== NULL
)
551 struct bound_minimal_symbol msym
;
553 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
554 throw_error (NO_ENTRY_VALUE_ERROR
,
555 _("DW_AT_GNU_call_site_target DWARF block resolving "
556 "requires known frame which is currently not "
557 "available at %s in %s"),
558 paddress (call_site_gdbarch
, call_site
->pc
),
559 (msym
.minsym
== NULL
? "???"
560 : SYMBOL_PRINT_NAME (msym
.minsym
)));
563 caller_arch
= get_frame_arch (caller_frame
);
564 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
565 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
566 dwarf_block
->data
, dwarf_block
->size
,
567 dwarf_block
->per_cu
);
568 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
570 if (VALUE_LVAL (val
) == lval_memory
)
571 return value_address (val
);
573 return value_as_address (val
);
576 case FIELD_LOC_KIND_PHYSNAME
:
578 const char *physname
;
579 struct minimal_symbol
*msym
;
581 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
583 /* Handle both the mangled and demangled PHYSNAME. */
584 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
587 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1).minsym
;
588 throw_error (NO_ENTRY_VALUE_ERROR
,
589 _("Cannot find function \"%s\" for a call site target "
591 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
592 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
595 return SYMBOL_VALUE_ADDRESS (msym
);
598 case FIELD_LOC_KIND_PHYSADDR
:
599 return FIELD_STATIC_PHYSADDR (call_site
->target
);
602 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
606 /* Convert function entry point exact address ADDR to the function which is
607 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
608 NO_ENTRY_VALUE_ERROR otherwise. */
610 static struct symbol
*
611 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
613 struct symbol
*sym
= find_pc_function (addr
);
616 if (sym
== NULL
|| BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
617 throw_error (NO_ENTRY_VALUE_ERROR
,
618 _("DW_TAG_GNU_call_site resolving failed to find function "
619 "name for address %s"),
620 paddress (gdbarch
, addr
));
622 type
= SYMBOL_TYPE (sym
);
623 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
624 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
629 /* Verify function with entry point exact address ADDR can never call itself
630 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
631 can call itself via tail calls.
633 If a funtion can tail call itself its entry value based parameters are
634 unreliable. There is no verification whether the value of some/all
635 parameters is unchanged through the self tail call, we expect if there is
636 a self tail call all the parameters can be modified. */
639 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
641 struct obstack addr_obstack
;
642 struct cleanup
*old_chain
;
645 /* Track here CORE_ADDRs which were already visited. */
648 /* The verification is completely unordered. Track here function addresses
649 which still need to be iterated. */
650 VEC (CORE_ADDR
) *todo
= NULL
;
652 obstack_init (&addr_obstack
);
653 old_chain
= make_cleanup_obstack_free (&addr_obstack
);
654 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
655 &addr_obstack
, hashtab_obstack_allocate
,
657 make_cleanup_htab_delete (addr_hash
);
659 make_cleanup (VEC_cleanup (CORE_ADDR
), &todo
);
661 VEC_safe_push (CORE_ADDR
, todo
, verify_addr
);
662 while (!VEC_empty (CORE_ADDR
, todo
))
664 struct symbol
*func_sym
;
665 struct call_site
*call_site
;
667 addr
= VEC_pop (CORE_ADDR
, todo
);
669 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
671 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
672 call_site
; call_site
= call_site
->tail_call_next
)
674 CORE_ADDR target_addr
;
677 /* CALLER_FRAME with registers is not available for tail-call jumped
679 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
681 if (target_addr
== verify_addr
)
683 struct bound_minimal_symbol msym
;
685 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
686 throw_error (NO_ENTRY_VALUE_ERROR
,
687 _("DW_OP_GNU_entry_value resolving has found "
688 "function \"%s\" at %s can call itself via tail "
690 (msym
.minsym
== NULL
? "???"
691 : SYMBOL_PRINT_NAME (msym
.minsym
)),
692 paddress (gdbarch
, verify_addr
));
695 slot
= htab_find_slot (addr_hash
, &target_addr
, INSERT
);
698 *slot
= obstack_copy (&addr_obstack
, &target_addr
,
699 sizeof (target_addr
));
700 VEC_safe_push (CORE_ADDR
, todo
, target_addr
);
705 do_cleanups (old_chain
);
708 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
709 ENTRY_VALUES_DEBUG. */
712 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
714 CORE_ADDR addr
= call_site
->pc
;
715 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
717 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
718 (msym
.minsym
== NULL
? "???"
719 : SYMBOL_PRINT_NAME (msym
.minsym
)));
723 /* vec.h needs single word type name, typedef it. */
724 typedef struct call_site
*call_sitep
;
726 /* Define VEC (call_sitep) functions. */
727 DEF_VEC_P (call_sitep
);
729 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
730 only top callers and bottom callees which are present in both. GDBARCH is
731 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
732 no remaining possibilities to provide unambiguous non-trivial result.
733 RESULTP should point to NULL on the first (initialization) call. Caller is
734 responsible for xfree of any RESULTP data. */
737 chain_candidate (struct gdbarch
*gdbarch
, struct call_site_chain
**resultp
,
738 VEC (call_sitep
) *chain
)
740 struct call_site_chain
*result
= *resultp
;
741 long length
= VEC_length (call_sitep
, chain
);
742 int callers
, callees
, idx
;
746 /* Create the initial chain containing all the passed PCs. */
748 result
= xmalloc (sizeof (*result
) + sizeof (*result
->call_site
)
750 result
->length
= length
;
751 result
->callers
= result
->callees
= length
;
752 memcpy (result
->call_site
, VEC_address (call_sitep
, chain
),
753 sizeof (*result
->call_site
) * length
);
756 if (entry_values_debug
)
758 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
759 for (idx
= 0; idx
< length
; idx
++)
760 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
761 fputc_unfiltered ('\n', gdb_stdlog
);
767 if (entry_values_debug
)
769 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
770 for (idx
= 0; idx
< length
; idx
++)
771 tailcall_dump (gdbarch
, VEC_index (call_sitep
, chain
, idx
));
772 fputc_unfiltered ('\n', gdb_stdlog
);
775 /* Intersect callers. */
777 callers
= min (result
->callers
, length
);
778 for (idx
= 0; idx
< callers
; idx
++)
779 if (result
->call_site
[idx
] != VEC_index (call_sitep
, chain
, idx
))
781 result
->callers
= idx
;
785 /* Intersect callees. */
787 callees
= min (result
->callees
, length
);
788 for (idx
= 0; idx
< callees
; idx
++)
789 if (result
->call_site
[result
->length
- 1 - idx
]
790 != VEC_index (call_sitep
, chain
, length
- 1 - idx
))
792 result
->callees
= idx
;
796 if (entry_values_debug
)
798 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
799 for (idx
= 0; idx
< result
->callers
; idx
++)
800 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
801 fputs_unfiltered (" |", gdb_stdlog
);
802 for (idx
= 0; idx
< result
->callees
; idx
++)
803 tailcall_dump (gdbarch
, result
->call_site
[result
->length
804 - result
->callees
+ idx
]);
805 fputc_unfiltered ('\n', gdb_stdlog
);
808 if (result
->callers
== 0 && result
->callees
== 0)
810 /* There are no common callers or callees. It could be also a direct
811 call (which has length 0) with ambiguous possibility of an indirect
812 call - CALLERS == CALLEES == 0 is valid during the first allocation
813 but any subsequence processing of such entry means ambiguity. */
819 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
820 PC again. In such case there must be two different code paths to reach
821 it, therefore some of the former determined intermediate PCs must differ
822 and the unambiguous chain gets shortened. */
823 gdb_assert (result
->callers
+ result
->callees
< result
->length
);
826 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
827 assumed frames between them use GDBARCH. Use depth first search so we can
828 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
829 would have needless GDB stack overhead. Caller is responsible for xfree of
830 the returned result. Any unreliability results in thrown
831 NO_ENTRY_VALUE_ERROR. */
833 static struct call_site_chain
*
834 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
837 CORE_ADDR save_callee_pc
= callee_pc
;
838 struct obstack addr_obstack
;
839 struct cleanup
*back_to_retval
, *back_to_workdata
;
840 struct call_site_chain
*retval
= NULL
;
841 struct call_site
*call_site
;
843 /* Mark CALL_SITEs so we do not visit the same ones twice. */
846 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
847 call_site nor any possible call_site at CALLEE_PC's function is there.
848 Any CALL_SITE in CHAIN will be iterated to its siblings - via
849 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
850 VEC (call_sitep
) *chain
= NULL
;
852 /* We are not interested in the specific PC inside the callee function. */
853 callee_pc
= get_pc_function_start (callee_pc
);
855 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
856 paddress (gdbarch
, save_callee_pc
));
858 back_to_retval
= make_cleanup (free_current_contents
, &retval
);
860 obstack_init (&addr_obstack
);
861 back_to_workdata
= make_cleanup_obstack_free (&addr_obstack
);
862 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
863 &addr_obstack
, hashtab_obstack_allocate
,
865 make_cleanup_htab_delete (addr_hash
);
867 make_cleanup (VEC_cleanup (call_sitep
), &chain
);
869 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
870 at the target's function. All the possible tail call sites in the
871 target's function will get iterated as already pushed into CHAIN via their
873 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
877 CORE_ADDR target_func_addr
;
878 struct call_site
*target_call_site
;
880 /* CALLER_FRAME with registers is not available for tail-call jumped
882 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
884 if (target_func_addr
== callee_pc
)
886 chain_candidate (gdbarch
, &retval
, chain
);
890 /* There is no way to reach CALLEE_PC again as we would prevent
891 entering it twice as being already marked in ADDR_HASH. */
892 target_call_site
= NULL
;
896 struct symbol
*target_func
;
898 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
899 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
904 /* Attempt to visit TARGET_CALL_SITE. */
906 if (target_call_site
)
910 slot
= htab_find_slot (addr_hash
, &target_call_site
->pc
, INSERT
);
913 /* Successfully entered TARGET_CALL_SITE. */
915 *slot
= &target_call_site
->pc
;
916 VEC_safe_push (call_sitep
, chain
, target_call_site
);
921 /* Backtrack (without revisiting the originating call_site). Try the
922 callers's sibling; if there isn't any try the callers's callers's
925 target_call_site
= NULL
;
926 while (!VEC_empty (call_sitep
, chain
))
928 call_site
= VEC_pop (call_sitep
, chain
);
930 gdb_assert (htab_find_slot (addr_hash
, &call_site
->pc
,
932 htab_remove_elt (addr_hash
, &call_site
->pc
);
934 target_call_site
= call_site
->tail_call_next
;
935 if (target_call_site
)
939 while (target_call_site
);
941 if (VEC_empty (call_sitep
, chain
))
944 call_site
= VEC_last (call_sitep
, chain
);
949 struct bound_minimal_symbol msym_caller
, msym_callee
;
951 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
952 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
953 throw_error (NO_ENTRY_VALUE_ERROR
,
954 _("There are no unambiguously determinable intermediate "
955 "callers or callees between caller function \"%s\" at %s "
956 "and callee function \"%s\" at %s"),
957 (msym_caller
.minsym
== NULL
958 ? "???" : SYMBOL_PRINT_NAME (msym_caller
.minsym
)),
959 paddress (gdbarch
, caller_pc
),
960 (msym_callee
.minsym
== NULL
961 ? "???" : SYMBOL_PRINT_NAME (msym_callee
.minsym
)),
962 paddress (gdbarch
, callee_pc
));
965 do_cleanups (back_to_workdata
);
966 discard_cleanups (back_to_retval
);
970 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
971 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
972 constructed return NULL. Caller is responsible for xfree of the returned
975 struct call_site_chain
*
976 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
979 volatile struct gdb_exception e
;
980 struct call_site_chain
*retval
= NULL
;
982 TRY_CATCH (e
, RETURN_MASK_ERROR
)
984 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
988 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
990 if (entry_values_debug
)
991 exception_print (gdb_stdout
, e
);
1001 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1004 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1005 enum call_site_parameter_kind kind
,
1006 union call_site_parameter_u kind_u
)
1008 if (kind
== parameter
->kind
)
1011 case CALL_SITE_PARAMETER_DWARF_REG
:
1012 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1013 case CALL_SITE_PARAMETER_FB_OFFSET
:
1014 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1015 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1016 return kind_u
.param_offset
.cu_off
== parameter
->u
.param_offset
.cu_off
;
1021 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1022 FRAME is for callee.
1024 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1027 static struct call_site_parameter
*
1028 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1029 enum call_site_parameter_kind kind
,
1030 union call_site_parameter_u kind_u
,
1031 struct dwarf2_per_cu_data
**per_cu_return
)
1033 CORE_ADDR func_addr
, caller_pc
;
1034 struct gdbarch
*gdbarch
;
1035 struct frame_info
*caller_frame
;
1036 struct call_site
*call_site
;
1038 /* Initialize it just to avoid a GCC false warning. */
1039 struct call_site_parameter
*parameter
= NULL
;
1040 CORE_ADDR target_addr
;
1042 while (get_frame_type (frame
) == INLINE_FRAME
)
1044 frame
= get_prev_frame (frame
);
1045 gdb_assert (frame
!= NULL
);
1048 func_addr
= get_frame_func (frame
);
1049 gdbarch
= get_frame_arch (frame
);
1050 caller_frame
= get_prev_frame (frame
);
1051 if (gdbarch
!= frame_unwind_arch (frame
))
1053 struct bound_minimal_symbol msym
1054 = lookup_minimal_symbol_by_pc (func_addr
);
1055 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1057 throw_error (NO_ENTRY_VALUE_ERROR
,
1058 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1059 "(of %s (%s)) does not match caller gdbarch %s"),
1060 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1061 paddress (gdbarch
, func_addr
),
1062 (msym
.minsym
== NULL
? "???"
1063 : SYMBOL_PRINT_NAME (msym
.minsym
)),
1064 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1067 if (caller_frame
== NULL
)
1069 struct bound_minimal_symbol msym
1070 = lookup_minimal_symbol_by_pc (func_addr
);
1072 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_GNU_entry_value resolving "
1073 "requires caller of %s (%s)"),
1074 paddress (gdbarch
, func_addr
),
1075 (msym
.minsym
== NULL
? "???"
1076 : SYMBOL_PRINT_NAME (msym
.minsym
)));
1078 caller_pc
= get_frame_pc (caller_frame
);
1079 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1081 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1082 if (target_addr
!= func_addr
)
1084 struct minimal_symbol
*target_msym
, *func_msym
;
1086 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1087 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1088 throw_error (NO_ENTRY_VALUE_ERROR
,
1089 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1090 "but the called frame is for %s at %s"),
1091 (target_msym
== NULL
? "???"
1092 : SYMBOL_PRINT_NAME (target_msym
)),
1093 paddress (gdbarch
, target_addr
),
1094 func_msym
== NULL
? "???" : SYMBOL_PRINT_NAME (func_msym
),
1095 paddress (gdbarch
, func_addr
));
1098 /* No entry value based parameters would be reliable if this function can
1099 call itself via tail calls. */
1100 func_verify_no_selftailcall (gdbarch
, func_addr
);
1102 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1104 parameter
= &call_site
->parameter
[iparams
];
1105 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1108 if (iparams
== call_site
->parameter_count
)
1110 struct minimal_symbol
*msym
1111 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1113 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1114 determine its value. */
1115 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1116 "at DW_TAG_GNU_call_site %s at %s"),
1117 paddress (gdbarch
, caller_pc
),
1118 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
1121 *per_cu_return
= call_site
->per_cu
;
1125 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1126 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1127 DW_AT_GNU_call_site_data_value (dereferenced) block.
1129 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1132 Function always returns non-NULL, non-optimized out value. It throws
1133 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1135 static struct value
*
1136 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1137 CORE_ADDR deref_size
, struct type
*type
,
1138 struct frame_info
*caller_frame
,
1139 struct dwarf2_per_cu_data
*per_cu
)
1141 const gdb_byte
*data_src
;
1145 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1146 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1148 /* DEREF_SIZE size is not verified here. */
1149 if (data_src
== NULL
)
1150 throw_error (NO_ENTRY_VALUE_ERROR
,
1151 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1153 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1154 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1156 data
= alloca (size
+ 1);
1157 memcpy (data
, data_src
, size
);
1158 data
[size
] = DW_OP_stack_value
;
1160 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1163 /* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
1164 Choose DEREF_SIZE value of that parameter. Search caller of the CTX's
1165 frame. CTX must be of dwarf_expr_ctx_funcs kind.
1167 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1168 can be more simple as it does not support cross-CU DWARF executions. */
1171 dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
1172 enum call_site_parameter_kind kind
,
1173 union call_site_parameter_u kind_u
,
1176 struct dwarf_expr_baton
*debaton
;
1177 struct frame_info
*frame
, *caller_frame
;
1178 struct dwarf2_per_cu_data
*caller_per_cu
;
1179 struct dwarf_expr_baton baton_local
;
1180 struct dwarf_expr_context saved_ctx
;
1181 struct call_site_parameter
*parameter
;
1182 const gdb_byte
*data_src
;
1185 gdb_assert (ctx
->funcs
== &dwarf_expr_ctx_funcs
);
1186 debaton
= ctx
->baton
;
1187 frame
= debaton
->frame
;
1188 caller_frame
= get_prev_frame (frame
);
1190 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1192 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1193 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1195 /* DEREF_SIZE size is not verified here. */
1196 if (data_src
== NULL
)
1197 throw_error (NO_ENTRY_VALUE_ERROR
,
1198 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1200 baton_local
.frame
= caller_frame
;
1201 baton_local
.per_cu
= caller_per_cu
;
1203 saved_ctx
.gdbarch
= ctx
->gdbarch
;
1204 saved_ctx
.addr_size
= ctx
->addr_size
;
1205 saved_ctx
.offset
= ctx
->offset
;
1206 saved_ctx
.baton
= ctx
->baton
;
1207 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (baton_local
.per_cu
));
1208 ctx
->addr_size
= dwarf2_per_cu_addr_size (baton_local
.per_cu
);
1209 ctx
->offset
= dwarf2_per_cu_text_offset (baton_local
.per_cu
);
1210 ctx
->baton
= &baton_local
;
1212 dwarf_expr_eval (ctx
, data_src
, size
);
1214 ctx
->gdbarch
= saved_ctx
.gdbarch
;
1215 ctx
->addr_size
= saved_ctx
.addr_size
;
1216 ctx
->offset
= saved_ctx
.offset
;
1217 ctx
->baton
= saved_ctx
.baton
;
1220 /* Callback function for dwarf2_evaluate_loc_desc.
1221 Fetch the address indexed by DW_OP_GNU_addr_index. */
1224 dwarf_expr_get_addr_index (void *baton
, unsigned int index
)
1226 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
1228 return dwarf2_read_addr_index (debaton
->per_cu
, index
);
1231 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1232 the indirect method on it, that is use its stored target value, the sole
1233 purpose of entry_data_value_funcs.. */
1235 static struct value
*
1236 entry_data_value_coerce_ref (const struct value
*value
)
1238 struct type
*checked_type
= check_typedef (value_type (value
));
1239 struct value
*target_val
;
1241 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
)
1244 target_val
= value_computed_closure (value
);
1245 value_incref (target_val
);
1249 /* Implement copy_closure. */
1252 entry_data_value_copy_closure (const struct value
*v
)
1254 struct value
*target_val
= value_computed_closure (v
);
1256 value_incref (target_val
);
1260 /* Implement free_closure. */
1263 entry_data_value_free_closure (struct value
*v
)
1265 struct value
*target_val
= value_computed_closure (v
);
1267 value_free (target_val
);
1270 /* Vector for methods for an entry value reference where the referenced value
1271 is stored in the caller. On the first dereference use
1272 DW_AT_GNU_call_site_data_value in the caller. */
1274 static const struct lval_funcs entry_data_value_funcs
=
1278 NULL
, /* check_validity */
1279 NULL
, /* check_any_valid */
1280 NULL
, /* indirect */
1281 entry_data_value_coerce_ref
,
1282 NULL
, /* check_synthetic_pointer */
1283 entry_data_value_copy_closure
,
1284 entry_data_value_free_closure
1287 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1288 are used to match DW_AT_location at the caller's
1289 DW_TAG_GNU_call_site_parameter.
1291 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1292 cannot resolve the parameter for any reason. */
1294 static struct value
*
1295 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1296 enum call_site_parameter_kind kind
,
1297 union call_site_parameter_u kind_u
)
1299 struct type
*checked_type
= check_typedef (type
);
1300 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1301 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1302 struct value
*outer_val
, *target_val
, *val
;
1303 struct call_site_parameter
*parameter
;
1304 struct dwarf2_per_cu_data
*caller_per_cu
;
1307 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1310 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1314 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1315 used and it is not available do not fall back to OUTER_VAL - dereferencing
1316 TYPE_CODE_REF with non-entry data value would give current value - not the
1319 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
1320 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1323 target_val
= dwarf_entry_parameter_to_value (parameter
,
1324 TYPE_LENGTH (target_type
),
1325 target_type
, caller_frame
,
1328 /* value_as_address dereferences TYPE_CODE_REF. */
1329 addr
= extract_typed_address (value_contents (outer_val
), checked_type
);
1331 /* The target entry value has artificial address of the entry value
1333 VALUE_LVAL (target_val
) = lval_memory
;
1334 set_value_address (target_val
, addr
);
1336 release_value (target_val
);
1337 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1338 target_val
/* closure */);
1340 /* Copy the referencing pointer to the new computed value. */
1341 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1342 TYPE_LENGTH (checked_type
));
1343 set_value_lazy (val
, 0);
1348 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1349 SIZE are DWARF block used to match DW_AT_location at the caller's
1350 DW_TAG_GNU_call_site_parameter.
1352 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1353 cannot resolve the parameter for any reason. */
1355 static struct value
*
1356 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1357 const gdb_byte
*block
, size_t block_len
)
1359 union call_site_parameter_u kind_u
;
1361 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1362 if (kind_u
.dwarf_reg
!= -1)
1363 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1366 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1367 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1370 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1371 suppressed during normal operation. The expression can be arbitrary if
1372 there is no caller-callee entry value binding expected. */
1373 throw_error (NO_ENTRY_VALUE_ERROR
,
1374 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1375 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1378 struct piece_closure
1380 /* Reference count. */
1383 /* The CU from which this closure's expression came. */
1384 struct dwarf2_per_cu_data
*per_cu
;
1386 /* The number of pieces used to describe this variable. */
1389 /* The target address size, used only for DWARF_VALUE_STACK. */
1392 /* The pieces themselves. */
1393 struct dwarf_expr_piece
*pieces
;
1396 /* Allocate a closure for a value formed from separately-described
1399 static struct piece_closure
*
1400 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1401 int n_pieces
, struct dwarf_expr_piece
*pieces
,
1404 struct piece_closure
*c
= XZALLOC (struct piece_closure
);
1409 c
->n_pieces
= n_pieces
;
1410 c
->addr_size
= addr_size
;
1411 c
->pieces
= XCALLOC (n_pieces
, struct dwarf_expr_piece
);
1413 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
1414 for (i
= 0; i
< n_pieces
; ++i
)
1415 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1416 value_incref (c
->pieces
[i
].v
.value
);
1421 /* The lowest-level function to extract bits from a byte buffer.
1422 SOURCE is the buffer. It is updated if we read to the end of a
1424 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1425 updated to reflect the number of bits actually read.
1426 NBITS is the number of bits we want to read. It is updated to
1427 reflect the number of bits actually read. This function may read
1429 BITS_BIG_ENDIAN is taken directly from gdbarch.
1430 This function returns the extracted bits. */
1433 extract_bits_primitive (const gdb_byte
**source
,
1434 unsigned int *source_offset_bits
,
1435 int *nbits
, int bits_big_endian
)
1437 unsigned int avail
, mask
, datum
;
1439 gdb_assert (*source_offset_bits
< 8);
1441 avail
= 8 - *source_offset_bits
;
1445 mask
= (1 << avail
) - 1;
1447 if (bits_big_endian
)
1448 datum
>>= 8 - (*source_offset_bits
+ *nbits
);
1450 datum
>>= *source_offset_bits
;
1454 *source_offset_bits
+= avail
;
1455 if (*source_offset_bits
>= 8)
1457 *source_offset_bits
-= 8;
1464 /* Extract some bits from a source buffer and move forward in the
1467 SOURCE is the source buffer. It is updated as bytes are read.
1468 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1470 NBITS is the number of bits to read.
1471 BITS_BIG_ENDIAN is taken directly from gdbarch.
1473 This function returns the bits that were read. */
1476 extract_bits (const gdb_byte
**source
, unsigned int *source_offset_bits
,
1477 int nbits
, int bits_big_endian
)
1481 gdb_assert (nbits
> 0 && nbits
<= 8);
1483 datum
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1489 more
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1491 if (bits_big_endian
)
1501 /* Write some bits into a buffer and move forward in the buffer.
1503 DATUM is the bits to write. The low-order bits of DATUM are used.
1504 DEST is the destination buffer. It is updated as bytes are
1506 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1508 NBITS is the number of valid bits in DATUM.
1509 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1512 insert_bits (unsigned int datum
,
1513 gdb_byte
*dest
, unsigned int dest_offset_bits
,
1514 int nbits
, int bits_big_endian
)
1518 gdb_assert (dest_offset_bits
+ nbits
<= 8);
1520 mask
= (1 << nbits
) - 1;
1521 if (bits_big_endian
)
1523 datum
<<= 8 - (dest_offset_bits
+ nbits
);
1524 mask
<<= 8 - (dest_offset_bits
+ nbits
);
1528 datum
<<= dest_offset_bits
;
1529 mask
<<= dest_offset_bits
;
1532 gdb_assert ((datum
& ~mask
) == 0);
1534 *dest
= (*dest
& ~mask
) | datum
;
1537 /* Copy bits from a source to a destination.
1539 DEST is where the bits should be written.
1540 DEST_OFFSET_BITS is the bit offset into DEST.
1541 SOURCE is the source of bits.
1542 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1543 BIT_COUNT is the number of bits to copy.
1544 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1547 copy_bitwise (gdb_byte
*dest
, unsigned int dest_offset_bits
,
1548 const gdb_byte
*source
, unsigned int source_offset_bits
,
1549 unsigned int bit_count
,
1550 int bits_big_endian
)
1552 unsigned int dest_avail
;
1555 /* Reduce everything to byte-size pieces. */
1556 dest
+= dest_offset_bits
/ 8;
1557 dest_offset_bits
%= 8;
1558 source
+= source_offset_bits
/ 8;
1559 source_offset_bits
%= 8;
1561 dest_avail
= 8 - dest_offset_bits
% 8;
1563 /* See if we can fill the first destination byte. */
1564 if (dest_avail
< bit_count
)
1566 datum
= extract_bits (&source
, &source_offset_bits
, dest_avail
,
1568 insert_bits (datum
, dest
, dest_offset_bits
, dest_avail
, bits_big_endian
);
1570 dest_offset_bits
= 0;
1571 bit_count
-= dest_avail
;
1574 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1575 than 8 bits remaining. */
1576 gdb_assert (dest_offset_bits
% 8 == 0 || bit_count
< 8);
1577 for (; bit_count
>= 8; bit_count
-= 8)
1579 datum
= extract_bits (&source
, &source_offset_bits
, 8, bits_big_endian
);
1580 *dest
++ = (gdb_byte
) datum
;
1583 /* Finally, we may have a few leftover bits. */
1584 gdb_assert (bit_count
<= 8 - dest_offset_bits
% 8);
1587 datum
= extract_bits (&source
, &source_offset_bits
, bit_count
,
1589 insert_bits (datum
, dest
, dest_offset_bits
, bit_count
, bits_big_endian
);
1594 read_pieced_value (struct value
*v
)
1598 ULONGEST bits_to_skip
;
1600 struct piece_closure
*c
1601 = (struct piece_closure
*) value_computed_closure (v
);
1602 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (v
));
1604 size_t buffer_size
= 0;
1605 gdb_byte
*buffer
= NULL
;
1606 struct cleanup
*cleanup
;
1608 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1610 if (value_type (v
) != value_enclosing_type (v
))
1611 internal_error (__FILE__
, __LINE__
,
1612 _("Should not be able to create a lazy value with "
1613 "an enclosing type"));
1615 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1617 contents
= value_contents_raw (v
);
1618 bits_to_skip
= 8 * value_offset (v
);
1619 if (value_bitsize (v
))
1621 bits_to_skip
+= value_bitpos (v
);
1622 type_len
= value_bitsize (v
);
1625 type_len
= 8 * TYPE_LENGTH (value_type (v
));
1627 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1629 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1630 size_t this_size
, this_size_bits
;
1631 long dest_offset_bits
, source_offset_bits
, source_offset
;
1632 const gdb_byte
*intermediate_buffer
;
1634 /* Compute size, source, and destination offsets for copying, in
1636 this_size_bits
= p
->size
;
1637 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1639 bits_to_skip
-= this_size_bits
;
1642 if (bits_to_skip
> 0)
1644 dest_offset_bits
= 0;
1645 source_offset_bits
= bits_to_skip
;
1646 this_size_bits
-= bits_to_skip
;
1651 dest_offset_bits
= offset
;
1652 source_offset_bits
= 0;
1654 if (this_size_bits
> type_len
- offset
)
1655 this_size_bits
= type_len
- offset
;
1657 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1658 source_offset
= source_offset_bits
/ 8;
1659 if (buffer_size
< this_size
)
1661 buffer_size
= this_size
;
1662 buffer
= xrealloc (buffer
, buffer_size
);
1664 intermediate_buffer
= buffer
;
1666 /* Copy from the source to DEST_BUFFER. */
1667 switch (p
->location
)
1669 case DWARF_VALUE_REGISTER
:
1671 struct gdbarch
*arch
= get_frame_arch (frame
);
1672 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1673 int reg_offset
= source_offset
;
1675 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1676 && this_size
< register_size (arch
, gdb_regnum
))
1678 /* Big-endian, and we want less than full size. */
1679 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1680 /* We want the lower-order THIS_SIZE_BITS of the bytes
1681 we extract from the register. */
1682 source_offset_bits
+= 8 * this_size
- this_size_bits
;
1685 if (gdb_regnum
!= -1)
1689 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1693 /* Just so garbage doesn't ever shine through. */
1694 memset (buffer
, 0, this_size
);
1697 set_value_optimized_out (v
, 1);
1699 mark_value_bytes_unavailable (v
, offset
, this_size
);
1704 error (_("Unable to access DWARF register number %s"),
1705 paddress (arch
, p
->v
.regno
));
1710 case DWARF_VALUE_MEMORY
:
1711 read_value_memory (v
, offset
,
1712 p
->v
.mem
.in_stack_memory
,
1713 p
->v
.mem
.addr
+ source_offset
,
1717 case DWARF_VALUE_STACK
:
1719 size_t n
= this_size
;
1721 if (n
> c
->addr_size
- source_offset
)
1722 n
= (c
->addr_size
>= source_offset
1723 ? c
->addr_size
- source_offset
1731 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
1733 intermediate_buffer
= val_bytes
+ source_offset
;
1738 case DWARF_VALUE_LITERAL
:
1740 size_t n
= this_size
;
1742 if (n
> p
->v
.literal
.length
- source_offset
)
1743 n
= (p
->v
.literal
.length
>= source_offset
1744 ? p
->v
.literal
.length
- source_offset
1747 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
1751 /* These bits show up as zeros -- but do not cause the value
1752 to be considered optimized-out. */
1753 case DWARF_VALUE_IMPLICIT_POINTER
:
1756 case DWARF_VALUE_OPTIMIZED_OUT
:
1757 set_value_optimized_out (v
, 1);
1761 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1764 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
1765 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1766 copy_bitwise (contents
, dest_offset_bits
,
1767 intermediate_buffer
, source_offset_bits
% 8,
1768 this_size_bits
, bits_big_endian
);
1770 offset
+= this_size_bits
;
1773 do_cleanups (cleanup
);
1777 write_pieced_value (struct value
*to
, struct value
*from
)
1781 ULONGEST bits_to_skip
;
1782 const gdb_byte
*contents
;
1783 struct piece_closure
*c
1784 = (struct piece_closure
*) value_computed_closure (to
);
1785 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
1787 size_t buffer_size
= 0;
1788 gdb_byte
*buffer
= NULL
;
1789 struct cleanup
*cleanup
;
1791 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
1795 set_value_optimized_out (to
, 1);
1799 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1801 contents
= value_contents (from
);
1802 bits_to_skip
= 8 * value_offset (to
);
1803 if (value_bitsize (to
))
1805 bits_to_skip
+= value_bitpos (to
);
1806 type_len
= value_bitsize (to
);
1809 type_len
= 8 * TYPE_LENGTH (value_type (to
));
1811 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1813 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1814 size_t this_size_bits
, this_size
;
1815 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
1817 const gdb_byte
*source_buffer
;
1819 this_size_bits
= p
->size
;
1820 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1822 bits_to_skip
-= this_size_bits
;
1825 if (this_size_bits
> type_len
- offset
)
1826 this_size_bits
= type_len
- offset
;
1827 if (bits_to_skip
> 0)
1829 dest_offset_bits
= bits_to_skip
;
1830 source_offset_bits
= 0;
1831 this_size_bits
-= bits_to_skip
;
1836 dest_offset_bits
= 0;
1837 source_offset_bits
= offset
;
1840 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1841 source_offset
= source_offset_bits
/ 8;
1842 dest_offset
= dest_offset_bits
/ 8;
1843 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
1845 source_buffer
= contents
+ source_offset
;
1850 if (buffer_size
< this_size
)
1852 buffer_size
= this_size
;
1853 buffer
= xrealloc (buffer
, buffer_size
);
1855 source_buffer
= buffer
;
1859 switch (p
->location
)
1861 case DWARF_VALUE_REGISTER
:
1863 struct gdbarch
*arch
= get_frame_arch (frame
);
1864 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1865 int reg_offset
= dest_offset
;
1867 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1868 && this_size
<= register_size (arch
, gdb_regnum
))
1869 /* Big-endian, and we want less than full size. */
1870 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1872 if (gdb_regnum
!= -1)
1878 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1883 error (_("Can't do read-modify-write to "
1884 "update bitfield; containing word has been "
1887 throw_error (NOT_AVAILABLE_ERROR
,
1888 _("Can't do read-modify-write to update "
1889 "bitfield; containing word "
1892 copy_bitwise (buffer
, dest_offset_bits
,
1893 contents
, source_offset_bits
,
1898 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1899 this_size
, source_buffer
);
1903 error (_("Unable to write to DWARF register number %s"),
1904 paddress (arch
, p
->v
.regno
));
1908 case DWARF_VALUE_MEMORY
:
1911 /* Only the first and last bytes can possibly have any
1913 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
, 1);
1914 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
1915 buffer
+ this_size
- 1, 1);
1916 copy_bitwise (buffer
, dest_offset_bits
,
1917 contents
, source_offset_bits
,
1922 write_memory (p
->v
.mem
.addr
+ dest_offset
,
1923 source_buffer
, this_size
);
1926 set_value_optimized_out (to
, 1);
1929 offset
+= this_size_bits
;
1932 do_cleanups (cleanup
);
1935 /* A helper function that checks bit validity in a pieced value.
1936 CHECK_FOR indicates the kind of validity checking.
1937 DWARF_VALUE_MEMORY means to check whether any bit is valid.
1938 DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
1940 DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
1941 implicit pointer. */
1944 check_pieced_value_bits (const struct value
*value
, int bit_offset
,
1946 enum dwarf_value_location check_for
)
1948 struct piece_closure
*c
1949 = (struct piece_closure
*) value_computed_closure (value
);
1951 int validity
= (check_for
== DWARF_VALUE_MEMORY
1952 || check_for
== DWARF_VALUE_IMPLICIT_POINTER
);
1954 bit_offset
+= 8 * value_offset (value
);
1955 if (value_bitsize (value
))
1956 bit_offset
+= value_bitpos (value
);
1958 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
1960 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1961 size_t this_size_bits
= p
->size
;
1965 if (bit_offset
>= this_size_bits
)
1967 bit_offset
-= this_size_bits
;
1971 bit_length
-= this_size_bits
- bit_offset
;
1975 bit_length
-= this_size_bits
;
1977 if (check_for
== DWARF_VALUE_IMPLICIT_POINTER
)
1979 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1982 else if (p
->location
== DWARF_VALUE_OPTIMIZED_OUT
1983 || p
->location
== DWARF_VALUE_IMPLICIT_POINTER
)
1999 check_pieced_value_validity (const struct value
*value
, int bit_offset
,
2002 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
2003 DWARF_VALUE_MEMORY
);
2007 check_pieced_value_invalid (const struct value
*value
)
2009 return check_pieced_value_bits (value
, 0,
2010 8 * TYPE_LENGTH (value_type (value
)),
2011 DWARF_VALUE_OPTIMIZED_OUT
);
2014 /* An implementation of an lval_funcs method to see whether a value is
2015 a synthetic pointer. */
2018 check_pieced_synthetic_pointer (const struct value
*value
, int bit_offset
,
2021 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
2022 DWARF_VALUE_IMPLICIT_POINTER
);
2025 /* A wrapper function for get_frame_address_in_block. */
2028 get_frame_address_in_block_wrapper (void *baton
)
2030 return get_frame_address_in_block (baton
);
2033 /* An implementation of an lval_funcs method to indirect through a
2034 pointer. This handles the synthetic pointer case when needed. */
2036 static struct value
*
2037 indirect_pieced_value (struct value
*value
)
2039 struct piece_closure
*c
2040 = (struct piece_closure
*) value_computed_closure (value
);
2042 struct frame_info
*frame
;
2043 struct dwarf2_locexpr_baton baton
;
2044 int i
, bit_offset
, bit_length
;
2045 struct dwarf_expr_piece
*piece
= NULL
;
2046 LONGEST byte_offset
;
2048 type
= check_typedef (value_type (value
));
2049 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
2052 bit_length
= 8 * TYPE_LENGTH (type
);
2053 bit_offset
= 8 * value_offset (value
);
2054 if (value_bitsize (value
))
2055 bit_offset
+= value_bitpos (value
);
2057 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2059 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2060 size_t this_size_bits
= p
->size
;
2064 if (bit_offset
>= this_size_bits
)
2066 bit_offset
-= this_size_bits
;
2070 bit_length
-= this_size_bits
- bit_offset
;
2074 bit_length
-= this_size_bits
;
2076 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2079 if (bit_length
!= 0)
2080 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2086 frame
= get_selected_frame (_("No frame selected."));
2088 /* This is an offset requested by GDB, such as value subscripts.
2089 However, due to how synthetic pointers are implemented, this is
2090 always presented to us as a pointer type. This means we have to
2091 sign-extend it manually as appropriate. */
2092 byte_offset
= value_as_address (value
);
2093 if (TYPE_LENGTH (value_type (value
)) < sizeof (LONGEST
))
2094 byte_offset
= gdb_sign_extend (byte_offset
,
2095 8 * TYPE_LENGTH (value_type (value
)));
2096 byte_offset
+= piece
->v
.ptr
.offset
;
2100 = dwarf2_fetch_die_loc_sect_off (piece
->v
.ptr
.die
, c
->per_cu
,
2101 get_frame_address_in_block_wrapper
,
2104 if (baton
.data
!= NULL
)
2105 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
2106 baton
.data
, baton
.size
, baton
.per_cu
,
2110 struct obstack temp_obstack
;
2111 struct cleanup
*cleanup
;
2112 const gdb_byte
*bytes
;
2114 struct value
*result
;
2116 obstack_init (&temp_obstack
);
2117 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2119 bytes
= dwarf2_fetch_constant_bytes (piece
->v
.ptr
.die
, c
->per_cu
,
2120 &temp_obstack
, &len
);
2122 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
2126 || byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > len
)
2127 invalid_synthetic_pointer ();
2128 bytes
+= byte_offset
;
2129 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
2132 do_cleanups (cleanup
);
2138 copy_pieced_value_closure (const struct value
*v
)
2140 struct piece_closure
*c
2141 = (struct piece_closure
*) value_computed_closure (v
);
2148 free_pieced_value_closure (struct value
*v
)
2150 struct piece_closure
*c
2151 = (struct piece_closure
*) value_computed_closure (v
);
2158 for (i
= 0; i
< c
->n_pieces
; ++i
)
2159 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
2160 value_free (c
->pieces
[i
].v
.value
);
2167 /* Functions for accessing a variable described by DW_OP_piece. */
2168 static const struct lval_funcs pieced_value_funcs
= {
2171 check_pieced_value_validity
,
2172 check_pieced_value_invalid
,
2173 indirect_pieced_value
,
2174 NULL
, /* coerce_ref */
2175 check_pieced_synthetic_pointer
,
2176 copy_pieced_value_closure
,
2177 free_pieced_value_closure
2180 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2182 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
=
2184 dwarf_expr_read_reg
,
2185 dwarf_expr_read_mem
,
2186 dwarf_expr_frame_base
,
2187 dwarf_expr_frame_cfa
,
2188 dwarf_expr_frame_pc
,
2189 dwarf_expr_tls_address
,
2190 dwarf_expr_dwarf_call
,
2191 dwarf_expr_get_base_type
,
2192 dwarf_expr_push_dwarf_reg_entry_value
,
2193 dwarf_expr_get_addr_index
2196 /* Evaluate a location description, starting at DATA and with length
2197 SIZE, to find the current location of variable of TYPE in the
2198 context of FRAME. BYTE_OFFSET is applied after the contents are
2201 static struct value
*
2202 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2203 const gdb_byte
*data
, size_t size
,
2204 struct dwarf2_per_cu_data
*per_cu
,
2205 LONGEST byte_offset
)
2207 struct value
*retval
;
2208 struct dwarf_expr_baton baton
;
2209 struct dwarf_expr_context
*ctx
;
2210 struct cleanup
*old_chain
, *value_chain
;
2211 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2212 volatile struct gdb_exception ex
;
2214 if (byte_offset
< 0)
2215 invalid_synthetic_pointer ();
2218 return allocate_optimized_out_value (type
);
2220 baton
.frame
= frame
;
2221 baton
.per_cu
= per_cu
;
2223 ctx
= new_dwarf_expr_context ();
2224 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2225 value_chain
= make_cleanup_value_free_to_mark (value_mark ());
2227 ctx
->gdbarch
= get_objfile_arch (objfile
);
2228 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2229 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2230 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2231 ctx
->baton
= &baton
;
2232 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2234 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2236 dwarf_expr_eval (ctx
, data
, size
);
2240 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2242 do_cleanups (old_chain
);
2243 retval
= allocate_value (type
);
2244 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
2247 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2249 if (entry_values_debug
)
2250 exception_print (gdb_stdout
, ex
);
2251 do_cleanups (old_chain
);
2252 return allocate_optimized_out_value (type
);
2255 throw_exception (ex
);
2258 if (ctx
->num_pieces
> 0)
2260 struct piece_closure
*c
;
2261 struct frame_id frame_id
= get_frame_id (frame
);
2262 ULONGEST bit_size
= 0;
2265 for (i
= 0; i
< ctx
->num_pieces
; ++i
)
2266 bit_size
+= ctx
->pieces
[i
].size
;
2267 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
2268 invalid_synthetic_pointer ();
2270 c
= allocate_piece_closure (per_cu
, ctx
->num_pieces
, ctx
->pieces
,
2272 /* We must clean up the value chain after creating the piece
2273 closure but before allocating the result. */
2274 do_cleanups (value_chain
);
2275 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
2276 VALUE_FRAME_ID (retval
) = frame_id
;
2277 set_value_offset (retval
, byte_offset
);
2281 switch (ctx
->location
)
2283 case DWARF_VALUE_REGISTER
:
2285 struct gdbarch
*arch
= get_frame_arch (frame
);
2287 = longest_to_int (value_as_long (dwarf_expr_fetch (ctx
, 0)));
2288 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
2290 if (byte_offset
!= 0)
2291 error (_("cannot use offset on synthetic pointer to register"));
2292 do_cleanups (value_chain
);
2293 if (gdb_regnum
== -1)
2294 error (_("Unable to access DWARF register number %d"),
2296 retval
= value_from_register (type
, gdb_regnum
, frame
);
2297 if (value_optimized_out (retval
))
2299 /* This means the register has undefined value / was
2300 not saved. As we're computing the location of some
2301 variable etc. in the program, not a value for
2302 inspecting a register ($pc, $sp, etc.), return a
2303 generic optimized out value instead, so that we show
2304 <optimized out> instead of <not saved>. */
2305 do_cleanups (value_chain
);
2306 retval
= allocate_optimized_out_value (type
);
2311 case DWARF_VALUE_MEMORY
:
2313 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
2314 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
2316 do_cleanups (value_chain
);
2317 retval
= value_at_lazy (type
, address
+ byte_offset
);
2318 if (in_stack_memory
)
2319 set_value_stack (retval
, 1);
2323 case DWARF_VALUE_STACK
:
2325 struct value
*value
= dwarf_expr_fetch (ctx
, 0);
2327 const gdb_byte
*val_bytes
;
2328 size_t n
= TYPE_LENGTH (value_type (value
));
2330 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2331 invalid_synthetic_pointer ();
2333 val_bytes
= value_contents_all (value
);
2334 val_bytes
+= byte_offset
;
2337 /* Preserve VALUE because we are going to free values back
2338 to the mark, but we still need the value contents
2340 value_incref (value
);
2341 do_cleanups (value_chain
);
2342 make_cleanup_value_free (value
);
2344 retval
= allocate_value (type
);
2345 contents
= value_contents_raw (retval
);
2346 if (n
> TYPE_LENGTH (type
))
2348 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2350 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2351 val_bytes
+= n
- TYPE_LENGTH (type
);
2352 n
= TYPE_LENGTH (type
);
2354 memcpy (contents
, val_bytes
, n
);
2358 case DWARF_VALUE_LITERAL
:
2361 const bfd_byte
*ldata
;
2362 size_t n
= ctx
->len
;
2364 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2365 invalid_synthetic_pointer ();
2367 do_cleanups (value_chain
);
2368 retval
= allocate_value (type
);
2369 contents
= value_contents_raw (retval
);
2371 ldata
= ctx
->data
+ byte_offset
;
2374 if (n
> TYPE_LENGTH (type
))
2376 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2378 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2379 ldata
+= n
- TYPE_LENGTH (type
);
2380 n
= TYPE_LENGTH (type
);
2382 memcpy (contents
, ldata
, n
);
2386 case DWARF_VALUE_OPTIMIZED_OUT
:
2387 do_cleanups (value_chain
);
2388 retval
= allocate_optimized_out_value (type
);
2391 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2392 operation by execute_stack_op. */
2393 case DWARF_VALUE_IMPLICIT_POINTER
:
2394 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2395 it can only be encountered when making a piece. */
2397 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2401 set_value_initialized (retval
, ctx
->initialized
);
2403 do_cleanups (old_chain
);
2408 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2409 passes 0 as the byte_offset. */
2412 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2413 const gdb_byte
*data
, size_t size
,
2414 struct dwarf2_per_cu_data
*per_cu
)
2416 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
2420 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2422 struct needs_frame_baton
2425 struct dwarf2_per_cu_data
*per_cu
;
2428 /* Reads from registers do require a frame. */
2430 needs_frame_read_reg (void *baton
, int regnum
)
2432 struct needs_frame_baton
*nf_baton
= baton
;
2434 nf_baton
->needs_frame
= 1;
2438 /* Reads from memory do not require a frame. */
2440 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
2442 memset (buf
, 0, len
);
2445 /* Frame-relative accesses do require a frame. */
2447 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
2449 static gdb_byte lit0
= DW_OP_lit0
;
2450 struct needs_frame_baton
*nf_baton
= baton
;
2455 nf_baton
->needs_frame
= 1;
2458 /* CFA accesses require a frame. */
2461 needs_frame_frame_cfa (void *baton
)
2463 struct needs_frame_baton
*nf_baton
= baton
;
2465 nf_baton
->needs_frame
= 1;
2469 /* Thread-local accesses do require a frame. */
2471 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
2473 struct needs_frame_baton
*nf_baton
= baton
;
2475 nf_baton
->needs_frame
= 1;
2479 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2482 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
2484 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2486 per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
,
2487 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
2490 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2493 needs_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
2494 enum call_site_parameter_kind kind
,
2495 union call_site_parameter_u kind_u
, int deref_size
)
2497 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2499 nf_baton
->needs_frame
= 1;
2501 /* The expression may require some stub values on DWARF stack. */
2502 dwarf_expr_push_address (ctx
, 0, 0);
2505 /* DW_OP_GNU_addr_index doesn't require a frame. */
2508 needs_get_addr_index (void *baton
, unsigned int index
)
2510 /* Nothing to do. */
2514 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2516 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs
=
2518 needs_frame_read_reg
,
2519 needs_frame_read_mem
,
2520 needs_frame_frame_base
,
2521 needs_frame_frame_cfa
,
2522 needs_frame_frame_cfa
, /* get_frame_pc */
2523 needs_frame_tls_address
,
2524 needs_frame_dwarf_call
,
2525 NULL
, /* get_base_type */
2526 needs_dwarf_reg_entry_value
,
2527 needs_get_addr_index
2530 /* Return non-zero iff the location expression at DATA (length SIZE)
2531 requires a frame to evaluate. */
2534 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, size_t size
,
2535 struct dwarf2_per_cu_data
*per_cu
)
2537 struct needs_frame_baton baton
;
2538 struct dwarf_expr_context
*ctx
;
2540 struct cleanup
*old_chain
;
2541 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2543 baton
.needs_frame
= 0;
2544 baton
.per_cu
= per_cu
;
2546 ctx
= new_dwarf_expr_context ();
2547 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2548 make_cleanup_value_free_to_mark (value_mark ());
2550 ctx
->gdbarch
= get_objfile_arch (objfile
);
2551 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2552 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2553 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2554 ctx
->baton
= &baton
;
2555 ctx
->funcs
= &needs_frame_ctx_funcs
;
2557 dwarf_expr_eval (ctx
, data
, size
);
2559 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
2561 if (ctx
->num_pieces
> 0)
2565 /* If the location has several pieces, and any of them are in
2566 registers, then we will need a frame to fetch them from. */
2567 for (i
= 0; i
< ctx
->num_pieces
; i
++)
2568 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2572 do_cleanups (old_chain
);
2574 return baton
.needs_frame
|| in_reg
;
2577 /* A helper function that throws an unimplemented error mentioning a
2578 given DWARF operator. */
2581 unimplemented (unsigned int op
)
2583 const char *name
= get_DW_OP_name (op
);
2586 error (_("DWARF operator %s cannot be translated to an agent expression"),
2589 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2590 "to an agent expression"),
2594 /* A helper function to convert a DWARF register to an arch register.
2595 ARCH is the architecture.
2596 DWARF_REG is the register.
2597 This will throw an exception if the DWARF register cannot be
2598 translated to an architecture register. */
2601 translate_register (struct gdbarch
*arch
, int dwarf_reg
)
2603 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2605 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
2609 /* A helper function that emits an access to memory. ARCH is the
2610 target architecture. EXPR is the expression which we are building.
2611 NBITS is the number of bits we want to read. This emits the
2612 opcodes needed to read the memory and then extract the desired
2616 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2618 ULONGEST nbytes
= (nbits
+ 7) / 8;
2620 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2623 ax_trace_quick (expr
, nbytes
);
2626 ax_simple (expr
, aop_ref8
);
2627 else if (nbits
<= 16)
2628 ax_simple (expr
, aop_ref16
);
2629 else if (nbits
<= 32)
2630 ax_simple (expr
, aop_ref32
);
2632 ax_simple (expr
, aop_ref64
);
2634 /* If we read exactly the number of bytes we wanted, we're done. */
2635 if (8 * nbytes
== nbits
)
2638 if (gdbarch_bits_big_endian (arch
))
2640 /* On a bits-big-endian machine, we want the high-order
2642 ax_const_l (expr
, 8 * nbytes
- nbits
);
2643 ax_simple (expr
, aop_rsh_unsigned
);
2647 /* On a bits-little-endian box, we want the low-order NBITS. */
2648 ax_zero_ext (expr
, nbits
);
2652 /* A helper function to return the frame's PC. */
2655 get_ax_pc (void *baton
)
2657 struct agent_expr
*expr
= baton
;
2662 /* Compile a DWARF location expression to an agent expression.
2664 EXPR is the agent expression we are building.
2665 LOC is the agent value we modify.
2666 ARCH is the architecture.
2667 ADDR_SIZE is the size of addresses, in bytes.
2668 OP_PTR is the start of the location expression.
2669 OP_END is one past the last byte of the location expression.
2671 This will throw an exception for various kinds of errors -- for
2672 example, if the expression cannot be compiled, or if the expression
2676 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2677 struct gdbarch
*arch
, unsigned int addr_size
,
2678 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
2679 struct dwarf2_per_cu_data
*per_cu
)
2681 struct cleanup
*cleanups
;
2683 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
2684 const gdb_byte
* const base
= op_ptr
;
2685 const gdb_byte
*previous_piece
= op_ptr
;
2686 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2687 ULONGEST bits_collected
= 0;
2688 unsigned int addr_size_bits
= 8 * addr_size
;
2689 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
2691 offsets
= xmalloc ((op_end
- op_ptr
) * sizeof (int));
2692 cleanups
= make_cleanup (xfree
, offsets
);
2694 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
2697 make_cleanup (VEC_cleanup (int), &dw_labels
);
2698 make_cleanup (VEC_cleanup (int), &patches
);
2700 /* By default we are making an address. */
2701 loc
->kind
= axs_lvalue_memory
;
2703 while (op_ptr
< op_end
)
2705 enum dwarf_location_atom op
= *op_ptr
;
2706 uint64_t uoffset
, reg
;
2710 offsets
[op_ptr
- base
] = expr
->len
;
2713 /* Our basic approach to code generation is to map DWARF
2714 operations directly to AX operations. However, there are
2717 First, DWARF works on address-sized units, but AX always uses
2718 LONGEST. For most operations we simply ignore this
2719 difference; instead we generate sign extensions as needed
2720 before division and comparison operations. It would be nice
2721 to omit the sign extensions, but there is no way to determine
2722 the size of the target's LONGEST. (This code uses the size
2723 of the host LONGEST in some cases -- that is a bug but it is
2726 Second, some DWARF operations cannot be translated to AX.
2727 For these we simply fail. See
2728 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2763 ax_const_l (expr
, op
- DW_OP_lit0
);
2767 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
2768 op_ptr
+= addr_size
;
2769 /* Some versions of GCC emit DW_OP_addr before
2770 DW_OP_GNU_push_tls_address. In this case the value is an
2771 index, not an address. We don't support things like
2772 branching between the address and the TLS op. */
2773 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
2774 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
2775 ax_const_l (expr
, uoffset
);
2779 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
2783 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
2787 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
2791 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
2795 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
2799 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
2803 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
2807 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
2811 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
2812 ax_const_l (expr
, uoffset
);
2815 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2816 ax_const_l (expr
, offset
);
2851 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2852 loc
->u
.reg
= translate_register (arch
, op
- DW_OP_reg0
);
2853 loc
->kind
= axs_lvalue_register
;
2857 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2858 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2859 loc
->u
.reg
= translate_register (arch
, reg
);
2860 loc
->kind
= axs_lvalue_register
;
2863 case DW_OP_implicit_value
:
2867 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
2868 if (op_ptr
+ len
> op_end
)
2869 error (_("DW_OP_implicit_value: too few bytes available."));
2870 if (len
> sizeof (ULONGEST
))
2871 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
2874 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
2877 dwarf_expr_require_composition (op_ptr
, op_end
,
2878 "DW_OP_implicit_value");
2880 loc
->kind
= axs_rvalue
;
2884 case DW_OP_stack_value
:
2885 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
2886 loc
->kind
= axs_rvalue
;
2921 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2922 i
= translate_register (arch
, op
- DW_OP_breg0
);
2926 ax_const_l (expr
, offset
);
2927 ax_simple (expr
, aop_add
);
2932 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2933 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2934 i
= translate_register (arch
, reg
);
2938 ax_const_l (expr
, offset
);
2939 ax_simple (expr
, aop_add
);
2945 const gdb_byte
*datastart
;
2948 struct symbol
*framefunc
;
2950 b
= block_for_pc (expr
->scope
);
2953 error (_("No block found for address"));
2955 framefunc
= block_linkage_function (b
);
2958 error (_("No function found for block"));
2960 dwarf_expr_frame_base_1 (framefunc
, expr
->scope
,
2961 &datastart
, &datalen
);
2963 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2964 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
2965 datastart
+ datalen
, per_cu
);
2966 if (loc
->kind
== axs_lvalue_register
)
2967 require_rvalue (expr
, loc
);
2971 ax_const_l (expr
, offset
);
2972 ax_simple (expr
, aop_add
);
2975 loc
->kind
= axs_lvalue_memory
;
2980 ax_simple (expr
, aop_dup
);
2984 ax_simple (expr
, aop_pop
);
2989 ax_pick (expr
, offset
);
2993 ax_simple (expr
, aop_swap
);
3001 ax_simple (expr
, aop_rot
);
3005 case DW_OP_deref_size
:
3009 if (op
== DW_OP_deref_size
)
3014 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3015 error (_("Unsupported size %d in %s"),
3016 size
, get_DW_OP_name (op
));
3017 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3022 /* Sign extend the operand. */
3023 ax_ext (expr
, addr_size_bits
);
3024 ax_simple (expr
, aop_dup
);
3025 ax_const_l (expr
, 0);
3026 ax_simple (expr
, aop_less_signed
);
3027 ax_simple (expr
, aop_log_not
);
3028 i
= ax_goto (expr
, aop_if_goto
);
3029 /* We have to emit 0 - X. */
3030 ax_const_l (expr
, 0);
3031 ax_simple (expr
, aop_swap
);
3032 ax_simple (expr
, aop_sub
);
3033 ax_label (expr
, i
, expr
->len
);
3037 /* No need to sign extend here. */
3038 ax_const_l (expr
, 0);
3039 ax_simple (expr
, aop_swap
);
3040 ax_simple (expr
, aop_sub
);
3044 /* Sign extend the operand. */
3045 ax_ext (expr
, addr_size_bits
);
3046 ax_simple (expr
, aop_bit_not
);
3049 case DW_OP_plus_uconst
:
3050 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3051 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3052 but we micro-optimize anyhow. */
3055 ax_const_l (expr
, reg
);
3056 ax_simple (expr
, aop_add
);
3061 ax_simple (expr
, aop_bit_and
);
3065 /* Sign extend the operands. */
3066 ax_ext (expr
, addr_size_bits
);
3067 ax_simple (expr
, aop_swap
);
3068 ax_ext (expr
, addr_size_bits
);
3069 ax_simple (expr
, aop_swap
);
3070 ax_simple (expr
, aop_div_signed
);
3074 ax_simple (expr
, aop_sub
);
3078 ax_simple (expr
, aop_rem_unsigned
);
3082 ax_simple (expr
, aop_mul
);
3086 ax_simple (expr
, aop_bit_or
);
3090 ax_simple (expr
, aop_add
);
3094 ax_simple (expr
, aop_lsh
);
3098 ax_simple (expr
, aop_rsh_unsigned
);
3102 ax_simple (expr
, aop_rsh_signed
);
3106 ax_simple (expr
, aop_bit_xor
);
3110 /* Sign extend the operands. */
3111 ax_ext (expr
, addr_size_bits
);
3112 ax_simple (expr
, aop_swap
);
3113 ax_ext (expr
, addr_size_bits
);
3114 /* Note no swap here: A <= B is !(B < A). */
3115 ax_simple (expr
, aop_less_signed
);
3116 ax_simple (expr
, aop_log_not
);
3120 /* Sign extend the operands. */
3121 ax_ext (expr
, addr_size_bits
);
3122 ax_simple (expr
, aop_swap
);
3123 ax_ext (expr
, addr_size_bits
);
3124 ax_simple (expr
, aop_swap
);
3125 /* A >= B is !(A < B). */
3126 ax_simple (expr
, aop_less_signed
);
3127 ax_simple (expr
, aop_log_not
);
3131 /* Sign extend the operands. */
3132 ax_ext (expr
, addr_size_bits
);
3133 ax_simple (expr
, aop_swap
);
3134 ax_ext (expr
, addr_size_bits
);
3135 /* No need for a second swap here. */
3136 ax_simple (expr
, aop_equal
);
3140 /* Sign extend the operands. */
3141 ax_ext (expr
, addr_size_bits
);
3142 ax_simple (expr
, aop_swap
);
3143 ax_ext (expr
, addr_size_bits
);
3144 ax_simple (expr
, aop_swap
);
3145 ax_simple (expr
, aop_less_signed
);
3149 /* Sign extend the operands. */
3150 ax_ext (expr
, addr_size_bits
);
3151 ax_simple (expr
, aop_swap
);
3152 ax_ext (expr
, addr_size_bits
);
3153 /* Note no swap here: A > B is B < A. */
3154 ax_simple (expr
, aop_less_signed
);
3158 /* Sign extend the operands. */
3159 ax_ext (expr
, addr_size_bits
);
3160 ax_simple (expr
, aop_swap
);
3161 ax_ext (expr
, addr_size_bits
);
3162 /* No need for a swap here. */
3163 ax_simple (expr
, aop_equal
);
3164 ax_simple (expr
, aop_log_not
);
3167 case DW_OP_call_frame_cfa
:
3168 dwarf2_compile_cfa_to_ax (expr
, loc
, arch
, expr
->scope
, per_cu
);
3169 loc
->kind
= axs_lvalue_memory
;
3172 case DW_OP_GNU_push_tls_address
:
3177 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3179 i
= ax_goto (expr
, aop_goto
);
3180 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3181 VEC_safe_push (int, patches
, i
);
3185 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3187 /* Zero extend the operand. */
3188 ax_zero_ext (expr
, addr_size_bits
);
3189 i
= ax_goto (expr
, aop_if_goto
);
3190 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3191 VEC_safe_push (int, patches
, i
);
3198 case DW_OP_bit_piece
:
3200 uint64_t size
, offset
;
3202 if (op_ptr
- 1 == previous_piece
)
3203 error (_("Cannot translate empty pieces to agent expressions"));
3204 previous_piece
= op_ptr
- 1;
3206 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3207 if (op
== DW_OP_piece
)
3213 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
3215 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3216 error (_("Expression pieces exceed word size"));
3218 /* Access the bits. */
3221 case axs_lvalue_register
:
3222 ax_reg (expr
, loc
->u
.reg
);
3225 case axs_lvalue_memory
:
3226 /* Offset the pointer, if needed. */
3229 ax_const_l (expr
, offset
/ 8);
3230 ax_simple (expr
, aop_add
);
3233 access_memory (arch
, expr
, size
);
3237 /* For a bits-big-endian target, shift up what we already
3238 have. For a bits-little-endian target, shift up the
3239 new data. Note that there is a potential bug here if
3240 the DWARF expression leaves multiple values on the
3242 if (bits_collected
> 0)
3244 if (bits_big_endian
)
3246 ax_simple (expr
, aop_swap
);
3247 ax_const_l (expr
, size
);
3248 ax_simple (expr
, aop_lsh
);
3249 /* We don't need a second swap here, because
3250 aop_bit_or is symmetric. */
3254 ax_const_l (expr
, size
);
3255 ax_simple (expr
, aop_lsh
);
3257 ax_simple (expr
, aop_bit_or
);
3260 bits_collected
+= size
;
3261 loc
->kind
= axs_rvalue
;
3265 case DW_OP_GNU_uninit
:
3271 struct dwarf2_locexpr_baton block
;
3272 int size
= (op
== DW_OP_call2
? 2 : 4);
3275 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3278 offset
.cu_off
= uoffset
;
3279 block
= dwarf2_fetch_die_loc_cu_off (offset
, per_cu
,
3282 /* DW_OP_call_ref is currently not supported. */
3283 gdb_assert (block
.per_cu
== per_cu
);
3285 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3286 block
.data
, block
.data
+ block
.size
,
3291 case DW_OP_call_ref
:
3299 /* Patch all the branches we emitted. */
3300 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
3302 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
3304 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3305 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
3308 do_cleanups (cleanups
);
3312 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3313 evaluator to calculate the location. */
3314 static struct value
*
3315 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3317 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3320 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3321 dlbaton
->size
, dlbaton
->per_cu
);
3326 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3327 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3330 static struct value
*
3331 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3333 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3335 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3339 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3341 locexpr_read_needs_frame (struct symbol
*symbol
)
3343 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3345 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
3349 /* Return true if DATA points to the end of a piece. END is one past
3350 the last byte in the expression. */
3353 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3355 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3358 /* Helper for locexpr_describe_location_piece that finds the name of a
3362 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3366 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
3367 return gdbarch_register_name (gdbarch
, regnum
);
3370 /* Nicely describe a single piece of a location, returning an updated
3371 position in the bytecode sequence. This function cannot recognize
3372 all locations; if a location is not recognized, it simply returns
3373 DATA. If there is an error during reading, e.g. we run off the end
3374 of the buffer, an error is thrown. */
3376 static const gdb_byte
*
3377 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3378 CORE_ADDR addr
, struct objfile
*objfile
,
3379 struct dwarf2_per_cu_data
*per_cu
,
3380 const gdb_byte
*data
, const gdb_byte
*end
,
3381 unsigned int addr_size
)
3383 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3386 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3388 fprintf_filtered (stream
, _("a variable in $%s"),
3389 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3392 else if (data
[0] == DW_OP_regx
)
3396 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3397 fprintf_filtered (stream
, _("a variable in $%s"),
3398 locexpr_regname (gdbarch
, reg
));
3400 else if (data
[0] == DW_OP_fbreg
)
3403 struct symbol
*framefunc
;
3405 int64_t frame_offset
;
3406 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3408 int64_t base_offset
= 0;
3410 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3411 if (!piece_end_p (new_data
, end
))
3415 b
= block_for_pc (addr
);
3418 error (_("No block found for address for symbol \"%s\"."),
3419 SYMBOL_PRINT_NAME (symbol
));
3421 framefunc
= block_linkage_function (b
);
3424 error (_("No function found for block for symbol \"%s\"."),
3425 SYMBOL_PRINT_NAME (symbol
));
3427 dwarf_expr_frame_base_1 (framefunc
, addr
, &base_data
, &base_size
);
3429 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3431 const gdb_byte
*buf_end
;
3433 frame_reg
= base_data
[0] - DW_OP_breg0
;
3434 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3436 if (buf_end
!= base_data
+ base_size
)
3437 error (_("Unexpected opcode after "
3438 "DW_OP_breg%u for symbol \"%s\"."),
3439 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3441 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3443 /* The frame base is just the register, with no offset. */
3444 frame_reg
= base_data
[0] - DW_OP_reg0
;
3449 /* We don't know what to do with the frame base expression,
3450 so we can't trace this variable; give up. */
3454 fprintf_filtered (stream
,
3455 _("a variable at frame base reg $%s offset %s+%s"),
3456 locexpr_regname (gdbarch
, frame_reg
),
3457 plongest (base_offset
), plongest (frame_offset
));
3459 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3460 && piece_end_p (data
, end
))
3464 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3466 fprintf_filtered (stream
,
3467 _("a variable at offset %s from base reg $%s"),
3469 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3472 /* The location expression for a TLS variable looks like this (on a
3475 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3476 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3478 0x3 is the encoding for DW_OP_addr, which has an operand as long
3479 as the size of an address on the target machine (here is 8
3480 bytes). Note that more recent version of GCC emit DW_OP_const4u
3481 or DW_OP_const8u, depending on address size, rather than
3482 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3483 The operand represents the offset at which the variable is within
3484 the thread local storage. */
3486 else if (data
+ 1 + addr_size
< end
3487 && (data
[0] == DW_OP_addr
3488 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3489 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3490 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3491 && piece_end_p (data
+ 2 + addr_size
, end
))
3494 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3495 gdbarch_byte_order (gdbarch
));
3497 fprintf_filtered (stream
,
3498 _("a thread-local variable at offset 0x%s "
3499 "in the thread-local storage for `%s'"),
3500 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3502 data
+= 1 + addr_size
+ 1;
3505 /* With -gsplit-dwarf a TLS variable can also look like this:
3506 DW_AT_location : 3 byte block: fc 4 e0
3507 (DW_OP_GNU_const_index: 4;
3508 DW_OP_GNU_push_tls_address) */
3509 else if (data
+ 3 <= end
3510 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3511 && data
[0] == DW_OP_GNU_const_index
3513 && data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3514 && piece_end_p (data
+ 2 + leb128_size
, end
))
3518 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3519 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3520 fprintf_filtered (stream
,
3521 _("a thread-local variable at offset 0x%s "
3522 "in the thread-local storage for `%s'"),
3523 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3527 else if (data
[0] >= DW_OP_lit0
3528 && data
[0] <= DW_OP_lit31
3530 && data
[1] == DW_OP_stack_value
)
3532 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3539 /* Disassemble an expression, stopping at the end of a piece or at the
3540 end of the expression. Returns a pointer to the next unread byte
3541 in the input expression. If ALL is nonzero, then this function
3542 will keep going until it reaches the end of the expression.
3543 If there is an error during reading, e.g. we run off the end
3544 of the buffer, an error is thrown. */
3546 static const gdb_byte
*
3547 disassemble_dwarf_expression (struct ui_file
*stream
,
3548 struct gdbarch
*arch
, unsigned int addr_size
,
3549 int offset_size
, const gdb_byte
*start
,
3550 const gdb_byte
*data
, const gdb_byte
*end
,
3551 int indent
, int all
,
3552 struct dwarf2_per_cu_data
*per_cu
)
3556 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3558 enum dwarf_location_atom op
= *data
++;
3563 name
= get_DW_OP_name (op
);
3566 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3567 op
, (long) (data
- 1 - start
));
3568 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3569 (long) (data
- 1 - start
), name
);
3574 ul
= extract_unsigned_integer (data
, addr_size
,
3575 gdbarch_byte_order (arch
));
3577 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3581 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3583 fprintf_filtered (stream
, " %s", pulongest (ul
));
3586 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3588 fprintf_filtered (stream
, " %s", plongest (l
));
3591 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3593 fprintf_filtered (stream
, " %s", pulongest (ul
));
3596 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3598 fprintf_filtered (stream
, " %s", plongest (l
));
3601 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3603 fprintf_filtered (stream
, " %s", pulongest (ul
));
3606 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3608 fprintf_filtered (stream
, " %s", plongest (l
));
3611 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3613 fprintf_filtered (stream
, " %s", pulongest (ul
));
3616 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3618 fprintf_filtered (stream
, " %s", plongest (l
));
3621 data
= safe_read_uleb128 (data
, end
, &ul
);
3622 fprintf_filtered (stream
, " %s", pulongest (ul
));
3625 data
= safe_read_sleb128 (data
, end
, &l
);
3626 fprintf_filtered (stream
, " %s", plongest (l
));
3661 fprintf_filtered (stream
, " [$%s]",
3662 locexpr_regname (arch
, op
- DW_OP_reg0
));
3666 data
= safe_read_uleb128 (data
, end
, &ul
);
3667 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3668 locexpr_regname (arch
, (int) ul
));
3671 case DW_OP_implicit_value
:
3672 data
= safe_read_uleb128 (data
, end
, &ul
);
3674 fprintf_filtered (stream
, " %s", pulongest (ul
));
3709 data
= safe_read_sleb128 (data
, end
, &l
);
3710 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
3711 locexpr_regname (arch
, op
- DW_OP_breg0
));
3715 data
= safe_read_uleb128 (data
, end
, &ul
);
3716 data
= safe_read_sleb128 (data
, end
, &l
);
3717 fprintf_filtered (stream
, " register %s [$%s] offset %s",
3719 locexpr_regname (arch
, (int) ul
),
3724 data
= safe_read_sleb128 (data
, end
, &l
);
3725 fprintf_filtered (stream
, " %s", plongest (l
));
3728 case DW_OP_xderef_size
:
3729 case DW_OP_deref_size
:
3731 fprintf_filtered (stream
, " %d", *data
);
3735 case DW_OP_plus_uconst
:
3736 data
= safe_read_uleb128 (data
, end
, &ul
);
3737 fprintf_filtered (stream
, " %s", pulongest (ul
));
3741 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3743 fprintf_filtered (stream
, " to %ld",
3744 (long) (data
+ l
- start
));
3748 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3750 fprintf_filtered (stream
, " %ld",
3751 (long) (data
+ l
- start
));
3755 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3757 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
3761 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3763 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3766 case DW_OP_call_ref
:
3767 ul
= extract_unsigned_integer (data
, offset_size
,
3768 gdbarch_byte_order (arch
));
3769 data
+= offset_size
;
3770 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
3774 data
= safe_read_uleb128 (data
, end
, &ul
);
3775 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
3778 case DW_OP_bit_piece
:
3782 data
= safe_read_uleb128 (data
, end
, &ul
);
3783 data
= safe_read_uleb128 (data
, end
, &offset
);
3784 fprintf_filtered (stream
, " size %s offset %s (bits)",
3785 pulongest (ul
), pulongest (offset
));
3789 case DW_OP_GNU_implicit_pointer
:
3791 ul
= extract_unsigned_integer (data
, offset_size
,
3792 gdbarch_byte_order (arch
));
3793 data
+= offset_size
;
3795 data
= safe_read_sleb128 (data
, end
, &l
);
3797 fprintf_filtered (stream
, " DIE %s offset %s",
3798 phex_nz (ul
, offset_size
),
3803 case DW_OP_GNU_deref_type
:
3805 int addr_size
= *data
++;
3809 data
= safe_read_uleb128 (data
, end
, &ul
);
3811 type
= dwarf2_get_die_type (offset
, per_cu
);
3812 fprintf_filtered (stream
, "<");
3813 type_print (type
, "", stream
, -1);
3814 fprintf_filtered (stream
, " [0x%s]> %d", phex_nz (offset
.cu_off
, 0),
3819 case DW_OP_GNU_const_type
:
3824 data
= safe_read_uleb128 (data
, end
, &ul
);
3825 type_die
.cu_off
= ul
;
3826 type
= dwarf2_get_die_type (type_die
, per_cu
);
3827 fprintf_filtered (stream
, "<");
3828 type_print (type
, "", stream
, -1);
3829 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3833 case DW_OP_GNU_regval_type
:
3839 data
= safe_read_uleb128 (data
, end
, ®
);
3840 data
= safe_read_uleb128 (data
, end
, &ul
);
3841 type_die
.cu_off
= ul
;
3843 type
= dwarf2_get_die_type (type_die
, per_cu
);
3844 fprintf_filtered (stream
, "<");
3845 type_print (type
, "", stream
, -1);
3846 fprintf_filtered (stream
, " [0x%s]> [$%s]",
3847 phex_nz (type_die
.cu_off
, 0),
3848 locexpr_regname (arch
, reg
));
3852 case DW_OP_GNU_convert
:
3853 case DW_OP_GNU_reinterpret
:
3857 data
= safe_read_uleb128 (data
, end
, &ul
);
3858 type_die
.cu_off
= ul
;
3860 if (type_die
.cu_off
== 0)
3861 fprintf_filtered (stream
, "<0>");
3866 type
= dwarf2_get_die_type (type_die
, per_cu
);
3867 fprintf_filtered (stream
, "<");
3868 type_print (type
, "", stream
, -1);
3869 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3874 case DW_OP_GNU_entry_value
:
3875 data
= safe_read_uleb128 (data
, end
, &ul
);
3876 fputc_filtered ('\n', stream
);
3877 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
3878 start
, data
, data
+ ul
, indent
+ 2,
3883 case DW_OP_GNU_parameter_ref
:
3884 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3886 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3889 case DW_OP_GNU_addr_index
:
3890 data
= safe_read_uleb128 (data
, end
, &ul
);
3891 ul
= dwarf2_read_addr_index (per_cu
, ul
);
3892 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3894 case DW_OP_GNU_const_index
:
3895 data
= safe_read_uleb128 (data
, end
, &ul
);
3896 ul
= dwarf2_read_addr_index (per_cu
, ul
);
3897 fprintf_filtered (stream
, " %s", pulongest (ul
));
3901 fprintf_filtered (stream
, "\n");
3907 /* Describe a single location, which may in turn consist of multiple
3911 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
3912 struct ui_file
*stream
,
3913 const gdb_byte
*data
, size_t size
,
3914 struct objfile
*objfile
, unsigned int addr_size
,
3915 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
3917 const gdb_byte
*end
= data
+ size
;
3918 int first_piece
= 1, bad
= 0;
3922 const gdb_byte
*here
= data
;
3923 int disassemble
= 1;
3928 fprintf_filtered (stream
, _(", and "));
3930 if (!dwarf2_always_disassemble
)
3932 data
= locexpr_describe_location_piece (symbol
, stream
,
3933 addr
, objfile
, per_cu
,
3934 data
, end
, addr_size
);
3935 /* If we printed anything, or if we have an empty piece,
3936 then don't disassemble. */
3938 || data
[0] == DW_OP_piece
3939 || data
[0] == DW_OP_bit_piece
)
3944 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
3945 data
= disassemble_dwarf_expression (stream
,
3946 get_objfile_arch (objfile
),
3947 addr_size
, offset_size
, data
,
3949 dwarf2_always_disassemble
,
3955 int empty
= data
== here
;
3958 fprintf_filtered (stream
, " ");
3959 if (data
[0] == DW_OP_piece
)
3963 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
3966 fprintf_filtered (stream
, _("an empty %s-byte piece"),
3969 fprintf_filtered (stream
, _(" [%s-byte piece]"),
3972 else if (data
[0] == DW_OP_bit_piece
)
3974 uint64_t bits
, offset
;
3976 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
3977 data
= safe_read_uleb128 (data
, end
, &offset
);
3980 fprintf_filtered (stream
,
3981 _("an empty %s-bit piece"),
3984 fprintf_filtered (stream
,
3985 _(" [%s-bit piece, offset %s bits]"),
3986 pulongest (bits
), pulongest (offset
));
3996 if (bad
|| data
> end
)
3997 error (_("Corrupted DWARF2 expression for \"%s\"."),
3998 SYMBOL_PRINT_NAME (symbol
));
4001 /* Print a natural-language description of SYMBOL to STREAM. This
4002 version is for a symbol with a single location. */
4005 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4006 struct ui_file
*stream
)
4008 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4009 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4010 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4011 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4013 locexpr_describe_location_1 (symbol
, addr
, stream
,
4014 dlbaton
->data
, dlbaton
->size
,
4015 objfile
, addr_size
, offset_size
,
4019 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4020 any necessary bytecode in AX. */
4023 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4024 struct agent_expr
*ax
, struct axs_value
*value
)
4026 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4027 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4029 if (dlbaton
->size
== 0)
4030 value
->optimized_out
= 1;
4032 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
4033 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4037 /* The set of location functions used with the DWARF-2 expression
4039 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4040 locexpr_read_variable
,
4041 locexpr_read_variable_at_entry
,
4042 locexpr_read_needs_frame
,
4043 locexpr_describe_location
,
4044 0, /* location_has_loclist */
4045 locexpr_tracepoint_var_ref
4049 /* Wrapper functions for location lists. These generally find
4050 the appropriate location expression and call something above. */
4052 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4053 evaluator to calculate the location. */
4054 static struct value
*
4055 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4057 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4059 const gdb_byte
*data
;
4061 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4063 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4064 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4070 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4071 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4074 Function always returns non-NULL value, it may be marked optimized out if
4075 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4076 if it cannot resolve the parameter for any reason. */
4078 static struct value
*
4079 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4081 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4082 const gdb_byte
*data
;
4086 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4087 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4089 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4091 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4093 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4096 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
4098 loclist_read_needs_frame (struct symbol
*symbol
)
4100 /* If there's a location list, then assume we need to have a frame
4101 to choose the appropriate location expression. With tracking of
4102 global variables this is not necessarily true, but such tracking
4103 is disabled in GCC at the moment until we figure out how to
4109 /* Print a natural-language description of SYMBOL to STREAM. This
4110 version applies when there is a list of different locations, each
4111 with a specified address range. */
4114 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4115 struct ui_file
*stream
)
4117 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4118 const gdb_byte
*loc_ptr
, *buf_end
;
4119 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4120 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4121 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4122 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4123 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4124 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4125 /* Adjust base_address for relocatable objects. */
4126 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4127 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4130 loc_ptr
= dlbaton
->data
;
4131 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4133 fprintf_filtered (stream
, _("multi-location:\n"));
4135 /* Iterate through locations until we run out. */
4138 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4140 enum debug_loc_kind kind
;
4141 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4143 if (dlbaton
->from_dwo
)
4144 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4145 loc_ptr
, buf_end
, &new_ptr
,
4146 &low
, &high
, byte_order
);
4148 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4150 byte_order
, addr_size
,
4155 case DEBUG_LOC_END_OF_LIST
:
4158 case DEBUG_LOC_BASE_ADDRESS
:
4159 base_address
= high
+ base_offset
;
4160 fprintf_filtered (stream
, _(" Base address %s"),
4161 paddress (gdbarch
, base_address
));
4163 case DEBUG_LOC_START_END
:
4164 case DEBUG_LOC_START_LENGTH
:
4166 case DEBUG_LOC_BUFFER_OVERFLOW
:
4167 case DEBUG_LOC_INVALID_ENTRY
:
4168 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4169 SYMBOL_PRINT_NAME (symbol
));
4171 gdb_assert_not_reached ("bad debug_loc_kind");
4174 /* Otherwise, a location expression entry. */
4175 low
+= base_address
;
4176 high
+= base_address
;
4178 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4181 /* (It would improve readability to print only the minimum
4182 necessary digits of the second number of the range.) */
4183 fprintf_filtered (stream
, _(" Range %s-%s: "),
4184 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4186 /* Now describe this particular location. */
4187 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4188 objfile
, addr_size
, offset_size
,
4191 fprintf_filtered (stream
, "\n");
4197 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4198 any necessary bytecode in AX. */
4200 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4201 struct agent_expr
*ax
, struct axs_value
*value
)
4203 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4204 const gdb_byte
*data
;
4206 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4208 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4210 value
->optimized_out
= 1;
4212 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
4216 /* The set of location functions used with the DWARF-2 expression
4217 evaluator and location lists. */
4218 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4219 loclist_read_variable
,
4220 loclist_read_variable_at_entry
,
4221 loclist_read_needs_frame
,
4222 loclist_describe_location
,
4223 1, /* location_has_loclist */
4224 loclist_tracepoint_var_ref
4227 /* Provide a prototype to silence -Wmissing-prototypes. */
4228 extern initialize_file_ftype _initialize_dwarf2loc
;
4231 _initialize_dwarf2loc (void)
4233 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4234 &entry_values_debug
,
4235 _("Set entry values and tail call frames "
4237 _("Show entry values and tail call frames "
4239 _("When non-zero, the process of determining "
4240 "parameter values from function entry point "
4241 "and tail call frames will be printed."),
4243 show_entry_values_debug
,
4244 &setdebuglist
, &showdebuglist
);