1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003-2014 Free Software Foundation, Inc.
5 Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
33 #include "exceptions.h"
38 #include "dwarf2expr.h"
39 #include "dwarf2loc.h"
40 #include "dwarf2-frame.h"
43 #include "gdb_assert.h"
45 extern int dwarf2_always_disassemble
;
47 static void dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
48 const gdb_byte
**start
, size_t *length
);
50 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
;
52 static struct value
*dwarf2_evaluate_loc_desc_full (struct type
*type
,
53 struct frame_info
*frame
,
56 struct dwarf2_per_cu_data
*per_cu
,
59 /* Until these have formal names, we define these here.
60 ref: http://gcc.gnu.org/wiki/DebugFission
61 Each entry in .debug_loc.dwo begins with a byte that describes the entry,
62 and is then followed by data specific to that entry. */
66 /* Indicates the end of the list of entries. */
67 DEBUG_LOC_END_OF_LIST
= 0,
69 /* This is followed by an unsigned LEB128 number that is an index into
70 .debug_addr and specifies the base address for all following entries. */
71 DEBUG_LOC_BASE_ADDRESS
= 1,
73 /* This is followed by two unsigned LEB128 numbers that are indices into
74 .debug_addr and specify the beginning and ending addresses, and then
75 a normal location expression as in .debug_loc. */
76 DEBUG_LOC_START_END
= 2,
78 /* This is followed by an unsigned LEB128 number that is an index into
79 .debug_addr and specifies the beginning address, and a 4 byte unsigned
80 number that specifies the length, and then a normal location expression
82 DEBUG_LOC_START_LENGTH
= 3,
84 /* An internal value indicating there is insufficient data. */
85 DEBUG_LOC_BUFFER_OVERFLOW
= -1,
87 /* An internal value indicating an invalid kind of entry was found. */
88 DEBUG_LOC_INVALID_ENTRY
= -2
91 /* Helper function which throws an error if a synthetic pointer is
95 invalid_synthetic_pointer (void)
97 error (_("access outside bounds of object "
98 "referenced via synthetic pointer"));
101 /* Decode the addresses in a non-dwo .debug_loc entry.
102 A pointer to the next byte to examine is returned in *NEW_PTR.
103 The encoded low,high addresses are return in *LOW,*HIGH.
104 The result indicates the kind of entry found. */
106 static enum debug_loc_kind
107 decode_debug_loc_addresses (const gdb_byte
*loc_ptr
, const gdb_byte
*buf_end
,
108 const gdb_byte
**new_ptr
,
109 CORE_ADDR
*low
, CORE_ADDR
*high
,
110 enum bfd_endian byte_order
,
111 unsigned int addr_size
,
114 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
116 if (buf_end
- loc_ptr
< 2 * addr_size
)
117 return DEBUG_LOC_BUFFER_OVERFLOW
;
120 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
122 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
123 loc_ptr
+= addr_size
;
126 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
128 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
129 loc_ptr
+= addr_size
;
133 /* A base-address-selection entry. */
134 if ((*low
& base_mask
) == base_mask
)
135 return DEBUG_LOC_BASE_ADDRESS
;
137 /* An end-of-list entry. */
138 if (*low
== 0 && *high
== 0)
139 return DEBUG_LOC_END_OF_LIST
;
141 return DEBUG_LOC_START_END
;
144 /* Decode the addresses in .debug_loc.dwo entry.
145 A pointer to the next byte to examine is returned in *NEW_PTR.
146 The encoded low,high addresses are return in *LOW,*HIGH.
147 The result indicates the kind of entry found. */
149 static enum debug_loc_kind
150 decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data
*per_cu
,
151 const gdb_byte
*loc_ptr
,
152 const gdb_byte
*buf_end
,
153 const gdb_byte
**new_ptr
,
154 CORE_ADDR
*low
, CORE_ADDR
*high
,
155 enum bfd_endian byte_order
)
157 uint64_t low_index
, high_index
;
159 if (loc_ptr
== buf_end
)
160 return DEBUG_LOC_BUFFER_OVERFLOW
;
164 case DEBUG_LOC_END_OF_LIST
:
166 return DEBUG_LOC_END_OF_LIST
;
167 case DEBUG_LOC_BASE_ADDRESS
:
169 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
171 return DEBUG_LOC_BUFFER_OVERFLOW
;
172 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
174 return DEBUG_LOC_BASE_ADDRESS
;
175 case DEBUG_LOC_START_END
:
176 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
178 return DEBUG_LOC_BUFFER_OVERFLOW
;
179 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
180 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
182 return DEBUG_LOC_BUFFER_OVERFLOW
;
183 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
185 return DEBUG_LOC_START_END
;
186 case DEBUG_LOC_START_LENGTH
:
187 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
189 return DEBUG_LOC_BUFFER_OVERFLOW
;
190 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
191 if (loc_ptr
+ 4 > buf_end
)
192 return DEBUG_LOC_BUFFER_OVERFLOW
;
194 *high
+= extract_unsigned_integer (loc_ptr
, 4, byte_order
);
195 *new_ptr
= loc_ptr
+ 4;
196 return DEBUG_LOC_START_LENGTH
;
198 return DEBUG_LOC_INVALID_ENTRY
;
202 /* A function for dealing with location lists. Given a
203 symbol baton (BATON) and a pc value (PC), find the appropriate
204 location expression, set *LOCEXPR_LENGTH, and return a pointer
205 to the beginning of the expression. Returns NULL on failure.
207 For now, only return the first matching location expression; there
208 can be more than one in the list. */
211 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
212 size_t *locexpr_length
, CORE_ADDR pc
)
214 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
215 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
216 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
217 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
218 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
219 /* Adjust base_address for relocatable objects. */
220 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (baton
->per_cu
);
221 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
222 const gdb_byte
*loc_ptr
, *buf_end
;
224 loc_ptr
= baton
->data
;
225 buf_end
= baton
->data
+ baton
->size
;
229 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
231 enum debug_loc_kind kind
;
232 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
235 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
236 loc_ptr
, buf_end
, &new_ptr
,
237 &low
, &high
, byte_order
);
239 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
241 byte_order
, addr_size
,
246 case DEBUG_LOC_END_OF_LIST
:
249 case DEBUG_LOC_BASE_ADDRESS
:
250 base_address
= high
+ base_offset
;
252 case DEBUG_LOC_START_END
:
253 case DEBUG_LOC_START_LENGTH
:
255 case DEBUG_LOC_BUFFER_OVERFLOW
:
256 case DEBUG_LOC_INVALID_ENTRY
:
257 error (_("dwarf2_find_location_expression: "
258 "Corrupted DWARF expression."));
260 gdb_assert_not_reached ("bad debug_loc_kind");
263 /* Otherwise, a location expression entry.
264 If the entry is from a DWO, don't add base address: the entry is
265 from .debug_addr which has absolute addresses. */
266 if (! baton
->from_dwo
)
269 high
+= base_address
;
272 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
275 if (low
== high
&& pc
== low
)
277 /* This is entry PC record present only at entry point
278 of a function. Verify it is really the function entry point. */
280 struct block
*pc_block
= block_for_pc (pc
);
281 struct symbol
*pc_func
= NULL
;
284 pc_func
= block_linkage_function (pc_block
);
286 if (pc_func
&& pc
== BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func
)))
288 *locexpr_length
= length
;
293 if (pc
>= low
&& pc
< high
)
295 *locexpr_length
= length
;
303 /* This is the baton used when performing dwarf2 expression
305 struct dwarf_expr_baton
307 struct frame_info
*frame
;
308 struct dwarf2_per_cu_data
*per_cu
;
311 /* Helper functions for dwarf2_evaluate_loc_desc. */
313 /* Using the frame specified in BATON, return the value of register
314 REGNUM, treated as a pointer. */
316 dwarf_expr_read_addr_from_reg (void *baton
, int dwarf_regnum
)
318 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
319 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
323 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
324 result
= address_from_register (builtin_type (gdbarch
)->builtin_data_ptr
,
325 regnum
, debaton
->frame
);
329 /* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback. */
331 static struct value
*
332 dwarf_expr_get_reg_value (void *baton
, struct type
*type
, int dwarf_regnum
)
334 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
335 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
336 int regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
338 return value_from_register (type
, regnum
, debaton
->frame
);
341 /* Read memory at ADDR (length LEN) into BUF. */
344 dwarf_expr_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
346 read_memory (addr
, buf
, len
);
349 /* Using the frame specified in BATON, find the location expression
350 describing the frame base. Return a pointer to it in START and
351 its length in LENGTH. */
353 dwarf_expr_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
355 /* FIXME: cagney/2003-03-26: This code should be using
356 get_frame_base_address(), and then implement a dwarf2 specific
358 struct symbol
*framefunc
;
359 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
360 struct block
*bl
= get_frame_block (debaton
->frame
, NULL
);
363 error (_("frame address is not available."));
365 /* Use block_linkage_function, which returns a real (not inlined)
366 function, instead of get_frame_function, which may return an
368 framefunc
= block_linkage_function (bl
);
370 /* If we found a frame-relative symbol then it was certainly within
371 some function associated with a frame. If we can't find the frame,
372 something has gone wrong. */
373 gdb_assert (framefunc
!= NULL
);
375 dwarf_expr_frame_base_1 (framefunc
,
376 get_frame_address_in_block (debaton
->frame
),
380 /* Implement find_frame_base_location method for LOC_BLOCK functions using
381 DWARF expression for its DW_AT_frame_base. */
384 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
385 const gdb_byte
**start
, size_t *length
)
387 struct dwarf2_locexpr_baton
*symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
389 *length
= symbaton
->size
;
390 *start
= symbaton
->data
;
393 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
394 function uses DWARF expression for its DW_AT_frame_base. */
396 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
398 locexpr_find_frame_base_location
401 /* Implement find_frame_base_location method for LOC_BLOCK functions using
402 DWARF location list for its DW_AT_frame_base. */
405 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
406 const gdb_byte
**start
, size_t *length
)
408 struct dwarf2_loclist_baton
*symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
410 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
413 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
414 function uses DWARF location list for its DW_AT_frame_base. */
416 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
418 loclist_find_frame_base_location
422 dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
423 const gdb_byte
**start
, size_t *length
)
425 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
427 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
429 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
435 error (_("Could not find the frame base for \"%s\"."),
436 SYMBOL_NATURAL_NAME (framefunc
));
439 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
440 the frame in BATON. */
443 dwarf_expr_frame_cfa (void *baton
)
445 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
447 return dwarf2_frame_cfa (debaton
->frame
);
450 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
451 the frame in BATON. */
454 dwarf_expr_frame_pc (void *baton
)
456 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
458 return get_frame_address_in_block (debaton
->frame
);
461 /* Using the objfile specified in BATON, find the address for the
462 current thread's thread-local storage with offset OFFSET. */
464 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
466 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
467 struct objfile
*objfile
= dwarf2_per_cu_objfile (debaton
->per_cu
);
469 return target_translate_tls_address (objfile
, offset
);
472 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
473 current CU (as is PER_CU). State of the CTX is not affected by the
477 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
478 struct dwarf2_per_cu_data
*per_cu
,
479 CORE_ADDR (*get_frame_pc
) (void *baton
),
482 struct dwarf2_locexpr_baton block
;
484 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
, get_frame_pc
, baton
);
486 /* DW_OP_call_ref is currently not supported. */
487 gdb_assert (block
.per_cu
== per_cu
);
489 dwarf_expr_eval (ctx
, block
.data
, block
.size
);
492 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
495 dwarf_expr_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
497 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
499 per_cu_dwarf_call (ctx
, die_offset
, debaton
->per_cu
,
500 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
503 /* Callback function for dwarf2_evaluate_loc_desc. */
506 dwarf_expr_get_base_type (struct dwarf_expr_context
*ctx
,
507 cu_offset die_offset
)
509 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
511 return dwarf2_get_die_type (die_offset
, debaton
->per_cu
);
514 /* See dwarf2loc.h. */
516 unsigned int entry_values_debug
= 0;
518 /* Helper to set entry_values_debug. */
521 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
522 struct cmd_list_element
*c
, const char *value
)
524 fprintf_filtered (file
,
525 _("Entry values and tail call frames debugging is %s.\n"),
529 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
530 CALLER_FRAME (for registers) can be NULL if it is not known. This function
531 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
534 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
535 struct call_site
*call_site
,
536 struct frame_info
*caller_frame
)
538 switch (FIELD_LOC_KIND (call_site
->target
))
540 case FIELD_LOC_KIND_DWARF_BLOCK
:
542 struct dwarf2_locexpr_baton
*dwarf_block
;
544 struct type
*caller_core_addr_type
;
545 struct gdbarch
*caller_arch
;
547 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
548 if (dwarf_block
== NULL
)
550 struct bound_minimal_symbol msym
;
552 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
553 throw_error (NO_ENTRY_VALUE_ERROR
,
554 _("DW_AT_GNU_call_site_target is not specified "
556 paddress (call_site_gdbarch
, call_site
->pc
),
557 (msym
.minsym
== NULL
? "???"
558 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
561 if (caller_frame
== NULL
)
563 struct bound_minimal_symbol msym
;
565 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
566 throw_error (NO_ENTRY_VALUE_ERROR
,
567 _("DW_AT_GNU_call_site_target DWARF block resolving "
568 "requires known frame which is currently not "
569 "available at %s in %s"),
570 paddress (call_site_gdbarch
, call_site
->pc
),
571 (msym
.minsym
== NULL
? "???"
572 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
575 caller_arch
= get_frame_arch (caller_frame
);
576 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
577 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
578 dwarf_block
->data
, dwarf_block
->size
,
579 dwarf_block
->per_cu
);
580 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
582 if (VALUE_LVAL (val
) == lval_memory
)
583 return value_address (val
);
585 return value_as_address (val
);
588 case FIELD_LOC_KIND_PHYSNAME
:
590 const char *physname
;
591 struct bound_minimal_symbol msym
;
593 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
595 /* Handle both the mangled and demangled PHYSNAME. */
596 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
597 if (msym
.minsym
== NULL
)
599 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
600 throw_error (NO_ENTRY_VALUE_ERROR
,
601 _("Cannot find function \"%s\" for a call site target "
603 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
604 (msym
.minsym
== NULL
? "???"
605 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
608 return MSYMBOL_VALUE_ADDRESS (msym
.minsym
);
611 case FIELD_LOC_KIND_PHYSADDR
:
612 return FIELD_STATIC_PHYSADDR (call_site
->target
);
615 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
619 /* Convert function entry point exact address ADDR to the function which is
620 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
621 NO_ENTRY_VALUE_ERROR otherwise. */
623 static struct symbol
*
624 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
626 struct symbol
*sym
= find_pc_function (addr
);
629 if (sym
== NULL
|| BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
630 throw_error (NO_ENTRY_VALUE_ERROR
,
631 _("DW_TAG_GNU_call_site resolving failed to find function "
632 "name for address %s"),
633 paddress (gdbarch
, addr
));
635 type
= SYMBOL_TYPE (sym
);
636 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
637 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
642 /* Verify function with entry point exact address ADDR can never call itself
643 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
644 can call itself via tail calls.
646 If a funtion can tail call itself its entry value based parameters are
647 unreliable. There is no verification whether the value of some/all
648 parameters is unchanged through the self tail call, we expect if there is
649 a self tail call all the parameters can be modified. */
652 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
654 struct obstack addr_obstack
;
655 struct cleanup
*old_chain
;
658 /* Track here CORE_ADDRs which were already visited. */
661 /* The verification is completely unordered. Track here function addresses
662 which still need to be iterated. */
663 VEC (CORE_ADDR
) *todo
= NULL
;
665 obstack_init (&addr_obstack
);
666 old_chain
= make_cleanup_obstack_free (&addr_obstack
);
667 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
668 &addr_obstack
, hashtab_obstack_allocate
,
670 make_cleanup_htab_delete (addr_hash
);
672 make_cleanup (VEC_cleanup (CORE_ADDR
), &todo
);
674 VEC_safe_push (CORE_ADDR
, todo
, verify_addr
);
675 while (!VEC_empty (CORE_ADDR
, todo
))
677 struct symbol
*func_sym
;
678 struct call_site
*call_site
;
680 addr
= VEC_pop (CORE_ADDR
, todo
);
682 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
684 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
685 call_site
; call_site
= call_site
->tail_call_next
)
687 CORE_ADDR target_addr
;
690 /* CALLER_FRAME with registers is not available for tail-call jumped
692 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
694 if (target_addr
== verify_addr
)
696 struct bound_minimal_symbol msym
;
698 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
699 throw_error (NO_ENTRY_VALUE_ERROR
,
700 _("DW_OP_GNU_entry_value resolving has found "
701 "function \"%s\" at %s can call itself via tail "
703 (msym
.minsym
== NULL
? "???"
704 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
705 paddress (gdbarch
, verify_addr
));
708 slot
= htab_find_slot (addr_hash
, &target_addr
, INSERT
);
711 *slot
= obstack_copy (&addr_obstack
, &target_addr
,
712 sizeof (target_addr
));
713 VEC_safe_push (CORE_ADDR
, todo
, target_addr
);
718 do_cleanups (old_chain
);
721 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
722 ENTRY_VALUES_DEBUG. */
725 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
727 CORE_ADDR addr
= call_site
->pc
;
728 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
730 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
731 (msym
.minsym
== NULL
? "???"
732 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
736 /* vec.h needs single word type name, typedef it. */
737 typedef struct call_site
*call_sitep
;
739 /* Define VEC (call_sitep) functions. */
740 DEF_VEC_P (call_sitep
);
742 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
743 only top callers and bottom callees which are present in both. GDBARCH is
744 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
745 no remaining possibilities to provide unambiguous non-trivial result.
746 RESULTP should point to NULL on the first (initialization) call. Caller is
747 responsible for xfree of any RESULTP data. */
750 chain_candidate (struct gdbarch
*gdbarch
, struct call_site_chain
**resultp
,
751 VEC (call_sitep
) *chain
)
753 struct call_site_chain
*result
= *resultp
;
754 long length
= VEC_length (call_sitep
, chain
);
755 int callers
, callees
, idx
;
759 /* Create the initial chain containing all the passed PCs. */
761 result
= xmalloc (sizeof (*result
) + sizeof (*result
->call_site
)
763 result
->length
= length
;
764 result
->callers
= result
->callees
= length
;
765 if (!VEC_empty (call_sitep
, chain
))
766 memcpy (result
->call_site
, VEC_address (call_sitep
, chain
),
767 sizeof (*result
->call_site
) * length
);
770 if (entry_values_debug
)
772 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
773 for (idx
= 0; idx
< length
; idx
++)
774 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
775 fputc_unfiltered ('\n', gdb_stdlog
);
781 if (entry_values_debug
)
783 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
784 for (idx
= 0; idx
< length
; idx
++)
785 tailcall_dump (gdbarch
, VEC_index (call_sitep
, chain
, idx
));
786 fputc_unfiltered ('\n', gdb_stdlog
);
789 /* Intersect callers. */
791 callers
= min (result
->callers
, length
);
792 for (idx
= 0; idx
< callers
; idx
++)
793 if (result
->call_site
[idx
] != VEC_index (call_sitep
, chain
, idx
))
795 result
->callers
= idx
;
799 /* Intersect callees. */
801 callees
= min (result
->callees
, length
);
802 for (idx
= 0; idx
< callees
; idx
++)
803 if (result
->call_site
[result
->length
- 1 - idx
]
804 != VEC_index (call_sitep
, chain
, length
- 1 - idx
))
806 result
->callees
= idx
;
810 if (entry_values_debug
)
812 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
813 for (idx
= 0; idx
< result
->callers
; idx
++)
814 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
815 fputs_unfiltered (" |", gdb_stdlog
);
816 for (idx
= 0; idx
< result
->callees
; idx
++)
817 tailcall_dump (gdbarch
, result
->call_site
[result
->length
818 - result
->callees
+ idx
]);
819 fputc_unfiltered ('\n', gdb_stdlog
);
822 if (result
->callers
== 0 && result
->callees
== 0)
824 /* There are no common callers or callees. It could be also a direct
825 call (which has length 0) with ambiguous possibility of an indirect
826 call - CALLERS == CALLEES == 0 is valid during the first allocation
827 but any subsequence processing of such entry means ambiguity. */
833 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
834 PC again. In such case there must be two different code paths to reach
835 it, therefore some of the former determined intermediate PCs must differ
836 and the unambiguous chain gets shortened. */
837 gdb_assert (result
->callers
+ result
->callees
< result
->length
);
840 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
841 assumed frames between them use GDBARCH. Use depth first search so we can
842 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
843 would have needless GDB stack overhead. Caller is responsible for xfree of
844 the returned result. Any unreliability results in thrown
845 NO_ENTRY_VALUE_ERROR. */
847 static struct call_site_chain
*
848 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
851 CORE_ADDR save_callee_pc
= callee_pc
;
852 struct obstack addr_obstack
;
853 struct cleanup
*back_to_retval
, *back_to_workdata
;
854 struct call_site_chain
*retval
= NULL
;
855 struct call_site
*call_site
;
857 /* Mark CALL_SITEs so we do not visit the same ones twice. */
860 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
861 call_site nor any possible call_site at CALLEE_PC's function is there.
862 Any CALL_SITE in CHAIN will be iterated to its siblings - via
863 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
864 VEC (call_sitep
) *chain
= NULL
;
866 /* We are not interested in the specific PC inside the callee function. */
867 callee_pc
= get_pc_function_start (callee_pc
);
869 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
870 paddress (gdbarch
, save_callee_pc
));
872 back_to_retval
= make_cleanup (free_current_contents
, &retval
);
874 obstack_init (&addr_obstack
);
875 back_to_workdata
= make_cleanup_obstack_free (&addr_obstack
);
876 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
877 &addr_obstack
, hashtab_obstack_allocate
,
879 make_cleanup_htab_delete (addr_hash
);
881 make_cleanup (VEC_cleanup (call_sitep
), &chain
);
883 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
884 at the target's function. All the possible tail call sites in the
885 target's function will get iterated as already pushed into CHAIN via their
887 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
891 CORE_ADDR target_func_addr
;
892 struct call_site
*target_call_site
;
894 /* CALLER_FRAME with registers is not available for tail-call jumped
896 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
898 if (target_func_addr
== callee_pc
)
900 chain_candidate (gdbarch
, &retval
, chain
);
904 /* There is no way to reach CALLEE_PC again as we would prevent
905 entering it twice as being already marked in ADDR_HASH. */
906 target_call_site
= NULL
;
910 struct symbol
*target_func
;
912 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
913 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
918 /* Attempt to visit TARGET_CALL_SITE. */
920 if (target_call_site
)
924 slot
= htab_find_slot (addr_hash
, &target_call_site
->pc
, INSERT
);
927 /* Successfully entered TARGET_CALL_SITE. */
929 *slot
= &target_call_site
->pc
;
930 VEC_safe_push (call_sitep
, chain
, target_call_site
);
935 /* Backtrack (without revisiting the originating call_site). Try the
936 callers's sibling; if there isn't any try the callers's callers's
939 target_call_site
= NULL
;
940 while (!VEC_empty (call_sitep
, chain
))
942 call_site
= VEC_pop (call_sitep
, chain
);
944 gdb_assert (htab_find_slot (addr_hash
, &call_site
->pc
,
946 htab_remove_elt (addr_hash
, &call_site
->pc
);
948 target_call_site
= call_site
->tail_call_next
;
949 if (target_call_site
)
953 while (target_call_site
);
955 if (VEC_empty (call_sitep
, chain
))
958 call_site
= VEC_last (call_sitep
, chain
);
963 struct bound_minimal_symbol msym_caller
, msym_callee
;
965 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
966 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
967 throw_error (NO_ENTRY_VALUE_ERROR
,
968 _("There are no unambiguously determinable intermediate "
969 "callers or callees between caller function \"%s\" at %s "
970 "and callee function \"%s\" at %s"),
971 (msym_caller
.minsym
== NULL
972 ? "???" : MSYMBOL_PRINT_NAME (msym_caller
.minsym
)),
973 paddress (gdbarch
, caller_pc
),
974 (msym_callee
.minsym
== NULL
975 ? "???" : MSYMBOL_PRINT_NAME (msym_callee
.minsym
)),
976 paddress (gdbarch
, callee_pc
));
979 do_cleanups (back_to_workdata
);
980 discard_cleanups (back_to_retval
);
984 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
985 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
986 constructed return NULL. Caller is responsible for xfree of the returned
989 struct call_site_chain
*
990 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
993 volatile struct gdb_exception e
;
994 struct call_site_chain
*retval
= NULL
;
996 TRY_CATCH (e
, RETURN_MASK_ERROR
)
998 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
1002 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
1004 if (entry_values_debug
)
1005 exception_print (gdb_stdout
, e
);
1010 throw_exception (e
);
1015 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1018 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1019 enum call_site_parameter_kind kind
,
1020 union call_site_parameter_u kind_u
)
1022 if (kind
== parameter
->kind
)
1025 case CALL_SITE_PARAMETER_DWARF_REG
:
1026 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1027 case CALL_SITE_PARAMETER_FB_OFFSET
:
1028 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1029 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1030 return kind_u
.param_offset
.cu_off
== parameter
->u
.param_offset
.cu_off
;
1035 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1036 FRAME is for callee.
1038 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1041 static struct call_site_parameter
*
1042 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1043 enum call_site_parameter_kind kind
,
1044 union call_site_parameter_u kind_u
,
1045 struct dwarf2_per_cu_data
**per_cu_return
)
1047 CORE_ADDR func_addr
, caller_pc
;
1048 struct gdbarch
*gdbarch
;
1049 struct frame_info
*caller_frame
;
1050 struct call_site
*call_site
;
1052 /* Initialize it just to avoid a GCC false warning. */
1053 struct call_site_parameter
*parameter
= NULL
;
1054 CORE_ADDR target_addr
;
1056 while (get_frame_type (frame
) == INLINE_FRAME
)
1058 frame
= get_prev_frame (frame
);
1059 gdb_assert (frame
!= NULL
);
1062 func_addr
= get_frame_func (frame
);
1063 gdbarch
= get_frame_arch (frame
);
1064 caller_frame
= get_prev_frame (frame
);
1065 if (gdbarch
!= frame_unwind_arch (frame
))
1067 struct bound_minimal_symbol msym
1068 = lookup_minimal_symbol_by_pc (func_addr
);
1069 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1071 throw_error (NO_ENTRY_VALUE_ERROR
,
1072 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1073 "(of %s (%s)) does not match caller gdbarch %s"),
1074 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1075 paddress (gdbarch
, func_addr
),
1076 (msym
.minsym
== NULL
? "???"
1077 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
1078 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1081 if (caller_frame
== NULL
)
1083 struct bound_minimal_symbol msym
1084 = lookup_minimal_symbol_by_pc (func_addr
);
1086 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_GNU_entry_value resolving "
1087 "requires caller of %s (%s)"),
1088 paddress (gdbarch
, func_addr
),
1089 (msym
.minsym
== NULL
? "???"
1090 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
1092 caller_pc
= get_frame_pc (caller_frame
);
1093 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1095 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1096 if (target_addr
!= func_addr
)
1098 struct minimal_symbol
*target_msym
, *func_msym
;
1100 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1101 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1102 throw_error (NO_ENTRY_VALUE_ERROR
,
1103 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1104 "but the called frame is for %s at %s"),
1105 (target_msym
== NULL
? "???"
1106 : MSYMBOL_PRINT_NAME (target_msym
)),
1107 paddress (gdbarch
, target_addr
),
1108 func_msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (func_msym
),
1109 paddress (gdbarch
, func_addr
));
1112 /* No entry value based parameters would be reliable if this function can
1113 call itself via tail calls. */
1114 func_verify_no_selftailcall (gdbarch
, func_addr
);
1116 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1118 parameter
= &call_site
->parameter
[iparams
];
1119 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1122 if (iparams
== call_site
->parameter_count
)
1124 struct minimal_symbol
*msym
1125 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1127 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1128 determine its value. */
1129 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1130 "at DW_TAG_GNU_call_site %s at %s"),
1131 paddress (gdbarch
, caller_pc
),
1132 msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (msym
));
1135 *per_cu_return
= call_site
->per_cu
;
1139 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1140 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1141 DW_AT_GNU_call_site_data_value (dereferenced) block.
1143 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1146 Function always returns non-NULL, non-optimized out value. It throws
1147 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1149 static struct value
*
1150 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1151 CORE_ADDR deref_size
, struct type
*type
,
1152 struct frame_info
*caller_frame
,
1153 struct dwarf2_per_cu_data
*per_cu
)
1155 const gdb_byte
*data_src
;
1159 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1160 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1162 /* DEREF_SIZE size is not verified here. */
1163 if (data_src
== NULL
)
1164 throw_error (NO_ENTRY_VALUE_ERROR
,
1165 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1167 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1168 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1170 data
= alloca (size
+ 1);
1171 memcpy (data
, data_src
, size
);
1172 data
[size
] = DW_OP_stack_value
;
1174 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1177 /* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
1178 Choose DEREF_SIZE value of that parameter. Search caller of the CTX's
1179 frame. CTX must be of dwarf_expr_ctx_funcs kind.
1181 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1182 can be more simple as it does not support cross-CU DWARF executions. */
1185 dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
1186 enum call_site_parameter_kind kind
,
1187 union call_site_parameter_u kind_u
,
1190 struct dwarf_expr_baton
*debaton
;
1191 struct frame_info
*frame
, *caller_frame
;
1192 struct dwarf2_per_cu_data
*caller_per_cu
;
1193 struct dwarf_expr_baton baton_local
;
1194 struct dwarf_expr_context saved_ctx
;
1195 struct call_site_parameter
*parameter
;
1196 const gdb_byte
*data_src
;
1199 gdb_assert (ctx
->funcs
== &dwarf_expr_ctx_funcs
);
1200 debaton
= ctx
->baton
;
1201 frame
= debaton
->frame
;
1202 caller_frame
= get_prev_frame (frame
);
1204 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1206 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1207 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1209 /* DEREF_SIZE size is not verified here. */
1210 if (data_src
== NULL
)
1211 throw_error (NO_ENTRY_VALUE_ERROR
,
1212 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1214 baton_local
.frame
= caller_frame
;
1215 baton_local
.per_cu
= caller_per_cu
;
1217 saved_ctx
.gdbarch
= ctx
->gdbarch
;
1218 saved_ctx
.addr_size
= ctx
->addr_size
;
1219 saved_ctx
.offset
= ctx
->offset
;
1220 saved_ctx
.baton
= ctx
->baton
;
1221 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (baton_local
.per_cu
));
1222 ctx
->addr_size
= dwarf2_per_cu_addr_size (baton_local
.per_cu
);
1223 ctx
->offset
= dwarf2_per_cu_text_offset (baton_local
.per_cu
);
1224 ctx
->baton
= &baton_local
;
1226 dwarf_expr_eval (ctx
, data_src
, size
);
1228 ctx
->gdbarch
= saved_ctx
.gdbarch
;
1229 ctx
->addr_size
= saved_ctx
.addr_size
;
1230 ctx
->offset
= saved_ctx
.offset
;
1231 ctx
->baton
= saved_ctx
.baton
;
1234 /* Callback function for dwarf2_evaluate_loc_desc.
1235 Fetch the address indexed by DW_OP_GNU_addr_index. */
1238 dwarf_expr_get_addr_index (void *baton
, unsigned int index
)
1240 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
1242 return dwarf2_read_addr_index (debaton
->per_cu
, index
);
1245 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1246 the indirect method on it, that is use its stored target value, the sole
1247 purpose of entry_data_value_funcs.. */
1249 static struct value
*
1250 entry_data_value_coerce_ref (const struct value
*value
)
1252 struct type
*checked_type
= check_typedef (value_type (value
));
1253 struct value
*target_val
;
1255 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
)
1258 target_val
= value_computed_closure (value
);
1259 value_incref (target_val
);
1263 /* Implement copy_closure. */
1266 entry_data_value_copy_closure (const struct value
*v
)
1268 struct value
*target_val
= value_computed_closure (v
);
1270 value_incref (target_val
);
1274 /* Implement free_closure. */
1277 entry_data_value_free_closure (struct value
*v
)
1279 struct value
*target_val
= value_computed_closure (v
);
1281 value_free (target_val
);
1284 /* Vector for methods for an entry value reference where the referenced value
1285 is stored in the caller. On the first dereference use
1286 DW_AT_GNU_call_site_data_value in the caller. */
1288 static const struct lval_funcs entry_data_value_funcs
=
1292 NULL
, /* check_validity */
1293 NULL
, /* check_any_valid */
1294 NULL
, /* indirect */
1295 entry_data_value_coerce_ref
,
1296 NULL
, /* check_synthetic_pointer */
1297 entry_data_value_copy_closure
,
1298 entry_data_value_free_closure
1301 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1302 are used to match DW_AT_location at the caller's
1303 DW_TAG_GNU_call_site_parameter.
1305 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1306 cannot resolve the parameter for any reason. */
1308 static struct value
*
1309 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1310 enum call_site_parameter_kind kind
,
1311 union call_site_parameter_u kind_u
)
1313 struct type
*checked_type
= check_typedef (type
);
1314 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1315 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1316 struct value
*outer_val
, *target_val
, *val
;
1317 struct call_site_parameter
*parameter
;
1318 struct dwarf2_per_cu_data
*caller_per_cu
;
1321 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1324 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1328 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1329 used and it is not available do not fall back to OUTER_VAL - dereferencing
1330 TYPE_CODE_REF with non-entry data value would give current value - not the
1333 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
1334 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1337 target_val
= dwarf_entry_parameter_to_value (parameter
,
1338 TYPE_LENGTH (target_type
),
1339 target_type
, caller_frame
,
1342 /* value_as_address dereferences TYPE_CODE_REF. */
1343 addr
= extract_typed_address (value_contents (outer_val
), checked_type
);
1345 /* The target entry value has artificial address of the entry value
1347 VALUE_LVAL (target_val
) = lval_memory
;
1348 set_value_address (target_val
, addr
);
1350 release_value (target_val
);
1351 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1352 target_val
/* closure */);
1354 /* Copy the referencing pointer to the new computed value. */
1355 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1356 TYPE_LENGTH (checked_type
));
1357 set_value_lazy (val
, 0);
1362 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1363 SIZE are DWARF block used to match DW_AT_location at the caller's
1364 DW_TAG_GNU_call_site_parameter.
1366 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1367 cannot resolve the parameter for any reason. */
1369 static struct value
*
1370 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1371 const gdb_byte
*block
, size_t block_len
)
1373 union call_site_parameter_u kind_u
;
1375 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1376 if (kind_u
.dwarf_reg
!= -1)
1377 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1380 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1381 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1384 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1385 suppressed during normal operation. The expression can be arbitrary if
1386 there is no caller-callee entry value binding expected. */
1387 throw_error (NO_ENTRY_VALUE_ERROR
,
1388 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1389 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1392 struct piece_closure
1394 /* Reference count. */
1397 /* The CU from which this closure's expression came. */
1398 struct dwarf2_per_cu_data
*per_cu
;
1400 /* The number of pieces used to describe this variable. */
1403 /* The target address size, used only for DWARF_VALUE_STACK. */
1406 /* The pieces themselves. */
1407 struct dwarf_expr_piece
*pieces
;
1410 /* Allocate a closure for a value formed from separately-described
1413 static struct piece_closure
*
1414 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1415 int n_pieces
, struct dwarf_expr_piece
*pieces
,
1418 struct piece_closure
*c
= XCNEW (struct piece_closure
);
1423 c
->n_pieces
= n_pieces
;
1424 c
->addr_size
= addr_size
;
1425 c
->pieces
= XCNEWVEC (struct dwarf_expr_piece
, n_pieces
);
1427 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
1428 for (i
= 0; i
< n_pieces
; ++i
)
1429 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1430 value_incref (c
->pieces
[i
].v
.value
);
1435 /* The lowest-level function to extract bits from a byte buffer.
1436 SOURCE is the buffer. It is updated if we read to the end of a
1438 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1439 updated to reflect the number of bits actually read.
1440 NBITS is the number of bits we want to read. It is updated to
1441 reflect the number of bits actually read. This function may read
1443 BITS_BIG_ENDIAN is taken directly from gdbarch.
1444 This function returns the extracted bits. */
1447 extract_bits_primitive (const gdb_byte
**source
,
1448 unsigned int *source_offset_bits
,
1449 int *nbits
, int bits_big_endian
)
1451 unsigned int avail
, mask
, datum
;
1453 gdb_assert (*source_offset_bits
< 8);
1455 avail
= 8 - *source_offset_bits
;
1459 mask
= (1 << avail
) - 1;
1461 if (bits_big_endian
)
1462 datum
>>= 8 - (*source_offset_bits
+ *nbits
);
1464 datum
>>= *source_offset_bits
;
1468 *source_offset_bits
+= avail
;
1469 if (*source_offset_bits
>= 8)
1471 *source_offset_bits
-= 8;
1478 /* Extract some bits from a source buffer and move forward in the
1481 SOURCE is the source buffer. It is updated as bytes are read.
1482 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1484 NBITS is the number of bits to read.
1485 BITS_BIG_ENDIAN is taken directly from gdbarch.
1487 This function returns the bits that were read. */
1490 extract_bits (const gdb_byte
**source
, unsigned int *source_offset_bits
,
1491 int nbits
, int bits_big_endian
)
1495 gdb_assert (nbits
> 0 && nbits
<= 8);
1497 datum
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1503 more
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1505 if (bits_big_endian
)
1515 /* Write some bits into a buffer and move forward in the buffer.
1517 DATUM is the bits to write. The low-order bits of DATUM are used.
1518 DEST is the destination buffer. It is updated as bytes are
1520 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1522 NBITS is the number of valid bits in DATUM.
1523 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1526 insert_bits (unsigned int datum
,
1527 gdb_byte
*dest
, unsigned int dest_offset_bits
,
1528 int nbits
, int bits_big_endian
)
1532 gdb_assert (dest_offset_bits
+ nbits
<= 8);
1534 mask
= (1 << nbits
) - 1;
1535 if (bits_big_endian
)
1537 datum
<<= 8 - (dest_offset_bits
+ nbits
);
1538 mask
<<= 8 - (dest_offset_bits
+ nbits
);
1542 datum
<<= dest_offset_bits
;
1543 mask
<<= dest_offset_bits
;
1546 gdb_assert ((datum
& ~mask
) == 0);
1548 *dest
= (*dest
& ~mask
) | datum
;
1551 /* Copy bits from a source to a destination.
1553 DEST is where the bits should be written.
1554 DEST_OFFSET_BITS is the bit offset into DEST.
1555 SOURCE is the source of bits.
1556 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1557 BIT_COUNT is the number of bits to copy.
1558 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1561 copy_bitwise (gdb_byte
*dest
, unsigned int dest_offset_bits
,
1562 const gdb_byte
*source
, unsigned int source_offset_bits
,
1563 unsigned int bit_count
,
1564 int bits_big_endian
)
1566 unsigned int dest_avail
;
1569 /* Reduce everything to byte-size pieces. */
1570 dest
+= dest_offset_bits
/ 8;
1571 dest_offset_bits
%= 8;
1572 source
+= source_offset_bits
/ 8;
1573 source_offset_bits
%= 8;
1575 dest_avail
= 8 - dest_offset_bits
% 8;
1577 /* See if we can fill the first destination byte. */
1578 if (dest_avail
< bit_count
)
1580 datum
= extract_bits (&source
, &source_offset_bits
, dest_avail
,
1582 insert_bits (datum
, dest
, dest_offset_bits
, dest_avail
, bits_big_endian
);
1584 dest_offset_bits
= 0;
1585 bit_count
-= dest_avail
;
1588 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1589 than 8 bits remaining. */
1590 gdb_assert (dest_offset_bits
% 8 == 0 || bit_count
< 8);
1591 for (; bit_count
>= 8; bit_count
-= 8)
1593 datum
= extract_bits (&source
, &source_offset_bits
, 8, bits_big_endian
);
1594 *dest
++ = (gdb_byte
) datum
;
1597 /* Finally, we may have a few leftover bits. */
1598 gdb_assert (bit_count
<= 8 - dest_offset_bits
% 8);
1601 datum
= extract_bits (&source
, &source_offset_bits
, bit_count
,
1603 insert_bits (datum
, dest
, dest_offset_bits
, bit_count
, bits_big_endian
);
1608 read_pieced_value (struct value
*v
)
1612 ULONGEST bits_to_skip
;
1614 struct piece_closure
*c
1615 = (struct piece_closure
*) value_computed_closure (v
);
1616 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (v
));
1618 size_t buffer_size
= 0;
1619 gdb_byte
*buffer
= NULL
;
1620 struct cleanup
*cleanup
;
1622 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1624 if (value_type (v
) != value_enclosing_type (v
))
1625 internal_error (__FILE__
, __LINE__
,
1626 _("Should not be able to create a lazy value with "
1627 "an enclosing type"));
1629 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1631 contents
= value_contents_raw (v
);
1632 bits_to_skip
= 8 * value_offset (v
);
1633 if (value_bitsize (v
))
1635 bits_to_skip
+= value_bitpos (v
);
1636 type_len
= value_bitsize (v
);
1639 type_len
= 8 * TYPE_LENGTH (value_type (v
));
1641 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1643 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1644 size_t this_size
, this_size_bits
;
1645 long dest_offset_bits
, source_offset_bits
, source_offset
;
1646 const gdb_byte
*intermediate_buffer
;
1648 /* Compute size, source, and destination offsets for copying, in
1650 this_size_bits
= p
->size
;
1651 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1653 bits_to_skip
-= this_size_bits
;
1656 if (bits_to_skip
> 0)
1658 dest_offset_bits
= 0;
1659 source_offset_bits
= bits_to_skip
;
1660 this_size_bits
-= bits_to_skip
;
1665 dest_offset_bits
= offset
;
1666 source_offset_bits
= 0;
1668 if (this_size_bits
> type_len
- offset
)
1669 this_size_bits
= type_len
- offset
;
1671 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1672 source_offset
= source_offset_bits
/ 8;
1673 if (buffer_size
< this_size
)
1675 buffer_size
= this_size
;
1676 buffer
= xrealloc (buffer
, buffer_size
);
1678 intermediate_buffer
= buffer
;
1680 /* Copy from the source to DEST_BUFFER. */
1681 switch (p
->location
)
1683 case DWARF_VALUE_REGISTER
:
1685 struct gdbarch
*arch
= get_frame_arch (frame
);
1686 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1687 int reg_offset
= source_offset
;
1689 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1690 && this_size
< register_size (arch
, gdb_regnum
))
1692 /* Big-endian, and we want less than full size. */
1693 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1694 /* We want the lower-order THIS_SIZE_BITS of the bytes
1695 we extract from the register. */
1696 source_offset_bits
+= 8 * this_size
- this_size_bits
;
1699 if (gdb_regnum
!= -1)
1703 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1707 /* Just so garbage doesn't ever shine through. */
1708 memset (buffer
, 0, this_size
);
1711 set_value_optimized_out (v
, 1);
1713 mark_value_bits_unavailable (v
, offset
, this_size_bits
);
1718 error (_("Unable to access DWARF register number %s"),
1719 paddress (arch
, p
->v
.regno
));
1724 case DWARF_VALUE_MEMORY
:
1725 read_value_memory (v
, offset
,
1726 p
->v
.mem
.in_stack_memory
,
1727 p
->v
.mem
.addr
+ source_offset
,
1731 case DWARF_VALUE_STACK
:
1733 size_t n
= this_size
;
1735 if (n
> c
->addr_size
- source_offset
)
1736 n
= (c
->addr_size
>= source_offset
1737 ? c
->addr_size
- source_offset
1745 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
1747 intermediate_buffer
= val_bytes
+ source_offset
;
1752 case DWARF_VALUE_LITERAL
:
1754 size_t n
= this_size
;
1756 if (n
> p
->v
.literal
.length
- source_offset
)
1757 n
= (p
->v
.literal
.length
>= source_offset
1758 ? p
->v
.literal
.length
- source_offset
1761 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
1765 /* These bits show up as zeros -- but do not cause the value
1766 to be considered optimized-out. */
1767 case DWARF_VALUE_IMPLICIT_POINTER
:
1770 case DWARF_VALUE_OPTIMIZED_OUT
:
1771 set_value_optimized_out (v
, 1);
1775 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1778 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
1779 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1780 copy_bitwise (contents
, dest_offset_bits
,
1781 intermediate_buffer
, source_offset_bits
% 8,
1782 this_size_bits
, bits_big_endian
);
1784 offset
+= this_size_bits
;
1787 do_cleanups (cleanup
);
1791 write_pieced_value (struct value
*to
, struct value
*from
)
1795 ULONGEST bits_to_skip
;
1796 const gdb_byte
*contents
;
1797 struct piece_closure
*c
1798 = (struct piece_closure
*) value_computed_closure (to
);
1799 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
1801 size_t buffer_size
= 0;
1802 gdb_byte
*buffer
= NULL
;
1803 struct cleanup
*cleanup
;
1805 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
1809 set_value_optimized_out (to
, 1);
1813 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1815 contents
= value_contents (from
);
1816 bits_to_skip
= 8 * value_offset (to
);
1817 if (value_bitsize (to
))
1819 bits_to_skip
+= value_bitpos (to
);
1820 type_len
= value_bitsize (to
);
1823 type_len
= 8 * TYPE_LENGTH (value_type (to
));
1825 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1827 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1828 size_t this_size_bits
, this_size
;
1829 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
1831 const gdb_byte
*source_buffer
;
1833 this_size_bits
= p
->size
;
1834 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1836 bits_to_skip
-= this_size_bits
;
1839 if (this_size_bits
> type_len
- offset
)
1840 this_size_bits
= type_len
- offset
;
1841 if (bits_to_skip
> 0)
1843 dest_offset_bits
= bits_to_skip
;
1844 source_offset_bits
= 0;
1845 this_size_bits
-= bits_to_skip
;
1850 dest_offset_bits
= 0;
1851 source_offset_bits
= offset
;
1854 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1855 source_offset
= source_offset_bits
/ 8;
1856 dest_offset
= dest_offset_bits
/ 8;
1857 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
1859 source_buffer
= contents
+ source_offset
;
1864 if (buffer_size
< this_size
)
1866 buffer_size
= this_size
;
1867 buffer
= xrealloc (buffer
, buffer_size
);
1869 source_buffer
= buffer
;
1873 switch (p
->location
)
1875 case DWARF_VALUE_REGISTER
:
1877 struct gdbarch
*arch
= get_frame_arch (frame
);
1878 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1879 int reg_offset
= dest_offset
;
1881 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1882 && this_size
<= register_size (arch
, gdb_regnum
))
1883 /* Big-endian, and we want less than full size. */
1884 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1886 if (gdb_regnum
!= -1)
1892 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1897 throw_error (OPTIMIZED_OUT_ERROR
,
1898 _("Can't do read-modify-write to "
1899 "update bitfield; containing word "
1900 "has been optimized out"));
1902 throw_error (NOT_AVAILABLE_ERROR
,
1903 _("Can't do read-modify-write to update "
1904 "bitfield; containing word "
1907 copy_bitwise (buffer
, dest_offset_bits
,
1908 contents
, source_offset_bits
,
1913 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1914 this_size
, source_buffer
);
1918 error (_("Unable to write to DWARF register number %s"),
1919 paddress (arch
, p
->v
.regno
));
1923 case DWARF_VALUE_MEMORY
:
1926 /* Only the first and last bytes can possibly have any
1928 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
, 1);
1929 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
1930 buffer
+ this_size
- 1, 1);
1931 copy_bitwise (buffer
, dest_offset_bits
,
1932 contents
, source_offset_bits
,
1937 write_memory (p
->v
.mem
.addr
+ dest_offset
,
1938 source_buffer
, this_size
);
1941 set_value_optimized_out (to
, 1);
1944 offset
+= this_size_bits
;
1947 do_cleanups (cleanup
);
1950 /* A helper function that checks bit validity in a pieced value.
1951 CHECK_FOR indicates the kind of validity checking.
1952 DWARF_VALUE_MEMORY means to check whether any bit is valid.
1953 DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
1955 DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
1956 implicit pointer. */
1959 check_pieced_value_bits (const struct value
*value
, int bit_offset
,
1961 enum dwarf_value_location check_for
)
1963 struct piece_closure
*c
1964 = (struct piece_closure
*) value_computed_closure (value
);
1966 int validity
= (check_for
== DWARF_VALUE_MEMORY
1967 || check_for
== DWARF_VALUE_IMPLICIT_POINTER
);
1969 bit_offset
+= 8 * value_offset (value
);
1970 if (value_bitsize (value
))
1971 bit_offset
+= value_bitpos (value
);
1973 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
1975 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1976 size_t this_size_bits
= p
->size
;
1980 if (bit_offset
>= this_size_bits
)
1982 bit_offset
-= this_size_bits
;
1986 bit_length
-= this_size_bits
- bit_offset
;
1990 bit_length
-= this_size_bits
;
1992 if (check_for
== DWARF_VALUE_IMPLICIT_POINTER
)
1994 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1997 else if (p
->location
== DWARF_VALUE_OPTIMIZED_OUT
1998 || p
->location
== DWARF_VALUE_IMPLICIT_POINTER
)
2014 check_pieced_value_validity (const struct value
*value
, int bit_offset
,
2017 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
2018 DWARF_VALUE_MEMORY
);
2022 check_pieced_value_invalid (const struct value
*value
)
2024 return check_pieced_value_bits (value
, 0,
2025 8 * TYPE_LENGTH (value_type (value
)),
2026 DWARF_VALUE_OPTIMIZED_OUT
);
2029 /* An implementation of an lval_funcs method to see whether a value is
2030 a synthetic pointer. */
2033 check_pieced_synthetic_pointer (const struct value
*value
, int bit_offset
,
2036 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
2037 DWARF_VALUE_IMPLICIT_POINTER
);
2040 /* A wrapper function for get_frame_address_in_block. */
2043 get_frame_address_in_block_wrapper (void *baton
)
2045 return get_frame_address_in_block (baton
);
2048 /* An implementation of an lval_funcs method to indirect through a
2049 pointer. This handles the synthetic pointer case when needed. */
2051 static struct value
*
2052 indirect_pieced_value (struct value
*value
)
2054 struct piece_closure
*c
2055 = (struct piece_closure
*) value_computed_closure (value
);
2057 struct frame_info
*frame
;
2058 struct dwarf2_locexpr_baton baton
;
2059 int i
, bit_offset
, bit_length
;
2060 struct dwarf_expr_piece
*piece
= NULL
;
2061 LONGEST byte_offset
;
2063 type
= check_typedef (value_type (value
));
2064 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
2067 bit_length
= 8 * TYPE_LENGTH (type
);
2068 bit_offset
= 8 * value_offset (value
);
2069 if (value_bitsize (value
))
2070 bit_offset
+= value_bitpos (value
);
2072 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2074 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2075 size_t this_size_bits
= p
->size
;
2079 if (bit_offset
>= this_size_bits
)
2081 bit_offset
-= this_size_bits
;
2085 bit_length
-= this_size_bits
- bit_offset
;
2089 bit_length
-= this_size_bits
;
2091 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2094 if (bit_length
!= 0)
2095 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2101 frame
= get_selected_frame (_("No frame selected."));
2103 /* This is an offset requested by GDB, such as value subscripts.
2104 However, due to how synthetic pointers are implemented, this is
2105 always presented to us as a pointer type. This means we have to
2106 sign-extend it manually as appropriate. */
2107 byte_offset
= value_as_address (value
);
2108 if (TYPE_LENGTH (value_type (value
)) < sizeof (LONGEST
))
2109 byte_offset
= gdb_sign_extend (byte_offset
,
2110 8 * TYPE_LENGTH (value_type (value
)));
2111 byte_offset
+= piece
->v
.ptr
.offset
;
2115 = dwarf2_fetch_die_loc_sect_off (piece
->v
.ptr
.die
, c
->per_cu
,
2116 get_frame_address_in_block_wrapper
,
2119 if (baton
.data
!= NULL
)
2120 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
2121 baton
.data
, baton
.size
, baton
.per_cu
,
2125 struct obstack temp_obstack
;
2126 struct cleanup
*cleanup
;
2127 const gdb_byte
*bytes
;
2129 struct value
*result
;
2131 obstack_init (&temp_obstack
);
2132 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2134 bytes
= dwarf2_fetch_constant_bytes (piece
->v
.ptr
.die
, c
->per_cu
,
2135 &temp_obstack
, &len
);
2137 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
2141 || byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > len
)
2142 invalid_synthetic_pointer ();
2143 bytes
+= byte_offset
;
2144 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
2147 do_cleanups (cleanup
);
2153 copy_pieced_value_closure (const struct value
*v
)
2155 struct piece_closure
*c
2156 = (struct piece_closure
*) value_computed_closure (v
);
2163 free_pieced_value_closure (struct value
*v
)
2165 struct piece_closure
*c
2166 = (struct piece_closure
*) value_computed_closure (v
);
2173 for (i
= 0; i
< c
->n_pieces
; ++i
)
2174 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
2175 value_free (c
->pieces
[i
].v
.value
);
2182 /* Functions for accessing a variable described by DW_OP_piece. */
2183 static const struct lval_funcs pieced_value_funcs
= {
2186 check_pieced_value_validity
,
2187 check_pieced_value_invalid
,
2188 indirect_pieced_value
,
2189 NULL
, /* coerce_ref */
2190 check_pieced_synthetic_pointer
,
2191 copy_pieced_value_closure
,
2192 free_pieced_value_closure
2195 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2197 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
=
2199 dwarf_expr_read_addr_from_reg
,
2200 dwarf_expr_get_reg_value
,
2201 dwarf_expr_read_mem
,
2202 dwarf_expr_frame_base
,
2203 dwarf_expr_frame_cfa
,
2204 dwarf_expr_frame_pc
,
2205 dwarf_expr_tls_address
,
2206 dwarf_expr_dwarf_call
,
2207 dwarf_expr_get_base_type
,
2208 dwarf_expr_push_dwarf_reg_entry_value
,
2209 dwarf_expr_get_addr_index
2212 /* Evaluate a location description, starting at DATA and with length
2213 SIZE, to find the current location of variable of TYPE in the
2214 context of FRAME. BYTE_OFFSET is applied after the contents are
2217 static struct value
*
2218 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2219 const gdb_byte
*data
, size_t size
,
2220 struct dwarf2_per_cu_data
*per_cu
,
2221 LONGEST byte_offset
)
2223 struct value
*retval
;
2224 struct dwarf_expr_baton baton
;
2225 struct dwarf_expr_context
*ctx
;
2226 struct cleanup
*old_chain
, *value_chain
;
2227 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2228 volatile struct gdb_exception ex
;
2230 if (byte_offset
< 0)
2231 invalid_synthetic_pointer ();
2234 return allocate_optimized_out_value (type
);
2236 baton
.frame
= frame
;
2237 baton
.per_cu
= per_cu
;
2239 ctx
= new_dwarf_expr_context ();
2240 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2241 value_chain
= make_cleanup_value_free_to_mark (value_mark ());
2243 ctx
->gdbarch
= get_objfile_arch (objfile
);
2244 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2245 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2246 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2247 ctx
->baton
= &baton
;
2248 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2250 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2252 dwarf_expr_eval (ctx
, data
, size
);
2256 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2258 do_cleanups (old_chain
);
2259 retval
= allocate_value (type
);
2260 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
2263 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2265 if (entry_values_debug
)
2266 exception_print (gdb_stdout
, ex
);
2267 do_cleanups (old_chain
);
2268 return allocate_optimized_out_value (type
);
2271 throw_exception (ex
);
2274 if (ctx
->num_pieces
> 0)
2276 struct piece_closure
*c
;
2277 struct frame_id frame_id
= get_frame_id (frame
);
2278 ULONGEST bit_size
= 0;
2281 for (i
= 0; i
< ctx
->num_pieces
; ++i
)
2282 bit_size
+= ctx
->pieces
[i
].size
;
2283 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
2284 invalid_synthetic_pointer ();
2286 c
= allocate_piece_closure (per_cu
, ctx
->num_pieces
, ctx
->pieces
,
2288 /* We must clean up the value chain after creating the piece
2289 closure but before allocating the result. */
2290 do_cleanups (value_chain
);
2291 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
2292 VALUE_FRAME_ID (retval
) = frame_id
;
2293 set_value_offset (retval
, byte_offset
);
2297 switch (ctx
->location
)
2299 case DWARF_VALUE_REGISTER
:
2301 struct gdbarch
*arch
= get_frame_arch (frame
);
2303 = longest_to_int (value_as_long (dwarf_expr_fetch (ctx
, 0)));
2304 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
2306 if (byte_offset
!= 0)
2307 error (_("cannot use offset on synthetic pointer to register"));
2308 do_cleanups (value_chain
);
2309 if (gdb_regnum
== -1)
2310 error (_("Unable to access DWARF register number %d"),
2312 retval
= value_from_register (type
, gdb_regnum
, frame
);
2313 if (value_optimized_out (retval
))
2315 /* This means the register has undefined value / was
2316 not saved. As we're computing the location of some
2317 variable etc. in the program, not a value for
2318 inspecting a register ($pc, $sp, etc.), return a
2319 generic optimized out value instead, so that we show
2320 <optimized out> instead of <not saved>. */
2321 do_cleanups (value_chain
);
2322 retval
= allocate_optimized_out_value (type
);
2327 case DWARF_VALUE_MEMORY
:
2329 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
2330 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
2332 do_cleanups (value_chain
);
2333 retval
= value_at_lazy (type
, address
+ byte_offset
);
2334 if (in_stack_memory
)
2335 set_value_stack (retval
, 1);
2339 case DWARF_VALUE_STACK
:
2341 struct value
*value
= dwarf_expr_fetch (ctx
, 0);
2343 const gdb_byte
*val_bytes
;
2344 size_t n
= TYPE_LENGTH (value_type (value
));
2346 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2347 invalid_synthetic_pointer ();
2349 val_bytes
= value_contents_all (value
);
2350 val_bytes
+= byte_offset
;
2353 /* Preserve VALUE because we are going to free values back
2354 to the mark, but we still need the value contents
2356 value_incref (value
);
2357 do_cleanups (value_chain
);
2358 make_cleanup_value_free (value
);
2360 retval
= allocate_value (type
);
2361 contents
= value_contents_raw (retval
);
2362 if (n
> TYPE_LENGTH (type
))
2364 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2366 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2367 val_bytes
+= n
- TYPE_LENGTH (type
);
2368 n
= TYPE_LENGTH (type
);
2370 memcpy (contents
, val_bytes
, n
);
2374 case DWARF_VALUE_LITERAL
:
2377 const bfd_byte
*ldata
;
2378 size_t n
= ctx
->len
;
2380 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2381 invalid_synthetic_pointer ();
2383 do_cleanups (value_chain
);
2384 retval
= allocate_value (type
);
2385 contents
= value_contents_raw (retval
);
2387 ldata
= ctx
->data
+ byte_offset
;
2390 if (n
> TYPE_LENGTH (type
))
2392 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2394 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2395 ldata
+= n
- TYPE_LENGTH (type
);
2396 n
= TYPE_LENGTH (type
);
2398 memcpy (contents
, ldata
, n
);
2402 case DWARF_VALUE_OPTIMIZED_OUT
:
2403 do_cleanups (value_chain
);
2404 retval
= allocate_optimized_out_value (type
);
2407 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2408 operation by execute_stack_op. */
2409 case DWARF_VALUE_IMPLICIT_POINTER
:
2410 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2411 it can only be encountered when making a piece. */
2413 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2417 set_value_initialized (retval
, ctx
->initialized
);
2419 do_cleanups (old_chain
);
2424 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2425 passes 0 as the byte_offset. */
2428 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2429 const gdb_byte
*data
, size_t size
,
2430 struct dwarf2_per_cu_data
*per_cu
)
2432 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
2436 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2438 struct needs_frame_baton
2441 struct dwarf2_per_cu_data
*per_cu
;
2444 /* Reads from registers do require a frame. */
2446 needs_frame_read_addr_from_reg (void *baton
, int regnum
)
2448 struct needs_frame_baton
*nf_baton
= baton
;
2450 nf_baton
->needs_frame
= 1;
2454 /* struct dwarf_expr_context_funcs' "get_reg_value" callback:
2455 Reads from registers do require a frame. */
2457 static struct value
*
2458 needs_frame_get_reg_value (void *baton
, struct type
*type
, int regnum
)
2460 struct needs_frame_baton
*nf_baton
= baton
;
2462 nf_baton
->needs_frame
= 1;
2463 return value_zero (type
, not_lval
);
2466 /* Reads from memory do not require a frame. */
2468 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
2470 memset (buf
, 0, len
);
2473 /* Frame-relative accesses do require a frame. */
2475 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
2477 static gdb_byte lit0
= DW_OP_lit0
;
2478 struct needs_frame_baton
*nf_baton
= baton
;
2483 nf_baton
->needs_frame
= 1;
2486 /* CFA accesses require a frame. */
2489 needs_frame_frame_cfa (void *baton
)
2491 struct needs_frame_baton
*nf_baton
= baton
;
2493 nf_baton
->needs_frame
= 1;
2497 /* Thread-local accesses do require a frame. */
2499 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
2501 struct needs_frame_baton
*nf_baton
= baton
;
2503 nf_baton
->needs_frame
= 1;
2507 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2510 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
2512 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2514 per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
,
2515 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
2518 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2521 needs_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
2522 enum call_site_parameter_kind kind
,
2523 union call_site_parameter_u kind_u
, int deref_size
)
2525 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2527 nf_baton
->needs_frame
= 1;
2529 /* The expression may require some stub values on DWARF stack. */
2530 dwarf_expr_push_address (ctx
, 0, 0);
2533 /* DW_OP_GNU_addr_index doesn't require a frame. */
2536 needs_get_addr_index (void *baton
, unsigned int index
)
2538 /* Nothing to do. */
2542 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2544 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs
=
2546 needs_frame_read_addr_from_reg
,
2547 needs_frame_get_reg_value
,
2548 needs_frame_read_mem
,
2549 needs_frame_frame_base
,
2550 needs_frame_frame_cfa
,
2551 needs_frame_frame_cfa
, /* get_frame_pc */
2552 needs_frame_tls_address
,
2553 needs_frame_dwarf_call
,
2554 NULL
, /* get_base_type */
2555 needs_dwarf_reg_entry_value
,
2556 needs_get_addr_index
2559 /* Return non-zero iff the location expression at DATA (length SIZE)
2560 requires a frame to evaluate. */
2563 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, size_t size
,
2564 struct dwarf2_per_cu_data
*per_cu
)
2566 struct needs_frame_baton baton
;
2567 struct dwarf_expr_context
*ctx
;
2569 struct cleanup
*old_chain
;
2570 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2572 baton
.needs_frame
= 0;
2573 baton
.per_cu
= per_cu
;
2575 ctx
= new_dwarf_expr_context ();
2576 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2577 make_cleanup_value_free_to_mark (value_mark ());
2579 ctx
->gdbarch
= get_objfile_arch (objfile
);
2580 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2581 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2582 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2583 ctx
->baton
= &baton
;
2584 ctx
->funcs
= &needs_frame_ctx_funcs
;
2586 dwarf_expr_eval (ctx
, data
, size
);
2588 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
2590 if (ctx
->num_pieces
> 0)
2594 /* If the location has several pieces, and any of them are in
2595 registers, then we will need a frame to fetch them from. */
2596 for (i
= 0; i
< ctx
->num_pieces
; i
++)
2597 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2601 do_cleanups (old_chain
);
2603 return baton
.needs_frame
|| in_reg
;
2606 /* A helper function that throws an unimplemented error mentioning a
2607 given DWARF operator. */
2610 unimplemented (unsigned int op
)
2612 const char *name
= get_DW_OP_name (op
);
2615 error (_("DWARF operator %s cannot be translated to an agent expression"),
2618 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2619 "to an agent expression"),
2623 /* A helper function to convert a DWARF register to an arch register.
2624 ARCH is the architecture.
2625 DWARF_REG is the register.
2626 This will throw an exception if the DWARF register cannot be
2627 translated to an architecture register. */
2630 translate_register (struct gdbarch
*arch
, int dwarf_reg
)
2632 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2634 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
2638 /* A helper function that emits an access to memory. ARCH is the
2639 target architecture. EXPR is the expression which we are building.
2640 NBITS is the number of bits we want to read. This emits the
2641 opcodes needed to read the memory and then extract the desired
2645 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2647 ULONGEST nbytes
= (nbits
+ 7) / 8;
2649 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2652 ax_trace_quick (expr
, nbytes
);
2655 ax_simple (expr
, aop_ref8
);
2656 else if (nbits
<= 16)
2657 ax_simple (expr
, aop_ref16
);
2658 else if (nbits
<= 32)
2659 ax_simple (expr
, aop_ref32
);
2661 ax_simple (expr
, aop_ref64
);
2663 /* If we read exactly the number of bytes we wanted, we're done. */
2664 if (8 * nbytes
== nbits
)
2667 if (gdbarch_bits_big_endian (arch
))
2669 /* On a bits-big-endian machine, we want the high-order
2671 ax_const_l (expr
, 8 * nbytes
- nbits
);
2672 ax_simple (expr
, aop_rsh_unsigned
);
2676 /* On a bits-little-endian box, we want the low-order NBITS. */
2677 ax_zero_ext (expr
, nbits
);
2681 /* A helper function to return the frame's PC. */
2684 get_ax_pc (void *baton
)
2686 struct agent_expr
*expr
= baton
;
2691 /* Compile a DWARF location expression to an agent expression.
2693 EXPR is the agent expression we are building.
2694 LOC is the agent value we modify.
2695 ARCH is the architecture.
2696 ADDR_SIZE is the size of addresses, in bytes.
2697 OP_PTR is the start of the location expression.
2698 OP_END is one past the last byte of the location expression.
2700 This will throw an exception for various kinds of errors -- for
2701 example, if the expression cannot be compiled, or if the expression
2705 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2706 struct gdbarch
*arch
, unsigned int addr_size
,
2707 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
2708 struct dwarf2_per_cu_data
*per_cu
)
2710 struct cleanup
*cleanups
;
2712 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
2713 const gdb_byte
* const base
= op_ptr
;
2714 const gdb_byte
*previous_piece
= op_ptr
;
2715 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2716 ULONGEST bits_collected
= 0;
2717 unsigned int addr_size_bits
= 8 * addr_size
;
2718 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
2720 offsets
= xmalloc ((op_end
- op_ptr
) * sizeof (int));
2721 cleanups
= make_cleanup (xfree
, offsets
);
2723 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
2726 make_cleanup (VEC_cleanup (int), &dw_labels
);
2727 make_cleanup (VEC_cleanup (int), &patches
);
2729 /* By default we are making an address. */
2730 loc
->kind
= axs_lvalue_memory
;
2732 while (op_ptr
< op_end
)
2734 enum dwarf_location_atom op
= *op_ptr
;
2735 uint64_t uoffset
, reg
;
2739 offsets
[op_ptr
- base
] = expr
->len
;
2742 /* Our basic approach to code generation is to map DWARF
2743 operations directly to AX operations. However, there are
2746 First, DWARF works on address-sized units, but AX always uses
2747 LONGEST. For most operations we simply ignore this
2748 difference; instead we generate sign extensions as needed
2749 before division and comparison operations. It would be nice
2750 to omit the sign extensions, but there is no way to determine
2751 the size of the target's LONGEST. (This code uses the size
2752 of the host LONGEST in some cases -- that is a bug but it is
2755 Second, some DWARF operations cannot be translated to AX.
2756 For these we simply fail. See
2757 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2792 ax_const_l (expr
, op
- DW_OP_lit0
);
2796 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
2797 op_ptr
+= addr_size
;
2798 /* Some versions of GCC emit DW_OP_addr before
2799 DW_OP_GNU_push_tls_address. In this case the value is an
2800 index, not an address. We don't support things like
2801 branching between the address and the TLS op. */
2802 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
2803 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
2804 ax_const_l (expr
, uoffset
);
2808 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
2812 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
2816 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
2820 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
2824 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
2828 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
2832 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
2836 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
2840 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
2841 ax_const_l (expr
, uoffset
);
2844 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2845 ax_const_l (expr
, offset
);
2880 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2881 loc
->u
.reg
= translate_register (arch
, op
- DW_OP_reg0
);
2882 loc
->kind
= axs_lvalue_register
;
2886 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2887 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2888 loc
->u
.reg
= translate_register (arch
, reg
);
2889 loc
->kind
= axs_lvalue_register
;
2892 case DW_OP_implicit_value
:
2896 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
2897 if (op_ptr
+ len
> op_end
)
2898 error (_("DW_OP_implicit_value: too few bytes available."));
2899 if (len
> sizeof (ULONGEST
))
2900 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
2903 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
2906 dwarf_expr_require_composition (op_ptr
, op_end
,
2907 "DW_OP_implicit_value");
2909 loc
->kind
= axs_rvalue
;
2913 case DW_OP_stack_value
:
2914 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
2915 loc
->kind
= axs_rvalue
;
2950 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2951 i
= translate_register (arch
, op
- DW_OP_breg0
);
2955 ax_const_l (expr
, offset
);
2956 ax_simple (expr
, aop_add
);
2961 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2962 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2963 i
= translate_register (arch
, reg
);
2967 ax_const_l (expr
, offset
);
2968 ax_simple (expr
, aop_add
);
2974 const gdb_byte
*datastart
;
2977 struct symbol
*framefunc
;
2979 b
= block_for_pc (expr
->scope
);
2982 error (_("No block found for address"));
2984 framefunc
= block_linkage_function (b
);
2987 error (_("No function found for block"));
2989 dwarf_expr_frame_base_1 (framefunc
, expr
->scope
,
2990 &datastart
, &datalen
);
2992 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2993 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
2994 datastart
+ datalen
, per_cu
);
2995 if (loc
->kind
== axs_lvalue_register
)
2996 require_rvalue (expr
, loc
);
3000 ax_const_l (expr
, offset
);
3001 ax_simple (expr
, aop_add
);
3004 loc
->kind
= axs_lvalue_memory
;
3009 ax_simple (expr
, aop_dup
);
3013 ax_simple (expr
, aop_pop
);
3018 ax_pick (expr
, offset
);
3022 ax_simple (expr
, aop_swap
);
3030 ax_simple (expr
, aop_rot
);
3034 case DW_OP_deref_size
:
3038 if (op
== DW_OP_deref_size
)
3043 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3044 error (_("Unsupported size %d in %s"),
3045 size
, get_DW_OP_name (op
));
3046 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3051 /* Sign extend the operand. */
3052 ax_ext (expr
, addr_size_bits
);
3053 ax_simple (expr
, aop_dup
);
3054 ax_const_l (expr
, 0);
3055 ax_simple (expr
, aop_less_signed
);
3056 ax_simple (expr
, aop_log_not
);
3057 i
= ax_goto (expr
, aop_if_goto
);
3058 /* We have to emit 0 - X. */
3059 ax_const_l (expr
, 0);
3060 ax_simple (expr
, aop_swap
);
3061 ax_simple (expr
, aop_sub
);
3062 ax_label (expr
, i
, expr
->len
);
3066 /* No need to sign extend here. */
3067 ax_const_l (expr
, 0);
3068 ax_simple (expr
, aop_swap
);
3069 ax_simple (expr
, aop_sub
);
3073 /* Sign extend the operand. */
3074 ax_ext (expr
, addr_size_bits
);
3075 ax_simple (expr
, aop_bit_not
);
3078 case DW_OP_plus_uconst
:
3079 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3080 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3081 but we micro-optimize anyhow. */
3084 ax_const_l (expr
, reg
);
3085 ax_simple (expr
, aop_add
);
3090 ax_simple (expr
, aop_bit_and
);
3094 /* Sign extend the operands. */
3095 ax_ext (expr
, addr_size_bits
);
3096 ax_simple (expr
, aop_swap
);
3097 ax_ext (expr
, addr_size_bits
);
3098 ax_simple (expr
, aop_swap
);
3099 ax_simple (expr
, aop_div_signed
);
3103 ax_simple (expr
, aop_sub
);
3107 ax_simple (expr
, aop_rem_unsigned
);
3111 ax_simple (expr
, aop_mul
);
3115 ax_simple (expr
, aop_bit_or
);
3119 ax_simple (expr
, aop_add
);
3123 ax_simple (expr
, aop_lsh
);
3127 ax_simple (expr
, aop_rsh_unsigned
);
3131 ax_simple (expr
, aop_rsh_signed
);
3135 ax_simple (expr
, aop_bit_xor
);
3139 /* Sign extend the operands. */
3140 ax_ext (expr
, addr_size_bits
);
3141 ax_simple (expr
, aop_swap
);
3142 ax_ext (expr
, addr_size_bits
);
3143 /* Note no swap here: A <= B is !(B < A). */
3144 ax_simple (expr
, aop_less_signed
);
3145 ax_simple (expr
, aop_log_not
);
3149 /* Sign extend the operands. */
3150 ax_ext (expr
, addr_size_bits
);
3151 ax_simple (expr
, aop_swap
);
3152 ax_ext (expr
, addr_size_bits
);
3153 ax_simple (expr
, aop_swap
);
3154 /* A >= B is !(A < B). */
3155 ax_simple (expr
, aop_less_signed
);
3156 ax_simple (expr
, aop_log_not
);
3160 /* Sign extend the operands. */
3161 ax_ext (expr
, addr_size_bits
);
3162 ax_simple (expr
, aop_swap
);
3163 ax_ext (expr
, addr_size_bits
);
3164 /* No need for a second swap here. */
3165 ax_simple (expr
, aop_equal
);
3169 /* Sign extend the operands. */
3170 ax_ext (expr
, addr_size_bits
);
3171 ax_simple (expr
, aop_swap
);
3172 ax_ext (expr
, addr_size_bits
);
3173 ax_simple (expr
, aop_swap
);
3174 ax_simple (expr
, aop_less_signed
);
3178 /* Sign extend the operands. */
3179 ax_ext (expr
, addr_size_bits
);
3180 ax_simple (expr
, aop_swap
);
3181 ax_ext (expr
, addr_size_bits
);
3182 /* Note no swap here: A > B is B < A. */
3183 ax_simple (expr
, aop_less_signed
);
3187 /* Sign extend the operands. */
3188 ax_ext (expr
, addr_size_bits
);
3189 ax_simple (expr
, aop_swap
);
3190 ax_ext (expr
, addr_size_bits
);
3191 /* No need for a swap here. */
3192 ax_simple (expr
, aop_equal
);
3193 ax_simple (expr
, aop_log_not
);
3196 case DW_OP_call_frame_cfa
:
3197 dwarf2_compile_cfa_to_ax (expr
, loc
, arch
, expr
->scope
, per_cu
);
3198 loc
->kind
= axs_lvalue_memory
;
3201 case DW_OP_GNU_push_tls_address
:
3206 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3208 i
= ax_goto (expr
, aop_goto
);
3209 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3210 VEC_safe_push (int, patches
, i
);
3214 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3216 /* Zero extend the operand. */
3217 ax_zero_ext (expr
, addr_size_bits
);
3218 i
= ax_goto (expr
, aop_if_goto
);
3219 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3220 VEC_safe_push (int, patches
, i
);
3227 case DW_OP_bit_piece
:
3229 uint64_t size
, offset
;
3231 if (op_ptr
- 1 == previous_piece
)
3232 error (_("Cannot translate empty pieces to agent expressions"));
3233 previous_piece
= op_ptr
- 1;
3235 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3236 if (op
== DW_OP_piece
)
3242 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
3244 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3245 error (_("Expression pieces exceed word size"));
3247 /* Access the bits. */
3250 case axs_lvalue_register
:
3251 ax_reg (expr
, loc
->u
.reg
);
3254 case axs_lvalue_memory
:
3255 /* Offset the pointer, if needed. */
3258 ax_const_l (expr
, offset
/ 8);
3259 ax_simple (expr
, aop_add
);
3262 access_memory (arch
, expr
, size
);
3266 /* For a bits-big-endian target, shift up what we already
3267 have. For a bits-little-endian target, shift up the
3268 new data. Note that there is a potential bug here if
3269 the DWARF expression leaves multiple values on the
3271 if (bits_collected
> 0)
3273 if (bits_big_endian
)
3275 ax_simple (expr
, aop_swap
);
3276 ax_const_l (expr
, size
);
3277 ax_simple (expr
, aop_lsh
);
3278 /* We don't need a second swap here, because
3279 aop_bit_or is symmetric. */
3283 ax_const_l (expr
, size
);
3284 ax_simple (expr
, aop_lsh
);
3286 ax_simple (expr
, aop_bit_or
);
3289 bits_collected
+= size
;
3290 loc
->kind
= axs_rvalue
;
3294 case DW_OP_GNU_uninit
:
3300 struct dwarf2_locexpr_baton block
;
3301 int size
= (op
== DW_OP_call2
? 2 : 4);
3304 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3307 offset
.cu_off
= uoffset
;
3308 block
= dwarf2_fetch_die_loc_cu_off (offset
, per_cu
,
3311 /* DW_OP_call_ref is currently not supported. */
3312 gdb_assert (block
.per_cu
== per_cu
);
3314 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3315 block
.data
, block
.data
+ block
.size
,
3320 case DW_OP_call_ref
:
3328 /* Patch all the branches we emitted. */
3329 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
3331 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
3333 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3334 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
3337 do_cleanups (cleanups
);
3341 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3342 evaluator to calculate the location. */
3343 static struct value
*
3344 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3346 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3349 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3350 dlbaton
->size
, dlbaton
->per_cu
);
3355 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3356 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3359 static struct value
*
3360 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3362 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3364 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3368 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3370 locexpr_read_needs_frame (struct symbol
*symbol
)
3372 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3374 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
3378 /* Return true if DATA points to the end of a piece. END is one past
3379 the last byte in the expression. */
3382 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3384 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3387 /* Helper for locexpr_describe_location_piece that finds the name of a
3391 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3395 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
3396 return gdbarch_register_name (gdbarch
, regnum
);
3399 /* Nicely describe a single piece of a location, returning an updated
3400 position in the bytecode sequence. This function cannot recognize
3401 all locations; if a location is not recognized, it simply returns
3402 DATA. If there is an error during reading, e.g. we run off the end
3403 of the buffer, an error is thrown. */
3405 static const gdb_byte
*
3406 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3407 CORE_ADDR addr
, struct objfile
*objfile
,
3408 struct dwarf2_per_cu_data
*per_cu
,
3409 const gdb_byte
*data
, const gdb_byte
*end
,
3410 unsigned int addr_size
)
3412 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3415 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3417 fprintf_filtered (stream
, _("a variable in $%s"),
3418 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3421 else if (data
[0] == DW_OP_regx
)
3425 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3426 fprintf_filtered (stream
, _("a variable in $%s"),
3427 locexpr_regname (gdbarch
, reg
));
3429 else if (data
[0] == DW_OP_fbreg
)
3432 struct symbol
*framefunc
;
3434 int64_t frame_offset
;
3435 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3437 int64_t base_offset
= 0;
3439 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3440 if (!piece_end_p (new_data
, end
))
3444 b
= block_for_pc (addr
);
3447 error (_("No block found for address for symbol \"%s\"."),
3448 SYMBOL_PRINT_NAME (symbol
));
3450 framefunc
= block_linkage_function (b
);
3453 error (_("No function found for block for symbol \"%s\"."),
3454 SYMBOL_PRINT_NAME (symbol
));
3456 dwarf_expr_frame_base_1 (framefunc
, addr
, &base_data
, &base_size
);
3458 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3460 const gdb_byte
*buf_end
;
3462 frame_reg
= base_data
[0] - DW_OP_breg0
;
3463 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3465 if (buf_end
!= base_data
+ base_size
)
3466 error (_("Unexpected opcode after "
3467 "DW_OP_breg%u for symbol \"%s\"."),
3468 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3470 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3472 /* The frame base is just the register, with no offset. */
3473 frame_reg
= base_data
[0] - DW_OP_reg0
;
3478 /* We don't know what to do with the frame base expression,
3479 so we can't trace this variable; give up. */
3483 fprintf_filtered (stream
,
3484 _("a variable at frame base reg $%s offset %s+%s"),
3485 locexpr_regname (gdbarch
, frame_reg
),
3486 plongest (base_offset
), plongest (frame_offset
));
3488 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3489 && piece_end_p (data
, end
))
3493 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3495 fprintf_filtered (stream
,
3496 _("a variable at offset %s from base reg $%s"),
3498 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3501 /* The location expression for a TLS variable looks like this (on a
3504 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3505 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3507 0x3 is the encoding for DW_OP_addr, which has an operand as long
3508 as the size of an address on the target machine (here is 8
3509 bytes). Note that more recent version of GCC emit DW_OP_const4u
3510 or DW_OP_const8u, depending on address size, rather than
3511 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3512 The operand represents the offset at which the variable is within
3513 the thread local storage. */
3515 else if (data
+ 1 + addr_size
< end
3516 && (data
[0] == DW_OP_addr
3517 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3518 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3519 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3520 && piece_end_p (data
+ 2 + addr_size
, end
))
3523 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3524 gdbarch_byte_order (gdbarch
));
3526 fprintf_filtered (stream
,
3527 _("a thread-local variable at offset 0x%s "
3528 "in the thread-local storage for `%s'"),
3529 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3531 data
+= 1 + addr_size
+ 1;
3534 /* With -gsplit-dwarf a TLS variable can also look like this:
3535 DW_AT_location : 3 byte block: fc 4 e0
3536 (DW_OP_GNU_const_index: 4;
3537 DW_OP_GNU_push_tls_address) */
3538 else if (data
+ 3 <= end
3539 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3540 && data
[0] == DW_OP_GNU_const_index
3542 && data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3543 && piece_end_p (data
+ 2 + leb128_size
, end
))
3547 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3548 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3549 fprintf_filtered (stream
,
3550 _("a thread-local variable at offset 0x%s "
3551 "in the thread-local storage for `%s'"),
3552 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3556 else if (data
[0] >= DW_OP_lit0
3557 && data
[0] <= DW_OP_lit31
3559 && data
[1] == DW_OP_stack_value
)
3561 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3568 /* Disassemble an expression, stopping at the end of a piece or at the
3569 end of the expression. Returns a pointer to the next unread byte
3570 in the input expression. If ALL is nonzero, then this function
3571 will keep going until it reaches the end of the expression.
3572 If there is an error during reading, e.g. we run off the end
3573 of the buffer, an error is thrown. */
3575 static const gdb_byte
*
3576 disassemble_dwarf_expression (struct ui_file
*stream
,
3577 struct gdbarch
*arch
, unsigned int addr_size
,
3578 int offset_size
, const gdb_byte
*start
,
3579 const gdb_byte
*data
, const gdb_byte
*end
,
3580 int indent
, int all
,
3581 struct dwarf2_per_cu_data
*per_cu
)
3585 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3587 enum dwarf_location_atom op
= *data
++;
3592 name
= get_DW_OP_name (op
);
3595 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3596 op
, (long) (data
- 1 - start
));
3597 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3598 (long) (data
- 1 - start
), name
);
3603 ul
= extract_unsigned_integer (data
, addr_size
,
3604 gdbarch_byte_order (arch
));
3606 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3610 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3612 fprintf_filtered (stream
, " %s", pulongest (ul
));
3615 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3617 fprintf_filtered (stream
, " %s", plongest (l
));
3620 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3622 fprintf_filtered (stream
, " %s", pulongest (ul
));
3625 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3627 fprintf_filtered (stream
, " %s", plongest (l
));
3630 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3632 fprintf_filtered (stream
, " %s", pulongest (ul
));
3635 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3637 fprintf_filtered (stream
, " %s", plongest (l
));
3640 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3642 fprintf_filtered (stream
, " %s", pulongest (ul
));
3645 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3647 fprintf_filtered (stream
, " %s", plongest (l
));
3650 data
= safe_read_uleb128 (data
, end
, &ul
);
3651 fprintf_filtered (stream
, " %s", pulongest (ul
));
3654 data
= safe_read_sleb128 (data
, end
, &l
);
3655 fprintf_filtered (stream
, " %s", plongest (l
));
3690 fprintf_filtered (stream
, " [$%s]",
3691 locexpr_regname (arch
, op
- DW_OP_reg0
));
3695 data
= safe_read_uleb128 (data
, end
, &ul
);
3696 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3697 locexpr_regname (arch
, (int) ul
));
3700 case DW_OP_implicit_value
:
3701 data
= safe_read_uleb128 (data
, end
, &ul
);
3703 fprintf_filtered (stream
, " %s", pulongest (ul
));
3738 data
= safe_read_sleb128 (data
, end
, &l
);
3739 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
3740 locexpr_regname (arch
, op
- DW_OP_breg0
));
3744 data
= safe_read_uleb128 (data
, end
, &ul
);
3745 data
= safe_read_sleb128 (data
, end
, &l
);
3746 fprintf_filtered (stream
, " register %s [$%s] offset %s",
3748 locexpr_regname (arch
, (int) ul
),
3753 data
= safe_read_sleb128 (data
, end
, &l
);
3754 fprintf_filtered (stream
, " %s", plongest (l
));
3757 case DW_OP_xderef_size
:
3758 case DW_OP_deref_size
:
3760 fprintf_filtered (stream
, " %d", *data
);
3764 case DW_OP_plus_uconst
:
3765 data
= safe_read_uleb128 (data
, end
, &ul
);
3766 fprintf_filtered (stream
, " %s", pulongest (ul
));
3770 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3772 fprintf_filtered (stream
, " to %ld",
3773 (long) (data
+ l
- start
));
3777 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3779 fprintf_filtered (stream
, " %ld",
3780 (long) (data
+ l
- start
));
3784 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3786 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
3790 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3792 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3795 case DW_OP_call_ref
:
3796 ul
= extract_unsigned_integer (data
, offset_size
,
3797 gdbarch_byte_order (arch
));
3798 data
+= offset_size
;
3799 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
3803 data
= safe_read_uleb128 (data
, end
, &ul
);
3804 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
3807 case DW_OP_bit_piece
:
3811 data
= safe_read_uleb128 (data
, end
, &ul
);
3812 data
= safe_read_uleb128 (data
, end
, &offset
);
3813 fprintf_filtered (stream
, " size %s offset %s (bits)",
3814 pulongest (ul
), pulongest (offset
));
3818 case DW_OP_GNU_implicit_pointer
:
3820 ul
= extract_unsigned_integer (data
, offset_size
,
3821 gdbarch_byte_order (arch
));
3822 data
+= offset_size
;
3824 data
= safe_read_sleb128 (data
, end
, &l
);
3826 fprintf_filtered (stream
, " DIE %s offset %s",
3827 phex_nz (ul
, offset_size
),
3832 case DW_OP_GNU_deref_type
:
3834 int addr_size
= *data
++;
3838 data
= safe_read_uleb128 (data
, end
, &ul
);
3840 type
= dwarf2_get_die_type (offset
, per_cu
);
3841 fprintf_filtered (stream
, "<");
3842 type_print (type
, "", stream
, -1);
3843 fprintf_filtered (stream
, " [0x%s]> %d", phex_nz (offset
.cu_off
, 0),
3848 case DW_OP_GNU_const_type
:
3853 data
= safe_read_uleb128 (data
, end
, &ul
);
3854 type_die
.cu_off
= ul
;
3855 type
= dwarf2_get_die_type (type_die
, per_cu
);
3856 fprintf_filtered (stream
, "<");
3857 type_print (type
, "", stream
, -1);
3858 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3862 case DW_OP_GNU_regval_type
:
3868 data
= safe_read_uleb128 (data
, end
, ®
);
3869 data
= safe_read_uleb128 (data
, end
, &ul
);
3870 type_die
.cu_off
= ul
;
3872 type
= dwarf2_get_die_type (type_die
, per_cu
);
3873 fprintf_filtered (stream
, "<");
3874 type_print (type
, "", stream
, -1);
3875 fprintf_filtered (stream
, " [0x%s]> [$%s]",
3876 phex_nz (type_die
.cu_off
, 0),
3877 locexpr_regname (arch
, reg
));
3881 case DW_OP_GNU_convert
:
3882 case DW_OP_GNU_reinterpret
:
3886 data
= safe_read_uleb128 (data
, end
, &ul
);
3887 type_die
.cu_off
= ul
;
3889 if (type_die
.cu_off
== 0)
3890 fprintf_filtered (stream
, "<0>");
3895 type
= dwarf2_get_die_type (type_die
, per_cu
);
3896 fprintf_filtered (stream
, "<");
3897 type_print (type
, "", stream
, -1);
3898 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3903 case DW_OP_GNU_entry_value
:
3904 data
= safe_read_uleb128 (data
, end
, &ul
);
3905 fputc_filtered ('\n', stream
);
3906 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
3907 start
, data
, data
+ ul
, indent
+ 2,
3912 case DW_OP_GNU_parameter_ref
:
3913 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3915 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3918 case DW_OP_GNU_addr_index
:
3919 data
= safe_read_uleb128 (data
, end
, &ul
);
3920 ul
= dwarf2_read_addr_index (per_cu
, ul
);
3921 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3923 case DW_OP_GNU_const_index
:
3924 data
= safe_read_uleb128 (data
, end
, &ul
);
3925 ul
= dwarf2_read_addr_index (per_cu
, ul
);
3926 fprintf_filtered (stream
, " %s", pulongest (ul
));
3930 fprintf_filtered (stream
, "\n");
3936 /* Describe a single location, which may in turn consist of multiple
3940 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
3941 struct ui_file
*stream
,
3942 const gdb_byte
*data
, size_t size
,
3943 struct objfile
*objfile
, unsigned int addr_size
,
3944 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
3946 const gdb_byte
*end
= data
+ size
;
3947 int first_piece
= 1, bad
= 0;
3951 const gdb_byte
*here
= data
;
3952 int disassemble
= 1;
3957 fprintf_filtered (stream
, _(", and "));
3959 if (!dwarf2_always_disassemble
)
3961 data
= locexpr_describe_location_piece (symbol
, stream
,
3962 addr
, objfile
, per_cu
,
3963 data
, end
, addr_size
);
3964 /* If we printed anything, or if we have an empty piece,
3965 then don't disassemble. */
3967 || data
[0] == DW_OP_piece
3968 || data
[0] == DW_OP_bit_piece
)
3973 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
3974 data
= disassemble_dwarf_expression (stream
,
3975 get_objfile_arch (objfile
),
3976 addr_size
, offset_size
, data
,
3978 dwarf2_always_disassemble
,
3984 int empty
= data
== here
;
3987 fprintf_filtered (stream
, " ");
3988 if (data
[0] == DW_OP_piece
)
3992 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
3995 fprintf_filtered (stream
, _("an empty %s-byte piece"),
3998 fprintf_filtered (stream
, _(" [%s-byte piece]"),
4001 else if (data
[0] == DW_OP_bit_piece
)
4003 uint64_t bits
, offset
;
4005 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
4006 data
= safe_read_uleb128 (data
, end
, &offset
);
4009 fprintf_filtered (stream
,
4010 _("an empty %s-bit piece"),
4013 fprintf_filtered (stream
,
4014 _(" [%s-bit piece, offset %s bits]"),
4015 pulongest (bits
), pulongest (offset
));
4025 if (bad
|| data
> end
)
4026 error (_("Corrupted DWARF2 expression for \"%s\"."),
4027 SYMBOL_PRINT_NAME (symbol
));
4030 /* Print a natural-language description of SYMBOL to STREAM. This
4031 version is for a symbol with a single location. */
4034 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4035 struct ui_file
*stream
)
4037 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4038 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4039 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4040 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4042 locexpr_describe_location_1 (symbol
, addr
, stream
,
4043 dlbaton
->data
, dlbaton
->size
,
4044 objfile
, addr_size
, offset_size
,
4048 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4049 any necessary bytecode in AX. */
4052 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4053 struct agent_expr
*ax
, struct axs_value
*value
)
4055 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4056 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4058 if (dlbaton
->size
== 0)
4059 value
->optimized_out
= 1;
4061 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
4062 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4066 /* The set of location functions used with the DWARF-2 expression
4068 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4069 locexpr_read_variable
,
4070 locexpr_read_variable_at_entry
,
4071 locexpr_read_needs_frame
,
4072 locexpr_describe_location
,
4073 0, /* location_has_loclist */
4074 locexpr_tracepoint_var_ref
4078 /* Wrapper functions for location lists. These generally find
4079 the appropriate location expression and call something above. */
4081 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4082 evaluator to calculate the location. */
4083 static struct value
*
4084 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4086 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4088 const gdb_byte
*data
;
4090 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4092 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4093 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4099 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4100 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4103 Function always returns non-NULL value, it may be marked optimized out if
4104 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4105 if it cannot resolve the parameter for any reason. */
4107 static struct value
*
4108 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4110 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4111 const gdb_byte
*data
;
4115 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4116 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4118 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4120 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4122 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4125 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
4127 loclist_read_needs_frame (struct symbol
*symbol
)
4129 /* If there's a location list, then assume we need to have a frame
4130 to choose the appropriate location expression. With tracking of
4131 global variables this is not necessarily true, but such tracking
4132 is disabled in GCC at the moment until we figure out how to
4138 /* Print a natural-language description of SYMBOL to STREAM. This
4139 version applies when there is a list of different locations, each
4140 with a specified address range. */
4143 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4144 struct ui_file
*stream
)
4146 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4147 const gdb_byte
*loc_ptr
, *buf_end
;
4148 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4149 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4150 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4151 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4152 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4153 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4154 /* Adjust base_address for relocatable objects. */
4155 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4156 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4159 loc_ptr
= dlbaton
->data
;
4160 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4162 fprintf_filtered (stream
, _("multi-location:\n"));
4164 /* Iterate through locations until we run out. */
4167 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4169 enum debug_loc_kind kind
;
4170 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4172 if (dlbaton
->from_dwo
)
4173 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4174 loc_ptr
, buf_end
, &new_ptr
,
4175 &low
, &high
, byte_order
);
4177 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4179 byte_order
, addr_size
,
4184 case DEBUG_LOC_END_OF_LIST
:
4187 case DEBUG_LOC_BASE_ADDRESS
:
4188 base_address
= high
+ base_offset
;
4189 fprintf_filtered (stream
, _(" Base address %s"),
4190 paddress (gdbarch
, base_address
));
4192 case DEBUG_LOC_START_END
:
4193 case DEBUG_LOC_START_LENGTH
:
4195 case DEBUG_LOC_BUFFER_OVERFLOW
:
4196 case DEBUG_LOC_INVALID_ENTRY
:
4197 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4198 SYMBOL_PRINT_NAME (symbol
));
4200 gdb_assert_not_reached ("bad debug_loc_kind");
4203 /* Otherwise, a location expression entry. */
4204 low
+= base_address
;
4205 high
+= base_address
;
4207 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4210 /* (It would improve readability to print only the minimum
4211 necessary digits of the second number of the range.) */
4212 fprintf_filtered (stream
, _(" Range %s-%s: "),
4213 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4215 /* Now describe this particular location. */
4216 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4217 objfile
, addr_size
, offset_size
,
4220 fprintf_filtered (stream
, "\n");
4226 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4227 any necessary bytecode in AX. */
4229 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4230 struct agent_expr
*ax
, struct axs_value
*value
)
4232 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4233 const gdb_byte
*data
;
4235 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4237 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4239 value
->optimized_out
= 1;
4241 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
4245 /* The set of location functions used with the DWARF-2 expression
4246 evaluator and location lists. */
4247 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4248 loclist_read_variable
,
4249 loclist_read_variable_at_entry
,
4250 loclist_read_needs_frame
,
4251 loclist_describe_location
,
4252 1, /* location_has_loclist */
4253 loclist_tracepoint_var_ref
4256 /* Provide a prototype to silence -Wmissing-prototypes. */
4257 extern initialize_file_ftype _initialize_dwarf2loc
;
4260 _initialize_dwarf2loc (void)
4262 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4263 &entry_values_debug
,
4264 _("Set entry values and tail call frames "
4266 _("Show entry values and tail call frames "
4268 _("When non-zero, the process of determining "
4269 "parameter values from function entry point "
4270 "and tail call frames will be printed."),
4272 show_entry_values_debug
,
4273 &setdebuglist
, &showdebuglist
);