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 /* This is followed by two unsigned LEB128 operands. The values of these
96 operands are the starting and ending offsets, respectively, relative to
97 the applicable base address. */
98 DEBUG_LOC_OFFSET_PAIR
= 4,
100 /* An internal value indicating there is insufficient data. */
101 DEBUG_LOC_BUFFER_OVERFLOW
= -1,
103 /* An internal value indicating an invalid kind of entry was found. */
104 DEBUG_LOC_INVALID_ENTRY
= -2
107 /* Helper function which throws an error if a synthetic pointer is
111 invalid_synthetic_pointer (void)
113 error (_("access outside bounds of object "
114 "referenced via synthetic pointer"));
117 /* Decode the addresses in a non-dwo .debug_loc entry.
118 A pointer to the next byte to examine is returned in *NEW_PTR.
119 The encoded low,high addresses are return in *LOW,*HIGH.
120 The result indicates the kind of entry found. */
122 static enum debug_loc_kind
123 decode_debug_loc_addresses (const gdb_byte
*loc_ptr
, const gdb_byte
*buf_end
,
124 const gdb_byte
**new_ptr
,
125 CORE_ADDR
*low
, CORE_ADDR
*high
,
126 enum bfd_endian byte_order
,
127 unsigned int addr_size
,
130 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
132 if (buf_end
- loc_ptr
< 2 * addr_size
)
133 return DEBUG_LOC_BUFFER_OVERFLOW
;
136 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
138 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
139 loc_ptr
+= addr_size
;
142 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
144 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
145 loc_ptr
+= addr_size
;
149 /* A base-address-selection entry. */
150 if ((*low
& base_mask
) == base_mask
)
151 return DEBUG_LOC_BASE_ADDRESS
;
153 /* An end-of-list entry. */
154 if (*low
== 0 && *high
== 0)
155 return DEBUG_LOC_END_OF_LIST
;
157 return DEBUG_LOC_START_END
;
160 /* Decode the addresses in .debug_loclists entry.
161 A pointer to the next byte to examine is returned in *NEW_PTR.
162 The encoded low,high addresses are return in *LOW,*HIGH.
163 The result indicates the kind of entry found. */
165 static enum debug_loc_kind
166 decode_debug_loclists_addresses (struct dwarf2_per_cu_data
*per_cu
,
167 const gdb_byte
*loc_ptr
,
168 const gdb_byte
*buf_end
,
169 const gdb_byte
**new_ptr
,
170 CORE_ADDR
*low
, CORE_ADDR
*high
,
171 enum bfd_endian byte_order
,
172 unsigned int addr_size
,
177 if (loc_ptr
== buf_end
)
178 return DEBUG_LOC_BUFFER_OVERFLOW
;
182 case DW_LLE_base_addressx
:
184 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
186 return DEBUG_LOC_BUFFER_OVERFLOW
;
187 *high
= dwarf2_read_addr_index (per_cu
, u64
);
189 return DEBUG_LOC_BASE_ADDRESS
;
190 case DW_LLE_startx_length
:
191 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
193 return DEBUG_LOC_BUFFER_OVERFLOW
;
194 *low
= dwarf2_read_addr_index (per_cu
, u64
);
196 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
198 return DEBUG_LOC_BUFFER_OVERFLOW
;
201 return DEBUG_LOC_START_LENGTH
;
202 case DW_LLE_start_length
:
203 if (buf_end
- loc_ptr
< addr_size
)
204 return DEBUG_LOC_BUFFER_OVERFLOW
;
206 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
208 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
209 loc_ptr
+= addr_size
;
211 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
213 return DEBUG_LOC_BUFFER_OVERFLOW
;
216 return DEBUG_LOC_START_LENGTH
;
217 case DW_LLE_end_of_list
:
219 return DEBUG_LOC_END_OF_LIST
;
220 case DW_LLE_base_address
:
221 if (loc_ptr
+ addr_size
> buf_end
)
222 return DEBUG_LOC_BUFFER_OVERFLOW
;
224 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
226 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
227 loc_ptr
+= addr_size
;
229 return DEBUG_LOC_BASE_ADDRESS
;
230 case DW_LLE_offset_pair
:
231 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
233 return DEBUG_LOC_BUFFER_OVERFLOW
;
235 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
237 return DEBUG_LOC_BUFFER_OVERFLOW
;
240 return DEBUG_LOC_OFFSET_PAIR
;
241 /* Following cases are not supported yet. */
242 case DW_LLE_startx_endx
:
243 case DW_LLE_start_end
:
244 case DW_LLE_default_location
:
246 return DEBUG_LOC_INVALID_ENTRY
;
250 /* Decode the addresses in .debug_loc.dwo entry.
251 A pointer to the next byte to examine is returned in *NEW_PTR.
252 The encoded low,high addresses are return in *LOW,*HIGH.
253 The result indicates the kind of entry found. */
255 static enum debug_loc_kind
256 decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data
*per_cu
,
257 const gdb_byte
*loc_ptr
,
258 const gdb_byte
*buf_end
,
259 const gdb_byte
**new_ptr
,
260 CORE_ADDR
*low
, CORE_ADDR
*high
,
261 enum bfd_endian byte_order
)
263 uint64_t low_index
, high_index
;
265 if (loc_ptr
== buf_end
)
266 return DEBUG_LOC_BUFFER_OVERFLOW
;
270 case DW_LLE_GNU_end_of_list_entry
:
272 return DEBUG_LOC_END_OF_LIST
;
273 case DW_LLE_GNU_base_address_selection_entry
:
275 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
277 return DEBUG_LOC_BUFFER_OVERFLOW
;
278 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
280 return DEBUG_LOC_BASE_ADDRESS
;
281 case DW_LLE_GNU_start_end_entry
:
282 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
284 return DEBUG_LOC_BUFFER_OVERFLOW
;
285 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
286 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
288 return DEBUG_LOC_BUFFER_OVERFLOW
;
289 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
291 return DEBUG_LOC_START_END
;
292 case DW_LLE_GNU_start_length_entry
:
293 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
295 return DEBUG_LOC_BUFFER_OVERFLOW
;
296 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
297 if (loc_ptr
+ 4 > buf_end
)
298 return DEBUG_LOC_BUFFER_OVERFLOW
;
300 *high
+= extract_unsigned_integer (loc_ptr
, 4, byte_order
);
301 *new_ptr
= loc_ptr
+ 4;
302 return DEBUG_LOC_START_LENGTH
;
304 return DEBUG_LOC_INVALID_ENTRY
;
308 /* A function for dealing with location lists. Given a
309 symbol baton (BATON) and a pc value (PC), find the appropriate
310 location expression, set *LOCEXPR_LENGTH, and return a pointer
311 to the beginning of the expression. Returns NULL on failure.
313 For now, only return the first matching location expression; there
314 can be more than one in the list. */
317 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
318 size_t *locexpr_length
, CORE_ADDR pc
)
320 struct objfile
*objfile
= baton
->per_cu
->objfile ();
321 struct gdbarch
*gdbarch
= objfile
->arch ();
322 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
323 unsigned int addr_size
= baton
->per_cu
->addr_size ();
324 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
325 /* Adjust base_address for relocatable objects. */
326 CORE_ADDR base_offset
= baton
->per_cu
->text_offset ();
327 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
328 const gdb_byte
*loc_ptr
, *buf_end
;
330 loc_ptr
= baton
->data
;
331 buf_end
= baton
->data
+ baton
->size
;
335 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
337 enum debug_loc_kind kind
;
338 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
340 if (baton
->per_cu
->version () < 5 && baton
->from_dwo
)
341 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
342 loc_ptr
, buf_end
, &new_ptr
,
343 &low
, &high
, byte_order
);
344 else if (baton
->per_cu
->version () < 5)
345 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
347 byte_order
, addr_size
,
350 kind
= decode_debug_loclists_addresses (baton
->per_cu
,
351 loc_ptr
, buf_end
, &new_ptr
,
352 &low
, &high
, byte_order
,
353 addr_size
, signed_addr_p
);
358 case DEBUG_LOC_END_OF_LIST
:
361 case DEBUG_LOC_BASE_ADDRESS
:
362 base_address
= high
+ base_offset
;
364 case DEBUG_LOC_START_END
:
365 case DEBUG_LOC_START_LENGTH
:
366 case DEBUG_LOC_OFFSET_PAIR
:
368 case DEBUG_LOC_BUFFER_OVERFLOW
:
369 case DEBUG_LOC_INVALID_ENTRY
:
370 error (_("dwarf2_find_location_expression: "
371 "Corrupted DWARF expression."));
373 gdb_assert_not_reached ("bad debug_loc_kind");
376 /* Otherwise, a location expression entry.
377 If the entry is from a DWO, don't add base address: the entry is from
378 .debug_addr which already has the DWARF "base address". We still add
379 base_offset in case we're debugging a PIE executable. However, if the
380 entry is DW_LLE_offset_pair from a DWO, add the base address as the
381 operands are offsets relative to the applicable base address. */
382 if (baton
->from_dwo
&& kind
!= DEBUG_LOC_OFFSET_PAIR
)
390 high
+= base_address
;
393 if (baton
->per_cu
->version () < 5)
395 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
400 unsigned int bytes_read
;
402 length
= read_unsigned_leb128 (NULL
, loc_ptr
, &bytes_read
);
403 loc_ptr
+= bytes_read
;
406 if (low
== high
&& pc
== low
)
408 /* This is entry PC record present only at entry point
409 of a function. Verify it is really the function entry point. */
411 const struct block
*pc_block
= block_for_pc (pc
);
412 struct symbol
*pc_func
= NULL
;
415 pc_func
= block_linkage_function (pc_block
);
417 if (pc_func
&& pc
== BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (pc_func
)))
419 *locexpr_length
= length
;
424 if (pc
>= low
&& pc
< high
)
426 *locexpr_length
= length
;
434 /* Implement find_frame_base_location method for LOC_BLOCK functions using
435 DWARF expression for its DW_AT_frame_base. */
438 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
439 const gdb_byte
**start
, size_t *length
)
441 struct dwarf2_locexpr_baton
*symbaton
442 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
444 *length
= symbaton
->size
;
445 *start
= symbaton
->data
;
448 /* Implement the struct symbol_block_ops::get_frame_base method for
449 LOC_BLOCK functions using a DWARF expression as its DW_AT_frame_base. */
452 locexpr_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
454 struct gdbarch
*gdbarch
;
456 struct dwarf2_locexpr_baton
*dlbaton
;
457 const gdb_byte
*start
;
459 struct value
*result
;
461 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
462 Thus, it's supposed to provide the find_frame_base_location method as
464 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
466 gdbarch
= get_frame_arch (frame
);
467 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
468 dlbaton
= (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
470 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
471 (framefunc
, get_frame_pc (frame
), &start
, &length
);
472 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
475 /* The DW_AT_frame_base attribute contains a location description which
476 computes the base address itself. However, the call to
477 dwarf2_evaluate_loc_desc returns a value representing a variable at
478 that address. The frame base address is thus this variable's
480 return value_address (result
);
483 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
484 function uses DWARF expression for its DW_AT_frame_base. */
486 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
488 locexpr_find_frame_base_location
,
489 locexpr_get_frame_base
492 /* Implement find_frame_base_location method for LOC_BLOCK functions using
493 DWARF location list for its DW_AT_frame_base. */
496 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
497 const gdb_byte
**start
, size_t *length
)
499 struct dwarf2_loclist_baton
*symbaton
500 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
502 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
505 /* Implement the struct symbol_block_ops::get_frame_base method for
506 LOC_BLOCK functions using a DWARF location list as its DW_AT_frame_base. */
509 loclist_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
511 struct gdbarch
*gdbarch
;
513 struct dwarf2_loclist_baton
*dlbaton
;
514 const gdb_byte
*start
;
516 struct value
*result
;
518 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
519 Thus, it's supposed to provide the find_frame_base_location method as
521 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
523 gdbarch
= get_frame_arch (frame
);
524 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
525 dlbaton
= (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
527 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
528 (framefunc
, get_frame_pc (frame
), &start
, &length
);
529 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
532 /* The DW_AT_frame_base attribute contains a location description which
533 computes the base address itself. However, the call to
534 dwarf2_evaluate_loc_desc returns a value representing a variable at
535 that address. The frame base address is thus this variable's
537 return value_address (result
);
540 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
541 function uses DWARF location list for its DW_AT_frame_base. */
543 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
545 loclist_find_frame_base_location
,
546 loclist_get_frame_base
549 /* See dwarf2loc.h. */
552 func_get_frame_base_dwarf_block (struct symbol
*framefunc
, CORE_ADDR pc
,
553 const gdb_byte
**start
, size_t *length
)
555 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
557 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
559 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
565 error (_("Could not find the frame base for \"%s\"."),
566 framefunc
->natural_name ());
570 get_frame_pc_for_per_cu_dwarf_call (void *baton
)
572 dwarf_expr_context
*ctx
= (dwarf_expr_context
*) baton
;
574 return ctx
->get_frame_pc ();
578 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
579 struct dwarf2_per_cu_data
*per_cu
)
581 struct dwarf2_locexpr_baton block
;
583 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
,
584 get_frame_pc_for_per_cu_dwarf_call
,
587 /* DW_OP_call_ref is currently not supported. */
588 gdb_assert (block
.per_cu
== per_cu
);
590 ctx
->eval (block
.data
, block
.size
);
593 /* Given context CTX, section offset SECT_OFF, and compilation unit
594 data PER_CU, execute the "variable value" operation on the DIE
595 found at SECT_OFF. */
597 static struct value
*
598 sect_variable_value (struct dwarf_expr_context
*ctx
, sect_offset sect_off
,
599 struct dwarf2_per_cu_data
*per_cu
)
601 struct type
*die_type
= dwarf2_fetch_die_type_sect_off (sect_off
, per_cu
);
603 if (die_type
== NULL
)
604 error (_("Bad DW_OP_GNU_variable_value DIE."));
606 /* Note: Things still work when the following test is removed. This
607 test and error is here to conform to the proposed specification. */
608 if (TYPE_CODE (die_type
) != TYPE_CODE_INT
609 && TYPE_CODE (die_type
) != TYPE_CODE_PTR
)
610 error (_("Type of DW_OP_GNU_variable_value DIE must be an integer or pointer."));
612 struct type
*type
= lookup_pointer_type (die_type
);
613 struct frame_info
*frame
= get_selected_frame (_("No frame selected."));
614 return indirect_synthetic_pointer (sect_off
, 0, per_cu
, frame
, type
, true);
617 class dwarf_evaluate_loc_desc
: public dwarf_expr_context
621 struct frame_info
*frame
;
622 struct dwarf2_per_cu_data
*per_cu
;
623 CORE_ADDR obj_address
;
625 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
626 the frame in BATON. */
628 CORE_ADDR
get_frame_cfa () override
630 return dwarf2_frame_cfa (frame
);
633 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
634 the frame in BATON. */
636 CORE_ADDR
get_frame_pc () override
638 return get_frame_address_in_block (frame
);
641 /* Using the objfile specified in BATON, find the address for the
642 current thread's thread-local storage with offset OFFSET. */
643 CORE_ADDR
get_tls_address (CORE_ADDR offset
) override
645 struct objfile
*objfile
= per_cu
->objfile ();
647 return target_translate_tls_address (objfile
, offset
);
650 /* Helper interface of per_cu_dwarf_call for
651 dwarf2_evaluate_loc_desc. */
653 void dwarf_call (cu_offset die_offset
) override
655 per_cu_dwarf_call (this, die_offset
, per_cu
);
658 /* Helper interface of sect_variable_value for
659 dwarf2_evaluate_loc_desc. */
661 struct value
*dwarf_variable_value (sect_offset sect_off
) override
663 return sect_variable_value (this, sect_off
, per_cu
);
666 struct type
*get_base_type (cu_offset die_offset
, int size
) override
668 struct type
*result
= dwarf2_get_die_type (die_offset
, per_cu
);
670 error (_("Could not find type for DW_OP_const_type"));
671 if (size
!= 0 && TYPE_LENGTH (result
) != size
)
672 error (_("DW_OP_const_type has different sizes for type and data"));
676 /* Callback function for dwarf2_evaluate_loc_desc.
677 Fetch the address indexed by DW_OP_addrx or DW_OP_GNU_addr_index. */
679 CORE_ADDR
get_addr_index (unsigned int index
) override
681 return dwarf2_read_addr_index (per_cu
, index
);
684 /* Callback function for get_object_address. Return the address of the VLA
687 CORE_ADDR
get_object_address () override
689 if (obj_address
== 0)
690 error (_("Location address is not set."));
694 /* Execute DWARF block of call_site_parameter which matches KIND and
695 KIND_U. Choose DEREF_SIZE value of that parameter. Search
696 caller of this objects's frame.
698 The caller can be from a different CU - per_cu_dwarf_call
699 implementation can be more simple as it does not support cross-CU
702 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
703 union call_site_parameter_u kind_u
,
704 int deref_size
) override
706 struct frame_info
*caller_frame
;
707 struct dwarf2_per_cu_data
*caller_per_cu
;
708 struct call_site_parameter
*parameter
;
709 const gdb_byte
*data_src
;
712 caller_frame
= get_prev_frame (frame
);
714 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
716 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
717 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
719 /* DEREF_SIZE size is not verified here. */
720 if (data_src
== NULL
)
721 throw_error (NO_ENTRY_VALUE_ERROR
,
722 _("Cannot resolve DW_AT_call_data_value"));
724 scoped_restore save_frame
= make_scoped_restore (&this->frame
,
726 scoped_restore save_per_cu
= make_scoped_restore (&this->per_cu
,
728 scoped_restore save_obj_addr
= make_scoped_restore (&this->obj_address
,
731 scoped_restore save_arch
= make_scoped_restore (&this->gdbarch
);
732 this->gdbarch
= per_cu
->objfile ()->arch ();
733 scoped_restore save_addr_size
= make_scoped_restore (&this->addr_size
);
734 this->addr_size
= per_cu
->addr_size ();
735 scoped_restore save_offset
= make_scoped_restore (&this->offset
);
736 this->offset
= per_cu
->text_offset ();
738 this->eval (data_src
, size
);
741 /* Using the frame specified in BATON, find the location expression
742 describing the frame base. Return a pointer to it in START and
743 its length in LENGTH. */
744 void get_frame_base (const gdb_byte
**start
, size_t * length
) override
746 /* FIXME: cagney/2003-03-26: This code should be using
747 get_frame_base_address(), and then implement a dwarf2 specific
749 struct symbol
*framefunc
;
750 const struct block
*bl
= get_frame_block (frame
, NULL
);
753 error (_("frame address is not available."));
755 /* Use block_linkage_function, which returns a real (not inlined)
756 function, instead of get_frame_function, which may return an
758 framefunc
= block_linkage_function (bl
);
760 /* If we found a frame-relative symbol then it was certainly within
761 some function associated with a frame. If we can't find the frame,
762 something has gone wrong. */
763 gdb_assert (framefunc
!= NULL
);
765 func_get_frame_base_dwarf_block (framefunc
,
766 get_frame_address_in_block (frame
),
770 /* Read memory at ADDR (length LEN) into BUF. */
772 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
774 read_memory (addr
, buf
, len
);
777 /* Using the frame specified in BATON, return the value of register
778 REGNUM, treated as a pointer. */
779 CORE_ADDR
read_addr_from_reg (int dwarf_regnum
) override
781 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
782 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
784 return address_from_register (regnum
, frame
);
787 /* Implement "get_reg_value" callback. */
789 struct value
*get_reg_value (struct type
*type
, int dwarf_regnum
) override
791 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
792 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
794 return value_from_register (type
, regnum
, frame
);
798 /* See dwarf2loc.h. */
800 unsigned int entry_values_debug
= 0;
802 /* Helper to set entry_values_debug. */
805 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
806 struct cmd_list_element
*c
, const char *value
)
808 fprintf_filtered (file
,
809 _("Entry values and tail call frames debugging is %s.\n"),
813 /* Find DW_TAG_call_site's DW_AT_call_target address.
814 CALLER_FRAME (for registers) can be NULL if it is not known. This function
815 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
818 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
819 struct call_site
*call_site
,
820 struct frame_info
*caller_frame
)
822 switch (FIELD_LOC_KIND (call_site
->target
))
824 case FIELD_LOC_KIND_DWARF_BLOCK
:
826 struct dwarf2_locexpr_baton
*dwarf_block
;
828 struct type
*caller_core_addr_type
;
829 struct gdbarch
*caller_arch
;
831 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
832 if (dwarf_block
== NULL
)
834 struct bound_minimal_symbol msym
;
836 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
837 throw_error (NO_ENTRY_VALUE_ERROR
,
838 _("DW_AT_call_target is not specified at %s in %s"),
839 paddress (call_site_gdbarch
, call_site
->pc
),
840 (msym
.minsym
== NULL
? "???"
841 : msym
.minsym
->print_name ()));
844 if (caller_frame
== NULL
)
846 struct bound_minimal_symbol msym
;
848 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
849 throw_error (NO_ENTRY_VALUE_ERROR
,
850 _("DW_AT_call_target DWARF block resolving "
851 "requires known frame which is currently not "
852 "available at %s in %s"),
853 paddress (call_site_gdbarch
, call_site
->pc
),
854 (msym
.minsym
== NULL
? "???"
855 : msym
.minsym
->print_name ()));
858 caller_arch
= get_frame_arch (caller_frame
);
859 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
860 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
861 dwarf_block
->data
, dwarf_block
->size
,
862 dwarf_block
->per_cu
);
863 /* DW_AT_call_target is a DWARF expression, not a DWARF location. */
864 if (VALUE_LVAL (val
) == lval_memory
)
865 return value_address (val
);
867 return value_as_address (val
);
870 case FIELD_LOC_KIND_PHYSNAME
:
872 const char *physname
;
873 struct bound_minimal_symbol msym
;
875 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
877 /* Handle both the mangled and demangled PHYSNAME. */
878 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
879 if (msym
.minsym
== NULL
)
881 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
882 throw_error (NO_ENTRY_VALUE_ERROR
,
883 _("Cannot find function \"%s\" for a call site target "
885 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
886 (msym
.minsym
== NULL
? "???"
887 : msym
.minsym
->print_name ()));
890 return BMSYMBOL_VALUE_ADDRESS (msym
);
893 case FIELD_LOC_KIND_PHYSADDR
:
894 return FIELD_STATIC_PHYSADDR (call_site
->target
);
897 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
901 /* Convert function entry point exact address ADDR to the function which is
902 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
903 NO_ENTRY_VALUE_ERROR otherwise. */
905 static struct symbol
*
906 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
908 struct symbol
*sym
= find_pc_function (addr
);
911 if (sym
== NULL
|| BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
912 throw_error (NO_ENTRY_VALUE_ERROR
,
913 _("DW_TAG_call_site resolving failed to find function "
914 "name for address %s"),
915 paddress (gdbarch
, addr
));
917 type
= SYMBOL_TYPE (sym
);
918 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
919 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
924 /* Verify function with entry point exact address ADDR can never call itself
925 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
926 can call itself via tail calls.
928 If a funtion can tail call itself its entry value based parameters are
929 unreliable. There is no verification whether the value of some/all
930 parameters is unchanged through the self tail call, we expect if there is
931 a self tail call all the parameters can be modified. */
934 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
938 /* The verification is completely unordered. Track here function addresses
939 which still need to be iterated. */
940 std::vector
<CORE_ADDR
> todo
;
942 /* Track here CORE_ADDRs which were already visited. */
943 std::unordered_set
<CORE_ADDR
> addr_hash
;
945 todo
.push_back (verify_addr
);
946 while (!todo
.empty ())
948 struct symbol
*func_sym
;
949 struct call_site
*call_site
;
954 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
956 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
957 call_site
; call_site
= call_site
->tail_call_next
)
959 CORE_ADDR target_addr
;
961 /* CALLER_FRAME with registers is not available for tail-call jumped
963 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
965 if (target_addr
== verify_addr
)
967 struct bound_minimal_symbol msym
;
969 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
970 throw_error (NO_ENTRY_VALUE_ERROR
,
971 _("DW_OP_entry_value resolving has found "
972 "function \"%s\" at %s can call itself via tail "
974 (msym
.minsym
== NULL
? "???"
975 : msym
.minsym
->print_name ()),
976 paddress (gdbarch
, verify_addr
));
979 if (addr_hash
.insert (target_addr
).second
)
980 todo
.push_back (target_addr
);
985 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
986 ENTRY_VALUES_DEBUG. */
989 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
991 CORE_ADDR addr
= call_site
->pc
;
992 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
994 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
995 (msym
.minsym
== NULL
? "???"
996 : msym
.minsym
->print_name ()));
1000 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
1001 only top callers and bottom callees which are present in both. GDBARCH is
1002 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
1003 no remaining possibilities to provide unambiguous non-trivial result.
1004 RESULTP should point to NULL on the first (initialization) call. Caller is
1005 responsible for xfree of any RESULTP data. */
1008 chain_candidate (struct gdbarch
*gdbarch
,
1009 gdb::unique_xmalloc_ptr
<struct call_site_chain
> *resultp
,
1010 std::vector
<struct call_site
*> *chain
)
1012 long length
= chain
->size ();
1013 int callers
, callees
, idx
;
1015 if (*resultp
== NULL
)
1017 /* Create the initial chain containing all the passed PCs. */
1019 struct call_site_chain
*result
1020 = ((struct call_site_chain
*)
1021 xmalloc (sizeof (*result
)
1022 + sizeof (*result
->call_site
) * (length
- 1)));
1023 result
->length
= length
;
1024 result
->callers
= result
->callees
= length
;
1025 if (!chain
->empty ())
1026 memcpy (result
->call_site
, chain
->data (),
1027 sizeof (*result
->call_site
) * length
);
1028 resultp
->reset (result
);
1030 if (entry_values_debug
)
1032 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
1033 for (idx
= 0; idx
< length
; idx
++)
1034 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
1035 fputc_unfiltered ('\n', gdb_stdlog
);
1041 if (entry_values_debug
)
1043 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
1044 for (idx
= 0; idx
< length
; idx
++)
1045 tailcall_dump (gdbarch
, chain
->at (idx
));
1046 fputc_unfiltered ('\n', gdb_stdlog
);
1049 /* Intersect callers. */
1051 callers
= std::min ((long) (*resultp
)->callers
, length
);
1052 for (idx
= 0; idx
< callers
; idx
++)
1053 if ((*resultp
)->call_site
[idx
] != chain
->at (idx
))
1055 (*resultp
)->callers
= idx
;
1059 /* Intersect callees. */
1061 callees
= std::min ((long) (*resultp
)->callees
, length
);
1062 for (idx
= 0; idx
< callees
; idx
++)
1063 if ((*resultp
)->call_site
[(*resultp
)->length
- 1 - idx
]
1064 != chain
->at (length
- 1 - idx
))
1066 (*resultp
)->callees
= idx
;
1070 if (entry_values_debug
)
1072 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
1073 for (idx
= 0; idx
< (*resultp
)->callers
; idx
++)
1074 tailcall_dump (gdbarch
, (*resultp
)->call_site
[idx
]);
1075 fputs_unfiltered (" |", gdb_stdlog
);
1076 for (idx
= 0; idx
< (*resultp
)->callees
; idx
++)
1077 tailcall_dump (gdbarch
,
1078 (*resultp
)->call_site
[(*resultp
)->length
1079 - (*resultp
)->callees
+ idx
]);
1080 fputc_unfiltered ('\n', gdb_stdlog
);
1083 if ((*resultp
)->callers
== 0 && (*resultp
)->callees
== 0)
1085 /* There are no common callers or callees. It could be also a direct
1086 call (which has length 0) with ambiguous possibility of an indirect
1087 call - CALLERS == CALLEES == 0 is valid during the first allocation
1088 but any subsequence processing of such entry means ambiguity. */
1089 resultp
->reset (NULL
);
1093 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
1094 PC again. In such case there must be two different code paths to reach
1095 it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
1096 gdb_assert ((*resultp
)->callers
+ (*resultp
)->callees
<= (*resultp
)->length
);
1099 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1100 assumed frames between them use GDBARCH. Use depth first search so we can
1101 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
1102 would have needless GDB stack overhead. Any unreliability results
1103 in thrown NO_ENTRY_VALUE_ERROR. */
1105 static gdb::unique_xmalloc_ptr
<call_site_chain
>
1106 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1107 CORE_ADDR callee_pc
)
1109 CORE_ADDR save_callee_pc
= callee_pc
;
1110 gdb::unique_xmalloc_ptr
<struct call_site_chain
> retval
;
1111 struct call_site
*call_site
;
1113 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
1114 call_site nor any possible call_site at CALLEE_PC's function is there.
1115 Any CALL_SITE in CHAIN will be iterated to its siblings - via
1116 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
1117 std::vector
<struct call_site
*> chain
;
1119 /* We are not interested in the specific PC inside the callee function. */
1120 callee_pc
= get_pc_function_start (callee_pc
);
1122 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
1123 paddress (gdbarch
, save_callee_pc
));
1125 /* Mark CALL_SITEs so we do not visit the same ones twice. */
1126 std::unordered_set
<CORE_ADDR
> addr_hash
;
1128 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
1129 at the target's function. All the possible tail call sites in the
1130 target's function will get iterated as already pushed into CHAIN via their
1132 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1136 CORE_ADDR target_func_addr
;
1137 struct call_site
*target_call_site
;
1139 /* CALLER_FRAME with registers is not available for tail-call jumped
1141 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
1143 if (target_func_addr
== callee_pc
)
1145 chain_candidate (gdbarch
, &retval
, &chain
);
1149 /* There is no way to reach CALLEE_PC again as we would prevent
1150 entering it twice as being already marked in ADDR_HASH. */
1151 target_call_site
= NULL
;
1155 struct symbol
*target_func
;
1157 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
1158 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
1163 /* Attempt to visit TARGET_CALL_SITE. */
1165 if (target_call_site
)
1167 if (addr_hash
.insert (target_call_site
->pc
).second
)
1169 /* Successfully entered TARGET_CALL_SITE. */
1171 chain
.push_back (target_call_site
);
1176 /* Backtrack (without revisiting the originating call_site). Try the
1177 callers's sibling; if there isn't any try the callers's callers's
1180 target_call_site
= NULL
;
1181 while (!chain
.empty ())
1183 call_site
= chain
.back ();
1186 size_t removed
= addr_hash
.erase (call_site
->pc
);
1187 gdb_assert (removed
== 1);
1189 target_call_site
= call_site
->tail_call_next
;
1190 if (target_call_site
)
1194 while (target_call_site
);
1199 call_site
= chain
.back ();
1204 struct bound_minimal_symbol msym_caller
, msym_callee
;
1206 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
1207 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
1208 throw_error (NO_ENTRY_VALUE_ERROR
,
1209 _("There are no unambiguously determinable intermediate "
1210 "callers or callees between caller function \"%s\" at %s "
1211 "and callee function \"%s\" at %s"),
1212 (msym_caller
.minsym
== NULL
1213 ? "???" : msym_caller
.minsym
->print_name ()),
1214 paddress (gdbarch
, caller_pc
),
1215 (msym_callee
.minsym
== NULL
1216 ? "???" : msym_callee
.minsym
->print_name ()),
1217 paddress (gdbarch
, callee_pc
));
1223 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1224 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
1225 constructed return NULL. */
1227 gdb::unique_xmalloc_ptr
<call_site_chain
>
1228 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1229 CORE_ADDR callee_pc
)
1231 gdb::unique_xmalloc_ptr
<call_site_chain
> retval
;
1235 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
1237 catch (const gdb_exception_error
&e
)
1239 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
1241 if (entry_values_debug
)
1242 exception_print (gdb_stdout
, e
);
1253 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1256 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1257 enum call_site_parameter_kind kind
,
1258 union call_site_parameter_u kind_u
)
1260 if (kind
== parameter
->kind
)
1263 case CALL_SITE_PARAMETER_DWARF_REG
:
1264 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1265 case CALL_SITE_PARAMETER_FB_OFFSET
:
1266 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1267 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1268 return kind_u
.param_cu_off
== parameter
->u
.param_cu_off
;
1273 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1274 FRAME is for callee.
1276 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1279 static struct call_site_parameter
*
1280 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1281 enum call_site_parameter_kind kind
,
1282 union call_site_parameter_u kind_u
,
1283 struct dwarf2_per_cu_data
**per_cu_return
)
1285 CORE_ADDR func_addr
, caller_pc
;
1286 struct gdbarch
*gdbarch
;
1287 struct frame_info
*caller_frame
;
1288 struct call_site
*call_site
;
1290 /* Initialize it just to avoid a GCC false warning. */
1291 struct call_site_parameter
*parameter
= NULL
;
1292 CORE_ADDR target_addr
;
1294 while (get_frame_type (frame
) == INLINE_FRAME
)
1296 frame
= get_prev_frame (frame
);
1297 gdb_assert (frame
!= NULL
);
1300 func_addr
= get_frame_func (frame
);
1301 gdbarch
= get_frame_arch (frame
);
1302 caller_frame
= get_prev_frame (frame
);
1303 if (gdbarch
!= frame_unwind_arch (frame
))
1305 struct bound_minimal_symbol msym
1306 = lookup_minimal_symbol_by_pc (func_addr
);
1307 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1309 throw_error (NO_ENTRY_VALUE_ERROR
,
1310 _("DW_OP_entry_value resolving callee gdbarch %s "
1311 "(of %s (%s)) does not match caller gdbarch %s"),
1312 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1313 paddress (gdbarch
, func_addr
),
1314 (msym
.minsym
== NULL
? "???"
1315 : msym
.minsym
->print_name ()),
1316 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1319 if (caller_frame
== NULL
)
1321 struct bound_minimal_symbol msym
1322 = lookup_minimal_symbol_by_pc (func_addr
);
1324 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_entry_value resolving "
1325 "requires caller of %s (%s)"),
1326 paddress (gdbarch
, func_addr
),
1327 (msym
.minsym
== NULL
? "???"
1328 : msym
.minsym
->print_name ()));
1330 caller_pc
= get_frame_pc (caller_frame
);
1331 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1333 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1334 if (target_addr
!= func_addr
)
1336 struct minimal_symbol
*target_msym
, *func_msym
;
1338 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1339 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1340 throw_error (NO_ENTRY_VALUE_ERROR
,
1341 _("DW_OP_entry_value resolving expects callee %s at %s "
1342 "but the called frame is for %s at %s"),
1343 (target_msym
== NULL
? "???"
1344 : target_msym
->print_name ()),
1345 paddress (gdbarch
, target_addr
),
1346 func_msym
== NULL
? "???" : func_msym
->print_name (),
1347 paddress (gdbarch
, func_addr
));
1350 /* No entry value based parameters would be reliable if this function can
1351 call itself via tail calls. */
1352 func_verify_no_selftailcall (gdbarch
, func_addr
);
1354 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1356 parameter
= &call_site
->parameter
[iparams
];
1357 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1360 if (iparams
== call_site
->parameter_count
)
1362 struct minimal_symbol
*msym
1363 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1365 /* DW_TAG_call_site_parameter will be missing just if GCC could not
1366 determine its value. */
1367 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1368 "at DW_TAG_call_site %s at %s"),
1369 paddress (gdbarch
, caller_pc
),
1370 msym
== NULL
? "???" : msym
->print_name ());
1373 *per_cu_return
= call_site
->per_cu
;
1377 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1378 the normal DW_AT_call_value block. Otherwise return the
1379 DW_AT_call_data_value (dereferenced) block.
1381 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1384 Function always returns non-NULL, non-optimized out value. It throws
1385 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1387 static struct value
*
1388 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1389 CORE_ADDR deref_size
, struct type
*type
,
1390 struct frame_info
*caller_frame
,
1391 struct dwarf2_per_cu_data
*per_cu
)
1393 const gdb_byte
*data_src
;
1397 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1398 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1400 /* DEREF_SIZE size is not verified here. */
1401 if (data_src
== NULL
)
1402 throw_error (NO_ENTRY_VALUE_ERROR
,
1403 _("Cannot resolve DW_AT_call_data_value"));
1405 /* DW_AT_call_value is a DWARF expression, not a DWARF
1406 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1408 data
= (gdb_byte
*) alloca (size
+ 1);
1409 memcpy (data
, data_src
, size
);
1410 data
[size
] = DW_OP_stack_value
;
1412 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1415 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1416 the indirect method on it, that is use its stored target value, the sole
1417 purpose of entry_data_value_funcs.. */
1419 static struct value
*
1420 entry_data_value_coerce_ref (const struct value
*value
)
1422 struct type
*checked_type
= check_typedef (value_type (value
));
1423 struct value
*target_val
;
1425 if (!TYPE_IS_REFERENCE (checked_type
))
1428 target_val
= (struct value
*) value_computed_closure (value
);
1429 value_incref (target_val
);
1433 /* Implement copy_closure. */
1436 entry_data_value_copy_closure (const struct value
*v
)
1438 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1440 value_incref (target_val
);
1444 /* Implement free_closure. */
1447 entry_data_value_free_closure (struct value
*v
)
1449 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1451 value_decref (target_val
);
1454 /* Vector for methods for an entry value reference where the referenced value
1455 is stored in the caller. On the first dereference use
1456 DW_AT_call_data_value in the caller. */
1458 static const struct lval_funcs entry_data_value_funcs
=
1462 NULL
, /* indirect */
1463 entry_data_value_coerce_ref
,
1464 NULL
, /* check_synthetic_pointer */
1465 entry_data_value_copy_closure
,
1466 entry_data_value_free_closure
1469 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1470 are used to match DW_AT_location at the caller's
1471 DW_TAG_call_site_parameter.
1473 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1474 cannot resolve the parameter for any reason. */
1476 static struct value
*
1477 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1478 enum call_site_parameter_kind kind
,
1479 union call_site_parameter_u kind_u
)
1481 struct type
*checked_type
= check_typedef (type
);
1482 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1483 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1484 struct value
*outer_val
, *target_val
, *val
;
1485 struct call_site_parameter
*parameter
;
1486 struct dwarf2_per_cu_data
*caller_per_cu
;
1488 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1491 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1495 /* Check if DW_AT_call_data_value cannot be used. If it should be
1496 used and it is not available do not fall back to OUTER_VAL - dereferencing
1497 TYPE_CODE_REF with non-entry data value would give current value - not the
1500 if (!TYPE_IS_REFERENCE (checked_type
)
1501 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1504 target_val
= dwarf_entry_parameter_to_value (parameter
,
1505 TYPE_LENGTH (target_type
),
1506 target_type
, caller_frame
,
1509 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1510 release_value (target_val
).release ());
1512 /* Copy the referencing pointer to the new computed value. */
1513 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1514 TYPE_LENGTH (checked_type
));
1515 set_value_lazy (val
, 0);
1520 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1521 SIZE are DWARF block used to match DW_AT_location at the caller's
1522 DW_TAG_call_site_parameter.
1524 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1525 cannot resolve the parameter for any reason. */
1527 static struct value
*
1528 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1529 const gdb_byte
*block
, size_t block_len
)
1531 union call_site_parameter_u kind_u
;
1533 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1534 if (kind_u
.dwarf_reg
!= -1)
1535 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1538 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1539 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1542 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1543 suppressed during normal operation. The expression can be arbitrary if
1544 there is no caller-callee entry value binding expected. */
1545 throw_error (NO_ENTRY_VALUE_ERROR
,
1546 _("DWARF-2 expression error: DW_OP_entry_value is supported "
1547 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1550 struct piece_closure
1552 /* Reference count. */
1555 /* The CU from which this closure's expression came. */
1556 struct dwarf2_per_cu_data
*per_cu
= NULL
;
1558 /* The pieces describing this variable. */
1559 std::vector
<dwarf_expr_piece
> pieces
;
1561 /* Frame ID of frame to which a register value is relative, used
1562 only by DWARF_VALUE_REGISTER. */
1563 struct frame_id frame_id
;
1566 /* Allocate a closure for a value formed from separately-described
1569 static struct piece_closure
*
1570 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1571 std::vector
<dwarf_expr_piece
> &&pieces
,
1572 struct frame_info
*frame
)
1574 struct piece_closure
*c
= new piece_closure
;
1578 c
->pieces
= std::move (pieces
);
1580 c
->frame_id
= null_frame_id
;
1582 c
->frame_id
= get_frame_id (frame
);
1584 for (dwarf_expr_piece
&piece
: c
->pieces
)
1585 if (piece
.location
== DWARF_VALUE_STACK
)
1586 value_incref (piece
.v
.value
);
1591 /* Return the number of bytes overlapping a contiguous chunk of N_BITS
1592 bits whose first bit is located at bit offset START. */
1595 bits_to_bytes (ULONGEST start
, ULONGEST n_bits
)
1597 return (start
% 8 + n_bits
+ 7) / 8;
1600 /* Read or write a pieced value V. If FROM != NULL, operate in "write
1601 mode": copy FROM into the pieces comprising V. If FROM == NULL,
1602 operate in "read mode": fetch the contents of the (lazy) value V by
1603 composing it from its pieces. */
1606 rw_pieced_value (struct value
*v
, struct value
*from
)
1609 LONGEST offset
= 0, max_offset
;
1610 ULONGEST bits_to_skip
;
1611 gdb_byte
*v_contents
;
1612 const gdb_byte
*from_contents
;
1613 struct piece_closure
*c
1614 = (struct piece_closure
*) value_computed_closure (v
);
1615 gdb::byte_vector buffer
;
1616 bool bits_big_endian
= type_byte_order (value_type (v
)) == BFD_ENDIAN_BIG
;
1620 from_contents
= value_contents (from
);
1625 if (value_type (v
) != value_enclosing_type (v
))
1626 internal_error (__FILE__
, __LINE__
,
1627 _("Should not be able to create a lazy value with "
1628 "an enclosing type"));
1629 v_contents
= value_contents_raw (v
);
1630 from_contents
= NULL
;
1633 bits_to_skip
= 8 * value_offset (v
);
1634 if (value_bitsize (v
))
1636 bits_to_skip
+= (8 * value_offset (value_parent (v
))
1637 + value_bitpos (v
));
1639 && (type_byte_order (value_type (from
))
1642 /* Use the least significant bits of FROM. */
1643 max_offset
= 8 * TYPE_LENGTH (value_type (from
));
1644 offset
= max_offset
- value_bitsize (v
);
1647 max_offset
= value_bitsize (v
);
1650 max_offset
= 8 * TYPE_LENGTH (value_type (v
));
1652 /* Advance to the first non-skipped piece. */
1653 for (i
= 0; i
< c
->pieces
.size () && bits_to_skip
>= c
->pieces
[i
].size
; i
++)
1654 bits_to_skip
-= c
->pieces
[i
].size
;
1656 for (; i
< c
->pieces
.size () && offset
< max_offset
; i
++)
1658 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1659 size_t this_size_bits
, this_size
;
1661 this_size_bits
= p
->size
- bits_to_skip
;
1662 if (this_size_bits
> max_offset
- offset
)
1663 this_size_bits
= max_offset
- offset
;
1665 switch (p
->location
)
1667 case DWARF_VALUE_REGISTER
:
1669 struct frame_info
*frame
= frame_find_by_id (c
->frame_id
);
1670 struct gdbarch
*arch
= get_frame_arch (frame
);
1671 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, p
->v
.regno
);
1672 ULONGEST reg_bits
= 8 * register_size (arch
, gdb_regnum
);
1675 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1676 && p
->offset
+ p
->size
< reg_bits
)
1678 /* Big-endian, and we want less than full size. */
1679 bits_to_skip
+= reg_bits
- (p
->offset
+ p
->size
);
1682 bits_to_skip
+= p
->offset
;
1684 this_size
= bits_to_bytes (bits_to_skip
, this_size_bits
);
1685 buffer
.resize (this_size
);
1690 if (!get_frame_register_bytes (frame
, gdb_regnum
,
1692 this_size
, buffer
.data (),
1696 mark_value_bits_optimized_out (v
, offset
,
1699 mark_value_bits_unavailable (v
, offset
,
1704 copy_bitwise (v_contents
, offset
,
1705 buffer
.data (), bits_to_skip
% 8,
1706 this_size_bits
, bits_big_endian
);
1711 if (bits_to_skip
% 8 != 0 || this_size_bits
% 8 != 0)
1713 /* Data is copied non-byte-aligned into the register.
1714 Need some bits from original register value. */
1715 get_frame_register_bytes (frame
, gdb_regnum
,
1717 this_size
, buffer
.data (),
1720 throw_error (OPTIMIZED_OUT_ERROR
,
1721 _("Can't do read-modify-write to "
1722 "update bitfield; containing word "
1723 "has been optimized out"));
1725 throw_error (NOT_AVAILABLE_ERROR
,
1726 _("Can't do read-modify-write to "
1727 "update bitfield; containing word "
1731 copy_bitwise (buffer
.data (), bits_to_skip
% 8,
1732 from_contents
, offset
,
1733 this_size_bits
, bits_big_endian
);
1734 put_frame_register_bytes (frame
, gdb_regnum
,
1736 this_size
, buffer
.data ());
1741 case DWARF_VALUE_MEMORY
:
1743 bits_to_skip
+= p
->offset
;
1745 CORE_ADDR start_addr
= p
->v
.mem
.addr
+ bits_to_skip
/ 8;
1747 if (bits_to_skip
% 8 == 0 && this_size_bits
% 8 == 0
1750 /* Everything is byte-aligned; no buffer needed. */
1752 write_memory_with_notification (start_addr
,
1755 this_size_bits
/ 8);
1757 read_value_memory (v
, offset
,
1758 p
->v
.mem
.in_stack_memory
,
1759 p
->v
.mem
.addr
+ bits_to_skip
/ 8,
1760 v_contents
+ offset
/ 8,
1761 this_size_bits
/ 8);
1765 this_size
= bits_to_bytes (bits_to_skip
, this_size_bits
);
1766 buffer
.resize (this_size
);
1771 read_value_memory (v
, offset
,
1772 p
->v
.mem
.in_stack_memory
,
1773 p
->v
.mem
.addr
+ bits_to_skip
/ 8,
1774 buffer
.data (), this_size
);
1775 copy_bitwise (v_contents
, offset
,
1776 buffer
.data (), bits_to_skip
% 8,
1777 this_size_bits
, bits_big_endian
);
1782 if (bits_to_skip
% 8 != 0 || this_size_bits
% 8 != 0)
1786 /* Perform a single read for small sizes. */
1787 read_memory (start_addr
, buffer
.data (),
1792 /* Only the first and last bytes can possibly have
1794 read_memory (start_addr
, buffer
.data (), 1);
1795 read_memory (start_addr
+ this_size
- 1,
1796 &buffer
[this_size
- 1], 1);
1800 copy_bitwise (buffer
.data (), bits_to_skip
% 8,
1801 from_contents
, offset
,
1802 this_size_bits
, bits_big_endian
);
1803 write_memory_with_notification (start_addr
,
1810 case DWARF_VALUE_STACK
:
1814 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1818 struct objfile
*objfile
= c
->per_cu
->objfile ();
1819 struct gdbarch
*objfile_gdbarch
= objfile
->arch ();
1820 ULONGEST stack_value_size_bits
1821 = 8 * TYPE_LENGTH (value_type (p
->v
.value
));
1823 /* Use zeroes if piece reaches beyond stack value. */
1824 if (p
->offset
+ p
->size
> stack_value_size_bits
)
1827 /* Piece is anchored at least significant bit end. */
1828 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
1829 bits_to_skip
+= stack_value_size_bits
- p
->offset
- p
->size
;
1831 bits_to_skip
+= p
->offset
;
1833 copy_bitwise (v_contents
, offset
,
1834 value_contents_all (p
->v
.value
),
1836 this_size_bits
, bits_big_endian
);
1840 case DWARF_VALUE_LITERAL
:
1844 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1848 ULONGEST literal_size_bits
= 8 * p
->v
.literal
.length
;
1849 size_t n
= this_size_bits
;
1851 /* Cut off at the end of the implicit value. */
1852 bits_to_skip
+= p
->offset
;
1853 if (bits_to_skip
>= literal_size_bits
)
1855 if (n
> literal_size_bits
- bits_to_skip
)
1856 n
= literal_size_bits
- bits_to_skip
;
1858 copy_bitwise (v_contents
, offset
,
1859 p
->v
.literal
.data
, bits_to_skip
,
1860 n
, bits_big_endian
);
1864 case DWARF_VALUE_IMPLICIT_POINTER
:
1867 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1871 /* These bits show up as zeros -- but do not cause the value to
1872 be considered optimized-out. */
1875 case DWARF_VALUE_OPTIMIZED_OUT
:
1876 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1880 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1883 offset
+= this_size_bits
;
1890 read_pieced_value (struct value
*v
)
1892 rw_pieced_value (v
, NULL
);
1896 write_pieced_value (struct value
*to
, struct value
*from
)
1898 rw_pieced_value (to
, from
);
1901 /* An implementation of an lval_funcs method to see whether a value is
1902 a synthetic pointer. */
1905 check_pieced_synthetic_pointer (const struct value
*value
, LONGEST bit_offset
,
1908 struct piece_closure
*c
1909 = (struct piece_closure
*) value_computed_closure (value
);
1912 bit_offset
+= 8 * value_offset (value
);
1913 if (value_bitsize (value
))
1914 bit_offset
+= value_bitpos (value
);
1916 for (i
= 0; i
< c
->pieces
.size () && bit_length
> 0; i
++)
1918 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1919 size_t this_size_bits
= p
->size
;
1923 if (bit_offset
>= this_size_bits
)
1925 bit_offset
-= this_size_bits
;
1929 bit_length
-= this_size_bits
- bit_offset
;
1933 bit_length
-= this_size_bits
;
1935 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1942 /* A wrapper function for get_frame_address_in_block. */
1945 get_frame_address_in_block_wrapper (void *baton
)
1947 return get_frame_address_in_block ((struct frame_info
*) baton
);
1950 /* Fetch a DW_AT_const_value through a synthetic pointer. */
1952 static struct value
*
1953 fetch_const_value_from_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
1954 struct dwarf2_per_cu_data
*per_cu
,
1957 struct value
*result
= NULL
;
1958 const gdb_byte
*bytes
;
1961 auto_obstack temp_obstack
;
1962 bytes
= dwarf2_fetch_constant_bytes (die
, per_cu
, &temp_obstack
, &len
);
1966 if (byte_offset
>= 0
1967 && byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) <= len
)
1969 bytes
+= byte_offset
;
1970 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
1973 invalid_synthetic_pointer ();
1976 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
1981 /* Fetch the value pointed to by a synthetic pointer. */
1983 static struct value
*
1984 indirect_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
1985 struct dwarf2_per_cu_data
*per_cu
,
1986 struct frame_info
*frame
, struct type
*type
,
1987 bool resolve_abstract_p
)
1989 /* Fetch the location expression of the DIE we're pointing to. */
1990 struct dwarf2_locexpr_baton baton
1991 = dwarf2_fetch_die_loc_sect_off (die
, per_cu
,
1992 get_frame_address_in_block_wrapper
, frame
,
1993 resolve_abstract_p
);
1995 /* Get type of pointed-to DIE. */
1996 struct type
*orig_type
= dwarf2_fetch_die_type_sect_off (die
, per_cu
);
1997 if (orig_type
== NULL
)
1998 invalid_synthetic_pointer ();
2000 /* If pointed-to DIE has a DW_AT_location, evaluate it and return the
2001 resulting value. Otherwise, it may have a DW_AT_const_value instead,
2002 or it may've been optimized out. */
2003 if (baton
.data
!= NULL
)
2004 return dwarf2_evaluate_loc_desc_full (orig_type
, frame
, baton
.data
,
2005 baton
.size
, baton
.per_cu
,
2006 TYPE_TARGET_TYPE (type
),
2009 return fetch_const_value_from_synthetic_pointer (die
, byte_offset
, per_cu
,
2013 /* An implementation of an lval_funcs method to indirect through a
2014 pointer. This handles the synthetic pointer case when needed. */
2016 static struct value
*
2017 indirect_pieced_value (struct value
*value
)
2019 struct piece_closure
*c
2020 = (struct piece_closure
*) value_computed_closure (value
);
2022 struct frame_info
*frame
;
2025 struct dwarf_expr_piece
*piece
= NULL
;
2026 LONGEST byte_offset
;
2027 enum bfd_endian byte_order
;
2029 type
= check_typedef (value_type (value
));
2030 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
2033 bit_length
= 8 * TYPE_LENGTH (type
);
2034 bit_offset
= 8 * value_offset (value
);
2035 if (value_bitsize (value
))
2036 bit_offset
+= value_bitpos (value
);
2038 for (i
= 0; i
< c
->pieces
.size () && bit_length
> 0; i
++)
2040 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2041 size_t this_size_bits
= p
->size
;
2045 if (bit_offset
>= this_size_bits
)
2047 bit_offset
-= this_size_bits
;
2051 bit_length
-= this_size_bits
- bit_offset
;
2055 bit_length
-= this_size_bits
;
2057 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2060 if (bit_length
!= 0)
2061 error (_("Invalid use of DW_OP_implicit_pointer"));
2067 gdb_assert (piece
!= NULL
);
2068 frame
= get_selected_frame (_("No frame selected."));
2070 /* This is an offset requested by GDB, such as value subscripts.
2071 However, due to how synthetic pointers are implemented, this is
2072 always presented to us as a pointer type. This means we have to
2073 sign-extend it manually as appropriate. Use raw
2074 extract_signed_integer directly rather than value_as_address and
2075 sign extend afterwards on architectures that would need it
2076 (mostly everywhere except MIPS, which has signed addresses) as
2077 the later would go through gdbarch_pointer_to_address and thus
2078 return a CORE_ADDR with high bits set on architectures that
2079 encode address spaces and other things in CORE_ADDR. */
2080 byte_order
= gdbarch_byte_order (get_frame_arch (frame
));
2081 byte_offset
= extract_signed_integer (value_contents (value
),
2082 TYPE_LENGTH (type
), byte_order
);
2083 byte_offset
+= piece
->v
.ptr
.offset
;
2085 return indirect_synthetic_pointer (piece
->v
.ptr
.die_sect_off
,
2086 byte_offset
, c
->per_cu
,
2090 /* Implementation of the coerce_ref method of lval_funcs for synthetic C++
2093 static struct value
*
2094 coerce_pieced_ref (const struct value
*value
)
2096 struct type
*type
= check_typedef (value_type (value
));
2098 if (value_bits_synthetic_pointer (value
, value_embedded_offset (value
),
2099 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
2101 const struct piece_closure
*closure
2102 = (struct piece_closure
*) value_computed_closure (value
);
2103 struct frame_info
*frame
2104 = get_selected_frame (_("No frame selected."));
2106 /* gdb represents synthetic pointers as pieced values with a single
2108 gdb_assert (closure
!= NULL
);
2109 gdb_assert (closure
->pieces
.size () == 1);
2111 return indirect_synthetic_pointer
2112 (closure
->pieces
[0].v
.ptr
.die_sect_off
,
2113 closure
->pieces
[0].v
.ptr
.offset
,
2114 closure
->per_cu
, frame
, type
);
2118 /* Else: not a synthetic reference; do nothing. */
2124 copy_pieced_value_closure (const struct value
*v
)
2126 struct piece_closure
*c
2127 = (struct piece_closure
*) value_computed_closure (v
);
2134 free_pieced_value_closure (struct value
*v
)
2136 struct piece_closure
*c
2137 = (struct piece_closure
*) value_computed_closure (v
);
2142 for (dwarf_expr_piece
&p
: c
->pieces
)
2143 if (p
.location
== DWARF_VALUE_STACK
)
2144 value_decref (p
.v
.value
);
2150 /* Functions for accessing a variable described by DW_OP_piece. */
2151 static const struct lval_funcs pieced_value_funcs
= {
2154 indirect_pieced_value
,
2156 check_pieced_synthetic_pointer
,
2157 copy_pieced_value_closure
,
2158 free_pieced_value_closure
2161 /* Evaluate a location description, starting at DATA and with length
2162 SIZE, to find the current location of variable of TYPE in the
2163 context of FRAME. If SUBOBJ_TYPE is non-NULL, return instead the
2164 location of the subobject of type SUBOBJ_TYPE at byte offset
2165 SUBOBJ_BYTE_OFFSET within the variable of type TYPE. */
2167 static struct value
*
2168 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2169 const gdb_byte
*data
, size_t size
,
2170 struct dwarf2_per_cu_data
*per_cu
,
2171 struct type
*subobj_type
,
2172 LONGEST subobj_byte_offset
)
2174 struct value
*retval
;
2175 struct objfile
*objfile
= per_cu
->objfile ();
2177 if (subobj_type
== NULL
)
2180 subobj_byte_offset
= 0;
2182 else if (subobj_byte_offset
< 0)
2183 invalid_synthetic_pointer ();
2186 return allocate_optimized_out_value (subobj_type
);
2188 dwarf_evaluate_loc_desc ctx
;
2190 ctx
.per_cu
= per_cu
;
2191 ctx
.obj_address
= 0;
2193 scoped_value_mark free_values
;
2195 ctx
.gdbarch
= objfile
->arch ();
2196 ctx
.addr_size
= per_cu
->addr_size ();
2197 ctx
.ref_addr_size
= per_cu
->ref_addr_size ();
2198 ctx
.offset
= per_cu
->text_offset ();
2202 ctx
.eval (data
, size
);
2204 catch (const gdb_exception_error
&ex
)
2206 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2208 free_values
.free_to_mark ();
2209 retval
= allocate_value (subobj_type
);
2210 mark_value_bytes_unavailable (retval
, 0,
2211 TYPE_LENGTH (subobj_type
));
2214 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2216 if (entry_values_debug
)
2217 exception_print (gdb_stdout
, ex
);
2218 free_values
.free_to_mark ();
2219 return allocate_optimized_out_value (subobj_type
);
2225 if (ctx
.pieces
.size () > 0)
2227 struct piece_closure
*c
;
2228 ULONGEST bit_size
= 0;
2230 for (dwarf_expr_piece
&piece
: ctx
.pieces
)
2231 bit_size
+= piece
.size
;
2232 /* Complain if the expression is larger than the size of the
2234 if (bit_size
> 8 * TYPE_LENGTH (type
))
2235 invalid_synthetic_pointer ();
2237 c
= allocate_piece_closure (per_cu
, std::move (ctx
.pieces
), frame
);
2238 /* We must clean up the value chain after creating the piece
2239 closure but before allocating the result. */
2240 free_values
.free_to_mark ();
2241 retval
= allocate_computed_value (subobj_type
,
2242 &pieced_value_funcs
, c
);
2243 set_value_offset (retval
, subobj_byte_offset
);
2247 switch (ctx
.location
)
2249 case DWARF_VALUE_REGISTER
:
2251 struct gdbarch
*arch
= get_frame_arch (frame
);
2253 = longest_to_int (value_as_long (ctx
.fetch (0)));
2254 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, dwarf_regnum
);
2256 if (subobj_byte_offset
!= 0)
2257 error (_("cannot use offset on synthetic pointer to register"));
2258 free_values
.free_to_mark ();
2259 retval
= value_from_register (subobj_type
, gdb_regnum
, frame
);
2260 if (value_optimized_out (retval
))
2264 /* This means the register has undefined value / was
2265 not saved. As we're computing the location of some
2266 variable etc. in the program, not a value for
2267 inspecting a register ($pc, $sp, etc.), return a
2268 generic optimized out value instead, so that we show
2269 <optimized out> instead of <not saved>. */
2270 tmp
= allocate_value (subobj_type
);
2271 value_contents_copy (tmp
, 0, retval
, 0,
2272 TYPE_LENGTH (subobj_type
));
2278 case DWARF_VALUE_MEMORY
:
2280 struct type
*ptr_type
;
2281 CORE_ADDR address
= ctx
.fetch_address (0);
2282 bool in_stack_memory
= ctx
.fetch_in_stack_memory (0);
2284 /* DW_OP_deref_size (and possibly other operations too) may
2285 create a pointer instead of an address. Ideally, the
2286 pointer to address conversion would be performed as part
2287 of those operations, but the type of the object to
2288 which the address refers is not known at the time of
2289 the operation. Therefore, we do the conversion here
2290 since the type is readily available. */
2292 switch (TYPE_CODE (subobj_type
))
2294 case TYPE_CODE_FUNC
:
2295 case TYPE_CODE_METHOD
:
2296 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_func_ptr
;
2299 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_data_ptr
;
2302 address
= value_as_address (value_from_pointer (ptr_type
, address
));
2304 free_values
.free_to_mark ();
2305 retval
= value_at_lazy (subobj_type
,
2306 address
+ subobj_byte_offset
);
2307 if (in_stack_memory
)
2308 set_value_stack (retval
, 1);
2312 case DWARF_VALUE_STACK
:
2314 struct value
*value
= ctx
.fetch (0);
2315 size_t n
= TYPE_LENGTH (value_type (value
));
2316 size_t len
= TYPE_LENGTH (subobj_type
);
2317 size_t max
= TYPE_LENGTH (type
);
2318 struct gdbarch
*objfile_gdbarch
= objfile
->arch ();
2320 if (subobj_byte_offset
+ len
> max
)
2321 invalid_synthetic_pointer ();
2323 /* Preserve VALUE because we are going to free values back
2324 to the mark, but we still need the value contents
2326 value_ref_ptr value_holder
= value_ref_ptr::new_reference (value
);
2327 free_values
.free_to_mark ();
2329 retval
= allocate_value (subobj_type
);
2331 /* The given offset is relative to the actual object. */
2332 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2333 subobj_byte_offset
+= n
- max
;
2335 memcpy (value_contents_raw (retval
),
2336 value_contents_all (value
) + subobj_byte_offset
, len
);
2340 case DWARF_VALUE_LITERAL
:
2343 size_t n
= TYPE_LENGTH (subobj_type
);
2345 if (subobj_byte_offset
+ n
> ctx
.len
)
2346 invalid_synthetic_pointer ();
2348 free_values
.free_to_mark ();
2349 retval
= allocate_value (subobj_type
);
2350 contents
= value_contents_raw (retval
);
2351 memcpy (contents
, ctx
.data
+ subobj_byte_offset
, n
);
2355 case DWARF_VALUE_OPTIMIZED_OUT
:
2356 free_values
.free_to_mark ();
2357 retval
= allocate_optimized_out_value (subobj_type
);
2360 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2361 operation by execute_stack_op. */
2362 case DWARF_VALUE_IMPLICIT_POINTER
:
2363 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2364 it can only be encountered when making a piece. */
2366 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2370 set_value_initialized (retval
, ctx
.initialized
);
2375 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2376 passes 0 as the byte_offset. */
2379 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2380 const gdb_byte
*data
, size_t size
,
2381 struct dwarf2_per_cu_data
*per_cu
)
2383 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
,
2387 /* A specialization of dwarf_evaluate_loc_desc that is used by
2388 dwarf2_locexpr_baton_eval. This subclass exists to handle the case
2389 where a caller of dwarf2_locexpr_baton_eval passes in some data,
2390 but with the address being 0. In this situation, we arrange for
2391 memory reads to come from the passed-in buffer. */
2393 struct evaluate_for_locexpr_baton
: public dwarf_evaluate_loc_desc
2395 /* The data that was passed in. */
2396 gdb::array_view
<const gdb_byte
> data_view
;
2398 CORE_ADDR
get_object_address () override
2400 if (data_view
.data () == nullptr && obj_address
== 0)
2401 error (_("Location address is not set."));
2405 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
2410 /* Prefer the passed-in memory, if it exists. */
2411 CORE_ADDR offset
= addr
- obj_address
;
2412 if (offset
< data_view
.size () && offset
+ len
<= data_view
.size ())
2414 memcpy (buf
, data_view
.data (), len
);
2418 read_memory (addr
, buf
, len
);
2422 /* Evaluates a dwarf expression and stores the result in VAL,
2423 expecting that the dwarf expression only produces a single
2424 CORE_ADDR. FRAME is the frame in which the expression is
2425 evaluated. ADDR_STACK is a context (location of a variable) and
2426 might be needed to evaluate the location expression.
2427 PUSH_INITIAL_VALUE is true if the address (either from ADDR_STACK,
2428 or the default of 0) should be pushed on the DWARF expression
2429 evaluation stack before evaluating the expression; this is required
2430 by certain forms of DWARF expression. Returns 1 on success, 0
2434 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton
*dlbaton
,
2435 struct frame_info
*frame
,
2436 const struct property_addr_info
*addr_stack
,
2438 bool push_initial_value
)
2440 struct objfile
*objfile
;
2442 if (dlbaton
== NULL
|| dlbaton
->size
== 0)
2445 evaluate_for_locexpr_baton ctx
;
2448 ctx
.per_cu
= dlbaton
->per_cu
;
2449 if (addr_stack
== nullptr)
2450 ctx
.obj_address
= 0;
2453 ctx
.obj_address
= addr_stack
->addr
;
2454 ctx
.data_view
= addr_stack
->valaddr
;
2457 objfile
= dlbaton
->per_cu
->objfile ();
2459 ctx
.gdbarch
= objfile
->arch ();
2460 ctx
.addr_size
= dlbaton
->per_cu
->addr_size ();
2461 ctx
.ref_addr_size
= dlbaton
->per_cu
->ref_addr_size ();
2462 ctx
.offset
= dlbaton
->per_cu
->text_offset ();
2464 if (push_initial_value
)
2465 ctx
.push_address (ctx
.obj_address
, false);
2469 ctx
.eval (dlbaton
->data
, dlbaton
->size
);
2471 catch (const gdb_exception_error
&ex
)
2473 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2477 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2479 if (entry_values_debug
)
2480 exception_print (gdb_stdout
, ex
);
2487 switch (ctx
.location
)
2489 case DWARF_VALUE_REGISTER
:
2490 case DWARF_VALUE_MEMORY
:
2491 case DWARF_VALUE_STACK
:
2492 *valp
= ctx
.fetch_address (0);
2493 if (ctx
.location
== DWARF_VALUE_REGISTER
)
2494 *valp
= ctx
.read_addr_from_reg (*valp
);
2496 case DWARF_VALUE_LITERAL
:
2497 *valp
= extract_signed_integer (ctx
.data
, ctx
.len
,
2498 gdbarch_byte_order (ctx
.gdbarch
));
2500 /* Unsupported dwarf values. */
2501 case DWARF_VALUE_OPTIMIZED_OUT
:
2502 case DWARF_VALUE_IMPLICIT_POINTER
:
2509 /* See dwarf2loc.h. */
2512 dwarf2_evaluate_property (const struct dynamic_prop
*prop
,
2513 struct frame_info
*frame
,
2514 const struct property_addr_info
*addr_stack
,
2516 bool push_initial_value
)
2521 if (frame
== NULL
&& has_stack_frames ())
2522 frame
= get_selected_frame (NULL
);
2528 const struct dwarf2_property_baton
*baton
2529 = (const struct dwarf2_property_baton
*) prop
->data
.baton
;
2530 gdb_assert (baton
->property_type
!= NULL
);
2532 if (dwarf2_locexpr_baton_eval (&baton
->locexpr
, frame
, addr_stack
,
2533 value
, push_initial_value
))
2535 if (baton
->locexpr
.is_reference
)
2537 struct value
*val
= value_at (baton
->property_type
, *value
);
2538 *value
= value_as_address (val
);
2542 gdb_assert (baton
->property_type
!= NULL
);
2544 struct type
*type
= check_typedef (baton
->property_type
);
2545 if (TYPE_LENGTH (type
) < sizeof (CORE_ADDR
)
2546 && !TYPE_UNSIGNED (type
))
2548 /* If we have a valid return candidate and it's value
2549 is signed, we have to sign-extend the value because
2550 CORE_ADDR on 64bit machine has 8 bytes but address
2551 size of an 32bit application is bytes. */
2553 = (baton
->locexpr
.per_cu
->addr_size ()
2555 const CORE_ADDR neg_mask
2556 = (~((CORE_ADDR
) 0) << (addr_size
- 1));
2558 /* Check if signed bit is set and sign-extend values. */
2559 if (*value
& neg_mask
)
2570 struct dwarf2_property_baton
*baton
2571 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2573 const gdb_byte
*data
;
2578 || !get_frame_address_in_block_if_available (frame
, &pc
))
2581 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2584 val
= dwarf2_evaluate_loc_desc (baton
->property_type
, frame
, data
,
2585 size
, baton
->loclist
.per_cu
);
2586 if (!value_optimized_out (val
))
2588 *value
= value_as_address (val
);
2596 *value
= prop
->data
.const_val
;
2599 case PROP_ADDR_OFFSET
:
2601 struct dwarf2_property_baton
*baton
2602 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2603 const struct property_addr_info
*pinfo
;
2606 for (pinfo
= addr_stack
; pinfo
!= NULL
; pinfo
= pinfo
->next
)
2608 /* This approach lets us avoid checking the qualifiers. */
2609 if (TYPE_MAIN_TYPE (pinfo
->type
)
2610 == TYPE_MAIN_TYPE (baton
->property_type
))
2614 error (_("cannot find reference address for offset property"));
2615 if (pinfo
->valaddr
.data () != NULL
)
2616 val
= value_from_contents
2617 (baton
->offset_info
.type
,
2618 pinfo
->valaddr
.data () + baton
->offset_info
.offset
);
2620 val
= value_at (baton
->offset_info
.type
,
2621 pinfo
->addr
+ baton
->offset_info
.offset
);
2622 *value
= value_as_address (val
);
2630 /* See dwarf2loc.h. */
2633 dwarf2_compile_property_to_c (string_file
*stream
,
2634 const char *result_name
,
2635 struct gdbarch
*gdbarch
,
2636 unsigned char *registers_used
,
2637 const struct dynamic_prop
*prop
,
2641 struct dwarf2_property_baton
*baton
2642 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2643 const gdb_byte
*data
;
2645 struct dwarf2_per_cu_data
*per_cu
;
2647 if (prop
->kind
== PROP_LOCEXPR
)
2649 data
= baton
->locexpr
.data
;
2650 size
= baton
->locexpr
.size
;
2651 per_cu
= baton
->locexpr
.per_cu
;
2655 gdb_assert (prop
->kind
== PROP_LOCLIST
);
2657 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2658 per_cu
= baton
->loclist
.per_cu
;
2661 compile_dwarf_bounds_to_c (stream
, result_name
, prop
, sym
, pc
,
2662 gdbarch
, registers_used
,
2663 per_cu
->addr_size (),
2664 data
, data
+ size
, per_cu
);
2668 /* Helper functions and baton for dwarf2_loc_desc_get_symbol_read_needs. */
2670 class symbol_needs_eval_context
: public dwarf_expr_context
2674 enum symbol_needs_kind needs
;
2675 struct dwarf2_per_cu_data
*per_cu
;
2677 /* Reads from registers do require a frame. */
2678 CORE_ADDR
read_addr_from_reg (int regnum
) override
2680 needs
= SYMBOL_NEEDS_FRAME
;
2684 /* "get_reg_value" callback: Reads from registers do require a
2687 struct value
*get_reg_value (struct type
*type
, int regnum
) override
2689 needs
= SYMBOL_NEEDS_FRAME
;
2690 return value_zero (type
, not_lval
);
2693 /* Reads from memory do not require a frame. */
2694 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
2696 memset (buf
, 0, len
);
2699 /* Frame-relative accesses do require a frame. */
2700 void get_frame_base (const gdb_byte
**start
, size_t *length
) override
2702 static gdb_byte lit0
= DW_OP_lit0
;
2707 needs
= SYMBOL_NEEDS_FRAME
;
2710 /* CFA accesses require a frame. */
2711 CORE_ADDR
get_frame_cfa () override
2713 needs
= SYMBOL_NEEDS_FRAME
;
2717 CORE_ADDR
get_frame_pc () override
2719 needs
= SYMBOL_NEEDS_FRAME
;
2723 /* Thread-local accesses require registers, but not a frame. */
2724 CORE_ADDR
get_tls_address (CORE_ADDR offset
) override
2726 if (needs
<= SYMBOL_NEEDS_REGISTERS
)
2727 needs
= SYMBOL_NEEDS_REGISTERS
;
2731 /* Helper interface of per_cu_dwarf_call for
2732 dwarf2_loc_desc_get_symbol_read_needs. */
2734 void dwarf_call (cu_offset die_offset
) override
2736 per_cu_dwarf_call (this, die_offset
, per_cu
);
2739 /* Helper interface of sect_variable_value for
2740 dwarf2_loc_desc_get_symbol_read_needs. */
2742 struct value
*dwarf_variable_value (sect_offset sect_off
) override
2744 return sect_variable_value (this, sect_off
, per_cu
);
2747 /* DW_OP_entry_value accesses require a caller, therefore a
2750 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
2751 union call_site_parameter_u kind_u
,
2752 int deref_size
) override
2754 needs
= SYMBOL_NEEDS_FRAME
;
2756 /* The expression may require some stub values on DWARF stack. */
2757 push_address (0, 0);
2760 /* DW_OP_addrx and DW_OP_GNU_addr_index doesn't require a frame. */
2762 CORE_ADDR
get_addr_index (unsigned int index
) override
2764 /* Nothing to do. */
2768 /* DW_OP_push_object_address has a frame already passed through. */
2770 CORE_ADDR
get_object_address () override
2772 /* Nothing to do. */
2777 /* Compute the correct symbol_needs_kind value for the location
2778 expression at DATA (length SIZE). */
2780 static enum symbol_needs_kind
2781 dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte
*data
, size_t size
,
2782 struct dwarf2_per_cu_data
*per_cu
)
2785 struct objfile
*objfile
= per_cu
->objfile ();
2787 scoped_value_mark free_values
;
2789 symbol_needs_eval_context ctx
;
2791 ctx
.needs
= SYMBOL_NEEDS_NONE
;
2792 ctx
.per_cu
= per_cu
;
2793 ctx
.gdbarch
= objfile
->arch ();
2794 ctx
.addr_size
= per_cu
->addr_size ();
2795 ctx
.ref_addr_size
= per_cu
->ref_addr_size ();
2796 ctx
.offset
= per_cu
->text_offset ();
2798 ctx
.eval (data
, size
);
2800 in_reg
= ctx
.location
== DWARF_VALUE_REGISTER
;
2802 /* If the location has several pieces, and any of them are in
2803 registers, then we will need a frame to fetch them from. */
2804 for (dwarf_expr_piece
&p
: ctx
.pieces
)
2805 if (p
.location
== DWARF_VALUE_REGISTER
)
2809 ctx
.needs
= SYMBOL_NEEDS_FRAME
;
2813 /* A helper function that throws an unimplemented error mentioning a
2814 given DWARF operator. */
2816 static void ATTRIBUTE_NORETURN
2817 unimplemented (unsigned int op
)
2819 const char *name
= get_DW_OP_name (op
);
2822 error (_("DWARF operator %s cannot be translated to an agent expression"),
2825 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2826 "to an agent expression"),
2832 This is basically a wrapper on gdbarch_dwarf2_reg_to_regnum so that we
2833 can issue a complaint, which is better than having every target's
2834 implementation of dwarf2_reg_to_regnum do it. */
2837 dwarf_reg_to_regnum (struct gdbarch
*arch
, int dwarf_reg
)
2839 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2843 complaint (_("bad DWARF register number %d"), dwarf_reg
);
2848 /* Subroutine of dwarf_reg_to_regnum_or_error to simplify it.
2849 Throw an error because DWARF_REG is bad. */
2852 throw_bad_regnum_error (ULONGEST dwarf_reg
)
2854 /* Still want to print -1 as "-1".
2855 We *could* have int and ULONGEST versions of dwarf2_reg_to_regnum_or_error
2856 but that's overkill for now. */
2857 if ((int) dwarf_reg
== dwarf_reg
)
2858 error (_("Unable to access DWARF register number %d"), (int) dwarf_reg
);
2859 error (_("Unable to access DWARF register number %s"),
2860 pulongest (dwarf_reg
));
2863 /* See dwarf2loc.h. */
2866 dwarf_reg_to_regnum_or_error (struct gdbarch
*arch
, ULONGEST dwarf_reg
)
2870 if (dwarf_reg
> INT_MAX
)
2871 throw_bad_regnum_error (dwarf_reg
);
2872 /* Yes, we will end up issuing a complaint and an error if DWARF_REG is
2873 bad, but that's ok. */
2874 reg
= dwarf_reg_to_regnum (arch
, (int) dwarf_reg
);
2876 throw_bad_regnum_error (dwarf_reg
);
2880 /* A helper function that emits an access to memory. ARCH is the
2881 target architecture. EXPR is the expression which we are building.
2882 NBITS is the number of bits we want to read. This emits the
2883 opcodes needed to read the memory and then extract the desired
2887 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2889 ULONGEST nbytes
= (nbits
+ 7) / 8;
2891 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2894 ax_trace_quick (expr
, nbytes
);
2897 ax_simple (expr
, aop_ref8
);
2898 else if (nbits
<= 16)
2899 ax_simple (expr
, aop_ref16
);
2900 else if (nbits
<= 32)
2901 ax_simple (expr
, aop_ref32
);
2903 ax_simple (expr
, aop_ref64
);
2905 /* If we read exactly the number of bytes we wanted, we're done. */
2906 if (8 * nbytes
== nbits
)
2909 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
)
2911 /* On a bits-big-endian machine, we want the high-order
2913 ax_const_l (expr
, 8 * nbytes
- nbits
);
2914 ax_simple (expr
, aop_rsh_unsigned
);
2918 /* On a bits-little-endian box, we want the low-order NBITS. */
2919 ax_zero_ext (expr
, nbits
);
2923 /* A helper function to return the frame's PC. */
2926 get_ax_pc (void *baton
)
2928 struct agent_expr
*expr
= (struct agent_expr
*) baton
;
2933 /* Compile a DWARF location expression to an agent expression.
2935 EXPR is the agent expression we are building.
2936 LOC is the agent value we modify.
2937 ARCH is the architecture.
2938 ADDR_SIZE is the size of addresses, in bytes.
2939 OP_PTR is the start of the location expression.
2940 OP_END is one past the last byte of the location expression.
2942 This will throw an exception for various kinds of errors -- for
2943 example, if the expression cannot be compiled, or if the expression
2947 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2948 unsigned int addr_size
, const gdb_byte
*op_ptr
,
2949 const gdb_byte
*op_end
,
2950 struct dwarf2_per_cu_data
*per_cu
)
2952 gdbarch
*arch
= expr
->gdbarch
;
2953 std::vector
<int> dw_labels
, patches
;
2954 const gdb_byte
* const base
= op_ptr
;
2955 const gdb_byte
*previous_piece
= op_ptr
;
2956 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2957 ULONGEST bits_collected
= 0;
2958 unsigned int addr_size_bits
= 8 * addr_size
;
2959 bool bits_big_endian
= byte_order
== BFD_ENDIAN_BIG
;
2961 std::vector
<int> offsets (op_end
- op_ptr
, -1);
2963 /* By default we are making an address. */
2964 loc
->kind
= axs_lvalue_memory
;
2966 while (op_ptr
< op_end
)
2968 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
2969 uint64_t uoffset
, reg
;
2973 offsets
[op_ptr
- base
] = expr
->len
;
2976 /* Our basic approach to code generation is to map DWARF
2977 operations directly to AX operations. However, there are
2980 First, DWARF works on address-sized units, but AX always uses
2981 LONGEST. For most operations we simply ignore this
2982 difference; instead we generate sign extensions as needed
2983 before division and comparison operations. It would be nice
2984 to omit the sign extensions, but there is no way to determine
2985 the size of the target's LONGEST. (This code uses the size
2986 of the host LONGEST in some cases -- that is a bug but it is
2989 Second, some DWARF operations cannot be translated to AX.
2990 For these we simply fail. See
2991 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
3026 ax_const_l (expr
, op
- DW_OP_lit0
);
3030 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
3031 op_ptr
+= addr_size
;
3032 /* Some versions of GCC emit DW_OP_addr before
3033 DW_OP_GNU_push_tls_address. In this case the value is an
3034 index, not an address. We don't support things like
3035 branching between the address and the TLS op. */
3036 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
3037 uoffset
+= per_cu
->text_offset ();
3038 ax_const_l (expr
, uoffset
);
3042 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
3046 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
3050 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
3054 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
3058 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
3062 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
3066 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
3070 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
3074 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3075 ax_const_l (expr
, uoffset
);
3078 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3079 ax_const_l (expr
, offset
);
3114 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3115 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_reg0
);
3116 loc
->kind
= axs_lvalue_register
;
3120 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3121 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3122 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3123 loc
->kind
= axs_lvalue_register
;
3126 case DW_OP_implicit_value
:
3130 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
3131 if (op_ptr
+ len
> op_end
)
3132 error (_("DW_OP_implicit_value: too few bytes available."));
3133 if (len
> sizeof (ULONGEST
))
3134 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
3137 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
3140 dwarf_expr_require_composition (op_ptr
, op_end
,
3141 "DW_OP_implicit_value");
3143 loc
->kind
= axs_rvalue
;
3147 case DW_OP_stack_value
:
3148 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
3149 loc
->kind
= axs_rvalue
;
3184 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3185 i
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_breg0
);
3189 ax_const_l (expr
, offset
);
3190 ax_simple (expr
, aop_add
);
3195 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3196 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3197 i
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3201 ax_const_l (expr
, offset
);
3202 ax_simple (expr
, aop_add
);
3208 const gdb_byte
*datastart
;
3210 const struct block
*b
;
3211 struct symbol
*framefunc
;
3213 b
= block_for_pc (expr
->scope
);
3216 error (_("No block found for address"));
3218 framefunc
= block_linkage_function (b
);
3221 error (_("No function found for block"));
3223 func_get_frame_base_dwarf_block (framefunc
, expr
->scope
,
3224 &datastart
, &datalen
);
3226 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3227 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, datastart
,
3228 datastart
+ datalen
, per_cu
);
3229 if (loc
->kind
== axs_lvalue_register
)
3230 require_rvalue (expr
, loc
);
3234 ax_const_l (expr
, offset
);
3235 ax_simple (expr
, aop_add
);
3238 loc
->kind
= axs_lvalue_memory
;
3243 ax_simple (expr
, aop_dup
);
3247 ax_simple (expr
, aop_pop
);
3252 ax_pick (expr
, offset
);
3256 ax_simple (expr
, aop_swap
);
3264 ax_simple (expr
, aop_rot
);
3268 case DW_OP_deref_size
:
3272 if (op
== DW_OP_deref_size
)
3277 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3278 error (_("Unsupported size %d in %s"),
3279 size
, get_DW_OP_name (op
));
3280 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3285 /* Sign extend the operand. */
3286 ax_ext (expr
, addr_size_bits
);
3287 ax_simple (expr
, aop_dup
);
3288 ax_const_l (expr
, 0);
3289 ax_simple (expr
, aop_less_signed
);
3290 ax_simple (expr
, aop_log_not
);
3291 i
= ax_goto (expr
, aop_if_goto
);
3292 /* We have to emit 0 - X. */
3293 ax_const_l (expr
, 0);
3294 ax_simple (expr
, aop_swap
);
3295 ax_simple (expr
, aop_sub
);
3296 ax_label (expr
, i
, expr
->len
);
3300 /* No need to sign extend here. */
3301 ax_const_l (expr
, 0);
3302 ax_simple (expr
, aop_swap
);
3303 ax_simple (expr
, aop_sub
);
3307 /* Sign extend the operand. */
3308 ax_ext (expr
, addr_size_bits
);
3309 ax_simple (expr
, aop_bit_not
);
3312 case DW_OP_plus_uconst
:
3313 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3314 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3315 but we micro-optimize anyhow. */
3318 ax_const_l (expr
, reg
);
3319 ax_simple (expr
, aop_add
);
3324 ax_simple (expr
, aop_bit_and
);
3328 /* Sign extend the operands. */
3329 ax_ext (expr
, addr_size_bits
);
3330 ax_simple (expr
, aop_swap
);
3331 ax_ext (expr
, addr_size_bits
);
3332 ax_simple (expr
, aop_swap
);
3333 ax_simple (expr
, aop_div_signed
);
3337 ax_simple (expr
, aop_sub
);
3341 ax_simple (expr
, aop_rem_unsigned
);
3345 ax_simple (expr
, aop_mul
);
3349 ax_simple (expr
, aop_bit_or
);
3353 ax_simple (expr
, aop_add
);
3357 ax_simple (expr
, aop_lsh
);
3361 ax_simple (expr
, aop_rsh_unsigned
);
3365 ax_simple (expr
, aop_rsh_signed
);
3369 ax_simple (expr
, aop_bit_xor
);
3373 /* Sign extend the operands. */
3374 ax_ext (expr
, addr_size_bits
);
3375 ax_simple (expr
, aop_swap
);
3376 ax_ext (expr
, addr_size_bits
);
3377 /* Note no swap here: A <= B is !(B < A). */
3378 ax_simple (expr
, aop_less_signed
);
3379 ax_simple (expr
, aop_log_not
);
3383 /* Sign extend the operands. */
3384 ax_ext (expr
, addr_size_bits
);
3385 ax_simple (expr
, aop_swap
);
3386 ax_ext (expr
, addr_size_bits
);
3387 ax_simple (expr
, aop_swap
);
3388 /* A >= B is !(A < B). */
3389 ax_simple (expr
, aop_less_signed
);
3390 ax_simple (expr
, aop_log_not
);
3394 /* Sign extend the operands. */
3395 ax_ext (expr
, addr_size_bits
);
3396 ax_simple (expr
, aop_swap
);
3397 ax_ext (expr
, addr_size_bits
);
3398 /* No need for a second swap here. */
3399 ax_simple (expr
, aop_equal
);
3403 /* Sign extend the operands. */
3404 ax_ext (expr
, addr_size_bits
);
3405 ax_simple (expr
, aop_swap
);
3406 ax_ext (expr
, addr_size_bits
);
3407 ax_simple (expr
, aop_swap
);
3408 ax_simple (expr
, aop_less_signed
);
3412 /* Sign extend the operands. */
3413 ax_ext (expr
, addr_size_bits
);
3414 ax_simple (expr
, aop_swap
);
3415 ax_ext (expr
, addr_size_bits
);
3416 /* Note no swap here: A > B is B < A. */
3417 ax_simple (expr
, aop_less_signed
);
3421 /* Sign extend the operands. */
3422 ax_ext (expr
, addr_size_bits
);
3423 ax_simple (expr
, aop_swap
);
3424 ax_ext (expr
, addr_size_bits
);
3425 /* No need for a swap here. */
3426 ax_simple (expr
, aop_equal
);
3427 ax_simple (expr
, aop_log_not
);
3430 case DW_OP_call_frame_cfa
:
3433 CORE_ADDR text_offset
;
3435 const gdb_byte
*cfa_start
, *cfa_end
;
3437 if (dwarf2_fetch_cfa_info (arch
, expr
->scope
, per_cu
,
3439 &text_offset
, &cfa_start
, &cfa_end
))
3442 ax_reg (expr
, regnum
);
3445 ax_const_l (expr
, off
);
3446 ax_simple (expr
, aop_add
);
3451 /* Another expression. */
3452 ax_const_l (expr
, text_offset
);
3453 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, cfa_start
,
3457 loc
->kind
= axs_lvalue_memory
;
3461 case DW_OP_GNU_push_tls_address
:
3462 case DW_OP_form_tls_address
:
3466 case DW_OP_push_object_address
:
3471 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3473 i
= ax_goto (expr
, aop_goto
);
3474 dw_labels
.push_back (op_ptr
+ offset
- base
);
3475 patches
.push_back (i
);
3479 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3481 /* Zero extend the operand. */
3482 ax_zero_ext (expr
, addr_size_bits
);
3483 i
= ax_goto (expr
, aop_if_goto
);
3484 dw_labels
.push_back (op_ptr
+ offset
- base
);
3485 patches
.push_back (i
);
3492 case DW_OP_bit_piece
:
3496 if (op_ptr
- 1 == previous_piece
)
3497 error (_("Cannot translate empty pieces to agent expressions"));
3498 previous_piece
= op_ptr
- 1;
3500 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3501 if (op
== DW_OP_piece
)
3507 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3509 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3510 error (_("Expression pieces exceed word size"));
3512 /* Access the bits. */
3515 case axs_lvalue_register
:
3516 ax_reg (expr
, loc
->u
.reg
);
3519 case axs_lvalue_memory
:
3520 /* Offset the pointer, if needed. */
3523 ax_const_l (expr
, uoffset
/ 8);
3524 ax_simple (expr
, aop_add
);
3527 access_memory (arch
, expr
, size
);
3531 /* For a bits-big-endian target, shift up what we already
3532 have. For a bits-little-endian target, shift up the
3533 new data. Note that there is a potential bug here if
3534 the DWARF expression leaves multiple values on the
3536 if (bits_collected
> 0)
3538 if (bits_big_endian
)
3540 ax_simple (expr
, aop_swap
);
3541 ax_const_l (expr
, size
);
3542 ax_simple (expr
, aop_lsh
);
3543 /* We don't need a second swap here, because
3544 aop_bit_or is symmetric. */
3548 ax_const_l (expr
, size
);
3549 ax_simple (expr
, aop_lsh
);
3551 ax_simple (expr
, aop_bit_or
);
3554 bits_collected
+= size
;
3555 loc
->kind
= axs_rvalue
;
3559 case DW_OP_GNU_uninit
:
3565 struct dwarf2_locexpr_baton block
;
3566 int size
= (op
== DW_OP_call2
? 2 : 4);
3568 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3571 cu_offset cuoffset
= (cu_offset
) uoffset
;
3572 block
= dwarf2_fetch_die_loc_cu_off (cuoffset
, per_cu
,
3575 /* DW_OP_call_ref is currently not supported. */
3576 gdb_assert (block
.per_cu
== per_cu
);
3578 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, block
.data
,
3579 block
.data
+ block
.size
, per_cu
);
3583 case DW_OP_call_ref
:
3586 case DW_OP_GNU_variable_value
:
3594 /* Patch all the branches we emitted. */
3595 for (int i
= 0; i
< patches
.size (); ++i
)
3597 int targ
= offsets
[dw_labels
[i
]];
3599 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3600 ax_label (expr
, patches
[i
], targ
);
3605 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3606 evaluator to calculate the location. */
3607 static struct value
*
3608 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3610 struct dwarf2_locexpr_baton
*dlbaton
3611 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3614 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3615 dlbaton
->size
, dlbaton
->per_cu
);
3620 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3621 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3624 static struct value
*
3625 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3627 struct dwarf2_locexpr_baton
*dlbaton
3628 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3630 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3634 /* Implementation of get_symbol_read_needs from
3635 symbol_computed_ops. */
3637 static enum symbol_needs_kind
3638 locexpr_get_symbol_read_needs (struct symbol
*symbol
)
3640 struct dwarf2_locexpr_baton
*dlbaton
3641 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3643 return dwarf2_loc_desc_get_symbol_read_needs (dlbaton
->data
, dlbaton
->size
,
3647 /* Return true if DATA points to the end of a piece. END is one past
3648 the last byte in the expression. */
3651 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3653 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3656 /* Helper for locexpr_describe_location_piece that finds the name of a
3660 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3664 /* This doesn't use dwarf_reg_to_regnum_or_error on purpose.
3665 We'd rather print *something* here than throw an error. */
3666 regnum
= dwarf_reg_to_regnum (gdbarch
, dwarf_regnum
);
3667 /* gdbarch_register_name may just return "", return something more
3668 descriptive for bad register numbers. */
3671 /* The text is output as "$bad_register_number".
3672 That is why we use the underscores. */
3673 return _("bad_register_number");
3675 return gdbarch_register_name (gdbarch
, regnum
);
3678 /* Nicely describe a single piece of a location, returning an updated
3679 position in the bytecode sequence. This function cannot recognize
3680 all locations; if a location is not recognized, it simply returns
3681 DATA. If there is an error during reading, e.g. we run off the end
3682 of the buffer, an error is thrown. */
3684 static const gdb_byte
*
3685 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3686 CORE_ADDR addr
, struct objfile
*objfile
,
3687 struct dwarf2_per_cu_data
*per_cu
,
3688 const gdb_byte
*data
, const gdb_byte
*end
,
3689 unsigned int addr_size
)
3691 struct gdbarch
*gdbarch
= objfile
->arch ();
3694 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3696 fprintf_filtered (stream
, _("a variable in $%s"),
3697 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3700 else if (data
[0] == DW_OP_regx
)
3704 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3705 fprintf_filtered (stream
, _("a variable in $%s"),
3706 locexpr_regname (gdbarch
, reg
));
3708 else if (data
[0] == DW_OP_fbreg
)
3710 const struct block
*b
;
3711 struct symbol
*framefunc
;
3713 int64_t frame_offset
;
3714 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3716 int64_t base_offset
= 0;
3718 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3719 if (!piece_end_p (new_data
, end
))
3723 b
= block_for_pc (addr
);
3726 error (_("No block found for address for symbol \"%s\"."),
3727 symbol
->print_name ());
3729 framefunc
= block_linkage_function (b
);
3732 error (_("No function found for block for symbol \"%s\"."),
3733 symbol
->print_name ());
3735 func_get_frame_base_dwarf_block (framefunc
, addr
, &base_data
, &base_size
);
3737 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3739 const gdb_byte
*buf_end
;
3741 frame_reg
= base_data
[0] - DW_OP_breg0
;
3742 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3744 if (buf_end
!= base_data
+ base_size
)
3745 error (_("Unexpected opcode after "
3746 "DW_OP_breg%u for symbol \"%s\"."),
3747 frame_reg
, symbol
->print_name ());
3749 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3751 /* The frame base is just the register, with no offset. */
3752 frame_reg
= base_data
[0] - DW_OP_reg0
;
3757 /* We don't know what to do with the frame base expression,
3758 so we can't trace this variable; give up. */
3762 fprintf_filtered (stream
,
3763 _("a variable at frame base reg $%s offset %s+%s"),
3764 locexpr_regname (gdbarch
, frame_reg
),
3765 plongest (base_offset
), plongest (frame_offset
));
3767 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3768 && piece_end_p (data
, end
))
3772 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3774 fprintf_filtered (stream
,
3775 _("a variable at offset %s from base reg $%s"),
3777 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3780 /* The location expression for a TLS variable looks like this (on a
3783 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3784 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3786 0x3 is the encoding for DW_OP_addr, which has an operand as long
3787 as the size of an address on the target machine (here is 8
3788 bytes). Note that more recent version of GCC emit DW_OP_const4u
3789 or DW_OP_const8u, depending on address size, rather than
3790 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3791 The operand represents the offset at which the variable is within
3792 the thread local storage. */
3794 else if (data
+ 1 + addr_size
< end
3795 && (data
[0] == DW_OP_addr
3796 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3797 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3798 && (data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3799 || data
[1 + addr_size
] == DW_OP_form_tls_address
)
3800 && piece_end_p (data
+ 2 + addr_size
, end
))
3803 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3804 gdbarch_byte_order (gdbarch
));
3806 fprintf_filtered (stream
,
3807 _("a thread-local variable at offset 0x%s "
3808 "in the thread-local storage for `%s'"),
3809 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3811 data
+= 1 + addr_size
+ 1;
3814 /* With -gsplit-dwarf a TLS variable can also look like this:
3815 DW_AT_location : 3 byte block: fc 4 e0
3816 (DW_OP_GNU_const_index: 4;
3817 DW_OP_GNU_push_tls_address) */
3818 else if (data
+ 3 <= end
3819 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3820 && data
[0] == DW_OP_GNU_const_index
3822 && (data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3823 || data
[1 + leb128_size
] == DW_OP_form_tls_address
)
3824 && piece_end_p (data
+ 2 + leb128_size
, end
))
3828 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3829 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3830 fprintf_filtered (stream
,
3831 _("a thread-local variable at offset 0x%s "
3832 "in the thread-local storage for `%s'"),
3833 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3837 else if (data
[0] >= DW_OP_lit0
3838 && data
[0] <= DW_OP_lit31
3840 && data
[1] == DW_OP_stack_value
)
3842 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3849 /* Disassemble an expression, stopping at the end of a piece or at the
3850 end of the expression. Returns a pointer to the next unread byte
3851 in the input expression. If ALL is nonzero, then this function
3852 will keep going until it reaches the end of the expression.
3853 If there is an error during reading, e.g. we run off the end
3854 of the buffer, an error is thrown. */
3856 static const gdb_byte
*
3857 disassemble_dwarf_expression (struct ui_file
*stream
,
3858 struct gdbarch
*arch
, unsigned int addr_size
,
3859 int offset_size
, const gdb_byte
*start
,
3860 const gdb_byte
*data
, const gdb_byte
*end
,
3861 int indent
, int all
,
3862 struct dwarf2_per_cu_data
*per_cu
)
3866 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3868 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *data
++;
3873 name
= get_DW_OP_name (op
);
3876 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3877 op
, (long) (data
- 1 - start
));
3878 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3879 (long) (data
- 1 - start
), name
);
3884 ul
= extract_unsigned_integer (data
, addr_size
,
3885 gdbarch_byte_order (arch
));
3887 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3891 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3893 fprintf_filtered (stream
, " %s", pulongest (ul
));
3896 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3898 fprintf_filtered (stream
, " %s", plongest (l
));
3901 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3903 fprintf_filtered (stream
, " %s", pulongest (ul
));
3906 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3908 fprintf_filtered (stream
, " %s", plongest (l
));
3911 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3913 fprintf_filtered (stream
, " %s", pulongest (ul
));
3916 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3918 fprintf_filtered (stream
, " %s", plongest (l
));
3921 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3923 fprintf_filtered (stream
, " %s", pulongest (ul
));
3926 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3928 fprintf_filtered (stream
, " %s", plongest (l
));
3931 data
= safe_read_uleb128 (data
, end
, &ul
);
3932 fprintf_filtered (stream
, " %s", pulongest (ul
));
3935 data
= safe_read_sleb128 (data
, end
, &l
);
3936 fprintf_filtered (stream
, " %s", plongest (l
));
3971 fprintf_filtered (stream
, " [$%s]",
3972 locexpr_regname (arch
, op
- DW_OP_reg0
));
3976 data
= safe_read_uleb128 (data
, end
, &ul
);
3977 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3978 locexpr_regname (arch
, (int) ul
));
3981 case DW_OP_implicit_value
:
3982 data
= safe_read_uleb128 (data
, end
, &ul
);
3984 fprintf_filtered (stream
, " %s", pulongest (ul
));
4019 data
= safe_read_sleb128 (data
, end
, &l
);
4020 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
4021 locexpr_regname (arch
, op
- DW_OP_breg0
));
4025 data
= safe_read_uleb128 (data
, end
, &ul
);
4026 data
= safe_read_sleb128 (data
, end
, &l
);
4027 fprintf_filtered (stream
, " register %s [$%s] offset %s",
4029 locexpr_regname (arch
, (int) ul
),
4034 data
= safe_read_sleb128 (data
, end
, &l
);
4035 fprintf_filtered (stream
, " %s", plongest (l
));
4038 case DW_OP_xderef_size
:
4039 case DW_OP_deref_size
:
4041 fprintf_filtered (stream
, " %d", *data
);
4045 case DW_OP_plus_uconst
:
4046 data
= safe_read_uleb128 (data
, end
, &ul
);
4047 fprintf_filtered (stream
, " %s", pulongest (ul
));
4051 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4053 fprintf_filtered (stream
, " to %ld",
4054 (long) (data
+ l
- start
));
4058 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4060 fprintf_filtered (stream
, " %ld",
4061 (long) (data
+ l
- start
));
4065 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
4067 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
4071 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4073 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4076 case DW_OP_call_ref
:
4077 ul
= extract_unsigned_integer (data
, offset_size
,
4078 gdbarch_byte_order (arch
));
4079 data
+= offset_size
;
4080 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4084 data
= safe_read_uleb128 (data
, end
, &ul
);
4085 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
4088 case DW_OP_bit_piece
:
4092 data
= safe_read_uleb128 (data
, end
, &ul
);
4093 data
= safe_read_uleb128 (data
, end
, &offset
);
4094 fprintf_filtered (stream
, " size %s offset %s (bits)",
4095 pulongest (ul
), pulongest (offset
));
4099 case DW_OP_implicit_pointer
:
4100 case DW_OP_GNU_implicit_pointer
:
4102 ul
= extract_unsigned_integer (data
, offset_size
,
4103 gdbarch_byte_order (arch
));
4104 data
+= offset_size
;
4106 data
= safe_read_sleb128 (data
, end
, &l
);
4108 fprintf_filtered (stream
, " DIE %s offset %s",
4109 phex_nz (ul
, offset_size
),
4114 case DW_OP_deref_type
:
4115 case DW_OP_GNU_deref_type
:
4117 int deref_addr_size
= *data
++;
4120 data
= safe_read_uleb128 (data
, end
, &ul
);
4121 cu_offset offset
= (cu_offset
) ul
;
4122 type
= dwarf2_get_die_type (offset
, per_cu
);
4123 fprintf_filtered (stream
, "<");
4124 type_print (type
, "", stream
, -1);
4125 fprintf_filtered (stream
, " [0x%s]> %d",
4126 phex_nz (to_underlying (offset
), 0),
4131 case DW_OP_const_type
:
4132 case DW_OP_GNU_const_type
:
4136 data
= safe_read_uleb128 (data
, end
, &ul
);
4137 cu_offset type_die
= (cu_offset
) ul
;
4138 type
= dwarf2_get_die_type (type_die
, per_cu
);
4139 fprintf_filtered (stream
, "<");
4140 type_print (type
, "", stream
, -1);
4141 fprintf_filtered (stream
, " [0x%s]>",
4142 phex_nz (to_underlying (type_die
), 0));
4145 fprintf_filtered (stream
, " %d byte block:", n
);
4146 for (int i
= 0; i
< n
; ++i
)
4147 fprintf_filtered (stream
, " %02x", data
[i
]);
4152 case DW_OP_regval_type
:
4153 case DW_OP_GNU_regval_type
:
4158 data
= safe_read_uleb128 (data
, end
, ®
);
4159 data
= safe_read_uleb128 (data
, end
, &ul
);
4160 cu_offset type_die
= (cu_offset
) ul
;
4162 type
= dwarf2_get_die_type (type_die
, per_cu
);
4163 fprintf_filtered (stream
, "<");
4164 type_print (type
, "", stream
, -1);
4165 fprintf_filtered (stream
, " [0x%s]> [$%s]",
4166 phex_nz (to_underlying (type_die
), 0),
4167 locexpr_regname (arch
, reg
));
4172 case DW_OP_GNU_convert
:
4173 case DW_OP_reinterpret
:
4174 case DW_OP_GNU_reinterpret
:
4176 data
= safe_read_uleb128 (data
, end
, &ul
);
4177 cu_offset type_die
= (cu_offset
) ul
;
4179 if (to_underlying (type_die
) == 0)
4180 fprintf_filtered (stream
, "<0>");
4185 type
= dwarf2_get_die_type (type_die
, per_cu
);
4186 fprintf_filtered (stream
, "<");
4187 type_print (type
, "", stream
, -1);
4188 fprintf_filtered (stream
, " [0x%s]>",
4189 phex_nz (to_underlying (type_die
), 0));
4194 case DW_OP_entry_value
:
4195 case DW_OP_GNU_entry_value
:
4196 data
= safe_read_uleb128 (data
, end
, &ul
);
4197 fputc_filtered ('\n', stream
);
4198 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
4199 start
, data
, data
+ ul
, indent
+ 2,
4204 case DW_OP_GNU_parameter_ref
:
4205 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4207 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4211 case DW_OP_GNU_addr_index
:
4212 data
= safe_read_uleb128 (data
, end
, &ul
);
4213 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4214 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
4216 case DW_OP_GNU_const_index
:
4217 data
= safe_read_uleb128 (data
, end
, &ul
);
4218 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4219 fprintf_filtered (stream
, " %s", pulongest (ul
));
4222 case DW_OP_GNU_variable_value
:
4223 ul
= extract_unsigned_integer (data
, offset_size
,
4224 gdbarch_byte_order (arch
));
4225 data
+= offset_size
;
4226 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4230 fprintf_filtered (stream
, "\n");
4236 static bool dwarf_always_disassemble
;
4239 show_dwarf_always_disassemble (struct ui_file
*file
, int from_tty
,
4240 struct cmd_list_element
*c
, const char *value
)
4242 fprintf_filtered (file
,
4243 _("Whether to always disassemble "
4244 "DWARF expressions is %s.\n"),
4248 /* Describe a single location, which may in turn consist of multiple
4252 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
4253 struct ui_file
*stream
,
4254 const gdb_byte
*data
, size_t size
,
4255 struct objfile
*objfile
, unsigned int addr_size
,
4256 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
4258 const gdb_byte
*end
= data
+ size
;
4259 int first_piece
= 1, bad
= 0;
4263 const gdb_byte
*here
= data
;
4264 int disassemble
= 1;
4269 fprintf_filtered (stream
, _(", and "));
4271 if (!dwarf_always_disassemble
)
4273 data
= locexpr_describe_location_piece (symbol
, stream
,
4274 addr
, objfile
, per_cu
,
4275 data
, end
, addr_size
);
4276 /* If we printed anything, or if we have an empty piece,
4277 then don't disassemble. */
4279 || data
[0] == DW_OP_piece
4280 || data
[0] == DW_OP_bit_piece
)
4285 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
4286 data
= disassemble_dwarf_expression (stream
,
4288 addr_size
, offset_size
, data
,
4290 dwarf_always_disassemble
,
4296 int empty
= data
== here
;
4299 fprintf_filtered (stream
, " ");
4300 if (data
[0] == DW_OP_piece
)
4304 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
4307 fprintf_filtered (stream
, _("an empty %s-byte piece"),
4310 fprintf_filtered (stream
, _(" [%s-byte piece]"),
4313 else if (data
[0] == DW_OP_bit_piece
)
4315 uint64_t bits
, offset
;
4317 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
4318 data
= safe_read_uleb128 (data
, end
, &offset
);
4321 fprintf_filtered (stream
,
4322 _("an empty %s-bit piece"),
4325 fprintf_filtered (stream
,
4326 _(" [%s-bit piece, offset %s bits]"),
4327 pulongest (bits
), pulongest (offset
));
4337 if (bad
|| data
> end
)
4338 error (_("Corrupted DWARF2 expression for \"%s\"."),
4339 symbol
->print_name ());
4342 /* Print a natural-language description of SYMBOL to STREAM. This
4343 version is for a symbol with a single location. */
4346 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4347 struct ui_file
*stream
)
4349 struct dwarf2_locexpr_baton
*dlbaton
4350 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4351 struct objfile
*objfile
= dlbaton
->per_cu
->objfile ();
4352 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4353 int offset_size
= dlbaton
->per_cu
->offset_size ();
4355 locexpr_describe_location_1 (symbol
, addr
, stream
,
4356 dlbaton
->data
, dlbaton
->size
,
4357 objfile
, addr_size
, offset_size
,
4361 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4362 any necessary bytecode in AX. */
4365 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
4366 struct axs_value
*value
)
4368 struct dwarf2_locexpr_baton
*dlbaton
4369 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4370 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4372 if (dlbaton
->size
== 0)
4373 value
->optimized_out
= 1;
4375 dwarf2_compile_expr_to_ax (ax
, value
, addr_size
, dlbaton
->data
,
4376 dlbaton
->data
+ dlbaton
->size
, dlbaton
->per_cu
);
4379 /* symbol_computed_ops 'generate_c_location' method. */
4382 locexpr_generate_c_location (struct symbol
*sym
, string_file
*stream
,
4383 struct gdbarch
*gdbarch
,
4384 unsigned char *registers_used
,
4385 CORE_ADDR pc
, const char *result_name
)
4387 struct dwarf2_locexpr_baton
*dlbaton
4388 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (sym
);
4389 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4391 if (dlbaton
->size
== 0)
4392 error (_("symbol \"%s\" is optimized out"), sym
->natural_name ());
4394 compile_dwarf_expr_to_c (stream
, result_name
,
4395 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4396 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4400 /* The set of location functions used with the DWARF-2 expression
4402 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4403 locexpr_read_variable
,
4404 locexpr_read_variable_at_entry
,
4405 locexpr_get_symbol_read_needs
,
4406 locexpr_describe_location
,
4407 0, /* location_has_loclist */
4408 locexpr_tracepoint_var_ref
,
4409 locexpr_generate_c_location
4413 /* Wrapper functions for location lists. These generally find
4414 the appropriate location expression and call something above. */
4416 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4417 evaluator to calculate the location. */
4418 static struct value
*
4419 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4421 struct dwarf2_loclist_baton
*dlbaton
4422 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4424 const gdb_byte
*data
;
4426 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4428 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4429 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4435 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4436 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4439 Function always returns non-NULL value, it may be marked optimized out if
4440 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4441 if it cannot resolve the parameter for any reason. */
4443 static struct value
*
4444 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4446 struct dwarf2_loclist_baton
*dlbaton
4447 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4448 const gdb_byte
*data
;
4452 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4453 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4455 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4457 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4459 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4462 /* Implementation of get_symbol_read_needs from
4463 symbol_computed_ops. */
4465 static enum symbol_needs_kind
4466 loclist_symbol_needs (struct symbol
*symbol
)
4468 /* If there's a location list, then assume we need to have a frame
4469 to choose the appropriate location expression. With tracking of
4470 global variables this is not necessarily true, but such tracking
4471 is disabled in GCC at the moment until we figure out how to
4474 return SYMBOL_NEEDS_FRAME
;
4477 /* Print a natural-language description of SYMBOL to STREAM. This
4478 version applies when there is a list of different locations, each
4479 with a specified address range. */
4482 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4483 struct ui_file
*stream
)
4485 struct dwarf2_loclist_baton
*dlbaton
4486 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4487 const gdb_byte
*loc_ptr
, *buf_end
;
4488 struct objfile
*objfile
= dlbaton
->per_cu
->objfile ();
4489 struct gdbarch
*gdbarch
= objfile
->arch ();
4490 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4491 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4492 int offset_size
= dlbaton
->per_cu
->offset_size ();
4493 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4494 /* Adjust base_address for relocatable objects. */
4495 CORE_ADDR base_offset
= dlbaton
->per_cu
->text_offset ();
4496 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4499 loc_ptr
= dlbaton
->data
;
4500 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4502 fprintf_filtered (stream
, _("multi-location:\n"));
4504 /* Iterate through locations until we run out. */
4507 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4509 enum debug_loc_kind kind
;
4510 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4512 if (dlbaton
->per_cu
->version () < 5 && dlbaton
->from_dwo
)
4513 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4514 loc_ptr
, buf_end
, &new_ptr
,
4515 &low
, &high
, byte_order
);
4516 else if (dlbaton
->per_cu
->version () < 5)
4517 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4519 byte_order
, addr_size
,
4522 kind
= decode_debug_loclists_addresses (dlbaton
->per_cu
,
4523 loc_ptr
, buf_end
, &new_ptr
,
4524 &low
, &high
, byte_order
,
4525 addr_size
, signed_addr_p
);
4529 case DEBUG_LOC_END_OF_LIST
:
4532 case DEBUG_LOC_BASE_ADDRESS
:
4533 base_address
= high
+ base_offset
;
4534 fprintf_filtered (stream
, _(" Base address %s"),
4535 paddress (gdbarch
, base_address
));
4537 case DEBUG_LOC_START_END
:
4538 case DEBUG_LOC_START_LENGTH
:
4539 case DEBUG_LOC_OFFSET_PAIR
:
4541 case DEBUG_LOC_BUFFER_OVERFLOW
:
4542 case DEBUG_LOC_INVALID_ENTRY
:
4543 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4544 symbol
->print_name ());
4546 gdb_assert_not_reached ("bad debug_loc_kind");
4549 /* Otherwise, a location expression entry. */
4550 low
+= base_address
;
4551 high
+= base_address
;
4553 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
);
4554 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
);
4556 if (dlbaton
->per_cu
->version () < 5)
4558 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4563 unsigned int bytes_read
;
4564 length
= read_unsigned_leb128 (NULL
, loc_ptr
, &bytes_read
);
4565 loc_ptr
+= bytes_read
;
4568 /* (It would improve readability to print only the minimum
4569 necessary digits of the second number of the range.) */
4570 fprintf_filtered (stream
, _(" Range %s-%s: "),
4571 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4573 /* Now describe this particular location. */
4574 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4575 objfile
, addr_size
, offset_size
,
4578 fprintf_filtered (stream
, "\n");
4584 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4585 any necessary bytecode in AX. */
4587 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
4588 struct axs_value
*value
)
4590 struct dwarf2_loclist_baton
*dlbaton
4591 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4592 const gdb_byte
*data
;
4594 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4596 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4598 value
->optimized_out
= 1;
4600 dwarf2_compile_expr_to_ax (ax
, value
, addr_size
, data
, data
+ size
,
4604 /* symbol_computed_ops 'generate_c_location' method. */
4607 loclist_generate_c_location (struct symbol
*sym
, string_file
*stream
,
4608 struct gdbarch
*gdbarch
,
4609 unsigned char *registers_used
,
4610 CORE_ADDR pc
, const char *result_name
)
4612 struct dwarf2_loclist_baton
*dlbaton
4613 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (sym
);
4614 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4615 const gdb_byte
*data
;
4618 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4620 error (_("symbol \"%s\" is optimized out"), sym
->natural_name ());
4622 compile_dwarf_expr_to_c (stream
, result_name
,
4623 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4628 /* The set of location functions used with the DWARF-2 expression
4629 evaluator and location lists. */
4630 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4631 loclist_read_variable
,
4632 loclist_read_variable_at_entry
,
4633 loclist_symbol_needs
,
4634 loclist_describe_location
,
4635 1, /* location_has_loclist */
4636 loclist_tracepoint_var_ref
,
4637 loclist_generate_c_location
4640 void _initialize_dwarf2loc ();
4642 _initialize_dwarf2loc ()
4644 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4645 &entry_values_debug
,
4646 _("Set entry values and tail call frames "
4648 _("Show entry values and tail call frames "
4650 _("When non-zero, the process of determining "
4651 "parameter values from function entry point "
4652 "and tail call frames will be printed."),
4654 show_entry_values_debug
,
4655 &setdebuglist
, &showdebuglist
);
4657 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
4658 &dwarf_always_disassemble
, _("\
4659 Set whether `info address' always disassembles DWARF expressions."), _("\
4660 Show whether `info address' always disassembles DWARF expressions."), _("\
4661 When enabled, DWARF expressions are always printed in an assembly-like\n\
4662 syntax. When disabled, expressions will be printed in a more\n\
4663 conversational style, when possible."),
4665 show_dwarf_always_disassemble
,
4667 &show_dwarf_cmdlist
);