1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003-2014 Free Software Foundation, Inc.
5 Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
37 #include "dwarf2expr.h"
38 #include "dwarf2loc.h"
39 #include "dwarf2-frame.h"
41 extern int dwarf2_always_disassemble
;
43 static void dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
44 const gdb_byte
**start
, size_t *length
);
46 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
;
48 static struct value
*dwarf2_evaluate_loc_desc_full (struct type
*type
,
49 struct frame_info
*frame
,
52 struct dwarf2_per_cu_data
*per_cu
,
55 /* Until these have formal names, we define these here.
56 ref: http://gcc.gnu.org/wiki/DebugFission
57 Each entry in .debug_loc.dwo begins with a byte that describes the entry,
58 and is then followed by data specific to that entry. */
62 /* Indicates the end of the list of entries. */
63 DEBUG_LOC_END_OF_LIST
= 0,
65 /* This is followed by an unsigned LEB128 number that is an index into
66 .debug_addr and specifies the base address for all following entries. */
67 DEBUG_LOC_BASE_ADDRESS
= 1,
69 /* This is followed by two unsigned LEB128 numbers that are indices into
70 .debug_addr and specify the beginning and ending addresses, and then
71 a normal location expression as in .debug_loc. */
72 DEBUG_LOC_START_END
= 2,
74 /* This is followed by an unsigned LEB128 number that is an index into
75 .debug_addr and specifies the beginning address, and a 4 byte unsigned
76 number that specifies the length, and then a normal location expression
78 DEBUG_LOC_START_LENGTH
= 3,
80 /* An internal value indicating there is insufficient data. */
81 DEBUG_LOC_BUFFER_OVERFLOW
= -1,
83 /* An internal value indicating an invalid kind of entry was found. */
84 DEBUG_LOC_INVALID_ENTRY
= -2
87 /* Helper function which throws an error if a synthetic pointer is
91 invalid_synthetic_pointer (void)
93 error (_("access outside bounds of object "
94 "referenced via synthetic pointer"));
97 /* Decode the addresses in a non-dwo .debug_loc entry.
98 A pointer to the next byte to examine is returned in *NEW_PTR.
99 The encoded low,high addresses are return in *LOW,*HIGH.
100 The result indicates the kind of entry found. */
102 static enum debug_loc_kind
103 decode_debug_loc_addresses (const gdb_byte
*loc_ptr
, const gdb_byte
*buf_end
,
104 const gdb_byte
**new_ptr
,
105 CORE_ADDR
*low
, CORE_ADDR
*high
,
106 enum bfd_endian byte_order
,
107 unsigned int addr_size
,
110 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
112 if (buf_end
- loc_ptr
< 2 * addr_size
)
113 return DEBUG_LOC_BUFFER_OVERFLOW
;
116 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
118 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
119 loc_ptr
+= addr_size
;
122 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
124 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
125 loc_ptr
+= addr_size
;
129 /* A base-address-selection entry. */
130 if ((*low
& base_mask
) == base_mask
)
131 return DEBUG_LOC_BASE_ADDRESS
;
133 /* An end-of-list entry. */
134 if (*low
== 0 && *high
== 0)
135 return DEBUG_LOC_END_OF_LIST
;
137 return DEBUG_LOC_START_END
;
140 /* Decode the addresses in .debug_loc.dwo entry.
141 A pointer to the next byte to examine is returned in *NEW_PTR.
142 The encoded low,high addresses are return in *LOW,*HIGH.
143 The result indicates the kind of entry found. */
145 static enum debug_loc_kind
146 decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data
*per_cu
,
147 const gdb_byte
*loc_ptr
,
148 const gdb_byte
*buf_end
,
149 const gdb_byte
**new_ptr
,
150 CORE_ADDR
*low
, CORE_ADDR
*high
,
151 enum bfd_endian byte_order
)
153 uint64_t low_index
, high_index
;
155 if (loc_ptr
== buf_end
)
156 return DEBUG_LOC_BUFFER_OVERFLOW
;
160 case DEBUG_LOC_END_OF_LIST
:
162 return DEBUG_LOC_END_OF_LIST
;
163 case DEBUG_LOC_BASE_ADDRESS
:
165 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
167 return DEBUG_LOC_BUFFER_OVERFLOW
;
168 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
170 return DEBUG_LOC_BASE_ADDRESS
;
171 case DEBUG_LOC_START_END
:
172 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
174 return DEBUG_LOC_BUFFER_OVERFLOW
;
175 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
176 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
178 return DEBUG_LOC_BUFFER_OVERFLOW
;
179 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
181 return DEBUG_LOC_START_END
;
182 case DEBUG_LOC_START_LENGTH
:
183 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
185 return DEBUG_LOC_BUFFER_OVERFLOW
;
186 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
187 if (loc_ptr
+ 4 > buf_end
)
188 return DEBUG_LOC_BUFFER_OVERFLOW
;
190 *high
+= extract_unsigned_integer (loc_ptr
, 4, byte_order
);
191 *new_ptr
= loc_ptr
+ 4;
192 return DEBUG_LOC_START_LENGTH
;
194 return DEBUG_LOC_INVALID_ENTRY
;
198 /* A function for dealing with location lists. Given a
199 symbol baton (BATON) and a pc value (PC), find the appropriate
200 location expression, set *LOCEXPR_LENGTH, and return a pointer
201 to the beginning of the expression. Returns NULL on failure.
203 For now, only return the first matching location expression; there
204 can be more than one in the list. */
207 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
208 size_t *locexpr_length
, CORE_ADDR pc
)
210 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
211 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
212 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
213 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
214 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
215 /* Adjust base_address for relocatable objects. */
216 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (baton
->per_cu
);
217 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
218 const gdb_byte
*loc_ptr
, *buf_end
;
220 loc_ptr
= baton
->data
;
221 buf_end
= baton
->data
+ baton
->size
;
225 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
227 enum debug_loc_kind kind
;
228 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
231 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
232 loc_ptr
, buf_end
, &new_ptr
,
233 &low
, &high
, byte_order
);
235 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
237 byte_order
, addr_size
,
242 case DEBUG_LOC_END_OF_LIST
:
245 case DEBUG_LOC_BASE_ADDRESS
:
246 base_address
= high
+ base_offset
;
248 case DEBUG_LOC_START_END
:
249 case DEBUG_LOC_START_LENGTH
:
251 case DEBUG_LOC_BUFFER_OVERFLOW
:
252 case DEBUG_LOC_INVALID_ENTRY
:
253 error (_("dwarf2_find_location_expression: "
254 "Corrupted DWARF expression."));
256 gdb_assert_not_reached ("bad debug_loc_kind");
259 /* Otherwise, a location expression entry.
260 If the entry is from a DWO, don't add base address: the entry is
261 from .debug_addr which has absolute addresses. */
262 if (! baton
->from_dwo
)
265 high
+= base_address
;
268 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
271 if (low
== high
&& pc
== low
)
273 /* This is entry PC record present only at entry point
274 of a function. Verify it is really the function entry point. */
276 const struct block
*pc_block
= block_for_pc (pc
);
277 struct symbol
*pc_func
= NULL
;
280 pc_func
= block_linkage_function (pc_block
);
282 if (pc_func
&& pc
== BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func
)))
284 *locexpr_length
= length
;
289 if (pc
>= low
&& pc
< high
)
291 *locexpr_length
= length
;
299 /* This is the baton used when performing dwarf2 expression
301 struct dwarf_expr_baton
303 struct frame_info
*frame
;
304 struct dwarf2_per_cu_data
*per_cu
;
305 CORE_ADDR obj_address
;
308 /* Helper functions for dwarf2_evaluate_loc_desc. */
310 /* Using the frame specified in BATON, return the value of register
311 REGNUM, treated as a pointer. */
313 dwarf_expr_read_addr_from_reg (void *baton
, int dwarf_regnum
)
315 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
316 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
317 int regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
319 return address_from_register (regnum
, debaton
->frame
);
322 /* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback. */
324 static struct value
*
325 dwarf_expr_get_reg_value (void *baton
, struct type
*type
, int dwarf_regnum
)
327 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
328 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
329 int regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
331 return value_from_register (type
, regnum
, debaton
->frame
);
334 /* Read memory at ADDR (length LEN) into BUF. */
337 dwarf_expr_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
339 read_memory (addr
, buf
, len
);
342 /* Using the frame specified in BATON, find the location expression
343 describing the frame base. Return a pointer to it in START and
344 its length in LENGTH. */
346 dwarf_expr_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
348 /* FIXME: cagney/2003-03-26: This code should be using
349 get_frame_base_address(), and then implement a dwarf2 specific
351 struct symbol
*framefunc
;
352 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
353 const struct block
*bl
= get_frame_block (debaton
->frame
, NULL
);
356 error (_("frame address is not available."));
358 /* Use block_linkage_function, which returns a real (not inlined)
359 function, instead of get_frame_function, which may return an
361 framefunc
= block_linkage_function (bl
);
363 /* If we found a frame-relative symbol then it was certainly within
364 some function associated with a frame. If we can't find the frame,
365 something has gone wrong. */
366 gdb_assert (framefunc
!= NULL
);
368 dwarf_expr_frame_base_1 (framefunc
,
369 get_frame_address_in_block (debaton
->frame
),
373 /* Implement find_frame_base_location method for LOC_BLOCK functions using
374 DWARF expression for its DW_AT_frame_base. */
377 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
378 const gdb_byte
**start
, size_t *length
)
380 struct dwarf2_locexpr_baton
*symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
382 *length
= symbaton
->size
;
383 *start
= symbaton
->data
;
386 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
387 function uses DWARF expression for its DW_AT_frame_base. */
389 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
391 locexpr_find_frame_base_location
394 /* Implement find_frame_base_location method for LOC_BLOCK functions using
395 DWARF location list for its DW_AT_frame_base. */
398 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
399 const gdb_byte
**start
, size_t *length
)
401 struct dwarf2_loclist_baton
*symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
403 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
406 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
407 function uses DWARF location list for its DW_AT_frame_base. */
409 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
411 loclist_find_frame_base_location
415 dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
416 const gdb_byte
**start
, size_t *length
)
418 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
420 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
422 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
428 error (_("Could not find the frame base for \"%s\"."),
429 SYMBOL_NATURAL_NAME (framefunc
));
432 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
433 the frame in BATON. */
436 dwarf_expr_frame_cfa (void *baton
)
438 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
440 return dwarf2_frame_cfa (debaton
->frame
);
443 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
444 the frame in BATON. */
447 dwarf_expr_frame_pc (void *baton
)
449 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
451 return get_frame_address_in_block (debaton
->frame
);
454 /* Using the objfile specified in BATON, find the address for the
455 current thread's thread-local storage with offset OFFSET. */
457 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
459 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
460 struct objfile
*objfile
= dwarf2_per_cu_objfile (debaton
->per_cu
);
462 return target_translate_tls_address (objfile
, offset
);
465 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
466 current CU (as is PER_CU). State of the CTX is not affected by the
470 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
471 struct dwarf2_per_cu_data
*per_cu
,
472 CORE_ADDR (*get_frame_pc
) (void *baton
),
475 struct dwarf2_locexpr_baton block
;
477 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
, get_frame_pc
, baton
);
479 /* DW_OP_call_ref is currently not supported. */
480 gdb_assert (block
.per_cu
== per_cu
);
482 dwarf_expr_eval (ctx
, block
.data
, block
.size
);
485 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
488 dwarf_expr_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
490 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
492 per_cu_dwarf_call (ctx
, die_offset
, debaton
->per_cu
,
493 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
496 /* Callback function for dwarf2_evaluate_loc_desc. */
499 dwarf_expr_get_base_type (struct dwarf_expr_context
*ctx
,
500 cu_offset die_offset
)
502 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
504 return dwarf2_get_die_type (die_offset
, debaton
->per_cu
);
507 /* See dwarf2loc.h. */
509 unsigned int entry_values_debug
= 0;
511 /* Helper to set entry_values_debug. */
514 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
515 struct cmd_list_element
*c
, const char *value
)
517 fprintf_filtered (file
,
518 _("Entry values and tail call frames debugging is %s.\n"),
522 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
523 CALLER_FRAME (for registers) can be NULL if it is not known. This function
524 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
527 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
528 struct call_site
*call_site
,
529 struct frame_info
*caller_frame
)
531 switch (FIELD_LOC_KIND (call_site
->target
))
533 case FIELD_LOC_KIND_DWARF_BLOCK
:
535 struct dwarf2_locexpr_baton
*dwarf_block
;
537 struct type
*caller_core_addr_type
;
538 struct gdbarch
*caller_arch
;
540 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
541 if (dwarf_block
== NULL
)
543 struct bound_minimal_symbol msym
;
545 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
546 throw_error (NO_ENTRY_VALUE_ERROR
,
547 _("DW_AT_GNU_call_site_target is not specified "
549 paddress (call_site_gdbarch
, call_site
->pc
),
550 (msym
.minsym
== NULL
? "???"
551 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
554 if (caller_frame
== NULL
)
556 struct bound_minimal_symbol msym
;
558 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
559 throw_error (NO_ENTRY_VALUE_ERROR
,
560 _("DW_AT_GNU_call_site_target DWARF block resolving "
561 "requires known frame which is currently not "
562 "available at %s in %s"),
563 paddress (call_site_gdbarch
, call_site
->pc
),
564 (msym
.minsym
== NULL
? "???"
565 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
568 caller_arch
= get_frame_arch (caller_frame
);
569 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
570 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
571 dwarf_block
->data
, dwarf_block
->size
,
572 dwarf_block
->per_cu
);
573 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
575 if (VALUE_LVAL (val
) == lval_memory
)
576 return value_address (val
);
578 return value_as_address (val
);
581 case FIELD_LOC_KIND_PHYSNAME
:
583 const char *physname
;
584 struct bound_minimal_symbol msym
;
586 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
588 /* Handle both the mangled and demangled PHYSNAME. */
589 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
590 if (msym
.minsym
== NULL
)
592 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
593 throw_error (NO_ENTRY_VALUE_ERROR
,
594 _("Cannot find function \"%s\" for a call site target "
596 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
597 (msym
.minsym
== NULL
? "???"
598 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
601 return BMSYMBOL_VALUE_ADDRESS (msym
);
604 case FIELD_LOC_KIND_PHYSADDR
:
605 return FIELD_STATIC_PHYSADDR (call_site
->target
);
608 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
612 /* Convert function entry point exact address ADDR to the function which is
613 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
614 NO_ENTRY_VALUE_ERROR otherwise. */
616 static struct symbol
*
617 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
619 struct symbol
*sym
= find_pc_function (addr
);
622 if (sym
== NULL
|| BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
623 throw_error (NO_ENTRY_VALUE_ERROR
,
624 _("DW_TAG_GNU_call_site resolving failed to find function "
625 "name for address %s"),
626 paddress (gdbarch
, addr
));
628 type
= SYMBOL_TYPE (sym
);
629 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
630 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
635 /* Verify function with entry point exact address ADDR can never call itself
636 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
637 can call itself via tail calls.
639 If a funtion can tail call itself its entry value based parameters are
640 unreliable. There is no verification whether the value of some/all
641 parameters is unchanged through the self tail call, we expect if there is
642 a self tail call all the parameters can be modified. */
645 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
647 struct obstack addr_obstack
;
648 struct cleanup
*old_chain
;
651 /* Track here CORE_ADDRs which were already visited. */
654 /* The verification is completely unordered. Track here function addresses
655 which still need to be iterated. */
656 VEC (CORE_ADDR
) *todo
= NULL
;
658 obstack_init (&addr_obstack
);
659 old_chain
= make_cleanup_obstack_free (&addr_obstack
);
660 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
661 &addr_obstack
, hashtab_obstack_allocate
,
663 make_cleanup_htab_delete (addr_hash
);
665 make_cleanup (VEC_cleanup (CORE_ADDR
), &todo
);
667 VEC_safe_push (CORE_ADDR
, todo
, verify_addr
);
668 while (!VEC_empty (CORE_ADDR
, todo
))
670 struct symbol
*func_sym
;
671 struct call_site
*call_site
;
673 addr
= VEC_pop (CORE_ADDR
, todo
);
675 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
677 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
678 call_site
; call_site
= call_site
->tail_call_next
)
680 CORE_ADDR target_addr
;
683 /* CALLER_FRAME with registers is not available for tail-call jumped
685 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
687 if (target_addr
== verify_addr
)
689 struct bound_minimal_symbol msym
;
691 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
692 throw_error (NO_ENTRY_VALUE_ERROR
,
693 _("DW_OP_GNU_entry_value resolving has found "
694 "function \"%s\" at %s can call itself via tail "
696 (msym
.minsym
== NULL
? "???"
697 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
698 paddress (gdbarch
, verify_addr
));
701 slot
= htab_find_slot (addr_hash
, &target_addr
, INSERT
);
704 *slot
= obstack_copy (&addr_obstack
, &target_addr
,
705 sizeof (target_addr
));
706 VEC_safe_push (CORE_ADDR
, todo
, target_addr
);
711 do_cleanups (old_chain
);
714 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
715 ENTRY_VALUES_DEBUG. */
718 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
720 CORE_ADDR addr
= call_site
->pc
;
721 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
723 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
724 (msym
.minsym
== NULL
? "???"
725 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
729 /* vec.h needs single word type name, typedef it. */
730 typedef struct call_site
*call_sitep
;
732 /* Define VEC (call_sitep) functions. */
733 DEF_VEC_P (call_sitep
);
735 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
736 only top callers and bottom callees which are present in both. GDBARCH is
737 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
738 no remaining possibilities to provide unambiguous non-trivial result.
739 RESULTP should point to NULL on the first (initialization) call. Caller is
740 responsible for xfree of any RESULTP data. */
743 chain_candidate (struct gdbarch
*gdbarch
, struct call_site_chain
**resultp
,
744 VEC (call_sitep
) *chain
)
746 struct call_site_chain
*result
= *resultp
;
747 long length
= VEC_length (call_sitep
, chain
);
748 int callers
, callees
, idx
;
752 /* Create the initial chain containing all the passed PCs. */
754 result
= xmalloc (sizeof (*result
) + sizeof (*result
->call_site
)
756 result
->length
= length
;
757 result
->callers
= result
->callees
= length
;
758 if (!VEC_empty (call_sitep
, chain
))
759 memcpy (result
->call_site
, VEC_address (call_sitep
, chain
),
760 sizeof (*result
->call_site
) * length
);
763 if (entry_values_debug
)
765 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
766 for (idx
= 0; idx
< length
; idx
++)
767 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
768 fputc_unfiltered ('\n', gdb_stdlog
);
774 if (entry_values_debug
)
776 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
777 for (idx
= 0; idx
< length
; idx
++)
778 tailcall_dump (gdbarch
, VEC_index (call_sitep
, chain
, idx
));
779 fputc_unfiltered ('\n', gdb_stdlog
);
782 /* Intersect callers. */
784 callers
= min (result
->callers
, length
);
785 for (idx
= 0; idx
< callers
; idx
++)
786 if (result
->call_site
[idx
] != VEC_index (call_sitep
, chain
, idx
))
788 result
->callers
= idx
;
792 /* Intersect callees. */
794 callees
= min (result
->callees
, length
);
795 for (idx
= 0; idx
< callees
; idx
++)
796 if (result
->call_site
[result
->length
- 1 - idx
]
797 != VEC_index (call_sitep
, chain
, length
- 1 - idx
))
799 result
->callees
= idx
;
803 if (entry_values_debug
)
805 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
806 for (idx
= 0; idx
< result
->callers
; idx
++)
807 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
808 fputs_unfiltered (" |", gdb_stdlog
);
809 for (idx
= 0; idx
< result
->callees
; idx
++)
810 tailcall_dump (gdbarch
, result
->call_site
[result
->length
811 - result
->callees
+ idx
]);
812 fputc_unfiltered ('\n', gdb_stdlog
);
815 if (result
->callers
== 0 && result
->callees
== 0)
817 /* There are no common callers or callees. It could be also a direct
818 call (which has length 0) with ambiguous possibility of an indirect
819 call - CALLERS == CALLEES == 0 is valid during the first allocation
820 but any subsequence processing of such entry means ambiguity. */
826 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
827 PC again. In such case there must be two different code paths to reach
828 it, therefore some of the former determined intermediate PCs must differ
829 and the unambiguous chain gets shortened. */
830 gdb_assert (result
->callers
+ result
->callees
< result
->length
);
833 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
834 assumed frames between them use GDBARCH. Use depth first search so we can
835 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
836 would have needless GDB stack overhead. Caller is responsible for xfree of
837 the returned result. Any unreliability results in thrown
838 NO_ENTRY_VALUE_ERROR. */
840 static struct call_site_chain
*
841 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
844 CORE_ADDR save_callee_pc
= callee_pc
;
845 struct obstack addr_obstack
;
846 struct cleanup
*back_to_retval
, *back_to_workdata
;
847 struct call_site_chain
*retval
= NULL
;
848 struct call_site
*call_site
;
850 /* Mark CALL_SITEs so we do not visit the same ones twice. */
853 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
854 call_site nor any possible call_site at CALLEE_PC's function is there.
855 Any CALL_SITE in CHAIN will be iterated to its siblings - via
856 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
857 VEC (call_sitep
) *chain
= NULL
;
859 /* We are not interested in the specific PC inside the callee function. */
860 callee_pc
= get_pc_function_start (callee_pc
);
862 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
863 paddress (gdbarch
, save_callee_pc
));
865 back_to_retval
= make_cleanup (free_current_contents
, &retval
);
867 obstack_init (&addr_obstack
);
868 back_to_workdata
= make_cleanup_obstack_free (&addr_obstack
);
869 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
870 &addr_obstack
, hashtab_obstack_allocate
,
872 make_cleanup_htab_delete (addr_hash
);
874 make_cleanup (VEC_cleanup (call_sitep
), &chain
);
876 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
877 at the target's function. All the possible tail call sites in the
878 target's function will get iterated as already pushed into CHAIN via their
880 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
884 CORE_ADDR target_func_addr
;
885 struct call_site
*target_call_site
;
887 /* CALLER_FRAME with registers is not available for tail-call jumped
889 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
891 if (target_func_addr
== callee_pc
)
893 chain_candidate (gdbarch
, &retval
, chain
);
897 /* There is no way to reach CALLEE_PC again as we would prevent
898 entering it twice as being already marked in ADDR_HASH. */
899 target_call_site
= NULL
;
903 struct symbol
*target_func
;
905 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
906 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
911 /* Attempt to visit TARGET_CALL_SITE. */
913 if (target_call_site
)
917 slot
= htab_find_slot (addr_hash
, &target_call_site
->pc
, INSERT
);
920 /* Successfully entered TARGET_CALL_SITE. */
922 *slot
= &target_call_site
->pc
;
923 VEC_safe_push (call_sitep
, chain
, target_call_site
);
928 /* Backtrack (without revisiting the originating call_site). Try the
929 callers's sibling; if there isn't any try the callers's callers's
932 target_call_site
= NULL
;
933 while (!VEC_empty (call_sitep
, chain
))
935 call_site
= VEC_pop (call_sitep
, chain
);
937 gdb_assert (htab_find_slot (addr_hash
, &call_site
->pc
,
939 htab_remove_elt (addr_hash
, &call_site
->pc
);
941 target_call_site
= call_site
->tail_call_next
;
942 if (target_call_site
)
946 while (target_call_site
);
948 if (VEC_empty (call_sitep
, chain
))
951 call_site
= VEC_last (call_sitep
, chain
);
956 struct bound_minimal_symbol msym_caller
, msym_callee
;
958 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
959 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
960 throw_error (NO_ENTRY_VALUE_ERROR
,
961 _("There are no unambiguously determinable intermediate "
962 "callers or callees between caller function \"%s\" at %s "
963 "and callee function \"%s\" at %s"),
964 (msym_caller
.minsym
== NULL
965 ? "???" : MSYMBOL_PRINT_NAME (msym_caller
.minsym
)),
966 paddress (gdbarch
, caller_pc
),
967 (msym_callee
.minsym
== NULL
968 ? "???" : MSYMBOL_PRINT_NAME (msym_callee
.minsym
)),
969 paddress (gdbarch
, callee_pc
));
972 do_cleanups (back_to_workdata
);
973 discard_cleanups (back_to_retval
);
977 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
978 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
979 constructed return NULL. Caller is responsible for xfree of the returned
982 struct call_site_chain
*
983 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
986 volatile struct gdb_exception e
;
987 struct call_site_chain
*retval
= NULL
;
989 TRY_CATCH (e
, RETURN_MASK_ERROR
)
991 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
995 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
997 if (entry_values_debug
)
998 exception_print (gdb_stdout
, e
);
1003 throw_exception (e
);
1008 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1011 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1012 enum call_site_parameter_kind kind
,
1013 union call_site_parameter_u kind_u
)
1015 if (kind
== parameter
->kind
)
1018 case CALL_SITE_PARAMETER_DWARF_REG
:
1019 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1020 case CALL_SITE_PARAMETER_FB_OFFSET
:
1021 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1022 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1023 return kind_u
.param_offset
.cu_off
== parameter
->u
.param_offset
.cu_off
;
1028 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1029 FRAME is for callee.
1031 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1034 static struct call_site_parameter
*
1035 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1036 enum call_site_parameter_kind kind
,
1037 union call_site_parameter_u kind_u
,
1038 struct dwarf2_per_cu_data
**per_cu_return
)
1040 CORE_ADDR func_addr
, caller_pc
;
1041 struct gdbarch
*gdbarch
;
1042 struct frame_info
*caller_frame
;
1043 struct call_site
*call_site
;
1045 /* Initialize it just to avoid a GCC false warning. */
1046 struct call_site_parameter
*parameter
= NULL
;
1047 CORE_ADDR target_addr
;
1049 while (get_frame_type (frame
) == INLINE_FRAME
)
1051 frame
= get_prev_frame (frame
);
1052 gdb_assert (frame
!= NULL
);
1055 func_addr
= get_frame_func (frame
);
1056 gdbarch
= get_frame_arch (frame
);
1057 caller_frame
= get_prev_frame (frame
);
1058 if (gdbarch
!= frame_unwind_arch (frame
))
1060 struct bound_minimal_symbol msym
1061 = lookup_minimal_symbol_by_pc (func_addr
);
1062 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1064 throw_error (NO_ENTRY_VALUE_ERROR
,
1065 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1066 "(of %s (%s)) does not match caller gdbarch %s"),
1067 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1068 paddress (gdbarch
, func_addr
),
1069 (msym
.minsym
== NULL
? "???"
1070 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
1071 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1074 if (caller_frame
== NULL
)
1076 struct bound_minimal_symbol msym
1077 = lookup_minimal_symbol_by_pc (func_addr
);
1079 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_GNU_entry_value resolving "
1080 "requires caller of %s (%s)"),
1081 paddress (gdbarch
, func_addr
),
1082 (msym
.minsym
== NULL
? "???"
1083 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
1085 caller_pc
= get_frame_pc (caller_frame
);
1086 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1088 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1089 if (target_addr
!= func_addr
)
1091 struct minimal_symbol
*target_msym
, *func_msym
;
1093 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1094 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1095 throw_error (NO_ENTRY_VALUE_ERROR
,
1096 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1097 "but the called frame is for %s at %s"),
1098 (target_msym
== NULL
? "???"
1099 : MSYMBOL_PRINT_NAME (target_msym
)),
1100 paddress (gdbarch
, target_addr
),
1101 func_msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (func_msym
),
1102 paddress (gdbarch
, func_addr
));
1105 /* No entry value based parameters would be reliable if this function can
1106 call itself via tail calls. */
1107 func_verify_no_selftailcall (gdbarch
, func_addr
);
1109 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1111 parameter
= &call_site
->parameter
[iparams
];
1112 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1115 if (iparams
== call_site
->parameter_count
)
1117 struct minimal_symbol
*msym
1118 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1120 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1121 determine its value. */
1122 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1123 "at DW_TAG_GNU_call_site %s at %s"),
1124 paddress (gdbarch
, caller_pc
),
1125 msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (msym
));
1128 *per_cu_return
= call_site
->per_cu
;
1132 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1133 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1134 DW_AT_GNU_call_site_data_value (dereferenced) block.
1136 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1139 Function always returns non-NULL, non-optimized out value. It throws
1140 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1142 static struct value
*
1143 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1144 CORE_ADDR deref_size
, struct type
*type
,
1145 struct frame_info
*caller_frame
,
1146 struct dwarf2_per_cu_data
*per_cu
)
1148 const gdb_byte
*data_src
;
1152 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1153 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1155 /* DEREF_SIZE size is not verified here. */
1156 if (data_src
== NULL
)
1157 throw_error (NO_ENTRY_VALUE_ERROR
,
1158 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1160 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1161 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1163 data
= alloca (size
+ 1);
1164 memcpy (data
, data_src
, size
);
1165 data
[size
] = DW_OP_stack_value
;
1167 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1170 /* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
1171 Choose DEREF_SIZE value of that parameter. Search caller of the CTX's
1172 frame. CTX must be of dwarf_expr_ctx_funcs kind.
1174 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1175 can be more simple as it does not support cross-CU DWARF executions. */
1178 dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
1179 enum call_site_parameter_kind kind
,
1180 union call_site_parameter_u kind_u
,
1183 struct dwarf_expr_baton
*debaton
;
1184 struct frame_info
*frame
, *caller_frame
;
1185 struct dwarf2_per_cu_data
*caller_per_cu
;
1186 struct dwarf_expr_baton baton_local
;
1187 struct dwarf_expr_context saved_ctx
;
1188 struct call_site_parameter
*parameter
;
1189 const gdb_byte
*data_src
;
1192 gdb_assert (ctx
->funcs
== &dwarf_expr_ctx_funcs
);
1193 debaton
= ctx
->baton
;
1194 frame
= debaton
->frame
;
1195 caller_frame
= get_prev_frame (frame
);
1197 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1199 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1200 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1202 /* DEREF_SIZE size is not verified here. */
1203 if (data_src
== NULL
)
1204 throw_error (NO_ENTRY_VALUE_ERROR
,
1205 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1207 baton_local
.frame
= caller_frame
;
1208 baton_local
.per_cu
= caller_per_cu
;
1209 baton_local
.obj_address
= 0;
1211 saved_ctx
.gdbarch
= ctx
->gdbarch
;
1212 saved_ctx
.addr_size
= ctx
->addr_size
;
1213 saved_ctx
.offset
= ctx
->offset
;
1214 saved_ctx
.baton
= ctx
->baton
;
1215 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (baton_local
.per_cu
));
1216 ctx
->addr_size
= dwarf2_per_cu_addr_size (baton_local
.per_cu
);
1217 ctx
->offset
= dwarf2_per_cu_text_offset (baton_local
.per_cu
);
1218 ctx
->baton
= &baton_local
;
1220 dwarf_expr_eval (ctx
, data_src
, size
);
1222 ctx
->gdbarch
= saved_ctx
.gdbarch
;
1223 ctx
->addr_size
= saved_ctx
.addr_size
;
1224 ctx
->offset
= saved_ctx
.offset
;
1225 ctx
->baton
= saved_ctx
.baton
;
1228 /* Callback function for dwarf2_evaluate_loc_desc.
1229 Fetch the address indexed by DW_OP_GNU_addr_index. */
1232 dwarf_expr_get_addr_index (void *baton
, unsigned int index
)
1234 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
1236 return dwarf2_read_addr_index (debaton
->per_cu
, index
);
1239 /* Callback function for get_object_address. Return the address of the VLA
1243 dwarf_expr_get_obj_addr (void *baton
)
1245 struct dwarf_expr_baton
*debaton
= baton
;
1247 gdb_assert (debaton
!= NULL
);
1249 if (debaton
->obj_address
== 0)
1250 error (_("Location address is not set."));
1252 return debaton
->obj_address
;
1255 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1256 the indirect method on it, that is use its stored target value, the sole
1257 purpose of entry_data_value_funcs.. */
1259 static struct value
*
1260 entry_data_value_coerce_ref (const struct value
*value
)
1262 struct type
*checked_type
= check_typedef (value_type (value
));
1263 struct value
*target_val
;
1265 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
)
1268 target_val
= value_computed_closure (value
);
1269 value_incref (target_val
);
1273 /* Implement copy_closure. */
1276 entry_data_value_copy_closure (const struct value
*v
)
1278 struct value
*target_val
= value_computed_closure (v
);
1280 value_incref (target_val
);
1284 /* Implement free_closure. */
1287 entry_data_value_free_closure (struct value
*v
)
1289 struct value
*target_val
= value_computed_closure (v
);
1291 value_free (target_val
);
1294 /* Vector for methods for an entry value reference where the referenced value
1295 is stored in the caller. On the first dereference use
1296 DW_AT_GNU_call_site_data_value in the caller. */
1298 static const struct lval_funcs entry_data_value_funcs
=
1302 NULL
, /* indirect */
1303 entry_data_value_coerce_ref
,
1304 NULL
, /* check_synthetic_pointer */
1305 entry_data_value_copy_closure
,
1306 entry_data_value_free_closure
1309 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1310 are used to match DW_AT_location at the caller's
1311 DW_TAG_GNU_call_site_parameter.
1313 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1314 cannot resolve the parameter for any reason. */
1316 static struct value
*
1317 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1318 enum call_site_parameter_kind kind
,
1319 union call_site_parameter_u kind_u
)
1321 struct type
*checked_type
= check_typedef (type
);
1322 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1323 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1324 struct value
*outer_val
, *target_val
, *val
;
1325 struct call_site_parameter
*parameter
;
1326 struct dwarf2_per_cu_data
*caller_per_cu
;
1328 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1331 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1335 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1336 used and it is not available do not fall back to OUTER_VAL - dereferencing
1337 TYPE_CODE_REF with non-entry data value would give current value - not the
1340 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
1341 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1344 target_val
= dwarf_entry_parameter_to_value (parameter
,
1345 TYPE_LENGTH (target_type
),
1346 target_type
, caller_frame
,
1349 release_value (target_val
);
1350 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1351 target_val
/* closure */);
1353 /* Copy the referencing pointer to the new computed value. */
1354 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1355 TYPE_LENGTH (checked_type
));
1356 set_value_lazy (val
, 0);
1361 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1362 SIZE are DWARF block used to match DW_AT_location at the caller's
1363 DW_TAG_GNU_call_site_parameter.
1365 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1366 cannot resolve the parameter for any reason. */
1368 static struct value
*
1369 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1370 const gdb_byte
*block
, size_t block_len
)
1372 union call_site_parameter_u kind_u
;
1374 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1375 if (kind_u
.dwarf_reg
!= -1)
1376 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1379 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1380 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1383 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1384 suppressed during normal operation. The expression can be arbitrary if
1385 there is no caller-callee entry value binding expected. */
1386 throw_error (NO_ENTRY_VALUE_ERROR
,
1387 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1388 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1391 struct piece_closure
1393 /* Reference count. */
1396 /* The CU from which this closure's expression came. */
1397 struct dwarf2_per_cu_data
*per_cu
;
1399 /* The number of pieces used to describe this variable. */
1402 /* The target address size, used only for DWARF_VALUE_STACK. */
1405 /* The pieces themselves. */
1406 struct dwarf_expr_piece
*pieces
;
1409 /* Allocate a closure for a value formed from separately-described
1412 static struct piece_closure
*
1413 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1414 int n_pieces
, struct dwarf_expr_piece
*pieces
,
1417 struct piece_closure
*c
= XCNEW (struct piece_closure
);
1422 c
->n_pieces
= n_pieces
;
1423 c
->addr_size
= addr_size
;
1424 c
->pieces
= XCNEWVEC (struct dwarf_expr_piece
, n_pieces
);
1426 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
1427 for (i
= 0; i
< n_pieces
; ++i
)
1428 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1429 value_incref (c
->pieces
[i
].v
.value
);
1434 /* The lowest-level function to extract bits from a byte buffer.
1435 SOURCE is the buffer. It is updated if we read to the end of a
1437 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1438 updated to reflect the number of bits actually read.
1439 NBITS is the number of bits we want to read. It is updated to
1440 reflect the number of bits actually read. This function may read
1442 BITS_BIG_ENDIAN is taken directly from gdbarch.
1443 This function returns the extracted bits. */
1446 extract_bits_primitive (const gdb_byte
**source
,
1447 unsigned int *source_offset_bits
,
1448 int *nbits
, int bits_big_endian
)
1450 unsigned int avail
, mask
, datum
;
1452 gdb_assert (*source_offset_bits
< 8);
1454 avail
= 8 - *source_offset_bits
;
1458 mask
= (1 << avail
) - 1;
1460 if (bits_big_endian
)
1461 datum
>>= 8 - (*source_offset_bits
+ *nbits
);
1463 datum
>>= *source_offset_bits
;
1467 *source_offset_bits
+= avail
;
1468 if (*source_offset_bits
>= 8)
1470 *source_offset_bits
-= 8;
1477 /* Extract some bits from a source buffer and move forward in the
1480 SOURCE is the source buffer. It is updated as bytes are read.
1481 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1483 NBITS is the number of bits to read.
1484 BITS_BIG_ENDIAN is taken directly from gdbarch.
1486 This function returns the bits that were read. */
1489 extract_bits (const gdb_byte
**source
, unsigned int *source_offset_bits
,
1490 int nbits
, int bits_big_endian
)
1494 gdb_assert (nbits
> 0 && nbits
<= 8);
1496 datum
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1502 more
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1504 if (bits_big_endian
)
1514 /* Write some bits into a buffer and move forward in the buffer.
1516 DATUM is the bits to write. The low-order bits of DATUM are used.
1517 DEST is the destination buffer. It is updated as bytes are
1519 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1521 NBITS is the number of valid bits in DATUM.
1522 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1525 insert_bits (unsigned int datum
,
1526 gdb_byte
*dest
, unsigned int dest_offset_bits
,
1527 int nbits
, int bits_big_endian
)
1531 gdb_assert (dest_offset_bits
+ nbits
<= 8);
1533 mask
= (1 << nbits
) - 1;
1534 if (bits_big_endian
)
1536 datum
<<= 8 - (dest_offset_bits
+ nbits
);
1537 mask
<<= 8 - (dest_offset_bits
+ nbits
);
1541 datum
<<= dest_offset_bits
;
1542 mask
<<= dest_offset_bits
;
1545 gdb_assert ((datum
& ~mask
) == 0);
1547 *dest
= (*dest
& ~mask
) | datum
;
1550 /* Copy bits from a source to a destination.
1552 DEST is where the bits should be written.
1553 DEST_OFFSET_BITS is the bit offset into DEST.
1554 SOURCE is the source of bits.
1555 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1556 BIT_COUNT is the number of bits to copy.
1557 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1560 copy_bitwise (gdb_byte
*dest
, unsigned int dest_offset_bits
,
1561 const gdb_byte
*source
, unsigned int source_offset_bits
,
1562 unsigned int bit_count
,
1563 int bits_big_endian
)
1565 unsigned int dest_avail
;
1568 /* Reduce everything to byte-size pieces. */
1569 dest
+= dest_offset_bits
/ 8;
1570 dest_offset_bits
%= 8;
1571 source
+= source_offset_bits
/ 8;
1572 source_offset_bits
%= 8;
1574 dest_avail
= 8 - dest_offset_bits
% 8;
1576 /* See if we can fill the first destination byte. */
1577 if (dest_avail
< bit_count
)
1579 datum
= extract_bits (&source
, &source_offset_bits
, dest_avail
,
1581 insert_bits (datum
, dest
, dest_offset_bits
, dest_avail
, bits_big_endian
);
1583 dest_offset_bits
= 0;
1584 bit_count
-= dest_avail
;
1587 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1588 than 8 bits remaining. */
1589 gdb_assert (dest_offset_bits
% 8 == 0 || bit_count
< 8);
1590 for (; bit_count
>= 8; bit_count
-= 8)
1592 datum
= extract_bits (&source
, &source_offset_bits
, 8, bits_big_endian
);
1593 *dest
++ = (gdb_byte
) datum
;
1596 /* Finally, we may have a few leftover bits. */
1597 gdb_assert (bit_count
<= 8 - dest_offset_bits
% 8);
1600 datum
= extract_bits (&source
, &source_offset_bits
, bit_count
,
1602 insert_bits (datum
, dest
, dest_offset_bits
, bit_count
, bits_big_endian
);
1607 read_pieced_value (struct value
*v
)
1611 ULONGEST bits_to_skip
;
1613 struct piece_closure
*c
1614 = (struct piece_closure
*) value_computed_closure (v
);
1615 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (v
));
1617 size_t buffer_size
= 0;
1618 gdb_byte
*buffer
= NULL
;
1619 struct cleanup
*cleanup
;
1621 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1623 if (value_type (v
) != value_enclosing_type (v
))
1624 internal_error (__FILE__
, __LINE__
,
1625 _("Should not be able to create a lazy value with "
1626 "an enclosing type"));
1628 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1630 contents
= value_contents_raw (v
);
1631 bits_to_skip
= 8 * value_offset (v
);
1632 if (value_bitsize (v
))
1634 bits_to_skip
+= value_bitpos (v
);
1635 type_len
= value_bitsize (v
);
1638 type_len
= 8 * TYPE_LENGTH (value_type (v
));
1640 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1642 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1643 size_t this_size
, this_size_bits
;
1644 long dest_offset_bits
, source_offset_bits
, source_offset
;
1645 const gdb_byte
*intermediate_buffer
;
1647 /* Compute size, source, and destination offsets for copying, in
1649 this_size_bits
= p
->size
;
1650 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1652 bits_to_skip
-= this_size_bits
;
1655 if (bits_to_skip
> 0)
1657 dest_offset_bits
= 0;
1658 source_offset_bits
= bits_to_skip
;
1659 this_size_bits
-= bits_to_skip
;
1664 dest_offset_bits
= offset
;
1665 source_offset_bits
= 0;
1667 if (this_size_bits
> type_len
- offset
)
1668 this_size_bits
= type_len
- offset
;
1670 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1671 source_offset
= source_offset_bits
/ 8;
1672 if (buffer_size
< this_size
)
1674 buffer_size
= this_size
;
1675 buffer
= xrealloc (buffer
, buffer_size
);
1677 intermediate_buffer
= buffer
;
1679 /* Copy from the source to DEST_BUFFER. */
1680 switch (p
->location
)
1682 case DWARF_VALUE_REGISTER
:
1684 struct gdbarch
*arch
= get_frame_arch (frame
);
1685 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1686 int reg_offset
= source_offset
;
1688 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1689 && this_size
< register_size (arch
, gdb_regnum
))
1691 /* Big-endian, and we want less than full size. */
1692 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1693 /* We want the lower-order THIS_SIZE_BITS of the bytes
1694 we extract from the register. */
1695 source_offset_bits
+= 8 * this_size
- this_size_bits
;
1698 if (gdb_regnum
!= -1)
1702 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1706 /* Just so garbage doesn't ever shine through. */
1707 memset (buffer
, 0, this_size
);
1710 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1712 mark_value_bits_unavailable (v
, offset
, this_size_bits
);
1717 error (_("Unable to access DWARF register number %s"),
1718 paddress (arch
, p
->v
.regno
));
1723 case DWARF_VALUE_MEMORY
:
1724 read_value_memory (v
, offset
,
1725 p
->v
.mem
.in_stack_memory
,
1726 p
->v
.mem
.addr
+ source_offset
,
1730 case DWARF_VALUE_STACK
:
1732 size_t n
= this_size
;
1734 if (n
> c
->addr_size
- source_offset
)
1735 n
= (c
->addr_size
>= source_offset
1736 ? c
->addr_size
- source_offset
1744 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
1746 intermediate_buffer
= val_bytes
+ source_offset
;
1751 case DWARF_VALUE_LITERAL
:
1753 size_t n
= this_size
;
1755 if (n
> p
->v
.literal
.length
- source_offset
)
1756 n
= (p
->v
.literal
.length
>= source_offset
1757 ? p
->v
.literal
.length
- source_offset
1760 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
1764 /* These bits show up as zeros -- but do not cause the value
1765 to be considered optimized-out. */
1766 case DWARF_VALUE_IMPLICIT_POINTER
:
1769 case DWARF_VALUE_OPTIMIZED_OUT
:
1770 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1774 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1777 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
1778 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1779 copy_bitwise (contents
, dest_offset_bits
,
1780 intermediate_buffer
, source_offset_bits
% 8,
1781 this_size_bits
, bits_big_endian
);
1783 offset
+= this_size_bits
;
1786 do_cleanups (cleanup
);
1790 write_pieced_value (struct value
*to
, struct value
*from
)
1794 ULONGEST bits_to_skip
;
1795 const gdb_byte
*contents
;
1796 struct piece_closure
*c
1797 = (struct piece_closure
*) value_computed_closure (to
);
1798 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
1800 size_t buffer_size
= 0;
1801 gdb_byte
*buffer
= NULL
;
1802 struct cleanup
*cleanup
;
1804 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
1808 mark_value_bytes_optimized_out (to
, 0, TYPE_LENGTH (value_type (to
)));
1812 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1814 contents
= value_contents (from
);
1815 bits_to_skip
= 8 * value_offset (to
);
1816 if (value_bitsize (to
))
1818 bits_to_skip
+= value_bitpos (to
);
1819 type_len
= value_bitsize (to
);
1822 type_len
= 8 * TYPE_LENGTH (value_type (to
));
1824 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1826 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1827 size_t this_size_bits
, this_size
;
1828 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
1830 const gdb_byte
*source_buffer
;
1832 this_size_bits
= p
->size
;
1833 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1835 bits_to_skip
-= this_size_bits
;
1838 if (this_size_bits
> type_len
- offset
)
1839 this_size_bits
= type_len
- offset
;
1840 if (bits_to_skip
> 0)
1842 dest_offset_bits
= bits_to_skip
;
1843 source_offset_bits
= 0;
1844 this_size_bits
-= bits_to_skip
;
1849 dest_offset_bits
= 0;
1850 source_offset_bits
= offset
;
1853 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1854 source_offset
= source_offset_bits
/ 8;
1855 dest_offset
= dest_offset_bits
/ 8;
1856 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
1858 source_buffer
= contents
+ source_offset
;
1863 if (buffer_size
< this_size
)
1865 buffer_size
= this_size
;
1866 buffer
= xrealloc (buffer
, buffer_size
);
1868 source_buffer
= buffer
;
1872 switch (p
->location
)
1874 case DWARF_VALUE_REGISTER
:
1876 struct gdbarch
*arch
= get_frame_arch (frame
);
1877 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1878 int reg_offset
= dest_offset
;
1880 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1881 && this_size
<= register_size (arch
, gdb_regnum
))
1882 /* Big-endian, and we want less than full size. */
1883 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1885 if (gdb_regnum
!= -1)
1891 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1896 throw_error (OPTIMIZED_OUT_ERROR
,
1897 _("Can't do read-modify-write to "
1898 "update bitfield; containing word "
1899 "has been optimized out"));
1901 throw_error (NOT_AVAILABLE_ERROR
,
1902 _("Can't do read-modify-write to update "
1903 "bitfield; containing word "
1906 copy_bitwise (buffer
, dest_offset_bits
,
1907 contents
, source_offset_bits
,
1912 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1913 this_size
, source_buffer
);
1917 error (_("Unable to write to DWARF register number %s"),
1918 paddress (arch
, p
->v
.regno
));
1922 case DWARF_VALUE_MEMORY
:
1925 /* Only the first and last bytes can possibly have any
1927 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
, 1);
1928 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
1929 buffer
+ this_size
- 1, 1);
1930 copy_bitwise (buffer
, dest_offset_bits
,
1931 contents
, source_offset_bits
,
1936 write_memory (p
->v
.mem
.addr
+ dest_offset
,
1937 source_buffer
, this_size
);
1940 mark_value_bytes_optimized_out (to
, 0, TYPE_LENGTH (value_type (to
)));
1943 offset
+= this_size_bits
;
1946 do_cleanups (cleanup
);
1949 /* An implementation of an lval_funcs method to see whether a value is
1950 a synthetic pointer. */
1953 check_pieced_synthetic_pointer (const struct value
*value
, int bit_offset
,
1956 struct piece_closure
*c
1957 = (struct piece_closure
*) value_computed_closure (value
);
1960 bit_offset
+= 8 * value_offset (value
);
1961 if (value_bitsize (value
))
1962 bit_offset
+= value_bitpos (value
);
1964 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
1966 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1967 size_t this_size_bits
= p
->size
;
1971 if (bit_offset
>= this_size_bits
)
1973 bit_offset
-= this_size_bits
;
1977 bit_length
-= this_size_bits
- bit_offset
;
1981 bit_length
-= this_size_bits
;
1983 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1990 /* A wrapper function for get_frame_address_in_block. */
1993 get_frame_address_in_block_wrapper (void *baton
)
1995 return get_frame_address_in_block (baton
);
1998 /* An implementation of an lval_funcs method to indirect through a
1999 pointer. This handles the synthetic pointer case when needed. */
2001 static struct value
*
2002 indirect_pieced_value (struct value
*value
)
2004 struct piece_closure
*c
2005 = (struct piece_closure
*) value_computed_closure (value
);
2007 struct frame_info
*frame
;
2008 struct dwarf2_locexpr_baton baton
;
2009 int i
, bit_offset
, bit_length
;
2010 struct dwarf_expr_piece
*piece
= NULL
;
2011 LONGEST byte_offset
;
2013 type
= check_typedef (value_type (value
));
2014 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
2017 bit_length
= 8 * TYPE_LENGTH (type
);
2018 bit_offset
= 8 * value_offset (value
);
2019 if (value_bitsize (value
))
2020 bit_offset
+= value_bitpos (value
);
2022 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2024 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2025 size_t this_size_bits
= p
->size
;
2029 if (bit_offset
>= this_size_bits
)
2031 bit_offset
-= this_size_bits
;
2035 bit_length
-= this_size_bits
- bit_offset
;
2039 bit_length
-= this_size_bits
;
2041 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2044 if (bit_length
!= 0)
2045 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2051 frame
= get_selected_frame (_("No frame selected."));
2053 /* This is an offset requested by GDB, such as value subscripts.
2054 However, due to how synthetic pointers are implemented, this is
2055 always presented to us as a pointer type. This means we have to
2056 sign-extend it manually as appropriate. */
2057 byte_offset
= value_as_address (value
);
2058 if (TYPE_LENGTH (value_type (value
)) < sizeof (LONGEST
))
2059 byte_offset
= gdb_sign_extend (byte_offset
,
2060 8 * TYPE_LENGTH (value_type (value
)));
2061 byte_offset
+= piece
->v
.ptr
.offset
;
2065 = dwarf2_fetch_die_loc_sect_off (piece
->v
.ptr
.die
, c
->per_cu
,
2066 get_frame_address_in_block_wrapper
,
2069 if (baton
.data
!= NULL
)
2070 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
2071 baton
.data
, baton
.size
, baton
.per_cu
,
2075 struct obstack temp_obstack
;
2076 struct cleanup
*cleanup
;
2077 const gdb_byte
*bytes
;
2079 struct value
*result
;
2081 obstack_init (&temp_obstack
);
2082 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2084 bytes
= dwarf2_fetch_constant_bytes (piece
->v
.ptr
.die
, c
->per_cu
,
2085 &temp_obstack
, &len
);
2087 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
2091 || byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > len
)
2092 invalid_synthetic_pointer ();
2093 bytes
+= byte_offset
;
2094 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
2097 do_cleanups (cleanup
);
2103 copy_pieced_value_closure (const struct value
*v
)
2105 struct piece_closure
*c
2106 = (struct piece_closure
*) value_computed_closure (v
);
2113 free_pieced_value_closure (struct value
*v
)
2115 struct piece_closure
*c
2116 = (struct piece_closure
*) value_computed_closure (v
);
2123 for (i
= 0; i
< c
->n_pieces
; ++i
)
2124 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
2125 value_free (c
->pieces
[i
].v
.value
);
2132 /* Functions for accessing a variable described by DW_OP_piece. */
2133 static const struct lval_funcs pieced_value_funcs
= {
2136 indirect_pieced_value
,
2137 NULL
, /* coerce_ref */
2138 check_pieced_synthetic_pointer
,
2139 copy_pieced_value_closure
,
2140 free_pieced_value_closure
2143 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2145 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
=
2147 dwarf_expr_read_addr_from_reg
,
2148 dwarf_expr_get_reg_value
,
2149 dwarf_expr_read_mem
,
2150 dwarf_expr_frame_base
,
2151 dwarf_expr_frame_cfa
,
2152 dwarf_expr_frame_pc
,
2153 dwarf_expr_tls_address
,
2154 dwarf_expr_dwarf_call
,
2155 dwarf_expr_get_base_type
,
2156 dwarf_expr_push_dwarf_reg_entry_value
,
2157 dwarf_expr_get_addr_index
,
2158 dwarf_expr_get_obj_addr
2161 /* Evaluate a location description, starting at DATA and with length
2162 SIZE, to find the current location of variable of TYPE in the
2163 context of FRAME. BYTE_OFFSET is applied after the contents are
2166 static struct value
*
2167 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2168 const gdb_byte
*data
, size_t size
,
2169 struct dwarf2_per_cu_data
*per_cu
,
2170 LONGEST byte_offset
)
2172 struct value
*retval
;
2173 struct dwarf_expr_baton baton
;
2174 struct dwarf_expr_context
*ctx
;
2175 struct cleanup
*old_chain
, *value_chain
;
2176 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2177 volatile struct gdb_exception ex
;
2179 if (byte_offset
< 0)
2180 invalid_synthetic_pointer ();
2183 return allocate_optimized_out_value (type
);
2185 baton
.frame
= frame
;
2186 baton
.per_cu
= per_cu
;
2187 baton
.obj_address
= 0;
2189 ctx
= new_dwarf_expr_context ();
2190 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2191 value_chain
= make_cleanup_value_free_to_mark (value_mark ());
2193 ctx
->gdbarch
= get_objfile_arch (objfile
);
2194 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2195 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2196 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2197 ctx
->baton
= &baton
;
2198 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2200 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2202 dwarf_expr_eval (ctx
, data
, size
);
2206 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2208 do_cleanups (old_chain
);
2209 retval
= allocate_value (type
);
2210 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
2213 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2215 if (entry_values_debug
)
2216 exception_print (gdb_stdout
, ex
);
2217 do_cleanups (old_chain
);
2218 return allocate_optimized_out_value (type
);
2221 throw_exception (ex
);
2224 if (ctx
->num_pieces
> 0)
2226 struct piece_closure
*c
;
2227 struct frame_id frame_id
= get_frame_id (frame
);
2228 ULONGEST bit_size
= 0;
2231 for (i
= 0; i
< ctx
->num_pieces
; ++i
)
2232 bit_size
+= ctx
->pieces
[i
].size
;
2233 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
2234 invalid_synthetic_pointer ();
2236 c
= allocate_piece_closure (per_cu
, ctx
->num_pieces
, ctx
->pieces
,
2238 /* We must clean up the value chain after creating the piece
2239 closure but before allocating the result. */
2240 do_cleanups (value_chain
);
2241 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
2242 VALUE_FRAME_ID (retval
) = frame_id
;
2243 set_value_offset (retval
, byte_offset
);
2247 switch (ctx
->location
)
2249 case DWARF_VALUE_REGISTER
:
2251 struct gdbarch
*arch
= get_frame_arch (frame
);
2253 = longest_to_int (value_as_long (dwarf_expr_fetch (ctx
, 0)));
2254 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
2256 if (byte_offset
!= 0)
2257 error (_("cannot use offset on synthetic pointer to register"));
2258 do_cleanups (value_chain
);
2259 if (gdb_regnum
== -1)
2260 error (_("Unable to access DWARF register number %d"),
2262 retval
= value_from_register (type
, gdb_regnum
, frame
);
2263 if (value_optimized_out (retval
))
2267 /* This means the register has undefined value / was
2268 not saved. As we're computing the location of some
2269 variable etc. in the program, not a value for
2270 inspecting a register ($pc, $sp, etc.), return a
2271 generic optimized out value instead, so that we show
2272 <optimized out> instead of <not saved>. */
2273 do_cleanups (value_chain
);
2274 tmp
= allocate_value (type
);
2275 value_contents_copy (tmp
, 0, retval
, 0, TYPE_LENGTH (type
));
2281 case DWARF_VALUE_MEMORY
:
2283 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
2284 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
2286 do_cleanups (value_chain
);
2287 retval
= value_at_lazy (type
, address
+ byte_offset
);
2288 if (in_stack_memory
)
2289 set_value_stack (retval
, 1);
2293 case DWARF_VALUE_STACK
:
2295 struct value
*value
= dwarf_expr_fetch (ctx
, 0);
2297 const gdb_byte
*val_bytes
;
2298 size_t n
= TYPE_LENGTH (value_type (value
));
2300 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2301 invalid_synthetic_pointer ();
2303 val_bytes
= value_contents_all (value
);
2304 val_bytes
+= byte_offset
;
2307 /* Preserve VALUE because we are going to free values back
2308 to the mark, but we still need the value contents
2310 value_incref (value
);
2311 do_cleanups (value_chain
);
2312 make_cleanup_value_free (value
);
2314 retval
= allocate_value (type
);
2315 contents
= value_contents_raw (retval
);
2316 if (n
> TYPE_LENGTH (type
))
2318 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2320 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2321 val_bytes
+= n
- TYPE_LENGTH (type
);
2322 n
= TYPE_LENGTH (type
);
2324 memcpy (contents
, val_bytes
, n
);
2328 case DWARF_VALUE_LITERAL
:
2331 const bfd_byte
*ldata
;
2332 size_t n
= ctx
->len
;
2334 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2335 invalid_synthetic_pointer ();
2337 do_cleanups (value_chain
);
2338 retval
= allocate_value (type
);
2339 contents
= value_contents_raw (retval
);
2341 ldata
= ctx
->data
+ byte_offset
;
2344 if (n
> TYPE_LENGTH (type
))
2346 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2348 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2349 ldata
+= n
- TYPE_LENGTH (type
);
2350 n
= TYPE_LENGTH (type
);
2352 memcpy (contents
, ldata
, n
);
2356 case DWARF_VALUE_OPTIMIZED_OUT
:
2357 do_cleanups (value_chain
);
2358 retval
= allocate_optimized_out_value (type
);
2361 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2362 operation by execute_stack_op. */
2363 case DWARF_VALUE_IMPLICIT_POINTER
:
2364 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2365 it can only be encountered when making a piece. */
2367 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2371 set_value_initialized (retval
, ctx
->initialized
);
2373 do_cleanups (old_chain
);
2378 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2379 passes 0 as the byte_offset. */
2382 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2383 const gdb_byte
*data
, size_t size
,
2384 struct dwarf2_per_cu_data
*per_cu
)
2386 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
2389 /* Evaluates a dwarf expression and stores the result in VAL, expecting
2390 that the dwarf expression only produces a single CORE_ADDR. ADDR is a
2391 context (location of a variable) and might be needed to evaluate the
2392 location expression.
2393 Returns 1 on success, 0 otherwise. */
2396 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton
*dlbaton
,
2400 struct dwarf_expr_context
*ctx
;
2401 struct dwarf_expr_baton baton
;
2402 struct objfile
*objfile
;
2403 struct cleanup
*cleanup
;
2405 if (dlbaton
== NULL
|| dlbaton
->size
== 0)
2408 ctx
= new_dwarf_expr_context ();
2409 cleanup
= make_cleanup_free_dwarf_expr_context (ctx
);
2411 baton
.frame
= get_selected_frame (NULL
);
2412 baton
.per_cu
= dlbaton
->per_cu
;
2413 baton
.obj_address
= addr
;
2415 objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2417 ctx
->gdbarch
= get_objfile_arch (objfile
);
2418 ctx
->addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2419 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (dlbaton
->per_cu
);
2420 ctx
->offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
2421 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2422 ctx
->baton
= &baton
;
2424 dwarf_expr_eval (ctx
, dlbaton
->data
, dlbaton
->size
);
2426 switch (ctx
->location
)
2428 case DWARF_VALUE_REGISTER
:
2429 case DWARF_VALUE_MEMORY
:
2430 case DWARF_VALUE_STACK
:
2431 *valp
= dwarf_expr_fetch_address (ctx
, 0);
2432 if (ctx
->location
== DWARF_VALUE_REGISTER
)
2433 *valp
= dwarf_expr_read_addr_from_reg (&baton
, *valp
);
2434 do_cleanups (cleanup
);
2436 case DWARF_VALUE_LITERAL
:
2437 *valp
= extract_signed_integer (ctx
->data
, ctx
->len
,
2438 gdbarch_byte_order (ctx
->gdbarch
));
2439 do_cleanups (cleanup
);
2441 /* Unsupported dwarf values. */
2442 case DWARF_VALUE_OPTIMIZED_OUT
:
2443 case DWARF_VALUE_IMPLICIT_POINTER
:
2447 do_cleanups (cleanup
);
2451 /* See dwarf2loc.h. */
2454 dwarf2_evaluate_property (const struct dynamic_prop
*prop
,
2455 CORE_ADDR address
, CORE_ADDR
*value
)
2464 const struct dwarf2_property_baton
*baton
= prop
->data
.baton
;
2466 if (dwarf2_locexpr_baton_eval (&baton
->locexpr
, address
, value
))
2468 if (baton
->referenced_type
)
2470 struct value
*val
= value_at (baton
->referenced_type
, *value
);
2472 *value
= value_as_address (val
);
2481 struct dwarf2_property_baton
*baton
= prop
->data
.baton
;
2482 struct frame_info
*frame
= get_selected_frame (NULL
);
2483 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2484 const gdb_byte
*data
;
2488 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2491 val
= dwarf2_evaluate_loc_desc (baton
->referenced_type
, frame
, data
,
2492 size
, baton
->loclist
.per_cu
);
2493 if (!value_optimized_out (val
))
2495 *value
= value_as_address (val
);
2503 *value
= prop
->data
.const_val
;
2511 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2513 struct needs_frame_baton
2516 struct dwarf2_per_cu_data
*per_cu
;
2519 /* Reads from registers do require a frame. */
2521 needs_frame_read_addr_from_reg (void *baton
, int regnum
)
2523 struct needs_frame_baton
*nf_baton
= baton
;
2525 nf_baton
->needs_frame
= 1;
2529 /* struct dwarf_expr_context_funcs' "get_reg_value" callback:
2530 Reads from registers do require a frame. */
2532 static struct value
*
2533 needs_frame_get_reg_value (void *baton
, struct type
*type
, int regnum
)
2535 struct needs_frame_baton
*nf_baton
= baton
;
2537 nf_baton
->needs_frame
= 1;
2538 return value_zero (type
, not_lval
);
2541 /* Reads from memory do not require a frame. */
2543 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
2545 memset (buf
, 0, len
);
2548 /* Frame-relative accesses do require a frame. */
2550 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
2552 static gdb_byte lit0
= DW_OP_lit0
;
2553 struct needs_frame_baton
*nf_baton
= baton
;
2558 nf_baton
->needs_frame
= 1;
2561 /* CFA accesses require a frame. */
2564 needs_frame_frame_cfa (void *baton
)
2566 struct needs_frame_baton
*nf_baton
= baton
;
2568 nf_baton
->needs_frame
= 1;
2572 /* Thread-local accesses do require a frame. */
2574 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
2576 struct needs_frame_baton
*nf_baton
= baton
;
2578 nf_baton
->needs_frame
= 1;
2582 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2585 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
2587 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2589 per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
,
2590 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
2593 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2596 needs_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
2597 enum call_site_parameter_kind kind
,
2598 union call_site_parameter_u kind_u
, int deref_size
)
2600 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2602 nf_baton
->needs_frame
= 1;
2604 /* The expression may require some stub values on DWARF stack. */
2605 dwarf_expr_push_address (ctx
, 0, 0);
2608 /* DW_OP_GNU_addr_index doesn't require a frame. */
2611 needs_get_addr_index (void *baton
, unsigned int index
)
2613 /* Nothing to do. */
2617 /* DW_OP_push_object_address has a frame already passed through. */
2620 needs_get_obj_addr (void *baton
)
2622 /* Nothing to do. */
2626 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2628 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs
=
2630 needs_frame_read_addr_from_reg
,
2631 needs_frame_get_reg_value
,
2632 needs_frame_read_mem
,
2633 needs_frame_frame_base
,
2634 needs_frame_frame_cfa
,
2635 needs_frame_frame_cfa
, /* get_frame_pc */
2636 needs_frame_tls_address
,
2637 needs_frame_dwarf_call
,
2638 NULL
, /* get_base_type */
2639 needs_dwarf_reg_entry_value
,
2640 needs_get_addr_index
,
2644 /* Return non-zero iff the location expression at DATA (length SIZE)
2645 requires a frame to evaluate. */
2648 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, size_t size
,
2649 struct dwarf2_per_cu_data
*per_cu
)
2651 struct needs_frame_baton baton
;
2652 struct dwarf_expr_context
*ctx
;
2654 struct cleanup
*old_chain
;
2655 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2657 baton
.needs_frame
= 0;
2658 baton
.per_cu
= per_cu
;
2660 ctx
= new_dwarf_expr_context ();
2661 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2662 make_cleanup_value_free_to_mark (value_mark ());
2664 ctx
->gdbarch
= get_objfile_arch (objfile
);
2665 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2666 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2667 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2668 ctx
->baton
= &baton
;
2669 ctx
->funcs
= &needs_frame_ctx_funcs
;
2671 dwarf_expr_eval (ctx
, data
, size
);
2673 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
2675 if (ctx
->num_pieces
> 0)
2679 /* If the location has several pieces, and any of them are in
2680 registers, then we will need a frame to fetch them from. */
2681 for (i
= 0; i
< ctx
->num_pieces
; i
++)
2682 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2686 do_cleanups (old_chain
);
2688 return baton
.needs_frame
|| in_reg
;
2691 /* A helper function that throws an unimplemented error mentioning a
2692 given DWARF operator. */
2695 unimplemented (unsigned int op
)
2697 const char *name
= get_DW_OP_name (op
);
2700 error (_("DWARF operator %s cannot be translated to an agent expression"),
2703 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2704 "to an agent expression"),
2708 /* A helper function to convert a DWARF register to an arch register.
2709 ARCH is the architecture.
2710 DWARF_REG is the register.
2711 This will throw an exception if the DWARF register cannot be
2712 translated to an architecture register. */
2715 translate_register (struct gdbarch
*arch
, int dwarf_reg
)
2717 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2719 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
2723 /* A helper function that emits an access to memory. ARCH is the
2724 target architecture. EXPR is the expression which we are building.
2725 NBITS is the number of bits we want to read. This emits the
2726 opcodes needed to read the memory and then extract the desired
2730 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2732 ULONGEST nbytes
= (nbits
+ 7) / 8;
2734 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2737 ax_trace_quick (expr
, nbytes
);
2740 ax_simple (expr
, aop_ref8
);
2741 else if (nbits
<= 16)
2742 ax_simple (expr
, aop_ref16
);
2743 else if (nbits
<= 32)
2744 ax_simple (expr
, aop_ref32
);
2746 ax_simple (expr
, aop_ref64
);
2748 /* If we read exactly the number of bytes we wanted, we're done. */
2749 if (8 * nbytes
== nbits
)
2752 if (gdbarch_bits_big_endian (arch
))
2754 /* On a bits-big-endian machine, we want the high-order
2756 ax_const_l (expr
, 8 * nbytes
- nbits
);
2757 ax_simple (expr
, aop_rsh_unsigned
);
2761 /* On a bits-little-endian box, we want the low-order NBITS. */
2762 ax_zero_ext (expr
, nbits
);
2766 /* A helper function to return the frame's PC. */
2769 get_ax_pc (void *baton
)
2771 struct agent_expr
*expr
= baton
;
2776 /* Compile a DWARF location expression to an agent expression.
2778 EXPR is the agent expression we are building.
2779 LOC is the agent value we modify.
2780 ARCH is the architecture.
2781 ADDR_SIZE is the size of addresses, in bytes.
2782 OP_PTR is the start of the location expression.
2783 OP_END is one past the last byte of the location expression.
2785 This will throw an exception for various kinds of errors -- for
2786 example, if the expression cannot be compiled, or if the expression
2790 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2791 struct gdbarch
*arch
, unsigned int addr_size
,
2792 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
2793 struct dwarf2_per_cu_data
*per_cu
)
2795 struct cleanup
*cleanups
;
2797 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
2798 const gdb_byte
* const base
= op_ptr
;
2799 const gdb_byte
*previous_piece
= op_ptr
;
2800 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2801 ULONGEST bits_collected
= 0;
2802 unsigned int addr_size_bits
= 8 * addr_size
;
2803 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
2805 offsets
= xmalloc ((op_end
- op_ptr
) * sizeof (int));
2806 cleanups
= make_cleanup (xfree
, offsets
);
2808 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
2811 make_cleanup (VEC_cleanup (int), &dw_labels
);
2812 make_cleanup (VEC_cleanup (int), &patches
);
2814 /* By default we are making an address. */
2815 loc
->kind
= axs_lvalue_memory
;
2817 while (op_ptr
< op_end
)
2819 enum dwarf_location_atom op
= *op_ptr
;
2820 uint64_t uoffset
, reg
;
2824 offsets
[op_ptr
- base
] = expr
->len
;
2827 /* Our basic approach to code generation is to map DWARF
2828 operations directly to AX operations. However, there are
2831 First, DWARF works on address-sized units, but AX always uses
2832 LONGEST. For most operations we simply ignore this
2833 difference; instead we generate sign extensions as needed
2834 before division and comparison operations. It would be nice
2835 to omit the sign extensions, but there is no way to determine
2836 the size of the target's LONGEST. (This code uses the size
2837 of the host LONGEST in some cases -- that is a bug but it is
2840 Second, some DWARF operations cannot be translated to AX.
2841 For these we simply fail. See
2842 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2877 ax_const_l (expr
, op
- DW_OP_lit0
);
2881 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
2882 op_ptr
+= addr_size
;
2883 /* Some versions of GCC emit DW_OP_addr before
2884 DW_OP_GNU_push_tls_address. In this case the value is an
2885 index, not an address. We don't support things like
2886 branching between the address and the TLS op. */
2887 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
2888 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
2889 ax_const_l (expr
, uoffset
);
2893 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
2897 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
2901 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
2905 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
2909 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
2913 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
2917 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
2921 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
2925 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
2926 ax_const_l (expr
, uoffset
);
2929 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2930 ax_const_l (expr
, offset
);
2965 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2966 loc
->u
.reg
= translate_register (arch
, op
- DW_OP_reg0
);
2967 loc
->kind
= axs_lvalue_register
;
2971 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2972 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2973 loc
->u
.reg
= translate_register (arch
, reg
);
2974 loc
->kind
= axs_lvalue_register
;
2977 case DW_OP_implicit_value
:
2981 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
2982 if (op_ptr
+ len
> op_end
)
2983 error (_("DW_OP_implicit_value: too few bytes available."));
2984 if (len
> sizeof (ULONGEST
))
2985 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
2988 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
2991 dwarf_expr_require_composition (op_ptr
, op_end
,
2992 "DW_OP_implicit_value");
2994 loc
->kind
= axs_rvalue
;
2998 case DW_OP_stack_value
:
2999 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
3000 loc
->kind
= axs_rvalue
;
3035 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3036 i
= translate_register (arch
, op
- DW_OP_breg0
);
3040 ax_const_l (expr
, offset
);
3041 ax_simple (expr
, aop_add
);
3046 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3047 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3048 i
= translate_register (arch
, reg
);
3052 ax_const_l (expr
, offset
);
3053 ax_simple (expr
, aop_add
);
3059 const gdb_byte
*datastart
;
3061 const struct block
*b
;
3062 struct symbol
*framefunc
;
3064 b
= block_for_pc (expr
->scope
);
3067 error (_("No block found for address"));
3069 framefunc
= block_linkage_function (b
);
3072 error (_("No function found for block"));
3074 dwarf_expr_frame_base_1 (framefunc
, expr
->scope
,
3075 &datastart
, &datalen
);
3077 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3078 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
3079 datastart
+ datalen
, per_cu
);
3080 if (loc
->kind
== axs_lvalue_register
)
3081 require_rvalue (expr
, loc
);
3085 ax_const_l (expr
, offset
);
3086 ax_simple (expr
, aop_add
);
3089 loc
->kind
= axs_lvalue_memory
;
3094 ax_simple (expr
, aop_dup
);
3098 ax_simple (expr
, aop_pop
);
3103 ax_pick (expr
, offset
);
3107 ax_simple (expr
, aop_swap
);
3115 ax_simple (expr
, aop_rot
);
3119 case DW_OP_deref_size
:
3123 if (op
== DW_OP_deref_size
)
3128 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3129 error (_("Unsupported size %d in %s"),
3130 size
, get_DW_OP_name (op
));
3131 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3136 /* Sign extend the operand. */
3137 ax_ext (expr
, addr_size_bits
);
3138 ax_simple (expr
, aop_dup
);
3139 ax_const_l (expr
, 0);
3140 ax_simple (expr
, aop_less_signed
);
3141 ax_simple (expr
, aop_log_not
);
3142 i
= ax_goto (expr
, aop_if_goto
);
3143 /* We have to emit 0 - X. */
3144 ax_const_l (expr
, 0);
3145 ax_simple (expr
, aop_swap
);
3146 ax_simple (expr
, aop_sub
);
3147 ax_label (expr
, i
, expr
->len
);
3151 /* No need to sign extend here. */
3152 ax_const_l (expr
, 0);
3153 ax_simple (expr
, aop_swap
);
3154 ax_simple (expr
, aop_sub
);
3158 /* Sign extend the operand. */
3159 ax_ext (expr
, addr_size_bits
);
3160 ax_simple (expr
, aop_bit_not
);
3163 case DW_OP_plus_uconst
:
3164 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3165 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3166 but we micro-optimize anyhow. */
3169 ax_const_l (expr
, reg
);
3170 ax_simple (expr
, aop_add
);
3175 ax_simple (expr
, aop_bit_and
);
3179 /* Sign extend the operands. */
3180 ax_ext (expr
, addr_size_bits
);
3181 ax_simple (expr
, aop_swap
);
3182 ax_ext (expr
, addr_size_bits
);
3183 ax_simple (expr
, aop_swap
);
3184 ax_simple (expr
, aop_div_signed
);
3188 ax_simple (expr
, aop_sub
);
3192 ax_simple (expr
, aop_rem_unsigned
);
3196 ax_simple (expr
, aop_mul
);
3200 ax_simple (expr
, aop_bit_or
);
3204 ax_simple (expr
, aop_add
);
3208 ax_simple (expr
, aop_lsh
);
3212 ax_simple (expr
, aop_rsh_unsigned
);
3216 ax_simple (expr
, aop_rsh_signed
);
3220 ax_simple (expr
, aop_bit_xor
);
3224 /* Sign extend the operands. */
3225 ax_ext (expr
, addr_size_bits
);
3226 ax_simple (expr
, aop_swap
);
3227 ax_ext (expr
, addr_size_bits
);
3228 /* Note no swap here: A <= B is !(B < A). */
3229 ax_simple (expr
, aop_less_signed
);
3230 ax_simple (expr
, aop_log_not
);
3234 /* Sign extend the operands. */
3235 ax_ext (expr
, addr_size_bits
);
3236 ax_simple (expr
, aop_swap
);
3237 ax_ext (expr
, addr_size_bits
);
3238 ax_simple (expr
, aop_swap
);
3239 /* A >= B is !(A < B). */
3240 ax_simple (expr
, aop_less_signed
);
3241 ax_simple (expr
, aop_log_not
);
3245 /* Sign extend the operands. */
3246 ax_ext (expr
, addr_size_bits
);
3247 ax_simple (expr
, aop_swap
);
3248 ax_ext (expr
, addr_size_bits
);
3249 /* No need for a second swap here. */
3250 ax_simple (expr
, aop_equal
);
3254 /* Sign extend the operands. */
3255 ax_ext (expr
, addr_size_bits
);
3256 ax_simple (expr
, aop_swap
);
3257 ax_ext (expr
, addr_size_bits
);
3258 ax_simple (expr
, aop_swap
);
3259 ax_simple (expr
, aop_less_signed
);
3263 /* Sign extend the operands. */
3264 ax_ext (expr
, addr_size_bits
);
3265 ax_simple (expr
, aop_swap
);
3266 ax_ext (expr
, addr_size_bits
);
3267 /* Note no swap here: A > B is B < A. */
3268 ax_simple (expr
, aop_less_signed
);
3272 /* Sign extend the operands. */
3273 ax_ext (expr
, addr_size_bits
);
3274 ax_simple (expr
, aop_swap
);
3275 ax_ext (expr
, addr_size_bits
);
3276 /* No need for a swap here. */
3277 ax_simple (expr
, aop_equal
);
3278 ax_simple (expr
, aop_log_not
);
3281 case DW_OP_call_frame_cfa
:
3282 dwarf2_compile_cfa_to_ax (expr
, loc
, arch
, expr
->scope
, per_cu
);
3283 loc
->kind
= axs_lvalue_memory
;
3286 case DW_OP_GNU_push_tls_address
:
3290 case DW_OP_push_object_address
:
3295 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3297 i
= ax_goto (expr
, aop_goto
);
3298 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3299 VEC_safe_push (int, patches
, i
);
3303 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3305 /* Zero extend the operand. */
3306 ax_zero_ext (expr
, addr_size_bits
);
3307 i
= ax_goto (expr
, aop_if_goto
);
3308 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3309 VEC_safe_push (int, patches
, i
);
3316 case DW_OP_bit_piece
:
3318 uint64_t size
, offset
;
3320 if (op_ptr
- 1 == previous_piece
)
3321 error (_("Cannot translate empty pieces to agent expressions"));
3322 previous_piece
= op_ptr
- 1;
3324 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3325 if (op
== DW_OP_piece
)
3331 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
3333 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3334 error (_("Expression pieces exceed word size"));
3336 /* Access the bits. */
3339 case axs_lvalue_register
:
3340 ax_reg (expr
, loc
->u
.reg
);
3343 case axs_lvalue_memory
:
3344 /* Offset the pointer, if needed. */
3347 ax_const_l (expr
, offset
/ 8);
3348 ax_simple (expr
, aop_add
);
3351 access_memory (arch
, expr
, size
);
3355 /* For a bits-big-endian target, shift up what we already
3356 have. For a bits-little-endian target, shift up the
3357 new data. Note that there is a potential bug here if
3358 the DWARF expression leaves multiple values on the
3360 if (bits_collected
> 0)
3362 if (bits_big_endian
)
3364 ax_simple (expr
, aop_swap
);
3365 ax_const_l (expr
, size
);
3366 ax_simple (expr
, aop_lsh
);
3367 /* We don't need a second swap here, because
3368 aop_bit_or is symmetric. */
3372 ax_const_l (expr
, size
);
3373 ax_simple (expr
, aop_lsh
);
3375 ax_simple (expr
, aop_bit_or
);
3378 bits_collected
+= size
;
3379 loc
->kind
= axs_rvalue
;
3383 case DW_OP_GNU_uninit
:
3389 struct dwarf2_locexpr_baton block
;
3390 int size
= (op
== DW_OP_call2
? 2 : 4);
3393 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3396 offset
.cu_off
= uoffset
;
3397 block
= dwarf2_fetch_die_loc_cu_off (offset
, per_cu
,
3400 /* DW_OP_call_ref is currently not supported. */
3401 gdb_assert (block
.per_cu
== per_cu
);
3403 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3404 block
.data
, block
.data
+ block
.size
,
3409 case DW_OP_call_ref
:
3417 /* Patch all the branches we emitted. */
3418 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
3420 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
3422 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3423 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
3426 do_cleanups (cleanups
);
3430 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3431 evaluator to calculate the location. */
3432 static struct value
*
3433 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3435 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3438 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3439 dlbaton
->size
, dlbaton
->per_cu
);
3444 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3445 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3448 static struct value
*
3449 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3451 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3453 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3457 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3459 locexpr_read_needs_frame (struct symbol
*symbol
)
3461 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3463 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
3467 /* Return true if DATA points to the end of a piece. END is one past
3468 the last byte in the expression. */
3471 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3473 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3476 /* Helper for locexpr_describe_location_piece that finds the name of a
3480 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3484 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
3485 return gdbarch_register_name (gdbarch
, regnum
);
3488 /* Nicely describe a single piece of a location, returning an updated
3489 position in the bytecode sequence. This function cannot recognize
3490 all locations; if a location is not recognized, it simply returns
3491 DATA. If there is an error during reading, e.g. we run off the end
3492 of the buffer, an error is thrown. */
3494 static const gdb_byte
*
3495 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3496 CORE_ADDR addr
, struct objfile
*objfile
,
3497 struct dwarf2_per_cu_data
*per_cu
,
3498 const gdb_byte
*data
, const gdb_byte
*end
,
3499 unsigned int addr_size
)
3501 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3504 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3506 fprintf_filtered (stream
, _("a variable in $%s"),
3507 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3510 else if (data
[0] == DW_OP_regx
)
3514 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3515 fprintf_filtered (stream
, _("a variable in $%s"),
3516 locexpr_regname (gdbarch
, reg
));
3518 else if (data
[0] == DW_OP_fbreg
)
3520 const struct block
*b
;
3521 struct symbol
*framefunc
;
3523 int64_t frame_offset
;
3524 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3526 int64_t base_offset
= 0;
3528 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3529 if (!piece_end_p (new_data
, end
))
3533 b
= block_for_pc (addr
);
3536 error (_("No block found for address for symbol \"%s\"."),
3537 SYMBOL_PRINT_NAME (symbol
));
3539 framefunc
= block_linkage_function (b
);
3542 error (_("No function found for block for symbol \"%s\"."),
3543 SYMBOL_PRINT_NAME (symbol
));
3545 dwarf_expr_frame_base_1 (framefunc
, addr
, &base_data
, &base_size
);
3547 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3549 const gdb_byte
*buf_end
;
3551 frame_reg
= base_data
[0] - DW_OP_breg0
;
3552 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3554 if (buf_end
!= base_data
+ base_size
)
3555 error (_("Unexpected opcode after "
3556 "DW_OP_breg%u for symbol \"%s\"."),
3557 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3559 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3561 /* The frame base is just the register, with no offset. */
3562 frame_reg
= base_data
[0] - DW_OP_reg0
;
3567 /* We don't know what to do with the frame base expression,
3568 so we can't trace this variable; give up. */
3572 fprintf_filtered (stream
,
3573 _("a variable at frame base reg $%s offset %s+%s"),
3574 locexpr_regname (gdbarch
, frame_reg
),
3575 plongest (base_offset
), plongest (frame_offset
));
3577 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3578 && piece_end_p (data
, end
))
3582 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3584 fprintf_filtered (stream
,
3585 _("a variable at offset %s from base reg $%s"),
3587 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3590 /* The location expression for a TLS variable looks like this (on a
3593 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3594 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3596 0x3 is the encoding for DW_OP_addr, which has an operand as long
3597 as the size of an address on the target machine (here is 8
3598 bytes). Note that more recent version of GCC emit DW_OP_const4u
3599 or DW_OP_const8u, depending on address size, rather than
3600 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3601 The operand represents the offset at which the variable is within
3602 the thread local storage. */
3604 else if (data
+ 1 + addr_size
< end
3605 && (data
[0] == DW_OP_addr
3606 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3607 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3608 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3609 && piece_end_p (data
+ 2 + addr_size
, end
))
3612 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3613 gdbarch_byte_order (gdbarch
));
3615 fprintf_filtered (stream
,
3616 _("a thread-local variable at offset 0x%s "
3617 "in the thread-local storage for `%s'"),
3618 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3620 data
+= 1 + addr_size
+ 1;
3623 /* With -gsplit-dwarf a TLS variable can also look like this:
3624 DW_AT_location : 3 byte block: fc 4 e0
3625 (DW_OP_GNU_const_index: 4;
3626 DW_OP_GNU_push_tls_address) */
3627 else if (data
+ 3 <= end
3628 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3629 && data
[0] == DW_OP_GNU_const_index
3631 && data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3632 && piece_end_p (data
+ 2 + leb128_size
, end
))
3636 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3637 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3638 fprintf_filtered (stream
,
3639 _("a thread-local variable at offset 0x%s "
3640 "in the thread-local storage for `%s'"),
3641 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3645 else if (data
[0] >= DW_OP_lit0
3646 && data
[0] <= DW_OP_lit31
3648 && data
[1] == DW_OP_stack_value
)
3650 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3657 /* Disassemble an expression, stopping at the end of a piece or at the
3658 end of the expression. Returns a pointer to the next unread byte
3659 in the input expression. If ALL is nonzero, then this function
3660 will keep going until it reaches the end of the expression.
3661 If there is an error during reading, e.g. we run off the end
3662 of the buffer, an error is thrown. */
3664 static const gdb_byte
*
3665 disassemble_dwarf_expression (struct ui_file
*stream
,
3666 struct gdbarch
*arch
, unsigned int addr_size
,
3667 int offset_size
, const gdb_byte
*start
,
3668 const gdb_byte
*data
, const gdb_byte
*end
,
3669 int indent
, int all
,
3670 struct dwarf2_per_cu_data
*per_cu
)
3674 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3676 enum dwarf_location_atom op
= *data
++;
3681 name
= get_DW_OP_name (op
);
3684 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3685 op
, (long) (data
- 1 - start
));
3686 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3687 (long) (data
- 1 - start
), name
);
3692 ul
= extract_unsigned_integer (data
, addr_size
,
3693 gdbarch_byte_order (arch
));
3695 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3699 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3701 fprintf_filtered (stream
, " %s", pulongest (ul
));
3704 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3706 fprintf_filtered (stream
, " %s", plongest (l
));
3709 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3711 fprintf_filtered (stream
, " %s", pulongest (ul
));
3714 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3716 fprintf_filtered (stream
, " %s", plongest (l
));
3719 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3721 fprintf_filtered (stream
, " %s", pulongest (ul
));
3724 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3726 fprintf_filtered (stream
, " %s", plongest (l
));
3729 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3731 fprintf_filtered (stream
, " %s", pulongest (ul
));
3734 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3736 fprintf_filtered (stream
, " %s", plongest (l
));
3739 data
= safe_read_uleb128 (data
, end
, &ul
);
3740 fprintf_filtered (stream
, " %s", pulongest (ul
));
3743 data
= safe_read_sleb128 (data
, end
, &l
);
3744 fprintf_filtered (stream
, " %s", plongest (l
));
3779 fprintf_filtered (stream
, " [$%s]",
3780 locexpr_regname (arch
, op
- DW_OP_reg0
));
3784 data
= safe_read_uleb128 (data
, end
, &ul
);
3785 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3786 locexpr_regname (arch
, (int) ul
));
3789 case DW_OP_implicit_value
:
3790 data
= safe_read_uleb128 (data
, end
, &ul
);
3792 fprintf_filtered (stream
, " %s", pulongest (ul
));
3827 data
= safe_read_sleb128 (data
, end
, &l
);
3828 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
3829 locexpr_regname (arch
, op
- DW_OP_breg0
));
3833 data
= safe_read_uleb128 (data
, end
, &ul
);
3834 data
= safe_read_sleb128 (data
, end
, &l
);
3835 fprintf_filtered (stream
, " register %s [$%s] offset %s",
3837 locexpr_regname (arch
, (int) ul
),
3842 data
= safe_read_sleb128 (data
, end
, &l
);
3843 fprintf_filtered (stream
, " %s", plongest (l
));
3846 case DW_OP_xderef_size
:
3847 case DW_OP_deref_size
:
3849 fprintf_filtered (stream
, " %d", *data
);
3853 case DW_OP_plus_uconst
:
3854 data
= safe_read_uleb128 (data
, end
, &ul
);
3855 fprintf_filtered (stream
, " %s", pulongest (ul
));
3859 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3861 fprintf_filtered (stream
, " to %ld",
3862 (long) (data
+ l
- start
));
3866 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3868 fprintf_filtered (stream
, " %ld",
3869 (long) (data
+ l
- start
));
3873 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3875 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
3879 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3881 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3884 case DW_OP_call_ref
:
3885 ul
= extract_unsigned_integer (data
, offset_size
,
3886 gdbarch_byte_order (arch
));
3887 data
+= offset_size
;
3888 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
3892 data
= safe_read_uleb128 (data
, end
, &ul
);
3893 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
3896 case DW_OP_bit_piece
:
3900 data
= safe_read_uleb128 (data
, end
, &ul
);
3901 data
= safe_read_uleb128 (data
, end
, &offset
);
3902 fprintf_filtered (stream
, " size %s offset %s (bits)",
3903 pulongest (ul
), pulongest (offset
));
3907 case DW_OP_GNU_implicit_pointer
:
3909 ul
= extract_unsigned_integer (data
, offset_size
,
3910 gdbarch_byte_order (arch
));
3911 data
+= offset_size
;
3913 data
= safe_read_sleb128 (data
, end
, &l
);
3915 fprintf_filtered (stream
, " DIE %s offset %s",
3916 phex_nz (ul
, offset_size
),
3921 case DW_OP_GNU_deref_type
:
3923 int addr_size
= *data
++;
3927 data
= safe_read_uleb128 (data
, end
, &ul
);
3929 type
= dwarf2_get_die_type (offset
, per_cu
);
3930 fprintf_filtered (stream
, "<");
3931 type_print (type
, "", stream
, -1);
3932 fprintf_filtered (stream
, " [0x%s]> %d", phex_nz (offset
.cu_off
, 0),
3937 case DW_OP_GNU_const_type
:
3942 data
= safe_read_uleb128 (data
, end
, &ul
);
3943 type_die
.cu_off
= ul
;
3944 type
= dwarf2_get_die_type (type_die
, per_cu
);
3945 fprintf_filtered (stream
, "<");
3946 type_print (type
, "", stream
, -1);
3947 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3951 case DW_OP_GNU_regval_type
:
3957 data
= safe_read_uleb128 (data
, end
, ®
);
3958 data
= safe_read_uleb128 (data
, end
, &ul
);
3959 type_die
.cu_off
= ul
;
3961 type
= dwarf2_get_die_type (type_die
, per_cu
);
3962 fprintf_filtered (stream
, "<");
3963 type_print (type
, "", stream
, -1);
3964 fprintf_filtered (stream
, " [0x%s]> [$%s]",
3965 phex_nz (type_die
.cu_off
, 0),
3966 locexpr_regname (arch
, reg
));
3970 case DW_OP_GNU_convert
:
3971 case DW_OP_GNU_reinterpret
:
3975 data
= safe_read_uleb128 (data
, end
, &ul
);
3976 type_die
.cu_off
= ul
;
3978 if (type_die
.cu_off
== 0)
3979 fprintf_filtered (stream
, "<0>");
3984 type
= dwarf2_get_die_type (type_die
, per_cu
);
3985 fprintf_filtered (stream
, "<");
3986 type_print (type
, "", stream
, -1);
3987 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3992 case DW_OP_GNU_entry_value
:
3993 data
= safe_read_uleb128 (data
, end
, &ul
);
3994 fputc_filtered ('\n', stream
);
3995 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
3996 start
, data
, data
+ ul
, indent
+ 2,
4001 case DW_OP_GNU_parameter_ref
:
4002 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4004 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4007 case DW_OP_GNU_addr_index
:
4008 data
= safe_read_uleb128 (data
, end
, &ul
);
4009 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4010 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
4012 case DW_OP_GNU_const_index
:
4013 data
= safe_read_uleb128 (data
, end
, &ul
);
4014 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4015 fprintf_filtered (stream
, " %s", pulongest (ul
));
4019 fprintf_filtered (stream
, "\n");
4025 /* Describe a single location, which may in turn consist of multiple
4029 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
4030 struct ui_file
*stream
,
4031 const gdb_byte
*data
, size_t size
,
4032 struct objfile
*objfile
, unsigned int addr_size
,
4033 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
4035 const gdb_byte
*end
= data
+ size
;
4036 int first_piece
= 1, bad
= 0;
4040 const gdb_byte
*here
= data
;
4041 int disassemble
= 1;
4046 fprintf_filtered (stream
, _(", and "));
4048 if (!dwarf2_always_disassemble
)
4050 data
= locexpr_describe_location_piece (symbol
, stream
,
4051 addr
, objfile
, per_cu
,
4052 data
, end
, addr_size
);
4053 /* If we printed anything, or if we have an empty piece,
4054 then don't disassemble. */
4056 || data
[0] == DW_OP_piece
4057 || data
[0] == DW_OP_bit_piece
)
4062 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
4063 data
= disassemble_dwarf_expression (stream
,
4064 get_objfile_arch (objfile
),
4065 addr_size
, offset_size
, data
,
4067 dwarf2_always_disassemble
,
4073 int empty
= data
== here
;
4076 fprintf_filtered (stream
, " ");
4077 if (data
[0] == DW_OP_piece
)
4081 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
4084 fprintf_filtered (stream
, _("an empty %s-byte piece"),
4087 fprintf_filtered (stream
, _(" [%s-byte piece]"),
4090 else if (data
[0] == DW_OP_bit_piece
)
4092 uint64_t bits
, offset
;
4094 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
4095 data
= safe_read_uleb128 (data
, end
, &offset
);
4098 fprintf_filtered (stream
,
4099 _("an empty %s-bit piece"),
4102 fprintf_filtered (stream
,
4103 _(" [%s-bit piece, offset %s bits]"),
4104 pulongest (bits
), pulongest (offset
));
4114 if (bad
|| data
> end
)
4115 error (_("Corrupted DWARF2 expression for \"%s\"."),
4116 SYMBOL_PRINT_NAME (symbol
));
4119 /* Print a natural-language description of SYMBOL to STREAM. This
4120 version is for a symbol with a single location. */
4123 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4124 struct ui_file
*stream
)
4126 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4127 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4128 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4129 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4131 locexpr_describe_location_1 (symbol
, addr
, stream
,
4132 dlbaton
->data
, dlbaton
->size
,
4133 objfile
, addr_size
, offset_size
,
4137 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4138 any necessary bytecode in AX. */
4141 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4142 struct agent_expr
*ax
, struct axs_value
*value
)
4144 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4145 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4147 if (dlbaton
->size
== 0)
4148 value
->optimized_out
= 1;
4150 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
4151 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4155 /* The set of location functions used with the DWARF-2 expression
4157 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4158 locexpr_read_variable
,
4159 locexpr_read_variable_at_entry
,
4160 locexpr_read_needs_frame
,
4161 locexpr_describe_location
,
4162 0, /* location_has_loclist */
4163 locexpr_tracepoint_var_ref
4167 /* Wrapper functions for location lists. These generally find
4168 the appropriate location expression and call something above. */
4170 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4171 evaluator to calculate the location. */
4172 static struct value
*
4173 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4175 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4177 const gdb_byte
*data
;
4179 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4181 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4182 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4188 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4189 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4192 Function always returns non-NULL value, it may be marked optimized out if
4193 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4194 if it cannot resolve the parameter for any reason. */
4196 static struct value
*
4197 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4199 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4200 const gdb_byte
*data
;
4204 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4205 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4207 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4209 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4211 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4214 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
4216 loclist_read_needs_frame (struct symbol
*symbol
)
4218 /* If there's a location list, then assume we need to have a frame
4219 to choose the appropriate location expression. With tracking of
4220 global variables this is not necessarily true, but such tracking
4221 is disabled in GCC at the moment until we figure out how to
4227 /* Print a natural-language description of SYMBOL to STREAM. This
4228 version applies when there is a list of different locations, each
4229 with a specified address range. */
4232 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4233 struct ui_file
*stream
)
4235 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4236 const gdb_byte
*loc_ptr
, *buf_end
;
4237 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4238 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4239 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4240 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4241 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4242 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4243 /* Adjust base_address for relocatable objects. */
4244 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4245 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4248 loc_ptr
= dlbaton
->data
;
4249 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4251 fprintf_filtered (stream
, _("multi-location:\n"));
4253 /* Iterate through locations until we run out. */
4256 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4258 enum debug_loc_kind kind
;
4259 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4261 if (dlbaton
->from_dwo
)
4262 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4263 loc_ptr
, buf_end
, &new_ptr
,
4264 &low
, &high
, byte_order
);
4266 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4268 byte_order
, addr_size
,
4273 case DEBUG_LOC_END_OF_LIST
:
4276 case DEBUG_LOC_BASE_ADDRESS
:
4277 base_address
= high
+ base_offset
;
4278 fprintf_filtered (stream
, _(" Base address %s"),
4279 paddress (gdbarch
, base_address
));
4281 case DEBUG_LOC_START_END
:
4282 case DEBUG_LOC_START_LENGTH
:
4284 case DEBUG_LOC_BUFFER_OVERFLOW
:
4285 case DEBUG_LOC_INVALID_ENTRY
:
4286 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4287 SYMBOL_PRINT_NAME (symbol
));
4289 gdb_assert_not_reached ("bad debug_loc_kind");
4292 /* Otherwise, a location expression entry. */
4293 low
+= base_address
;
4294 high
+= base_address
;
4296 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4299 /* (It would improve readability to print only the minimum
4300 necessary digits of the second number of the range.) */
4301 fprintf_filtered (stream
, _(" Range %s-%s: "),
4302 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4304 /* Now describe this particular location. */
4305 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4306 objfile
, addr_size
, offset_size
,
4309 fprintf_filtered (stream
, "\n");
4315 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4316 any necessary bytecode in AX. */
4318 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4319 struct agent_expr
*ax
, struct axs_value
*value
)
4321 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4322 const gdb_byte
*data
;
4324 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4326 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4328 value
->optimized_out
= 1;
4330 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
4334 /* The set of location functions used with the DWARF-2 expression
4335 evaluator and location lists. */
4336 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4337 loclist_read_variable
,
4338 loclist_read_variable_at_entry
,
4339 loclist_read_needs_frame
,
4340 loclist_describe_location
,
4341 1, /* location_has_loclist */
4342 loclist_tracepoint_var_ref
4345 /* Provide a prototype to silence -Wmissing-prototypes. */
4346 extern initialize_file_ftype _initialize_dwarf2loc
;
4349 _initialize_dwarf2loc (void)
4351 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4352 &entry_values_debug
,
4353 _("Set entry values and tail call frames "
4355 _("Show entry values and tail call frames "
4357 _("When non-zero, the process of determining "
4358 "parameter values from function entry point "
4359 "and tail call frames will be printed."),
4361 show_entry_values_debug
,
4362 &setdebuglist
, &showdebuglist
);