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 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
385 function uses DWARF expression for its DW_AT_frame_base. */
387 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
389 locexpr_find_frame_base_location
392 /* Implement find_frame_base_location method for LOC_BLOCK functions using
393 DWARF location list for its DW_AT_frame_base. */
396 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
397 const gdb_byte
**start
, size_t *length
)
399 struct dwarf2_loclist_baton
*symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
401 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
404 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
405 function uses DWARF location list for its DW_AT_frame_base. */
407 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
409 loclist_find_frame_base_location
412 /* See dwarf2loc.h. */
415 func_get_frame_base_dwarf_block (struct symbol
*framefunc
, CORE_ADDR pc
,
416 const gdb_byte
**start
, size_t *length
)
418 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
420 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
422 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
428 error (_("Could not find the frame base for \"%s\"."),
429 SYMBOL_NATURAL_NAME (framefunc
));
432 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
433 the frame in BATON. */
436 dwarf_expr_frame_cfa (void *baton
)
438 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
440 return dwarf2_frame_cfa (debaton
->frame
);
443 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
444 the frame in BATON. */
447 dwarf_expr_frame_pc (void *baton
)
449 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
451 return get_frame_address_in_block (debaton
->frame
);
454 /* Using the objfile specified in BATON, find the address for the
455 current thread's thread-local storage with offset OFFSET. */
457 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
459 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
460 struct objfile
*objfile
= dwarf2_per_cu_objfile (debaton
->per_cu
);
462 return target_translate_tls_address (objfile
, offset
);
465 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
466 current CU (as is PER_CU). State of the CTX is not affected by the
470 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
471 struct dwarf2_per_cu_data
*per_cu
,
472 CORE_ADDR (*get_frame_pc
) (void *baton
),
475 struct dwarf2_locexpr_baton block
;
477 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
, get_frame_pc
, baton
);
479 /* DW_OP_call_ref is currently not supported. */
480 gdb_assert (block
.per_cu
== per_cu
);
482 dwarf_expr_eval (ctx
, block
.data
, block
.size
);
485 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
488 dwarf_expr_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
490 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
492 per_cu_dwarf_call (ctx
, die_offset
, debaton
->per_cu
,
493 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
496 /* Callback function for dwarf2_evaluate_loc_desc. */
499 dwarf_expr_get_base_type (struct dwarf_expr_context
*ctx
,
500 cu_offset die_offset
)
502 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
504 return dwarf2_get_die_type (die_offset
, debaton
->per_cu
);
507 /* See dwarf2loc.h. */
509 unsigned int entry_values_debug
= 0;
511 /* Helper to set entry_values_debug. */
514 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
515 struct cmd_list_element
*c
, const char *value
)
517 fprintf_filtered (file
,
518 _("Entry values and tail call frames debugging is %s.\n"),
522 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
523 CALLER_FRAME (for registers) can be NULL if it is not known. This function
524 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
527 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
528 struct call_site
*call_site
,
529 struct frame_info
*caller_frame
)
531 switch (FIELD_LOC_KIND (call_site
->target
))
533 case FIELD_LOC_KIND_DWARF_BLOCK
:
535 struct dwarf2_locexpr_baton
*dwarf_block
;
537 struct type
*caller_core_addr_type
;
538 struct gdbarch
*caller_arch
;
540 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
541 if (dwarf_block
== NULL
)
543 struct bound_minimal_symbol msym
;
545 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
546 throw_error (NO_ENTRY_VALUE_ERROR
,
547 _("DW_AT_GNU_call_site_target is not specified "
549 paddress (call_site_gdbarch
, call_site
->pc
),
550 (msym
.minsym
== NULL
? "???"
551 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
554 if (caller_frame
== NULL
)
556 struct bound_minimal_symbol msym
;
558 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
559 throw_error (NO_ENTRY_VALUE_ERROR
,
560 _("DW_AT_GNU_call_site_target DWARF block resolving "
561 "requires known frame which is currently not "
562 "available at %s in %s"),
563 paddress (call_site_gdbarch
, call_site
->pc
),
564 (msym
.minsym
== NULL
? "???"
565 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
568 caller_arch
= get_frame_arch (caller_frame
);
569 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
570 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
571 dwarf_block
->data
, dwarf_block
->size
,
572 dwarf_block
->per_cu
);
573 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
575 if (VALUE_LVAL (val
) == lval_memory
)
576 return value_address (val
);
578 return value_as_address (val
);
581 case FIELD_LOC_KIND_PHYSNAME
:
583 const char *physname
;
584 struct bound_minimal_symbol msym
;
586 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
588 /* Handle both the mangled and demangled PHYSNAME. */
589 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
590 if (msym
.minsym
== NULL
)
592 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
593 throw_error (NO_ENTRY_VALUE_ERROR
,
594 _("Cannot find function \"%s\" for a call site target "
596 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
597 (msym
.minsym
== NULL
? "???"
598 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
601 return BMSYMBOL_VALUE_ADDRESS (msym
);
604 case FIELD_LOC_KIND_PHYSADDR
:
605 return FIELD_STATIC_PHYSADDR (call_site
->target
);
608 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
612 /* Convert function entry point exact address ADDR to the function which is
613 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
614 NO_ENTRY_VALUE_ERROR otherwise. */
616 static struct symbol
*
617 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
619 struct symbol
*sym
= find_pc_function (addr
);
622 if (sym
== NULL
|| BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
623 throw_error (NO_ENTRY_VALUE_ERROR
,
624 _("DW_TAG_GNU_call_site resolving failed to find function "
625 "name for address %s"),
626 paddress (gdbarch
, addr
));
628 type
= SYMBOL_TYPE (sym
);
629 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
630 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
635 /* Verify function with entry point exact address ADDR can never call itself
636 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
637 can call itself via tail calls.
639 If a funtion can tail call itself its entry value based parameters are
640 unreliable. There is no verification whether the value of some/all
641 parameters is unchanged through the self tail call, we expect if there is
642 a self tail call all the parameters can be modified. */
645 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
647 struct obstack addr_obstack
;
648 struct cleanup
*old_chain
;
651 /* Track here CORE_ADDRs which were already visited. */
654 /* The verification is completely unordered. Track here function addresses
655 which still need to be iterated. */
656 VEC (CORE_ADDR
) *todo
= NULL
;
658 obstack_init (&addr_obstack
);
659 old_chain
= make_cleanup_obstack_free (&addr_obstack
);
660 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
661 &addr_obstack
, hashtab_obstack_allocate
,
663 make_cleanup_htab_delete (addr_hash
);
665 make_cleanup (VEC_cleanup (CORE_ADDR
), &todo
);
667 VEC_safe_push (CORE_ADDR
, todo
, verify_addr
);
668 while (!VEC_empty (CORE_ADDR
, todo
))
670 struct symbol
*func_sym
;
671 struct call_site
*call_site
;
673 addr
= VEC_pop (CORE_ADDR
, todo
);
675 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
677 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
678 call_site
; call_site
= call_site
->tail_call_next
)
680 CORE_ADDR target_addr
;
683 /* CALLER_FRAME with registers is not available for tail-call jumped
685 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
687 if (target_addr
== verify_addr
)
689 struct bound_minimal_symbol msym
;
691 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
692 throw_error (NO_ENTRY_VALUE_ERROR
,
693 _("DW_OP_GNU_entry_value resolving has found "
694 "function \"%s\" at %s can call itself via tail "
696 (msym
.minsym
== NULL
? "???"
697 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
698 paddress (gdbarch
, verify_addr
));
701 slot
= htab_find_slot (addr_hash
, &target_addr
, INSERT
);
704 *slot
= obstack_copy (&addr_obstack
, &target_addr
,
705 sizeof (target_addr
));
706 VEC_safe_push (CORE_ADDR
, todo
, target_addr
);
711 do_cleanups (old_chain
);
714 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
715 ENTRY_VALUES_DEBUG. */
718 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
720 CORE_ADDR addr
= call_site
->pc
;
721 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
723 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
724 (msym
.minsym
== NULL
? "???"
725 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
729 /* vec.h needs single word type name, typedef it. */
730 typedef struct call_site
*call_sitep
;
732 /* Define VEC (call_sitep) functions. */
733 DEF_VEC_P (call_sitep
);
735 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
736 only top callers and bottom callees which are present in both. GDBARCH is
737 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
738 no remaining possibilities to provide unambiguous non-trivial result.
739 RESULTP should point to NULL on the first (initialization) call. Caller is
740 responsible for xfree of any RESULTP data. */
743 chain_candidate (struct gdbarch
*gdbarch
, struct call_site_chain
**resultp
,
744 VEC (call_sitep
) *chain
)
746 struct call_site_chain
*result
= *resultp
;
747 long length
= VEC_length (call_sitep
, chain
);
748 int callers
, callees
, idx
;
752 /* Create the initial chain containing all the passed PCs. */
754 result
= xmalloc (sizeof (*result
) + sizeof (*result
->call_site
)
756 result
->length
= length
;
757 result
->callers
= result
->callees
= length
;
758 if (!VEC_empty (call_sitep
, chain
))
759 memcpy (result
->call_site
, VEC_address (call_sitep
, chain
),
760 sizeof (*result
->call_site
) * length
);
763 if (entry_values_debug
)
765 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
766 for (idx
= 0; idx
< length
; idx
++)
767 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
768 fputc_unfiltered ('\n', gdb_stdlog
);
774 if (entry_values_debug
)
776 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
777 for (idx
= 0; idx
< length
; idx
++)
778 tailcall_dump (gdbarch
, VEC_index (call_sitep
, chain
, idx
));
779 fputc_unfiltered ('\n', gdb_stdlog
);
782 /* Intersect callers. */
784 callers
= min (result
->callers
, length
);
785 for (idx
= 0; idx
< callers
; idx
++)
786 if (result
->call_site
[idx
] != VEC_index (call_sitep
, chain
, idx
))
788 result
->callers
= idx
;
792 /* Intersect callees. */
794 callees
= min (result
->callees
, length
);
795 for (idx
= 0; idx
< callees
; idx
++)
796 if (result
->call_site
[result
->length
- 1 - idx
]
797 != VEC_index (call_sitep
, chain
, length
- 1 - idx
))
799 result
->callees
= idx
;
803 if (entry_values_debug
)
805 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
806 for (idx
= 0; idx
< result
->callers
; idx
++)
807 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
808 fputs_unfiltered (" |", gdb_stdlog
);
809 for (idx
= 0; idx
< result
->callees
; idx
++)
810 tailcall_dump (gdbarch
, result
->call_site
[result
->length
811 - result
->callees
+ idx
]);
812 fputc_unfiltered ('\n', gdb_stdlog
);
815 if (result
->callers
== 0 && result
->callees
== 0)
817 /* There are no common callers or callees. It could be also a direct
818 call (which has length 0) with ambiguous possibility of an indirect
819 call - CALLERS == CALLEES == 0 is valid during the first allocation
820 but any subsequence processing of such entry means ambiguity. */
826 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
827 PC again. In such case there must be two different code paths to reach
828 it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
829 gdb_assert (result
->callers
+ result
->callees
<= result
->length
);
832 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
833 assumed frames between them use GDBARCH. Use depth first search so we can
834 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
835 would have needless GDB stack overhead. Caller is responsible for xfree of
836 the returned result. Any unreliability results in thrown
837 NO_ENTRY_VALUE_ERROR. */
839 static struct call_site_chain
*
840 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
843 CORE_ADDR save_callee_pc
= callee_pc
;
844 struct obstack addr_obstack
;
845 struct cleanup
*back_to_retval
, *back_to_workdata
;
846 struct call_site_chain
*retval
= NULL
;
847 struct call_site
*call_site
;
849 /* Mark CALL_SITEs so we do not visit the same ones twice. */
852 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
853 call_site nor any possible call_site at CALLEE_PC's function is there.
854 Any CALL_SITE in CHAIN will be iterated to its siblings - via
855 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
856 VEC (call_sitep
) *chain
= NULL
;
858 /* We are not interested in the specific PC inside the callee function. */
859 callee_pc
= get_pc_function_start (callee_pc
);
861 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
862 paddress (gdbarch
, save_callee_pc
));
864 back_to_retval
= make_cleanup (free_current_contents
, &retval
);
866 obstack_init (&addr_obstack
);
867 back_to_workdata
= make_cleanup_obstack_free (&addr_obstack
);
868 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
869 &addr_obstack
, hashtab_obstack_allocate
,
871 make_cleanup_htab_delete (addr_hash
);
873 make_cleanup (VEC_cleanup (call_sitep
), &chain
);
875 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
876 at the target's function. All the possible tail call sites in the
877 target's function will get iterated as already pushed into CHAIN via their
879 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
883 CORE_ADDR target_func_addr
;
884 struct call_site
*target_call_site
;
886 /* CALLER_FRAME with registers is not available for tail-call jumped
888 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
890 if (target_func_addr
== callee_pc
)
892 chain_candidate (gdbarch
, &retval
, chain
);
896 /* There is no way to reach CALLEE_PC again as we would prevent
897 entering it twice as being already marked in ADDR_HASH. */
898 target_call_site
= NULL
;
902 struct symbol
*target_func
;
904 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
905 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
910 /* Attempt to visit TARGET_CALL_SITE. */
912 if (target_call_site
)
916 slot
= htab_find_slot (addr_hash
, &target_call_site
->pc
, INSERT
);
919 /* Successfully entered TARGET_CALL_SITE. */
921 *slot
= &target_call_site
->pc
;
922 VEC_safe_push (call_sitep
, chain
, target_call_site
);
927 /* Backtrack (without revisiting the originating call_site). Try the
928 callers's sibling; if there isn't any try the callers's callers's
931 target_call_site
= NULL
;
932 while (!VEC_empty (call_sitep
, chain
))
934 call_site
= VEC_pop (call_sitep
, chain
);
936 gdb_assert (htab_find_slot (addr_hash
, &call_site
->pc
,
938 htab_remove_elt (addr_hash
, &call_site
->pc
);
940 target_call_site
= call_site
->tail_call_next
;
941 if (target_call_site
)
945 while (target_call_site
);
947 if (VEC_empty (call_sitep
, chain
))
950 call_site
= VEC_last (call_sitep
, chain
);
955 struct bound_minimal_symbol msym_caller
, msym_callee
;
957 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
958 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
959 throw_error (NO_ENTRY_VALUE_ERROR
,
960 _("There are no unambiguously determinable intermediate "
961 "callers or callees between caller function \"%s\" at %s "
962 "and callee function \"%s\" at %s"),
963 (msym_caller
.minsym
== NULL
964 ? "???" : MSYMBOL_PRINT_NAME (msym_caller
.minsym
)),
965 paddress (gdbarch
, caller_pc
),
966 (msym_callee
.minsym
== NULL
967 ? "???" : MSYMBOL_PRINT_NAME (msym_callee
.minsym
)),
968 paddress (gdbarch
, callee_pc
));
971 do_cleanups (back_to_workdata
);
972 discard_cleanups (back_to_retval
);
976 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
977 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
978 constructed return NULL. Caller is responsible for xfree of the returned
981 struct call_site_chain
*
982 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
985 struct call_site_chain
*retval
= NULL
;
989 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
991 CATCH (e
, RETURN_MASK_ERROR
)
993 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
995 if (entry_values_debug
)
996 exception_print (gdb_stdout
, e
);
1001 throw_exception (e
);
1008 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1011 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1012 enum call_site_parameter_kind kind
,
1013 union call_site_parameter_u kind_u
)
1015 if (kind
== parameter
->kind
)
1018 case CALL_SITE_PARAMETER_DWARF_REG
:
1019 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1020 case CALL_SITE_PARAMETER_FB_OFFSET
:
1021 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1022 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1023 return kind_u
.param_offset
.cu_off
== parameter
->u
.param_offset
.cu_off
;
1028 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1029 FRAME is for callee.
1031 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1034 static struct call_site_parameter
*
1035 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1036 enum call_site_parameter_kind kind
,
1037 union call_site_parameter_u kind_u
,
1038 struct dwarf2_per_cu_data
**per_cu_return
)
1040 CORE_ADDR func_addr
, caller_pc
;
1041 struct gdbarch
*gdbarch
;
1042 struct frame_info
*caller_frame
;
1043 struct call_site
*call_site
;
1045 /* Initialize it just to avoid a GCC false warning. */
1046 struct call_site_parameter
*parameter
= NULL
;
1047 CORE_ADDR target_addr
;
1049 while (get_frame_type (frame
) == INLINE_FRAME
)
1051 frame
= get_prev_frame (frame
);
1052 gdb_assert (frame
!= NULL
);
1055 func_addr
= get_frame_func (frame
);
1056 gdbarch
= get_frame_arch (frame
);
1057 caller_frame
= get_prev_frame (frame
);
1058 if (gdbarch
!= frame_unwind_arch (frame
))
1060 struct bound_minimal_symbol msym
1061 = lookup_minimal_symbol_by_pc (func_addr
);
1062 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1064 throw_error (NO_ENTRY_VALUE_ERROR
,
1065 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1066 "(of %s (%s)) does not match caller gdbarch %s"),
1067 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1068 paddress (gdbarch
, func_addr
),
1069 (msym
.minsym
== NULL
? "???"
1070 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
1071 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1074 if (caller_frame
== NULL
)
1076 struct bound_minimal_symbol msym
1077 = lookup_minimal_symbol_by_pc (func_addr
);
1079 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_GNU_entry_value resolving "
1080 "requires caller of %s (%s)"),
1081 paddress (gdbarch
, func_addr
),
1082 (msym
.minsym
== NULL
? "???"
1083 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
1085 caller_pc
= get_frame_pc (caller_frame
);
1086 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1088 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1089 if (target_addr
!= func_addr
)
1091 struct minimal_symbol
*target_msym
, *func_msym
;
1093 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1094 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1095 throw_error (NO_ENTRY_VALUE_ERROR
,
1096 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1097 "but the called frame is for %s at %s"),
1098 (target_msym
== NULL
? "???"
1099 : MSYMBOL_PRINT_NAME (target_msym
)),
1100 paddress (gdbarch
, target_addr
),
1101 func_msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (func_msym
),
1102 paddress (gdbarch
, func_addr
));
1105 /* No entry value based parameters would be reliable if this function can
1106 call itself via tail calls. */
1107 func_verify_no_selftailcall (gdbarch
, func_addr
);
1109 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1111 parameter
= &call_site
->parameter
[iparams
];
1112 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1115 if (iparams
== call_site
->parameter_count
)
1117 struct minimal_symbol
*msym
1118 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1120 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1121 determine its value. */
1122 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1123 "at DW_TAG_GNU_call_site %s at %s"),
1124 paddress (gdbarch
, caller_pc
),
1125 msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (msym
));
1128 *per_cu_return
= call_site
->per_cu
;
1132 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1133 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1134 DW_AT_GNU_call_site_data_value (dereferenced) block.
1136 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1139 Function always returns non-NULL, non-optimized out value. It throws
1140 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1142 static struct value
*
1143 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1144 CORE_ADDR deref_size
, struct type
*type
,
1145 struct frame_info
*caller_frame
,
1146 struct dwarf2_per_cu_data
*per_cu
)
1148 const gdb_byte
*data_src
;
1152 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1153 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1155 /* DEREF_SIZE size is not verified here. */
1156 if (data_src
== NULL
)
1157 throw_error (NO_ENTRY_VALUE_ERROR
,
1158 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1160 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1161 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1163 data
= alloca (size
+ 1);
1164 memcpy (data
, data_src
, size
);
1165 data
[size
] = DW_OP_stack_value
;
1167 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1170 /* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
1171 Choose DEREF_SIZE value of that parameter. Search caller of the CTX's
1172 frame. CTX must be of dwarf_expr_ctx_funcs kind.
1174 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1175 can be more simple as it does not support cross-CU DWARF executions. */
1178 dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
1179 enum call_site_parameter_kind kind
,
1180 union call_site_parameter_u kind_u
,
1183 struct dwarf_expr_baton
*debaton
;
1184 struct frame_info
*frame
, *caller_frame
;
1185 struct dwarf2_per_cu_data
*caller_per_cu
;
1186 struct dwarf_expr_baton baton_local
;
1187 struct dwarf_expr_context saved_ctx
;
1188 struct call_site_parameter
*parameter
;
1189 const gdb_byte
*data_src
;
1192 gdb_assert (ctx
->funcs
== &dwarf_expr_ctx_funcs
);
1193 debaton
= ctx
->baton
;
1194 frame
= debaton
->frame
;
1195 caller_frame
= get_prev_frame (frame
);
1197 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1199 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1200 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1202 /* DEREF_SIZE size is not verified here. */
1203 if (data_src
== NULL
)
1204 throw_error (NO_ENTRY_VALUE_ERROR
,
1205 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1207 baton_local
.frame
= caller_frame
;
1208 baton_local
.per_cu
= caller_per_cu
;
1209 baton_local
.obj_address
= 0;
1211 saved_ctx
.gdbarch
= ctx
->gdbarch
;
1212 saved_ctx
.addr_size
= ctx
->addr_size
;
1213 saved_ctx
.offset
= ctx
->offset
;
1214 saved_ctx
.baton
= ctx
->baton
;
1215 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (baton_local
.per_cu
));
1216 ctx
->addr_size
= dwarf2_per_cu_addr_size (baton_local
.per_cu
);
1217 ctx
->offset
= dwarf2_per_cu_text_offset (baton_local
.per_cu
);
1218 ctx
->baton
= &baton_local
;
1220 dwarf_expr_eval (ctx
, data_src
, size
);
1222 ctx
->gdbarch
= saved_ctx
.gdbarch
;
1223 ctx
->addr_size
= saved_ctx
.addr_size
;
1224 ctx
->offset
= saved_ctx
.offset
;
1225 ctx
->baton
= saved_ctx
.baton
;
1228 /* Callback function for dwarf2_evaluate_loc_desc.
1229 Fetch the address indexed by DW_OP_GNU_addr_index. */
1232 dwarf_expr_get_addr_index (void *baton
, unsigned int index
)
1234 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
1236 return dwarf2_read_addr_index (debaton
->per_cu
, index
);
1239 /* Callback function for get_object_address. Return the address of the VLA
1243 dwarf_expr_get_obj_addr (void *baton
)
1245 struct dwarf_expr_baton
*debaton
= baton
;
1247 gdb_assert (debaton
!= NULL
);
1249 if (debaton
->obj_address
== 0)
1250 error (_("Location address is not set."));
1252 return debaton
->obj_address
;
1255 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1256 the indirect method on it, that is use its stored target value, the sole
1257 purpose of entry_data_value_funcs.. */
1259 static struct value
*
1260 entry_data_value_coerce_ref (const struct value
*value
)
1262 struct type
*checked_type
= check_typedef (value_type (value
));
1263 struct value
*target_val
;
1265 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
)
1268 target_val
= value_computed_closure (value
);
1269 value_incref (target_val
);
1273 /* Implement copy_closure. */
1276 entry_data_value_copy_closure (const struct value
*v
)
1278 struct value
*target_val
= value_computed_closure (v
);
1280 value_incref (target_val
);
1284 /* Implement free_closure. */
1287 entry_data_value_free_closure (struct value
*v
)
1289 struct value
*target_val
= value_computed_closure (v
);
1291 value_free (target_val
);
1294 /* Vector for methods for an entry value reference where the referenced value
1295 is stored in the caller. On the first dereference use
1296 DW_AT_GNU_call_site_data_value in the caller. */
1298 static const struct lval_funcs entry_data_value_funcs
=
1302 NULL
, /* indirect */
1303 entry_data_value_coerce_ref
,
1304 NULL
, /* check_synthetic_pointer */
1305 entry_data_value_copy_closure
,
1306 entry_data_value_free_closure
1309 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1310 are used to match DW_AT_location at the caller's
1311 DW_TAG_GNU_call_site_parameter.
1313 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1314 cannot resolve the parameter for any reason. */
1316 static struct value
*
1317 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1318 enum call_site_parameter_kind kind
,
1319 union call_site_parameter_u kind_u
)
1321 struct type
*checked_type
= check_typedef (type
);
1322 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1323 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1324 struct value
*outer_val
, *target_val
, *val
;
1325 struct call_site_parameter
*parameter
;
1326 struct dwarf2_per_cu_data
*caller_per_cu
;
1328 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1331 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1335 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1336 used and it is not available do not fall back to OUTER_VAL - dereferencing
1337 TYPE_CODE_REF with non-entry data value would give current value - not the
1340 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
1341 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1344 target_val
= dwarf_entry_parameter_to_value (parameter
,
1345 TYPE_LENGTH (target_type
),
1346 target_type
, caller_frame
,
1349 release_value (target_val
);
1350 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1351 target_val
/* closure */);
1353 /* Copy the referencing pointer to the new computed value. */
1354 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1355 TYPE_LENGTH (checked_type
));
1356 set_value_lazy (val
, 0);
1361 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1362 SIZE are DWARF block used to match DW_AT_location at the caller's
1363 DW_TAG_GNU_call_site_parameter.
1365 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1366 cannot resolve the parameter for any reason. */
1368 static struct value
*
1369 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1370 const gdb_byte
*block
, size_t block_len
)
1372 union call_site_parameter_u kind_u
;
1374 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1375 if (kind_u
.dwarf_reg
!= -1)
1376 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1379 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1380 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1383 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1384 suppressed during normal operation. The expression can be arbitrary if
1385 there is no caller-callee entry value binding expected. */
1386 throw_error (NO_ENTRY_VALUE_ERROR
,
1387 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1388 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1391 struct piece_closure
1393 /* Reference count. */
1396 /* The CU from which this closure's expression came. */
1397 struct dwarf2_per_cu_data
*per_cu
;
1399 /* The number of pieces used to describe this variable. */
1402 /* The target address size, used only for DWARF_VALUE_STACK. */
1405 /* The pieces themselves. */
1406 struct dwarf_expr_piece
*pieces
;
1409 /* Allocate a closure for a value formed from separately-described
1412 static struct piece_closure
*
1413 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1414 int n_pieces
, struct dwarf_expr_piece
*pieces
,
1417 struct piece_closure
*c
= XCNEW (struct piece_closure
);
1422 c
->n_pieces
= n_pieces
;
1423 c
->addr_size
= addr_size
;
1424 c
->pieces
= XCNEWVEC (struct dwarf_expr_piece
, n_pieces
);
1426 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
1427 for (i
= 0; i
< n_pieces
; ++i
)
1428 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1429 value_incref (c
->pieces
[i
].v
.value
);
1434 /* The lowest-level function to extract bits from a byte buffer.
1435 SOURCE is the buffer. It is updated if we read to the end of a
1437 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1438 updated to reflect the number of bits actually read.
1439 NBITS is the number of bits we want to read. It is updated to
1440 reflect the number of bits actually read. This function may read
1442 BITS_BIG_ENDIAN is taken directly from gdbarch.
1443 This function returns the extracted bits. */
1446 extract_bits_primitive (const gdb_byte
**source
,
1447 unsigned int *source_offset_bits
,
1448 int *nbits
, int bits_big_endian
)
1450 unsigned int avail
, mask
, datum
;
1452 gdb_assert (*source_offset_bits
< 8);
1454 avail
= 8 - *source_offset_bits
;
1458 mask
= (1 << avail
) - 1;
1460 if (bits_big_endian
)
1461 datum
>>= 8 - (*source_offset_bits
+ *nbits
);
1463 datum
>>= *source_offset_bits
;
1467 *source_offset_bits
+= avail
;
1468 if (*source_offset_bits
>= 8)
1470 *source_offset_bits
-= 8;
1477 /* Extract some bits from a source buffer and move forward in the
1480 SOURCE is the source buffer. It is updated as bytes are read.
1481 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1483 NBITS is the number of bits to read.
1484 BITS_BIG_ENDIAN is taken directly from gdbarch.
1486 This function returns the bits that were read. */
1489 extract_bits (const gdb_byte
**source
, unsigned int *source_offset_bits
,
1490 int nbits
, int bits_big_endian
)
1494 gdb_assert (nbits
> 0 && nbits
<= 8);
1496 datum
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1502 more
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1504 if (bits_big_endian
)
1514 /* Write some bits into a buffer and move forward in the buffer.
1516 DATUM is the bits to write. The low-order bits of DATUM are used.
1517 DEST is the destination buffer. It is updated as bytes are
1519 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1521 NBITS is the number of valid bits in DATUM.
1522 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1525 insert_bits (unsigned int datum
,
1526 gdb_byte
*dest
, unsigned int dest_offset_bits
,
1527 int nbits
, int bits_big_endian
)
1531 gdb_assert (dest_offset_bits
+ nbits
<= 8);
1533 mask
= (1 << nbits
) - 1;
1534 if (bits_big_endian
)
1536 datum
<<= 8 - (dest_offset_bits
+ nbits
);
1537 mask
<<= 8 - (dest_offset_bits
+ nbits
);
1541 datum
<<= dest_offset_bits
;
1542 mask
<<= dest_offset_bits
;
1545 gdb_assert ((datum
& ~mask
) == 0);
1547 *dest
= (*dest
& ~mask
) | datum
;
1550 /* Copy bits from a source to a destination.
1552 DEST is where the bits should be written.
1553 DEST_OFFSET_BITS is the bit offset into DEST.
1554 SOURCE is the source of bits.
1555 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1556 BIT_COUNT is the number of bits to copy.
1557 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1560 copy_bitwise (gdb_byte
*dest
, unsigned int dest_offset_bits
,
1561 const gdb_byte
*source
, unsigned int source_offset_bits
,
1562 unsigned int bit_count
,
1563 int bits_big_endian
)
1565 unsigned int dest_avail
;
1568 /* Reduce everything to byte-size pieces. */
1569 dest
+= dest_offset_bits
/ 8;
1570 dest_offset_bits
%= 8;
1571 source
+= source_offset_bits
/ 8;
1572 source_offset_bits
%= 8;
1574 dest_avail
= 8 - dest_offset_bits
% 8;
1576 /* See if we can fill the first destination byte. */
1577 if (dest_avail
< bit_count
)
1579 datum
= extract_bits (&source
, &source_offset_bits
, dest_avail
,
1581 insert_bits (datum
, dest
, dest_offset_bits
, dest_avail
, bits_big_endian
);
1583 dest_offset_bits
= 0;
1584 bit_count
-= dest_avail
;
1587 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1588 than 8 bits remaining. */
1589 gdb_assert (dest_offset_bits
% 8 == 0 || bit_count
< 8);
1590 for (; bit_count
>= 8; bit_count
-= 8)
1592 datum
= extract_bits (&source
, &source_offset_bits
, 8, bits_big_endian
);
1593 *dest
++ = (gdb_byte
) datum
;
1596 /* Finally, we may have a few leftover bits. */
1597 gdb_assert (bit_count
<= 8 - dest_offset_bits
% 8);
1600 datum
= extract_bits (&source
, &source_offset_bits
, bit_count
,
1602 insert_bits (datum
, dest
, dest_offset_bits
, bit_count
, bits_big_endian
);
1607 read_pieced_value (struct value
*v
)
1611 ULONGEST bits_to_skip
;
1613 struct piece_closure
*c
1614 = (struct piece_closure
*) value_computed_closure (v
);
1615 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (v
));
1617 size_t buffer_size
= 0;
1618 gdb_byte
*buffer
= NULL
;
1619 struct cleanup
*cleanup
;
1621 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1623 if (value_type (v
) != value_enclosing_type (v
))
1624 internal_error (__FILE__
, __LINE__
,
1625 _("Should not be able to create a lazy value with "
1626 "an enclosing type"));
1628 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1630 contents
= value_contents_raw (v
);
1631 bits_to_skip
= 8 * value_offset (v
);
1632 if (value_bitsize (v
))
1634 bits_to_skip
+= value_bitpos (v
);
1635 type_len
= value_bitsize (v
);
1638 type_len
= 8 * TYPE_LENGTH (value_type (v
));
1640 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1642 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1643 size_t this_size
, this_size_bits
;
1644 long dest_offset_bits
, source_offset_bits
, source_offset
;
1645 const gdb_byte
*intermediate_buffer
;
1647 /* Compute size, source, and destination offsets for copying, in
1649 this_size_bits
= p
->size
;
1650 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1652 bits_to_skip
-= this_size_bits
;
1655 if (bits_to_skip
> 0)
1657 dest_offset_bits
= 0;
1658 source_offset_bits
= bits_to_skip
;
1659 this_size_bits
-= bits_to_skip
;
1664 dest_offset_bits
= offset
;
1665 source_offset_bits
= 0;
1667 if (this_size_bits
> type_len
- offset
)
1668 this_size_bits
= type_len
- offset
;
1670 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1671 source_offset
= source_offset_bits
/ 8;
1672 if (buffer_size
< this_size
)
1674 buffer_size
= this_size
;
1675 buffer
= xrealloc (buffer
, buffer_size
);
1677 intermediate_buffer
= buffer
;
1679 /* Copy from the source to DEST_BUFFER. */
1680 switch (p
->location
)
1682 case DWARF_VALUE_REGISTER
:
1684 struct gdbarch
*arch
= get_frame_arch (frame
);
1685 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1687 if (gdb_regnum
!= -1)
1690 int reg_offset
= source_offset
;
1692 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1693 && this_size
< register_size (arch
, gdb_regnum
))
1695 /* Big-endian, and we want less than full size. */
1696 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1697 /* We want the lower-order THIS_SIZE_BITS of the bytes
1698 we extract from the register. */
1699 source_offset_bits
+= 8 * this_size
- this_size_bits
;
1702 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1706 /* Just so garbage doesn't ever shine through. */
1707 memset (buffer
, 0, this_size
);
1710 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1712 mark_value_bits_unavailable (v
, offset
, this_size_bits
);
1717 error (_("Unable to access DWARF register number %s"),
1718 paddress (arch
, p
->v
.regno
));
1723 case DWARF_VALUE_MEMORY
:
1724 read_value_memory (v
, offset
,
1725 p
->v
.mem
.in_stack_memory
,
1726 p
->v
.mem
.addr
+ source_offset
,
1730 case DWARF_VALUE_STACK
:
1732 size_t n
= this_size
;
1734 if (n
> c
->addr_size
- source_offset
)
1735 n
= (c
->addr_size
>= source_offset
1736 ? c
->addr_size
- source_offset
1744 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
1746 intermediate_buffer
= val_bytes
+ source_offset
;
1751 case DWARF_VALUE_LITERAL
:
1753 size_t n
= this_size
;
1755 if (n
> p
->v
.literal
.length
- source_offset
)
1756 n
= (p
->v
.literal
.length
>= source_offset
1757 ? p
->v
.literal
.length
- source_offset
1760 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
1764 /* These bits show up as zeros -- but do not cause the value
1765 to be considered optimized-out. */
1766 case DWARF_VALUE_IMPLICIT_POINTER
:
1769 case DWARF_VALUE_OPTIMIZED_OUT
:
1770 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1774 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1777 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
1778 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1779 copy_bitwise (contents
, dest_offset_bits
,
1780 intermediate_buffer
, source_offset_bits
% 8,
1781 this_size_bits
, bits_big_endian
);
1783 offset
+= this_size_bits
;
1786 do_cleanups (cleanup
);
1790 write_pieced_value (struct value
*to
, struct value
*from
)
1794 ULONGEST bits_to_skip
;
1795 const gdb_byte
*contents
;
1796 struct piece_closure
*c
1797 = (struct piece_closure
*) value_computed_closure (to
);
1798 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
1800 size_t buffer_size
= 0;
1801 gdb_byte
*buffer
= NULL
;
1802 struct cleanup
*cleanup
;
1804 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
1808 mark_value_bytes_optimized_out (to
, 0, TYPE_LENGTH (value_type (to
)));
1812 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1814 contents
= value_contents (from
);
1815 bits_to_skip
= 8 * value_offset (to
);
1816 if (value_bitsize (to
))
1818 bits_to_skip
+= value_bitpos (to
);
1819 type_len
= value_bitsize (to
);
1822 type_len
= 8 * TYPE_LENGTH (value_type (to
));
1824 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1826 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1827 size_t this_size_bits
, this_size
;
1828 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
1830 const gdb_byte
*source_buffer
;
1832 this_size_bits
= p
->size
;
1833 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1835 bits_to_skip
-= this_size_bits
;
1838 if (this_size_bits
> type_len
- offset
)
1839 this_size_bits
= type_len
- offset
;
1840 if (bits_to_skip
> 0)
1842 dest_offset_bits
= bits_to_skip
;
1843 source_offset_bits
= 0;
1844 this_size_bits
-= bits_to_skip
;
1849 dest_offset_bits
= 0;
1850 source_offset_bits
= offset
;
1853 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1854 source_offset
= source_offset_bits
/ 8;
1855 dest_offset
= dest_offset_bits
/ 8;
1856 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
1858 source_buffer
= contents
+ source_offset
;
1863 if (buffer_size
< this_size
)
1865 buffer_size
= this_size
;
1866 buffer
= xrealloc (buffer
, buffer_size
);
1868 source_buffer
= buffer
;
1872 switch (p
->location
)
1874 case DWARF_VALUE_REGISTER
:
1876 struct gdbarch
*arch
= get_frame_arch (frame
);
1877 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1879 if (gdb_regnum
!= -1)
1881 int reg_offset
= dest_offset
;
1883 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1884 && this_size
<= register_size (arch
, gdb_regnum
))
1886 /* Big-endian, and we want less than full size. */
1887 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1894 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1899 throw_error (OPTIMIZED_OUT_ERROR
,
1900 _("Can't do read-modify-write to "
1901 "update bitfield; containing word "
1902 "has been optimized out"));
1904 throw_error (NOT_AVAILABLE_ERROR
,
1905 _("Can't do read-modify-write to update "
1906 "bitfield; containing word "
1909 copy_bitwise (buffer
, dest_offset_bits
,
1910 contents
, source_offset_bits
,
1915 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1916 this_size
, source_buffer
);
1920 error (_("Unable to write to DWARF register number %s"),
1921 paddress (arch
, p
->v
.regno
));
1925 case DWARF_VALUE_MEMORY
:
1928 /* Only the first and last bytes can possibly have any
1930 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
, 1);
1931 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
1932 buffer
+ this_size
- 1, 1);
1933 copy_bitwise (buffer
, dest_offset_bits
,
1934 contents
, source_offset_bits
,
1939 write_memory (p
->v
.mem
.addr
+ dest_offset
,
1940 source_buffer
, this_size
);
1943 mark_value_bytes_optimized_out (to
, 0, TYPE_LENGTH (value_type (to
)));
1946 offset
+= this_size_bits
;
1949 do_cleanups (cleanup
);
1952 /* An implementation of an lval_funcs method to see whether a value is
1953 a synthetic pointer. */
1956 check_pieced_synthetic_pointer (const struct value
*value
, int bit_offset
,
1959 struct piece_closure
*c
1960 = (struct piece_closure
*) value_computed_closure (value
);
1963 bit_offset
+= 8 * value_offset (value
);
1964 if (value_bitsize (value
))
1965 bit_offset
+= value_bitpos (value
);
1967 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
1969 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1970 size_t this_size_bits
= p
->size
;
1974 if (bit_offset
>= this_size_bits
)
1976 bit_offset
-= this_size_bits
;
1980 bit_length
-= this_size_bits
- bit_offset
;
1984 bit_length
-= this_size_bits
;
1986 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1993 /* A wrapper function for get_frame_address_in_block. */
1996 get_frame_address_in_block_wrapper (void *baton
)
1998 return get_frame_address_in_block (baton
);
2001 /* An implementation of an lval_funcs method to indirect through a
2002 pointer. This handles the synthetic pointer case when needed. */
2004 static struct value
*
2005 indirect_pieced_value (struct value
*value
)
2007 struct piece_closure
*c
2008 = (struct piece_closure
*) value_computed_closure (value
);
2010 struct frame_info
*frame
;
2011 struct dwarf2_locexpr_baton baton
;
2012 int i
, bit_offset
, bit_length
;
2013 struct dwarf_expr_piece
*piece
= NULL
;
2014 LONGEST byte_offset
;
2015 enum bfd_endian byte_order
;
2017 type
= check_typedef (value_type (value
));
2018 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
2021 bit_length
= 8 * TYPE_LENGTH (type
);
2022 bit_offset
= 8 * value_offset (value
);
2023 if (value_bitsize (value
))
2024 bit_offset
+= value_bitpos (value
);
2026 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2028 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2029 size_t this_size_bits
= p
->size
;
2033 if (bit_offset
>= this_size_bits
)
2035 bit_offset
-= this_size_bits
;
2039 bit_length
-= this_size_bits
- bit_offset
;
2043 bit_length
-= this_size_bits
;
2045 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2048 if (bit_length
!= 0)
2049 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2055 frame
= get_selected_frame (_("No frame selected."));
2057 /* This is an offset requested by GDB, such as value subscripts.
2058 However, due to how synthetic pointers are implemented, this is
2059 always presented to us as a pointer type. This means we have to
2060 sign-extend it manually as appropriate. Use raw
2061 extract_signed_integer directly rather than value_as_address and
2062 sign extend afterwards on architectures that would need it
2063 (mostly everywhere except MIPS, which has signed addresses) as
2064 the later would go through gdbarch_pointer_to_address and thus
2065 return a CORE_ADDR with high bits set on architectures that
2066 encode address spaces and other things in CORE_ADDR. */
2067 byte_order
= gdbarch_byte_order (get_frame_arch (frame
));
2068 byte_offset
= extract_signed_integer (value_contents (value
),
2069 TYPE_LENGTH (type
), byte_order
);
2070 byte_offset
+= piece
->v
.ptr
.offset
;
2074 = dwarf2_fetch_die_loc_sect_off (piece
->v
.ptr
.die
, c
->per_cu
,
2075 get_frame_address_in_block_wrapper
,
2078 if (baton
.data
!= NULL
)
2079 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
2080 baton
.data
, baton
.size
, baton
.per_cu
,
2084 struct obstack temp_obstack
;
2085 struct cleanup
*cleanup
;
2086 const gdb_byte
*bytes
;
2088 struct value
*result
;
2090 obstack_init (&temp_obstack
);
2091 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2093 bytes
= dwarf2_fetch_constant_bytes (piece
->v
.ptr
.die
, c
->per_cu
,
2094 &temp_obstack
, &len
);
2096 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
2100 || byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > len
)
2101 invalid_synthetic_pointer ();
2102 bytes
+= byte_offset
;
2103 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
2106 do_cleanups (cleanup
);
2112 copy_pieced_value_closure (const struct value
*v
)
2114 struct piece_closure
*c
2115 = (struct piece_closure
*) value_computed_closure (v
);
2122 free_pieced_value_closure (struct value
*v
)
2124 struct piece_closure
*c
2125 = (struct piece_closure
*) value_computed_closure (v
);
2132 for (i
= 0; i
< c
->n_pieces
; ++i
)
2133 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
2134 value_free (c
->pieces
[i
].v
.value
);
2141 /* Functions for accessing a variable described by DW_OP_piece. */
2142 static const struct lval_funcs pieced_value_funcs
= {
2145 indirect_pieced_value
,
2146 NULL
, /* coerce_ref */
2147 check_pieced_synthetic_pointer
,
2148 copy_pieced_value_closure
,
2149 free_pieced_value_closure
2152 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2154 const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
=
2156 dwarf_expr_read_addr_from_reg
,
2157 dwarf_expr_get_reg_value
,
2158 dwarf_expr_read_mem
,
2159 dwarf_expr_frame_base
,
2160 dwarf_expr_frame_cfa
,
2161 dwarf_expr_frame_pc
,
2162 dwarf_expr_tls_address
,
2163 dwarf_expr_dwarf_call
,
2164 dwarf_expr_get_base_type
,
2165 dwarf_expr_push_dwarf_reg_entry_value
,
2166 dwarf_expr_get_addr_index
,
2167 dwarf_expr_get_obj_addr
2170 /* Evaluate a location description, starting at DATA and with length
2171 SIZE, to find the current location of variable of TYPE in the
2172 context of FRAME. BYTE_OFFSET is applied after the contents are
2175 static struct value
*
2176 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2177 const gdb_byte
*data
, size_t size
,
2178 struct dwarf2_per_cu_data
*per_cu
,
2179 LONGEST byte_offset
)
2181 struct value
*retval
;
2182 struct dwarf_expr_baton baton
;
2183 struct dwarf_expr_context
*ctx
;
2184 struct cleanup
*old_chain
, *value_chain
;
2185 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2187 if (byte_offset
< 0)
2188 invalid_synthetic_pointer ();
2191 return allocate_optimized_out_value (type
);
2193 baton
.frame
= frame
;
2194 baton
.per_cu
= per_cu
;
2195 baton
.obj_address
= 0;
2197 ctx
= new_dwarf_expr_context ();
2198 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2199 value_chain
= make_cleanup_value_free_to_mark (value_mark ());
2201 ctx
->gdbarch
= get_objfile_arch (objfile
);
2202 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2203 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2204 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2205 ctx
->baton
= &baton
;
2206 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2210 dwarf_expr_eval (ctx
, data
, size
);
2212 CATCH (ex
, RETURN_MASK_ERROR
)
2214 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2216 do_cleanups (old_chain
);
2217 retval
= allocate_value (type
);
2218 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
2221 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2223 if (entry_values_debug
)
2224 exception_print (gdb_stdout
, ex
);
2225 do_cleanups (old_chain
);
2226 return allocate_optimized_out_value (type
);
2229 throw_exception (ex
);
2233 if (ctx
->num_pieces
> 0)
2235 struct piece_closure
*c
;
2236 struct frame_id frame_id
= get_frame_id (frame
);
2237 ULONGEST bit_size
= 0;
2240 for (i
= 0; i
< ctx
->num_pieces
; ++i
)
2241 bit_size
+= ctx
->pieces
[i
].size
;
2242 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
2243 invalid_synthetic_pointer ();
2245 c
= allocate_piece_closure (per_cu
, ctx
->num_pieces
, ctx
->pieces
,
2247 /* We must clean up the value chain after creating the piece
2248 closure but before allocating the result. */
2249 do_cleanups (value_chain
);
2250 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
2251 VALUE_FRAME_ID (retval
) = frame_id
;
2252 set_value_offset (retval
, byte_offset
);
2256 switch (ctx
->location
)
2258 case DWARF_VALUE_REGISTER
:
2260 struct gdbarch
*arch
= get_frame_arch (frame
);
2262 = longest_to_int (value_as_long (dwarf_expr_fetch (ctx
, 0)));
2263 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
2265 if (byte_offset
!= 0)
2266 error (_("cannot use offset on synthetic pointer to register"));
2267 do_cleanups (value_chain
);
2268 if (gdb_regnum
== -1)
2269 error (_("Unable to access DWARF register number %d"),
2271 retval
= value_from_register (type
, gdb_regnum
, frame
);
2272 if (value_optimized_out (retval
))
2276 /* This means the register has undefined value / was
2277 not saved. As we're computing the location of some
2278 variable etc. in the program, not a value for
2279 inspecting a register ($pc, $sp, etc.), return a
2280 generic optimized out value instead, so that we show
2281 <optimized out> instead of <not saved>. */
2282 do_cleanups (value_chain
);
2283 tmp
= allocate_value (type
);
2284 value_contents_copy (tmp
, 0, retval
, 0, TYPE_LENGTH (type
));
2290 case DWARF_VALUE_MEMORY
:
2292 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
2293 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
2295 do_cleanups (value_chain
);
2296 retval
= value_at_lazy (type
, address
+ byte_offset
);
2297 if (in_stack_memory
)
2298 set_value_stack (retval
, 1);
2302 case DWARF_VALUE_STACK
:
2304 struct value
*value
= dwarf_expr_fetch (ctx
, 0);
2306 const gdb_byte
*val_bytes
;
2307 size_t n
= TYPE_LENGTH (value_type (value
));
2309 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2310 invalid_synthetic_pointer ();
2312 val_bytes
= value_contents_all (value
);
2313 val_bytes
+= byte_offset
;
2316 /* Preserve VALUE because we are going to free values back
2317 to the mark, but we still need the value contents
2319 value_incref (value
);
2320 do_cleanups (value_chain
);
2321 make_cleanup_value_free (value
);
2323 retval
= allocate_value (type
);
2324 contents
= value_contents_raw (retval
);
2325 if (n
> TYPE_LENGTH (type
))
2327 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2329 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2330 val_bytes
+= n
- TYPE_LENGTH (type
);
2331 n
= TYPE_LENGTH (type
);
2333 memcpy (contents
, val_bytes
, n
);
2337 case DWARF_VALUE_LITERAL
:
2340 const bfd_byte
*ldata
;
2341 size_t n
= ctx
->len
;
2343 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2344 invalid_synthetic_pointer ();
2346 do_cleanups (value_chain
);
2347 retval
= allocate_value (type
);
2348 contents
= value_contents_raw (retval
);
2350 ldata
= ctx
->data
+ byte_offset
;
2353 if (n
> TYPE_LENGTH (type
))
2355 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2357 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2358 ldata
+= n
- TYPE_LENGTH (type
);
2359 n
= TYPE_LENGTH (type
);
2361 memcpy (contents
, ldata
, n
);
2365 case DWARF_VALUE_OPTIMIZED_OUT
:
2366 do_cleanups (value_chain
);
2367 retval
= allocate_optimized_out_value (type
);
2370 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2371 operation by execute_stack_op. */
2372 case DWARF_VALUE_IMPLICIT_POINTER
:
2373 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2374 it can only be encountered when making a piece. */
2376 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2380 set_value_initialized (retval
, ctx
->initialized
);
2382 do_cleanups (old_chain
);
2387 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2388 passes 0 as the byte_offset. */
2391 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2392 const gdb_byte
*data
, size_t size
,
2393 struct dwarf2_per_cu_data
*per_cu
)
2395 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
2398 /* Evaluates a dwarf expression and stores the result in VAL, expecting
2399 that the dwarf expression only produces a single CORE_ADDR. ADDR is a
2400 context (location of a variable) and might be needed to evaluate the
2401 location expression.
2402 Returns 1 on success, 0 otherwise. */
2405 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton
*dlbaton
,
2409 struct dwarf_expr_context
*ctx
;
2410 struct dwarf_expr_baton baton
;
2411 struct objfile
*objfile
;
2412 struct cleanup
*cleanup
;
2414 if (dlbaton
== NULL
|| dlbaton
->size
== 0)
2417 ctx
= new_dwarf_expr_context ();
2418 cleanup
= make_cleanup_free_dwarf_expr_context (ctx
);
2420 baton
.frame
= get_selected_frame (NULL
);
2421 baton
.per_cu
= dlbaton
->per_cu
;
2422 baton
.obj_address
= addr
;
2424 objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2426 ctx
->gdbarch
= get_objfile_arch (objfile
);
2427 ctx
->addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2428 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (dlbaton
->per_cu
);
2429 ctx
->offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
2430 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2431 ctx
->baton
= &baton
;
2433 dwarf_expr_eval (ctx
, dlbaton
->data
, dlbaton
->size
);
2435 switch (ctx
->location
)
2437 case DWARF_VALUE_REGISTER
:
2438 case DWARF_VALUE_MEMORY
:
2439 case DWARF_VALUE_STACK
:
2440 *valp
= dwarf_expr_fetch_address (ctx
, 0);
2441 if (ctx
->location
== DWARF_VALUE_REGISTER
)
2442 *valp
= dwarf_expr_read_addr_from_reg (&baton
, *valp
);
2443 do_cleanups (cleanup
);
2445 case DWARF_VALUE_LITERAL
:
2446 *valp
= extract_signed_integer (ctx
->data
, ctx
->len
,
2447 gdbarch_byte_order (ctx
->gdbarch
));
2448 do_cleanups (cleanup
);
2450 /* Unsupported dwarf values. */
2451 case DWARF_VALUE_OPTIMIZED_OUT
:
2452 case DWARF_VALUE_IMPLICIT_POINTER
:
2456 do_cleanups (cleanup
);
2460 /* See dwarf2loc.h. */
2463 dwarf2_evaluate_property (const struct dynamic_prop
*prop
,
2464 struct property_addr_info
*addr_stack
,
2474 const struct dwarf2_property_baton
*baton
= prop
->data
.baton
;
2476 if (dwarf2_locexpr_baton_eval (&baton
->locexpr
, addr_stack
->addr
,
2479 if (baton
->referenced_type
)
2481 struct value
*val
= value_at (baton
->referenced_type
, *value
);
2483 *value
= value_as_address (val
);
2492 struct dwarf2_property_baton
*baton
= prop
->data
.baton
;
2493 struct frame_info
*frame
= get_selected_frame (NULL
);
2494 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2495 const gdb_byte
*data
;
2499 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2502 val
= dwarf2_evaluate_loc_desc (baton
->referenced_type
, frame
, data
,
2503 size
, baton
->loclist
.per_cu
);
2504 if (!value_optimized_out (val
))
2506 *value
= value_as_address (val
);
2514 *value
= prop
->data
.const_val
;
2517 case PROP_ADDR_OFFSET
:
2519 struct dwarf2_property_baton
*baton
= prop
->data
.baton
;
2520 struct property_addr_info
*pinfo
;
2523 for (pinfo
= addr_stack
; pinfo
!= NULL
; pinfo
= pinfo
->next
)
2524 if (pinfo
->type
== baton
->referenced_type
)
2527 error (_("cannot find reference address for offset property"));
2528 if (pinfo
->valaddr
!= NULL
)
2529 val
= value_from_contents
2530 (baton
->offset_info
.type
,
2531 pinfo
->valaddr
+ baton
->offset_info
.offset
);
2533 val
= value_at (baton
->offset_info
.type
,
2534 pinfo
->addr
+ baton
->offset_info
.offset
);
2535 *value
= value_as_address (val
);
2543 /* See dwarf2loc.h. */
2546 dwarf2_compile_property_to_c (struct ui_file
*stream
,
2547 const char *result_name
,
2548 struct gdbarch
*gdbarch
,
2549 unsigned char *registers_used
,
2550 const struct dynamic_prop
*prop
,
2554 struct dwarf2_property_baton
*baton
= prop
->data
.baton
;
2555 const gdb_byte
*data
;
2557 struct dwarf2_per_cu_data
*per_cu
;
2559 if (prop
->kind
== PROP_LOCEXPR
)
2561 data
= baton
->locexpr
.data
;
2562 size
= baton
->locexpr
.size
;
2563 per_cu
= baton
->locexpr
.per_cu
;
2567 gdb_assert (prop
->kind
== PROP_LOCLIST
);
2569 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2570 per_cu
= baton
->loclist
.per_cu
;
2573 compile_dwarf_bounds_to_c (stream
, result_name
, prop
, sym
, pc
,
2574 gdbarch
, registers_used
,
2575 dwarf2_per_cu_addr_size (per_cu
),
2576 data
, data
+ size
, per_cu
);
2580 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2582 struct needs_frame_baton
2585 struct dwarf2_per_cu_data
*per_cu
;
2588 /* Reads from registers do require a frame. */
2590 needs_frame_read_addr_from_reg (void *baton
, int regnum
)
2592 struct needs_frame_baton
*nf_baton
= baton
;
2594 nf_baton
->needs_frame
= 1;
2598 /* struct dwarf_expr_context_funcs' "get_reg_value" callback:
2599 Reads from registers do require a frame. */
2601 static struct value
*
2602 needs_frame_get_reg_value (void *baton
, struct type
*type
, int regnum
)
2604 struct needs_frame_baton
*nf_baton
= baton
;
2606 nf_baton
->needs_frame
= 1;
2607 return value_zero (type
, not_lval
);
2610 /* Reads from memory do not require a frame. */
2612 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
2614 memset (buf
, 0, len
);
2617 /* Frame-relative accesses do require a frame. */
2619 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
2621 static gdb_byte lit0
= DW_OP_lit0
;
2622 struct needs_frame_baton
*nf_baton
= baton
;
2627 nf_baton
->needs_frame
= 1;
2630 /* CFA accesses require a frame. */
2633 needs_frame_frame_cfa (void *baton
)
2635 struct needs_frame_baton
*nf_baton
= baton
;
2637 nf_baton
->needs_frame
= 1;
2641 /* Thread-local accesses do require a frame. */
2643 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
2645 struct needs_frame_baton
*nf_baton
= baton
;
2647 nf_baton
->needs_frame
= 1;
2651 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2654 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
2656 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2658 per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
,
2659 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
2662 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2665 needs_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
2666 enum call_site_parameter_kind kind
,
2667 union call_site_parameter_u kind_u
, int deref_size
)
2669 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2671 nf_baton
->needs_frame
= 1;
2673 /* The expression may require some stub values on DWARF stack. */
2674 dwarf_expr_push_address (ctx
, 0, 0);
2677 /* DW_OP_GNU_addr_index doesn't require a frame. */
2680 needs_get_addr_index (void *baton
, unsigned int index
)
2682 /* Nothing to do. */
2686 /* DW_OP_push_object_address has a frame already passed through. */
2689 needs_get_obj_addr (void *baton
)
2691 /* Nothing to do. */
2695 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2697 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs
=
2699 needs_frame_read_addr_from_reg
,
2700 needs_frame_get_reg_value
,
2701 needs_frame_read_mem
,
2702 needs_frame_frame_base
,
2703 needs_frame_frame_cfa
,
2704 needs_frame_frame_cfa
, /* get_frame_pc */
2705 needs_frame_tls_address
,
2706 needs_frame_dwarf_call
,
2707 NULL
, /* get_base_type */
2708 needs_dwarf_reg_entry_value
,
2709 needs_get_addr_index
,
2713 /* Return non-zero iff the location expression at DATA (length SIZE)
2714 requires a frame to evaluate. */
2717 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, size_t size
,
2718 struct dwarf2_per_cu_data
*per_cu
)
2720 struct needs_frame_baton baton
;
2721 struct dwarf_expr_context
*ctx
;
2723 struct cleanup
*old_chain
;
2724 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2726 baton
.needs_frame
= 0;
2727 baton
.per_cu
= per_cu
;
2729 ctx
= new_dwarf_expr_context ();
2730 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2731 make_cleanup_value_free_to_mark (value_mark ());
2733 ctx
->gdbarch
= get_objfile_arch (objfile
);
2734 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2735 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2736 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2737 ctx
->baton
= &baton
;
2738 ctx
->funcs
= &needs_frame_ctx_funcs
;
2740 dwarf_expr_eval (ctx
, data
, size
);
2742 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
2744 if (ctx
->num_pieces
> 0)
2748 /* If the location has several pieces, and any of them are in
2749 registers, then we will need a frame to fetch them from. */
2750 for (i
= 0; i
< ctx
->num_pieces
; i
++)
2751 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2755 do_cleanups (old_chain
);
2757 return baton
.needs_frame
|| in_reg
;
2760 /* A helper function that throws an unimplemented error mentioning a
2761 given DWARF operator. */
2764 unimplemented (unsigned int op
)
2766 const char *name
= get_DW_OP_name (op
);
2769 error (_("DWARF operator %s cannot be translated to an agent expression"),
2772 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2773 "to an agent expression"),
2777 /* See dwarf2loc.h. */
2780 dwarf2_reg_to_regnum_or_error (struct gdbarch
*arch
, int dwarf_reg
)
2782 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2784 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
2788 /* A helper function that emits an access to memory. ARCH is the
2789 target architecture. EXPR is the expression which we are building.
2790 NBITS is the number of bits we want to read. This emits the
2791 opcodes needed to read the memory and then extract the desired
2795 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2797 ULONGEST nbytes
= (nbits
+ 7) / 8;
2799 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2802 ax_trace_quick (expr
, nbytes
);
2805 ax_simple (expr
, aop_ref8
);
2806 else if (nbits
<= 16)
2807 ax_simple (expr
, aop_ref16
);
2808 else if (nbits
<= 32)
2809 ax_simple (expr
, aop_ref32
);
2811 ax_simple (expr
, aop_ref64
);
2813 /* If we read exactly the number of bytes we wanted, we're done. */
2814 if (8 * nbytes
== nbits
)
2817 if (gdbarch_bits_big_endian (arch
))
2819 /* On a bits-big-endian machine, we want the high-order
2821 ax_const_l (expr
, 8 * nbytes
- nbits
);
2822 ax_simple (expr
, aop_rsh_unsigned
);
2826 /* On a bits-little-endian box, we want the low-order NBITS. */
2827 ax_zero_ext (expr
, nbits
);
2831 /* A helper function to return the frame's PC. */
2834 get_ax_pc (void *baton
)
2836 struct agent_expr
*expr
= baton
;
2841 /* Compile a DWARF location expression to an agent expression.
2843 EXPR is the agent expression we are building.
2844 LOC is the agent value we modify.
2845 ARCH is the architecture.
2846 ADDR_SIZE is the size of addresses, in bytes.
2847 OP_PTR is the start of the location expression.
2848 OP_END is one past the last byte of the location expression.
2850 This will throw an exception for various kinds of errors -- for
2851 example, if the expression cannot be compiled, or if the expression
2855 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2856 struct gdbarch
*arch
, unsigned int addr_size
,
2857 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
2858 struct dwarf2_per_cu_data
*per_cu
)
2860 struct cleanup
*cleanups
;
2862 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
2863 const gdb_byte
* const base
= op_ptr
;
2864 const gdb_byte
*previous_piece
= op_ptr
;
2865 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2866 ULONGEST bits_collected
= 0;
2867 unsigned int addr_size_bits
= 8 * addr_size
;
2868 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
2870 offsets
= xmalloc ((op_end
- op_ptr
) * sizeof (int));
2871 cleanups
= make_cleanup (xfree
, offsets
);
2873 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
2876 make_cleanup (VEC_cleanup (int), &dw_labels
);
2877 make_cleanup (VEC_cleanup (int), &patches
);
2879 /* By default we are making an address. */
2880 loc
->kind
= axs_lvalue_memory
;
2882 while (op_ptr
< op_end
)
2884 enum dwarf_location_atom op
= *op_ptr
;
2885 uint64_t uoffset
, reg
;
2889 offsets
[op_ptr
- base
] = expr
->len
;
2892 /* Our basic approach to code generation is to map DWARF
2893 operations directly to AX operations. However, there are
2896 First, DWARF works on address-sized units, but AX always uses
2897 LONGEST. For most operations we simply ignore this
2898 difference; instead we generate sign extensions as needed
2899 before division and comparison operations. It would be nice
2900 to omit the sign extensions, but there is no way to determine
2901 the size of the target's LONGEST. (This code uses the size
2902 of the host LONGEST in some cases -- that is a bug but it is
2905 Second, some DWARF operations cannot be translated to AX.
2906 For these we simply fail. See
2907 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2942 ax_const_l (expr
, op
- DW_OP_lit0
);
2946 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
2947 op_ptr
+= addr_size
;
2948 /* Some versions of GCC emit DW_OP_addr before
2949 DW_OP_GNU_push_tls_address. In this case the value is an
2950 index, not an address. We don't support things like
2951 branching between the address and the TLS op. */
2952 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
2953 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
2954 ax_const_l (expr
, uoffset
);
2958 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
2962 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
2966 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
2970 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
2974 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
2978 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
2982 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
2986 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
2990 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
2991 ax_const_l (expr
, uoffset
);
2994 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2995 ax_const_l (expr
, offset
);
3030 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3031 loc
->u
.reg
= dwarf2_reg_to_regnum_or_error (arch
, op
- DW_OP_reg0
);
3032 loc
->kind
= axs_lvalue_register
;
3036 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3037 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3038 loc
->u
.reg
= dwarf2_reg_to_regnum_or_error (arch
, reg
);
3039 loc
->kind
= axs_lvalue_register
;
3042 case DW_OP_implicit_value
:
3046 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
3047 if (op_ptr
+ len
> op_end
)
3048 error (_("DW_OP_implicit_value: too few bytes available."));
3049 if (len
> sizeof (ULONGEST
))
3050 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
3053 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
3056 dwarf_expr_require_composition (op_ptr
, op_end
,
3057 "DW_OP_implicit_value");
3059 loc
->kind
= axs_rvalue
;
3063 case DW_OP_stack_value
:
3064 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
3065 loc
->kind
= axs_rvalue
;
3100 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3101 i
= dwarf2_reg_to_regnum_or_error (arch
, op
- DW_OP_breg0
);
3105 ax_const_l (expr
, offset
);
3106 ax_simple (expr
, aop_add
);
3111 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3112 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3113 i
= dwarf2_reg_to_regnum_or_error (arch
, reg
);
3117 ax_const_l (expr
, offset
);
3118 ax_simple (expr
, aop_add
);
3124 const gdb_byte
*datastart
;
3126 const struct block
*b
;
3127 struct symbol
*framefunc
;
3129 b
= block_for_pc (expr
->scope
);
3132 error (_("No block found for address"));
3134 framefunc
= block_linkage_function (b
);
3137 error (_("No function found for block"));
3139 func_get_frame_base_dwarf_block (framefunc
, expr
->scope
,
3140 &datastart
, &datalen
);
3142 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3143 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
3144 datastart
+ datalen
, per_cu
);
3145 if (loc
->kind
== axs_lvalue_register
)
3146 require_rvalue (expr
, loc
);
3150 ax_const_l (expr
, offset
);
3151 ax_simple (expr
, aop_add
);
3154 loc
->kind
= axs_lvalue_memory
;
3159 ax_simple (expr
, aop_dup
);
3163 ax_simple (expr
, aop_pop
);
3168 ax_pick (expr
, offset
);
3172 ax_simple (expr
, aop_swap
);
3180 ax_simple (expr
, aop_rot
);
3184 case DW_OP_deref_size
:
3188 if (op
== DW_OP_deref_size
)
3193 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3194 error (_("Unsupported size %d in %s"),
3195 size
, get_DW_OP_name (op
));
3196 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3201 /* Sign extend the operand. */
3202 ax_ext (expr
, addr_size_bits
);
3203 ax_simple (expr
, aop_dup
);
3204 ax_const_l (expr
, 0);
3205 ax_simple (expr
, aop_less_signed
);
3206 ax_simple (expr
, aop_log_not
);
3207 i
= ax_goto (expr
, aop_if_goto
);
3208 /* We have to emit 0 - X. */
3209 ax_const_l (expr
, 0);
3210 ax_simple (expr
, aop_swap
);
3211 ax_simple (expr
, aop_sub
);
3212 ax_label (expr
, i
, expr
->len
);
3216 /* No need to sign extend here. */
3217 ax_const_l (expr
, 0);
3218 ax_simple (expr
, aop_swap
);
3219 ax_simple (expr
, aop_sub
);
3223 /* Sign extend the operand. */
3224 ax_ext (expr
, addr_size_bits
);
3225 ax_simple (expr
, aop_bit_not
);
3228 case DW_OP_plus_uconst
:
3229 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3230 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3231 but we micro-optimize anyhow. */
3234 ax_const_l (expr
, reg
);
3235 ax_simple (expr
, aop_add
);
3240 ax_simple (expr
, aop_bit_and
);
3244 /* Sign extend the operands. */
3245 ax_ext (expr
, addr_size_bits
);
3246 ax_simple (expr
, aop_swap
);
3247 ax_ext (expr
, addr_size_bits
);
3248 ax_simple (expr
, aop_swap
);
3249 ax_simple (expr
, aop_div_signed
);
3253 ax_simple (expr
, aop_sub
);
3257 ax_simple (expr
, aop_rem_unsigned
);
3261 ax_simple (expr
, aop_mul
);
3265 ax_simple (expr
, aop_bit_or
);
3269 ax_simple (expr
, aop_add
);
3273 ax_simple (expr
, aop_lsh
);
3277 ax_simple (expr
, aop_rsh_unsigned
);
3281 ax_simple (expr
, aop_rsh_signed
);
3285 ax_simple (expr
, aop_bit_xor
);
3289 /* Sign extend the operands. */
3290 ax_ext (expr
, addr_size_bits
);
3291 ax_simple (expr
, aop_swap
);
3292 ax_ext (expr
, addr_size_bits
);
3293 /* Note no swap here: A <= B is !(B < A). */
3294 ax_simple (expr
, aop_less_signed
);
3295 ax_simple (expr
, aop_log_not
);
3299 /* Sign extend the operands. */
3300 ax_ext (expr
, addr_size_bits
);
3301 ax_simple (expr
, aop_swap
);
3302 ax_ext (expr
, addr_size_bits
);
3303 ax_simple (expr
, aop_swap
);
3304 /* A >= B is !(A < B). */
3305 ax_simple (expr
, aop_less_signed
);
3306 ax_simple (expr
, aop_log_not
);
3310 /* Sign extend the operands. */
3311 ax_ext (expr
, addr_size_bits
);
3312 ax_simple (expr
, aop_swap
);
3313 ax_ext (expr
, addr_size_bits
);
3314 /* No need for a second swap here. */
3315 ax_simple (expr
, aop_equal
);
3319 /* Sign extend the operands. */
3320 ax_ext (expr
, addr_size_bits
);
3321 ax_simple (expr
, aop_swap
);
3322 ax_ext (expr
, addr_size_bits
);
3323 ax_simple (expr
, aop_swap
);
3324 ax_simple (expr
, aop_less_signed
);
3328 /* Sign extend the operands. */
3329 ax_ext (expr
, addr_size_bits
);
3330 ax_simple (expr
, aop_swap
);
3331 ax_ext (expr
, addr_size_bits
);
3332 /* Note no swap here: A > B is B < A. */
3333 ax_simple (expr
, aop_less_signed
);
3337 /* Sign extend the operands. */
3338 ax_ext (expr
, addr_size_bits
);
3339 ax_simple (expr
, aop_swap
);
3340 ax_ext (expr
, addr_size_bits
);
3341 /* No need for a swap here. */
3342 ax_simple (expr
, aop_equal
);
3343 ax_simple (expr
, aop_log_not
);
3346 case DW_OP_call_frame_cfa
:
3349 CORE_ADDR text_offset
;
3351 const gdb_byte
*cfa_start
, *cfa_end
;
3353 if (dwarf2_fetch_cfa_info (arch
, expr
->scope
, per_cu
,
3355 &text_offset
, &cfa_start
, &cfa_end
))
3358 ax_reg (expr
, regnum
);
3361 ax_const_l (expr
, off
);
3362 ax_simple (expr
, aop_add
);
3367 /* Another expression. */
3368 ax_const_l (expr
, text_offset
);
3369 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3370 cfa_start
, cfa_end
, per_cu
);
3373 loc
->kind
= axs_lvalue_memory
;
3377 case DW_OP_GNU_push_tls_address
:
3381 case DW_OP_push_object_address
:
3386 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3388 i
= ax_goto (expr
, aop_goto
);
3389 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3390 VEC_safe_push (int, patches
, i
);
3394 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3396 /* Zero extend the operand. */
3397 ax_zero_ext (expr
, addr_size_bits
);
3398 i
= ax_goto (expr
, aop_if_goto
);
3399 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3400 VEC_safe_push (int, patches
, i
);
3407 case DW_OP_bit_piece
:
3409 uint64_t size
, offset
;
3411 if (op_ptr
- 1 == previous_piece
)
3412 error (_("Cannot translate empty pieces to agent expressions"));
3413 previous_piece
= op_ptr
- 1;
3415 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3416 if (op
== DW_OP_piece
)
3422 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
3424 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3425 error (_("Expression pieces exceed word size"));
3427 /* Access the bits. */
3430 case axs_lvalue_register
:
3431 ax_reg (expr
, loc
->u
.reg
);
3434 case axs_lvalue_memory
:
3435 /* Offset the pointer, if needed. */
3438 ax_const_l (expr
, offset
/ 8);
3439 ax_simple (expr
, aop_add
);
3442 access_memory (arch
, expr
, size
);
3446 /* For a bits-big-endian target, shift up what we already
3447 have. For a bits-little-endian target, shift up the
3448 new data. Note that there is a potential bug here if
3449 the DWARF expression leaves multiple values on the
3451 if (bits_collected
> 0)
3453 if (bits_big_endian
)
3455 ax_simple (expr
, aop_swap
);
3456 ax_const_l (expr
, size
);
3457 ax_simple (expr
, aop_lsh
);
3458 /* We don't need a second swap here, because
3459 aop_bit_or is symmetric. */
3463 ax_const_l (expr
, size
);
3464 ax_simple (expr
, aop_lsh
);
3466 ax_simple (expr
, aop_bit_or
);
3469 bits_collected
+= size
;
3470 loc
->kind
= axs_rvalue
;
3474 case DW_OP_GNU_uninit
:
3480 struct dwarf2_locexpr_baton block
;
3481 int size
= (op
== DW_OP_call2
? 2 : 4);
3484 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3487 offset
.cu_off
= uoffset
;
3488 block
= dwarf2_fetch_die_loc_cu_off (offset
, per_cu
,
3491 /* DW_OP_call_ref is currently not supported. */
3492 gdb_assert (block
.per_cu
== per_cu
);
3494 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3495 block
.data
, block
.data
+ block
.size
,
3500 case DW_OP_call_ref
:
3508 /* Patch all the branches we emitted. */
3509 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
3511 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
3513 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3514 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
3517 do_cleanups (cleanups
);
3521 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3522 evaluator to calculate the location. */
3523 static struct value
*
3524 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3526 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3529 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3530 dlbaton
->size
, dlbaton
->per_cu
);
3535 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3536 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3539 static struct value
*
3540 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3542 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3544 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3548 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3550 locexpr_read_needs_frame (struct symbol
*symbol
)
3552 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3554 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
3558 /* Return true if DATA points to the end of a piece. END is one past
3559 the last byte in the expression. */
3562 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3564 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3567 /* Helper for locexpr_describe_location_piece that finds the name of a
3571 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3575 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
3576 return gdbarch_register_name (gdbarch
, regnum
);
3579 /* Nicely describe a single piece of a location, returning an updated
3580 position in the bytecode sequence. This function cannot recognize
3581 all locations; if a location is not recognized, it simply returns
3582 DATA. If there is an error during reading, e.g. we run off the end
3583 of the buffer, an error is thrown. */
3585 static const gdb_byte
*
3586 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3587 CORE_ADDR addr
, struct objfile
*objfile
,
3588 struct dwarf2_per_cu_data
*per_cu
,
3589 const gdb_byte
*data
, const gdb_byte
*end
,
3590 unsigned int addr_size
)
3592 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3595 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3597 fprintf_filtered (stream
, _("a variable in $%s"),
3598 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3601 else if (data
[0] == DW_OP_regx
)
3605 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3606 fprintf_filtered (stream
, _("a variable in $%s"),
3607 locexpr_regname (gdbarch
, reg
));
3609 else if (data
[0] == DW_OP_fbreg
)
3611 const struct block
*b
;
3612 struct symbol
*framefunc
;
3614 int64_t frame_offset
;
3615 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3617 int64_t base_offset
= 0;
3619 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3620 if (!piece_end_p (new_data
, end
))
3624 b
= block_for_pc (addr
);
3627 error (_("No block found for address for symbol \"%s\"."),
3628 SYMBOL_PRINT_NAME (symbol
));
3630 framefunc
= block_linkage_function (b
);
3633 error (_("No function found for block for symbol \"%s\"."),
3634 SYMBOL_PRINT_NAME (symbol
));
3636 func_get_frame_base_dwarf_block (framefunc
, addr
, &base_data
, &base_size
);
3638 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3640 const gdb_byte
*buf_end
;
3642 frame_reg
= base_data
[0] - DW_OP_breg0
;
3643 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3645 if (buf_end
!= base_data
+ base_size
)
3646 error (_("Unexpected opcode after "
3647 "DW_OP_breg%u for symbol \"%s\"."),
3648 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3650 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3652 /* The frame base is just the register, with no offset. */
3653 frame_reg
= base_data
[0] - DW_OP_reg0
;
3658 /* We don't know what to do with the frame base expression,
3659 so we can't trace this variable; give up. */
3663 fprintf_filtered (stream
,
3664 _("a variable at frame base reg $%s offset %s+%s"),
3665 locexpr_regname (gdbarch
, frame_reg
),
3666 plongest (base_offset
), plongest (frame_offset
));
3668 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3669 && piece_end_p (data
, end
))
3673 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3675 fprintf_filtered (stream
,
3676 _("a variable at offset %s from base reg $%s"),
3678 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3681 /* The location expression for a TLS variable looks like this (on a
3684 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3685 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3687 0x3 is the encoding for DW_OP_addr, which has an operand as long
3688 as the size of an address on the target machine (here is 8
3689 bytes). Note that more recent version of GCC emit DW_OP_const4u
3690 or DW_OP_const8u, depending on address size, rather than
3691 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3692 The operand represents the offset at which the variable is within
3693 the thread local storage. */
3695 else if (data
+ 1 + addr_size
< end
3696 && (data
[0] == DW_OP_addr
3697 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3698 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3699 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3700 && piece_end_p (data
+ 2 + addr_size
, end
))
3703 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3704 gdbarch_byte_order (gdbarch
));
3706 fprintf_filtered (stream
,
3707 _("a thread-local variable at offset 0x%s "
3708 "in the thread-local storage for `%s'"),
3709 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3711 data
+= 1 + addr_size
+ 1;
3714 /* With -gsplit-dwarf a TLS variable can also look like this:
3715 DW_AT_location : 3 byte block: fc 4 e0
3716 (DW_OP_GNU_const_index: 4;
3717 DW_OP_GNU_push_tls_address) */
3718 else if (data
+ 3 <= end
3719 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3720 && data
[0] == DW_OP_GNU_const_index
3722 && data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3723 && piece_end_p (data
+ 2 + leb128_size
, end
))
3727 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3728 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3729 fprintf_filtered (stream
,
3730 _("a thread-local variable at offset 0x%s "
3731 "in the thread-local storage for `%s'"),
3732 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3736 else if (data
[0] >= DW_OP_lit0
3737 && data
[0] <= DW_OP_lit31
3739 && data
[1] == DW_OP_stack_value
)
3741 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3748 /* Disassemble an expression, stopping at the end of a piece or at the
3749 end of the expression. Returns a pointer to the next unread byte
3750 in the input expression. If ALL is nonzero, then this function
3751 will keep going until it reaches the end of the expression.
3752 If there is an error during reading, e.g. we run off the end
3753 of the buffer, an error is thrown. */
3755 static const gdb_byte
*
3756 disassemble_dwarf_expression (struct ui_file
*stream
,
3757 struct gdbarch
*arch
, unsigned int addr_size
,
3758 int offset_size
, const gdb_byte
*start
,
3759 const gdb_byte
*data
, const gdb_byte
*end
,
3760 int indent
, int all
,
3761 struct dwarf2_per_cu_data
*per_cu
)
3765 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3767 enum dwarf_location_atom op
= *data
++;
3772 name
= get_DW_OP_name (op
);
3775 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3776 op
, (long) (data
- 1 - start
));
3777 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3778 (long) (data
- 1 - start
), name
);
3783 ul
= extract_unsigned_integer (data
, addr_size
,
3784 gdbarch_byte_order (arch
));
3786 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3790 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3792 fprintf_filtered (stream
, " %s", pulongest (ul
));
3795 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3797 fprintf_filtered (stream
, " %s", plongest (l
));
3800 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3802 fprintf_filtered (stream
, " %s", pulongest (ul
));
3805 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3807 fprintf_filtered (stream
, " %s", plongest (l
));
3810 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3812 fprintf_filtered (stream
, " %s", pulongest (ul
));
3815 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3817 fprintf_filtered (stream
, " %s", plongest (l
));
3820 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3822 fprintf_filtered (stream
, " %s", pulongest (ul
));
3825 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3827 fprintf_filtered (stream
, " %s", plongest (l
));
3830 data
= safe_read_uleb128 (data
, end
, &ul
);
3831 fprintf_filtered (stream
, " %s", pulongest (ul
));
3834 data
= safe_read_sleb128 (data
, end
, &l
);
3835 fprintf_filtered (stream
, " %s", plongest (l
));
3870 fprintf_filtered (stream
, " [$%s]",
3871 locexpr_regname (arch
, op
- DW_OP_reg0
));
3875 data
= safe_read_uleb128 (data
, end
, &ul
);
3876 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3877 locexpr_regname (arch
, (int) ul
));
3880 case DW_OP_implicit_value
:
3881 data
= safe_read_uleb128 (data
, end
, &ul
);
3883 fprintf_filtered (stream
, " %s", pulongest (ul
));
3918 data
= safe_read_sleb128 (data
, end
, &l
);
3919 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
3920 locexpr_regname (arch
, op
- DW_OP_breg0
));
3924 data
= safe_read_uleb128 (data
, end
, &ul
);
3925 data
= safe_read_sleb128 (data
, end
, &l
);
3926 fprintf_filtered (stream
, " register %s [$%s] offset %s",
3928 locexpr_regname (arch
, (int) ul
),
3933 data
= safe_read_sleb128 (data
, end
, &l
);
3934 fprintf_filtered (stream
, " %s", plongest (l
));
3937 case DW_OP_xderef_size
:
3938 case DW_OP_deref_size
:
3940 fprintf_filtered (stream
, " %d", *data
);
3944 case DW_OP_plus_uconst
:
3945 data
= safe_read_uleb128 (data
, end
, &ul
);
3946 fprintf_filtered (stream
, " %s", pulongest (ul
));
3950 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3952 fprintf_filtered (stream
, " to %ld",
3953 (long) (data
+ l
- start
));
3957 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3959 fprintf_filtered (stream
, " %ld",
3960 (long) (data
+ l
- start
));
3964 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3966 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
3970 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3972 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3975 case DW_OP_call_ref
:
3976 ul
= extract_unsigned_integer (data
, offset_size
,
3977 gdbarch_byte_order (arch
));
3978 data
+= offset_size
;
3979 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
3983 data
= safe_read_uleb128 (data
, end
, &ul
);
3984 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
3987 case DW_OP_bit_piece
:
3991 data
= safe_read_uleb128 (data
, end
, &ul
);
3992 data
= safe_read_uleb128 (data
, end
, &offset
);
3993 fprintf_filtered (stream
, " size %s offset %s (bits)",
3994 pulongest (ul
), pulongest (offset
));
3998 case DW_OP_GNU_implicit_pointer
:
4000 ul
= extract_unsigned_integer (data
, offset_size
,
4001 gdbarch_byte_order (arch
));
4002 data
+= offset_size
;
4004 data
= safe_read_sleb128 (data
, end
, &l
);
4006 fprintf_filtered (stream
, " DIE %s offset %s",
4007 phex_nz (ul
, offset_size
),
4012 case DW_OP_GNU_deref_type
:
4014 int addr_size
= *data
++;
4018 data
= safe_read_uleb128 (data
, end
, &ul
);
4020 type
= dwarf2_get_die_type (offset
, per_cu
);
4021 fprintf_filtered (stream
, "<");
4022 type_print (type
, "", stream
, -1);
4023 fprintf_filtered (stream
, " [0x%s]> %d", phex_nz (offset
.cu_off
, 0),
4028 case DW_OP_GNU_const_type
:
4033 data
= safe_read_uleb128 (data
, end
, &ul
);
4034 type_die
.cu_off
= ul
;
4035 type
= dwarf2_get_die_type (type_die
, per_cu
);
4036 fprintf_filtered (stream
, "<");
4037 type_print (type
, "", stream
, -1);
4038 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
4042 case DW_OP_GNU_regval_type
:
4048 data
= safe_read_uleb128 (data
, end
, ®
);
4049 data
= safe_read_uleb128 (data
, end
, &ul
);
4050 type_die
.cu_off
= ul
;
4052 type
= dwarf2_get_die_type (type_die
, per_cu
);
4053 fprintf_filtered (stream
, "<");
4054 type_print (type
, "", stream
, -1);
4055 fprintf_filtered (stream
, " [0x%s]> [$%s]",
4056 phex_nz (type_die
.cu_off
, 0),
4057 locexpr_regname (arch
, reg
));
4061 case DW_OP_GNU_convert
:
4062 case DW_OP_GNU_reinterpret
:
4066 data
= safe_read_uleb128 (data
, end
, &ul
);
4067 type_die
.cu_off
= ul
;
4069 if (type_die
.cu_off
== 0)
4070 fprintf_filtered (stream
, "<0>");
4075 type
= dwarf2_get_die_type (type_die
, per_cu
);
4076 fprintf_filtered (stream
, "<");
4077 type_print (type
, "", stream
, -1);
4078 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
4083 case DW_OP_GNU_entry_value
:
4084 data
= safe_read_uleb128 (data
, end
, &ul
);
4085 fputc_filtered ('\n', stream
);
4086 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
4087 start
, data
, data
+ ul
, indent
+ 2,
4092 case DW_OP_GNU_parameter_ref
:
4093 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4095 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4098 case DW_OP_GNU_addr_index
:
4099 data
= safe_read_uleb128 (data
, end
, &ul
);
4100 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4101 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
4103 case DW_OP_GNU_const_index
:
4104 data
= safe_read_uleb128 (data
, end
, &ul
);
4105 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4106 fprintf_filtered (stream
, " %s", pulongest (ul
));
4110 fprintf_filtered (stream
, "\n");
4116 /* Describe a single location, which may in turn consist of multiple
4120 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
4121 struct ui_file
*stream
,
4122 const gdb_byte
*data
, size_t size
,
4123 struct objfile
*objfile
, unsigned int addr_size
,
4124 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
4126 const gdb_byte
*end
= data
+ size
;
4127 int first_piece
= 1, bad
= 0;
4131 const gdb_byte
*here
= data
;
4132 int disassemble
= 1;
4137 fprintf_filtered (stream
, _(", and "));
4139 if (!dwarf_always_disassemble
)
4141 data
= locexpr_describe_location_piece (symbol
, stream
,
4142 addr
, objfile
, per_cu
,
4143 data
, end
, addr_size
);
4144 /* If we printed anything, or if we have an empty piece,
4145 then don't disassemble. */
4147 || data
[0] == DW_OP_piece
4148 || data
[0] == DW_OP_bit_piece
)
4153 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
4154 data
= disassemble_dwarf_expression (stream
,
4155 get_objfile_arch (objfile
),
4156 addr_size
, offset_size
, data
,
4158 dwarf_always_disassemble
,
4164 int empty
= data
== here
;
4167 fprintf_filtered (stream
, " ");
4168 if (data
[0] == DW_OP_piece
)
4172 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
4175 fprintf_filtered (stream
, _("an empty %s-byte piece"),
4178 fprintf_filtered (stream
, _(" [%s-byte piece]"),
4181 else if (data
[0] == DW_OP_bit_piece
)
4183 uint64_t bits
, offset
;
4185 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
4186 data
= safe_read_uleb128 (data
, end
, &offset
);
4189 fprintf_filtered (stream
,
4190 _("an empty %s-bit piece"),
4193 fprintf_filtered (stream
,
4194 _(" [%s-bit piece, offset %s bits]"),
4195 pulongest (bits
), pulongest (offset
));
4205 if (bad
|| data
> end
)
4206 error (_("Corrupted DWARF2 expression for \"%s\"."),
4207 SYMBOL_PRINT_NAME (symbol
));
4210 /* Print a natural-language description of SYMBOL to STREAM. This
4211 version is for a symbol with a single location. */
4214 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4215 struct ui_file
*stream
)
4217 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4218 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4219 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4220 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4222 locexpr_describe_location_1 (symbol
, addr
, stream
,
4223 dlbaton
->data
, dlbaton
->size
,
4224 objfile
, addr_size
, offset_size
,
4228 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4229 any necessary bytecode in AX. */
4232 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4233 struct agent_expr
*ax
, struct axs_value
*value
)
4235 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4236 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4238 if (dlbaton
->size
== 0)
4239 value
->optimized_out
= 1;
4241 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
4242 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4246 /* symbol_computed_ops 'generate_c_location' method. */
4249 locexpr_generate_c_location (struct symbol
*sym
, struct ui_file
*stream
,
4250 struct gdbarch
*gdbarch
,
4251 unsigned char *registers_used
,
4252 CORE_ADDR pc
, const char *result_name
)
4254 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (sym
);
4255 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4257 if (dlbaton
->size
== 0)
4258 error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym
));
4260 compile_dwarf_expr_to_c (stream
, result_name
,
4261 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4262 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4266 /* The set of location functions used with the DWARF-2 expression
4268 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4269 locexpr_read_variable
,
4270 locexpr_read_variable_at_entry
,
4271 locexpr_read_needs_frame
,
4272 locexpr_describe_location
,
4273 0, /* location_has_loclist */
4274 locexpr_tracepoint_var_ref
,
4275 locexpr_generate_c_location
4279 /* Wrapper functions for location lists. These generally find
4280 the appropriate location expression and call something above. */
4282 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4283 evaluator to calculate the location. */
4284 static struct value
*
4285 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4287 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4289 const gdb_byte
*data
;
4291 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4293 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4294 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4300 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4301 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4304 Function always returns non-NULL value, it may be marked optimized out if
4305 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4306 if it cannot resolve the parameter for any reason. */
4308 static struct value
*
4309 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4311 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4312 const gdb_byte
*data
;
4316 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4317 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4319 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4321 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4323 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4326 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
4328 loclist_read_needs_frame (struct symbol
*symbol
)
4330 /* If there's a location list, then assume we need to have a frame
4331 to choose the appropriate location expression. With tracking of
4332 global variables this is not necessarily true, but such tracking
4333 is disabled in GCC at the moment until we figure out how to
4339 /* Print a natural-language description of SYMBOL to STREAM. This
4340 version applies when there is a list of different locations, each
4341 with a specified address range. */
4344 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4345 struct ui_file
*stream
)
4347 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4348 const gdb_byte
*loc_ptr
, *buf_end
;
4349 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4350 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4351 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4352 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4353 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4354 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4355 /* Adjust base_address for relocatable objects. */
4356 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4357 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4360 loc_ptr
= dlbaton
->data
;
4361 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4363 fprintf_filtered (stream
, _("multi-location:\n"));
4365 /* Iterate through locations until we run out. */
4368 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4370 enum debug_loc_kind kind
;
4371 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4373 if (dlbaton
->from_dwo
)
4374 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4375 loc_ptr
, buf_end
, &new_ptr
,
4376 &low
, &high
, byte_order
);
4378 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4380 byte_order
, addr_size
,
4385 case DEBUG_LOC_END_OF_LIST
:
4388 case DEBUG_LOC_BASE_ADDRESS
:
4389 base_address
= high
+ base_offset
;
4390 fprintf_filtered (stream
, _(" Base address %s"),
4391 paddress (gdbarch
, base_address
));
4393 case DEBUG_LOC_START_END
:
4394 case DEBUG_LOC_START_LENGTH
:
4396 case DEBUG_LOC_BUFFER_OVERFLOW
:
4397 case DEBUG_LOC_INVALID_ENTRY
:
4398 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4399 SYMBOL_PRINT_NAME (symbol
));
4401 gdb_assert_not_reached ("bad debug_loc_kind");
4404 /* Otherwise, a location expression entry. */
4405 low
+= base_address
;
4406 high
+= base_address
;
4408 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
);
4409 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
);
4411 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4414 /* (It would improve readability to print only the minimum
4415 necessary digits of the second number of the range.) */
4416 fprintf_filtered (stream
, _(" Range %s-%s: "),
4417 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4419 /* Now describe this particular location. */
4420 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4421 objfile
, addr_size
, offset_size
,
4424 fprintf_filtered (stream
, "\n");
4430 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4431 any necessary bytecode in AX. */
4433 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4434 struct agent_expr
*ax
, struct axs_value
*value
)
4436 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4437 const gdb_byte
*data
;
4439 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4441 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4443 value
->optimized_out
= 1;
4445 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
4449 /* symbol_computed_ops 'generate_c_location' method. */
4452 loclist_generate_c_location (struct symbol
*sym
, struct ui_file
*stream
,
4453 struct gdbarch
*gdbarch
,
4454 unsigned char *registers_used
,
4455 CORE_ADDR pc
, const char *result_name
)
4457 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (sym
);
4458 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4459 const gdb_byte
*data
;
4462 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4464 error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym
));
4466 compile_dwarf_expr_to_c (stream
, result_name
,
4467 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4472 /* The set of location functions used with the DWARF-2 expression
4473 evaluator and location lists. */
4474 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4475 loclist_read_variable
,
4476 loclist_read_variable_at_entry
,
4477 loclist_read_needs_frame
,
4478 loclist_describe_location
,
4479 1, /* location_has_loclist */
4480 loclist_tracepoint_var_ref
,
4481 loclist_generate_c_location
4484 /* Provide a prototype to silence -Wmissing-prototypes. */
4485 extern initialize_file_ftype _initialize_dwarf2loc
;
4488 _initialize_dwarf2loc (void)
4490 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4491 &entry_values_debug
,
4492 _("Set entry values and tail call frames "
4494 _("Show entry values and tail call frames "
4496 _("When non-zero, the process of determining "
4497 "parameter values from function entry point "
4498 "and tail call frames will be printed."),
4500 show_entry_values_debug
,
4501 &setdebuglist
, &showdebuglist
);