1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003-2020 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/>. */
35 #include "complaints.h"
37 #include "dwarf2/expr.h"
38 #include "dwarf2/loc.h"
39 #include "dwarf2/read.h"
40 #include "dwarf2/frame.h"
41 #include "dwarf2/leb.h"
42 #include "compile/compile.h"
43 #include "gdbsupport/selftest.h"
46 #include <unordered_set>
47 #include "gdbsupport/underlying.h"
48 #include "gdbsupport/byte-vector.h"
50 static struct value
*dwarf2_evaluate_loc_desc_full (struct type
*type
,
51 struct frame_info
*frame
,
54 struct dwarf2_per_cu_data
*per_cu
,
55 struct type
*subobj_type
,
56 LONGEST subobj_byte_offset
);
58 static struct call_site_parameter
*dwarf_expr_reg_to_entry_parameter
59 (struct frame_info
*frame
,
60 enum call_site_parameter_kind kind
,
61 union call_site_parameter_u kind_u
,
62 struct dwarf2_per_cu_data
**per_cu_return
);
64 static struct value
*indirect_synthetic_pointer
65 (sect_offset die
, LONGEST byte_offset
,
66 struct dwarf2_per_cu_data
*per_cu
,
67 struct frame_info
*frame
,
68 struct type
*type
, bool resolve_abstract_p
= false);
70 /* Until these have formal names, we define these here.
71 ref: http://gcc.gnu.org/wiki/DebugFission
72 Each entry in .debug_loc.dwo begins with a byte that describes the entry,
73 and is then followed by data specific to that entry. */
77 /* Indicates the end of the list of entries. */
78 DEBUG_LOC_END_OF_LIST
= 0,
80 /* This is followed by an unsigned LEB128 number that is an index into
81 .debug_addr and specifies the base address for all following entries. */
82 DEBUG_LOC_BASE_ADDRESS
= 1,
84 /* This is followed by two unsigned LEB128 numbers that are indices into
85 .debug_addr and specify the beginning and ending addresses, and then
86 a normal location expression as in .debug_loc. */
87 DEBUG_LOC_START_END
= 2,
89 /* This is followed by an unsigned LEB128 number that is an index into
90 .debug_addr and specifies the beginning address, and a 4 byte unsigned
91 number that specifies the length, and then a normal location expression
93 DEBUG_LOC_START_LENGTH
= 3,
95 /* An internal value indicating there is insufficient data. */
96 DEBUG_LOC_BUFFER_OVERFLOW
= -1,
98 /* An internal value indicating an invalid kind of entry was found. */
99 DEBUG_LOC_INVALID_ENTRY
= -2
102 /* Helper function which throws an error if a synthetic pointer is
106 invalid_synthetic_pointer (void)
108 error (_("access outside bounds of object "
109 "referenced via synthetic pointer"));
112 /* Decode the addresses in a non-dwo .debug_loc entry.
113 A pointer to the next byte to examine is returned in *NEW_PTR.
114 The encoded low,high addresses are return in *LOW,*HIGH.
115 The result indicates the kind of entry found. */
117 static enum debug_loc_kind
118 decode_debug_loc_addresses (const gdb_byte
*loc_ptr
, const gdb_byte
*buf_end
,
119 const gdb_byte
**new_ptr
,
120 CORE_ADDR
*low
, CORE_ADDR
*high
,
121 enum bfd_endian byte_order
,
122 unsigned int addr_size
,
125 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
127 if (buf_end
- loc_ptr
< 2 * addr_size
)
128 return DEBUG_LOC_BUFFER_OVERFLOW
;
131 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
133 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
134 loc_ptr
+= addr_size
;
137 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
139 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
140 loc_ptr
+= addr_size
;
144 /* A base-address-selection entry. */
145 if ((*low
& base_mask
) == base_mask
)
146 return DEBUG_LOC_BASE_ADDRESS
;
148 /* An end-of-list entry. */
149 if (*low
== 0 && *high
== 0)
150 return DEBUG_LOC_END_OF_LIST
;
152 return DEBUG_LOC_START_END
;
155 /* Decode the addresses in .debug_loclists entry.
156 A pointer to the next byte to examine is returned in *NEW_PTR.
157 The encoded low,high addresses are return in *LOW,*HIGH.
158 The result indicates the kind of entry found. */
160 static enum debug_loc_kind
161 decode_debug_loclists_addresses (struct dwarf2_per_cu_data
*per_cu
,
162 const gdb_byte
*loc_ptr
,
163 const gdb_byte
*buf_end
,
164 const gdb_byte
**new_ptr
,
165 CORE_ADDR
*low
, CORE_ADDR
*high
,
166 enum bfd_endian byte_order
,
167 unsigned int addr_size
,
172 if (loc_ptr
== buf_end
)
173 return DEBUG_LOC_BUFFER_OVERFLOW
;
177 case DW_LLE_base_addressx
:
179 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
181 return DEBUG_LOC_BUFFER_OVERFLOW
;
182 *high
= dwarf2_read_addr_index (per_cu
, u64
);
184 return DEBUG_LOC_BASE_ADDRESS
;
185 case DW_LLE_startx_length
:
186 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
188 return DEBUG_LOC_BUFFER_OVERFLOW
;
189 *low
= dwarf2_read_addr_index (per_cu
, u64
);
191 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
193 return DEBUG_LOC_BUFFER_OVERFLOW
;
196 return DEBUG_LOC_START_LENGTH
;
197 case DW_LLE_start_length
:
198 if (buf_end
- loc_ptr
< addr_size
)
199 return DEBUG_LOC_BUFFER_OVERFLOW
;
201 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
203 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
204 loc_ptr
+= addr_size
;
206 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
208 return DEBUG_LOC_BUFFER_OVERFLOW
;
211 return DEBUG_LOC_START_LENGTH
;
212 case DW_LLE_end_of_list
:
214 return DEBUG_LOC_END_OF_LIST
;
215 case DW_LLE_base_address
:
216 if (loc_ptr
+ addr_size
> buf_end
)
217 return DEBUG_LOC_BUFFER_OVERFLOW
;
219 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
221 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
222 loc_ptr
+= addr_size
;
224 return DEBUG_LOC_BASE_ADDRESS
;
225 case DW_LLE_offset_pair
:
226 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
228 return DEBUG_LOC_BUFFER_OVERFLOW
;
230 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
232 return DEBUG_LOC_BUFFER_OVERFLOW
;
235 return DEBUG_LOC_START_END
;
236 /* Following cases are not supported yet. */
237 case DW_LLE_startx_endx
:
238 case DW_LLE_start_end
:
239 case DW_LLE_default_location
:
241 return DEBUG_LOC_INVALID_ENTRY
;
245 /* Decode the addresses in .debug_loc.dwo entry.
246 A pointer to the next byte to examine is returned in *NEW_PTR.
247 The encoded low,high addresses are return in *LOW,*HIGH.
248 The result indicates the kind of entry found. */
250 static enum debug_loc_kind
251 decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data
*per_cu
,
252 const gdb_byte
*loc_ptr
,
253 const gdb_byte
*buf_end
,
254 const gdb_byte
**new_ptr
,
255 CORE_ADDR
*low
, CORE_ADDR
*high
,
256 enum bfd_endian byte_order
)
258 uint64_t low_index
, high_index
;
260 if (loc_ptr
== buf_end
)
261 return DEBUG_LOC_BUFFER_OVERFLOW
;
265 case DW_LLE_GNU_end_of_list_entry
:
267 return DEBUG_LOC_END_OF_LIST
;
268 case DW_LLE_GNU_base_address_selection_entry
:
270 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
272 return DEBUG_LOC_BUFFER_OVERFLOW
;
273 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
275 return DEBUG_LOC_BASE_ADDRESS
;
276 case DW_LLE_GNU_start_end_entry
:
277 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
279 return DEBUG_LOC_BUFFER_OVERFLOW
;
280 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
281 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
283 return DEBUG_LOC_BUFFER_OVERFLOW
;
284 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
286 return DEBUG_LOC_START_END
;
287 case DW_LLE_GNU_start_length_entry
:
288 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
290 return DEBUG_LOC_BUFFER_OVERFLOW
;
291 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
292 if (loc_ptr
+ 4 > buf_end
)
293 return DEBUG_LOC_BUFFER_OVERFLOW
;
295 *high
+= extract_unsigned_integer (loc_ptr
, 4, byte_order
);
296 *new_ptr
= loc_ptr
+ 4;
297 return DEBUG_LOC_START_LENGTH
;
299 return DEBUG_LOC_INVALID_ENTRY
;
303 /* A function for dealing with location lists. Given a
304 symbol baton (BATON) and a pc value (PC), find the appropriate
305 location expression, set *LOCEXPR_LENGTH, and return a pointer
306 to the beginning of the expression. Returns NULL on failure.
308 For now, only return the first matching location expression; there
309 can be more than one in the list. */
312 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
313 size_t *locexpr_length
, CORE_ADDR pc
)
315 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
316 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
317 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
318 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
319 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
320 /* Adjust base_address for relocatable objects. */
321 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (baton
->per_cu
);
322 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
323 const gdb_byte
*loc_ptr
, *buf_end
;
325 loc_ptr
= baton
->data
;
326 buf_end
= baton
->data
+ baton
->size
;
330 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
332 enum debug_loc_kind kind
;
333 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
336 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
337 loc_ptr
, buf_end
, &new_ptr
,
338 &low
, &high
, byte_order
);
339 else if (dwarf2_version (baton
->per_cu
) < 5)
340 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
342 byte_order
, addr_size
,
345 kind
= decode_debug_loclists_addresses (baton
->per_cu
,
346 loc_ptr
, buf_end
, &new_ptr
,
347 &low
, &high
, byte_order
,
348 addr_size
, signed_addr_p
);
353 case DEBUG_LOC_END_OF_LIST
:
356 case DEBUG_LOC_BASE_ADDRESS
:
357 base_address
= high
+ base_offset
;
359 case DEBUG_LOC_START_END
:
360 case DEBUG_LOC_START_LENGTH
:
362 case DEBUG_LOC_BUFFER_OVERFLOW
:
363 case DEBUG_LOC_INVALID_ENTRY
:
364 error (_("dwarf2_find_location_expression: "
365 "Corrupted DWARF expression."));
367 gdb_assert_not_reached ("bad debug_loc_kind");
370 /* Otherwise, a location expression entry.
371 If the entry is from a DWO, don't add base address: the entry is from
372 .debug_addr which already has the DWARF "base address". We still add
373 base_offset in case we're debugging a PIE executable. */
382 high
+= base_address
;
385 if (dwarf2_version (baton
->per_cu
) < 5)
387 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
392 unsigned int bytes_read
;
394 length
= read_unsigned_leb128 (NULL
, loc_ptr
, &bytes_read
);
395 loc_ptr
+= bytes_read
;
398 if (low
== high
&& pc
== low
)
400 /* This is entry PC record present only at entry point
401 of a function. Verify it is really the function entry point. */
403 const struct block
*pc_block
= block_for_pc (pc
);
404 struct symbol
*pc_func
= NULL
;
407 pc_func
= block_linkage_function (pc_block
);
409 if (pc_func
&& pc
== BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (pc_func
)))
411 *locexpr_length
= length
;
416 if (pc
>= low
&& pc
< high
)
418 *locexpr_length
= length
;
426 /* This is the baton used when performing dwarf2 expression
428 struct dwarf_expr_baton
430 struct frame_info
*frame
;
431 struct dwarf2_per_cu_data
*per_cu
;
432 CORE_ADDR obj_address
;
435 /* Implement find_frame_base_location method for LOC_BLOCK functions using
436 DWARF expression for its DW_AT_frame_base. */
439 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
440 const gdb_byte
**start
, size_t *length
)
442 struct dwarf2_locexpr_baton
*symbaton
443 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
445 *length
= symbaton
->size
;
446 *start
= symbaton
->data
;
449 /* Implement the struct symbol_block_ops::get_frame_base method for
450 LOC_BLOCK functions using a DWARF expression as its DW_AT_frame_base. */
453 locexpr_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
455 struct gdbarch
*gdbarch
;
457 struct dwarf2_locexpr_baton
*dlbaton
;
458 const gdb_byte
*start
;
460 struct value
*result
;
462 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
463 Thus, it's supposed to provide the find_frame_base_location method as
465 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
467 gdbarch
= get_frame_arch (frame
);
468 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
469 dlbaton
= (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
471 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
472 (framefunc
, get_frame_pc (frame
), &start
, &length
);
473 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
476 /* The DW_AT_frame_base attribute contains a location description which
477 computes the base address itself. However, the call to
478 dwarf2_evaluate_loc_desc returns a value representing a variable at
479 that address. The frame base address is thus this variable's
481 return value_address (result
);
484 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
485 function uses DWARF expression for its DW_AT_frame_base. */
487 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
489 locexpr_find_frame_base_location
,
490 locexpr_get_frame_base
493 /* Implement find_frame_base_location method for LOC_BLOCK functions using
494 DWARF location list for its DW_AT_frame_base. */
497 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
498 const gdb_byte
**start
, size_t *length
)
500 struct dwarf2_loclist_baton
*symbaton
501 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
503 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
506 /* Implement the struct symbol_block_ops::get_frame_base method for
507 LOC_BLOCK functions using a DWARF location list as its DW_AT_frame_base. */
510 loclist_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
512 struct gdbarch
*gdbarch
;
514 struct dwarf2_loclist_baton
*dlbaton
;
515 const gdb_byte
*start
;
517 struct value
*result
;
519 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
520 Thus, it's supposed to provide the find_frame_base_location method as
522 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
524 gdbarch
= get_frame_arch (frame
);
525 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
526 dlbaton
= (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
528 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
529 (framefunc
, get_frame_pc (frame
), &start
, &length
);
530 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
533 /* The DW_AT_frame_base attribute contains a location description which
534 computes the base address itself. However, the call to
535 dwarf2_evaluate_loc_desc returns a value representing a variable at
536 that address. The frame base address is thus this variable's
538 return value_address (result
);
541 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
542 function uses DWARF location list for its DW_AT_frame_base. */
544 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
546 loclist_find_frame_base_location
,
547 loclist_get_frame_base
550 /* See dwarf2loc.h. */
553 func_get_frame_base_dwarf_block (struct symbol
*framefunc
, CORE_ADDR pc
,
554 const gdb_byte
**start
, size_t *length
)
556 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
558 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
560 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
566 error (_("Could not find the frame base for \"%s\"."),
567 framefunc
->natural_name ());
571 get_frame_pc_for_per_cu_dwarf_call (void *baton
)
573 dwarf_expr_context
*ctx
= (dwarf_expr_context
*) baton
;
575 return ctx
->get_frame_pc ();
579 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
580 struct dwarf2_per_cu_data
*per_cu
)
582 struct dwarf2_locexpr_baton block
;
584 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
,
585 get_frame_pc_for_per_cu_dwarf_call
,
588 /* DW_OP_call_ref is currently not supported. */
589 gdb_assert (block
.per_cu
== per_cu
);
591 ctx
->eval (block
.data
, block
.size
);
594 /* Given context CTX, section offset SECT_OFF, and compilation unit
595 data PER_CU, execute the "variable value" operation on the DIE
596 found at SECT_OFF. */
598 static struct value
*
599 sect_variable_value (struct dwarf_expr_context
*ctx
, sect_offset sect_off
,
600 struct dwarf2_per_cu_data
*per_cu
)
602 struct type
*die_type
= dwarf2_fetch_die_type_sect_off (sect_off
, per_cu
);
604 if (die_type
== NULL
)
605 error (_("Bad DW_OP_GNU_variable_value DIE."));
607 /* Note: Things still work when the following test is removed. This
608 test and error is here to conform to the proposed specification. */
609 if (TYPE_CODE (die_type
) != TYPE_CODE_INT
610 && TYPE_CODE (die_type
) != TYPE_CODE_PTR
)
611 error (_("Type of DW_OP_GNU_variable_value DIE must be an integer or pointer."));
613 struct type
*type
= lookup_pointer_type (die_type
);
614 struct frame_info
*frame
= get_selected_frame (_("No frame selected."));
615 return indirect_synthetic_pointer (sect_off
, 0, per_cu
, frame
, type
, true);
618 class dwarf_evaluate_loc_desc
: public dwarf_expr_context
622 struct frame_info
*frame
;
623 struct dwarf2_per_cu_data
*per_cu
;
624 CORE_ADDR obj_address
;
626 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
627 the frame in BATON. */
629 CORE_ADDR
get_frame_cfa () override
631 return dwarf2_frame_cfa (frame
);
634 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
635 the frame in BATON. */
637 CORE_ADDR
get_frame_pc () override
639 return get_frame_address_in_block (frame
);
642 /* Using the objfile specified in BATON, find the address for the
643 current thread's thread-local storage with offset OFFSET. */
644 CORE_ADDR
get_tls_address (CORE_ADDR offset
) override
646 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
648 return target_translate_tls_address (objfile
, offset
);
651 /* Helper interface of per_cu_dwarf_call for
652 dwarf2_evaluate_loc_desc. */
654 void dwarf_call (cu_offset die_offset
) override
656 per_cu_dwarf_call (this, die_offset
, per_cu
);
659 /* Helper interface of sect_variable_value for
660 dwarf2_evaluate_loc_desc. */
662 struct value
*dwarf_variable_value (sect_offset sect_off
) override
664 return sect_variable_value (this, sect_off
, per_cu
);
667 struct type
*get_base_type (cu_offset die_offset
, int size
) override
669 struct type
*result
= dwarf2_get_die_type (die_offset
, per_cu
);
671 error (_("Could not find type for DW_OP_const_type"));
672 if (size
!= 0 && TYPE_LENGTH (result
) != size
)
673 error (_("DW_OP_const_type has different sizes for type and data"));
677 /* Callback function for dwarf2_evaluate_loc_desc.
678 Fetch the address indexed by DW_OP_addrx or DW_OP_GNU_addr_index. */
680 CORE_ADDR
get_addr_index (unsigned int index
) override
682 return dwarf2_read_addr_index (per_cu
, index
);
685 /* Callback function for get_object_address. Return the address of the VLA
688 CORE_ADDR
get_object_address () override
690 if (obj_address
== 0)
691 error (_("Location address is not set."));
695 /* Execute DWARF block of call_site_parameter which matches KIND and
696 KIND_U. Choose DEREF_SIZE value of that parameter. Search
697 caller of this objects's frame.
699 The caller can be from a different CU - per_cu_dwarf_call
700 implementation can be more simple as it does not support cross-CU
703 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
704 union call_site_parameter_u kind_u
,
705 int deref_size
) override
707 struct frame_info
*caller_frame
;
708 struct dwarf2_per_cu_data
*caller_per_cu
;
709 struct call_site_parameter
*parameter
;
710 const gdb_byte
*data_src
;
713 caller_frame
= get_prev_frame (frame
);
715 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
717 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
718 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
720 /* DEREF_SIZE size is not verified here. */
721 if (data_src
== NULL
)
722 throw_error (NO_ENTRY_VALUE_ERROR
,
723 _("Cannot resolve DW_AT_call_data_value"));
725 scoped_restore save_frame
= make_scoped_restore (&this->frame
,
727 scoped_restore save_per_cu
= make_scoped_restore (&this->per_cu
,
729 scoped_restore save_obj_addr
= make_scoped_restore (&this->obj_address
,
732 scoped_restore save_arch
= make_scoped_restore (&this->gdbarch
);
734 = get_objfile_arch (dwarf2_per_cu_objfile (per_cu
));
735 scoped_restore save_addr_size
= make_scoped_restore (&this->addr_size
);
736 this->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
737 scoped_restore save_offset
= make_scoped_restore (&this->offset
);
738 this->offset
= dwarf2_per_cu_text_offset (per_cu
);
740 this->eval (data_src
, size
);
743 /* Using the frame specified in BATON, find the location expression
744 describing the frame base. Return a pointer to it in START and
745 its length in LENGTH. */
746 void get_frame_base (const gdb_byte
**start
, size_t * length
) override
748 /* FIXME: cagney/2003-03-26: This code should be using
749 get_frame_base_address(), and then implement a dwarf2 specific
751 struct symbol
*framefunc
;
752 const struct block
*bl
= get_frame_block (frame
, NULL
);
755 error (_("frame address is not available."));
757 /* Use block_linkage_function, which returns a real (not inlined)
758 function, instead of get_frame_function, which may return an
760 framefunc
= block_linkage_function (bl
);
762 /* If we found a frame-relative symbol then it was certainly within
763 some function associated with a frame. If we can't find the frame,
764 something has gone wrong. */
765 gdb_assert (framefunc
!= NULL
);
767 func_get_frame_base_dwarf_block (framefunc
,
768 get_frame_address_in_block (frame
),
772 /* Read memory at ADDR (length LEN) into BUF. */
774 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
776 read_memory (addr
, buf
, len
);
779 /* Using the frame specified in BATON, return the value of register
780 REGNUM, treated as a pointer. */
781 CORE_ADDR
read_addr_from_reg (int dwarf_regnum
) override
783 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
784 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
786 return address_from_register (regnum
, frame
);
789 /* Implement "get_reg_value" callback. */
791 struct value
*get_reg_value (struct type
*type
, int dwarf_regnum
) override
793 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
794 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
796 return value_from_register (type
, regnum
, frame
);
800 /* See dwarf2loc.h. */
802 unsigned int entry_values_debug
= 0;
804 /* Helper to set entry_values_debug. */
807 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
808 struct cmd_list_element
*c
, const char *value
)
810 fprintf_filtered (file
,
811 _("Entry values and tail call frames debugging is %s.\n"),
815 /* Find DW_TAG_call_site's DW_AT_call_target address.
816 CALLER_FRAME (for registers) can be NULL if it is not known. This function
817 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
820 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
821 struct call_site
*call_site
,
822 struct frame_info
*caller_frame
)
824 switch (FIELD_LOC_KIND (call_site
->target
))
826 case FIELD_LOC_KIND_DWARF_BLOCK
:
828 struct dwarf2_locexpr_baton
*dwarf_block
;
830 struct type
*caller_core_addr_type
;
831 struct gdbarch
*caller_arch
;
833 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
834 if (dwarf_block
== NULL
)
836 struct bound_minimal_symbol msym
;
838 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
839 throw_error (NO_ENTRY_VALUE_ERROR
,
840 _("DW_AT_call_target is not specified at %s in %s"),
841 paddress (call_site_gdbarch
, call_site
->pc
),
842 (msym
.minsym
== NULL
? "???"
843 : msym
.minsym
->print_name ()));
846 if (caller_frame
== NULL
)
848 struct bound_minimal_symbol msym
;
850 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
851 throw_error (NO_ENTRY_VALUE_ERROR
,
852 _("DW_AT_call_target DWARF block resolving "
853 "requires known frame which is currently not "
854 "available at %s in %s"),
855 paddress (call_site_gdbarch
, call_site
->pc
),
856 (msym
.minsym
== NULL
? "???"
857 : msym
.minsym
->print_name ()));
860 caller_arch
= get_frame_arch (caller_frame
);
861 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
862 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
863 dwarf_block
->data
, dwarf_block
->size
,
864 dwarf_block
->per_cu
);
865 /* DW_AT_call_target is a DWARF expression, not a DWARF location. */
866 if (VALUE_LVAL (val
) == lval_memory
)
867 return value_address (val
);
869 return value_as_address (val
);
872 case FIELD_LOC_KIND_PHYSNAME
:
874 const char *physname
;
875 struct bound_minimal_symbol msym
;
877 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
879 /* Handle both the mangled and demangled PHYSNAME. */
880 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
881 if (msym
.minsym
== NULL
)
883 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
884 throw_error (NO_ENTRY_VALUE_ERROR
,
885 _("Cannot find function \"%s\" for a call site target "
887 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
888 (msym
.minsym
== NULL
? "???"
889 : msym
.minsym
->print_name ()));
892 return BMSYMBOL_VALUE_ADDRESS (msym
);
895 case FIELD_LOC_KIND_PHYSADDR
:
896 return FIELD_STATIC_PHYSADDR (call_site
->target
);
899 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
903 /* Convert function entry point exact address ADDR to the function which is
904 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
905 NO_ENTRY_VALUE_ERROR otherwise. */
907 static struct symbol
*
908 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
910 struct symbol
*sym
= find_pc_function (addr
);
913 if (sym
== NULL
|| BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
914 throw_error (NO_ENTRY_VALUE_ERROR
,
915 _("DW_TAG_call_site resolving failed to find function "
916 "name for address %s"),
917 paddress (gdbarch
, addr
));
919 type
= SYMBOL_TYPE (sym
);
920 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
921 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
926 /* Verify function with entry point exact address ADDR can never call itself
927 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
928 can call itself via tail calls.
930 If a funtion can tail call itself its entry value based parameters are
931 unreliable. There is no verification whether the value of some/all
932 parameters is unchanged through the self tail call, we expect if there is
933 a self tail call all the parameters can be modified. */
936 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
940 /* The verification is completely unordered. Track here function addresses
941 which still need to be iterated. */
942 std::vector
<CORE_ADDR
> todo
;
944 /* Track here CORE_ADDRs which were already visited. */
945 std::unordered_set
<CORE_ADDR
> addr_hash
;
947 todo
.push_back (verify_addr
);
948 while (!todo
.empty ())
950 struct symbol
*func_sym
;
951 struct call_site
*call_site
;
956 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
958 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
959 call_site
; call_site
= call_site
->tail_call_next
)
961 CORE_ADDR target_addr
;
963 /* CALLER_FRAME with registers is not available for tail-call jumped
965 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
967 if (target_addr
== verify_addr
)
969 struct bound_minimal_symbol msym
;
971 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
972 throw_error (NO_ENTRY_VALUE_ERROR
,
973 _("DW_OP_entry_value resolving has found "
974 "function \"%s\" at %s can call itself via tail "
976 (msym
.minsym
== NULL
? "???"
977 : msym
.minsym
->print_name ()),
978 paddress (gdbarch
, verify_addr
));
981 if (addr_hash
.insert (target_addr
).second
)
982 todo
.push_back (target_addr
);
987 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
988 ENTRY_VALUES_DEBUG. */
991 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
993 CORE_ADDR addr
= call_site
->pc
;
994 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
996 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
997 (msym
.minsym
== NULL
? "???"
998 : msym
.minsym
->print_name ()));
1002 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
1003 only top callers and bottom callees which are present in both. GDBARCH is
1004 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
1005 no remaining possibilities to provide unambiguous non-trivial result.
1006 RESULTP should point to NULL on the first (initialization) call. Caller is
1007 responsible for xfree of any RESULTP data. */
1010 chain_candidate (struct gdbarch
*gdbarch
,
1011 gdb::unique_xmalloc_ptr
<struct call_site_chain
> *resultp
,
1012 std::vector
<struct call_site
*> *chain
)
1014 long length
= chain
->size ();
1015 int callers
, callees
, idx
;
1017 if (*resultp
== NULL
)
1019 /* Create the initial chain containing all the passed PCs. */
1021 struct call_site_chain
*result
1022 = ((struct call_site_chain
*)
1023 xmalloc (sizeof (*result
)
1024 + sizeof (*result
->call_site
) * (length
- 1)));
1025 result
->length
= length
;
1026 result
->callers
= result
->callees
= length
;
1027 if (!chain
->empty ())
1028 memcpy (result
->call_site
, chain
->data (),
1029 sizeof (*result
->call_site
) * length
);
1030 resultp
->reset (result
);
1032 if (entry_values_debug
)
1034 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
1035 for (idx
= 0; idx
< length
; idx
++)
1036 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
1037 fputc_unfiltered ('\n', gdb_stdlog
);
1043 if (entry_values_debug
)
1045 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
1046 for (idx
= 0; idx
< length
; idx
++)
1047 tailcall_dump (gdbarch
, chain
->at (idx
));
1048 fputc_unfiltered ('\n', gdb_stdlog
);
1051 /* Intersect callers. */
1053 callers
= std::min ((long) (*resultp
)->callers
, length
);
1054 for (idx
= 0; idx
< callers
; idx
++)
1055 if ((*resultp
)->call_site
[idx
] != chain
->at (idx
))
1057 (*resultp
)->callers
= idx
;
1061 /* Intersect callees. */
1063 callees
= std::min ((long) (*resultp
)->callees
, length
);
1064 for (idx
= 0; idx
< callees
; idx
++)
1065 if ((*resultp
)->call_site
[(*resultp
)->length
- 1 - idx
]
1066 != chain
->at (length
- 1 - idx
))
1068 (*resultp
)->callees
= idx
;
1072 if (entry_values_debug
)
1074 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
1075 for (idx
= 0; idx
< (*resultp
)->callers
; idx
++)
1076 tailcall_dump (gdbarch
, (*resultp
)->call_site
[idx
]);
1077 fputs_unfiltered (" |", gdb_stdlog
);
1078 for (idx
= 0; idx
< (*resultp
)->callees
; idx
++)
1079 tailcall_dump (gdbarch
,
1080 (*resultp
)->call_site
[(*resultp
)->length
1081 - (*resultp
)->callees
+ idx
]);
1082 fputc_unfiltered ('\n', gdb_stdlog
);
1085 if ((*resultp
)->callers
== 0 && (*resultp
)->callees
== 0)
1087 /* There are no common callers or callees. It could be also a direct
1088 call (which has length 0) with ambiguous possibility of an indirect
1089 call - CALLERS == CALLEES == 0 is valid during the first allocation
1090 but any subsequence processing of such entry means ambiguity. */
1091 resultp
->reset (NULL
);
1095 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
1096 PC again. In such case there must be two different code paths to reach
1097 it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
1098 gdb_assert ((*resultp
)->callers
+ (*resultp
)->callees
<= (*resultp
)->length
);
1101 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1102 assumed frames between them use GDBARCH. Use depth first search so we can
1103 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
1104 would have needless GDB stack overhead. Caller is responsible for xfree of
1105 the returned result. Any unreliability results in thrown
1106 NO_ENTRY_VALUE_ERROR. */
1108 static struct call_site_chain
*
1109 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1110 CORE_ADDR callee_pc
)
1112 CORE_ADDR save_callee_pc
= callee_pc
;
1113 gdb::unique_xmalloc_ptr
<struct call_site_chain
> retval
;
1114 struct call_site
*call_site
;
1116 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
1117 call_site nor any possible call_site at CALLEE_PC's function is there.
1118 Any CALL_SITE in CHAIN will be iterated to its siblings - via
1119 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
1120 std::vector
<struct call_site
*> chain
;
1122 /* We are not interested in the specific PC inside the callee function. */
1123 callee_pc
= get_pc_function_start (callee_pc
);
1125 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
1126 paddress (gdbarch
, save_callee_pc
));
1128 /* Mark CALL_SITEs so we do not visit the same ones twice. */
1129 std::unordered_set
<CORE_ADDR
> addr_hash
;
1131 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
1132 at the target's function. All the possible tail call sites in the
1133 target's function will get iterated as already pushed into CHAIN via their
1135 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1139 CORE_ADDR target_func_addr
;
1140 struct call_site
*target_call_site
;
1142 /* CALLER_FRAME with registers is not available for tail-call jumped
1144 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
1146 if (target_func_addr
== callee_pc
)
1148 chain_candidate (gdbarch
, &retval
, &chain
);
1152 /* There is no way to reach CALLEE_PC again as we would prevent
1153 entering it twice as being already marked in ADDR_HASH. */
1154 target_call_site
= NULL
;
1158 struct symbol
*target_func
;
1160 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
1161 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
1166 /* Attempt to visit TARGET_CALL_SITE. */
1168 if (target_call_site
)
1170 if (addr_hash
.insert (target_call_site
->pc
).second
)
1172 /* Successfully entered TARGET_CALL_SITE. */
1174 chain
.push_back (target_call_site
);
1179 /* Backtrack (without revisiting the originating call_site). Try the
1180 callers's sibling; if there isn't any try the callers's callers's
1183 target_call_site
= NULL
;
1184 while (!chain
.empty ())
1186 call_site
= chain
.back ();
1189 size_t removed
= addr_hash
.erase (call_site
->pc
);
1190 gdb_assert (removed
== 1);
1192 target_call_site
= call_site
->tail_call_next
;
1193 if (target_call_site
)
1197 while (target_call_site
);
1202 call_site
= chain
.back ();
1207 struct bound_minimal_symbol msym_caller
, msym_callee
;
1209 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
1210 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
1211 throw_error (NO_ENTRY_VALUE_ERROR
,
1212 _("There are no unambiguously determinable intermediate "
1213 "callers or callees between caller function \"%s\" at %s "
1214 "and callee function \"%s\" at %s"),
1215 (msym_caller
.minsym
== NULL
1216 ? "???" : msym_caller
.minsym
->print_name ()),
1217 paddress (gdbarch
, caller_pc
),
1218 (msym_callee
.minsym
== NULL
1219 ? "???" : msym_callee
.minsym
->print_name ()),
1220 paddress (gdbarch
, callee_pc
));
1223 return retval
.release ();
1226 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1227 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
1228 constructed return NULL. Caller is responsible for xfree of the returned
1231 struct call_site_chain
*
1232 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1233 CORE_ADDR callee_pc
)
1235 struct call_site_chain
*retval
= NULL
;
1239 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
1241 catch (const gdb_exception_error
&e
)
1243 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
1245 if (entry_values_debug
)
1246 exception_print (gdb_stdout
, e
);
1257 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1260 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1261 enum call_site_parameter_kind kind
,
1262 union call_site_parameter_u kind_u
)
1264 if (kind
== parameter
->kind
)
1267 case CALL_SITE_PARAMETER_DWARF_REG
:
1268 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1269 case CALL_SITE_PARAMETER_FB_OFFSET
:
1270 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1271 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1272 return kind_u
.param_cu_off
== parameter
->u
.param_cu_off
;
1277 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1278 FRAME is for callee.
1280 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1283 static struct call_site_parameter
*
1284 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1285 enum call_site_parameter_kind kind
,
1286 union call_site_parameter_u kind_u
,
1287 struct dwarf2_per_cu_data
**per_cu_return
)
1289 CORE_ADDR func_addr
, caller_pc
;
1290 struct gdbarch
*gdbarch
;
1291 struct frame_info
*caller_frame
;
1292 struct call_site
*call_site
;
1294 /* Initialize it just to avoid a GCC false warning. */
1295 struct call_site_parameter
*parameter
= NULL
;
1296 CORE_ADDR target_addr
;
1298 while (get_frame_type (frame
) == INLINE_FRAME
)
1300 frame
= get_prev_frame (frame
);
1301 gdb_assert (frame
!= NULL
);
1304 func_addr
= get_frame_func (frame
);
1305 gdbarch
= get_frame_arch (frame
);
1306 caller_frame
= get_prev_frame (frame
);
1307 if (gdbarch
!= frame_unwind_arch (frame
))
1309 struct bound_minimal_symbol msym
1310 = lookup_minimal_symbol_by_pc (func_addr
);
1311 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1313 throw_error (NO_ENTRY_VALUE_ERROR
,
1314 _("DW_OP_entry_value resolving callee gdbarch %s "
1315 "(of %s (%s)) does not match caller gdbarch %s"),
1316 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1317 paddress (gdbarch
, func_addr
),
1318 (msym
.minsym
== NULL
? "???"
1319 : msym
.minsym
->print_name ()),
1320 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1323 if (caller_frame
== NULL
)
1325 struct bound_minimal_symbol msym
1326 = lookup_minimal_symbol_by_pc (func_addr
);
1328 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_entry_value resolving "
1329 "requires caller of %s (%s)"),
1330 paddress (gdbarch
, func_addr
),
1331 (msym
.minsym
== NULL
? "???"
1332 : msym
.minsym
->print_name ()));
1334 caller_pc
= get_frame_pc (caller_frame
);
1335 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1337 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1338 if (target_addr
!= func_addr
)
1340 struct minimal_symbol
*target_msym
, *func_msym
;
1342 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1343 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1344 throw_error (NO_ENTRY_VALUE_ERROR
,
1345 _("DW_OP_entry_value resolving expects callee %s at %s "
1346 "but the called frame is for %s at %s"),
1347 (target_msym
== NULL
? "???"
1348 : target_msym
->print_name ()),
1349 paddress (gdbarch
, target_addr
),
1350 func_msym
== NULL
? "???" : func_msym
->print_name (),
1351 paddress (gdbarch
, func_addr
));
1354 /* No entry value based parameters would be reliable if this function can
1355 call itself via tail calls. */
1356 func_verify_no_selftailcall (gdbarch
, func_addr
);
1358 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1360 parameter
= &call_site
->parameter
[iparams
];
1361 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1364 if (iparams
== call_site
->parameter_count
)
1366 struct minimal_symbol
*msym
1367 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1369 /* DW_TAG_call_site_parameter will be missing just if GCC could not
1370 determine its value. */
1371 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1372 "at DW_TAG_call_site %s at %s"),
1373 paddress (gdbarch
, caller_pc
),
1374 msym
== NULL
? "???" : msym
->print_name ());
1377 *per_cu_return
= call_site
->per_cu
;
1381 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1382 the normal DW_AT_call_value block. Otherwise return the
1383 DW_AT_call_data_value (dereferenced) block.
1385 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1388 Function always returns non-NULL, non-optimized out value. It throws
1389 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1391 static struct value
*
1392 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1393 CORE_ADDR deref_size
, struct type
*type
,
1394 struct frame_info
*caller_frame
,
1395 struct dwarf2_per_cu_data
*per_cu
)
1397 const gdb_byte
*data_src
;
1401 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1402 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1404 /* DEREF_SIZE size is not verified here. */
1405 if (data_src
== NULL
)
1406 throw_error (NO_ENTRY_VALUE_ERROR
,
1407 _("Cannot resolve DW_AT_call_data_value"));
1409 /* DW_AT_call_value is a DWARF expression, not a DWARF
1410 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1412 data
= (gdb_byte
*) alloca (size
+ 1);
1413 memcpy (data
, data_src
, size
);
1414 data
[size
] = DW_OP_stack_value
;
1416 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1419 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1420 the indirect method on it, that is use its stored target value, the sole
1421 purpose of entry_data_value_funcs.. */
1423 static struct value
*
1424 entry_data_value_coerce_ref (const struct value
*value
)
1426 struct type
*checked_type
= check_typedef (value_type (value
));
1427 struct value
*target_val
;
1429 if (!TYPE_IS_REFERENCE (checked_type
))
1432 target_val
= (struct value
*) value_computed_closure (value
);
1433 value_incref (target_val
);
1437 /* Implement copy_closure. */
1440 entry_data_value_copy_closure (const struct value
*v
)
1442 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1444 value_incref (target_val
);
1448 /* Implement free_closure. */
1451 entry_data_value_free_closure (struct value
*v
)
1453 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1455 value_decref (target_val
);
1458 /* Vector for methods for an entry value reference where the referenced value
1459 is stored in the caller. On the first dereference use
1460 DW_AT_call_data_value in the caller. */
1462 static const struct lval_funcs entry_data_value_funcs
=
1466 NULL
, /* indirect */
1467 entry_data_value_coerce_ref
,
1468 NULL
, /* check_synthetic_pointer */
1469 entry_data_value_copy_closure
,
1470 entry_data_value_free_closure
1473 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1474 are used to match DW_AT_location at the caller's
1475 DW_TAG_call_site_parameter.
1477 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1478 cannot resolve the parameter for any reason. */
1480 static struct value
*
1481 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1482 enum call_site_parameter_kind kind
,
1483 union call_site_parameter_u kind_u
)
1485 struct type
*checked_type
= check_typedef (type
);
1486 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1487 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1488 struct value
*outer_val
, *target_val
, *val
;
1489 struct call_site_parameter
*parameter
;
1490 struct dwarf2_per_cu_data
*caller_per_cu
;
1492 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1495 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1499 /* Check if DW_AT_call_data_value cannot be used. If it should be
1500 used and it is not available do not fall back to OUTER_VAL - dereferencing
1501 TYPE_CODE_REF with non-entry data value would give current value - not the
1504 if (!TYPE_IS_REFERENCE (checked_type
)
1505 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1508 target_val
= dwarf_entry_parameter_to_value (parameter
,
1509 TYPE_LENGTH (target_type
),
1510 target_type
, caller_frame
,
1513 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1514 release_value (target_val
).release ());
1516 /* Copy the referencing pointer to the new computed value. */
1517 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1518 TYPE_LENGTH (checked_type
));
1519 set_value_lazy (val
, 0);
1524 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1525 SIZE are DWARF block used to match DW_AT_location at the caller's
1526 DW_TAG_call_site_parameter.
1528 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1529 cannot resolve the parameter for any reason. */
1531 static struct value
*
1532 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1533 const gdb_byte
*block
, size_t block_len
)
1535 union call_site_parameter_u kind_u
;
1537 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1538 if (kind_u
.dwarf_reg
!= -1)
1539 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1542 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1543 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1546 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1547 suppressed during normal operation. The expression can be arbitrary if
1548 there is no caller-callee entry value binding expected. */
1549 throw_error (NO_ENTRY_VALUE_ERROR
,
1550 _("DWARF-2 expression error: DW_OP_entry_value is supported "
1551 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1554 struct piece_closure
1556 /* Reference count. */
1559 /* The CU from which this closure's expression came. */
1560 struct dwarf2_per_cu_data
*per_cu
= NULL
;
1562 /* The pieces describing this variable. */
1563 std::vector
<dwarf_expr_piece
> pieces
;
1565 /* Frame ID of frame to which a register value is relative, used
1566 only by DWARF_VALUE_REGISTER. */
1567 struct frame_id frame_id
;
1570 /* Allocate a closure for a value formed from separately-described
1573 static struct piece_closure
*
1574 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1575 std::vector
<dwarf_expr_piece
> &&pieces
,
1576 struct frame_info
*frame
)
1578 struct piece_closure
*c
= new piece_closure
;
1582 c
->pieces
= std::move (pieces
);
1584 c
->frame_id
= null_frame_id
;
1586 c
->frame_id
= get_frame_id (frame
);
1588 for (dwarf_expr_piece
&piece
: c
->pieces
)
1589 if (piece
.location
== DWARF_VALUE_STACK
)
1590 value_incref (piece
.v
.value
);
1595 /* Return the number of bytes overlapping a contiguous chunk of N_BITS
1596 bits whose first bit is located at bit offset START. */
1599 bits_to_bytes (ULONGEST start
, ULONGEST n_bits
)
1601 return (start
% 8 + n_bits
+ 7) / 8;
1604 /* Read or write a pieced value V. If FROM != NULL, operate in "write
1605 mode": copy FROM into the pieces comprising V. If FROM == NULL,
1606 operate in "read mode": fetch the contents of the (lazy) value V by
1607 composing it from its pieces. */
1610 rw_pieced_value (struct value
*v
, struct value
*from
)
1613 LONGEST offset
= 0, max_offset
;
1614 ULONGEST bits_to_skip
;
1615 gdb_byte
*v_contents
;
1616 const gdb_byte
*from_contents
;
1617 struct piece_closure
*c
1618 = (struct piece_closure
*) value_computed_closure (v
);
1619 gdb::byte_vector buffer
;
1620 bool bits_big_endian
= type_byte_order (value_type (v
)) == BFD_ENDIAN_BIG
;
1624 from_contents
= value_contents (from
);
1629 if (value_type (v
) != value_enclosing_type (v
))
1630 internal_error (__FILE__
, __LINE__
,
1631 _("Should not be able to create a lazy value with "
1632 "an enclosing type"));
1633 v_contents
= value_contents_raw (v
);
1634 from_contents
= NULL
;
1637 bits_to_skip
= 8 * value_offset (v
);
1638 if (value_bitsize (v
))
1640 bits_to_skip
+= (8 * value_offset (value_parent (v
))
1641 + value_bitpos (v
));
1643 && (type_byte_order (value_type (from
))
1646 /* Use the least significant bits of FROM. */
1647 max_offset
= 8 * TYPE_LENGTH (value_type (from
));
1648 offset
= max_offset
- value_bitsize (v
);
1651 max_offset
= value_bitsize (v
);
1654 max_offset
= 8 * TYPE_LENGTH (value_type (v
));
1656 /* Advance to the first non-skipped piece. */
1657 for (i
= 0; i
< c
->pieces
.size () && bits_to_skip
>= c
->pieces
[i
].size
; i
++)
1658 bits_to_skip
-= c
->pieces
[i
].size
;
1660 for (; i
< c
->pieces
.size () && offset
< max_offset
; i
++)
1662 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1663 size_t this_size_bits
, this_size
;
1665 this_size_bits
= p
->size
- bits_to_skip
;
1666 if (this_size_bits
> max_offset
- offset
)
1667 this_size_bits
= max_offset
- offset
;
1669 switch (p
->location
)
1671 case DWARF_VALUE_REGISTER
:
1673 struct frame_info
*frame
= frame_find_by_id (c
->frame_id
);
1674 struct gdbarch
*arch
= get_frame_arch (frame
);
1675 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, p
->v
.regno
);
1676 ULONGEST reg_bits
= 8 * register_size (arch
, gdb_regnum
);
1679 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1680 && p
->offset
+ p
->size
< reg_bits
)
1682 /* Big-endian, and we want less than full size. */
1683 bits_to_skip
+= reg_bits
- (p
->offset
+ p
->size
);
1686 bits_to_skip
+= p
->offset
;
1688 this_size
= bits_to_bytes (bits_to_skip
, this_size_bits
);
1689 buffer
.resize (this_size
);
1694 if (!get_frame_register_bytes (frame
, gdb_regnum
,
1696 this_size
, buffer
.data (),
1700 mark_value_bits_optimized_out (v
, offset
,
1703 mark_value_bits_unavailable (v
, offset
,
1708 copy_bitwise (v_contents
, offset
,
1709 buffer
.data (), bits_to_skip
% 8,
1710 this_size_bits
, bits_big_endian
);
1715 if (bits_to_skip
% 8 != 0 || this_size_bits
% 8 != 0)
1717 /* Data is copied non-byte-aligned into the register.
1718 Need some bits from original register value. */
1719 get_frame_register_bytes (frame
, gdb_regnum
,
1721 this_size
, buffer
.data (),
1724 throw_error (OPTIMIZED_OUT_ERROR
,
1725 _("Can't do read-modify-write to "
1726 "update bitfield; containing word "
1727 "has been optimized out"));
1729 throw_error (NOT_AVAILABLE_ERROR
,
1730 _("Can't do read-modify-write to "
1731 "update bitfield; containing word "
1735 copy_bitwise (buffer
.data (), bits_to_skip
% 8,
1736 from_contents
, offset
,
1737 this_size_bits
, bits_big_endian
);
1738 put_frame_register_bytes (frame
, gdb_regnum
,
1740 this_size
, buffer
.data ());
1745 case DWARF_VALUE_MEMORY
:
1747 bits_to_skip
+= p
->offset
;
1749 CORE_ADDR start_addr
= p
->v
.mem
.addr
+ bits_to_skip
/ 8;
1751 if (bits_to_skip
% 8 == 0 && this_size_bits
% 8 == 0
1754 /* Everything is byte-aligned; no buffer needed. */
1756 write_memory_with_notification (start_addr
,
1759 this_size_bits
/ 8);
1761 read_value_memory (v
, offset
,
1762 p
->v
.mem
.in_stack_memory
,
1763 p
->v
.mem
.addr
+ bits_to_skip
/ 8,
1764 v_contents
+ offset
/ 8,
1765 this_size_bits
/ 8);
1769 this_size
= bits_to_bytes (bits_to_skip
, this_size_bits
);
1770 buffer
.resize (this_size
);
1775 read_value_memory (v
, offset
,
1776 p
->v
.mem
.in_stack_memory
,
1777 p
->v
.mem
.addr
+ bits_to_skip
/ 8,
1778 buffer
.data (), this_size
);
1779 copy_bitwise (v_contents
, offset
,
1780 buffer
.data (), bits_to_skip
% 8,
1781 this_size_bits
, bits_big_endian
);
1786 if (bits_to_skip
% 8 != 0 || this_size_bits
% 8 != 0)
1790 /* Perform a single read for small sizes. */
1791 read_memory (start_addr
, buffer
.data (),
1796 /* Only the first and last bytes can possibly have
1798 read_memory (start_addr
, buffer
.data (), 1);
1799 read_memory (start_addr
+ this_size
- 1,
1800 &buffer
[this_size
- 1], 1);
1804 copy_bitwise (buffer
.data (), bits_to_skip
% 8,
1805 from_contents
, offset
,
1806 this_size_bits
, bits_big_endian
);
1807 write_memory_with_notification (start_addr
,
1814 case DWARF_VALUE_STACK
:
1818 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1822 struct objfile
*objfile
= dwarf2_per_cu_objfile (c
->per_cu
);
1823 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
1824 ULONGEST stack_value_size_bits
1825 = 8 * TYPE_LENGTH (value_type (p
->v
.value
));
1827 /* Use zeroes if piece reaches beyond stack value. */
1828 if (p
->offset
+ p
->size
> stack_value_size_bits
)
1831 /* Piece is anchored at least significant bit end. */
1832 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
1833 bits_to_skip
+= stack_value_size_bits
- p
->offset
- p
->size
;
1835 bits_to_skip
+= p
->offset
;
1837 copy_bitwise (v_contents
, offset
,
1838 value_contents_all (p
->v
.value
),
1840 this_size_bits
, bits_big_endian
);
1844 case DWARF_VALUE_LITERAL
:
1848 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1852 ULONGEST literal_size_bits
= 8 * p
->v
.literal
.length
;
1853 size_t n
= this_size_bits
;
1855 /* Cut off at the end of the implicit value. */
1856 bits_to_skip
+= p
->offset
;
1857 if (bits_to_skip
>= literal_size_bits
)
1859 if (n
> literal_size_bits
- bits_to_skip
)
1860 n
= literal_size_bits
- bits_to_skip
;
1862 copy_bitwise (v_contents
, offset
,
1863 p
->v
.literal
.data
, bits_to_skip
,
1864 n
, bits_big_endian
);
1868 case DWARF_VALUE_IMPLICIT_POINTER
:
1871 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1875 /* These bits show up as zeros -- but do not cause the value to
1876 be considered optimized-out. */
1879 case DWARF_VALUE_OPTIMIZED_OUT
:
1880 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1884 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1887 offset
+= this_size_bits
;
1894 read_pieced_value (struct value
*v
)
1896 rw_pieced_value (v
, NULL
);
1900 write_pieced_value (struct value
*to
, struct value
*from
)
1902 rw_pieced_value (to
, from
);
1905 /* An implementation of an lval_funcs method to see whether a value is
1906 a synthetic pointer. */
1909 check_pieced_synthetic_pointer (const struct value
*value
, LONGEST bit_offset
,
1912 struct piece_closure
*c
1913 = (struct piece_closure
*) value_computed_closure (value
);
1916 bit_offset
+= 8 * value_offset (value
);
1917 if (value_bitsize (value
))
1918 bit_offset
+= value_bitpos (value
);
1920 for (i
= 0; i
< c
->pieces
.size () && bit_length
> 0; i
++)
1922 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1923 size_t this_size_bits
= p
->size
;
1927 if (bit_offset
>= this_size_bits
)
1929 bit_offset
-= this_size_bits
;
1933 bit_length
-= this_size_bits
- bit_offset
;
1937 bit_length
-= this_size_bits
;
1939 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1946 /* A wrapper function for get_frame_address_in_block. */
1949 get_frame_address_in_block_wrapper (void *baton
)
1951 return get_frame_address_in_block ((struct frame_info
*) baton
);
1954 /* Fetch a DW_AT_const_value through a synthetic pointer. */
1956 static struct value
*
1957 fetch_const_value_from_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
1958 struct dwarf2_per_cu_data
*per_cu
,
1961 struct value
*result
= NULL
;
1962 const gdb_byte
*bytes
;
1965 auto_obstack temp_obstack
;
1966 bytes
= dwarf2_fetch_constant_bytes (die
, per_cu
, &temp_obstack
, &len
);
1970 if (byte_offset
>= 0
1971 && byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) <= len
)
1973 bytes
+= byte_offset
;
1974 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
1977 invalid_synthetic_pointer ();
1980 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
1985 /* Fetch the value pointed to by a synthetic pointer. */
1987 static struct value
*
1988 indirect_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
1989 struct dwarf2_per_cu_data
*per_cu
,
1990 struct frame_info
*frame
, struct type
*type
,
1991 bool resolve_abstract_p
)
1993 /* Fetch the location expression of the DIE we're pointing to. */
1994 struct dwarf2_locexpr_baton baton
1995 = dwarf2_fetch_die_loc_sect_off (die
, per_cu
,
1996 get_frame_address_in_block_wrapper
, frame
,
1997 resolve_abstract_p
);
1999 /* Get type of pointed-to DIE. */
2000 struct type
*orig_type
= dwarf2_fetch_die_type_sect_off (die
, per_cu
);
2001 if (orig_type
== NULL
)
2002 invalid_synthetic_pointer ();
2004 /* If pointed-to DIE has a DW_AT_location, evaluate it and return the
2005 resulting value. Otherwise, it may have a DW_AT_const_value instead,
2006 or it may've been optimized out. */
2007 if (baton
.data
!= NULL
)
2008 return dwarf2_evaluate_loc_desc_full (orig_type
, frame
, baton
.data
,
2009 baton
.size
, baton
.per_cu
,
2010 TYPE_TARGET_TYPE (type
),
2013 return fetch_const_value_from_synthetic_pointer (die
, byte_offset
, per_cu
,
2017 /* An implementation of an lval_funcs method to indirect through a
2018 pointer. This handles the synthetic pointer case when needed. */
2020 static struct value
*
2021 indirect_pieced_value (struct value
*value
)
2023 struct piece_closure
*c
2024 = (struct piece_closure
*) value_computed_closure (value
);
2026 struct frame_info
*frame
;
2029 struct dwarf_expr_piece
*piece
= NULL
;
2030 LONGEST byte_offset
;
2031 enum bfd_endian byte_order
;
2033 type
= check_typedef (value_type (value
));
2034 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
2037 bit_length
= 8 * TYPE_LENGTH (type
);
2038 bit_offset
= 8 * value_offset (value
);
2039 if (value_bitsize (value
))
2040 bit_offset
+= value_bitpos (value
);
2042 for (i
= 0; i
< c
->pieces
.size () && bit_length
> 0; i
++)
2044 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2045 size_t this_size_bits
= p
->size
;
2049 if (bit_offset
>= this_size_bits
)
2051 bit_offset
-= this_size_bits
;
2055 bit_length
-= this_size_bits
- bit_offset
;
2059 bit_length
-= this_size_bits
;
2061 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2064 if (bit_length
!= 0)
2065 error (_("Invalid use of DW_OP_implicit_pointer"));
2071 gdb_assert (piece
!= NULL
);
2072 frame
= get_selected_frame (_("No frame selected."));
2074 /* This is an offset requested by GDB, such as value subscripts.
2075 However, due to how synthetic pointers are implemented, this is
2076 always presented to us as a pointer type. This means we have to
2077 sign-extend it manually as appropriate. Use raw
2078 extract_signed_integer directly rather than value_as_address and
2079 sign extend afterwards on architectures that would need it
2080 (mostly everywhere except MIPS, which has signed addresses) as
2081 the later would go through gdbarch_pointer_to_address and thus
2082 return a CORE_ADDR with high bits set on architectures that
2083 encode address spaces and other things in CORE_ADDR. */
2084 byte_order
= gdbarch_byte_order (get_frame_arch (frame
));
2085 byte_offset
= extract_signed_integer (value_contents (value
),
2086 TYPE_LENGTH (type
), byte_order
);
2087 byte_offset
+= piece
->v
.ptr
.offset
;
2089 return indirect_synthetic_pointer (piece
->v
.ptr
.die_sect_off
,
2090 byte_offset
, c
->per_cu
,
2094 /* Implementation of the coerce_ref method of lval_funcs for synthetic C++
2097 static struct value
*
2098 coerce_pieced_ref (const struct value
*value
)
2100 struct type
*type
= check_typedef (value_type (value
));
2102 if (value_bits_synthetic_pointer (value
, value_embedded_offset (value
),
2103 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
2105 const struct piece_closure
*closure
2106 = (struct piece_closure
*) value_computed_closure (value
);
2107 struct frame_info
*frame
2108 = get_selected_frame (_("No frame selected."));
2110 /* gdb represents synthetic pointers as pieced values with a single
2112 gdb_assert (closure
!= NULL
);
2113 gdb_assert (closure
->pieces
.size () == 1);
2115 return indirect_synthetic_pointer
2116 (closure
->pieces
[0].v
.ptr
.die_sect_off
,
2117 closure
->pieces
[0].v
.ptr
.offset
,
2118 closure
->per_cu
, frame
, type
);
2122 /* Else: not a synthetic reference; do nothing. */
2128 copy_pieced_value_closure (const struct value
*v
)
2130 struct piece_closure
*c
2131 = (struct piece_closure
*) value_computed_closure (v
);
2138 free_pieced_value_closure (struct value
*v
)
2140 struct piece_closure
*c
2141 = (struct piece_closure
*) value_computed_closure (v
);
2146 for (dwarf_expr_piece
&p
: c
->pieces
)
2147 if (p
.location
== DWARF_VALUE_STACK
)
2148 value_decref (p
.v
.value
);
2154 /* Functions for accessing a variable described by DW_OP_piece. */
2155 static const struct lval_funcs pieced_value_funcs
= {
2158 indirect_pieced_value
,
2160 check_pieced_synthetic_pointer
,
2161 copy_pieced_value_closure
,
2162 free_pieced_value_closure
2165 /* Evaluate a location description, starting at DATA and with length
2166 SIZE, to find the current location of variable of TYPE in the
2167 context of FRAME. If SUBOBJ_TYPE is non-NULL, return instead the
2168 location of the subobject of type SUBOBJ_TYPE at byte offset
2169 SUBOBJ_BYTE_OFFSET within the variable of type TYPE. */
2171 static struct value
*
2172 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2173 const gdb_byte
*data
, size_t size
,
2174 struct dwarf2_per_cu_data
*per_cu
,
2175 struct type
*subobj_type
,
2176 LONGEST subobj_byte_offset
)
2178 struct value
*retval
;
2179 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2181 if (subobj_type
== NULL
)
2184 subobj_byte_offset
= 0;
2186 else if (subobj_byte_offset
< 0)
2187 invalid_synthetic_pointer ();
2190 return allocate_optimized_out_value (subobj_type
);
2192 dwarf_evaluate_loc_desc ctx
;
2194 ctx
.per_cu
= per_cu
;
2195 ctx
.obj_address
= 0;
2197 scoped_value_mark free_values
;
2199 ctx
.gdbarch
= get_objfile_arch (objfile
);
2200 ctx
.addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2201 ctx
.ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2202 ctx
.offset
= dwarf2_per_cu_text_offset (per_cu
);
2206 ctx
.eval (data
, size
);
2208 catch (const gdb_exception_error
&ex
)
2210 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2212 free_values
.free_to_mark ();
2213 retval
= allocate_value (subobj_type
);
2214 mark_value_bytes_unavailable (retval
, 0,
2215 TYPE_LENGTH (subobj_type
));
2218 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2220 if (entry_values_debug
)
2221 exception_print (gdb_stdout
, ex
);
2222 free_values
.free_to_mark ();
2223 return allocate_optimized_out_value (subobj_type
);
2229 if (ctx
.pieces
.size () > 0)
2231 struct piece_closure
*c
;
2232 ULONGEST bit_size
= 0;
2234 for (dwarf_expr_piece
&piece
: ctx
.pieces
)
2235 bit_size
+= piece
.size
;
2236 /* Complain if the expression is larger than the size of the
2238 if (bit_size
> 8 * TYPE_LENGTH (type
))
2239 invalid_synthetic_pointer ();
2241 c
= allocate_piece_closure (per_cu
, std::move (ctx
.pieces
), frame
);
2242 /* We must clean up the value chain after creating the piece
2243 closure but before allocating the result. */
2244 free_values
.free_to_mark ();
2245 retval
= allocate_computed_value (subobj_type
,
2246 &pieced_value_funcs
, c
);
2247 set_value_offset (retval
, subobj_byte_offset
);
2251 switch (ctx
.location
)
2253 case DWARF_VALUE_REGISTER
:
2255 struct gdbarch
*arch
= get_frame_arch (frame
);
2257 = longest_to_int (value_as_long (ctx
.fetch (0)));
2258 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, dwarf_regnum
);
2260 if (subobj_byte_offset
!= 0)
2261 error (_("cannot use offset on synthetic pointer to register"));
2262 free_values
.free_to_mark ();
2263 retval
= value_from_register (subobj_type
, gdb_regnum
, frame
);
2264 if (value_optimized_out (retval
))
2268 /* This means the register has undefined value / was
2269 not saved. As we're computing the location of some
2270 variable etc. in the program, not a value for
2271 inspecting a register ($pc, $sp, etc.), return a
2272 generic optimized out value instead, so that we show
2273 <optimized out> instead of <not saved>. */
2274 tmp
= allocate_value (subobj_type
);
2275 value_contents_copy (tmp
, 0, retval
, 0,
2276 TYPE_LENGTH (subobj_type
));
2282 case DWARF_VALUE_MEMORY
:
2284 struct type
*ptr_type
;
2285 CORE_ADDR address
= ctx
.fetch_address (0);
2286 bool in_stack_memory
= ctx
.fetch_in_stack_memory (0);
2288 /* DW_OP_deref_size (and possibly other operations too) may
2289 create a pointer instead of an address. Ideally, the
2290 pointer to address conversion would be performed as part
2291 of those operations, but the type of the object to
2292 which the address refers is not known at the time of
2293 the operation. Therefore, we do the conversion here
2294 since the type is readily available. */
2296 switch (TYPE_CODE (subobj_type
))
2298 case TYPE_CODE_FUNC
:
2299 case TYPE_CODE_METHOD
:
2300 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_func_ptr
;
2303 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_data_ptr
;
2306 address
= value_as_address (value_from_pointer (ptr_type
, address
));
2308 free_values
.free_to_mark ();
2309 retval
= value_at_lazy (subobj_type
,
2310 address
+ subobj_byte_offset
);
2311 if (in_stack_memory
)
2312 set_value_stack (retval
, 1);
2316 case DWARF_VALUE_STACK
:
2318 struct value
*value
= ctx
.fetch (0);
2319 size_t n
= TYPE_LENGTH (value_type (value
));
2320 size_t len
= TYPE_LENGTH (subobj_type
);
2321 size_t max
= TYPE_LENGTH (type
);
2322 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2324 if (subobj_byte_offset
+ len
> max
)
2325 invalid_synthetic_pointer ();
2327 /* Preserve VALUE because we are going to free values back
2328 to the mark, but we still need the value contents
2330 value_ref_ptr value_holder
= value_ref_ptr::new_reference (value
);
2331 free_values
.free_to_mark ();
2333 retval
= allocate_value (subobj_type
);
2335 /* The given offset is relative to the actual object. */
2336 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2337 subobj_byte_offset
+= n
- max
;
2339 memcpy (value_contents_raw (retval
),
2340 value_contents_all (value
) + subobj_byte_offset
, len
);
2344 case DWARF_VALUE_LITERAL
:
2347 size_t n
= TYPE_LENGTH (subobj_type
);
2349 if (subobj_byte_offset
+ n
> ctx
.len
)
2350 invalid_synthetic_pointer ();
2352 free_values
.free_to_mark ();
2353 retval
= allocate_value (subobj_type
);
2354 contents
= value_contents_raw (retval
);
2355 memcpy (contents
, ctx
.data
+ subobj_byte_offset
, n
);
2359 case DWARF_VALUE_OPTIMIZED_OUT
:
2360 free_values
.free_to_mark ();
2361 retval
= allocate_optimized_out_value (subobj_type
);
2364 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2365 operation by execute_stack_op. */
2366 case DWARF_VALUE_IMPLICIT_POINTER
:
2367 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2368 it can only be encountered when making a piece. */
2370 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2374 set_value_initialized (retval
, ctx
.initialized
);
2379 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2380 passes 0 as the byte_offset. */
2383 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2384 const gdb_byte
*data
, size_t size
,
2385 struct dwarf2_per_cu_data
*per_cu
)
2387 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
,
2391 /* Evaluates a dwarf expression and stores the result in VAL, expecting
2392 that the dwarf expression only produces a single CORE_ADDR. FRAME is the
2393 frame in which the expression is evaluated. ADDR is a context (location of
2394 a variable) and might be needed to evaluate the location expression.
2395 Returns 1 on success, 0 otherwise. */
2398 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton
*dlbaton
,
2399 struct frame_info
*frame
,
2403 struct objfile
*objfile
;
2405 if (dlbaton
== NULL
|| dlbaton
->size
== 0)
2408 dwarf_evaluate_loc_desc ctx
;
2411 ctx
.per_cu
= dlbaton
->per_cu
;
2412 ctx
.obj_address
= addr
;
2414 objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2416 ctx
.gdbarch
= get_objfile_arch (objfile
);
2417 ctx
.addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2418 ctx
.ref_addr_size
= dwarf2_per_cu_ref_addr_size (dlbaton
->per_cu
);
2419 ctx
.offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
2423 ctx
.eval (dlbaton
->data
, dlbaton
->size
);
2425 catch (const gdb_exception_error
&ex
)
2427 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2431 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2433 if (entry_values_debug
)
2434 exception_print (gdb_stdout
, ex
);
2441 switch (ctx
.location
)
2443 case DWARF_VALUE_REGISTER
:
2444 case DWARF_VALUE_MEMORY
:
2445 case DWARF_VALUE_STACK
:
2446 *valp
= ctx
.fetch_address (0);
2447 if (ctx
.location
== DWARF_VALUE_REGISTER
)
2448 *valp
= ctx
.read_addr_from_reg (*valp
);
2450 case DWARF_VALUE_LITERAL
:
2451 *valp
= extract_signed_integer (ctx
.data
, ctx
.len
,
2452 gdbarch_byte_order (ctx
.gdbarch
));
2454 /* Unsupported dwarf values. */
2455 case DWARF_VALUE_OPTIMIZED_OUT
:
2456 case DWARF_VALUE_IMPLICIT_POINTER
:
2463 /* See dwarf2loc.h. */
2466 dwarf2_evaluate_property (const struct dynamic_prop
*prop
,
2467 struct frame_info
*frame
,
2468 struct property_addr_info
*addr_stack
,
2474 if (frame
== NULL
&& has_stack_frames ())
2475 frame
= get_selected_frame (NULL
);
2481 const struct dwarf2_property_baton
*baton
2482 = (const struct dwarf2_property_baton
*) prop
->data
.baton
;
2483 gdb_assert (baton
->property_type
!= NULL
);
2485 if (dwarf2_locexpr_baton_eval (&baton
->locexpr
, frame
,
2486 addr_stack
? addr_stack
->addr
: 0,
2489 if (baton
->locexpr
.is_reference
)
2491 struct value
*val
= value_at (baton
->property_type
, *value
);
2492 *value
= value_as_address (val
);
2496 gdb_assert (baton
->property_type
!= NULL
);
2498 struct type
*type
= check_typedef (baton
->property_type
);
2499 if (TYPE_LENGTH (type
) < sizeof (CORE_ADDR
)
2500 && !TYPE_UNSIGNED (type
))
2502 /* If we have a valid return candidate and it's value
2503 is signed, we have to sign-extend the value because
2504 CORE_ADDR on 64bit machine has 8 bytes but address
2505 size of an 32bit application is bytes. */
2507 = (dwarf2_per_cu_addr_size (baton
->locexpr
.per_cu
)
2509 const CORE_ADDR neg_mask
2510 = (~((CORE_ADDR
) 0) << (addr_size
- 1));
2512 /* Check if signed bit is set and sign-extend values. */
2513 if (*value
& neg_mask
)
2524 struct dwarf2_property_baton
*baton
2525 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2526 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2527 const gdb_byte
*data
;
2531 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2534 val
= dwarf2_evaluate_loc_desc (baton
->property_type
, frame
, data
,
2535 size
, baton
->loclist
.per_cu
);
2536 if (!value_optimized_out (val
))
2538 *value
= value_as_address (val
);
2546 *value
= prop
->data
.const_val
;
2549 case PROP_ADDR_OFFSET
:
2551 struct dwarf2_property_baton
*baton
2552 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2553 struct property_addr_info
*pinfo
;
2556 for (pinfo
= addr_stack
; pinfo
!= NULL
; pinfo
= pinfo
->next
)
2558 /* This approach lets us avoid checking the qualifiers. */
2559 if (TYPE_MAIN_TYPE (pinfo
->type
)
2560 == TYPE_MAIN_TYPE (baton
->property_type
))
2564 error (_("cannot find reference address for offset property"));
2565 if (pinfo
->valaddr
!= NULL
)
2566 val
= value_from_contents
2567 (baton
->offset_info
.type
,
2568 pinfo
->valaddr
+ baton
->offset_info
.offset
);
2570 val
= value_at (baton
->offset_info
.type
,
2571 pinfo
->addr
+ baton
->offset_info
.offset
);
2572 *value
= value_as_address (val
);
2580 /* See dwarf2loc.h. */
2583 dwarf2_compile_property_to_c (string_file
*stream
,
2584 const char *result_name
,
2585 struct gdbarch
*gdbarch
,
2586 unsigned char *registers_used
,
2587 const struct dynamic_prop
*prop
,
2591 struct dwarf2_property_baton
*baton
2592 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2593 const gdb_byte
*data
;
2595 struct dwarf2_per_cu_data
*per_cu
;
2597 if (prop
->kind
== PROP_LOCEXPR
)
2599 data
= baton
->locexpr
.data
;
2600 size
= baton
->locexpr
.size
;
2601 per_cu
= baton
->locexpr
.per_cu
;
2605 gdb_assert (prop
->kind
== PROP_LOCLIST
);
2607 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2608 per_cu
= baton
->loclist
.per_cu
;
2611 compile_dwarf_bounds_to_c (stream
, result_name
, prop
, sym
, pc
,
2612 gdbarch
, registers_used
,
2613 dwarf2_per_cu_addr_size (per_cu
),
2614 data
, data
+ size
, per_cu
);
2618 /* Helper functions and baton for dwarf2_loc_desc_get_symbol_read_needs. */
2620 class symbol_needs_eval_context
: public dwarf_expr_context
2624 enum symbol_needs_kind needs
;
2625 struct dwarf2_per_cu_data
*per_cu
;
2627 /* Reads from registers do require a frame. */
2628 CORE_ADDR
read_addr_from_reg (int regnum
) override
2630 needs
= SYMBOL_NEEDS_FRAME
;
2634 /* "get_reg_value" callback: Reads from registers do require a
2637 struct value
*get_reg_value (struct type
*type
, int regnum
) override
2639 needs
= SYMBOL_NEEDS_FRAME
;
2640 return value_zero (type
, not_lval
);
2643 /* Reads from memory do not require a frame. */
2644 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
2646 memset (buf
, 0, len
);
2649 /* Frame-relative accesses do require a frame. */
2650 void get_frame_base (const gdb_byte
**start
, size_t *length
) override
2652 static gdb_byte lit0
= DW_OP_lit0
;
2657 needs
= SYMBOL_NEEDS_FRAME
;
2660 /* CFA accesses require a frame. */
2661 CORE_ADDR
get_frame_cfa () override
2663 needs
= SYMBOL_NEEDS_FRAME
;
2667 CORE_ADDR
get_frame_pc () override
2669 needs
= SYMBOL_NEEDS_FRAME
;
2673 /* Thread-local accesses require registers, but not a frame. */
2674 CORE_ADDR
get_tls_address (CORE_ADDR offset
) override
2676 if (needs
<= SYMBOL_NEEDS_REGISTERS
)
2677 needs
= SYMBOL_NEEDS_REGISTERS
;
2681 /* Helper interface of per_cu_dwarf_call for
2682 dwarf2_loc_desc_get_symbol_read_needs. */
2684 void dwarf_call (cu_offset die_offset
) override
2686 per_cu_dwarf_call (this, die_offset
, per_cu
);
2689 /* Helper interface of sect_variable_value for
2690 dwarf2_loc_desc_get_symbol_read_needs. */
2692 struct value
*dwarf_variable_value (sect_offset sect_off
) override
2694 return sect_variable_value (this, sect_off
, per_cu
);
2697 /* DW_OP_entry_value accesses require a caller, therefore a
2700 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
2701 union call_site_parameter_u kind_u
,
2702 int deref_size
) override
2704 needs
= SYMBOL_NEEDS_FRAME
;
2706 /* The expression may require some stub values on DWARF stack. */
2707 push_address (0, 0);
2710 /* DW_OP_addrx and DW_OP_GNU_addr_index doesn't require a frame. */
2712 CORE_ADDR
get_addr_index (unsigned int index
) override
2714 /* Nothing to do. */
2718 /* DW_OP_push_object_address has a frame already passed through. */
2720 CORE_ADDR
get_object_address () override
2722 /* Nothing to do. */
2727 /* Compute the correct symbol_needs_kind value for the location
2728 expression at DATA (length SIZE). */
2730 static enum symbol_needs_kind
2731 dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte
*data
, size_t size
,
2732 struct dwarf2_per_cu_data
*per_cu
)
2735 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2737 scoped_value_mark free_values
;
2739 symbol_needs_eval_context ctx
;
2741 ctx
.needs
= SYMBOL_NEEDS_NONE
;
2742 ctx
.per_cu
= per_cu
;
2743 ctx
.gdbarch
= get_objfile_arch (objfile
);
2744 ctx
.addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2745 ctx
.ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2746 ctx
.offset
= dwarf2_per_cu_text_offset (per_cu
);
2748 ctx
.eval (data
, size
);
2750 in_reg
= ctx
.location
== DWARF_VALUE_REGISTER
;
2752 /* If the location has several pieces, and any of them are in
2753 registers, then we will need a frame to fetch them from. */
2754 for (dwarf_expr_piece
&p
: ctx
.pieces
)
2755 if (p
.location
== DWARF_VALUE_REGISTER
)
2759 ctx
.needs
= SYMBOL_NEEDS_FRAME
;
2763 /* A helper function that throws an unimplemented error mentioning a
2764 given DWARF operator. */
2766 static void ATTRIBUTE_NORETURN
2767 unimplemented (unsigned int op
)
2769 const char *name
= get_DW_OP_name (op
);
2772 error (_("DWARF operator %s cannot be translated to an agent expression"),
2775 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2776 "to an agent expression"),
2782 This is basically a wrapper on gdbarch_dwarf2_reg_to_regnum so that we
2783 can issue a complaint, which is better than having every target's
2784 implementation of dwarf2_reg_to_regnum do it. */
2787 dwarf_reg_to_regnum (struct gdbarch
*arch
, int dwarf_reg
)
2789 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2793 complaint (_("bad DWARF register number %d"), dwarf_reg
);
2798 /* Subroutine of dwarf_reg_to_regnum_or_error to simplify it.
2799 Throw an error because DWARF_REG is bad. */
2802 throw_bad_regnum_error (ULONGEST dwarf_reg
)
2804 /* Still want to print -1 as "-1".
2805 We *could* have int and ULONGEST versions of dwarf2_reg_to_regnum_or_error
2806 but that's overkill for now. */
2807 if ((int) dwarf_reg
== dwarf_reg
)
2808 error (_("Unable to access DWARF register number %d"), (int) dwarf_reg
);
2809 error (_("Unable to access DWARF register number %s"),
2810 pulongest (dwarf_reg
));
2813 /* See dwarf2loc.h. */
2816 dwarf_reg_to_regnum_or_error (struct gdbarch
*arch
, ULONGEST dwarf_reg
)
2820 if (dwarf_reg
> INT_MAX
)
2821 throw_bad_regnum_error (dwarf_reg
);
2822 /* Yes, we will end up issuing a complaint and an error if DWARF_REG is
2823 bad, but that's ok. */
2824 reg
= dwarf_reg_to_regnum (arch
, (int) dwarf_reg
);
2826 throw_bad_regnum_error (dwarf_reg
);
2830 /* A helper function that emits an access to memory. ARCH is the
2831 target architecture. EXPR is the expression which we are building.
2832 NBITS is the number of bits we want to read. This emits the
2833 opcodes needed to read the memory and then extract the desired
2837 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2839 ULONGEST nbytes
= (nbits
+ 7) / 8;
2841 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2844 ax_trace_quick (expr
, nbytes
);
2847 ax_simple (expr
, aop_ref8
);
2848 else if (nbits
<= 16)
2849 ax_simple (expr
, aop_ref16
);
2850 else if (nbits
<= 32)
2851 ax_simple (expr
, aop_ref32
);
2853 ax_simple (expr
, aop_ref64
);
2855 /* If we read exactly the number of bytes we wanted, we're done. */
2856 if (8 * nbytes
== nbits
)
2859 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
)
2861 /* On a bits-big-endian machine, we want the high-order
2863 ax_const_l (expr
, 8 * nbytes
- nbits
);
2864 ax_simple (expr
, aop_rsh_unsigned
);
2868 /* On a bits-little-endian box, we want the low-order NBITS. */
2869 ax_zero_ext (expr
, nbits
);
2873 /* A helper function to return the frame's PC. */
2876 get_ax_pc (void *baton
)
2878 struct agent_expr
*expr
= (struct agent_expr
*) baton
;
2883 /* Compile a DWARF location expression to an agent expression.
2885 EXPR is the agent expression we are building.
2886 LOC is the agent value we modify.
2887 ARCH is the architecture.
2888 ADDR_SIZE is the size of addresses, in bytes.
2889 OP_PTR is the start of the location expression.
2890 OP_END is one past the last byte of the location expression.
2892 This will throw an exception for various kinds of errors -- for
2893 example, if the expression cannot be compiled, or if the expression
2897 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2898 unsigned int addr_size
, const gdb_byte
*op_ptr
,
2899 const gdb_byte
*op_end
,
2900 struct dwarf2_per_cu_data
*per_cu
)
2902 gdbarch
*arch
= expr
->gdbarch
;
2903 std::vector
<int> dw_labels
, patches
;
2904 const gdb_byte
* const base
= op_ptr
;
2905 const gdb_byte
*previous_piece
= op_ptr
;
2906 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2907 ULONGEST bits_collected
= 0;
2908 unsigned int addr_size_bits
= 8 * addr_size
;
2909 bool bits_big_endian
= byte_order
== BFD_ENDIAN_BIG
;
2911 std::vector
<int> offsets (op_end
- op_ptr
, -1);
2913 /* By default we are making an address. */
2914 loc
->kind
= axs_lvalue_memory
;
2916 while (op_ptr
< op_end
)
2918 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
2919 uint64_t uoffset
, reg
;
2923 offsets
[op_ptr
- base
] = expr
->len
;
2926 /* Our basic approach to code generation is to map DWARF
2927 operations directly to AX operations. However, there are
2930 First, DWARF works on address-sized units, but AX always uses
2931 LONGEST. For most operations we simply ignore this
2932 difference; instead we generate sign extensions as needed
2933 before division and comparison operations. It would be nice
2934 to omit the sign extensions, but there is no way to determine
2935 the size of the target's LONGEST. (This code uses the size
2936 of the host LONGEST in some cases -- that is a bug but it is
2939 Second, some DWARF operations cannot be translated to AX.
2940 For these we simply fail. See
2941 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2976 ax_const_l (expr
, op
- DW_OP_lit0
);
2980 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
2981 op_ptr
+= addr_size
;
2982 /* Some versions of GCC emit DW_OP_addr before
2983 DW_OP_GNU_push_tls_address. In this case the value is an
2984 index, not an address. We don't support things like
2985 branching between the address and the TLS op. */
2986 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
2987 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
2988 ax_const_l (expr
, uoffset
);
2992 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
2996 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
3000 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
3004 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
3008 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
3012 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
3016 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
3020 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
3024 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3025 ax_const_l (expr
, uoffset
);
3028 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3029 ax_const_l (expr
, offset
);
3064 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3065 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_reg0
);
3066 loc
->kind
= axs_lvalue_register
;
3070 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3071 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3072 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3073 loc
->kind
= axs_lvalue_register
;
3076 case DW_OP_implicit_value
:
3080 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
3081 if (op_ptr
+ len
> op_end
)
3082 error (_("DW_OP_implicit_value: too few bytes available."));
3083 if (len
> sizeof (ULONGEST
))
3084 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
3087 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
3090 dwarf_expr_require_composition (op_ptr
, op_end
,
3091 "DW_OP_implicit_value");
3093 loc
->kind
= axs_rvalue
;
3097 case DW_OP_stack_value
:
3098 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
3099 loc
->kind
= axs_rvalue
;
3134 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3135 i
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_breg0
);
3139 ax_const_l (expr
, offset
);
3140 ax_simple (expr
, aop_add
);
3145 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3146 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3147 i
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3151 ax_const_l (expr
, offset
);
3152 ax_simple (expr
, aop_add
);
3158 const gdb_byte
*datastart
;
3160 const struct block
*b
;
3161 struct symbol
*framefunc
;
3163 b
= block_for_pc (expr
->scope
);
3166 error (_("No block found for address"));
3168 framefunc
= block_linkage_function (b
);
3171 error (_("No function found for block"));
3173 func_get_frame_base_dwarf_block (framefunc
, expr
->scope
,
3174 &datastart
, &datalen
);
3176 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3177 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, datastart
,
3178 datastart
+ datalen
, per_cu
);
3179 if (loc
->kind
== axs_lvalue_register
)
3180 require_rvalue (expr
, loc
);
3184 ax_const_l (expr
, offset
);
3185 ax_simple (expr
, aop_add
);
3188 loc
->kind
= axs_lvalue_memory
;
3193 ax_simple (expr
, aop_dup
);
3197 ax_simple (expr
, aop_pop
);
3202 ax_pick (expr
, offset
);
3206 ax_simple (expr
, aop_swap
);
3214 ax_simple (expr
, aop_rot
);
3218 case DW_OP_deref_size
:
3222 if (op
== DW_OP_deref_size
)
3227 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3228 error (_("Unsupported size %d in %s"),
3229 size
, get_DW_OP_name (op
));
3230 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3235 /* Sign extend the operand. */
3236 ax_ext (expr
, addr_size_bits
);
3237 ax_simple (expr
, aop_dup
);
3238 ax_const_l (expr
, 0);
3239 ax_simple (expr
, aop_less_signed
);
3240 ax_simple (expr
, aop_log_not
);
3241 i
= ax_goto (expr
, aop_if_goto
);
3242 /* We have to emit 0 - X. */
3243 ax_const_l (expr
, 0);
3244 ax_simple (expr
, aop_swap
);
3245 ax_simple (expr
, aop_sub
);
3246 ax_label (expr
, i
, expr
->len
);
3250 /* No need to sign extend here. */
3251 ax_const_l (expr
, 0);
3252 ax_simple (expr
, aop_swap
);
3253 ax_simple (expr
, aop_sub
);
3257 /* Sign extend the operand. */
3258 ax_ext (expr
, addr_size_bits
);
3259 ax_simple (expr
, aop_bit_not
);
3262 case DW_OP_plus_uconst
:
3263 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3264 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3265 but we micro-optimize anyhow. */
3268 ax_const_l (expr
, reg
);
3269 ax_simple (expr
, aop_add
);
3274 ax_simple (expr
, aop_bit_and
);
3278 /* Sign extend the operands. */
3279 ax_ext (expr
, addr_size_bits
);
3280 ax_simple (expr
, aop_swap
);
3281 ax_ext (expr
, addr_size_bits
);
3282 ax_simple (expr
, aop_swap
);
3283 ax_simple (expr
, aop_div_signed
);
3287 ax_simple (expr
, aop_sub
);
3291 ax_simple (expr
, aop_rem_unsigned
);
3295 ax_simple (expr
, aop_mul
);
3299 ax_simple (expr
, aop_bit_or
);
3303 ax_simple (expr
, aop_add
);
3307 ax_simple (expr
, aop_lsh
);
3311 ax_simple (expr
, aop_rsh_unsigned
);
3315 ax_simple (expr
, aop_rsh_signed
);
3319 ax_simple (expr
, aop_bit_xor
);
3323 /* Sign extend the operands. */
3324 ax_ext (expr
, addr_size_bits
);
3325 ax_simple (expr
, aop_swap
);
3326 ax_ext (expr
, addr_size_bits
);
3327 /* Note no swap here: A <= B is !(B < A). */
3328 ax_simple (expr
, aop_less_signed
);
3329 ax_simple (expr
, aop_log_not
);
3333 /* Sign extend the operands. */
3334 ax_ext (expr
, addr_size_bits
);
3335 ax_simple (expr
, aop_swap
);
3336 ax_ext (expr
, addr_size_bits
);
3337 ax_simple (expr
, aop_swap
);
3338 /* A >= B is !(A < B). */
3339 ax_simple (expr
, aop_less_signed
);
3340 ax_simple (expr
, aop_log_not
);
3344 /* Sign extend the operands. */
3345 ax_ext (expr
, addr_size_bits
);
3346 ax_simple (expr
, aop_swap
);
3347 ax_ext (expr
, addr_size_bits
);
3348 /* No need for a second swap here. */
3349 ax_simple (expr
, aop_equal
);
3353 /* Sign extend the operands. */
3354 ax_ext (expr
, addr_size_bits
);
3355 ax_simple (expr
, aop_swap
);
3356 ax_ext (expr
, addr_size_bits
);
3357 ax_simple (expr
, aop_swap
);
3358 ax_simple (expr
, aop_less_signed
);
3362 /* Sign extend the operands. */
3363 ax_ext (expr
, addr_size_bits
);
3364 ax_simple (expr
, aop_swap
);
3365 ax_ext (expr
, addr_size_bits
);
3366 /* Note no swap here: A > B is B < A. */
3367 ax_simple (expr
, aop_less_signed
);
3371 /* Sign extend the operands. */
3372 ax_ext (expr
, addr_size_bits
);
3373 ax_simple (expr
, aop_swap
);
3374 ax_ext (expr
, addr_size_bits
);
3375 /* No need for a swap here. */
3376 ax_simple (expr
, aop_equal
);
3377 ax_simple (expr
, aop_log_not
);
3380 case DW_OP_call_frame_cfa
:
3383 CORE_ADDR text_offset
;
3385 const gdb_byte
*cfa_start
, *cfa_end
;
3387 if (dwarf2_fetch_cfa_info (arch
, expr
->scope
, per_cu
,
3389 &text_offset
, &cfa_start
, &cfa_end
))
3392 ax_reg (expr
, regnum
);
3395 ax_const_l (expr
, off
);
3396 ax_simple (expr
, aop_add
);
3401 /* Another expression. */
3402 ax_const_l (expr
, text_offset
);
3403 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, cfa_start
,
3407 loc
->kind
= axs_lvalue_memory
;
3411 case DW_OP_GNU_push_tls_address
:
3412 case DW_OP_form_tls_address
:
3416 case DW_OP_push_object_address
:
3421 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3423 i
= ax_goto (expr
, aop_goto
);
3424 dw_labels
.push_back (op_ptr
+ offset
- base
);
3425 patches
.push_back (i
);
3429 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3431 /* Zero extend the operand. */
3432 ax_zero_ext (expr
, addr_size_bits
);
3433 i
= ax_goto (expr
, aop_if_goto
);
3434 dw_labels
.push_back (op_ptr
+ offset
- base
);
3435 patches
.push_back (i
);
3442 case DW_OP_bit_piece
:
3446 if (op_ptr
- 1 == previous_piece
)
3447 error (_("Cannot translate empty pieces to agent expressions"));
3448 previous_piece
= op_ptr
- 1;
3450 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3451 if (op
== DW_OP_piece
)
3457 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3459 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3460 error (_("Expression pieces exceed word size"));
3462 /* Access the bits. */
3465 case axs_lvalue_register
:
3466 ax_reg (expr
, loc
->u
.reg
);
3469 case axs_lvalue_memory
:
3470 /* Offset the pointer, if needed. */
3473 ax_const_l (expr
, uoffset
/ 8);
3474 ax_simple (expr
, aop_add
);
3477 access_memory (arch
, expr
, size
);
3481 /* For a bits-big-endian target, shift up what we already
3482 have. For a bits-little-endian target, shift up the
3483 new data. Note that there is a potential bug here if
3484 the DWARF expression leaves multiple values on the
3486 if (bits_collected
> 0)
3488 if (bits_big_endian
)
3490 ax_simple (expr
, aop_swap
);
3491 ax_const_l (expr
, size
);
3492 ax_simple (expr
, aop_lsh
);
3493 /* We don't need a second swap here, because
3494 aop_bit_or is symmetric. */
3498 ax_const_l (expr
, size
);
3499 ax_simple (expr
, aop_lsh
);
3501 ax_simple (expr
, aop_bit_or
);
3504 bits_collected
+= size
;
3505 loc
->kind
= axs_rvalue
;
3509 case DW_OP_GNU_uninit
:
3515 struct dwarf2_locexpr_baton block
;
3516 int size
= (op
== DW_OP_call2
? 2 : 4);
3518 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3521 cu_offset cuoffset
= (cu_offset
) uoffset
;
3522 block
= dwarf2_fetch_die_loc_cu_off (cuoffset
, per_cu
,
3525 /* DW_OP_call_ref is currently not supported. */
3526 gdb_assert (block
.per_cu
== per_cu
);
3528 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, block
.data
,
3529 block
.data
+ block
.size
, per_cu
);
3533 case DW_OP_call_ref
:
3536 case DW_OP_GNU_variable_value
:
3544 /* Patch all the branches we emitted. */
3545 for (int i
= 0; i
< patches
.size (); ++i
)
3547 int targ
= offsets
[dw_labels
[i
]];
3549 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3550 ax_label (expr
, patches
[i
], targ
);
3555 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3556 evaluator to calculate the location. */
3557 static struct value
*
3558 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3560 struct dwarf2_locexpr_baton
*dlbaton
3561 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3564 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3565 dlbaton
->size
, dlbaton
->per_cu
);
3570 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3571 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3574 static struct value
*
3575 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3577 struct dwarf2_locexpr_baton
*dlbaton
3578 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3580 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3584 /* Implementation of get_symbol_read_needs from
3585 symbol_computed_ops. */
3587 static enum symbol_needs_kind
3588 locexpr_get_symbol_read_needs (struct symbol
*symbol
)
3590 struct dwarf2_locexpr_baton
*dlbaton
3591 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3593 return dwarf2_loc_desc_get_symbol_read_needs (dlbaton
->data
, dlbaton
->size
,
3597 /* Return true if DATA points to the end of a piece. END is one past
3598 the last byte in the expression. */
3601 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3603 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3606 /* Helper for locexpr_describe_location_piece that finds the name of a
3610 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3614 /* This doesn't use dwarf_reg_to_regnum_or_error on purpose.
3615 We'd rather print *something* here than throw an error. */
3616 regnum
= dwarf_reg_to_regnum (gdbarch
, dwarf_regnum
);
3617 /* gdbarch_register_name may just return "", return something more
3618 descriptive for bad register numbers. */
3621 /* The text is output as "$bad_register_number".
3622 That is why we use the underscores. */
3623 return _("bad_register_number");
3625 return gdbarch_register_name (gdbarch
, regnum
);
3628 /* Nicely describe a single piece of a location, returning an updated
3629 position in the bytecode sequence. This function cannot recognize
3630 all locations; if a location is not recognized, it simply returns
3631 DATA. If there is an error during reading, e.g. we run off the end
3632 of the buffer, an error is thrown. */
3634 static const gdb_byte
*
3635 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3636 CORE_ADDR addr
, struct objfile
*objfile
,
3637 struct dwarf2_per_cu_data
*per_cu
,
3638 const gdb_byte
*data
, const gdb_byte
*end
,
3639 unsigned int addr_size
)
3641 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3644 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3646 fprintf_filtered (stream
, _("a variable in $%s"),
3647 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3650 else if (data
[0] == DW_OP_regx
)
3654 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3655 fprintf_filtered (stream
, _("a variable in $%s"),
3656 locexpr_regname (gdbarch
, reg
));
3658 else if (data
[0] == DW_OP_fbreg
)
3660 const struct block
*b
;
3661 struct symbol
*framefunc
;
3663 int64_t frame_offset
;
3664 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3666 int64_t base_offset
= 0;
3668 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3669 if (!piece_end_p (new_data
, end
))
3673 b
= block_for_pc (addr
);
3676 error (_("No block found for address for symbol \"%s\"."),
3677 symbol
->print_name ());
3679 framefunc
= block_linkage_function (b
);
3682 error (_("No function found for block for symbol \"%s\"."),
3683 symbol
->print_name ());
3685 func_get_frame_base_dwarf_block (framefunc
, addr
, &base_data
, &base_size
);
3687 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3689 const gdb_byte
*buf_end
;
3691 frame_reg
= base_data
[0] - DW_OP_breg0
;
3692 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3694 if (buf_end
!= base_data
+ base_size
)
3695 error (_("Unexpected opcode after "
3696 "DW_OP_breg%u for symbol \"%s\"."),
3697 frame_reg
, symbol
->print_name ());
3699 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3701 /* The frame base is just the register, with no offset. */
3702 frame_reg
= base_data
[0] - DW_OP_reg0
;
3707 /* We don't know what to do with the frame base expression,
3708 so we can't trace this variable; give up. */
3712 fprintf_filtered (stream
,
3713 _("a variable at frame base reg $%s offset %s+%s"),
3714 locexpr_regname (gdbarch
, frame_reg
),
3715 plongest (base_offset
), plongest (frame_offset
));
3717 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3718 && piece_end_p (data
, end
))
3722 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3724 fprintf_filtered (stream
,
3725 _("a variable at offset %s from base reg $%s"),
3727 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3730 /* The location expression for a TLS variable looks like this (on a
3733 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3734 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3736 0x3 is the encoding for DW_OP_addr, which has an operand as long
3737 as the size of an address on the target machine (here is 8
3738 bytes). Note that more recent version of GCC emit DW_OP_const4u
3739 or DW_OP_const8u, depending on address size, rather than
3740 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3741 The operand represents the offset at which the variable is within
3742 the thread local storage. */
3744 else if (data
+ 1 + addr_size
< end
3745 && (data
[0] == DW_OP_addr
3746 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3747 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3748 && (data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3749 || data
[1 + addr_size
] == DW_OP_form_tls_address
)
3750 && piece_end_p (data
+ 2 + addr_size
, end
))
3753 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3754 gdbarch_byte_order (gdbarch
));
3756 fprintf_filtered (stream
,
3757 _("a thread-local variable at offset 0x%s "
3758 "in the thread-local storage for `%s'"),
3759 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3761 data
+= 1 + addr_size
+ 1;
3764 /* With -gsplit-dwarf a TLS variable can also look like this:
3765 DW_AT_location : 3 byte block: fc 4 e0
3766 (DW_OP_GNU_const_index: 4;
3767 DW_OP_GNU_push_tls_address) */
3768 else if (data
+ 3 <= end
3769 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3770 && data
[0] == DW_OP_GNU_const_index
3772 && (data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3773 || data
[1 + leb128_size
] == DW_OP_form_tls_address
)
3774 && piece_end_p (data
+ 2 + leb128_size
, end
))
3778 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3779 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3780 fprintf_filtered (stream
,
3781 _("a thread-local variable at offset 0x%s "
3782 "in the thread-local storage for `%s'"),
3783 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3787 else if (data
[0] >= DW_OP_lit0
3788 && data
[0] <= DW_OP_lit31
3790 && data
[1] == DW_OP_stack_value
)
3792 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3799 /* Disassemble an expression, stopping at the end of a piece or at the
3800 end of the expression. Returns a pointer to the next unread byte
3801 in the input expression. If ALL is nonzero, then this function
3802 will keep going until it reaches the end of the expression.
3803 If there is an error during reading, e.g. we run off the end
3804 of the buffer, an error is thrown. */
3806 static const gdb_byte
*
3807 disassemble_dwarf_expression (struct ui_file
*stream
,
3808 struct gdbarch
*arch
, unsigned int addr_size
,
3809 int offset_size
, const gdb_byte
*start
,
3810 const gdb_byte
*data
, const gdb_byte
*end
,
3811 int indent
, int all
,
3812 struct dwarf2_per_cu_data
*per_cu
)
3816 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3818 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *data
++;
3823 name
= get_DW_OP_name (op
);
3826 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3827 op
, (long) (data
- 1 - start
));
3828 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3829 (long) (data
- 1 - start
), name
);
3834 ul
= extract_unsigned_integer (data
, addr_size
,
3835 gdbarch_byte_order (arch
));
3837 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3841 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3843 fprintf_filtered (stream
, " %s", pulongest (ul
));
3846 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3848 fprintf_filtered (stream
, " %s", plongest (l
));
3851 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3853 fprintf_filtered (stream
, " %s", pulongest (ul
));
3856 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3858 fprintf_filtered (stream
, " %s", plongest (l
));
3861 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3863 fprintf_filtered (stream
, " %s", pulongest (ul
));
3866 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3868 fprintf_filtered (stream
, " %s", plongest (l
));
3871 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3873 fprintf_filtered (stream
, " %s", pulongest (ul
));
3876 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3878 fprintf_filtered (stream
, " %s", plongest (l
));
3881 data
= safe_read_uleb128 (data
, end
, &ul
);
3882 fprintf_filtered (stream
, " %s", pulongest (ul
));
3885 data
= safe_read_sleb128 (data
, end
, &l
);
3886 fprintf_filtered (stream
, " %s", plongest (l
));
3921 fprintf_filtered (stream
, " [$%s]",
3922 locexpr_regname (arch
, op
- DW_OP_reg0
));
3926 data
= safe_read_uleb128 (data
, end
, &ul
);
3927 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3928 locexpr_regname (arch
, (int) ul
));
3931 case DW_OP_implicit_value
:
3932 data
= safe_read_uleb128 (data
, end
, &ul
);
3934 fprintf_filtered (stream
, " %s", pulongest (ul
));
3969 data
= safe_read_sleb128 (data
, end
, &l
);
3970 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
3971 locexpr_regname (arch
, op
- DW_OP_breg0
));
3975 data
= safe_read_uleb128 (data
, end
, &ul
);
3976 data
= safe_read_sleb128 (data
, end
, &l
);
3977 fprintf_filtered (stream
, " register %s [$%s] offset %s",
3979 locexpr_regname (arch
, (int) ul
),
3984 data
= safe_read_sleb128 (data
, end
, &l
);
3985 fprintf_filtered (stream
, " %s", plongest (l
));
3988 case DW_OP_xderef_size
:
3989 case DW_OP_deref_size
:
3991 fprintf_filtered (stream
, " %d", *data
);
3995 case DW_OP_plus_uconst
:
3996 data
= safe_read_uleb128 (data
, end
, &ul
);
3997 fprintf_filtered (stream
, " %s", pulongest (ul
));
4001 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4003 fprintf_filtered (stream
, " to %ld",
4004 (long) (data
+ l
- start
));
4008 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4010 fprintf_filtered (stream
, " %ld",
4011 (long) (data
+ l
- start
));
4015 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
4017 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
4021 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4023 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4026 case DW_OP_call_ref
:
4027 ul
= extract_unsigned_integer (data
, offset_size
,
4028 gdbarch_byte_order (arch
));
4029 data
+= offset_size
;
4030 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4034 data
= safe_read_uleb128 (data
, end
, &ul
);
4035 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
4038 case DW_OP_bit_piece
:
4042 data
= safe_read_uleb128 (data
, end
, &ul
);
4043 data
= safe_read_uleb128 (data
, end
, &offset
);
4044 fprintf_filtered (stream
, " size %s offset %s (bits)",
4045 pulongest (ul
), pulongest (offset
));
4049 case DW_OP_implicit_pointer
:
4050 case DW_OP_GNU_implicit_pointer
:
4052 ul
= extract_unsigned_integer (data
, offset_size
,
4053 gdbarch_byte_order (arch
));
4054 data
+= offset_size
;
4056 data
= safe_read_sleb128 (data
, end
, &l
);
4058 fprintf_filtered (stream
, " DIE %s offset %s",
4059 phex_nz (ul
, offset_size
),
4064 case DW_OP_deref_type
:
4065 case DW_OP_GNU_deref_type
:
4067 int deref_addr_size
= *data
++;
4070 data
= safe_read_uleb128 (data
, end
, &ul
);
4071 cu_offset offset
= (cu_offset
) ul
;
4072 type
= dwarf2_get_die_type (offset
, per_cu
);
4073 fprintf_filtered (stream
, "<");
4074 type_print (type
, "", stream
, -1);
4075 fprintf_filtered (stream
, " [0x%s]> %d",
4076 phex_nz (to_underlying (offset
), 0),
4081 case DW_OP_const_type
:
4082 case DW_OP_GNU_const_type
:
4086 data
= safe_read_uleb128 (data
, end
, &ul
);
4087 cu_offset type_die
= (cu_offset
) ul
;
4088 type
= dwarf2_get_die_type (type_die
, per_cu
);
4089 fprintf_filtered (stream
, "<");
4090 type_print (type
, "", stream
, -1);
4091 fprintf_filtered (stream
, " [0x%s]>",
4092 phex_nz (to_underlying (type_die
), 0));
4096 case DW_OP_regval_type
:
4097 case DW_OP_GNU_regval_type
:
4102 data
= safe_read_uleb128 (data
, end
, ®
);
4103 data
= safe_read_uleb128 (data
, end
, &ul
);
4104 cu_offset type_die
= (cu_offset
) ul
;
4106 type
= dwarf2_get_die_type (type_die
, per_cu
);
4107 fprintf_filtered (stream
, "<");
4108 type_print (type
, "", stream
, -1);
4109 fprintf_filtered (stream
, " [0x%s]> [$%s]",
4110 phex_nz (to_underlying (type_die
), 0),
4111 locexpr_regname (arch
, reg
));
4116 case DW_OP_GNU_convert
:
4117 case DW_OP_reinterpret
:
4118 case DW_OP_GNU_reinterpret
:
4120 data
= safe_read_uleb128 (data
, end
, &ul
);
4121 cu_offset type_die
= (cu_offset
) ul
;
4123 if (to_underlying (type_die
) == 0)
4124 fprintf_filtered (stream
, "<0>");
4129 type
= dwarf2_get_die_type (type_die
, per_cu
);
4130 fprintf_filtered (stream
, "<");
4131 type_print (type
, "", stream
, -1);
4132 fprintf_filtered (stream
, " [0x%s]>",
4133 phex_nz (to_underlying (type_die
), 0));
4138 case DW_OP_entry_value
:
4139 case DW_OP_GNU_entry_value
:
4140 data
= safe_read_uleb128 (data
, end
, &ul
);
4141 fputc_filtered ('\n', stream
);
4142 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
4143 start
, data
, data
+ ul
, indent
+ 2,
4148 case DW_OP_GNU_parameter_ref
:
4149 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4151 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4155 case DW_OP_GNU_addr_index
:
4156 data
= safe_read_uleb128 (data
, end
, &ul
);
4157 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4158 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
4160 case DW_OP_GNU_const_index
:
4161 data
= safe_read_uleb128 (data
, end
, &ul
);
4162 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4163 fprintf_filtered (stream
, " %s", pulongest (ul
));
4166 case DW_OP_GNU_variable_value
:
4167 ul
= extract_unsigned_integer (data
, offset_size
,
4168 gdbarch_byte_order (arch
));
4169 data
+= offset_size
;
4170 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4174 fprintf_filtered (stream
, "\n");
4180 /* Describe a single location, which may in turn consist of multiple
4184 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
4185 struct ui_file
*stream
,
4186 const gdb_byte
*data
, size_t size
,
4187 struct objfile
*objfile
, unsigned int addr_size
,
4188 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
4190 const gdb_byte
*end
= data
+ size
;
4191 int first_piece
= 1, bad
= 0;
4195 const gdb_byte
*here
= data
;
4196 int disassemble
= 1;
4201 fprintf_filtered (stream
, _(", and "));
4203 if (!dwarf_always_disassemble
)
4205 data
= locexpr_describe_location_piece (symbol
, stream
,
4206 addr
, objfile
, per_cu
,
4207 data
, end
, addr_size
);
4208 /* If we printed anything, or if we have an empty piece,
4209 then don't disassemble. */
4211 || data
[0] == DW_OP_piece
4212 || data
[0] == DW_OP_bit_piece
)
4217 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
4218 data
= disassemble_dwarf_expression (stream
,
4219 get_objfile_arch (objfile
),
4220 addr_size
, offset_size
, data
,
4222 dwarf_always_disassemble
,
4228 int empty
= data
== here
;
4231 fprintf_filtered (stream
, " ");
4232 if (data
[0] == DW_OP_piece
)
4236 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
4239 fprintf_filtered (stream
, _("an empty %s-byte piece"),
4242 fprintf_filtered (stream
, _(" [%s-byte piece]"),
4245 else if (data
[0] == DW_OP_bit_piece
)
4247 uint64_t bits
, offset
;
4249 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
4250 data
= safe_read_uleb128 (data
, end
, &offset
);
4253 fprintf_filtered (stream
,
4254 _("an empty %s-bit piece"),
4257 fprintf_filtered (stream
,
4258 _(" [%s-bit piece, offset %s bits]"),
4259 pulongest (bits
), pulongest (offset
));
4269 if (bad
|| data
> end
)
4270 error (_("Corrupted DWARF2 expression for \"%s\"."),
4271 symbol
->print_name ());
4274 /* Print a natural-language description of SYMBOL to STREAM. This
4275 version is for a symbol with a single location. */
4278 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4279 struct ui_file
*stream
)
4281 struct dwarf2_locexpr_baton
*dlbaton
4282 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4283 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4284 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4285 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4287 locexpr_describe_location_1 (symbol
, addr
, stream
,
4288 dlbaton
->data
, dlbaton
->size
,
4289 objfile
, addr_size
, offset_size
,
4293 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4294 any necessary bytecode in AX. */
4297 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
4298 struct axs_value
*value
)
4300 struct dwarf2_locexpr_baton
*dlbaton
4301 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4302 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4304 if (dlbaton
->size
== 0)
4305 value
->optimized_out
= 1;
4307 dwarf2_compile_expr_to_ax (ax
, value
, addr_size
, dlbaton
->data
,
4308 dlbaton
->data
+ dlbaton
->size
, dlbaton
->per_cu
);
4311 /* symbol_computed_ops 'generate_c_location' method. */
4314 locexpr_generate_c_location (struct symbol
*sym
, string_file
*stream
,
4315 struct gdbarch
*gdbarch
,
4316 unsigned char *registers_used
,
4317 CORE_ADDR pc
, const char *result_name
)
4319 struct dwarf2_locexpr_baton
*dlbaton
4320 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (sym
);
4321 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4323 if (dlbaton
->size
== 0)
4324 error (_("symbol \"%s\" is optimized out"), sym
->natural_name ());
4326 compile_dwarf_expr_to_c (stream
, result_name
,
4327 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4328 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4332 /* The set of location functions used with the DWARF-2 expression
4334 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4335 locexpr_read_variable
,
4336 locexpr_read_variable_at_entry
,
4337 locexpr_get_symbol_read_needs
,
4338 locexpr_describe_location
,
4339 0, /* location_has_loclist */
4340 locexpr_tracepoint_var_ref
,
4341 locexpr_generate_c_location
4345 /* Wrapper functions for location lists. These generally find
4346 the appropriate location expression and call something above. */
4348 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4349 evaluator to calculate the location. */
4350 static struct value
*
4351 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4353 struct dwarf2_loclist_baton
*dlbaton
4354 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4356 const gdb_byte
*data
;
4358 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4360 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4361 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4367 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4368 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4371 Function always returns non-NULL value, it may be marked optimized out if
4372 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4373 if it cannot resolve the parameter for any reason. */
4375 static struct value
*
4376 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4378 struct dwarf2_loclist_baton
*dlbaton
4379 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4380 const gdb_byte
*data
;
4384 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4385 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4387 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4389 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4391 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4394 /* Implementation of get_symbol_read_needs from
4395 symbol_computed_ops. */
4397 static enum symbol_needs_kind
4398 loclist_symbol_needs (struct symbol
*symbol
)
4400 /* If there's a location list, then assume we need to have a frame
4401 to choose the appropriate location expression. With tracking of
4402 global variables this is not necessarily true, but such tracking
4403 is disabled in GCC at the moment until we figure out how to
4406 return SYMBOL_NEEDS_FRAME
;
4409 /* Print a natural-language description of SYMBOL to STREAM. This
4410 version applies when there is a list of different locations, each
4411 with a specified address range. */
4414 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4415 struct ui_file
*stream
)
4417 struct dwarf2_loclist_baton
*dlbaton
4418 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4419 const gdb_byte
*loc_ptr
, *buf_end
;
4420 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4421 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4422 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4423 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4424 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4425 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4426 /* Adjust base_address for relocatable objects. */
4427 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4428 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4431 loc_ptr
= dlbaton
->data
;
4432 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4434 fprintf_filtered (stream
, _("multi-location:\n"));
4436 /* Iterate through locations until we run out. */
4439 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4441 enum debug_loc_kind kind
;
4442 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4444 if (dlbaton
->from_dwo
)
4445 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4446 loc_ptr
, buf_end
, &new_ptr
,
4447 &low
, &high
, byte_order
);
4449 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4451 byte_order
, addr_size
,
4456 case DEBUG_LOC_END_OF_LIST
:
4459 case DEBUG_LOC_BASE_ADDRESS
:
4460 base_address
= high
+ base_offset
;
4461 fprintf_filtered (stream
, _(" Base address %s"),
4462 paddress (gdbarch
, base_address
));
4464 case DEBUG_LOC_START_END
:
4465 case DEBUG_LOC_START_LENGTH
:
4467 case DEBUG_LOC_BUFFER_OVERFLOW
:
4468 case DEBUG_LOC_INVALID_ENTRY
:
4469 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4470 symbol
->print_name ());
4472 gdb_assert_not_reached ("bad debug_loc_kind");
4475 /* Otherwise, a location expression entry. */
4476 low
+= base_address
;
4477 high
+= base_address
;
4479 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
);
4480 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
);
4482 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4485 /* (It would improve readability to print only the minimum
4486 necessary digits of the second number of the range.) */
4487 fprintf_filtered (stream
, _(" Range %s-%s: "),
4488 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4490 /* Now describe this particular location. */
4491 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4492 objfile
, addr_size
, offset_size
,
4495 fprintf_filtered (stream
, "\n");
4501 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4502 any necessary bytecode in AX. */
4504 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
4505 struct axs_value
*value
)
4507 struct dwarf2_loclist_baton
*dlbaton
4508 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4509 const gdb_byte
*data
;
4511 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4513 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4515 value
->optimized_out
= 1;
4517 dwarf2_compile_expr_to_ax (ax
, value
, addr_size
, data
, data
+ size
,
4521 /* symbol_computed_ops 'generate_c_location' method. */
4524 loclist_generate_c_location (struct symbol
*sym
, string_file
*stream
,
4525 struct gdbarch
*gdbarch
,
4526 unsigned char *registers_used
,
4527 CORE_ADDR pc
, const char *result_name
)
4529 struct dwarf2_loclist_baton
*dlbaton
4530 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (sym
);
4531 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4532 const gdb_byte
*data
;
4535 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4537 error (_("symbol \"%s\" is optimized out"), sym
->natural_name ());
4539 compile_dwarf_expr_to_c (stream
, result_name
,
4540 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4545 /* The set of location functions used with the DWARF-2 expression
4546 evaluator and location lists. */
4547 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4548 loclist_read_variable
,
4549 loclist_read_variable_at_entry
,
4550 loclist_symbol_needs
,
4551 loclist_describe_location
,
4552 1, /* location_has_loclist */
4553 loclist_tracepoint_var_ref
,
4554 loclist_generate_c_location
4557 void _initialize_dwarf2loc ();
4559 _initialize_dwarf2loc ()
4561 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4562 &entry_values_debug
,
4563 _("Set entry values and tail call frames "
4565 _("Show entry values and tail call frames "
4567 _("When non-zero, the process of determining "
4568 "parameter values from function entry point "
4569 "and tail call frames will be printed."),
4571 show_entry_values_debug
,
4572 &setdebuglist
, &showdebuglist
);