1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003-2015 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"
40 #include "compile/compile.h"
42 extern int dwarf_always_disassemble
;
44 extern const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
;
46 static struct value
*dwarf2_evaluate_loc_desc_full (struct type
*type
,
47 struct frame_info
*frame
,
50 struct dwarf2_per_cu_data
*per_cu
,
53 /* Until these have formal names, we define these here.
54 ref: http://gcc.gnu.org/wiki/DebugFission
55 Each entry in .debug_loc.dwo begins with a byte that describes the entry,
56 and is then followed by data specific to that entry. */
60 /* Indicates the end of the list of entries. */
61 DEBUG_LOC_END_OF_LIST
= 0,
63 /* This is followed by an unsigned LEB128 number that is an index into
64 .debug_addr and specifies the base address for all following entries. */
65 DEBUG_LOC_BASE_ADDRESS
= 1,
67 /* This is followed by two unsigned LEB128 numbers that are indices into
68 .debug_addr and specify the beginning and ending addresses, and then
69 a normal location expression as in .debug_loc. */
70 DEBUG_LOC_START_END
= 2,
72 /* This is followed by an unsigned LEB128 number that is an index into
73 .debug_addr and specifies the beginning address, and a 4 byte unsigned
74 number that specifies the length, and then a normal location expression
76 DEBUG_LOC_START_LENGTH
= 3,
78 /* An internal value indicating there is insufficient data. */
79 DEBUG_LOC_BUFFER_OVERFLOW
= -1,
81 /* An internal value indicating an invalid kind of entry was found. */
82 DEBUG_LOC_INVALID_ENTRY
= -2
85 /* Helper function which throws an error if a synthetic pointer is
89 invalid_synthetic_pointer (void)
91 error (_("access outside bounds of object "
92 "referenced via synthetic pointer"));
95 /* Decode the addresses in a non-dwo .debug_loc entry.
96 A pointer to the next byte to examine is returned in *NEW_PTR.
97 The encoded low,high addresses are return in *LOW,*HIGH.
98 The result indicates the kind of entry found. */
100 static enum debug_loc_kind
101 decode_debug_loc_addresses (const gdb_byte
*loc_ptr
, const gdb_byte
*buf_end
,
102 const gdb_byte
**new_ptr
,
103 CORE_ADDR
*low
, CORE_ADDR
*high
,
104 enum bfd_endian byte_order
,
105 unsigned int addr_size
,
108 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
110 if (buf_end
- loc_ptr
< 2 * addr_size
)
111 return DEBUG_LOC_BUFFER_OVERFLOW
;
114 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
116 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
117 loc_ptr
+= addr_size
;
120 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
122 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
123 loc_ptr
+= addr_size
;
127 /* A base-address-selection entry. */
128 if ((*low
& base_mask
) == base_mask
)
129 return DEBUG_LOC_BASE_ADDRESS
;
131 /* An end-of-list entry. */
132 if (*low
== 0 && *high
== 0)
133 return DEBUG_LOC_END_OF_LIST
;
135 return DEBUG_LOC_START_END
;
138 /* Decode the addresses in .debug_loc.dwo entry.
139 A pointer to the next byte to examine is returned in *NEW_PTR.
140 The encoded low,high addresses are return in *LOW,*HIGH.
141 The result indicates the kind of entry found. */
143 static enum debug_loc_kind
144 decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data
*per_cu
,
145 const gdb_byte
*loc_ptr
,
146 const gdb_byte
*buf_end
,
147 const gdb_byte
**new_ptr
,
148 CORE_ADDR
*low
, CORE_ADDR
*high
,
149 enum bfd_endian byte_order
)
151 uint64_t low_index
, high_index
;
153 if (loc_ptr
== buf_end
)
154 return DEBUG_LOC_BUFFER_OVERFLOW
;
158 case DEBUG_LOC_END_OF_LIST
:
160 return DEBUG_LOC_END_OF_LIST
;
161 case DEBUG_LOC_BASE_ADDRESS
:
163 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
165 return DEBUG_LOC_BUFFER_OVERFLOW
;
166 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
168 return DEBUG_LOC_BASE_ADDRESS
;
169 case DEBUG_LOC_START_END
:
170 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
172 return DEBUG_LOC_BUFFER_OVERFLOW
;
173 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
174 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
176 return DEBUG_LOC_BUFFER_OVERFLOW
;
177 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
179 return DEBUG_LOC_START_END
;
180 case DEBUG_LOC_START_LENGTH
:
181 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
183 return DEBUG_LOC_BUFFER_OVERFLOW
;
184 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
185 if (loc_ptr
+ 4 > buf_end
)
186 return DEBUG_LOC_BUFFER_OVERFLOW
;
188 *high
+= extract_unsigned_integer (loc_ptr
, 4, byte_order
);
189 *new_ptr
= loc_ptr
+ 4;
190 return DEBUG_LOC_START_LENGTH
;
192 return DEBUG_LOC_INVALID_ENTRY
;
196 /* A function for dealing with location lists. Given a
197 symbol baton (BATON) and a pc value (PC), find the appropriate
198 location expression, set *LOCEXPR_LENGTH, and return a pointer
199 to the beginning of the expression. Returns NULL on failure.
201 For now, only return the first matching location expression; there
202 can be more than one in the list. */
205 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
206 size_t *locexpr_length
, CORE_ADDR pc
)
208 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
209 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
210 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
211 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
212 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
213 /* Adjust base_address for relocatable objects. */
214 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (baton
->per_cu
);
215 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
216 const gdb_byte
*loc_ptr
, *buf_end
;
218 loc_ptr
= baton
->data
;
219 buf_end
= baton
->data
+ baton
->size
;
223 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
225 enum debug_loc_kind kind
;
226 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
229 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
230 loc_ptr
, buf_end
, &new_ptr
,
231 &low
, &high
, byte_order
);
233 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
235 byte_order
, addr_size
,
240 case DEBUG_LOC_END_OF_LIST
:
243 case DEBUG_LOC_BASE_ADDRESS
:
244 base_address
= high
+ base_offset
;
246 case DEBUG_LOC_START_END
:
247 case DEBUG_LOC_START_LENGTH
:
249 case DEBUG_LOC_BUFFER_OVERFLOW
:
250 case DEBUG_LOC_INVALID_ENTRY
:
251 error (_("dwarf2_find_location_expression: "
252 "Corrupted DWARF expression."));
254 gdb_assert_not_reached ("bad debug_loc_kind");
257 /* Otherwise, a location expression entry.
258 If the entry is from a DWO, don't add base address: the entry is
259 from .debug_addr which has absolute addresses. */
260 if (! baton
->from_dwo
)
263 high
+= base_address
;
266 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
269 if (low
== high
&& pc
== low
)
271 /* This is entry PC record present only at entry point
272 of a function. Verify it is really the function entry point. */
274 const struct block
*pc_block
= block_for_pc (pc
);
275 struct symbol
*pc_func
= NULL
;
278 pc_func
= block_linkage_function (pc_block
);
280 if (pc_func
&& pc
== BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func
)))
282 *locexpr_length
= length
;
287 if (pc
>= low
&& pc
< high
)
289 *locexpr_length
= length
;
297 /* This is the baton used when performing dwarf2 expression
299 struct dwarf_expr_baton
301 struct frame_info
*frame
;
302 struct dwarf2_per_cu_data
*per_cu
;
303 CORE_ADDR obj_address
;
306 /* Helper functions for dwarf2_evaluate_loc_desc. */
308 /* Using the frame specified in BATON, return the value of register
309 REGNUM, treated as a pointer. */
311 dwarf_expr_read_addr_from_reg (void *baton
, int dwarf_regnum
)
313 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
314 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
315 int regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
317 return address_from_register (regnum
, debaton
->frame
);
320 /* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback. */
322 static struct value
*
323 dwarf_expr_get_reg_value (void *baton
, struct type
*type
, int dwarf_regnum
)
325 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
326 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
327 int regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
329 return value_from_register (type
, regnum
, debaton
->frame
);
332 /* Read memory at ADDR (length LEN) into BUF. */
335 dwarf_expr_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
337 read_memory (addr
, buf
, len
);
340 /* Using the frame specified in BATON, find the location expression
341 describing the frame base. Return a pointer to it in START and
342 its length in LENGTH. */
344 dwarf_expr_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
346 /* FIXME: cagney/2003-03-26: This code should be using
347 get_frame_base_address(), and then implement a dwarf2 specific
349 struct symbol
*framefunc
;
350 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
351 const struct block
*bl
= get_frame_block (debaton
->frame
, NULL
);
354 error (_("frame address is not available."));
356 /* Use block_linkage_function, which returns a real (not inlined)
357 function, instead of get_frame_function, which may return an
359 framefunc
= block_linkage_function (bl
);
361 /* If we found a frame-relative symbol then it was certainly within
362 some function associated with a frame. If we can't find the frame,
363 something has gone wrong. */
364 gdb_assert (framefunc
!= NULL
);
366 func_get_frame_base_dwarf_block (framefunc
,
367 get_frame_address_in_block (debaton
->frame
),
371 /* Implement find_frame_base_location method for LOC_BLOCK functions using
372 DWARF expression for its DW_AT_frame_base. */
375 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
376 const gdb_byte
**start
, size_t *length
)
378 struct dwarf2_locexpr_baton
*symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
380 *length
= symbaton
->size
;
381 *start
= symbaton
->data
;
384 /* Implement the struct symbol_block_ops::get_frame_base method. */
387 block_op_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
389 struct gdbarch
*gdbarch
;
391 struct dwarf2_locexpr_baton
*dlbaton
;
392 const gdb_byte
*start
;
394 struct value
*result
;
396 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
397 Thus, it's supposed to provide the find_frame_base_location method as
399 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
401 gdbarch
= get_frame_arch (frame
);
402 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
403 dlbaton
= SYMBOL_LOCATION_BATON (framefunc
);
405 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
406 (framefunc
, get_frame_pc (frame
), &start
, &length
);
407 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
410 /* The DW_AT_frame_base attribute contains a location description which
411 computes the base address itself. However, the call to
412 dwarf2_evaluate_loc_desc returns a value representing a variable at
413 that address. The frame base address is thus this variable's
415 return value_address (result
);
418 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
419 function uses DWARF expression for its DW_AT_frame_base. */
421 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
423 locexpr_find_frame_base_location
,
424 block_op_get_frame_base
427 /* Implement find_frame_base_location method for LOC_BLOCK functions using
428 DWARF location list for its DW_AT_frame_base. */
431 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
432 const gdb_byte
**start
, size_t *length
)
434 struct dwarf2_loclist_baton
*symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
436 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
439 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
440 function uses DWARF location list for its DW_AT_frame_base. */
442 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
444 loclist_find_frame_base_location
,
445 block_op_get_frame_base
448 /* See dwarf2loc.h. */
451 func_get_frame_base_dwarf_block (struct symbol
*framefunc
, CORE_ADDR pc
,
452 const gdb_byte
**start
, size_t *length
)
454 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
456 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
458 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
464 error (_("Could not find the frame base for \"%s\"."),
465 SYMBOL_NATURAL_NAME (framefunc
));
468 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
469 the frame in BATON. */
472 dwarf_expr_frame_cfa (void *baton
)
474 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
476 return dwarf2_frame_cfa (debaton
->frame
);
479 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
480 the frame in BATON. */
483 dwarf_expr_frame_pc (void *baton
)
485 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
487 return get_frame_address_in_block (debaton
->frame
);
490 /* Using the objfile specified in BATON, find the address for the
491 current thread's thread-local storage with offset OFFSET. */
493 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
495 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
496 struct objfile
*objfile
= dwarf2_per_cu_objfile (debaton
->per_cu
);
498 return target_translate_tls_address (objfile
, offset
);
501 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
502 current CU (as is PER_CU). State of the CTX is not affected by the
506 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
507 struct dwarf2_per_cu_data
*per_cu
,
508 CORE_ADDR (*get_frame_pc
) (void *baton
),
511 struct dwarf2_locexpr_baton block
;
513 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
, get_frame_pc
, baton
);
515 /* DW_OP_call_ref is currently not supported. */
516 gdb_assert (block
.per_cu
== per_cu
);
518 dwarf_expr_eval (ctx
, block
.data
, block
.size
);
521 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
524 dwarf_expr_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
526 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
528 per_cu_dwarf_call (ctx
, die_offset
, debaton
->per_cu
,
529 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
532 /* Callback function for dwarf2_evaluate_loc_desc. */
535 dwarf_expr_get_base_type (struct dwarf_expr_context
*ctx
,
536 cu_offset die_offset
)
538 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
540 return dwarf2_get_die_type (die_offset
, debaton
->per_cu
);
543 /* See dwarf2loc.h. */
545 unsigned int entry_values_debug
= 0;
547 /* Helper to set entry_values_debug. */
550 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
551 struct cmd_list_element
*c
, const char *value
)
553 fprintf_filtered (file
,
554 _("Entry values and tail call frames debugging is %s.\n"),
558 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
559 CALLER_FRAME (for registers) can be NULL if it is not known. This function
560 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
563 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
564 struct call_site
*call_site
,
565 struct frame_info
*caller_frame
)
567 switch (FIELD_LOC_KIND (call_site
->target
))
569 case FIELD_LOC_KIND_DWARF_BLOCK
:
571 struct dwarf2_locexpr_baton
*dwarf_block
;
573 struct type
*caller_core_addr_type
;
574 struct gdbarch
*caller_arch
;
576 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
577 if (dwarf_block
== NULL
)
579 struct bound_minimal_symbol msym
;
581 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
582 throw_error (NO_ENTRY_VALUE_ERROR
,
583 _("DW_AT_GNU_call_site_target is not specified "
585 paddress (call_site_gdbarch
, call_site
->pc
),
586 (msym
.minsym
== NULL
? "???"
587 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
590 if (caller_frame
== NULL
)
592 struct bound_minimal_symbol msym
;
594 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
595 throw_error (NO_ENTRY_VALUE_ERROR
,
596 _("DW_AT_GNU_call_site_target DWARF block resolving "
597 "requires known frame which is currently not "
598 "available at %s in %s"),
599 paddress (call_site_gdbarch
, call_site
->pc
),
600 (msym
.minsym
== NULL
? "???"
601 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
604 caller_arch
= get_frame_arch (caller_frame
);
605 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
606 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
607 dwarf_block
->data
, dwarf_block
->size
,
608 dwarf_block
->per_cu
);
609 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
611 if (VALUE_LVAL (val
) == lval_memory
)
612 return value_address (val
);
614 return value_as_address (val
);
617 case FIELD_LOC_KIND_PHYSNAME
:
619 const char *physname
;
620 struct bound_minimal_symbol msym
;
622 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
624 /* Handle both the mangled and demangled PHYSNAME. */
625 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
626 if (msym
.minsym
== NULL
)
628 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
629 throw_error (NO_ENTRY_VALUE_ERROR
,
630 _("Cannot find function \"%s\" for a call site target "
632 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
633 (msym
.minsym
== NULL
? "???"
634 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
637 return BMSYMBOL_VALUE_ADDRESS (msym
);
640 case FIELD_LOC_KIND_PHYSADDR
:
641 return FIELD_STATIC_PHYSADDR (call_site
->target
);
644 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
648 /* Convert function entry point exact address ADDR to the function which is
649 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
650 NO_ENTRY_VALUE_ERROR otherwise. */
652 static struct symbol
*
653 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
655 struct symbol
*sym
= find_pc_function (addr
);
658 if (sym
== NULL
|| BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
659 throw_error (NO_ENTRY_VALUE_ERROR
,
660 _("DW_TAG_GNU_call_site resolving failed to find function "
661 "name for address %s"),
662 paddress (gdbarch
, addr
));
664 type
= SYMBOL_TYPE (sym
);
665 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
666 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
671 /* Verify function with entry point exact address ADDR can never call itself
672 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
673 can call itself via tail calls.
675 If a funtion can tail call itself its entry value based parameters are
676 unreliable. There is no verification whether the value of some/all
677 parameters is unchanged through the self tail call, we expect if there is
678 a self tail call all the parameters can be modified. */
681 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
683 struct obstack addr_obstack
;
684 struct cleanup
*old_chain
;
687 /* Track here CORE_ADDRs which were already visited. */
690 /* The verification is completely unordered. Track here function addresses
691 which still need to be iterated. */
692 VEC (CORE_ADDR
) *todo
= NULL
;
694 obstack_init (&addr_obstack
);
695 old_chain
= make_cleanup_obstack_free (&addr_obstack
);
696 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
697 &addr_obstack
, hashtab_obstack_allocate
,
699 make_cleanup_htab_delete (addr_hash
);
701 make_cleanup (VEC_cleanup (CORE_ADDR
), &todo
);
703 VEC_safe_push (CORE_ADDR
, todo
, verify_addr
);
704 while (!VEC_empty (CORE_ADDR
, todo
))
706 struct symbol
*func_sym
;
707 struct call_site
*call_site
;
709 addr
= VEC_pop (CORE_ADDR
, todo
);
711 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
713 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
714 call_site
; call_site
= call_site
->tail_call_next
)
716 CORE_ADDR target_addr
;
719 /* CALLER_FRAME with registers is not available for tail-call jumped
721 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
723 if (target_addr
== verify_addr
)
725 struct bound_minimal_symbol msym
;
727 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
728 throw_error (NO_ENTRY_VALUE_ERROR
,
729 _("DW_OP_GNU_entry_value resolving has found "
730 "function \"%s\" at %s can call itself via tail "
732 (msym
.minsym
== NULL
? "???"
733 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
734 paddress (gdbarch
, verify_addr
));
737 slot
= htab_find_slot (addr_hash
, &target_addr
, INSERT
);
740 *slot
= obstack_copy (&addr_obstack
, &target_addr
,
741 sizeof (target_addr
));
742 VEC_safe_push (CORE_ADDR
, todo
, target_addr
);
747 do_cleanups (old_chain
);
750 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
751 ENTRY_VALUES_DEBUG. */
754 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
756 CORE_ADDR addr
= call_site
->pc
;
757 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
759 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
760 (msym
.minsym
== NULL
? "???"
761 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
765 /* vec.h needs single word type name, typedef it. */
766 typedef struct call_site
*call_sitep
;
768 /* Define VEC (call_sitep) functions. */
769 DEF_VEC_P (call_sitep
);
771 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
772 only top callers and bottom callees which are present in both. GDBARCH is
773 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
774 no remaining possibilities to provide unambiguous non-trivial result.
775 RESULTP should point to NULL on the first (initialization) call. Caller is
776 responsible for xfree of any RESULTP data. */
779 chain_candidate (struct gdbarch
*gdbarch
, struct call_site_chain
**resultp
,
780 VEC (call_sitep
) *chain
)
782 struct call_site_chain
*result
= *resultp
;
783 long length
= VEC_length (call_sitep
, chain
);
784 int callers
, callees
, idx
;
788 /* Create the initial chain containing all the passed PCs. */
790 result
= xmalloc (sizeof (*result
) + sizeof (*result
->call_site
)
792 result
->length
= length
;
793 result
->callers
= result
->callees
= length
;
794 if (!VEC_empty (call_sitep
, chain
))
795 memcpy (result
->call_site
, VEC_address (call_sitep
, chain
),
796 sizeof (*result
->call_site
) * length
);
799 if (entry_values_debug
)
801 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
802 for (idx
= 0; idx
< length
; idx
++)
803 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
804 fputc_unfiltered ('\n', gdb_stdlog
);
810 if (entry_values_debug
)
812 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
813 for (idx
= 0; idx
< length
; idx
++)
814 tailcall_dump (gdbarch
, VEC_index (call_sitep
, chain
, idx
));
815 fputc_unfiltered ('\n', gdb_stdlog
);
818 /* Intersect callers. */
820 callers
= min (result
->callers
, length
);
821 for (idx
= 0; idx
< callers
; idx
++)
822 if (result
->call_site
[idx
] != VEC_index (call_sitep
, chain
, idx
))
824 result
->callers
= idx
;
828 /* Intersect callees. */
830 callees
= min (result
->callees
, length
);
831 for (idx
= 0; idx
< callees
; idx
++)
832 if (result
->call_site
[result
->length
- 1 - idx
]
833 != VEC_index (call_sitep
, chain
, length
- 1 - idx
))
835 result
->callees
= idx
;
839 if (entry_values_debug
)
841 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
842 for (idx
= 0; idx
< result
->callers
; idx
++)
843 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
844 fputs_unfiltered (" |", gdb_stdlog
);
845 for (idx
= 0; idx
< result
->callees
; idx
++)
846 tailcall_dump (gdbarch
, result
->call_site
[result
->length
847 - result
->callees
+ idx
]);
848 fputc_unfiltered ('\n', gdb_stdlog
);
851 if (result
->callers
== 0 && result
->callees
== 0)
853 /* There are no common callers or callees. It could be also a direct
854 call (which has length 0) with ambiguous possibility of an indirect
855 call - CALLERS == CALLEES == 0 is valid during the first allocation
856 but any subsequence processing of such entry means ambiguity. */
862 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
863 PC again. In such case there must be two different code paths to reach
864 it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
865 gdb_assert (result
->callers
+ result
->callees
<= result
->length
);
868 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
869 assumed frames between them use GDBARCH. Use depth first search so we can
870 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
871 would have needless GDB stack overhead. Caller is responsible for xfree of
872 the returned result. Any unreliability results in thrown
873 NO_ENTRY_VALUE_ERROR. */
875 static struct call_site_chain
*
876 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
879 CORE_ADDR save_callee_pc
= callee_pc
;
880 struct obstack addr_obstack
;
881 struct cleanup
*back_to_retval
, *back_to_workdata
;
882 struct call_site_chain
*retval
= NULL
;
883 struct call_site
*call_site
;
885 /* Mark CALL_SITEs so we do not visit the same ones twice. */
888 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
889 call_site nor any possible call_site at CALLEE_PC's function is there.
890 Any CALL_SITE in CHAIN will be iterated to its siblings - via
891 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
892 VEC (call_sitep
) *chain
= NULL
;
894 /* We are not interested in the specific PC inside the callee function. */
895 callee_pc
= get_pc_function_start (callee_pc
);
897 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
898 paddress (gdbarch
, save_callee_pc
));
900 back_to_retval
= make_cleanup (free_current_contents
, &retval
);
902 obstack_init (&addr_obstack
);
903 back_to_workdata
= make_cleanup_obstack_free (&addr_obstack
);
904 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
905 &addr_obstack
, hashtab_obstack_allocate
,
907 make_cleanup_htab_delete (addr_hash
);
909 make_cleanup (VEC_cleanup (call_sitep
), &chain
);
911 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
912 at the target's function. All the possible tail call sites in the
913 target's function will get iterated as already pushed into CHAIN via their
915 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
919 CORE_ADDR target_func_addr
;
920 struct call_site
*target_call_site
;
922 /* CALLER_FRAME with registers is not available for tail-call jumped
924 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
926 if (target_func_addr
== callee_pc
)
928 chain_candidate (gdbarch
, &retval
, chain
);
932 /* There is no way to reach CALLEE_PC again as we would prevent
933 entering it twice as being already marked in ADDR_HASH. */
934 target_call_site
= NULL
;
938 struct symbol
*target_func
;
940 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
941 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
946 /* Attempt to visit TARGET_CALL_SITE. */
948 if (target_call_site
)
952 slot
= htab_find_slot (addr_hash
, &target_call_site
->pc
, INSERT
);
955 /* Successfully entered TARGET_CALL_SITE. */
957 *slot
= &target_call_site
->pc
;
958 VEC_safe_push (call_sitep
, chain
, target_call_site
);
963 /* Backtrack (without revisiting the originating call_site). Try the
964 callers's sibling; if there isn't any try the callers's callers's
967 target_call_site
= NULL
;
968 while (!VEC_empty (call_sitep
, chain
))
970 call_site
= VEC_pop (call_sitep
, chain
);
972 gdb_assert (htab_find_slot (addr_hash
, &call_site
->pc
,
974 htab_remove_elt (addr_hash
, &call_site
->pc
);
976 target_call_site
= call_site
->tail_call_next
;
977 if (target_call_site
)
981 while (target_call_site
);
983 if (VEC_empty (call_sitep
, chain
))
986 call_site
= VEC_last (call_sitep
, chain
);
991 struct bound_minimal_symbol msym_caller
, msym_callee
;
993 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
994 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
995 throw_error (NO_ENTRY_VALUE_ERROR
,
996 _("There are no unambiguously determinable intermediate "
997 "callers or callees between caller function \"%s\" at %s "
998 "and callee function \"%s\" at %s"),
999 (msym_caller
.minsym
== NULL
1000 ? "???" : MSYMBOL_PRINT_NAME (msym_caller
.minsym
)),
1001 paddress (gdbarch
, caller_pc
),
1002 (msym_callee
.minsym
== NULL
1003 ? "???" : MSYMBOL_PRINT_NAME (msym_callee
.minsym
)),
1004 paddress (gdbarch
, callee_pc
));
1007 do_cleanups (back_to_workdata
);
1008 discard_cleanups (back_to_retval
);
1012 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1013 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
1014 constructed return NULL. Caller is responsible for xfree of the returned
1017 struct call_site_chain
*
1018 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1019 CORE_ADDR callee_pc
)
1021 struct call_site_chain
*retval
= NULL
;
1025 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
1027 CATCH (e
, RETURN_MASK_ERROR
)
1029 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
1031 if (entry_values_debug
)
1032 exception_print (gdb_stdout
, e
);
1037 throw_exception (e
);
1044 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1047 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1048 enum call_site_parameter_kind kind
,
1049 union call_site_parameter_u kind_u
)
1051 if (kind
== parameter
->kind
)
1054 case CALL_SITE_PARAMETER_DWARF_REG
:
1055 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1056 case CALL_SITE_PARAMETER_FB_OFFSET
:
1057 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1058 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1059 return kind_u
.param_offset
.cu_off
== parameter
->u
.param_offset
.cu_off
;
1064 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1065 FRAME is for callee.
1067 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1070 static struct call_site_parameter
*
1071 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1072 enum call_site_parameter_kind kind
,
1073 union call_site_parameter_u kind_u
,
1074 struct dwarf2_per_cu_data
**per_cu_return
)
1076 CORE_ADDR func_addr
, caller_pc
;
1077 struct gdbarch
*gdbarch
;
1078 struct frame_info
*caller_frame
;
1079 struct call_site
*call_site
;
1081 /* Initialize it just to avoid a GCC false warning. */
1082 struct call_site_parameter
*parameter
= NULL
;
1083 CORE_ADDR target_addr
;
1085 while (get_frame_type (frame
) == INLINE_FRAME
)
1087 frame
= get_prev_frame (frame
);
1088 gdb_assert (frame
!= NULL
);
1091 func_addr
= get_frame_func (frame
);
1092 gdbarch
= get_frame_arch (frame
);
1093 caller_frame
= get_prev_frame (frame
);
1094 if (gdbarch
!= frame_unwind_arch (frame
))
1096 struct bound_minimal_symbol msym
1097 = lookup_minimal_symbol_by_pc (func_addr
);
1098 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1100 throw_error (NO_ENTRY_VALUE_ERROR
,
1101 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1102 "(of %s (%s)) does not match caller gdbarch %s"),
1103 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1104 paddress (gdbarch
, func_addr
),
1105 (msym
.minsym
== NULL
? "???"
1106 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
1107 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1110 if (caller_frame
== NULL
)
1112 struct bound_minimal_symbol msym
1113 = lookup_minimal_symbol_by_pc (func_addr
);
1115 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_GNU_entry_value resolving "
1116 "requires caller of %s (%s)"),
1117 paddress (gdbarch
, func_addr
),
1118 (msym
.minsym
== NULL
? "???"
1119 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
1121 caller_pc
= get_frame_pc (caller_frame
);
1122 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1124 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1125 if (target_addr
!= func_addr
)
1127 struct minimal_symbol
*target_msym
, *func_msym
;
1129 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1130 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1131 throw_error (NO_ENTRY_VALUE_ERROR
,
1132 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1133 "but the called frame is for %s at %s"),
1134 (target_msym
== NULL
? "???"
1135 : MSYMBOL_PRINT_NAME (target_msym
)),
1136 paddress (gdbarch
, target_addr
),
1137 func_msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (func_msym
),
1138 paddress (gdbarch
, func_addr
));
1141 /* No entry value based parameters would be reliable if this function can
1142 call itself via tail calls. */
1143 func_verify_no_selftailcall (gdbarch
, func_addr
);
1145 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1147 parameter
= &call_site
->parameter
[iparams
];
1148 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1151 if (iparams
== call_site
->parameter_count
)
1153 struct minimal_symbol
*msym
1154 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1156 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1157 determine its value. */
1158 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1159 "at DW_TAG_GNU_call_site %s at %s"),
1160 paddress (gdbarch
, caller_pc
),
1161 msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (msym
));
1164 *per_cu_return
= call_site
->per_cu
;
1168 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1169 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1170 DW_AT_GNU_call_site_data_value (dereferenced) block.
1172 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1175 Function always returns non-NULL, non-optimized out value. It throws
1176 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1178 static struct value
*
1179 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1180 CORE_ADDR deref_size
, struct type
*type
,
1181 struct frame_info
*caller_frame
,
1182 struct dwarf2_per_cu_data
*per_cu
)
1184 const gdb_byte
*data_src
;
1188 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1189 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1191 /* DEREF_SIZE size is not verified here. */
1192 if (data_src
== NULL
)
1193 throw_error (NO_ENTRY_VALUE_ERROR
,
1194 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1196 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1197 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1199 data
= alloca (size
+ 1);
1200 memcpy (data
, data_src
, size
);
1201 data
[size
] = DW_OP_stack_value
;
1203 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1206 /* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
1207 Choose DEREF_SIZE value of that parameter. Search caller of the CTX's
1208 frame. CTX must be of dwarf_expr_ctx_funcs kind.
1210 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1211 can be more simple as it does not support cross-CU DWARF executions. */
1214 dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
1215 enum call_site_parameter_kind kind
,
1216 union call_site_parameter_u kind_u
,
1219 struct dwarf_expr_baton
*debaton
;
1220 struct frame_info
*frame
, *caller_frame
;
1221 struct dwarf2_per_cu_data
*caller_per_cu
;
1222 struct dwarf_expr_baton baton_local
;
1223 struct dwarf_expr_context saved_ctx
;
1224 struct call_site_parameter
*parameter
;
1225 const gdb_byte
*data_src
;
1228 gdb_assert (ctx
->funcs
== &dwarf_expr_ctx_funcs
);
1229 debaton
= ctx
->baton
;
1230 frame
= debaton
->frame
;
1231 caller_frame
= get_prev_frame (frame
);
1233 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1235 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1236 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1238 /* DEREF_SIZE size is not verified here. */
1239 if (data_src
== NULL
)
1240 throw_error (NO_ENTRY_VALUE_ERROR
,
1241 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1243 baton_local
.frame
= caller_frame
;
1244 baton_local
.per_cu
= caller_per_cu
;
1245 baton_local
.obj_address
= 0;
1247 saved_ctx
.gdbarch
= ctx
->gdbarch
;
1248 saved_ctx
.addr_size
= ctx
->addr_size
;
1249 saved_ctx
.offset
= ctx
->offset
;
1250 saved_ctx
.baton
= ctx
->baton
;
1251 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (baton_local
.per_cu
));
1252 ctx
->addr_size
= dwarf2_per_cu_addr_size (baton_local
.per_cu
);
1253 ctx
->offset
= dwarf2_per_cu_text_offset (baton_local
.per_cu
);
1254 ctx
->baton
= &baton_local
;
1256 dwarf_expr_eval (ctx
, data_src
, size
);
1258 ctx
->gdbarch
= saved_ctx
.gdbarch
;
1259 ctx
->addr_size
= saved_ctx
.addr_size
;
1260 ctx
->offset
= saved_ctx
.offset
;
1261 ctx
->baton
= saved_ctx
.baton
;
1264 /* Callback function for dwarf2_evaluate_loc_desc.
1265 Fetch the address indexed by DW_OP_GNU_addr_index. */
1268 dwarf_expr_get_addr_index (void *baton
, unsigned int index
)
1270 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
1272 return dwarf2_read_addr_index (debaton
->per_cu
, index
);
1275 /* Callback function for get_object_address. Return the address of the VLA
1279 dwarf_expr_get_obj_addr (void *baton
)
1281 struct dwarf_expr_baton
*debaton
= baton
;
1283 gdb_assert (debaton
!= NULL
);
1285 if (debaton
->obj_address
== 0)
1286 error (_("Location address is not set."));
1288 return debaton
->obj_address
;
1291 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1292 the indirect method on it, that is use its stored target value, the sole
1293 purpose of entry_data_value_funcs.. */
1295 static struct value
*
1296 entry_data_value_coerce_ref (const struct value
*value
)
1298 struct type
*checked_type
= check_typedef (value_type (value
));
1299 struct value
*target_val
;
1301 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
)
1304 target_val
= value_computed_closure (value
);
1305 value_incref (target_val
);
1309 /* Implement copy_closure. */
1312 entry_data_value_copy_closure (const struct value
*v
)
1314 struct value
*target_val
= value_computed_closure (v
);
1316 value_incref (target_val
);
1320 /* Implement free_closure. */
1323 entry_data_value_free_closure (struct value
*v
)
1325 struct value
*target_val
= value_computed_closure (v
);
1327 value_free (target_val
);
1330 /* Vector for methods for an entry value reference where the referenced value
1331 is stored in the caller. On the first dereference use
1332 DW_AT_GNU_call_site_data_value in the caller. */
1334 static const struct lval_funcs entry_data_value_funcs
=
1338 NULL
, /* indirect */
1339 entry_data_value_coerce_ref
,
1340 NULL
, /* check_synthetic_pointer */
1341 entry_data_value_copy_closure
,
1342 entry_data_value_free_closure
1345 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1346 are used to match DW_AT_location at the caller's
1347 DW_TAG_GNU_call_site_parameter.
1349 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1350 cannot resolve the parameter for any reason. */
1352 static struct value
*
1353 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1354 enum call_site_parameter_kind kind
,
1355 union call_site_parameter_u kind_u
)
1357 struct type
*checked_type
= check_typedef (type
);
1358 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1359 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1360 struct value
*outer_val
, *target_val
, *val
;
1361 struct call_site_parameter
*parameter
;
1362 struct dwarf2_per_cu_data
*caller_per_cu
;
1364 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1367 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1371 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1372 used and it is not available do not fall back to OUTER_VAL - dereferencing
1373 TYPE_CODE_REF with non-entry data value would give current value - not the
1376 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
1377 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1380 target_val
= dwarf_entry_parameter_to_value (parameter
,
1381 TYPE_LENGTH (target_type
),
1382 target_type
, caller_frame
,
1385 release_value (target_val
);
1386 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1387 target_val
/* closure */);
1389 /* Copy the referencing pointer to the new computed value. */
1390 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1391 TYPE_LENGTH (checked_type
));
1392 set_value_lazy (val
, 0);
1397 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1398 SIZE are DWARF block used to match DW_AT_location at the caller's
1399 DW_TAG_GNU_call_site_parameter.
1401 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1402 cannot resolve the parameter for any reason. */
1404 static struct value
*
1405 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1406 const gdb_byte
*block
, size_t block_len
)
1408 union call_site_parameter_u kind_u
;
1410 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1411 if (kind_u
.dwarf_reg
!= -1)
1412 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1415 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1416 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1419 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1420 suppressed during normal operation. The expression can be arbitrary if
1421 there is no caller-callee entry value binding expected. */
1422 throw_error (NO_ENTRY_VALUE_ERROR
,
1423 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1424 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1427 struct piece_closure
1429 /* Reference count. */
1432 /* The CU from which this closure's expression came. */
1433 struct dwarf2_per_cu_data
*per_cu
;
1435 /* The number of pieces used to describe this variable. */
1438 /* The target address size, used only for DWARF_VALUE_STACK. */
1441 /* The pieces themselves. */
1442 struct dwarf_expr_piece
*pieces
;
1445 /* Allocate a closure for a value formed from separately-described
1448 static struct piece_closure
*
1449 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1450 int n_pieces
, struct dwarf_expr_piece
*pieces
,
1453 struct piece_closure
*c
= XCNEW (struct piece_closure
);
1458 c
->n_pieces
= n_pieces
;
1459 c
->addr_size
= addr_size
;
1460 c
->pieces
= XCNEWVEC (struct dwarf_expr_piece
, n_pieces
);
1462 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
1463 for (i
= 0; i
< n_pieces
; ++i
)
1464 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1465 value_incref (c
->pieces
[i
].v
.value
);
1470 /* The lowest-level function to extract bits from a byte buffer.
1471 SOURCE is the buffer. It is updated if we read to the end of a
1473 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1474 updated to reflect the number of bits actually read.
1475 NBITS is the number of bits we want to read. It is updated to
1476 reflect the number of bits actually read. This function may read
1478 BITS_BIG_ENDIAN is taken directly from gdbarch.
1479 This function returns the extracted bits. */
1482 extract_bits_primitive (const gdb_byte
**source
,
1483 unsigned int *source_offset_bits
,
1484 int *nbits
, int bits_big_endian
)
1486 unsigned int avail
, mask
, datum
;
1488 gdb_assert (*source_offset_bits
< 8);
1490 avail
= 8 - *source_offset_bits
;
1494 mask
= (1 << avail
) - 1;
1496 if (bits_big_endian
)
1497 datum
>>= 8 - (*source_offset_bits
+ *nbits
);
1499 datum
>>= *source_offset_bits
;
1503 *source_offset_bits
+= avail
;
1504 if (*source_offset_bits
>= 8)
1506 *source_offset_bits
-= 8;
1513 /* Extract some bits from a source buffer and move forward in the
1516 SOURCE is the source buffer. It is updated as bytes are read.
1517 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1519 NBITS is the number of bits to read.
1520 BITS_BIG_ENDIAN is taken directly from gdbarch.
1522 This function returns the bits that were read. */
1525 extract_bits (const gdb_byte
**source
, unsigned int *source_offset_bits
,
1526 int nbits
, int bits_big_endian
)
1530 gdb_assert (nbits
> 0 && nbits
<= 8);
1532 datum
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1538 more
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1540 if (bits_big_endian
)
1550 /* Write some bits into a buffer and move forward in the buffer.
1552 DATUM is the bits to write. The low-order bits of DATUM are used.
1553 DEST is the destination buffer. It is updated as bytes are
1555 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1557 NBITS is the number of valid bits in DATUM.
1558 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1561 insert_bits (unsigned int datum
,
1562 gdb_byte
*dest
, unsigned int dest_offset_bits
,
1563 int nbits
, int bits_big_endian
)
1567 gdb_assert (dest_offset_bits
+ nbits
<= 8);
1569 mask
= (1 << nbits
) - 1;
1570 if (bits_big_endian
)
1572 datum
<<= 8 - (dest_offset_bits
+ nbits
);
1573 mask
<<= 8 - (dest_offset_bits
+ nbits
);
1577 datum
<<= dest_offset_bits
;
1578 mask
<<= dest_offset_bits
;
1581 gdb_assert ((datum
& ~mask
) == 0);
1583 *dest
= (*dest
& ~mask
) | datum
;
1586 /* Copy bits from a source to a destination.
1588 DEST is where the bits should be written.
1589 DEST_OFFSET_BITS is the bit offset into DEST.
1590 SOURCE is the source of bits.
1591 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1592 BIT_COUNT is the number of bits to copy.
1593 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1596 copy_bitwise (gdb_byte
*dest
, unsigned int dest_offset_bits
,
1597 const gdb_byte
*source
, unsigned int source_offset_bits
,
1598 unsigned int bit_count
,
1599 int bits_big_endian
)
1601 unsigned int dest_avail
;
1604 /* Reduce everything to byte-size pieces. */
1605 dest
+= dest_offset_bits
/ 8;
1606 dest_offset_bits
%= 8;
1607 source
+= source_offset_bits
/ 8;
1608 source_offset_bits
%= 8;
1610 dest_avail
= 8 - dest_offset_bits
% 8;
1612 /* See if we can fill the first destination byte. */
1613 if (dest_avail
< bit_count
)
1615 datum
= extract_bits (&source
, &source_offset_bits
, dest_avail
,
1617 insert_bits (datum
, dest
, dest_offset_bits
, dest_avail
, bits_big_endian
);
1619 dest_offset_bits
= 0;
1620 bit_count
-= dest_avail
;
1623 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1624 than 8 bits remaining. */
1625 gdb_assert (dest_offset_bits
% 8 == 0 || bit_count
< 8);
1626 for (; bit_count
>= 8; bit_count
-= 8)
1628 datum
= extract_bits (&source
, &source_offset_bits
, 8, bits_big_endian
);
1629 *dest
++ = (gdb_byte
) datum
;
1632 /* Finally, we may have a few leftover bits. */
1633 gdb_assert (bit_count
<= 8 - dest_offset_bits
% 8);
1636 datum
= extract_bits (&source
, &source_offset_bits
, bit_count
,
1638 insert_bits (datum
, dest
, dest_offset_bits
, bit_count
, bits_big_endian
);
1643 read_pieced_value (struct value
*v
)
1647 ULONGEST bits_to_skip
;
1649 struct piece_closure
*c
1650 = (struct piece_closure
*) value_computed_closure (v
);
1651 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (v
));
1653 size_t buffer_size
= 0;
1654 gdb_byte
*buffer
= NULL
;
1655 struct cleanup
*cleanup
;
1657 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1659 if (value_type (v
) != value_enclosing_type (v
))
1660 internal_error (__FILE__
, __LINE__
,
1661 _("Should not be able to create a lazy value with "
1662 "an enclosing type"));
1664 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1666 contents
= value_contents_raw (v
);
1667 bits_to_skip
= 8 * value_offset (v
);
1668 if (value_bitsize (v
))
1670 bits_to_skip
+= value_bitpos (v
);
1671 type_len
= value_bitsize (v
);
1674 type_len
= 8 * TYPE_LENGTH (value_type (v
));
1676 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1678 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1679 size_t this_size
, this_size_bits
;
1680 long dest_offset_bits
, source_offset_bits
, source_offset
;
1681 const gdb_byte
*intermediate_buffer
;
1683 /* Compute size, source, and destination offsets for copying, in
1685 this_size_bits
= p
->size
;
1686 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1688 bits_to_skip
-= this_size_bits
;
1691 if (bits_to_skip
> 0)
1693 dest_offset_bits
= 0;
1694 source_offset_bits
= bits_to_skip
;
1695 this_size_bits
-= bits_to_skip
;
1700 dest_offset_bits
= offset
;
1701 source_offset_bits
= 0;
1703 if (this_size_bits
> type_len
- offset
)
1704 this_size_bits
= type_len
- offset
;
1706 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1707 source_offset
= source_offset_bits
/ 8;
1708 if (buffer_size
< this_size
)
1710 buffer_size
= this_size
;
1711 buffer
= xrealloc (buffer
, buffer_size
);
1713 intermediate_buffer
= buffer
;
1715 /* Copy from the source to DEST_BUFFER. */
1716 switch (p
->location
)
1718 case DWARF_VALUE_REGISTER
:
1720 struct gdbarch
*arch
= get_frame_arch (frame
);
1721 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1723 if (gdb_regnum
!= -1)
1726 int reg_offset
= source_offset
;
1728 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1729 && this_size
< register_size (arch
, gdb_regnum
))
1731 /* Big-endian, and we want less than full size. */
1732 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1733 /* We want the lower-order THIS_SIZE_BITS of the bytes
1734 we extract from the register. */
1735 source_offset_bits
+= 8 * this_size
- this_size_bits
;
1738 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1742 /* Just so garbage doesn't ever shine through. */
1743 memset (buffer
, 0, this_size
);
1746 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1748 mark_value_bits_unavailable (v
, offset
, this_size_bits
);
1753 error (_("Unable to access DWARF register number %s"),
1754 paddress (arch
, p
->v
.regno
));
1759 case DWARF_VALUE_MEMORY
:
1760 read_value_memory (v
, offset
,
1761 p
->v
.mem
.in_stack_memory
,
1762 p
->v
.mem
.addr
+ source_offset
,
1766 case DWARF_VALUE_STACK
:
1768 size_t n
= this_size
;
1770 if (n
> c
->addr_size
- source_offset
)
1771 n
= (c
->addr_size
>= source_offset
1772 ? c
->addr_size
- source_offset
1780 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
1782 intermediate_buffer
= val_bytes
+ source_offset
;
1787 case DWARF_VALUE_LITERAL
:
1789 size_t n
= this_size
;
1791 if (n
> p
->v
.literal
.length
- source_offset
)
1792 n
= (p
->v
.literal
.length
>= source_offset
1793 ? p
->v
.literal
.length
- source_offset
1796 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
1800 /* These bits show up as zeros -- but do not cause the value
1801 to be considered optimized-out. */
1802 case DWARF_VALUE_IMPLICIT_POINTER
:
1805 case DWARF_VALUE_OPTIMIZED_OUT
:
1806 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1810 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1813 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
1814 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1815 copy_bitwise (contents
, dest_offset_bits
,
1816 intermediate_buffer
, source_offset_bits
% 8,
1817 this_size_bits
, bits_big_endian
);
1819 offset
+= this_size_bits
;
1822 do_cleanups (cleanup
);
1826 write_pieced_value (struct value
*to
, struct value
*from
)
1830 ULONGEST bits_to_skip
;
1831 const gdb_byte
*contents
;
1832 struct piece_closure
*c
1833 = (struct piece_closure
*) value_computed_closure (to
);
1834 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
1836 size_t buffer_size
= 0;
1837 gdb_byte
*buffer
= NULL
;
1838 struct cleanup
*cleanup
;
1840 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
1844 mark_value_bytes_optimized_out (to
, 0, TYPE_LENGTH (value_type (to
)));
1848 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1850 contents
= value_contents (from
);
1851 bits_to_skip
= 8 * value_offset (to
);
1852 if (value_bitsize (to
))
1854 bits_to_skip
+= value_bitpos (to
);
1855 type_len
= value_bitsize (to
);
1858 type_len
= 8 * TYPE_LENGTH (value_type (to
));
1860 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1862 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1863 size_t this_size_bits
, this_size
;
1864 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
1866 const gdb_byte
*source_buffer
;
1868 this_size_bits
= p
->size
;
1869 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1871 bits_to_skip
-= this_size_bits
;
1874 if (this_size_bits
> type_len
- offset
)
1875 this_size_bits
= type_len
- offset
;
1876 if (bits_to_skip
> 0)
1878 dest_offset_bits
= bits_to_skip
;
1879 source_offset_bits
= 0;
1880 this_size_bits
-= bits_to_skip
;
1885 dest_offset_bits
= 0;
1886 source_offset_bits
= offset
;
1889 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1890 source_offset
= source_offset_bits
/ 8;
1891 dest_offset
= dest_offset_bits
/ 8;
1892 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
1894 source_buffer
= contents
+ source_offset
;
1899 if (buffer_size
< this_size
)
1901 buffer_size
= this_size
;
1902 buffer
= xrealloc (buffer
, buffer_size
);
1904 source_buffer
= buffer
;
1908 switch (p
->location
)
1910 case DWARF_VALUE_REGISTER
:
1912 struct gdbarch
*arch
= get_frame_arch (frame
);
1913 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1915 if (gdb_regnum
!= -1)
1917 int reg_offset
= dest_offset
;
1919 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1920 && this_size
<= register_size (arch
, gdb_regnum
))
1922 /* Big-endian, and we want less than full size. */
1923 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1930 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1935 throw_error (OPTIMIZED_OUT_ERROR
,
1936 _("Can't do read-modify-write to "
1937 "update bitfield; containing word "
1938 "has been optimized out"));
1940 throw_error (NOT_AVAILABLE_ERROR
,
1941 _("Can't do read-modify-write to update "
1942 "bitfield; containing word "
1945 copy_bitwise (buffer
, dest_offset_bits
,
1946 contents
, source_offset_bits
,
1951 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1952 this_size
, source_buffer
);
1956 error (_("Unable to write to DWARF register number %s"),
1957 paddress (arch
, p
->v
.regno
));
1961 case DWARF_VALUE_MEMORY
:
1964 /* Only the first and last bytes can possibly have any
1966 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
, 1);
1967 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
1968 buffer
+ this_size
- 1, 1);
1969 copy_bitwise (buffer
, dest_offset_bits
,
1970 contents
, source_offset_bits
,
1975 write_memory (p
->v
.mem
.addr
+ dest_offset
,
1976 source_buffer
, this_size
);
1979 mark_value_bytes_optimized_out (to
, 0, TYPE_LENGTH (value_type (to
)));
1982 offset
+= this_size_bits
;
1985 do_cleanups (cleanup
);
1988 /* An implementation of an lval_funcs method to see whether a value is
1989 a synthetic pointer. */
1992 check_pieced_synthetic_pointer (const struct value
*value
, int bit_offset
,
1995 struct piece_closure
*c
1996 = (struct piece_closure
*) value_computed_closure (value
);
1999 bit_offset
+= 8 * value_offset (value
);
2000 if (value_bitsize (value
))
2001 bit_offset
+= value_bitpos (value
);
2003 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2005 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2006 size_t this_size_bits
= p
->size
;
2010 if (bit_offset
>= this_size_bits
)
2012 bit_offset
-= this_size_bits
;
2016 bit_length
-= this_size_bits
- bit_offset
;
2020 bit_length
-= this_size_bits
;
2022 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2029 /* A wrapper function for get_frame_address_in_block. */
2032 get_frame_address_in_block_wrapper (void *baton
)
2034 return get_frame_address_in_block (baton
);
2037 /* An implementation of an lval_funcs method to indirect through a
2038 pointer. This handles the synthetic pointer case when needed. */
2040 static struct value
*
2041 indirect_pieced_value (struct value
*value
)
2043 struct piece_closure
*c
2044 = (struct piece_closure
*) value_computed_closure (value
);
2046 struct frame_info
*frame
;
2047 struct dwarf2_locexpr_baton baton
;
2048 int i
, bit_offset
, bit_length
;
2049 struct dwarf_expr_piece
*piece
= NULL
;
2050 LONGEST byte_offset
;
2051 enum bfd_endian byte_order
;
2053 type
= check_typedef (value_type (value
));
2054 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
2057 bit_length
= 8 * TYPE_LENGTH (type
);
2058 bit_offset
= 8 * value_offset (value
);
2059 if (value_bitsize (value
))
2060 bit_offset
+= value_bitpos (value
);
2062 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2064 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2065 size_t this_size_bits
= p
->size
;
2069 if (bit_offset
>= this_size_bits
)
2071 bit_offset
-= this_size_bits
;
2075 bit_length
-= this_size_bits
- bit_offset
;
2079 bit_length
-= this_size_bits
;
2081 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2084 if (bit_length
!= 0)
2085 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2091 frame
= get_selected_frame (_("No frame selected."));
2093 /* This is an offset requested by GDB, such as value subscripts.
2094 However, due to how synthetic pointers are implemented, this is
2095 always presented to us as a pointer type. This means we have to
2096 sign-extend it manually as appropriate. Use raw
2097 extract_signed_integer directly rather than value_as_address and
2098 sign extend afterwards on architectures that would need it
2099 (mostly everywhere except MIPS, which has signed addresses) as
2100 the later would go through gdbarch_pointer_to_address and thus
2101 return a CORE_ADDR with high bits set on architectures that
2102 encode address spaces and other things in CORE_ADDR. */
2103 byte_order
= gdbarch_byte_order (get_frame_arch (frame
));
2104 byte_offset
= extract_signed_integer (value_contents (value
),
2105 TYPE_LENGTH (type
), byte_order
);
2106 byte_offset
+= piece
->v
.ptr
.offset
;
2110 = dwarf2_fetch_die_loc_sect_off (piece
->v
.ptr
.die
, c
->per_cu
,
2111 get_frame_address_in_block_wrapper
,
2114 if (baton
.data
!= NULL
)
2115 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
2116 baton
.data
, baton
.size
, baton
.per_cu
,
2120 struct obstack temp_obstack
;
2121 struct cleanup
*cleanup
;
2122 const gdb_byte
*bytes
;
2124 struct value
*result
;
2126 obstack_init (&temp_obstack
);
2127 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2129 bytes
= dwarf2_fetch_constant_bytes (piece
->v
.ptr
.die
, c
->per_cu
,
2130 &temp_obstack
, &len
);
2132 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
2136 || byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > len
)
2137 invalid_synthetic_pointer ();
2138 bytes
+= byte_offset
;
2139 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
2142 do_cleanups (cleanup
);
2148 copy_pieced_value_closure (const struct value
*v
)
2150 struct piece_closure
*c
2151 = (struct piece_closure
*) value_computed_closure (v
);
2158 free_pieced_value_closure (struct value
*v
)
2160 struct piece_closure
*c
2161 = (struct piece_closure
*) value_computed_closure (v
);
2168 for (i
= 0; i
< c
->n_pieces
; ++i
)
2169 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
2170 value_free (c
->pieces
[i
].v
.value
);
2177 /* Functions for accessing a variable described by DW_OP_piece. */
2178 static const struct lval_funcs pieced_value_funcs
= {
2181 indirect_pieced_value
,
2182 NULL
, /* coerce_ref */
2183 check_pieced_synthetic_pointer
,
2184 copy_pieced_value_closure
,
2185 free_pieced_value_closure
2188 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2190 const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
=
2192 dwarf_expr_read_addr_from_reg
,
2193 dwarf_expr_get_reg_value
,
2194 dwarf_expr_read_mem
,
2195 dwarf_expr_frame_base
,
2196 dwarf_expr_frame_cfa
,
2197 dwarf_expr_frame_pc
,
2198 dwarf_expr_tls_address
,
2199 dwarf_expr_dwarf_call
,
2200 dwarf_expr_get_base_type
,
2201 dwarf_expr_push_dwarf_reg_entry_value
,
2202 dwarf_expr_get_addr_index
,
2203 dwarf_expr_get_obj_addr
2206 /* Evaluate a location description, starting at DATA and with length
2207 SIZE, to find the current location of variable of TYPE in the
2208 context of FRAME. BYTE_OFFSET is applied after the contents are
2211 static struct value
*
2212 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2213 const gdb_byte
*data
, size_t size
,
2214 struct dwarf2_per_cu_data
*per_cu
,
2215 LONGEST byte_offset
)
2217 struct value
*retval
;
2218 struct dwarf_expr_baton baton
;
2219 struct dwarf_expr_context
*ctx
;
2220 struct cleanup
*old_chain
, *value_chain
;
2221 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2223 if (byte_offset
< 0)
2224 invalid_synthetic_pointer ();
2227 return allocate_optimized_out_value (type
);
2229 baton
.frame
= frame
;
2230 baton
.per_cu
= per_cu
;
2231 baton
.obj_address
= 0;
2233 ctx
= new_dwarf_expr_context ();
2234 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2235 value_chain
= make_cleanup_value_free_to_mark (value_mark ());
2237 ctx
->gdbarch
= get_objfile_arch (objfile
);
2238 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2239 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2240 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2241 ctx
->baton
= &baton
;
2242 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2246 dwarf_expr_eval (ctx
, data
, size
);
2248 CATCH (ex
, RETURN_MASK_ERROR
)
2250 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2252 do_cleanups (old_chain
);
2253 retval
= allocate_value (type
);
2254 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
2257 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2259 if (entry_values_debug
)
2260 exception_print (gdb_stdout
, ex
);
2261 do_cleanups (old_chain
);
2262 return allocate_optimized_out_value (type
);
2265 throw_exception (ex
);
2269 if (ctx
->num_pieces
> 0)
2271 struct piece_closure
*c
;
2272 struct frame_id frame_id
= get_frame_id (frame
);
2273 ULONGEST bit_size
= 0;
2276 for (i
= 0; i
< ctx
->num_pieces
; ++i
)
2277 bit_size
+= ctx
->pieces
[i
].size
;
2278 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
2279 invalid_synthetic_pointer ();
2281 c
= allocate_piece_closure (per_cu
, ctx
->num_pieces
, ctx
->pieces
,
2283 /* We must clean up the value chain after creating the piece
2284 closure but before allocating the result. */
2285 do_cleanups (value_chain
);
2286 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
2287 VALUE_FRAME_ID (retval
) = frame_id
;
2288 set_value_offset (retval
, byte_offset
);
2292 switch (ctx
->location
)
2294 case DWARF_VALUE_REGISTER
:
2296 struct gdbarch
*arch
= get_frame_arch (frame
);
2298 = longest_to_int (value_as_long (dwarf_expr_fetch (ctx
, 0)));
2299 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
2301 if (byte_offset
!= 0)
2302 error (_("cannot use offset on synthetic pointer to register"));
2303 do_cleanups (value_chain
);
2304 if (gdb_regnum
== -1)
2305 error (_("Unable to access DWARF register number %d"),
2307 retval
= value_from_register (type
, gdb_regnum
, frame
);
2308 if (value_optimized_out (retval
))
2312 /* This means the register has undefined value / was
2313 not saved. As we're computing the location of some
2314 variable etc. in the program, not a value for
2315 inspecting a register ($pc, $sp, etc.), return a
2316 generic optimized out value instead, so that we show
2317 <optimized out> instead of <not saved>. */
2318 do_cleanups (value_chain
);
2319 tmp
= allocate_value (type
);
2320 value_contents_copy (tmp
, 0, retval
, 0, TYPE_LENGTH (type
));
2326 case DWARF_VALUE_MEMORY
:
2328 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
2329 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
2331 do_cleanups (value_chain
);
2332 retval
= value_at_lazy (type
, address
+ byte_offset
);
2333 if (in_stack_memory
)
2334 set_value_stack (retval
, 1);
2338 case DWARF_VALUE_STACK
:
2340 struct value
*value
= dwarf_expr_fetch (ctx
, 0);
2342 const gdb_byte
*val_bytes
;
2343 size_t n
= TYPE_LENGTH (value_type (value
));
2345 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2346 invalid_synthetic_pointer ();
2348 val_bytes
= value_contents_all (value
);
2349 val_bytes
+= byte_offset
;
2352 /* Preserve VALUE because we are going to free values back
2353 to the mark, but we still need the value contents
2355 value_incref (value
);
2356 do_cleanups (value_chain
);
2357 make_cleanup_value_free (value
);
2359 retval
= allocate_value (type
);
2360 contents
= value_contents_raw (retval
);
2361 if (n
> TYPE_LENGTH (type
))
2363 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2365 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2366 val_bytes
+= n
- TYPE_LENGTH (type
);
2367 n
= TYPE_LENGTH (type
);
2369 memcpy (contents
, val_bytes
, n
);
2373 case DWARF_VALUE_LITERAL
:
2376 const bfd_byte
*ldata
;
2377 size_t n
= ctx
->len
;
2379 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2380 invalid_synthetic_pointer ();
2382 do_cleanups (value_chain
);
2383 retval
= allocate_value (type
);
2384 contents
= value_contents_raw (retval
);
2386 ldata
= ctx
->data
+ byte_offset
;
2389 if (n
> TYPE_LENGTH (type
))
2391 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2393 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2394 ldata
+= n
- TYPE_LENGTH (type
);
2395 n
= TYPE_LENGTH (type
);
2397 memcpy (contents
, ldata
, n
);
2401 case DWARF_VALUE_OPTIMIZED_OUT
:
2402 do_cleanups (value_chain
);
2403 retval
= allocate_optimized_out_value (type
);
2406 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2407 operation by execute_stack_op. */
2408 case DWARF_VALUE_IMPLICIT_POINTER
:
2409 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2410 it can only be encountered when making a piece. */
2412 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2416 set_value_initialized (retval
, ctx
->initialized
);
2418 do_cleanups (old_chain
);
2423 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2424 passes 0 as the byte_offset. */
2427 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2428 const gdb_byte
*data
, size_t size
,
2429 struct dwarf2_per_cu_data
*per_cu
)
2431 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
2434 /* Evaluates a dwarf expression and stores the result in VAL, expecting
2435 that the dwarf expression only produces a single CORE_ADDR. FRAME is the
2436 frame in which the expression is evaluated. ADDR is a context (location of
2437 a variable) and might be needed to evaluate the location expression.
2438 Returns 1 on success, 0 otherwise. */
2441 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton
*dlbaton
,
2442 struct frame_info
*frame
,
2446 struct dwarf_expr_context
*ctx
;
2447 struct dwarf_expr_baton baton
;
2448 struct objfile
*objfile
;
2449 struct cleanup
*cleanup
;
2451 if (dlbaton
== NULL
|| dlbaton
->size
== 0)
2454 ctx
= new_dwarf_expr_context ();
2455 cleanup
= make_cleanup_free_dwarf_expr_context (ctx
);
2457 baton
.frame
= frame
;
2458 baton
.per_cu
= dlbaton
->per_cu
;
2459 baton
.obj_address
= addr
;
2461 objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2463 ctx
->gdbarch
= get_objfile_arch (objfile
);
2464 ctx
->addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2465 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (dlbaton
->per_cu
);
2466 ctx
->offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
2467 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2468 ctx
->baton
= &baton
;
2470 dwarf_expr_eval (ctx
, dlbaton
->data
, dlbaton
->size
);
2472 switch (ctx
->location
)
2474 case DWARF_VALUE_REGISTER
:
2475 case DWARF_VALUE_MEMORY
:
2476 case DWARF_VALUE_STACK
:
2477 *valp
= dwarf_expr_fetch_address (ctx
, 0);
2478 if (ctx
->location
== DWARF_VALUE_REGISTER
)
2479 *valp
= dwarf_expr_read_addr_from_reg (&baton
, *valp
);
2480 do_cleanups (cleanup
);
2482 case DWARF_VALUE_LITERAL
:
2483 *valp
= extract_signed_integer (ctx
->data
, ctx
->len
,
2484 gdbarch_byte_order (ctx
->gdbarch
));
2485 do_cleanups (cleanup
);
2487 /* Unsupported dwarf values. */
2488 case DWARF_VALUE_OPTIMIZED_OUT
:
2489 case DWARF_VALUE_IMPLICIT_POINTER
:
2493 do_cleanups (cleanup
);
2497 /* See dwarf2loc.h. */
2500 dwarf2_evaluate_property (const struct dynamic_prop
*prop
,
2501 struct frame_info
*frame
,
2502 struct property_addr_info
*addr_stack
,
2508 if (frame
== NULL
&& has_stack_frames ())
2509 frame
= get_selected_frame (NULL
);
2515 const struct dwarf2_property_baton
*baton
= prop
->data
.baton
;
2517 if (dwarf2_locexpr_baton_eval (&baton
->locexpr
, frame
,
2518 addr_stack
? addr_stack
->addr
: 0,
2521 if (baton
->referenced_type
)
2523 struct value
*val
= value_at (baton
->referenced_type
, *value
);
2525 *value
= value_as_address (val
);
2534 struct dwarf2_property_baton
*baton
= prop
->data
.baton
;
2535 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2536 const gdb_byte
*data
;
2540 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2543 val
= dwarf2_evaluate_loc_desc (baton
->referenced_type
, frame
, data
,
2544 size
, baton
->loclist
.per_cu
);
2545 if (!value_optimized_out (val
))
2547 *value
= value_as_address (val
);
2555 *value
= prop
->data
.const_val
;
2558 case PROP_ADDR_OFFSET
:
2560 struct dwarf2_property_baton
*baton
= prop
->data
.baton
;
2561 struct property_addr_info
*pinfo
;
2564 for (pinfo
= addr_stack
; pinfo
!= NULL
; pinfo
= pinfo
->next
)
2565 if (pinfo
->type
== baton
->referenced_type
)
2568 error (_("cannot find reference address for offset property"));
2569 if (pinfo
->valaddr
!= NULL
)
2570 val
= value_from_contents
2571 (baton
->offset_info
.type
,
2572 pinfo
->valaddr
+ baton
->offset_info
.offset
);
2574 val
= value_at (baton
->offset_info
.type
,
2575 pinfo
->addr
+ baton
->offset_info
.offset
);
2576 *value
= value_as_address (val
);
2584 /* See dwarf2loc.h. */
2587 dwarf2_compile_property_to_c (struct ui_file
*stream
,
2588 const char *result_name
,
2589 struct gdbarch
*gdbarch
,
2590 unsigned char *registers_used
,
2591 const struct dynamic_prop
*prop
,
2595 struct dwarf2_property_baton
*baton
= prop
->data
.baton
;
2596 const gdb_byte
*data
;
2598 struct dwarf2_per_cu_data
*per_cu
;
2600 if (prop
->kind
== PROP_LOCEXPR
)
2602 data
= baton
->locexpr
.data
;
2603 size
= baton
->locexpr
.size
;
2604 per_cu
= baton
->locexpr
.per_cu
;
2608 gdb_assert (prop
->kind
== PROP_LOCLIST
);
2610 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2611 per_cu
= baton
->loclist
.per_cu
;
2614 compile_dwarf_bounds_to_c (stream
, result_name
, prop
, sym
, pc
,
2615 gdbarch
, registers_used
,
2616 dwarf2_per_cu_addr_size (per_cu
),
2617 data
, data
+ size
, per_cu
);
2621 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2623 struct needs_frame_baton
2626 struct dwarf2_per_cu_data
*per_cu
;
2629 /* Reads from registers do require a frame. */
2631 needs_frame_read_addr_from_reg (void *baton
, int regnum
)
2633 struct needs_frame_baton
*nf_baton
= baton
;
2635 nf_baton
->needs_frame
= 1;
2639 /* struct dwarf_expr_context_funcs' "get_reg_value" callback:
2640 Reads from registers do require a frame. */
2642 static struct value
*
2643 needs_frame_get_reg_value (void *baton
, struct type
*type
, int regnum
)
2645 struct needs_frame_baton
*nf_baton
= baton
;
2647 nf_baton
->needs_frame
= 1;
2648 return value_zero (type
, not_lval
);
2651 /* Reads from memory do not require a frame. */
2653 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
2655 memset (buf
, 0, len
);
2658 /* Frame-relative accesses do require a frame. */
2660 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
2662 static gdb_byte lit0
= DW_OP_lit0
;
2663 struct needs_frame_baton
*nf_baton
= baton
;
2668 nf_baton
->needs_frame
= 1;
2671 /* CFA accesses require a frame. */
2674 needs_frame_frame_cfa (void *baton
)
2676 struct needs_frame_baton
*nf_baton
= baton
;
2678 nf_baton
->needs_frame
= 1;
2682 /* Thread-local accesses do require a frame. */
2684 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
2686 struct needs_frame_baton
*nf_baton
= baton
;
2688 nf_baton
->needs_frame
= 1;
2692 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2695 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
2697 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2699 per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
,
2700 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
2703 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2706 needs_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
2707 enum call_site_parameter_kind kind
,
2708 union call_site_parameter_u kind_u
, int deref_size
)
2710 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2712 nf_baton
->needs_frame
= 1;
2714 /* The expression may require some stub values on DWARF stack. */
2715 dwarf_expr_push_address (ctx
, 0, 0);
2718 /* DW_OP_GNU_addr_index doesn't require a frame. */
2721 needs_get_addr_index (void *baton
, unsigned int index
)
2723 /* Nothing to do. */
2727 /* DW_OP_push_object_address has a frame already passed through. */
2730 needs_get_obj_addr (void *baton
)
2732 /* Nothing to do. */
2736 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2738 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs
=
2740 needs_frame_read_addr_from_reg
,
2741 needs_frame_get_reg_value
,
2742 needs_frame_read_mem
,
2743 needs_frame_frame_base
,
2744 needs_frame_frame_cfa
,
2745 needs_frame_frame_cfa
, /* get_frame_pc */
2746 needs_frame_tls_address
,
2747 needs_frame_dwarf_call
,
2748 NULL
, /* get_base_type */
2749 needs_dwarf_reg_entry_value
,
2750 needs_get_addr_index
,
2754 /* Return non-zero iff the location expression at DATA (length SIZE)
2755 requires a frame to evaluate. */
2758 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, size_t size
,
2759 struct dwarf2_per_cu_data
*per_cu
)
2761 struct needs_frame_baton baton
;
2762 struct dwarf_expr_context
*ctx
;
2764 struct cleanup
*old_chain
;
2765 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2767 baton
.needs_frame
= 0;
2768 baton
.per_cu
= per_cu
;
2770 ctx
= new_dwarf_expr_context ();
2771 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2772 make_cleanup_value_free_to_mark (value_mark ());
2774 ctx
->gdbarch
= get_objfile_arch (objfile
);
2775 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2776 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2777 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2778 ctx
->baton
= &baton
;
2779 ctx
->funcs
= &needs_frame_ctx_funcs
;
2781 dwarf_expr_eval (ctx
, data
, size
);
2783 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
2785 if (ctx
->num_pieces
> 0)
2789 /* If the location has several pieces, and any of them are in
2790 registers, then we will need a frame to fetch them from. */
2791 for (i
= 0; i
< ctx
->num_pieces
; i
++)
2792 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2796 do_cleanups (old_chain
);
2798 return baton
.needs_frame
|| in_reg
;
2801 /* A helper function that throws an unimplemented error mentioning a
2802 given DWARF operator. */
2805 unimplemented (unsigned int op
)
2807 const char *name
= get_DW_OP_name (op
);
2810 error (_("DWARF operator %s cannot be translated to an agent expression"),
2813 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2814 "to an agent expression"),
2818 /* See dwarf2loc.h. */
2821 dwarf2_reg_to_regnum_or_error (struct gdbarch
*arch
, int dwarf_reg
)
2823 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2825 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
2829 /* A helper function that emits an access to memory. ARCH is the
2830 target architecture. EXPR is the expression which we are building.
2831 NBITS is the number of bits we want to read. This emits the
2832 opcodes needed to read the memory and then extract the desired
2836 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2838 ULONGEST nbytes
= (nbits
+ 7) / 8;
2840 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2843 ax_trace_quick (expr
, nbytes
);
2846 ax_simple (expr
, aop_ref8
);
2847 else if (nbits
<= 16)
2848 ax_simple (expr
, aop_ref16
);
2849 else if (nbits
<= 32)
2850 ax_simple (expr
, aop_ref32
);
2852 ax_simple (expr
, aop_ref64
);
2854 /* If we read exactly the number of bytes we wanted, we're done. */
2855 if (8 * nbytes
== nbits
)
2858 if (gdbarch_bits_big_endian (arch
))
2860 /* On a bits-big-endian machine, we want the high-order
2862 ax_const_l (expr
, 8 * nbytes
- nbits
);
2863 ax_simple (expr
, aop_rsh_unsigned
);
2867 /* On a bits-little-endian box, we want the low-order NBITS. */
2868 ax_zero_ext (expr
, nbits
);
2872 /* A helper function to return the frame's PC. */
2875 get_ax_pc (void *baton
)
2877 struct agent_expr
*expr
= baton
;
2882 /* Compile a DWARF location expression to an agent expression.
2884 EXPR is the agent expression we are building.
2885 LOC is the agent value we modify.
2886 ARCH is the architecture.
2887 ADDR_SIZE is the size of addresses, in bytes.
2888 OP_PTR is the start of the location expression.
2889 OP_END is one past the last byte of the location expression.
2891 This will throw an exception for various kinds of errors -- for
2892 example, if the expression cannot be compiled, or if the expression
2896 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2897 struct gdbarch
*arch
, unsigned int addr_size
,
2898 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
2899 struct dwarf2_per_cu_data
*per_cu
)
2901 struct cleanup
*cleanups
;
2903 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
2904 const gdb_byte
* const base
= op_ptr
;
2905 const gdb_byte
*previous_piece
= op_ptr
;
2906 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2907 ULONGEST bits_collected
= 0;
2908 unsigned int addr_size_bits
= 8 * addr_size
;
2909 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
2911 offsets
= xmalloc ((op_end
- op_ptr
) * sizeof (int));
2912 cleanups
= make_cleanup (xfree
, offsets
);
2914 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
2917 make_cleanup (VEC_cleanup (int), &dw_labels
);
2918 make_cleanup (VEC_cleanup (int), &patches
);
2920 /* By default we are making an address. */
2921 loc
->kind
= axs_lvalue_memory
;
2923 while (op_ptr
< op_end
)
2925 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
2926 uint64_t uoffset
, reg
;
2930 offsets
[op_ptr
- base
] = expr
->len
;
2933 /* Our basic approach to code generation is to map DWARF
2934 operations directly to AX operations. However, there are
2937 First, DWARF works on address-sized units, but AX always uses
2938 LONGEST. For most operations we simply ignore this
2939 difference; instead we generate sign extensions as needed
2940 before division and comparison operations. It would be nice
2941 to omit the sign extensions, but there is no way to determine
2942 the size of the target's LONGEST. (This code uses the size
2943 of the host LONGEST in some cases -- that is a bug but it is
2946 Second, some DWARF operations cannot be translated to AX.
2947 For these we simply fail. See
2948 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2983 ax_const_l (expr
, op
- DW_OP_lit0
);
2987 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
2988 op_ptr
+= addr_size
;
2989 /* Some versions of GCC emit DW_OP_addr before
2990 DW_OP_GNU_push_tls_address. In this case the value is an
2991 index, not an address. We don't support things like
2992 branching between the address and the TLS op. */
2993 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
2994 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
2995 ax_const_l (expr
, uoffset
);
2999 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
3003 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
3007 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
3011 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
3015 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
3019 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
3023 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
3027 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
3031 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3032 ax_const_l (expr
, uoffset
);
3035 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3036 ax_const_l (expr
, offset
);
3071 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3072 loc
->u
.reg
= dwarf2_reg_to_regnum_or_error (arch
, op
- DW_OP_reg0
);
3073 loc
->kind
= axs_lvalue_register
;
3077 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3078 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3079 loc
->u
.reg
= dwarf2_reg_to_regnum_or_error (arch
, reg
);
3080 loc
->kind
= axs_lvalue_register
;
3083 case DW_OP_implicit_value
:
3087 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
3088 if (op_ptr
+ len
> op_end
)
3089 error (_("DW_OP_implicit_value: too few bytes available."));
3090 if (len
> sizeof (ULONGEST
))
3091 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
3094 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
3097 dwarf_expr_require_composition (op_ptr
, op_end
,
3098 "DW_OP_implicit_value");
3100 loc
->kind
= axs_rvalue
;
3104 case DW_OP_stack_value
:
3105 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
3106 loc
->kind
= axs_rvalue
;
3141 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3142 i
= dwarf2_reg_to_regnum_or_error (arch
, op
- DW_OP_breg0
);
3146 ax_const_l (expr
, offset
);
3147 ax_simple (expr
, aop_add
);
3152 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3153 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3154 i
= dwarf2_reg_to_regnum_or_error (arch
, reg
);
3158 ax_const_l (expr
, offset
);
3159 ax_simple (expr
, aop_add
);
3165 const gdb_byte
*datastart
;
3167 const struct block
*b
;
3168 struct symbol
*framefunc
;
3170 b
= block_for_pc (expr
->scope
);
3173 error (_("No block found for address"));
3175 framefunc
= block_linkage_function (b
);
3178 error (_("No function found for block"));
3180 func_get_frame_base_dwarf_block (framefunc
, expr
->scope
,
3181 &datastart
, &datalen
);
3183 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3184 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
3185 datastart
+ datalen
, per_cu
);
3186 if (loc
->kind
== axs_lvalue_register
)
3187 require_rvalue (expr
, loc
);
3191 ax_const_l (expr
, offset
);
3192 ax_simple (expr
, aop_add
);
3195 loc
->kind
= axs_lvalue_memory
;
3200 ax_simple (expr
, aop_dup
);
3204 ax_simple (expr
, aop_pop
);
3209 ax_pick (expr
, offset
);
3213 ax_simple (expr
, aop_swap
);
3221 ax_simple (expr
, aop_rot
);
3225 case DW_OP_deref_size
:
3229 if (op
== DW_OP_deref_size
)
3234 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3235 error (_("Unsupported size %d in %s"),
3236 size
, get_DW_OP_name (op
));
3237 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3242 /* Sign extend the operand. */
3243 ax_ext (expr
, addr_size_bits
);
3244 ax_simple (expr
, aop_dup
);
3245 ax_const_l (expr
, 0);
3246 ax_simple (expr
, aop_less_signed
);
3247 ax_simple (expr
, aop_log_not
);
3248 i
= ax_goto (expr
, aop_if_goto
);
3249 /* We have to emit 0 - X. */
3250 ax_const_l (expr
, 0);
3251 ax_simple (expr
, aop_swap
);
3252 ax_simple (expr
, aop_sub
);
3253 ax_label (expr
, i
, expr
->len
);
3257 /* No need to sign extend here. */
3258 ax_const_l (expr
, 0);
3259 ax_simple (expr
, aop_swap
);
3260 ax_simple (expr
, aop_sub
);
3264 /* Sign extend the operand. */
3265 ax_ext (expr
, addr_size_bits
);
3266 ax_simple (expr
, aop_bit_not
);
3269 case DW_OP_plus_uconst
:
3270 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3271 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3272 but we micro-optimize anyhow. */
3275 ax_const_l (expr
, reg
);
3276 ax_simple (expr
, aop_add
);
3281 ax_simple (expr
, aop_bit_and
);
3285 /* Sign extend the operands. */
3286 ax_ext (expr
, addr_size_bits
);
3287 ax_simple (expr
, aop_swap
);
3288 ax_ext (expr
, addr_size_bits
);
3289 ax_simple (expr
, aop_swap
);
3290 ax_simple (expr
, aop_div_signed
);
3294 ax_simple (expr
, aop_sub
);
3298 ax_simple (expr
, aop_rem_unsigned
);
3302 ax_simple (expr
, aop_mul
);
3306 ax_simple (expr
, aop_bit_or
);
3310 ax_simple (expr
, aop_add
);
3314 ax_simple (expr
, aop_lsh
);
3318 ax_simple (expr
, aop_rsh_unsigned
);
3322 ax_simple (expr
, aop_rsh_signed
);
3326 ax_simple (expr
, aop_bit_xor
);
3330 /* Sign extend the operands. */
3331 ax_ext (expr
, addr_size_bits
);
3332 ax_simple (expr
, aop_swap
);
3333 ax_ext (expr
, addr_size_bits
);
3334 /* Note no swap here: A <= B is !(B < A). */
3335 ax_simple (expr
, aop_less_signed
);
3336 ax_simple (expr
, aop_log_not
);
3340 /* Sign extend the operands. */
3341 ax_ext (expr
, addr_size_bits
);
3342 ax_simple (expr
, aop_swap
);
3343 ax_ext (expr
, addr_size_bits
);
3344 ax_simple (expr
, aop_swap
);
3345 /* A >= B is !(A < B). */
3346 ax_simple (expr
, aop_less_signed
);
3347 ax_simple (expr
, aop_log_not
);
3351 /* Sign extend the operands. */
3352 ax_ext (expr
, addr_size_bits
);
3353 ax_simple (expr
, aop_swap
);
3354 ax_ext (expr
, addr_size_bits
);
3355 /* No need for a second swap here. */
3356 ax_simple (expr
, aop_equal
);
3360 /* Sign extend the operands. */
3361 ax_ext (expr
, addr_size_bits
);
3362 ax_simple (expr
, aop_swap
);
3363 ax_ext (expr
, addr_size_bits
);
3364 ax_simple (expr
, aop_swap
);
3365 ax_simple (expr
, aop_less_signed
);
3369 /* Sign extend the operands. */
3370 ax_ext (expr
, addr_size_bits
);
3371 ax_simple (expr
, aop_swap
);
3372 ax_ext (expr
, addr_size_bits
);
3373 /* Note no swap here: A > B is B < A. */
3374 ax_simple (expr
, aop_less_signed
);
3378 /* Sign extend the operands. */
3379 ax_ext (expr
, addr_size_bits
);
3380 ax_simple (expr
, aop_swap
);
3381 ax_ext (expr
, addr_size_bits
);
3382 /* No need for a swap here. */
3383 ax_simple (expr
, aop_equal
);
3384 ax_simple (expr
, aop_log_not
);
3387 case DW_OP_call_frame_cfa
:
3390 CORE_ADDR text_offset
;
3392 const gdb_byte
*cfa_start
, *cfa_end
;
3394 if (dwarf2_fetch_cfa_info (arch
, expr
->scope
, per_cu
,
3396 &text_offset
, &cfa_start
, &cfa_end
))
3399 ax_reg (expr
, regnum
);
3402 ax_const_l (expr
, off
);
3403 ax_simple (expr
, aop_add
);
3408 /* Another expression. */
3409 ax_const_l (expr
, text_offset
);
3410 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3411 cfa_start
, cfa_end
, per_cu
);
3414 loc
->kind
= axs_lvalue_memory
;
3418 case DW_OP_GNU_push_tls_address
:
3422 case DW_OP_push_object_address
:
3427 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3429 i
= ax_goto (expr
, aop_goto
);
3430 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3431 VEC_safe_push (int, patches
, i
);
3435 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3437 /* Zero extend the operand. */
3438 ax_zero_ext (expr
, addr_size_bits
);
3439 i
= ax_goto (expr
, aop_if_goto
);
3440 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3441 VEC_safe_push (int, patches
, i
);
3448 case DW_OP_bit_piece
:
3450 uint64_t size
, offset
;
3452 if (op_ptr
- 1 == previous_piece
)
3453 error (_("Cannot translate empty pieces to agent expressions"));
3454 previous_piece
= op_ptr
- 1;
3456 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3457 if (op
== DW_OP_piece
)
3463 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
3465 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3466 error (_("Expression pieces exceed word size"));
3468 /* Access the bits. */
3471 case axs_lvalue_register
:
3472 ax_reg (expr
, loc
->u
.reg
);
3475 case axs_lvalue_memory
:
3476 /* Offset the pointer, if needed. */
3479 ax_const_l (expr
, offset
/ 8);
3480 ax_simple (expr
, aop_add
);
3483 access_memory (arch
, expr
, size
);
3487 /* For a bits-big-endian target, shift up what we already
3488 have. For a bits-little-endian target, shift up the
3489 new data. Note that there is a potential bug here if
3490 the DWARF expression leaves multiple values on the
3492 if (bits_collected
> 0)
3494 if (bits_big_endian
)
3496 ax_simple (expr
, aop_swap
);
3497 ax_const_l (expr
, size
);
3498 ax_simple (expr
, aop_lsh
);
3499 /* We don't need a second swap here, because
3500 aop_bit_or is symmetric. */
3504 ax_const_l (expr
, size
);
3505 ax_simple (expr
, aop_lsh
);
3507 ax_simple (expr
, aop_bit_or
);
3510 bits_collected
+= size
;
3511 loc
->kind
= axs_rvalue
;
3515 case DW_OP_GNU_uninit
:
3521 struct dwarf2_locexpr_baton block
;
3522 int size
= (op
== DW_OP_call2
? 2 : 4);
3525 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3528 offset
.cu_off
= uoffset
;
3529 block
= dwarf2_fetch_die_loc_cu_off (offset
, per_cu
,
3532 /* DW_OP_call_ref is currently not supported. */
3533 gdb_assert (block
.per_cu
== per_cu
);
3535 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3536 block
.data
, block
.data
+ block
.size
,
3541 case DW_OP_call_ref
:
3549 /* Patch all the branches we emitted. */
3550 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
3552 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
3554 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3555 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
3558 do_cleanups (cleanups
);
3562 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3563 evaluator to calculate the location. */
3564 static struct value
*
3565 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3567 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3570 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3571 dlbaton
->size
, dlbaton
->per_cu
);
3576 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3577 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3580 static struct value
*
3581 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3583 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3585 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3589 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3591 locexpr_read_needs_frame (struct symbol
*symbol
)
3593 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3595 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
3599 /* Return true if DATA points to the end of a piece. END is one past
3600 the last byte in the expression. */
3603 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3605 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3608 /* Helper for locexpr_describe_location_piece that finds the name of a
3612 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3616 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
3617 return gdbarch_register_name (gdbarch
, regnum
);
3620 /* Nicely describe a single piece of a location, returning an updated
3621 position in the bytecode sequence. This function cannot recognize
3622 all locations; if a location is not recognized, it simply returns
3623 DATA. If there is an error during reading, e.g. we run off the end
3624 of the buffer, an error is thrown. */
3626 static const gdb_byte
*
3627 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3628 CORE_ADDR addr
, struct objfile
*objfile
,
3629 struct dwarf2_per_cu_data
*per_cu
,
3630 const gdb_byte
*data
, const gdb_byte
*end
,
3631 unsigned int addr_size
)
3633 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3636 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3638 fprintf_filtered (stream
, _("a variable in $%s"),
3639 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3642 else if (data
[0] == DW_OP_regx
)
3646 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3647 fprintf_filtered (stream
, _("a variable in $%s"),
3648 locexpr_regname (gdbarch
, reg
));
3650 else if (data
[0] == DW_OP_fbreg
)
3652 const struct block
*b
;
3653 struct symbol
*framefunc
;
3655 int64_t frame_offset
;
3656 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3658 int64_t base_offset
= 0;
3660 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3661 if (!piece_end_p (new_data
, end
))
3665 b
= block_for_pc (addr
);
3668 error (_("No block found for address for symbol \"%s\"."),
3669 SYMBOL_PRINT_NAME (symbol
));
3671 framefunc
= block_linkage_function (b
);
3674 error (_("No function found for block for symbol \"%s\"."),
3675 SYMBOL_PRINT_NAME (symbol
));
3677 func_get_frame_base_dwarf_block (framefunc
, addr
, &base_data
, &base_size
);
3679 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3681 const gdb_byte
*buf_end
;
3683 frame_reg
= base_data
[0] - DW_OP_breg0
;
3684 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3686 if (buf_end
!= base_data
+ base_size
)
3687 error (_("Unexpected opcode after "
3688 "DW_OP_breg%u for symbol \"%s\"."),
3689 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3691 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3693 /* The frame base is just the register, with no offset. */
3694 frame_reg
= base_data
[0] - DW_OP_reg0
;
3699 /* We don't know what to do with the frame base expression,
3700 so we can't trace this variable; give up. */
3704 fprintf_filtered (stream
,
3705 _("a variable at frame base reg $%s offset %s+%s"),
3706 locexpr_regname (gdbarch
, frame_reg
),
3707 plongest (base_offset
), plongest (frame_offset
));
3709 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3710 && piece_end_p (data
, end
))
3714 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3716 fprintf_filtered (stream
,
3717 _("a variable at offset %s from base reg $%s"),
3719 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3722 /* The location expression for a TLS variable looks like this (on a
3725 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3726 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3728 0x3 is the encoding for DW_OP_addr, which has an operand as long
3729 as the size of an address on the target machine (here is 8
3730 bytes). Note that more recent version of GCC emit DW_OP_const4u
3731 or DW_OP_const8u, depending on address size, rather than
3732 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3733 The operand represents the offset at which the variable is within
3734 the thread local storage. */
3736 else if (data
+ 1 + addr_size
< end
3737 && (data
[0] == DW_OP_addr
3738 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3739 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3740 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3741 && piece_end_p (data
+ 2 + addr_size
, end
))
3744 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3745 gdbarch_byte_order (gdbarch
));
3747 fprintf_filtered (stream
,
3748 _("a thread-local variable at offset 0x%s "
3749 "in the thread-local storage for `%s'"),
3750 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3752 data
+= 1 + addr_size
+ 1;
3755 /* With -gsplit-dwarf a TLS variable can also look like this:
3756 DW_AT_location : 3 byte block: fc 4 e0
3757 (DW_OP_GNU_const_index: 4;
3758 DW_OP_GNU_push_tls_address) */
3759 else if (data
+ 3 <= end
3760 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3761 && data
[0] == DW_OP_GNU_const_index
3763 && data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3764 && piece_end_p (data
+ 2 + leb128_size
, end
))
3768 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3769 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3770 fprintf_filtered (stream
,
3771 _("a thread-local variable at offset 0x%s "
3772 "in the thread-local storage for `%s'"),
3773 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3777 else if (data
[0] >= DW_OP_lit0
3778 && data
[0] <= DW_OP_lit31
3780 && data
[1] == DW_OP_stack_value
)
3782 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3789 /* Disassemble an expression, stopping at the end of a piece or at the
3790 end of the expression. Returns a pointer to the next unread byte
3791 in the input expression. If ALL is nonzero, then this function
3792 will keep going until it reaches the end of the expression.
3793 If there is an error during reading, e.g. we run off the end
3794 of the buffer, an error is thrown. */
3796 static const gdb_byte
*
3797 disassemble_dwarf_expression (struct ui_file
*stream
,
3798 struct gdbarch
*arch
, unsigned int addr_size
,
3799 int offset_size
, const gdb_byte
*start
,
3800 const gdb_byte
*data
, const gdb_byte
*end
,
3801 int indent
, int all
,
3802 struct dwarf2_per_cu_data
*per_cu
)
3806 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3808 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *data
++;
3813 name
= get_DW_OP_name (op
);
3816 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3817 op
, (long) (data
- 1 - start
));
3818 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3819 (long) (data
- 1 - start
), name
);
3824 ul
= extract_unsigned_integer (data
, addr_size
,
3825 gdbarch_byte_order (arch
));
3827 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3831 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3833 fprintf_filtered (stream
, " %s", pulongest (ul
));
3836 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3838 fprintf_filtered (stream
, " %s", plongest (l
));
3841 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3843 fprintf_filtered (stream
, " %s", pulongest (ul
));
3846 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3848 fprintf_filtered (stream
, " %s", plongest (l
));
3851 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3853 fprintf_filtered (stream
, " %s", pulongest (ul
));
3856 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3858 fprintf_filtered (stream
, " %s", plongest (l
));
3861 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3863 fprintf_filtered (stream
, " %s", pulongest (ul
));
3866 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3868 fprintf_filtered (stream
, " %s", plongest (l
));
3871 data
= safe_read_uleb128 (data
, end
, &ul
);
3872 fprintf_filtered (stream
, " %s", pulongest (ul
));
3875 data
= safe_read_sleb128 (data
, end
, &l
);
3876 fprintf_filtered (stream
, " %s", plongest (l
));
3911 fprintf_filtered (stream
, " [$%s]",
3912 locexpr_regname (arch
, op
- DW_OP_reg0
));
3916 data
= safe_read_uleb128 (data
, end
, &ul
);
3917 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3918 locexpr_regname (arch
, (int) ul
));
3921 case DW_OP_implicit_value
:
3922 data
= safe_read_uleb128 (data
, end
, &ul
);
3924 fprintf_filtered (stream
, " %s", pulongest (ul
));
3959 data
= safe_read_sleb128 (data
, end
, &l
);
3960 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
3961 locexpr_regname (arch
, op
- DW_OP_breg0
));
3965 data
= safe_read_uleb128 (data
, end
, &ul
);
3966 data
= safe_read_sleb128 (data
, end
, &l
);
3967 fprintf_filtered (stream
, " register %s [$%s] offset %s",
3969 locexpr_regname (arch
, (int) ul
),
3974 data
= safe_read_sleb128 (data
, end
, &l
);
3975 fprintf_filtered (stream
, " %s", plongest (l
));
3978 case DW_OP_xderef_size
:
3979 case DW_OP_deref_size
:
3981 fprintf_filtered (stream
, " %d", *data
);
3985 case DW_OP_plus_uconst
:
3986 data
= safe_read_uleb128 (data
, end
, &ul
);
3987 fprintf_filtered (stream
, " %s", pulongest (ul
));
3991 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3993 fprintf_filtered (stream
, " to %ld",
3994 (long) (data
+ l
- start
));
3998 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4000 fprintf_filtered (stream
, " %ld",
4001 (long) (data
+ l
- start
));
4005 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
4007 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
4011 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4013 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4016 case DW_OP_call_ref
:
4017 ul
= extract_unsigned_integer (data
, offset_size
,
4018 gdbarch_byte_order (arch
));
4019 data
+= offset_size
;
4020 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4024 data
= safe_read_uleb128 (data
, end
, &ul
);
4025 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
4028 case DW_OP_bit_piece
:
4032 data
= safe_read_uleb128 (data
, end
, &ul
);
4033 data
= safe_read_uleb128 (data
, end
, &offset
);
4034 fprintf_filtered (stream
, " size %s offset %s (bits)",
4035 pulongest (ul
), pulongest (offset
));
4039 case DW_OP_GNU_implicit_pointer
:
4041 ul
= extract_unsigned_integer (data
, offset_size
,
4042 gdbarch_byte_order (arch
));
4043 data
+= offset_size
;
4045 data
= safe_read_sleb128 (data
, end
, &l
);
4047 fprintf_filtered (stream
, " DIE %s offset %s",
4048 phex_nz (ul
, offset_size
),
4053 case DW_OP_GNU_deref_type
:
4055 int addr_size
= *data
++;
4059 data
= safe_read_uleb128 (data
, end
, &ul
);
4061 type
= dwarf2_get_die_type (offset
, per_cu
);
4062 fprintf_filtered (stream
, "<");
4063 type_print (type
, "", stream
, -1);
4064 fprintf_filtered (stream
, " [0x%s]> %d", phex_nz (offset
.cu_off
, 0),
4069 case DW_OP_GNU_const_type
:
4074 data
= safe_read_uleb128 (data
, end
, &ul
);
4075 type_die
.cu_off
= ul
;
4076 type
= dwarf2_get_die_type (type_die
, per_cu
);
4077 fprintf_filtered (stream
, "<");
4078 type_print (type
, "", stream
, -1);
4079 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
4083 case DW_OP_GNU_regval_type
:
4089 data
= safe_read_uleb128 (data
, end
, ®
);
4090 data
= safe_read_uleb128 (data
, end
, &ul
);
4091 type_die
.cu_off
= ul
;
4093 type
= dwarf2_get_die_type (type_die
, per_cu
);
4094 fprintf_filtered (stream
, "<");
4095 type_print (type
, "", stream
, -1);
4096 fprintf_filtered (stream
, " [0x%s]> [$%s]",
4097 phex_nz (type_die
.cu_off
, 0),
4098 locexpr_regname (arch
, reg
));
4102 case DW_OP_GNU_convert
:
4103 case DW_OP_GNU_reinterpret
:
4107 data
= safe_read_uleb128 (data
, end
, &ul
);
4108 type_die
.cu_off
= ul
;
4110 if (type_die
.cu_off
== 0)
4111 fprintf_filtered (stream
, "<0>");
4116 type
= dwarf2_get_die_type (type_die
, per_cu
);
4117 fprintf_filtered (stream
, "<");
4118 type_print (type
, "", stream
, -1);
4119 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
4124 case DW_OP_GNU_entry_value
:
4125 data
= safe_read_uleb128 (data
, end
, &ul
);
4126 fputc_filtered ('\n', stream
);
4127 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
4128 start
, data
, data
+ ul
, indent
+ 2,
4133 case DW_OP_GNU_parameter_ref
:
4134 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4136 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4139 case DW_OP_GNU_addr_index
:
4140 data
= safe_read_uleb128 (data
, end
, &ul
);
4141 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4142 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
4144 case DW_OP_GNU_const_index
:
4145 data
= safe_read_uleb128 (data
, end
, &ul
);
4146 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4147 fprintf_filtered (stream
, " %s", pulongest (ul
));
4151 fprintf_filtered (stream
, "\n");
4157 /* Describe a single location, which may in turn consist of multiple
4161 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
4162 struct ui_file
*stream
,
4163 const gdb_byte
*data
, size_t size
,
4164 struct objfile
*objfile
, unsigned int addr_size
,
4165 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
4167 const gdb_byte
*end
= data
+ size
;
4168 int first_piece
= 1, bad
= 0;
4172 const gdb_byte
*here
= data
;
4173 int disassemble
= 1;
4178 fprintf_filtered (stream
, _(", and "));
4180 if (!dwarf_always_disassemble
)
4182 data
= locexpr_describe_location_piece (symbol
, stream
,
4183 addr
, objfile
, per_cu
,
4184 data
, end
, addr_size
);
4185 /* If we printed anything, or if we have an empty piece,
4186 then don't disassemble. */
4188 || data
[0] == DW_OP_piece
4189 || data
[0] == DW_OP_bit_piece
)
4194 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
4195 data
= disassemble_dwarf_expression (stream
,
4196 get_objfile_arch (objfile
),
4197 addr_size
, offset_size
, data
,
4199 dwarf_always_disassemble
,
4205 int empty
= data
== here
;
4208 fprintf_filtered (stream
, " ");
4209 if (data
[0] == DW_OP_piece
)
4213 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
4216 fprintf_filtered (stream
, _("an empty %s-byte piece"),
4219 fprintf_filtered (stream
, _(" [%s-byte piece]"),
4222 else if (data
[0] == DW_OP_bit_piece
)
4224 uint64_t bits
, offset
;
4226 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
4227 data
= safe_read_uleb128 (data
, end
, &offset
);
4230 fprintf_filtered (stream
,
4231 _("an empty %s-bit piece"),
4234 fprintf_filtered (stream
,
4235 _(" [%s-bit piece, offset %s bits]"),
4236 pulongest (bits
), pulongest (offset
));
4246 if (bad
|| data
> end
)
4247 error (_("Corrupted DWARF2 expression for \"%s\"."),
4248 SYMBOL_PRINT_NAME (symbol
));
4251 /* Print a natural-language description of SYMBOL to STREAM. This
4252 version is for a symbol with a single location. */
4255 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4256 struct ui_file
*stream
)
4258 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4259 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4260 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4261 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4263 locexpr_describe_location_1 (symbol
, addr
, stream
,
4264 dlbaton
->data
, dlbaton
->size
,
4265 objfile
, addr_size
, offset_size
,
4269 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4270 any necessary bytecode in AX. */
4273 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4274 struct agent_expr
*ax
, struct axs_value
*value
)
4276 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4277 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4279 if (dlbaton
->size
== 0)
4280 value
->optimized_out
= 1;
4282 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
4283 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4287 /* symbol_computed_ops 'generate_c_location' method. */
4290 locexpr_generate_c_location (struct symbol
*sym
, struct ui_file
*stream
,
4291 struct gdbarch
*gdbarch
,
4292 unsigned char *registers_used
,
4293 CORE_ADDR pc
, const char *result_name
)
4295 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (sym
);
4296 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4298 if (dlbaton
->size
== 0)
4299 error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym
));
4301 compile_dwarf_expr_to_c (stream
, result_name
,
4302 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4303 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4307 /* The set of location functions used with the DWARF-2 expression
4309 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4310 locexpr_read_variable
,
4311 locexpr_read_variable_at_entry
,
4312 locexpr_read_needs_frame
,
4313 locexpr_describe_location
,
4314 0, /* location_has_loclist */
4315 locexpr_tracepoint_var_ref
,
4316 locexpr_generate_c_location
4320 /* Wrapper functions for location lists. These generally find
4321 the appropriate location expression and call something above. */
4323 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4324 evaluator to calculate the location. */
4325 static struct value
*
4326 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4328 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4330 const gdb_byte
*data
;
4332 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4334 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4335 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4341 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4342 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4345 Function always returns non-NULL value, it may be marked optimized out if
4346 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4347 if it cannot resolve the parameter for any reason. */
4349 static struct value
*
4350 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4352 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4353 const gdb_byte
*data
;
4357 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4358 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4360 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4362 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4364 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4367 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
4369 loclist_read_needs_frame (struct symbol
*symbol
)
4371 /* If there's a location list, then assume we need to have a frame
4372 to choose the appropriate location expression. With tracking of
4373 global variables this is not necessarily true, but such tracking
4374 is disabled in GCC at the moment until we figure out how to
4380 /* Print a natural-language description of SYMBOL to STREAM. This
4381 version applies when there is a list of different locations, each
4382 with a specified address range. */
4385 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4386 struct ui_file
*stream
)
4388 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4389 const gdb_byte
*loc_ptr
, *buf_end
;
4390 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4391 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4392 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4393 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4394 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4395 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4396 /* Adjust base_address for relocatable objects. */
4397 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4398 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4401 loc_ptr
= dlbaton
->data
;
4402 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4404 fprintf_filtered (stream
, _("multi-location:\n"));
4406 /* Iterate through locations until we run out. */
4409 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4411 enum debug_loc_kind kind
;
4412 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4414 if (dlbaton
->from_dwo
)
4415 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4416 loc_ptr
, buf_end
, &new_ptr
,
4417 &low
, &high
, byte_order
);
4419 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4421 byte_order
, addr_size
,
4426 case DEBUG_LOC_END_OF_LIST
:
4429 case DEBUG_LOC_BASE_ADDRESS
:
4430 base_address
= high
+ base_offset
;
4431 fprintf_filtered (stream
, _(" Base address %s"),
4432 paddress (gdbarch
, base_address
));
4434 case DEBUG_LOC_START_END
:
4435 case DEBUG_LOC_START_LENGTH
:
4437 case DEBUG_LOC_BUFFER_OVERFLOW
:
4438 case DEBUG_LOC_INVALID_ENTRY
:
4439 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4440 SYMBOL_PRINT_NAME (symbol
));
4442 gdb_assert_not_reached ("bad debug_loc_kind");
4445 /* Otherwise, a location expression entry. */
4446 low
+= base_address
;
4447 high
+= base_address
;
4449 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
);
4450 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
);
4452 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4455 /* (It would improve readability to print only the minimum
4456 necessary digits of the second number of the range.) */
4457 fprintf_filtered (stream
, _(" Range %s-%s: "),
4458 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4460 /* Now describe this particular location. */
4461 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4462 objfile
, addr_size
, offset_size
,
4465 fprintf_filtered (stream
, "\n");
4471 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4472 any necessary bytecode in AX. */
4474 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4475 struct agent_expr
*ax
, struct axs_value
*value
)
4477 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4478 const gdb_byte
*data
;
4480 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4482 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4484 value
->optimized_out
= 1;
4486 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
4490 /* symbol_computed_ops 'generate_c_location' method. */
4493 loclist_generate_c_location (struct symbol
*sym
, struct ui_file
*stream
,
4494 struct gdbarch
*gdbarch
,
4495 unsigned char *registers_used
,
4496 CORE_ADDR pc
, const char *result_name
)
4498 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (sym
);
4499 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4500 const gdb_byte
*data
;
4503 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4505 error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym
));
4507 compile_dwarf_expr_to_c (stream
, result_name
,
4508 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4513 /* The set of location functions used with the DWARF-2 expression
4514 evaluator and location lists. */
4515 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4516 loclist_read_variable
,
4517 loclist_read_variable_at_entry
,
4518 loclist_read_needs_frame
,
4519 loclist_describe_location
,
4520 1, /* location_has_loclist */
4521 loclist_tracepoint_var_ref
,
4522 loclist_generate_c_location
4525 /* Provide a prototype to silence -Wmissing-prototypes. */
4526 extern initialize_file_ftype _initialize_dwarf2loc
;
4529 _initialize_dwarf2loc (void)
4531 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4532 &entry_values_debug
,
4533 _("Set entry values and tail call frames "
4535 _("Show entry values and tail call frames "
4537 _("When non-zero, the process of determining "
4538 "parameter values from function entry point "
4539 "and tail call frames will be printed."),
4541 show_entry_values_debug
,
4542 &setdebuglist
, &showdebuglist
);