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 dwarf2_per_objfile
*per_objfile
= baton
->per_objfile
;
321 struct objfile
*objfile
= per_objfile
->objfile
;
322 struct gdbarch
*gdbarch
= objfile
->arch ();
323 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
324 unsigned int addr_size
= baton
->per_cu
->addr_size ();
325 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
326 /* Adjust base_address for relocatable objects. */
327 CORE_ADDR base_offset
= baton
->per_cu
->text_offset ();
328 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
329 const gdb_byte
*loc_ptr
, *buf_end
;
331 loc_ptr
= baton
->data
;
332 buf_end
= baton
->data
+ baton
->size
;
336 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
338 enum debug_loc_kind kind
;
339 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
341 if (baton
->per_cu
->version () < 5 && baton
->from_dwo
)
342 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
343 loc_ptr
, buf_end
, &new_ptr
,
344 &low
, &high
, byte_order
);
345 else if (baton
->per_cu
->version () < 5)
346 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
348 byte_order
, addr_size
,
351 kind
= decode_debug_loclists_addresses (baton
->per_cu
,
352 loc_ptr
, buf_end
, &new_ptr
,
353 &low
, &high
, byte_order
,
354 addr_size
, signed_addr_p
);
359 case DEBUG_LOC_END_OF_LIST
:
362 case DEBUG_LOC_BASE_ADDRESS
:
363 base_address
= high
+ base_offset
;
365 case DEBUG_LOC_START_END
:
366 case DEBUG_LOC_START_LENGTH
:
367 case DEBUG_LOC_OFFSET_PAIR
:
369 case DEBUG_LOC_BUFFER_OVERFLOW
:
370 case DEBUG_LOC_INVALID_ENTRY
:
371 error (_("dwarf2_find_location_expression: "
372 "Corrupted DWARF expression."));
374 gdb_assert_not_reached ("bad debug_loc_kind");
377 /* Otherwise, a location expression entry.
378 If the entry is from a DWO, don't add base address: the entry is from
379 .debug_addr which already has the DWARF "base address". We still add
380 base_offset in case we're debugging a PIE executable. However, if the
381 entry is DW_LLE_offset_pair from a DWO, add the base address as the
382 operands are offsets relative to the applicable base address. */
383 if (baton
->from_dwo
&& kind
!= DEBUG_LOC_OFFSET_PAIR
)
391 high
+= base_address
;
394 if (baton
->per_cu
->version () < 5)
396 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
401 unsigned int bytes_read
;
403 length
= read_unsigned_leb128 (NULL
, loc_ptr
, &bytes_read
);
404 loc_ptr
+= bytes_read
;
407 if (low
== high
&& pc
== low
)
409 /* This is entry PC record present only at entry point
410 of a function. Verify it is really the function entry point. */
412 const struct block
*pc_block
= block_for_pc (pc
);
413 struct symbol
*pc_func
= NULL
;
416 pc_func
= block_linkage_function (pc_block
);
418 if (pc_func
&& pc
== BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (pc_func
)))
420 *locexpr_length
= length
;
425 if (pc
>= low
&& pc
< high
)
427 *locexpr_length
= length
;
435 /* Implement find_frame_base_location method for LOC_BLOCK functions using
436 DWARF expression for its DW_AT_frame_base. */
439 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
440 const gdb_byte
**start
, size_t *length
)
442 struct dwarf2_locexpr_baton
*symbaton
443 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
445 *length
= symbaton
->size
;
446 *start
= symbaton
->data
;
449 /* Implement the struct symbol_block_ops::get_frame_base method for
450 LOC_BLOCK functions using a DWARF expression as its DW_AT_frame_base. */
453 locexpr_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
455 struct gdbarch
*gdbarch
;
457 struct dwarf2_locexpr_baton
*dlbaton
;
458 const gdb_byte
*start
;
460 struct value
*result
;
462 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
463 Thus, it's supposed to provide the find_frame_base_location method as
465 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
467 gdbarch
= get_frame_arch (frame
);
468 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
469 dlbaton
= (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
471 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
472 (framefunc
, get_frame_pc (frame
), &start
, &length
);
473 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
476 /* The DW_AT_frame_base attribute contains a location description which
477 computes the base address itself. However, the call to
478 dwarf2_evaluate_loc_desc returns a value representing a variable at
479 that address. The frame base address is thus this variable's
481 return value_address (result
);
484 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
485 function uses DWARF expression for its DW_AT_frame_base. */
487 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
489 locexpr_find_frame_base_location
,
490 locexpr_get_frame_base
493 /* Implement find_frame_base_location method for LOC_BLOCK functions using
494 DWARF location list for its DW_AT_frame_base. */
497 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
498 const gdb_byte
**start
, size_t *length
)
500 struct dwarf2_loclist_baton
*symbaton
501 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
503 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
506 /* Implement the struct symbol_block_ops::get_frame_base method for
507 LOC_BLOCK functions using a DWARF location list as its DW_AT_frame_base. */
510 loclist_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
512 struct gdbarch
*gdbarch
;
514 struct dwarf2_loclist_baton
*dlbaton
;
515 const gdb_byte
*start
;
517 struct value
*result
;
519 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
520 Thus, it's supposed to provide the find_frame_base_location method as
522 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
524 gdbarch
= get_frame_arch (frame
);
525 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
526 dlbaton
= (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
528 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
529 (framefunc
, get_frame_pc (frame
), &start
, &length
);
530 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
533 /* The DW_AT_frame_base attribute contains a location description which
534 computes the base address itself. However, the call to
535 dwarf2_evaluate_loc_desc returns a value representing a variable at
536 that address. The frame base address is thus this variable's
538 return value_address (result
);
541 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
542 function uses DWARF location list for its DW_AT_frame_base. */
544 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
546 loclist_find_frame_base_location
,
547 loclist_get_frame_base
550 /* See dwarf2loc.h. */
553 func_get_frame_base_dwarf_block (struct symbol
*framefunc
, CORE_ADDR pc
,
554 const gdb_byte
**start
, size_t *length
)
556 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
558 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
560 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
566 error (_("Could not find the frame base for \"%s\"."),
567 framefunc
->natural_name ());
571 get_frame_pc_for_per_cu_dwarf_call (void *baton
)
573 dwarf_expr_context
*ctx
= (dwarf_expr_context
*) baton
;
575 return ctx
->get_frame_pc ();
579 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
580 struct dwarf2_per_cu_data
*per_cu
)
582 struct dwarf2_locexpr_baton block
;
584 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
,
585 get_frame_pc_for_per_cu_dwarf_call
,
588 /* DW_OP_call_ref is currently not supported. */
589 gdb_assert (block
.per_cu
== per_cu
);
591 ctx
->eval (block
.data
, block
.size
);
594 /* Given context CTX, section offset SECT_OFF, and compilation unit
595 data PER_CU, execute the "variable value" operation on the DIE
596 found at SECT_OFF. */
598 static struct value
*
599 sect_variable_value (struct dwarf_expr_context
*ctx
, sect_offset sect_off
,
600 struct dwarf2_per_cu_data
*per_cu
)
602 struct type
*die_type
= dwarf2_fetch_die_type_sect_off (sect_off
, per_cu
);
604 if (die_type
== NULL
)
605 error (_("Bad DW_OP_GNU_variable_value DIE."));
607 /* Note: Things still work when the following test is removed. This
608 test and error is here to conform to the proposed specification. */
609 if (die_type
->code () != TYPE_CODE_INT
610 && die_type
->code () != TYPE_CODE_PTR
)
611 error (_("Type of DW_OP_GNU_variable_value DIE must be an integer or pointer."));
613 struct type
*type
= lookup_pointer_type (die_type
);
614 struct frame_info
*frame
= get_selected_frame (_("No frame selected."));
615 return indirect_synthetic_pointer (sect_off
, 0, per_cu
, frame
, type
, true);
618 class dwarf_evaluate_loc_desc
: public dwarf_expr_context
622 struct frame_info
*frame
;
623 struct dwarf2_per_cu_data
*per_cu
;
624 CORE_ADDR obj_address
;
626 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
627 the frame in BATON. */
629 CORE_ADDR
get_frame_cfa () override
631 return dwarf2_frame_cfa (frame
);
634 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
635 the frame in BATON. */
637 CORE_ADDR
get_frame_pc () override
639 return get_frame_address_in_block (frame
);
642 /* Using the objfile specified in BATON, find the address for the
643 current thread's thread-local storage with offset OFFSET. */
644 CORE_ADDR
get_tls_address (CORE_ADDR offset
) override
646 struct objfile
*objfile
= per_cu
->objfile ();
648 return target_translate_tls_address (objfile
, offset
);
651 /* Helper interface of per_cu_dwarf_call for
652 dwarf2_evaluate_loc_desc. */
654 void dwarf_call (cu_offset die_offset
) override
656 per_cu_dwarf_call (this, die_offset
, per_cu
);
659 /* Helper interface of sect_variable_value for
660 dwarf2_evaluate_loc_desc. */
662 struct value
*dwarf_variable_value (sect_offset sect_off
) override
664 return sect_variable_value (this, sect_off
, per_cu
);
667 struct type
*get_base_type (cu_offset die_offset
, int size
) override
669 struct type
*result
= dwarf2_get_die_type (die_offset
, per_cu
);
671 error (_("Could not find type for DW_OP_const_type"));
672 if (size
!= 0 && TYPE_LENGTH (result
) != size
)
673 error (_("DW_OP_const_type has different sizes for type and data"));
677 /* Callback function for dwarf2_evaluate_loc_desc.
678 Fetch the address indexed by DW_OP_addrx or DW_OP_GNU_addr_index. */
680 CORE_ADDR
get_addr_index (unsigned int index
) override
682 return dwarf2_read_addr_index (per_cu
, index
);
685 /* Callback function for get_object_address. Return the address of the VLA
688 CORE_ADDR
get_object_address () override
690 if (obj_address
== 0)
691 error (_("Location address is not set."));
695 /* Execute DWARF block of call_site_parameter which matches KIND and
696 KIND_U. Choose DEREF_SIZE value of that parameter. Search
697 caller of this objects's frame.
699 The caller can be from a different CU - per_cu_dwarf_call
700 implementation can be more simple as it does not support cross-CU
703 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
704 union call_site_parameter_u kind_u
,
705 int deref_size
) override
707 struct frame_info
*caller_frame
;
708 struct dwarf2_per_cu_data
*caller_per_cu
;
709 struct call_site_parameter
*parameter
;
710 const gdb_byte
*data_src
;
713 caller_frame
= get_prev_frame (frame
);
715 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
717 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
718 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
720 /* DEREF_SIZE size is not verified here. */
721 if (data_src
== NULL
)
722 throw_error (NO_ENTRY_VALUE_ERROR
,
723 _("Cannot resolve DW_AT_call_data_value"));
725 scoped_restore save_frame
= make_scoped_restore (&this->frame
,
727 scoped_restore save_per_cu
= make_scoped_restore (&this->per_cu
,
729 scoped_restore save_obj_addr
= make_scoped_restore (&this->obj_address
,
732 scoped_restore save_arch
= make_scoped_restore (&this->gdbarch
);
733 this->gdbarch
= per_cu
->objfile ()->arch ();
734 scoped_restore save_addr_size
= make_scoped_restore (&this->addr_size
);
735 this->addr_size
= per_cu
->addr_size ();
736 scoped_restore save_offset
= make_scoped_restore (&this->offset
);
737 this->offset
= per_cu
->text_offset ();
739 this->eval (data_src
, size
);
742 /* Using the frame specified in BATON, find the location expression
743 describing the frame base. Return a pointer to it in START and
744 its length in LENGTH. */
745 void get_frame_base (const gdb_byte
**start
, size_t * length
) override
747 /* FIXME: cagney/2003-03-26: This code should be using
748 get_frame_base_address(), and then implement a dwarf2 specific
750 struct symbol
*framefunc
;
751 const struct block
*bl
= get_frame_block (frame
, NULL
);
754 error (_("frame address is not available."));
756 /* Use block_linkage_function, which returns a real (not inlined)
757 function, instead of get_frame_function, which may return an
759 framefunc
= block_linkage_function (bl
);
761 /* If we found a frame-relative symbol then it was certainly within
762 some function associated with a frame. If we can't find the frame,
763 something has gone wrong. */
764 gdb_assert (framefunc
!= NULL
);
766 func_get_frame_base_dwarf_block (framefunc
,
767 get_frame_address_in_block (frame
),
771 /* Read memory at ADDR (length LEN) into BUF. */
773 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
775 read_memory (addr
, buf
, len
);
778 /* Using the frame specified in BATON, return the value of register
779 REGNUM, treated as a pointer. */
780 CORE_ADDR
read_addr_from_reg (int dwarf_regnum
) override
782 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
783 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
785 return address_from_register (regnum
, frame
);
788 /* Implement "get_reg_value" callback. */
790 struct value
*get_reg_value (struct type
*type
, int dwarf_regnum
) override
792 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
793 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
795 return value_from_register (type
, regnum
, frame
);
799 /* See dwarf2loc.h. */
801 unsigned int entry_values_debug
= 0;
803 /* Helper to set entry_values_debug. */
806 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
807 struct cmd_list_element
*c
, const char *value
)
809 fprintf_filtered (file
,
810 _("Entry values and tail call frames debugging is %s.\n"),
814 /* Find DW_TAG_call_site's DW_AT_call_target address.
815 CALLER_FRAME (for registers) can be NULL if it is not known. This function
816 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
819 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
820 struct call_site
*call_site
,
821 struct frame_info
*caller_frame
)
823 switch (FIELD_LOC_KIND (call_site
->target
))
825 case FIELD_LOC_KIND_DWARF_BLOCK
:
827 struct dwarf2_locexpr_baton
*dwarf_block
;
829 struct type
*caller_core_addr_type
;
830 struct gdbarch
*caller_arch
;
832 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
833 if (dwarf_block
== NULL
)
835 struct bound_minimal_symbol msym
;
837 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
838 throw_error (NO_ENTRY_VALUE_ERROR
,
839 _("DW_AT_call_target is not specified at %s in %s"),
840 paddress (call_site_gdbarch
, call_site
->pc
),
841 (msym
.minsym
== NULL
? "???"
842 : msym
.minsym
->print_name ()));
845 if (caller_frame
== NULL
)
847 struct bound_minimal_symbol msym
;
849 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
850 throw_error (NO_ENTRY_VALUE_ERROR
,
851 _("DW_AT_call_target DWARF block resolving "
852 "requires known frame which is currently not "
853 "available at %s in %s"),
854 paddress (call_site_gdbarch
, call_site
->pc
),
855 (msym
.minsym
== NULL
? "???"
856 : msym
.minsym
->print_name ()));
859 caller_arch
= get_frame_arch (caller_frame
);
860 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
861 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
862 dwarf_block
->data
, dwarf_block
->size
,
863 dwarf_block
->per_cu
);
864 /* DW_AT_call_target is a DWARF expression, not a DWARF location. */
865 if (VALUE_LVAL (val
) == lval_memory
)
866 return value_address (val
);
868 return value_as_address (val
);
871 case FIELD_LOC_KIND_PHYSNAME
:
873 const char *physname
;
874 struct bound_minimal_symbol msym
;
876 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
878 /* Handle both the mangled and demangled PHYSNAME. */
879 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
880 if (msym
.minsym
== NULL
)
882 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
883 throw_error (NO_ENTRY_VALUE_ERROR
,
884 _("Cannot find function \"%s\" for a call site target "
886 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
887 (msym
.minsym
== NULL
? "???"
888 : msym
.minsym
->print_name ()));
891 return BMSYMBOL_VALUE_ADDRESS (msym
);
894 case FIELD_LOC_KIND_PHYSADDR
:
895 return FIELD_STATIC_PHYSADDR (call_site
->target
);
898 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
902 /* Convert function entry point exact address ADDR to the function which is
903 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
904 NO_ENTRY_VALUE_ERROR otherwise. */
906 static struct symbol
*
907 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
909 struct symbol
*sym
= find_pc_function (addr
);
912 if (sym
== NULL
|| BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
913 throw_error (NO_ENTRY_VALUE_ERROR
,
914 _("DW_TAG_call_site resolving failed to find function "
915 "name for address %s"),
916 paddress (gdbarch
, addr
));
918 type
= SYMBOL_TYPE (sym
);
919 gdb_assert (type
->code () == TYPE_CODE_FUNC
);
920 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
925 /* Verify function with entry point exact address ADDR can never call itself
926 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
927 can call itself via tail calls.
929 If a funtion can tail call itself its entry value based parameters are
930 unreliable. There is no verification whether the value of some/all
931 parameters is unchanged through the self tail call, we expect if there is
932 a self tail call all the parameters can be modified. */
935 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
939 /* The verification is completely unordered. Track here function addresses
940 which still need to be iterated. */
941 std::vector
<CORE_ADDR
> todo
;
943 /* Track here CORE_ADDRs which were already visited. */
944 std::unordered_set
<CORE_ADDR
> addr_hash
;
946 todo
.push_back (verify_addr
);
947 while (!todo
.empty ())
949 struct symbol
*func_sym
;
950 struct call_site
*call_site
;
955 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
957 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
958 call_site
; call_site
= call_site
->tail_call_next
)
960 CORE_ADDR target_addr
;
962 /* CALLER_FRAME with registers is not available for tail-call jumped
964 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
966 if (target_addr
== verify_addr
)
968 struct bound_minimal_symbol msym
;
970 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
971 throw_error (NO_ENTRY_VALUE_ERROR
,
972 _("DW_OP_entry_value resolving has found "
973 "function \"%s\" at %s can call itself via tail "
975 (msym
.minsym
== NULL
? "???"
976 : msym
.minsym
->print_name ()),
977 paddress (gdbarch
, verify_addr
));
980 if (addr_hash
.insert (target_addr
).second
)
981 todo
.push_back (target_addr
);
986 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
987 ENTRY_VALUES_DEBUG. */
990 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
992 CORE_ADDR addr
= call_site
->pc
;
993 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
995 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
996 (msym
.minsym
== NULL
? "???"
997 : msym
.minsym
->print_name ()));
1001 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
1002 only top callers and bottom callees which are present in both. GDBARCH is
1003 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
1004 no remaining possibilities to provide unambiguous non-trivial result.
1005 RESULTP should point to NULL on the first (initialization) call. Caller is
1006 responsible for xfree of any RESULTP data. */
1009 chain_candidate (struct gdbarch
*gdbarch
,
1010 gdb::unique_xmalloc_ptr
<struct call_site_chain
> *resultp
,
1011 std::vector
<struct call_site
*> *chain
)
1013 long length
= chain
->size ();
1014 int callers
, callees
, idx
;
1016 if (*resultp
== NULL
)
1018 /* Create the initial chain containing all the passed PCs. */
1020 struct call_site_chain
*result
1021 = ((struct call_site_chain
*)
1022 xmalloc (sizeof (*result
)
1023 + sizeof (*result
->call_site
) * (length
- 1)));
1024 result
->length
= length
;
1025 result
->callers
= result
->callees
= length
;
1026 if (!chain
->empty ())
1027 memcpy (result
->call_site
, chain
->data (),
1028 sizeof (*result
->call_site
) * length
);
1029 resultp
->reset (result
);
1031 if (entry_values_debug
)
1033 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
1034 for (idx
= 0; idx
< length
; idx
++)
1035 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
1036 fputc_unfiltered ('\n', gdb_stdlog
);
1042 if (entry_values_debug
)
1044 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
1045 for (idx
= 0; idx
< length
; idx
++)
1046 tailcall_dump (gdbarch
, chain
->at (idx
));
1047 fputc_unfiltered ('\n', gdb_stdlog
);
1050 /* Intersect callers. */
1052 callers
= std::min ((long) (*resultp
)->callers
, length
);
1053 for (idx
= 0; idx
< callers
; idx
++)
1054 if ((*resultp
)->call_site
[idx
] != chain
->at (idx
))
1056 (*resultp
)->callers
= idx
;
1060 /* Intersect callees. */
1062 callees
= std::min ((long) (*resultp
)->callees
, length
);
1063 for (idx
= 0; idx
< callees
; idx
++)
1064 if ((*resultp
)->call_site
[(*resultp
)->length
- 1 - idx
]
1065 != chain
->at (length
- 1 - idx
))
1067 (*resultp
)->callees
= idx
;
1071 if (entry_values_debug
)
1073 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
1074 for (idx
= 0; idx
< (*resultp
)->callers
; idx
++)
1075 tailcall_dump (gdbarch
, (*resultp
)->call_site
[idx
]);
1076 fputs_unfiltered (" |", gdb_stdlog
);
1077 for (idx
= 0; idx
< (*resultp
)->callees
; idx
++)
1078 tailcall_dump (gdbarch
,
1079 (*resultp
)->call_site
[(*resultp
)->length
1080 - (*resultp
)->callees
+ idx
]);
1081 fputc_unfiltered ('\n', gdb_stdlog
);
1084 if ((*resultp
)->callers
== 0 && (*resultp
)->callees
== 0)
1086 /* There are no common callers or callees. It could be also a direct
1087 call (which has length 0) with ambiguous possibility of an indirect
1088 call - CALLERS == CALLEES == 0 is valid during the first allocation
1089 but any subsequence processing of such entry means ambiguity. */
1090 resultp
->reset (NULL
);
1094 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
1095 PC again. In such case there must be two different code paths to reach
1096 it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
1097 gdb_assert ((*resultp
)->callers
+ (*resultp
)->callees
<= (*resultp
)->length
);
1100 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1101 assumed frames between them use GDBARCH. Use depth first search so we can
1102 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
1103 would have needless GDB stack overhead. Any unreliability results
1104 in thrown NO_ENTRY_VALUE_ERROR. */
1106 static gdb::unique_xmalloc_ptr
<call_site_chain
>
1107 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1108 CORE_ADDR callee_pc
)
1110 CORE_ADDR save_callee_pc
= callee_pc
;
1111 gdb::unique_xmalloc_ptr
<struct call_site_chain
> retval
;
1112 struct call_site
*call_site
;
1114 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
1115 call_site nor any possible call_site at CALLEE_PC's function is there.
1116 Any CALL_SITE in CHAIN will be iterated to its siblings - via
1117 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
1118 std::vector
<struct call_site
*> chain
;
1120 /* We are not interested in the specific PC inside the callee function. */
1121 callee_pc
= get_pc_function_start (callee_pc
);
1123 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
1124 paddress (gdbarch
, save_callee_pc
));
1126 /* Mark CALL_SITEs so we do not visit the same ones twice. */
1127 std::unordered_set
<CORE_ADDR
> addr_hash
;
1129 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
1130 at the target's function. All the possible tail call sites in the
1131 target's function will get iterated as already pushed into CHAIN via their
1133 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1137 CORE_ADDR target_func_addr
;
1138 struct call_site
*target_call_site
;
1140 /* CALLER_FRAME with registers is not available for tail-call jumped
1142 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
1144 if (target_func_addr
== callee_pc
)
1146 chain_candidate (gdbarch
, &retval
, &chain
);
1150 /* There is no way to reach CALLEE_PC again as we would prevent
1151 entering it twice as being already marked in ADDR_HASH. */
1152 target_call_site
= NULL
;
1156 struct symbol
*target_func
;
1158 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
1159 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
1164 /* Attempt to visit TARGET_CALL_SITE. */
1166 if (target_call_site
)
1168 if (addr_hash
.insert (target_call_site
->pc
).second
)
1170 /* Successfully entered TARGET_CALL_SITE. */
1172 chain
.push_back (target_call_site
);
1177 /* Backtrack (without revisiting the originating call_site). Try the
1178 callers's sibling; if there isn't any try the callers's callers's
1181 target_call_site
= NULL
;
1182 while (!chain
.empty ())
1184 call_site
= chain
.back ();
1187 size_t removed
= addr_hash
.erase (call_site
->pc
);
1188 gdb_assert (removed
== 1);
1190 target_call_site
= call_site
->tail_call_next
;
1191 if (target_call_site
)
1195 while (target_call_site
);
1200 call_site
= chain
.back ();
1205 struct bound_minimal_symbol msym_caller
, msym_callee
;
1207 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
1208 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
1209 throw_error (NO_ENTRY_VALUE_ERROR
,
1210 _("There are no unambiguously determinable intermediate "
1211 "callers or callees between caller function \"%s\" at %s "
1212 "and callee function \"%s\" at %s"),
1213 (msym_caller
.minsym
== NULL
1214 ? "???" : msym_caller
.minsym
->print_name ()),
1215 paddress (gdbarch
, caller_pc
),
1216 (msym_callee
.minsym
== NULL
1217 ? "???" : msym_callee
.minsym
->print_name ()),
1218 paddress (gdbarch
, callee_pc
));
1224 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1225 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
1226 constructed return NULL. */
1228 gdb::unique_xmalloc_ptr
<call_site_chain
>
1229 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1230 CORE_ADDR callee_pc
)
1232 gdb::unique_xmalloc_ptr
<call_site_chain
> retval
;
1236 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
1238 catch (const gdb_exception_error
&e
)
1240 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
1242 if (entry_values_debug
)
1243 exception_print (gdb_stdout
, e
);
1254 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1257 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1258 enum call_site_parameter_kind kind
,
1259 union call_site_parameter_u kind_u
)
1261 if (kind
== parameter
->kind
)
1264 case CALL_SITE_PARAMETER_DWARF_REG
:
1265 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1266 case CALL_SITE_PARAMETER_FB_OFFSET
:
1267 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1268 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1269 return kind_u
.param_cu_off
== parameter
->u
.param_cu_off
;
1274 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1275 FRAME is for callee.
1277 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1280 static struct call_site_parameter
*
1281 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1282 enum call_site_parameter_kind kind
,
1283 union call_site_parameter_u kind_u
,
1284 struct dwarf2_per_cu_data
**per_cu_return
)
1286 CORE_ADDR func_addr
, caller_pc
;
1287 struct gdbarch
*gdbarch
;
1288 struct frame_info
*caller_frame
;
1289 struct call_site
*call_site
;
1291 /* Initialize it just to avoid a GCC false warning. */
1292 struct call_site_parameter
*parameter
= NULL
;
1293 CORE_ADDR target_addr
;
1295 while (get_frame_type (frame
) == INLINE_FRAME
)
1297 frame
= get_prev_frame (frame
);
1298 gdb_assert (frame
!= NULL
);
1301 func_addr
= get_frame_func (frame
);
1302 gdbarch
= get_frame_arch (frame
);
1303 caller_frame
= get_prev_frame (frame
);
1304 if (gdbarch
!= frame_unwind_arch (frame
))
1306 struct bound_minimal_symbol msym
1307 = lookup_minimal_symbol_by_pc (func_addr
);
1308 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1310 throw_error (NO_ENTRY_VALUE_ERROR
,
1311 _("DW_OP_entry_value resolving callee gdbarch %s "
1312 "(of %s (%s)) does not match caller gdbarch %s"),
1313 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1314 paddress (gdbarch
, func_addr
),
1315 (msym
.minsym
== NULL
? "???"
1316 : msym
.minsym
->print_name ()),
1317 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1320 if (caller_frame
== NULL
)
1322 struct bound_minimal_symbol msym
1323 = lookup_minimal_symbol_by_pc (func_addr
);
1325 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_entry_value resolving "
1326 "requires caller of %s (%s)"),
1327 paddress (gdbarch
, func_addr
),
1328 (msym
.minsym
== NULL
? "???"
1329 : msym
.minsym
->print_name ()));
1331 caller_pc
= get_frame_pc (caller_frame
);
1332 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1334 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1335 if (target_addr
!= func_addr
)
1337 struct minimal_symbol
*target_msym
, *func_msym
;
1339 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1340 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1341 throw_error (NO_ENTRY_VALUE_ERROR
,
1342 _("DW_OP_entry_value resolving expects callee %s at %s "
1343 "but the called frame is for %s at %s"),
1344 (target_msym
== NULL
? "???"
1345 : target_msym
->print_name ()),
1346 paddress (gdbarch
, target_addr
),
1347 func_msym
== NULL
? "???" : func_msym
->print_name (),
1348 paddress (gdbarch
, func_addr
));
1351 /* No entry value based parameters would be reliable if this function can
1352 call itself via tail calls. */
1353 func_verify_no_selftailcall (gdbarch
, func_addr
);
1355 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1357 parameter
= &call_site
->parameter
[iparams
];
1358 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1361 if (iparams
== call_site
->parameter_count
)
1363 struct minimal_symbol
*msym
1364 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1366 /* DW_TAG_call_site_parameter will be missing just if GCC could not
1367 determine its value. */
1368 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1369 "at DW_TAG_call_site %s at %s"),
1370 paddress (gdbarch
, caller_pc
),
1371 msym
== NULL
? "???" : msym
->print_name ());
1374 *per_cu_return
= call_site
->per_cu
;
1378 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1379 the normal DW_AT_call_value block. Otherwise return the
1380 DW_AT_call_data_value (dereferenced) block.
1382 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1385 Function always returns non-NULL, non-optimized out value. It throws
1386 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1388 static struct value
*
1389 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1390 CORE_ADDR deref_size
, struct type
*type
,
1391 struct frame_info
*caller_frame
,
1392 struct dwarf2_per_cu_data
*per_cu
)
1394 const gdb_byte
*data_src
;
1398 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1399 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1401 /* DEREF_SIZE size is not verified here. */
1402 if (data_src
== NULL
)
1403 throw_error (NO_ENTRY_VALUE_ERROR
,
1404 _("Cannot resolve DW_AT_call_data_value"));
1406 /* DW_AT_call_value is a DWARF expression, not a DWARF
1407 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1409 data
= (gdb_byte
*) alloca (size
+ 1);
1410 memcpy (data
, data_src
, size
);
1411 data
[size
] = DW_OP_stack_value
;
1413 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1416 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1417 the indirect method on it, that is use its stored target value, the sole
1418 purpose of entry_data_value_funcs.. */
1420 static struct value
*
1421 entry_data_value_coerce_ref (const struct value
*value
)
1423 struct type
*checked_type
= check_typedef (value_type (value
));
1424 struct value
*target_val
;
1426 if (!TYPE_IS_REFERENCE (checked_type
))
1429 target_val
= (struct value
*) value_computed_closure (value
);
1430 value_incref (target_val
);
1434 /* Implement copy_closure. */
1437 entry_data_value_copy_closure (const struct value
*v
)
1439 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1441 value_incref (target_val
);
1445 /* Implement free_closure. */
1448 entry_data_value_free_closure (struct value
*v
)
1450 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1452 value_decref (target_val
);
1455 /* Vector for methods for an entry value reference where the referenced value
1456 is stored in the caller. On the first dereference use
1457 DW_AT_call_data_value in the caller. */
1459 static const struct lval_funcs entry_data_value_funcs
=
1463 NULL
, /* indirect */
1464 entry_data_value_coerce_ref
,
1465 NULL
, /* check_synthetic_pointer */
1466 entry_data_value_copy_closure
,
1467 entry_data_value_free_closure
1470 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1471 are used to match DW_AT_location at the caller's
1472 DW_TAG_call_site_parameter.
1474 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1475 cannot resolve the parameter for any reason. */
1477 static struct value
*
1478 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1479 enum call_site_parameter_kind kind
,
1480 union call_site_parameter_u kind_u
)
1482 struct type
*checked_type
= check_typedef (type
);
1483 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1484 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1485 struct value
*outer_val
, *target_val
, *val
;
1486 struct call_site_parameter
*parameter
;
1487 struct dwarf2_per_cu_data
*caller_per_cu
;
1489 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1492 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1496 /* Check if DW_AT_call_data_value cannot be used. If it should be
1497 used and it is not available do not fall back to OUTER_VAL - dereferencing
1498 TYPE_CODE_REF with non-entry data value would give current value - not the
1501 if (!TYPE_IS_REFERENCE (checked_type
)
1502 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1505 target_val
= dwarf_entry_parameter_to_value (parameter
,
1506 TYPE_LENGTH (target_type
),
1507 target_type
, caller_frame
,
1510 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1511 release_value (target_val
).release ());
1513 /* Copy the referencing pointer to the new computed value. */
1514 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1515 TYPE_LENGTH (checked_type
));
1516 set_value_lazy (val
, 0);
1521 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1522 SIZE are DWARF block used to match DW_AT_location at the caller's
1523 DW_TAG_call_site_parameter.
1525 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1526 cannot resolve the parameter for any reason. */
1528 static struct value
*
1529 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1530 const gdb_byte
*block
, size_t block_len
)
1532 union call_site_parameter_u kind_u
;
1534 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1535 if (kind_u
.dwarf_reg
!= -1)
1536 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1539 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1540 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1543 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1544 suppressed during normal operation. The expression can be arbitrary if
1545 there is no caller-callee entry value binding expected. */
1546 throw_error (NO_ENTRY_VALUE_ERROR
,
1547 _("DWARF-2 expression error: DW_OP_entry_value is supported "
1548 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1551 struct piece_closure
1553 /* Reference count. */
1556 /* The objfile from which this closure's expression came. */
1557 dwarf2_per_objfile
*per_objfile
= nullptr;
1559 /* The CU from which this closure's expression came. */
1560 struct dwarf2_per_cu_data
*per_cu
= NULL
;
1562 /* The pieces describing this variable. */
1563 std::vector
<dwarf_expr_piece
> pieces
;
1565 /* Frame ID of frame to which a register value is relative, used
1566 only by DWARF_VALUE_REGISTER. */
1567 struct frame_id frame_id
;
1570 /* Allocate a closure for a value formed from separately-described
1573 static struct piece_closure
*
1574 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1575 std::vector
<dwarf_expr_piece
> &&pieces
,
1576 struct frame_info
*frame
)
1578 struct piece_closure
*c
= new piece_closure
;
1581 /* We must capture this here due to sharing of DWARF state. */
1582 c
->per_objfile
= per_cu
->dwarf2_per_objfile
;
1584 c
->pieces
= std::move (pieces
);
1586 c
->frame_id
= null_frame_id
;
1588 c
->frame_id
= get_frame_id (frame
);
1590 for (dwarf_expr_piece
&piece
: c
->pieces
)
1591 if (piece
.location
== DWARF_VALUE_STACK
)
1592 value_incref (piece
.v
.value
);
1597 /* Return the number of bytes overlapping a contiguous chunk of N_BITS
1598 bits whose first bit is located at bit offset START. */
1601 bits_to_bytes (ULONGEST start
, ULONGEST n_bits
)
1603 return (start
% 8 + n_bits
+ 7) / 8;
1606 /* Read or write a pieced value V. If FROM != NULL, operate in "write
1607 mode": copy FROM into the pieces comprising V. If FROM == NULL,
1608 operate in "read mode": fetch the contents of the (lazy) value V by
1609 composing it from its pieces. */
1612 rw_pieced_value (struct value
*v
, struct value
*from
)
1615 LONGEST offset
= 0, max_offset
;
1616 ULONGEST bits_to_skip
;
1617 gdb_byte
*v_contents
;
1618 const gdb_byte
*from_contents
;
1619 struct piece_closure
*c
1620 = (struct piece_closure
*) value_computed_closure (v
);
1621 gdb::byte_vector buffer
;
1622 bool bits_big_endian
= type_byte_order (value_type (v
)) == BFD_ENDIAN_BIG
;
1626 from_contents
= value_contents (from
);
1631 if (value_type (v
) != value_enclosing_type (v
))
1632 internal_error (__FILE__
, __LINE__
,
1633 _("Should not be able to create a lazy value with "
1634 "an enclosing type"));
1635 v_contents
= value_contents_raw (v
);
1636 from_contents
= NULL
;
1639 bits_to_skip
= 8 * value_offset (v
);
1640 if (value_bitsize (v
))
1642 bits_to_skip
+= (8 * value_offset (value_parent (v
))
1643 + value_bitpos (v
));
1645 && (type_byte_order (value_type (from
))
1648 /* Use the least significant bits of FROM. */
1649 max_offset
= 8 * TYPE_LENGTH (value_type (from
));
1650 offset
= max_offset
- value_bitsize (v
);
1653 max_offset
= value_bitsize (v
);
1656 max_offset
= 8 * TYPE_LENGTH (value_type (v
));
1658 /* Advance to the first non-skipped piece. */
1659 for (i
= 0; i
< c
->pieces
.size () && bits_to_skip
>= c
->pieces
[i
].size
; i
++)
1660 bits_to_skip
-= c
->pieces
[i
].size
;
1662 for (; i
< c
->pieces
.size () && offset
< max_offset
; i
++)
1664 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1665 size_t this_size_bits
, this_size
;
1667 this_size_bits
= p
->size
- bits_to_skip
;
1668 if (this_size_bits
> max_offset
- offset
)
1669 this_size_bits
= max_offset
- offset
;
1671 switch (p
->location
)
1673 case DWARF_VALUE_REGISTER
:
1675 struct frame_info
*frame
= frame_find_by_id (c
->frame_id
);
1676 struct gdbarch
*arch
= get_frame_arch (frame
);
1677 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, p
->v
.regno
);
1678 ULONGEST reg_bits
= 8 * register_size (arch
, gdb_regnum
);
1681 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1682 && p
->offset
+ p
->size
< reg_bits
)
1684 /* Big-endian, and we want less than full size. */
1685 bits_to_skip
+= reg_bits
- (p
->offset
+ p
->size
);
1688 bits_to_skip
+= p
->offset
;
1690 this_size
= bits_to_bytes (bits_to_skip
, this_size_bits
);
1691 buffer
.resize (this_size
);
1696 if (!get_frame_register_bytes (frame
, gdb_regnum
,
1698 this_size
, buffer
.data (),
1702 mark_value_bits_optimized_out (v
, offset
,
1705 mark_value_bits_unavailable (v
, offset
,
1710 copy_bitwise (v_contents
, offset
,
1711 buffer
.data (), bits_to_skip
% 8,
1712 this_size_bits
, bits_big_endian
);
1717 if (bits_to_skip
% 8 != 0 || this_size_bits
% 8 != 0)
1719 /* Data is copied non-byte-aligned into the register.
1720 Need some bits from original register value. */
1721 get_frame_register_bytes (frame
, gdb_regnum
,
1723 this_size
, buffer
.data (),
1726 throw_error (OPTIMIZED_OUT_ERROR
,
1727 _("Can't do read-modify-write to "
1728 "update bitfield; containing word "
1729 "has been optimized out"));
1731 throw_error (NOT_AVAILABLE_ERROR
,
1732 _("Can't do read-modify-write to "
1733 "update bitfield; containing word "
1737 copy_bitwise (buffer
.data (), bits_to_skip
% 8,
1738 from_contents
, offset
,
1739 this_size_bits
, bits_big_endian
);
1740 put_frame_register_bytes (frame
, gdb_regnum
,
1742 this_size
, buffer
.data ());
1747 case DWARF_VALUE_MEMORY
:
1749 bits_to_skip
+= p
->offset
;
1751 CORE_ADDR start_addr
= p
->v
.mem
.addr
+ bits_to_skip
/ 8;
1753 if (bits_to_skip
% 8 == 0 && this_size_bits
% 8 == 0
1756 /* Everything is byte-aligned; no buffer needed. */
1758 write_memory_with_notification (start_addr
,
1761 this_size_bits
/ 8);
1763 read_value_memory (v
, offset
,
1764 p
->v
.mem
.in_stack_memory
,
1765 p
->v
.mem
.addr
+ bits_to_skip
/ 8,
1766 v_contents
+ offset
/ 8,
1767 this_size_bits
/ 8);
1771 this_size
= bits_to_bytes (bits_to_skip
, this_size_bits
);
1772 buffer
.resize (this_size
);
1777 read_value_memory (v
, offset
,
1778 p
->v
.mem
.in_stack_memory
,
1779 p
->v
.mem
.addr
+ bits_to_skip
/ 8,
1780 buffer
.data (), this_size
);
1781 copy_bitwise (v_contents
, offset
,
1782 buffer
.data (), bits_to_skip
% 8,
1783 this_size_bits
, bits_big_endian
);
1788 if (bits_to_skip
% 8 != 0 || this_size_bits
% 8 != 0)
1792 /* Perform a single read for small sizes. */
1793 read_memory (start_addr
, buffer
.data (),
1798 /* Only the first and last bytes can possibly have
1800 read_memory (start_addr
, buffer
.data (), 1);
1801 read_memory (start_addr
+ this_size
- 1,
1802 &buffer
[this_size
- 1], 1);
1806 copy_bitwise (buffer
.data (), bits_to_skip
% 8,
1807 from_contents
, offset
,
1808 this_size_bits
, bits_big_endian
);
1809 write_memory_with_notification (start_addr
,
1816 case DWARF_VALUE_STACK
:
1820 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1824 struct objfile
*objfile
= c
->per_cu
->objfile ();
1825 struct gdbarch
*objfile_gdbarch
= objfile
->arch ();
1826 ULONGEST stack_value_size_bits
1827 = 8 * TYPE_LENGTH (value_type (p
->v
.value
));
1829 /* Use zeroes if piece reaches beyond stack value. */
1830 if (p
->offset
+ p
->size
> stack_value_size_bits
)
1833 /* Piece is anchored at least significant bit end. */
1834 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
1835 bits_to_skip
+= stack_value_size_bits
- p
->offset
- p
->size
;
1837 bits_to_skip
+= p
->offset
;
1839 copy_bitwise (v_contents
, offset
,
1840 value_contents_all (p
->v
.value
),
1842 this_size_bits
, bits_big_endian
);
1846 case DWARF_VALUE_LITERAL
:
1850 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1854 ULONGEST literal_size_bits
= 8 * p
->v
.literal
.length
;
1855 size_t n
= this_size_bits
;
1857 /* Cut off at the end of the implicit value. */
1858 bits_to_skip
+= p
->offset
;
1859 if (bits_to_skip
>= literal_size_bits
)
1861 if (n
> literal_size_bits
- bits_to_skip
)
1862 n
= literal_size_bits
- bits_to_skip
;
1864 copy_bitwise (v_contents
, offset
,
1865 p
->v
.literal
.data
, bits_to_skip
,
1866 n
, bits_big_endian
);
1870 case DWARF_VALUE_IMPLICIT_POINTER
:
1873 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1877 /* These bits show up as zeros -- but do not cause the value to
1878 be considered optimized-out. */
1881 case DWARF_VALUE_OPTIMIZED_OUT
:
1882 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1886 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1889 offset
+= this_size_bits
;
1896 read_pieced_value (struct value
*v
)
1898 rw_pieced_value (v
, NULL
);
1902 write_pieced_value (struct value
*to
, struct value
*from
)
1904 rw_pieced_value (to
, from
);
1907 /* An implementation of an lval_funcs method to see whether a value is
1908 a synthetic pointer. */
1911 check_pieced_synthetic_pointer (const struct value
*value
, LONGEST bit_offset
,
1914 struct piece_closure
*c
1915 = (struct piece_closure
*) value_computed_closure (value
);
1918 bit_offset
+= 8 * value_offset (value
);
1919 if (value_bitsize (value
))
1920 bit_offset
+= value_bitpos (value
);
1922 for (i
= 0; i
< c
->pieces
.size () && bit_length
> 0; i
++)
1924 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1925 size_t this_size_bits
= p
->size
;
1929 if (bit_offset
>= this_size_bits
)
1931 bit_offset
-= this_size_bits
;
1935 bit_length
-= this_size_bits
- bit_offset
;
1939 bit_length
-= this_size_bits
;
1941 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1948 /* A wrapper function for get_frame_address_in_block. */
1951 get_frame_address_in_block_wrapper (void *baton
)
1953 return get_frame_address_in_block ((struct frame_info
*) baton
);
1956 /* Fetch a DW_AT_const_value through a synthetic pointer. */
1958 static struct value
*
1959 fetch_const_value_from_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
1960 struct dwarf2_per_cu_data
*per_cu
,
1963 struct value
*result
= NULL
;
1964 const gdb_byte
*bytes
;
1967 auto_obstack temp_obstack
;
1968 bytes
= dwarf2_fetch_constant_bytes (die
, per_cu
, &temp_obstack
, &len
);
1972 if (byte_offset
>= 0
1973 && byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) <= len
)
1975 bytes
+= byte_offset
;
1976 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
1979 invalid_synthetic_pointer ();
1982 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
1987 /* Fetch the value pointed to by a synthetic pointer. */
1989 static struct value
*
1990 indirect_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
1991 struct dwarf2_per_cu_data
*per_cu
,
1992 struct frame_info
*frame
, struct type
*type
,
1993 bool resolve_abstract_p
)
1995 /* Fetch the location expression of the DIE we're pointing to. */
1996 struct dwarf2_locexpr_baton baton
1997 = dwarf2_fetch_die_loc_sect_off (die
, per_cu
,
1998 get_frame_address_in_block_wrapper
, frame
,
1999 resolve_abstract_p
);
2001 /* Get type of pointed-to DIE. */
2002 struct type
*orig_type
= dwarf2_fetch_die_type_sect_off (die
, per_cu
);
2003 if (orig_type
== NULL
)
2004 invalid_synthetic_pointer ();
2006 /* If pointed-to DIE has a DW_AT_location, evaluate it and return the
2007 resulting value. Otherwise, it may have a DW_AT_const_value instead,
2008 or it may've been optimized out. */
2009 if (baton
.data
!= NULL
)
2010 return dwarf2_evaluate_loc_desc_full (orig_type
, frame
, baton
.data
,
2011 baton
.size
, baton
.per_cu
,
2012 TYPE_TARGET_TYPE (type
),
2015 return fetch_const_value_from_synthetic_pointer (die
, byte_offset
, per_cu
,
2019 /* An implementation of an lval_funcs method to indirect through a
2020 pointer. This handles the synthetic pointer case when needed. */
2022 static struct value
*
2023 indirect_pieced_value (struct value
*value
)
2025 struct piece_closure
*c
2026 = (struct piece_closure
*) value_computed_closure (value
);
2028 struct frame_info
*frame
;
2031 struct dwarf_expr_piece
*piece
= NULL
;
2032 LONGEST byte_offset
;
2033 enum bfd_endian byte_order
;
2035 type
= check_typedef (value_type (value
));
2036 if (type
->code () != TYPE_CODE_PTR
)
2039 bit_length
= 8 * TYPE_LENGTH (type
);
2040 bit_offset
= 8 * value_offset (value
);
2041 if (value_bitsize (value
))
2042 bit_offset
+= value_bitpos (value
);
2044 for (i
= 0; i
< c
->pieces
.size () && bit_length
> 0; i
++)
2046 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2047 size_t this_size_bits
= p
->size
;
2051 if (bit_offset
>= this_size_bits
)
2053 bit_offset
-= this_size_bits
;
2057 bit_length
-= this_size_bits
- bit_offset
;
2061 bit_length
-= this_size_bits
;
2063 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2066 if (bit_length
!= 0)
2067 error (_("Invalid use of DW_OP_implicit_pointer"));
2073 gdb_assert (piece
!= NULL
);
2074 frame
= get_selected_frame (_("No frame selected."));
2076 /* This is an offset requested by GDB, such as value subscripts.
2077 However, due to how synthetic pointers are implemented, this is
2078 always presented to us as a pointer type. This means we have to
2079 sign-extend it manually as appropriate. Use raw
2080 extract_signed_integer directly rather than value_as_address and
2081 sign extend afterwards on architectures that would need it
2082 (mostly everywhere except MIPS, which has signed addresses) as
2083 the later would go through gdbarch_pointer_to_address and thus
2084 return a CORE_ADDR with high bits set on architectures that
2085 encode address spaces and other things in CORE_ADDR. */
2086 byte_order
= gdbarch_byte_order (get_frame_arch (frame
));
2087 byte_offset
= extract_signed_integer (value_contents (value
),
2088 TYPE_LENGTH (type
), byte_order
);
2089 byte_offset
+= piece
->v
.ptr
.offset
;
2091 return indirect_synthetic_pointer (piece
->v
.ptr
.die_sect_off
,
2092 byte_offset
, c
->per_cu
,
2096 /* Implementation of the coerce_ref method of lval_funcs for synthetic C++
2099 static struct value
*
2100 coerce_pieced_ref (const struct value
*value
)
2102 struct type
*type
= check_typedef (value_type (value
));
2104 if (value_bits_synthetic_pointer (value
, value_embedded_offset (value
),
2105 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
2107 const struct piece_closure
*closure
2108 = (struct piece_closure
*) value_computed_closure (value
);
2109 struct frame_info
*frame
2110 = get_selected_frame (_("No frame selected."));
2112 /* gdb represents synthetic pointers as pieced values with a single
2114 gdb_assert (closure
!= NULL
);
2115 gdb_assert (closure
->pieces
.size () == 1);
2117 return indirect_synthetic_pointer
2118 (closure
->pieces
[0].v
.ptr
.die_sect_off
,
2119 closure
->pieces
[0].v
.ptr
.offset
,
2120 closure
->per_cu
, frame
, type
);
2124 /* Else: not a synthetic reference; do nothing. */
2130 copy_pieced_value_closure (const struct value
*v
)
2132 struct piece_closure
*c
2133 = (struct piece_closure
*) value_computed_closure (v
);
2140 free_pieced_value_closure (struct value
*v
)
2142 struct piece_closure
*c
2143 = (struct piece_closure
*) value_computed_closure (v
);
2148 for (dwarf_expr_piece
&p
: c
->pieces
)
2149 if (p
.location
== DWARF_VALUE_STACK
)
2150 value_decref (p
.v
.value
);
2156 /* Functions for accessing a variable described by DW_OP_piece. */
2157 static const struct lval_funcs pieced_value_funcs
= {
2160 indirect_pieced_value
,
2162 check_pieced_synthetic_pointer
,
2163 copy_pieced_value_closure
,
2164 free_pieced_value_closure
2167 /* Evaluate a location description, starting at DATA and with length
2168 SIZE, to find the current location of variable of TYPE in the
2169 context of FRAME. If SUBOBJ_TYPE is non-NULL, return instead the
2170 location of the subobject of type SUBOBJ_TYPE at byte offset
2171 SUBOBJ_BYTE_OFFSET within the variable of type TYPE. */
2173 static struct value
*
2174 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2175 const gdb_byte
*data
, size_t size
,
2176 struct dwarf2_per_cu_data
*per_cu
,
2177 struct type
*subobj_type
,
2178 LONGEST subobj_byte_offset
)
2180 struct value
*retval
;
2181 struct objfile
*objfile
= per_cu
->objfile ();
2183 if (subobj_type
== NULL
)
2186 subobj_byte_offset
= 0;
2188 else if (subobj_byte_offset
< 0)
2189 invalid_synthetic_pointer ();
2192 return allocate_optimized_out_value (subobj_type
);
2194 dwarf_evaluate_loc_desc ctx
;
2196 ctx
.per_cu
= per_cu
;
2197 ctx
.obj_address
= 0;
2199 scoped_value_mark free_values
;
2201 ctx
.gdbarch
= objfile
->arch ();
2202 ctx
.addr_size
= per_cu
->addr_size ();
2203 ctx
.ref_addr_size
= per_cu
->ref_addr_size ();
2204 ctx
.offset
= per_cu
->text_offset ();
2208 ctx
.eval (data
, size
);
2210 catch (const gdb_exception_error
&ex
)
2212 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2214 free_values
.free_to_mark ();
2215 retval
= allocate_value (subobj_type
);
2216 mark_value_bytes_unavailable (retval
, 0,
2217 TYPE_LENGTH (subobj_type
));
2220 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2222 if (entry_values_debug
)
2223 exception_print (gdb_stdout
, ex
);
2224 free_values
.free_to_mark ();
2225 return allocate_optimized_out_value (subobj_type
);
2231 if (ctx
.pieces
.size () > 0)
2233 struct piece_closure
*c
;
2234 ULONGEST bit_size
= 0;
2236 for (dwarf_expr_piece
&piece
: ctx
.pieces
)
2237 bit_size
+= piece
.size
;
2238 /* Complain if the expression is larger than the size of the
2240 if (bit_size
> 8 * TYPE_LENGTH (type
))
2241 invalid_synthetic_pointer ();
2243 c
= allocate_piece_closure (per_cu
, std::move (ctx
.pieces
), frame
);
2244 /* We must clean up the value chain after creating the piece
2245 closure but before allocating the result. */
2246 free_values
.free_to_mark ();
2247 retval
= allocate_computed_value (subobj_type
,
2248 &pieced_value_funcs
, c
);
2249 set_value_offset (retval
, subobj_byte_offset
);
2253 switch (ctx
.location
)
2255 case DWARF_VALUE_REGISTER
:
2257 struct gdbarch
*arch
= get_frame_arch (frame
);
2259 = longest_to_int (value_as_long (ctx
.fetch (0)));
2260 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, dwarf_regnum
);
2262 if (subobj_byte_offset
!= 0)
2263 error (_("cannot use offset on synthetic pointer to register"));
2264 free_values
.free_to_mark ();
2265 retval
= value_from_register (subobj_type
, gdb_regnum
, frame
);
2266 if (value_optimized_out (retval
))
2270 /* This means the register has undefined value / was
2271 not saved. As we're computing the location of some
2272 variable etc. in the program, not a value for
2273 inspecting a register ($pc, $sp, etc.), return a
2274 generic optimized out value instead, so that we show
2275 <optimized out> instead of <not saved>. */
2276 tmp
= allocate_value (subobj_type
);
2277 value_contents_copy (tmp
, 0, retval
, 0,
2278 TYPE_LENGTH (subobj_type
));
2284 case DWARF_VALUE_MEMORY
:
2286 struct type
*ptr_type
;
2287 CORE_ADDR address
= ctx
.fetch_address (0);
2288 bool in_stack_memory
= ctx
.fetch_in_stack_memory (0);
2290 /* DW_OP_deref_size (and possibly other operations too) may
2291 create a pointer instead of an address. Ideally, the
2292 pointer to address conversion would be performed as part
2293 of those operations, but the type of the object to
2294 which the address refers is not known at the time of
2295 the operation. Therefore, we do the conversion here
2296 since the type is readily available. */
2298 switch (subobj_type
->code ())
2300 case TYPE_CODE_FUNC
:
2301 case TYPE_CODE_METHOD
:
2302 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_func_ptr
;
2305 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_data_ptr
;
2308 address
= value_as_address (value_from_pointer (ptr_type
, address
));
2310 free_values
.free_to_mark ();
2311 retval
= value_at_lazy (subobj_type
,
2312 address
+ subobj_byte_offset
);
2313 if (in_stack_memory
)
2314 set_value_stack (retval
, 1);
2318 case DWARF_VALUE_STACK
:
2320 struct value
*value
= ctx
.fetch (0);
2321 size_t n
= TYPE_LENGTH (value_type (value
));
2322 size_t len
= TYPE_LENGTH (subobj_type
);
2323 size_t max
= TYPE_LENGTH (type
);
2324 struct gdbarch
*objfile_gdbarch
= objfile
->arch ();
2326 if (subobj_byte_offset
+ len
> max
)
2327 invalid_synthetic_pointer ();
2329 /* Preserve VALUE because we are going to free values back
2330 to the mark, but we still need the value contents
2332 value_ref_ptr value_holder
= value_ref_ptr::new_reference (value
);
2333 free_values
.free_to_mark ();
2335 retval
= allocate_value (subobj_type
);
2337 /* The given offset is relative to the actual object. */
2338 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2339 subobj_byte_offset
+= n
- max
;
2341 memcpy (value_contents_raw (retval
),
2342 value_contents_all (value
) + subobj_byte_offset
, len
);
2346 case DWARF_VALUE_LITERAL
:
2349 size_t n
= TYPE_LENGTH (subobj_type
);
2351 if (subobj_byte_offset
+ n
> ctx
.len
)
2352 invalid_synthetic_pointer ();
2354 free_values
.free_to_mark ();
2355 retval
= allocate_value (subobj_type
);
2356 contents
= value_contents_raw (retval
);
2357 memcpy (contents
, ctx
.data
+ subobj_byte_offset
, n
);
2361 case DWARF_VALUE_OPTIMIZED_OUT
:
2362 free_values
.free_to_mark ();
2363 retval
= allocate_optimized_out_value (subobj_type
);
2366 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2367 operation by execute_stack_op. */
2368 case DWARF_VALUE_IMPLICIT_POINTER
:
2369 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2370 it can only be encountered when making a piece. */
2372 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2376 set_value_initialized (retval
, ctx
.initialized
);
2381 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2382 passes 0 as the byte_offset. */
2385 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2386 const gdb_byte
*data
, size_t size
,
2387 struct dwarf2_per_cu_data
*per_cu
)
2389 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
,
2393 /* A specialization of dwarf_evaluate_loc_desc that is used by
2394 dwarf2_locexpr_baton_eval. This subclass exists to handle the case
2395 where a caller of dwarf2_locexpr_baton_eval passes in some data,
2396 but with the address being 0. In this situation, we arrange for
2397 memory reads to come from the passed-in buffer. */
2399 struct evaluate_for_locexpr_baton
: public dwarf_evaluate_loc_desc
2401 /* The data that was passed in. */
2402 gdb::array_view
<const gdb_byte
> data_view
;
2404 CORE_ADDR
get_object_address () override
2406 if (data_view
.data () == nullptr && obj_address
== 0)
2407 error (_("Location address is not set."));
2411 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
2416 /* Prefer the passed-in memory, if it exists. */
2417 CORE_ADDR offset
= addr
- obj_address
;
2418 if (offset
< data_view
.size () && offset
+ len
<= data_view
.size ())
2420 memcpy (buf
, data_view
.data (), len
);
2424 read_memory (addr
, buf
, len
);
2428 /* Evaluates a dwarf expression and stores the result in VAL,
2429 expecting that the dwarf expression only produces a single
2430 CORE_ADDR. FRAME is the frame in which the expression is
2431 evaluated. ADDR_STACK is a context (location of a variable) and
2432 might be needed to evaluate the location expression.
2433 PUSH_INITIAL_VALUE is true if the address (either from ADDR_STACK,
2434 or the default of 0) should be pushed on the DWARF expression
2435 evaluation stack before evaluating the expression; this is required
2436 by certain forms of DWARF expression. Returns 1 on success, 0
2440 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton
*dlbaton
,
2441 struct frame_info
*frame
,
2442 const struct property_addr_info
*addr_stack
,
2444 bool push_initial_value
)
2446 struct objfile
*objfile
;
2448 if (dlbaton
== NULL
|| dlbaton
->size
== 0)
2451 evaluate_for_locexpr_baton ctx
;
2454 ctx
.per_cu
= dlbaton
->per_cu
;
2455 if (addr_stack
== nullptr)
2456 ctx
.obj_address
= 0;
2459 ctx
.obj_address
= addr_stack
->addr
;
2460 ctx
.data_view
= addr_stack
->valaddr
;
2463 objfile
= dlbaton
->per_objfile
->objfile
;
2465 ctx
.gdbarch
= objfile
->arch ();
2466 ctx
.addr_size
= dlbaton
->per_cu
->addr_size ();
2467 ctx
.ref_addr_size
= dlbaton
->per_cu
->ref_addr_size ();
2468 ctx
.offset
= dlbaton
->per_cu
->text_offset ();
2470 if (push_initial_value
)
2471 ctx
.push_address (ctx
.obj_address
, false);
2475 ctx
.eval (dlbaton
->data
, dlbaton
->size
);
2477 catch (const gdb_exception_error
&ex
)
2479 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2483 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2485 if (entry_values_debug
)
2486 exception_print (gdb_stdout
, ex
);
2493 switch (ctx
.location
)
2495 case DWARF_VALUE_REGISTER
:
2496 case DWARF_VALUE_MEMORY
:
2497 case DWARF_VALUE_STACK
:
2498 *valp
= ctx
.fetch_address (0);
2499 if (ctx
.location
== DWARF_VALUE_REGISTER
)
2500 *valp
= ctx
.read_addr_from_reg (*valp
);
2502 case DWARF_VALUE_LITERAL
:
2503 *valp
= extract_signed_integer (ctx
.data
, ctx
.len
,
2504 gdbarch_byte_order (ctx
.gdbarch
));
2506 /* Unsupported dwarf values. */
2507 case DWARF_VALUE_OPTIMIZED_OUT
:
2508 case DWARF_VALUE_IMPLICIT_POINTER
:
2515 /* See dwarf2loc.h. */
2518 dwarf2_evaluate_property (const struct dynamic_prop
*prop
,
2519 struct frame_info
*frame
,
2520 const struct property_addr_info
*addr_stack
,
2522 bool push_initial_value
)
2527 if (frame
== NULL
&& has_stack_frames ())
2528 frame
= get_selected_frame (NULL
);
2534 const struct dwarf2_property_baton
*baton
2535 = (const struct dwarf2_property_baton
*) prop
->data
.baton
;
2536 gdb_assert (baton
->property_type
!= NULL
);
2538 if (dwarf2_locexpr_baton_eval (&baton
->locexpr
, frame
, addr_stack
,
2539 value
, push_initial_value
))
2541 if (baton
->locexpr
.is_reference
)
2543 struct value
*val
= value_at (baton
->property_type
, *value
);
2544 *value
= value_as_address (val
);
2548 gdb_assert (baton
->property_type
!= NULL
);
2550 struct type
*type
= check_typedef (baton
->property_type
);
2551 if (TYPE_LENGTH (type
) < sizeof (CORE_ADDR
)
2552 && !TYPE_UNSIGNED (type
))
2554 /* If we have a valid return candidate and it's value
2555 is signed, we have to sign-extend the value because
2556 CORE_ADDR on 64bit machine has 8 bytes but address
2557 size of an 32bit application is bytes. */
2559 = (baton
->locexpr
.per_cu
->addr_size ()
2561 const CORE_ADDR neg_mask
2562 = (~((CORE_ADDR
) 0) << (addr_size
- 1));
2564 /* Check if signed bit is set and sign-extend values. */
2565 if (*value
& neg_mask
)
2576 struct dwarf2_property_baton
*baton
2577 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2579 const gdb_byte
*data
;
2584 || !get_frame_address_in_block_if_available (frame
, &pc
))
2587 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2590 val
= dwarf2_evaluate_loc_desc (baton
->property_type
, frame
, data
,
2591 size
, baton
->loclist
.per_cu
);
2592 if (!value_optimized_out (val
))
2594 *value
= value_as_address (val
);
2602 *value
= prop
->data
.const_val
;
2605 case PROP_ADDR_OFFSET
:
2607 struct dwarf2_property_baton
*baton
2608 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2609 const struct property_addr_info
*pinfo
;
2612 for (pinfo
= addr_stack
; pinfo
!= NULL
; pinfo
= pinfo
->next
)
2614 /* This approach lets us avoid checking the qualifiers. */
2615 if (TYPE_MAIN_TYPE (pinfo
->type
)
2616 == TYPE_MAIN_TYPE (baton
->property_type
))
2620 error (_("cannot find reference address for offset property"));
2621 if (pinfo
->valaddr
.data () != NULL
)
2622 val
= value_from_contents
2623 (baton
->offset_info
.type
,
2624 pinfo
->valaddr
.data () + baton
->offset_info
.offset
);
2626 val
= value_at (baton
->offset_info
.type
,
2627 pinfo
->addr
+ baton
->offset_info
.offset
);
2628 *value
= value_as_address (val
);
2636 /* See dwarf2loc.h. */
2639 dwarf2_compile_property_to_c (string_file
*stream
,
2640 const char *result_name
,
2641 struct gdbarch
*gdbarch
,
2642 unsigned char *registers_used
,
2643 const struct dynamic_prop
*prop
,
2647 struct dwarf2_property_baton
*baton
2648 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2649 const gdb_byte
*data
;
2651 struct dwarf2_per_cu_data
*per_cu
;
2653 if (prop
->kind
== PROP_LOCEXPR
)
2655 data
= baton
->locexpr
.data
;
2656 size
= baton
->locexpr
.size
;
2657 per_cu
= baton
->locexpr
.per_cu
;
2661 gdb_assert (prop
->kind
== PROP_LOCLIST
);
2663 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2664 per_cu
= baton
->loclist
.per_cu
;
2667 compile_dwarf_bounds_to_c (stream
, result_name
, prop
, sym
, pc
,
2668 gdbarch
, registers_used
,
2669 per_cu
->addr_size (),
2670 data
, data
+ size
, per_cu
);
2674 /* Helper functions and baton for dwarf2_loc_desc_get_symbol_read_needs. */
2676 class symbol_needs_eval_context
: public dwarf_expr_context
2680 enum symbol_needs_kind needs
;
2681 struct dwarf2_per_cu_data
*per_cu
;
2683 /* Reads from registers do require a frame. */
2684 CORE_ADDR
read_addr_from_reg (int regnum
) override
2686 needs
= SYMBOL_NEEDS_FRAME
;
2690 /* "get_reg_value" callback: Reads from registers do require a
2693 struct value
*get_reg_value (struct type
*type
, int regnum
) override
2695 needs
= SYMBOL_NEEDS_FRAME
;
2696 return value_zero (type
, not_lval
);
2699 /* Reads from memory do not require a frame. */
2700 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
2702 memset (buf
, 0, len
);
2705 /* Frame-relative accesses do require a frame. */
2706 void get_frame_base (const gdb_byte
**start
, size_t *length
) override
2708 static gdb_byte lit0
= DW_OP_lit0
;
2713 needs
= SYMBOL_NEEDS_FRAME
;
2716 /* CFA accesses require a frame. */
2717 CORE_ADDR
get_frame_cfa () override
2719 needs
= SYMBOL_NEEDS_FRAME
;
2723 CORE_ADDR
get_frame_pc () override
2725 needs
= SYMBOL_NEEDS_FRAME
;
2729 /* Thread-local accesses require registers, but not a frame. */
2730 CORE_ADDR
get_tls_address (CORE_ADDR offset
) override
2732 if (needs
<= SYMBOL_NEEDS_REGISTERS
)
2733 needs
= SYMBOL_NEEDS_REGISTERS
;
2737 /* Helper interface of per_cu_dwarf_call for
2738 dwarf2_loc_desc_get_symbol_read_needs. */
2740 void dwarf_call (cu_offset die_offset
) override
2742 per_cu_dwarf_call (this, die_offset
, per_cu
);
2745 /* Helper interface of sect_variable_value for
2746 dwarf2_loc_desc_get_symbol_read_needs. */
2748 struct value
*dwarf_variable_value (sect_offset sect_off
) override
2750 return sect_variable_value (this, sect_off
, per_cu
);
2753 /* DW_OP_entry_value accesses require a caller, therefore a
2756 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
2757 union call_site_parameter_u kind_u
,
2758 int deref_size
) override
2760 needs
= SYMBOL_NEEDS_FRAME
;
2762 /* The expression may require some stub values on DWARF stack. */
2763 push_address (0, 0);
2766 /* DW_OP_addrx and DW_OP_GNU_addr_index doesn't require a frame. */
2768 CORE_ADDR
get_addr_index (unsigned int index
) override
2770 /* Nothing to do. */
2774 /* DW_OP_push_object_address has a frame already passed through. */
2776 CORE_ADDR
get_object_address () override
2778 /* Nothing to do. */
2783 /* Compute the correct symbol_needs_kind value for the location
2784 expression at DATA (length SIZE). */
2786 static enum symbol_needs_kind
2787 dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte
*data
, size_t size
,
2788 struct dwarf2_per_cu_data
*per_cu
)
2791 struct objfile
*objfile
= per_cu
->objfile ();
2793 scoped_value_mark free_values
;
2795 symbol_needs_eval_context ctx
;
2797 ctx
.needs
= SYMBOL_NEEDS_NONE
;
2798 ctx
.per_cu
= per_cu
;
2799 ctx
.gdbarch
= objfile
->arch ();
2800 ctx
.addr_size
= per_cu
->addr_size ();
2801 ctx
.ref_addr_size
= per_cu
->ref_addr_size ();
2802 ctx
.offset
= per_cu
->text_offset ();
2804 ctx
.eval (data
, size
);
2806 in_reg
= ctx
.location
== DWARF_VALUE_REGISTER
;
2808 /* If the location has several pieces, and any of them are in
2809 registers, then we will need a frame to fetch them from. */
2810 for (dwarf_expr_piece
&p
: ctx
.pieces
)
2811 if (p
.location
== DWARF_VALUE_REGISTER
)
2815 ctx
.needs
= SYMBOL_NEEDS_FRAME
;
2819 /* A helper function that throws an unimplemented error mentioning a
2820 given DWARF operator. */
2822 static void ATTRIBUTE_NORETURN
2823 unimplemented (unsigned int op
)
2825 const char *name
= get_DW_OP_name (op
);
2828 error (_("DWARF operator %s cannot be translated to an agent expression"),
2831 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2832 "to an agent expression"),
2838 This is basically a wrapper on gdbarch_dwarf2_reg_to_regnum so that we
2839 can issue a complaint, which is better than having every target's
2840 implementation of dwarf2_reg_to_regnum do it. */
2843 dwarf_reg_to_regnum (struct gdbarch
*arch
, int dwarf_reg
)
2845 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2849 complaint (_("bad DWARF register number %d"), dwarf_reg
);
2854 /* Subroutine of dwarf_reg_to_regnum_or_error to simplify it.
2855 Throw an error because DWARF_REG is bad. */
2858 throw_bad_regnum_error (ULONGEST dwarf_reg
)
2860 /* Still want to print -1 as "-1".
2861 We *could* have int and ULONGEST versions of dwarf2_reg_to_regnum_or_error
2862 but that's overkill for now. */
2863 if ((int) dwarf_reg
== dwarf_reg
)
2864 error (_("Unable to access DWARF register number %d"), (int) dwarf_reg
);
2865 error (_("Unable to access DWARF register number %s"),
2866 pulongest (dwarf_reg
));
2869 /* See dwarf2loc.h. */
2872 dwarf_reg_to_regnum_or_error (struct gdbarch
*arch
, ULONGEST dwarf_reg
)
2876 if (dwarf_reg
> INT_MAX
)
2877 throw_bad_regnum_error (dwarf_reg
);
2878 /* Yes, we will end up issuing a complaint and an error if DWARF_REG is
2879 bad, but that's ok. */
2880 reg
= dwarf_reg_to_regnum (arch
, (int) dwarf_reg
);
2882 throw_bad_regnum_error (dwarf_reg
);
2886 /* A helper function that emits an access to memory. ARCH is the
2887 target architecture. EXPR is the expression which we are building.
2888 NBITS is the number of bits we want to read. This emits the
2889 opcodes needed to read the memory and then extract the desired
2893 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2895 ULONGEST nbytes
= (nbits
+ 7) / 8;
2897 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2900 ax_trace_quick (expr
, nbytes
);
2903 ax_simple (expr
, aop_ref8
);
2904 else if (nbits
<= 16)
2905 ax_simple (expr
, aop_ref16
);
2906 else if (nbits
<= 32)
2907 ax_simple (expr
, aop_ref32
);
2909 ax_simple (expr
, aop_ref64
);
2911 /* If we read exactly the number of bytes we wanted, we're done. */
2912 if (8 * nbytes
== nbits
)
2915 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
)
2917 /* On a bits-big-endian machine, we want the high-order
2919 ax_const_l (expr
, 8 * nbytes
- nbits
);
2920 ax_simple (expr
, aop_rsh_unsigned
);
2924 /* On a bits-little-endian box, we want the low-order NBITS. */
2925 ax_zero_ext (expr
, nbits
);
2929 /* A helper function to return the frame's PC. */
2932 get_ax_pc (void *baton
)
2934 struct agent_expr
*expr
= (struct agent_expr
*) baton
;
2939 /* Compile a DWARF location expression to an agent expression.
2941 EXPR is the agent expression we are building.
2942 LOC is the agent value we modify.
2943 ARCH is the architecture.
2944 ADDR_SIZE is the size of addresses, in bytes.
2945 OP_PTR is the start of the location expression.
2946 OP_END is one past the last byte of the location expression.
2948 This will throw an exception for various kinds of errors -- for
2949 example, if the expression cannot be compiled, or if the expression
2953 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2954 unsigned int addr_size
, const gdb_byte
*op_ptr
,
2955 const gdb_byte
*op_end
,
2956 struct dwarf2_per_cu_data
*per_cu
)
2958 gdbarch
*arch
= expr
->gdbarch
;
2959 std::vector
<int> dw_labels
, patches
;
2960 const gdb_byte
* const base
= op_ptr
;
2961 const gdb_byte
*previous_piece
= op_ptr
;
2962 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2963 ULONGEST bits_collected
= 0;
2964 unsigned int addr_size_bits
= 8 * addr_size
;
2965 bool bits_big_endian
= byte_order
== BFD_ENDIAN_BIG
;
2967 std::vector
<int> offsets (op_end
- op_ptr
, -1);
2969 /* By default we are making an address. */
2970 loc
->kind
= axs_lvalue_memory
;
2972 while (op_ptr
< op_end
)
2974 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
2975 uint64_t uoffset
, reg
;
2979 offsets
[op_ptr
- base
] = expr
->len
;
2982 /* Our basic approach to code generation is to map DWARF
2983 operations directly to AX operations. However, there are
2986 First, DWARF works on address-sized units, but AX always uses
2987 LONGEST. For most operations we simply ignore this
2988 difference; instead we generate sign extensions as needed
2989 before division and comparison operations. It would be nice
2990 to omit the sign extensions, but there is no way to determine
2991 the size of the target's LONGEST. (This code uses the size
2992 of the host LONGEST in some cases -- that is a bug but it is
2995 Second, some DWARF operations cannot be translated to AX.
2996 For these we simply fail. See
2997 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
3032 ax_const_l (expr
, op
- DW_OP_lit0
);
3036 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
3037 op_ptr
+= addr_size
;
3038 /* Some versions of GCC emit DW_OP_addr before
3039 DW_OP_GNU_push_tls_address. In this case the value is an
3040 index, not an address. We don't support things like
3041 branching between the address and the TLS op. */
3042 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
3043 uoffset
+= per_cu
->text_offset ();
3044 ax_const_l (expr
, uoffset
);
3048 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
3052 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
3056 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
3060 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
3064 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
3068 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
3072 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
3076 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
3080 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3081 ax_const_l (expr
, uoffset
);
3084 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3085 ax_const_l (expr
, offset
);
3120 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3121 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_reg0
);
3122 loc
->kind
= axs_lvalue_register
;
3126 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3127 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3128 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3129 loc
->kind
= axs_lvalue_register
;
3132 case DW_OP_implicit_value
:
3136 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
3137 if (op_ptr
+ len
> op_end
)
3138 error (_("DW_OP_implicit_value: too few bytes available."));
3139 if (len
> sizeof (ULONGEST
))
3140 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
3143 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
3146 dwarf_expr_require_composition (op_ptr
, op_end
,
3147 "DW_OP_implicit_value");
3149 loc
->kind
= axs_rvalue
;
3153 case DW_OP_stack_value
:
3154 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
3155 loc
->kind
= axs_rvalue
;
3190 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3191 i
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_breg0
);
3195 ax_const_l (expr
, offset
);
3196 ax_simple (expr
, aop_add
);
3201 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3202 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3203 i
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3207 ax_const_l (expr
, offset
);
3208 ax_simple (expr
, aop_add
);
3214 const gdb_byte
*datastart
;
3216 const struct block
*b
;
3217 struct symbol
*framefunc
;
3219 b
= block_for_pc (expr
->scope
);
3222 error (_("No block found for address"));
3224 framefunc
= block_linkage_function (b
);
3227 error (_("No function found for block"));
3229 func_get_frame_base_dwarf_block (framefunc
, expr
->scope
,
3230 &datastart
, &datalen
);
3232 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3233 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, datastart
,
3234 datastart
+ datalen
, per_cu
);
3235 if (loc
->kind
== axs_lvalue_register
)
3236 require_rvalue (expr
, loc
);
3240 ax_const_l (expr
, offset
);
3241 ax_simple (expr
, aop_add
);
3244 loc
->kind
= axs_lvalue_memory
;
3249 ax_simple (expr
, aop_dup
);
3253 ax_simple (expr
, aop_pop
);
3258 ax_pick (expr
, offset
);
3262 ax_simple (expr
, aop_swap
);
3270 ax_simple (expr
, aop_rot
);
3274 case DW_OP_deref_size
:
3278 if (op
== DW_OP_deref_size
)
3283 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3284 error (_("Unsupported size %d in %s"),
3285 size
, get_DW_OP_name (op
));
3286 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3291 /* Sign extend the operand. */
3292 ax_ext (expr
, addr_size_bits
);
3293 ax_simple (expr
, aop_dup
);
3294 ax_const_l (expr
, 0);
3295 ax_simple (expr
, aop_less_signed
);
3296 ax_simple (expr
, aop_log_not
);
3297 i
= ax_goto (expr
, aop_if_goto
);
3298 /* We have to emit 0 - X. */
3299 ax_const_l (expr
, 0);
3300 ax_simple (expr
, aop_swap
);
3301 ax_simple (expr
, aop_sub
);
3302 ax_label (expr
, i
, expr
->len
);
3306 /* No need to sign extend here. */
3307 ax_const_l (expr
, 0);
3308 ax_simple (expr
, aop_swap
);
3309 ax_simple (expr
, aop_sub
);
3313 /* Sign extend the operand. */
3314 ax_ext (expr
, addr_size_bits
);
3315 ax_simple (expr
, aop_bit_not
);
3318 case DW_OP_plus_uconst
:
3319 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3320 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3321 but we micro-optimize anyhow. */
3324 ax_const_l (expr
, reg
);
3325 ax_simple (expr
, aop_add
);
3330 ax_simple (expr
, aop_bit_and
);
3334 /* Sign extend the operands. */
3335 ax_ext (expr
, addr_size_bits
);
3336 ax_simple (expr
, aop_swap
);
3337 ax_ext (expr
, addr_size_bits
);
3338 ax_simple (expr
, aop_swap
);
3339 ax_simple (expr
, aop_div_signed
);
3343 ax_simple (expr
, aop_sub
);
3347 ax_simple (expr
, aop_rem_unsigned
);
3351 ax_simple (expr
, aop_mul
);
3355 ax_simple (expr
, aop_bit_or
);
3359 ax_simple (expr
, aop_add
);
3363 ax_simple (expr
, aop_lsh
);
3367 ax_simple (expr
, aop_rsh_unsigned
);
3371 ax_simple (expr
, aop_rsh_signed
);
3375 ax_simple (expr
, aop_bit_xor
);
3379 /* Sign extend the operands. */
3380 ax_ext (expr
, addr_size_bits
);
3381 ax_simple (expr
, aop_swap
);
3382 ax_ext (expr
, addr_size_bits
);
3383 /* Note no swap here: A <= B is !(B < A). */
3384 ax_simple (expr
, aop_less_signed
);
3385 ax_simple (expr
, aop_log_not
);
3389 /* Sign extend the operands. */
3390 ax_ext (expr
, addr_size_bits
);
3391 ax_simple (expr
, aop_swap
);
3392 ax_ext (expr
, addr_size_bits
);
3393 ax_simple (expr
, aop_swap
);
3394 /* A >= B is !(A < B). */
3395 ax_simple (expr
, aop_less_signed
);
3396 ax_simple (expr
, aop_log_not
);
3400 /* Sign extend the operands. */
3401 ax_ext (expr
, addr_size_bits
);
3402 ax_simple (expr
, aop_swap
);
3403 ax_ext (expr
, addr_size_bits
);
3404 /* No need for a second swap here. */
3405 ax_simple (expr
, aop_equal
);
3409 /* Sign extend the operands. */
3410 ax_ext (expr
, addr_size_bits
);
3411 ax_simple (expr
, aop_swap
);
3412 ax_ext (expr
, addr_size_bits
);
3413 ax_simple (expr
, aop_swap
);
3414 ax_simple (expr
, aop_less_signed
);
3418 /* Sign extend the operands. */
3419 ax_ext (expr
, addr_size_bits
);
3420 ax_simple (expr
, aop_swap
);
3421 ax_ext (expr
, addr_size_bits
);
3422 /* Note no swap here: A > B is B < A. */
3423 ax_simple (expr
, aop_less_signed
);
3427 /* Sign extend the operands. */
3428 ax_ext (expr
, addr_size_bits
);
3429 ax_simple (expr
, aop_swap
);
3430 ax_ext (expr
, addr_size_bits
);
3431 /* No need for a swap here. */
3432 ax_simple (expr
, aop_equal
);
3433 ax_simple (expr
, aop_log_not
);
3436 case DW_OP_call_frame_cfa
:
3439 CORE_ADDR text_offset
;
3441 const gdb_byte
*cfa_start
, *cfa_end
;
3443 if (dwarf2_fetch_cfa_info (arch
, expr
->scope
, per_cu
,
3445 &text_offset
, &cfa_start
, &cfa_end
))
3448 ax_reg (expr
, regnum
);
3451 ax_const_l (expr
, off
);
3452 ax_simple (expr
, aop_add
);
3457 /* Another expression. */
3458 ax_const_l (expr
, text_offset
);
3459 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, cfa_start
,
3463 loc
->kind
= axs_lvalue_memory
;
3467 case DW_OP_GNU_push_tls_address
:
3468 case DW_OP_form_tls_address
:
3472 case DW_OP_push_object_address
:
3477 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3479 i
= ax_goto (expr
, aop_goto
);
3480 dw_labels
.push_back (op_ptr
+ offset
- base
);
3481 patches
.push_back (i
);
3485 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3487 /* Zero extend the operand. */
3488 ax_zero_ext (expr
, addr_size_bits
);
3489 i
= ax_goto (expr
, aop_if_goto
);
3490 dw_labels
.push_back (op_ptr
+ offset
- base
);
3491 patches
.push_back (i
);
3498 case DW_OP_bit_piece
:
3502 if (op_ptr
- 1 == previous_piece
)
3503 error (_("Cannot translate empty pieces to agent expressions"));
3504 previous_piece
= op_ptr
- 1;
3506 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3507 if (op
== DW_OP_piece
)
3513 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3515 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3516 error (_("Expression pieces exceed word size"));
3518 /* Access the bits. */
3521 case axs_lvalue_register
:
3522 ax_reg (expr
, loc
->u
.reg
);
3525 case axs_lvalue_memory
:
3526 /* Offset the pointer, if needed. */
3529 ax_const_l (expr
, uoffset
/ 8);
3530 ax_simple (expr
, aop_add
);
3533 access_memory (arch
, expr
, size
);
3537 /* For a bits-big-endian target, shift up what we already
3538 have. For a bits-little-endian target, shift up the
3539 new data. Note that there is a potential bug here if
3540 the DWARF expression leaves multiple values on the
3542 if (bits_collected
> 0)
3544 if (bits_big_endian
)
3546 ax_simple (expr
, aop_swap
);
3547 ax_const_l (expr
, size
);
3548 ax_simple (expr
, aop_lsh
);
3549 /* We don't need a second swap here, because
3550 aop_bit_or is symmetric. */
3554 ax_const_l (expr
, size
);
3555 ax_simple (expr
, aop_lsh
);
3557 ax_simple (expr
, aop_bit_or
);
3560 bits_collected
+= size
;
3561 loc
->kind
= axs_rvalue
;
3565 case DW_OP_GNU_uninit
:
3571 struct dwarf2_locexpr_baton block
;
3572 int size
= (op
== DW_OP_call2
? 2 : 4);
3574 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3577 cu_offset cuoffset
= (cu_offset
) uoffset
;
3578 block
= dwarf2_fetch_die_loc_cu_off (cuoffset
, per_cu
,
3581 /* DW_OP_call_ref is currently not supported. */
3582 gdb_assert (block
.per_cu
== per_cu
);
3584 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, block
.data
,
3585 block
.data
+ block
.size
, per_cu
);
3589 case DW_OP_call_ref
:
3592 case DW_OP_GNU_variable_value
:
3600 /* Patch all the branches we emitted. */
3601 for (int i
= 0; i
< patches
.size (); ++i
)
3603 int targ
= offsets
[dw_labels
[i
]];
3605 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3606 ax_label (expr
, patches
[i
], targ
);
3611 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3612 evaluator to calculate the location. */
3613 static struct value
*
3614 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3616 struct dwarf2_locexpr_baton
*dlbaton
3617 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3620 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3621 dlbaton
->size
, dlbaton
->per_cu
);
3626 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3627 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3630 static struct value
*
3631 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3633 struct dwarf2_locexpr_baton
*dlbaton
3634 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3636 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3640 /* Implementation of get_symbol_read_needs from
3641 symbol_computed_ops. */
3643 static enum symbol_needs_kind
3644 locexpr_get_symbol_read_needs (struct symbol
*symbol
)
3646 struct dwarf2_locexpr_baton
*dlbaton
3647 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3649 return dwarf2_loc_desc_get_symbol_read_needs (dlbaton
->data
, dlbaton
->size
,
3653 /* Return true if DATA points to the end of a piece. END is one past
3654 the last byte in the expression. */
3657 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3659 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3662 /* Helper for locexpr_describe_location_piece that finds the name of a
3666 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3670 /* This doesn't use dwarf_reg_to_regnum_or_error on purpose.
3671 We'd rather print *something* here than throw an error. */
3672 regnum
= dwarf_reg_to_regnum (gdbarch
, dwarf_regnum
);
3673 /* gdbarch_register_name may just return "", return something more
3674 descriptive for bad register numbers. */
3677 /* The text is output as "$bad_register_number".
3678 That is why we use the underscores. */
3679 return _("bad_register_number");
3681 return gdbarch_register_name (gdbarch
, regnum
);
3684 /* Nicely describe a single piece of a location, returning an updated
3685 position in the bytecode sequence. This function cannot recognize
3686 all locations; if a location is not recognized, it simply returns
3687 DATA. If there is an error during reading, e.g. we run off the end
3688 of the buffer, an error is thrown. */
3690 static const gdb_byte
*
3691 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3692 CORE_ADDR addr
, struct objfile
*objfile
,
3693 struct dwarf2_per_cu_data
*per_cu
,
3694 const gdb_byte
*data
, const gdb_byte
*end
,
3695 unsigned int addr_size
)
3697 struct gdbarch
*gdbarch
= objfile
->arch ();
3700 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3702 fprintf_filtered (stream
, _("a variable in $%s"),
3703 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3706 else if (data
[0] == DW_OP_regx
)
3710 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3711 fprintf_filtered (stream
, _("a variable in $%s"),
3712 locexpr_regname (gdbarch
, reg
));
3714 else if (data
[0] == DW_OP_fbreg
)
3716 const struct block
*b
;
3717 struct symbol
*framefunc
;
3719 int64_t frame_offset
;
3720 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3722 int64_t base_offset
= 0;
3724 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3725 if (!piece_end_p (new_data
, end
))
3729 b
= block_for_pc (addr
);
3732 error (_("No block found for address for symbol \"%s\"."),
3733 symbol
->print_name ());
3735 framefunc
= block_linkage_function (b
);
3738 error (_("No function found for block for symbol \"%s\"."),
3739 symbol
->print_name ());
3741 func_get_frame_base_dwarf_block (framefunc
, addr
, &base_data
, &base_size
);
3743 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3745 const gdb_byte
*buf_end
;
3747 frame_reg
= base_data
[0] - DW_OP_breg0
;
3748 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3750 if (buf_end
!= base_data
+ base_size
)
3751 error (_("Unexpected opcode after "
3752 "DW_OP_breg%u for symbol \"%s\"."),
3753 frame_reg
, symbol
->print_name ());
3755 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3757 /* The frame base is just the register, with no offset. */
3758 frame_reg
= base_data
[0] - DW_OP_reg0
;
3763 /* We don't know what to do with the frame base expression,
3764 so we can't trace this variable; give up. */
3768 fprintf_filtered (stream
,
3769 _("a variable at frame base reg $%s offset %s+%s"),
3770 locexpr_regname (gdbarch
, frame_reg
),
3771 plongest (base_offset
), plongest (frame_offset
));
3773 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3774 && piece_end_p (data
, end
))
3778 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3780 fprintf_filtered (stream
,
3781 _("a variable at offset %s from base reg $%s"),
3783 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3786 /* The location expression for a TLS variable looks like this (on a
3789 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3790 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3792 0x3 is the encoding for DW_OP_addr, which has an operand as long
3793 as the size of an address on the target machine (here is 8
3794 bytes). Note that more recent version of GCC emit DW_OP_const4u
3795 or DW_OP_const8u, depending on address size, rather than
3796 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3797 The operand represents the offset at which the variable is within
3798 the thread local storage. */
3800 else if (data
+ 1 + addr_size
< end
3801 && (data
[0] == DW_OP_addr
3802 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3803 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3804 && (data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3805 || data
[1 + addr_size
] == DW_OP_form_tls_address
)
3806 && piece_end_p (data
+ 2 + addr_size
, end
))
3809 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3810 gdbarch_byte_order (gdbarch
));
3812 fprintf_filtered (stream
,
3813 _("a thread-local variable at offset 0x%s "
3814 "in the thread-local storage for `%s'"),
3815 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3817 data
+= 1 + addr_size
+ 1;
3820 /* With -gsplit-dwarf a TLS variable can also look like this:
3821 DW_AT_location : 3 byte block: fc 4 e0
3822 (DW_OP_GNU_const_index: 4;
3823 DW_OP_GNU_push_tls_address) */
3824 else if (data
+ 3 <= end
3825 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3826 && data
[0] == DW_OP_GNU_const_index
3828 && (data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3829 || data
[1 + leb128_size
] == DW_OP_form_tls_address
)
3830 && piece_end_p (data
+ 2 + leb128_size
, end
))
3834 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3835 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3836 fprintf_filtered (stream
,
3837 _("a thread-local variable at offset 0x%s "
3838 "in the thread-local storage for `%s'"),
3839 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3843 else if (data
[0] >= DW_OP_lit0
3844 && data
[0] <= DW_OP_lit31
3846 && data
[1] == DW_OP_stack_value
)
3848 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3855 /* Disassemble an expression, stopping at the end of a piece or at the
3856 end of the expression. Returns a pointer to the next unread byte
3857 in the input expression. If ALL is nonzero, then this function
3858 will keep going until it reaches the end of the expression.
3859 If there is an error during reading, e.g. we run off the end
3860 of the buffer, an error is thrown. */
3862 static const gdb_byte
*
3863 disassemble_dwarf_expression (struct ui_file
*stream
,
3864 struct gdbarch
*arch
, unsigned int addr_size
,
3865 int offset_size
, const gdb_byte
*start
,
3866 const gdb_byte
*data
, const gdb_byte
*end
,
3867 int indent
, int all
,
3868 struct dwarf2_per_cu_data
*per_cu
)
3872 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3874 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *data
++;
3879 name
= get_DW_OP_name (op
);
3882 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3883 op
, (long) (data
- 1 - start
));
3884 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3885 (long) (data
- 1 - start
), name
);
3890 ul
= extract_unsigned_integer (data
, addr_size
,
3891 gdbarch_byte_order (arch
));
3893 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3897 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3899 fprintf_filtered (stream
, " %s", pulongest (ul
));
3902 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3904 fprintf_filtered (stream
, " %s", plongest (l
));
3907 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3909 fprintf_filtered (stream
, " %s", pulongest (ul
));
3912 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3914 fprintf_filtered (stream
, " %s", plongest (l
));
3917 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3919 fprintf_filtered (stream
, " %s", pulongest (ul
));
3922 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3924 fprintf_filtered (stream
, " %s", plongest (l
));
3927 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3929 fprintf_filtered (stream
, " %s", pulongest (ul
));
3932 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3934 fprintf_filtered (stream
, " %s", plongest (l
));
3937 data
= safe_read_uleb128 (data
, end
, &ul
);
3938 fprintf_filtered (stream
, " %s", pulongest (ul
));
3941 data
= safe_read_sleb128 (data
, end
, &l
);
3942 fprintf_filtered (stream
, " %s", plongest (l
));
3977 fprintf_filtered (stream
, " [$%s]",
3978 locexpr_regname (arch
, op
- DW_OP_reg0
));
3982 data
= safe_read_uleb128 (data
, end
, &ul
);
3983 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3984 locexpr_regname (arch
, (int) ul
));
3987 case DW_OP_implicit_value
:
3988 data
= safe_read_uleb128 (data
, end
, &ul
);
3990 fprintf_filtered (stream
, " %s", pulongest (ul
));
4025 data
= safe_read_sleb128 (data
, end
, &l
);
4026 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
4027 locexpr_regname (arch
, op
- DW_OP_breg0
));
4031 data
= safe_read_uleb128 (data
, end
, &ul
);
4032 data
= safe_read_sleb128 (data
, end
, &l
);
4033 fprintf_filtered (stream
, " register %s [$%s] offset %s",
4035 locexpr_regname (arch
, (int) ul
),
4040 data
= safe_read_sleb128 (data
, end
, &l
);
4041 fprintf_filtered (stream
, " %s", plongest (l
));
4044 case DW_OP_xderef_size
:
4045 case DW_OP_deref_size
:
4047 fprintf_filtered (stream
, " %d", *data
);
4051 case DW_OP_plus_uconst
:
4052 data
= safe_read_uleb128 (data
, end
, &ul
);
4053 fprintf_filtered (stream
, " %s", pulongest (ul
));
4057 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4059 fprintf_filtered (stream
, " to %ld",
4060 (long) (data
+ l
- start
));
4064 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4066 fprintf_filtered (stream
, " %ld",
4067 (long) (data
+ l
- start
));
4071 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
4073 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
4077 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4079 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4082 case DW_OP_call_ref
:
4083 ul
= extract_unsigned_integer (data
, offset_size
,
4084 gdbarch_byte_order (arch
));
4085 data
+= offset_size
;
4086 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4090 data
= safe_read_uleb128 (data
, end
, &ul
);
4091 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
4094 case DW_OP_bit_piece
:
4098 data
= safe_read_uleb128 (data
, end
, &ul
);
4099 data
= safe_read_uleb128 (data
, end
, &offset
);
4100 fprintf_filtered (stream
, " size %s offset %s (bits)",
4101 pulongest (ul
), pulongest (offset
));
4105 case DW_OP_implicit_pointer
:
4106 case DW_OP_GNU_implicit_pointer
:
4108 ul
= extract_unsigned_integer (data
, offset_size
,
4109 gdbarch_byte_order (arch
));
4110 data
+= offset_size
;
4112 data
= safe_read_sleb128 (data
, end
, &l
);
4114 fprintf_filtered (stream
, " DIE %s offset %s",
4115 phex_nz (ul
, offset_size
),
4120 case DW_OP_deref_type
:
4121 case DW_OP_GNU_deref_type
:
4123 int deref_addr_size
= *data
++;
4126 data
= safe_read_uleb128 (data
, end
, &ul
);
4127 cu_offset offset
= (cu_offset
) ul
;
4128 type
= dwarf2_get_die_type (offset
, per_cu
);
4129 fprintf_filtered (stream
, "<");
4130 type_print (type
, "", stream
, -1);
4131 fprintf_filtered (stream
, " [0x%s]> %d",
4132 phex_nz (to_underlying (offset
), 0),
4137 case DW_OP_const_type
:
4138 case DW_OP_GNU_const_type
:
4142 data
= safe_read_uleb128 (data
, end
, &ul
);
4143 cu_offset type_die
= (cu_offset
) ul
;
4144 type
= dwarf2_get_die_type (type_die
, per_cu
);
4145 fprintf_filtered (stream
, "<");
4146 type_print (type
, "", stream
, -1);
4147 fprintf_filtered (stream
, " [0x%s]>",
4148 phex_nz (to_underlying (type_die
), 0));
4151 fprintf_filtered (stream
, " %d byte block:", n
);
4152 for (int i
= 0; i
< n
; ++i
)
4153 fprintf_filtered (stream
, " %02x", data
[i
]);
4158 case DW_OP_regval_type
:
4159 case DW_OP_GNU_regval_type
:
4164 data
= safe_read_uleb128 (data
, end
, ®
);
4165 data
= safe_read_uleb128 (data
, end
, &ul
);
4166 cu_offset type_die
= (cu_offset
) ul
;
4168 type
= dwarf2_get_die_type (type_die
, per_cu
);
4169 fprintf_filtered (stream
, "<");
4170 type_print (type
, "", stream
, -1);
4171 fprintf_filtered (stream
, " [0x%s]> [$%s]",
4172 phex_nz (to_underlying (type_die
), 0),
4173 locexpr_regname (arch
, reg
));
4178 case DW_OP_GNU_convert
:
4179 case DW_OP_reinterpret
:
4180 case DW_OP_GNU_reinterpret
:
4182 data
= safe_read_uleb128 (data
, end
, &ul
);
4183 cu_offset type_die
= (cu_offset
) ul
;
4185 if (to_underlying (type_die
) == 0)
4186 fprintf_filtered (stream
, "<0>");
4191 type
= dwarf2_get_die_type (type_die
, per_cu
);
4192 fprintf_filtered (stream
, "<");
4193 type_print (type
, "", stream
, -1);
4194 fprintf_filtered (stream
, " [0x%s]>",
4195 phex_nz (to_underlying (type_die
), 0));
4200 case DW_OP_entry_value
:
4201 case DW_OP_GNU_entry_value
:
4202 data
= safe_read_uleb128 (data
, end
, &ul
);
4203 fputc_filtered ('\n', stream
);
4204 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
4205 start
, data
, data
+ ul
, indent
+ 2,
4210 case DW_OP_GNU_parameter_ref
:
4211 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4213 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4217 case DW_OP_GNU_addr_index
:
4218 data
= safe_read_uleb128 (data
, end
, &ul
);
4219 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4220 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
4222 case DW_OP_GNU_const_index
:
4223 data
= safe_read_uleb128 (data
, end
, &ul
);
4224 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4225 fprintf_filtered (stream
, " %s", pulongest (ul
));
4228 case DW_OP_GNU_variable_value
:
4229 ul
= extract_unsigned_integer (data
, offset_size
,
4230 gdbarch_byte_order (arch
));
4231 data
+= offset_size
;
4232 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4236 fprintf_filtered (stream
, "\n");
4242 static bool dwarf_always_disassemble
;
4245 show_dwarf_always_disassemble (struct ui_file
*file
, int from_tty
,
4246 struct cmd_list_element
*c
, const char *value
)
4248 fprintf_filtered (file
,
4249 _("Whether to always disassemble "
4250 "DWARF expressions is %s.\n"),
4254 /* Describe a single location, which may in turn consist of multiple
4258 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
4259 struct ui_file
*stream
,
4260 const gdb_byte
*data
, size_t size
,
4261 struct objfile
*objfile
, unsigned int addr_size
,
4262 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
4264 const gdb_byte
*end
= data
+ size
;
4265 int first_piece
= 1, bad
= 0;
4269 const gdb_byte
*here
= data
;
4270 int disassemble
= 1;
4275 fprintf_filtered (stream
, _(", and "));
4277 if (!dwarf_always_disassemble
)
4279 data
= locexpr_describe_location_piece (symbol
, stream
,
4280 addr
, objfile
, per_cu
,
4281 data
, end
, addr_size
);
4282 /* If we printed anything, or if we have an empty piece,
4283 then don't disassemble. */
4285 || data
[0] == DW_OP_piece
4286 || data
[0] == DW_OP_bit_piece
)
4291 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
4292 data
= disassemble_dwarf_expression (stream
,
4294 addr_size
, offset_size
, data
,
4296 dwarf_always_disassemble
,
4302 int empty
= data
== here
;
4305 fprintf_filtered (stream
, " ");
4306 if (data
[0] == DW_OP_piece
)
4310 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
4313 fprintf_filtered (stream
, _("an empty %s-byte piece"),
4316 fprintf_filtered (stream
, _(" [%s-byte piece]"),
4319 else if (data
[0] == DW_OP_bit_piece
)
4321 uint64_t bits
, offset
;
4323 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
4324 data
= safe_read_uleb128 (data
, end
, &offset
);
4327 fprintf_filtered (stream
,
4328 _("an empty %s-bit piece"),
4331 fprintf_filtered (stream
,
4332 _(" [%s-bit piece, offset %s bits]"),
4333 pulongest (bits
), pulongest (offset
));
4343 if (bad
|| data
> end
)
4344 error (_("Corrupted DWARF2 expression for \"%s\"."),
4345 symbol
->print_name ());
4348 /* Print a natural-language description of SYMBOL to STREAM. This
4349 version is for a symbol with a single location. */
4352 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4353 struct ui_file
*stream
)
4355 struct dwarf2_locexpr_baton
*dlbaton
4356 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4357 dwarf2_per_objfile
*per_objfile
= dlbaton
->per_objfile
;
4358 struct objfile
*objfile
= per_objfile
->objfile
;
4359 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4360 int offset_size
= dlbaton
->per_cu
->offset_size ();
4362 locexpr_describe_location_1 (symbol
, addr
, stream
,
4363 dlbaton
->data
, dlbaton
->size
,
4364 objfile
, addr_size
, offset_size
,
4368 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4369 any necessary bytecode in AX. */
4372 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
4373 struct axs_value
*value
)
4375 struct dwarf2_locexpr_baton
*dlbaton
4376 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4377 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4379 if (dlbaton
->size
== 0)
4380 value
->optimized_out
= 1;
4382 dwarf2_compile_expr_to_ax (ax
, value
, addr_size
, dlbaton
->data
,
4383 dlbaton
->data
+ dlbaton
->size
, dlbaton
->per_cu
);
4386 /* symbol_computed_ops 'generate_c_location' method. */
4389 locexpr_generate_c_location (struct symbol
*sym
, string_file
*stream
,
4390 struct gdbarch
*gdbarch
,
4391 unsigned char *registers_used
,
4392 CORE_ADDR pc
, const char *result_name
)
4394 struct dwarf2_locexpr_baton
*dlbaton
4395 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (sym
);
4396 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4398 if (dlbaton
->size
== 0)
4399 error (_("symbol \"%s\" is optimized out"), sym
->natural_name ());
4401 compile_dwarf_expr_to_c (stream
, result_name
,
4402 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4403 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4407 /* The set of location functions used with the DWARF-2 expression
4409 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4410 locexpr_read_variable
,
4411 locexpr_read_variable_at_entry
,
4412 locexpr_get_symbol_read_needs
,
4413 locexpr_describe_location
,
4414 0, /* location_has_loclist */
4415 locexpr_tracepoint_var_ref
,
4416 locexpr_generate_c_location
4420 /* Wrapper functions for location lists. These generally find
4421 the appropriate location expression and call something above. */
4423 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4424 evaluator to calculate the location. */
4425 static struct value
*
4426 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4428 struct dwarf2_loclist_baton
*dlbaton
4429 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4431 const gdb_byte
*data
;
4433 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4435 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4436 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4442 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4443 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4446 Function always returns non-NULL value, it may be marked optimized out if
4447 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4448 if it cannot resolve the parameter for any reason. */
4450 static struct value
*
4451 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4453 struct dwarf2_loclist_baton
*dlbaton
4454 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4455 const gdb_byte
*data
;
4459 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4460 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4462 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4464 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4466 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4469 /* Implementation of get_symbol_read_needs from
4470 symbol_computed_ops. */
4472 static enum symbol_needs_kind
4473 loclist_symbol_needs (struct symbol
*symbol
)
4475 /* If there's a location list, then assume we need to have a frame
4476 to choose the appropriate location expression. With tracking of
4477 global variables this is not necessarily true, but such tracking
4478 is disabled in GCC at the moment until we figure out how to
4481 return SYMBOL_NEEDS_FRAME
;
4484 /* Print a natural-language description of SYMBOL to STREAM. This
4485 version applies when there is a list of different locations, each
4486 with a specified address range. */
4489 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4490 struct ui_file
*stream
)
4492 struct dwarf2_loclist_baton
*dlbaton
4493 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4494 const gdb_byte
*loc_ptr
, *buf_end
;
4495 dwarf2_per_objfile
*per_objfile
= dlbaton
->per_objfile
;
4496 struct objfile
*objfile
= per_objfile
->objfile
;
4497 struct gdbarch
*gdbarch
= objfile
->arch ();
4498 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4499 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4500 int offset_size
= dlbaton
->per_cu
->offset_size ();
4501 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4502 /* Adjust base_address for relocatable objects. */
4503 CORE_ADDR base_offset
= dlbaton
->per_cu
->text_offset ();
4504 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4507 loc_ptr
= dlbaton
->data
;
4508 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4510 fprintf_filtered (stream
, _("multi-location:\n"));
4512 /* Iterate through locations until we run out. */
4515 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4517 enum debug_loc_kind kind
;
4518 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4520 if (dlbaton
->per_cu
->version () < 5 && dlbaton
->from_dwo
)
4521 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4522 loc_ptr
, buf_end
, &new_ptr
,
4523 &low
, &high
, byte_order
);
4524 else if (dlbaton
->per_cu
->version () < 5)
4525 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4527 byte_order
, addr_size
,
4530 kind
= decode_debug_loclists_addresses (dlbaton
->per_cu
,
4531 loc_ptr
, buf_end
, &new_ptr
,
4532 &low
, &high
, byte_order
,
4533 addr_size
, signed_addr_p
);
4537 case DEBUG_LOC_END_OF_LIST
:
4540 case DEBUG_LOC_BASE_ADDRESS
:
4541 base_address
= high
+ base_offset
;
4542 fprintf_filtered (stream
, _(" Base address %s"),
4543 paddress (gdbarch
, base_address
));
4545 case DEBUG_LOC_START_END
:
4546 case DEBUG_LOC_START_LENGTH
:
4547 case DEBUG_LOC_OFFSET_PAIR
:
4549 case DEBUG_LOC_BUFFER_OVERFLOW
:
4550 case DEBUG_LOC_INVALID_ENTRY
:
4551 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4552 symbol
->print_name ());
4554 gdb_assert_not_reached ("bad debug_loc_kind");
4557 /* Otherwise, a location expression entry. */
4558 low
+= base_address
;
4559 high
+= base_address
;
4561 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
);
4562 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
);
4564 if (dlbaton
->per_cu
->version () < 5)
4566 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4571 unsigned int bytes_read
;
4572 length
= read_unsigned_leb128 (NULL
, loc_ptr
, &bytes_read
);
4573 loc_ptr
+= bytes_read
;
4576 /* (It would improve readability to print only the minimum
4577 necessary digits of the second number of the range.) */
4578 fprintf_filtered (stream
, _(" Range %s-%s: "),
4579 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4581 /* Now describe this particular location. */
4582 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4583 objfile
, addr_size
, offset_size
,
4586 fprintf_filtered (stream
, "\n");
4592 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4593 any necessary bytecode in AX. */
4595 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
4596 struct axs_value
*value
)
4598 struct dwarf2_loclist_baton
*dlbaton
4599 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4600 const gdb_byte
*data
;
4602 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4604 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4606 value
->optimized_out
= 1;
4608 dwarf2_compile_expr_to_ax (ax
, value
, addr_size
, data
, data
+ size
,
4612 /* symbol_computed_ops 'generate_c_location' method. */
4615 loclist_generate_c_location (struct symbol
*sym
, string_file
*stream
,
4616 struct gdbarch
*gdbarch
,
4617 unsigned char *registers_used
,
4618 CORE_ADDR pc
, const char *result_name
)
4620 struct dwarf2_loclist_baton
*dlbaton
4621 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (sym
);
4622 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4623 const gdb_byte
*data
;
4626 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4628 error (_("symbol \"%s\" is optimized out"), sym
->natural_name ());
4630 compile_dwarf_expr_to_c (stream
, result_name
,
4631 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4636 /* The set of location functions used with the DWARF-2 expression
4637 evaluator and location lists. */
4638 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4639 loclist_read_variable
,
4640 loclist_read_variable_at_entry
,
4641 loclist_symbol_needs
,
4642 loclist_describe_location
,
4643 1, /* location_has_loclist */
4644 loclist_tracepoint_var_ref
,
4645 loclist_generate_c_location
4648 void _initialize_dwarf2loc ();
4650 _initialize_dwarf2loc ()
4652 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4653 &entry_values_debug
,
4654 _("Set entry values and tail call frames "
4656 _("Show entry values and tail call frames "
4658 _("When non-zero, the process of determining "
4659 "parameter values from function entry point "
4660 "and tail call frames will be printed."),
4662 show_entry_values_debug
,
4663 &setdebuglist
, &showdebuglist
);
4665 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
4666 &dwarf_always_disassemble
, _("\
4667 Set whether `info address' always disassembles DWARF expressions."), _("\
4668 Show whether `info address' always disassembles DWARF expressions."), _("\
4669 When enabled, DWARF expressions are always printed in an assembly-like\n\
4670 syntax. When disabled, expressions will be printed in a more\n\
4671 conversational style, when possible."),
4673 show_dwarf_always_disassemble
,
4675 &show_dwarf_cmdlist
);