1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003-2023 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
51 (struct type
*type
, frame_info_ptr frame
, const gdb_byte
*data
,
52 size_t size
, dwarf2_per_cu_data
*per_cu
, dwarf2_per_objfile
*per_objfile
,
53 struct type
*subobj_type
, LONGEST subobj_byte_offset
, bool as_lval
= true);
55 /* Until these have formal names, we define these here.
56 ref: http://gcc.gnu.org/wiki/DebugFission
57 Each entry in .debug_loc.dwo begins with a byte that describes the entry,
58 and is then followed by data specific to that entry. */
62 /* Indicates the end of the list of entries. */
63 DEBUG_LOC_END_OF_LIST
= 0,
65 /* This is followed by an unsigned LEB128 number that is an index into
66 .debug_addr and specifies the base address for all following entries. */
67 DEBUG_LOC_BASE_ADDRESS
= 1,
69 /* This is followed by two unsigned LEB128 numbers that are indices into
70 .debug_addr and specify the beginning and ending addresses, and then
71 a normal location expression as in .debug_loc. */
72 DEBUG_LOC_START_END
= 2,
74 /* This is followed by an unsigned LEB128 number that is an index into
75 .debug_addr and specifies the beginning address, and a 4 byte unsigned
76 number that specifies the length, and then a normal location expression
78 DEBUG_LOC_START_LENGTH
= 3,
80 /* This is followed by two unsigned LEB128 operands. The values of these
81 operands are the starting and ending offsets, respectively, relative to
82 the applicable base address. */
83 DEBUG_LOC_OFFSET_PAIR
= 4,
85 /* An internal value indicating there is insufficient data. */
86 DEBUG_LOC_BUFFER_OVERFLOW
= -1,
88 /* An internal value indicating an invalid kind of entry was found. */
89 DEBUG_LOC_INVALID_ENTRY
= -2
92 /* Helper function which throws an error if a synthetic pointer is
96 invalid_synthetic_pointer (void)
98 error (_("access outside bounds of object "
99 "referenced via synthetic pointer"));
102 /* Decode the addresses in a non-dwo .debug_loc entry.
103 A pointer to the next byte to examine is returned in *NEW_PTR.
104 The encoded low,high addresses are return in *LOW,*HIGH.
105 The result indicates the kind of entry found. */
107 static enum debug_loc_kind
108 decode_debug_loc_addresses (const gdb_byte
*loc_ptr
, const gdb_byte
*buf_end
,
109 const gdb_byte
**new_ptr
,
110 CORE_ADDR
*low
, CORE_ADDR
*high
,
111 enum bfd_endian byte_order
,
112 unsigned int addr_size
,
115 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
117 if (buf_end
- loc_ptr
< 2 * addr_size
)
118 return DEBUG_LOC_BUFFER_OVERFLOW
;
121 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
123 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
124 loc_ptr
+= addr_size
;
127 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
129 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
130 loc_ptr
+= addr_size
;
134 /* A base-address-selection entry. */
135 if ((*low
& base_mask
) == base_mask
)
136 return DEBUG_LOC_BASE_ADDRESS
;
138 /* An end-of-list entry. */
139 if (*low
== 0 && *high
== 0)
140 return DEBUG_LOC_END_OF_LIST
;
142 /* We want the caller to apply the base address, so we must return
143 DEBUG_LOC_OFFSET_PAIR here. */
144 return DEBUG_LOC_OFFSET_PAIR
;
147 /* Decode the addresses in .debug_loclists entry.
148 A pointer to the next byte to examine is returned in *NEW_PTR.
149 The encoded low,high addresses are return in *LOW,*HIGH.
150 The result indicates the kind of entry found. */
152 static enum debug_loc_kind
153 decode_debug_loclists_addresses (dwarf2_per_cu_data
*per_cu
,
154 dwarf2_per_objfile
*per_objfile
,
155 const gdb_byte
*loc_ptr
,
156 const gdb_byte
*buf_end
,
157 const gdb_byte
**new_ptr
,
158 CORE_ADDR
*low
, CORE_ADDR
*high
,
159 enum bfd_endian byte_order
,
160 unsigned int addr_size
,
165 if (loc_ptr
== buf_end
)
166 return DEBUG_LOC_BUFFER_OVERFLOW
;
170 case DW_LLE_base_addressx
:
172 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
174 return DEBUG_LOC_BUFFER_OVERFLOW
;
176 *high
= dwarf2_read_addr_index (per_cu
, per_objfile
, u64
);
178 return DEBUG_LOC_BASE_ADDRESS
;
180 case DW_LLE_startx_length
:
181 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
183 return DEBUG_LOC_BUFFER_OVERFLOW
;
185 *low
= dwarf2_read_addr_index (per_cu
, per_objfile
, u64
);
187 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
189 return DEBUG_LOC_BUFFER_OVERFLOW
;
193 return DEBUG_LOC_START_LENGTH
;
195 case DW_LLE_start_length
:
196 if (buf_end
- loc_ptr
< addr_size
)
197 return DEBUG_LOC_BUFFER_OVERFLOW
;
200 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
202 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
204 loc_ptr
+= addr_size
;
207 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
209 return DEBUG_LOC_BUFFER_OVERFLOW
;
213 return DEBUG_LOC_START_LENGTH
;
215 case DW_LLE_end_of_list
:
217 return DEBUG_LOC_END_OF_LIST
;
219 case DW_LLE_base_address
:
220 if (loc_ptr
+ addr_size
> buf_end
)
221 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
);
228 loc_ptr
+= addr_size
;
230 return DEBUG_LOC_BASE_ADDRESS
;
232 case DW_LLE_offset_pair
:
233 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
235 return DEBUG_LOC_BUFFER_OVERFLOW
;
238 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
240 return DEBUG_LOC_BUFFER_OVERFLOW
;
244 return DEBUG_LOC_OFFSET_PAIR
;
246 case DW_LLE_start_end
:
247 if (loc_ptr
+ 2 * addr_size
> buf_end
)
248 return DEBUG_LOC_BUFFER_OVERFLOW
;
251 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
253 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
255 loc_ptr
+= addr_size
;
257 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
259 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
261 loc_ptr
+= addr_size
;
263 return DEBUG_LOC_START_END
;
265 /* Following cases are not supported yet. */
266 case DW_LLE_startx_endx
:
267 case DW_LLE_default_location
:
269 return DEBUG_LOC_INVALID_ENTRY
;
273 /* Decode the addresses in .debug_loc.dwo entry.
274 A pointer to the next byte to examine is returned in *NEW_PTR.
275 The encoded low,high addresses are return in *LOW,*HIGH.
276 The result indicates the kind of entry found. */
278 static enum debug_loc_kind
279 decode_debug_loc_dwo_addresses (dwarf2_per_cu_data
*per_cu
,
280 dwarf2_per_objfile
*per_objfile
,
281 const gdb_byte
*loc_ptr
,
282 const gdb_byte
*buf_end
,
283 const gdb_byte
**new_ptr
,
284 CORE_ADDR
*low
, CORE_ADDR
*high
,
285 enum bfd_endian byte_order
)
287 uint64_t low_index
, high_index
;
289 if (loc_ptr
== buf_end
)
290 return DEBUG_LOC_BUFFER_OVERFLOW
;
294 case DW_LLE_GNU_end_of_list_entry
:
296 return DEBUG_LOC_END_OF_LIST
;
298 case DW_LLE_GNU_base_address_selection_entry
:
300 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
302 return DEBUG_LOC_BUFFER_OVERFLOW
;
304 *high
= dwarf2_read_addr_index (per_cu
, per_objfile
, high_index
);
306 return DEBUG_LOC_BASE_ADDRESS
;
308 case DW_LLE_GNU_start_end_entry
:
309 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
311 return DEBUG_LOC_BUFFER_OVERFLOW
;
313 *low
= dwarf2_read_addr_index (per_cu
, per_objfile
, low_index
);
314 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
316 return DEBUG_LOC_BUFFER_OVERFLOW
;
318 *high
= dwarf2_read_addr_index (per_cu
, per_objfile
, high_index
);
320 return DEBUG_LOC_START_END
;
322 case DW_LLE_GNU_start_length_entry
:
323 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
325 return DEBUG_LOC_BUFFER_OVERFLOW
;
327 *low
= dwarf2_read_addr_index (per_cu
, per_objfile
, low_index
);
328 if (loc_ptr
+ 4 > buf_end
)
329 return DEBUG_LOC_BUFFER_OVERFLOW
;
332 *high
+= extract_unsigned_integer (loc_ptr
, 4, byte_order
);
333 *new_ptr
= loc_ptr
+ 4;
334 return DEBUG_LOC_START_LENGTH
;
337 return DEBUG_LOC_INVALID_ENTRY
;
341 /* A function for dealing with location lists. Given a
342 symbol baton (BATON) and a pc value (PC), find the appropriate
343 location expression, set *LOCEXPR_LENGTH, and return a pointer
344 to the beginning of the expression. Returns NULL on failure.
346 For now, only return the first matching location expression; there
347 can be more than one in the list. */
350 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
351 size_t *locexpr_length
, CORE_ADDR pc
)
353 dwarf2_per_objfile
*per_objfile
= baton
->per_objfile
;
354 struct objfile
*objfile
= per_objfile
->objfile
;
355 struct gdbarch
*gdbarch
= objfile
->arch ();
356 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
357 unsigned int addr_size
= baton
->per_cu
->addr_size ();
358 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
.get ());
359 /* Adjustment for relocatable objects. */
360 CORE_ADDR text_offset
= baton
->per_objfile
->objfile
->text_section_offset ();
361 CORE_ADDR base_address
= baton
->base_address
;
362 const gdb_byte
*loc_ptr
, *buf_end
;
364 loc_ptr
= baton
->data
;
365 buf_end
= baton
->data
+ baton
->size
;
369 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
371 enum debug_loc_kind kind
;
372 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
374 if (baton
->per_cu
->version () < 5 && baton
->from_dwo
)
375 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
377 loc_ptr
, buf_end
, &new_ptr
,
378 &low
, &high
, byte_order
);
379 else if (baton
->per_cu
->version () < 5)
380 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
382 byte_order
, addr_size
,
385 kind
= decode_debug_loclists_addresses (baton
->per_cu
,
387 loc_ptr
, buf_end
, &new_ptr
,
388 &low
, &high
, byte_order
,
389 addr_size
, signed_addr_p
);
394 case DEBUG_LOC_END_OF_LIST
:
398 case DEBUG_LOC_BASE_ADDRESS
:
402 case DEBUG_LOC_START_END
:
403 case DEBUG_LOC_START_LENGTH
:
404 case DEBUG_LOC_OFFSET_PAIR
:
407 case DEBUG_LOC_BUFFER_OVERFLOW
:
408 case DEBUG_LOC_INVALID_ENTRY
:
409 error (_("dwarf2_find_location_expression: "
410 "Corrupted DWARF expression."));
413 gdb_assert_not_reached ("bad debug_loc_kind");
416 /* Otherwise, a location expression entry.
417 If the entry is from a DWO, don't add base address: the entry is from
418 .debug_addr which already has the DWARF "base address". We still add
419 text offset in case we're debugging a PIE executable. However, if the
420 entry is DW_LLE_offset_pair from a DWO, add the base address as the
421 operands are offsets relative to the applicable base address.
422 If the entry is DW_LLE_start_end or DW_LLE_start_length, then
423 it already is an address, and we don't need to add the base. */
426 if (!baton
->from_dwo
&& kind
== DEBUG_LOC_OFFSET_PAIR
)
429 high
+= base_address
;
432 if (baton
->per_cu
->version () < 5)
434 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
439 unsigned int bytes_read
;
441 length
= read_unsigned_leb128 (NULL
, loc_ptr
, &bytes_read
);
442 loc_ptr
+= bytes_read
;
445 if (low
== high
&& pc
== low
)
447 /* This is entry PC record present only at entry point
448 of a function. Verify it is really the function entry point. */
450 const struct block
*pc_block
= block_for_pc (pc
);
451 struct symbol
*pc_func
= NULL
;
454 pc_func
= block_linkage_function (pc_block
);
456 if (pc_func
&& pc
== pc_func
->value_block ()->entry_pc ())
458 *locexpr_length
= length
;
463 if (pc
>= low
&& pc
< high
)
465 *locexpr_length
= length
;
473 /* Implement find_frame_base_location method for LOC_BLOCK functions using
474 DWARF expression for its DW_AT_frame_base. */
477 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
478 const gdb_byte
**start
, size_t *length
)
480 struct dwarf2_locexpr_baton
*symbaton
481 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
483 *length
= symbaton
->size
;
484 *start
= symbaton
->data
;
487 /* Implement the struct symbol_block_ops::get_frame_base method for
488 LOC_BLOCK functions using a DWARF expression as its DW_AT_frame_base. */
491 locexpr_get_frame_base (struct symbol
*framefunc
, frame_info_ptr frame
)
493 struct gdbarch
*gdbarch
;
495 struct dwarf2_locexpr_baton
*dlbaton
;
496 const gdb_byte
*start
;
498 struct value
*result
;
500 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
501 Thus, it's supposed to provide the find_frame_base_location method as
503 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
505 gdbarch
= get_frame_arch (frame
);
506 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
507 dlbaton
= (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
509 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
510 (framefunc
, get_frame_pc (frame
), &start
, &length
);
511 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
512 dlbaton
->per_cu
, dlbaton
->per_objfile
);
514 /* The DW_AT_frame_base attribute contains a location description which
515 computes the base address itself. However, the call to
516 dwarf2_evaluate_loc_desc returns a value representing a variable at
517 that address. The frame base address is thus this variable's
519 return value_address (result
);
522 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
523 function uses DWARF expression for its DW_AT_frame_base. */
525 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
527 locexpr_find_frame_base_location
,
528 locexpr_get_frame_base
531 /* Implement find_frame_base_location method for LOC_BLOCK functions using
532 DWARF location list for its DW_AT_frame_base. */
535 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
536 const gdb_byte
**start
, size_t *length
)
538 struct dwarf2_loclist_baton
*symbaton
539 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
541 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
544 /* Implement the struct symbol_block_ops::get_frame_base method for
545 LOC_BLOCK functions using a DWARF location list as its DW_AT_frame_base. */
548 loclist_get_frame_base (struct symbol
*framefunc
, frame_info_ptr frame
)
550 struct gdbarch
*gdbarch
;
552 struct dwarf2_loclist_baton
*dlbaton
;
553 const gdb_byte
*start
;
555 struct value
*result
;
557 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
558 Thus, it's supposed to provide the find_frame_base_location method as
560 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
562 gdbarch
= get_frame_arch (frame
);
563 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
564 dlbaton
= (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
566 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
567 (framefunc
, get_frame_pc (frame
), &start
, &length
);
568 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
569 dlbaton
->per_cu
, dlbaton
->per_objfile
);
571 /* The DW_AT_frame_base attribute contains a location description which
572 computes the base address itself. However, the call to
573 dwarf2_evaluate_loc_desc returns a value representing a variable at
574 that address. The frame base address is thus this variable's
576 return value_address (result
);
579 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
580 function uses DWARF location list for its DW_AT_frame_base. */
582 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
584 loclist_find_frame_base_location
,
585 loclist_get_frame_base
588 /* See dwarf2/loc.h. */
591 func_get_frame_base_dwarf_block (struct symbol
*framefunc
, CORE_ADDR pc
,
592 const gdb_byte
**start
, size_t *length
)
594 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
596 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
598 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
604 error (_("Could not find the frame base for \"%s\"."),
605 framefunc
->natural_name ());
611 compute_var_value (const char *name
)
613 struct block_symbol sym
= lookup_symbol (name
, nullptr, VAR_DOMAIN
,
615 if (sym
.symbol
!= nullptr)
616 return value_of_variable (sym
.symbol
, sym
.block
);
620 /* See dwarf2/loc.h. */
622 unsigned int entry_values_debug
= 0;
624 /* Helper to set entry_values_debug. */
627 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
628 struct cmd_list_element
*c
, const char *value
)
631 _("Entry values and tail call frames debugging is %s.\n"),
635 /* See gdbtypes.h. */
638 call_site_target::iterate_over_addresses
639 (struct gdbarch
*call_site_gdbarch
,
640 const struct call_site
*call_site
,
641 frame_info_ptr caller_frame
,
642 iterate_ftype callback
) const
646 case call_site_target::DWARF_BLOCK
:
648 struct dwarf2_locexpr_baton
*dwarf_block
;
650 struct type
*caller_core_addr_type
;
651 struct gdbarch
*caller_arch
;
653 dwarf_block
= m_loc
.dwarf_block
;
654 if (dwarf_block
== NULL
)
656 struct bound_minimal_symbol msym
;
658 msym
= lookup_minimal_symbol_by_pc (call_site
->pc () - 1);
659 throw_error (NO_ENTRY_VALUE_ERROR
,
660 _("DW_AT_call_target is not specified at %s in %s"),
661 paddress (call_site_gdbarch
, call_site
->pc ()),
662 (msym
.minsym
== NULL
? "???"
663 : msym
.minsym
->print_name ()));
666 if (caller_frame
== NULL
)
668 struct bound_minimal_symbol msym
;
670 msym
= lookup_minimal_symbol_by_pc (call_site
->pc () - 1);
671 throw_error (NO_ENTRY_VALUE_ERROR
,
672 _("DW_AT_call_target DWARF block resolving "
673 "requires known frame which is currently not "
674 "available at %s in %s"),
675 paddress (call_site_gdbarch
, call_site
->pc ()),
676 (msym
.minsym
== NULL
? "???"
677 : msym
.minsym
->print_name ()));
680 caller_arch
= get_frame_arch (caller_frame
);
681 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
682 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
683 dwarf_block
->data
, dwarf_block
->size
,
685 dwarf_block
->per_objfile
);
686 /* DW_AT_call_target is a DWARF expression, not a DWARF location. */
687 if (VALUE_LVAL (val
) == lval_memory
)
688 callback (value_address (val
));
690 callback (value_as_address (val
));
694 case call_site_target::PHYSNAME
:
696 const char *physname
;
697 struct bound_minimal_symbol msym
;
699 physname
= m_loc
.physname
;
701 /* Handle both the mangled and demangled PHYSNAME. */
702 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
703 if (msym
.minsym
== NULL
)
705 msym
= lookup_minimal_symbol_by_pc (call_site
->pc () - 1);
706 throw_error (NO_ENTRY_VALUE_ERROR
,
707 _("Cannot find function \"%s\" for a call site target "
709 physname
, paddress (call_site_gdbarch
, call_site
->pc ()),
710 (msym
.minsym
== NULL
? "???"
711 : msym
.minsym
->print_name ()));
714 callback (msym
.value_address ());
718 case call_site_target::PHYSADDR
:
720 dwarf2_per_objfile
*per_objfile
= call_site
->per_objfile
;
721 compunit_symtab
*cust
= per_objfile
->get_symtab (call_site
->per_cu
);
722 int sect_idx
= cust
->block_line_section ();
723 CORE_ADDR delta
= per_objfile
->objfile
->section_offsets
[sect_idx
];
725 callback (m_loc
.physaddr
+ delta
);
729 case call_site_target::ADDRESSES
:
731 dwarf2_per_objfile
*per_objfile
= call_site
->per_objfile
;
732 compunit_symtab
*cust
= per_objfile
->get_symtab (call_site
->per_cu
);
733 int sect_idx
= cust
->block_line_section ();
734 CORE_ADDR delta
= per_objfile
->objfile
->section_offsets
[sect_idx
];
736 for (unsigned i
= 0; i
< m_loc
.addresses
.length
; ++i
)
737 callback (m_loc
.addresses
.values
[i
] + delta
);
742 internal_error (_("invalid call site target kind"));
746 /* Convert function entry point exact address ADDR to the function which is
747 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
748 NO_ENTRY_VALUE_ERROR otherwise. */
750 static struct symbol
*
751 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
753 struct symbol
*sym
= find_pc_function (addr
);
756 if (sym
== NULL
|| sym
->value_block ()->entry_pc () != addr
)
757 throw_error (NO_ENTRY_VALUE_ERROR
,
758 _("DW_TAG_call_site resolving failed to find function "
759 "name for address %s"),
760 paddress (gdbarch
, addr
));
763 gdb_assert (type
->code () == TYPE_CODE_FUNC
);
764 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
769 /* Verify function with entry point exact address ADDR can never call itself
770 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
771 can call itself via tail calls.
773 If a funtion can tail call itself its entry value based parameters are
774 unreliable. There is no verification whether the value of some/all
775 parameters is unchanged through the self tail call, we expect if there is
776 a self tail call all the parameters can be modified. */
779 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
783 /* The verification is completely unordered. Track here function addresses
784 which still need to be iterated. */
785 std::vector
<CORE_ADDR
> todo
;
787 /* Track here CORE_ADDRs which were already visited. */
788 std::unordered_set
<CORE_ADDR
> addr_hash
;
790 todo
.push_back (verify_addr
);
791 while (!todo
.empty ())
793 struct symbol
*func_sym
;
794 struct call_site
*call_site
;
799 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
801 for (call_site
= TYPE_TAIL_CALL_LIST (func_sym
->type ());
802 call_site
; call_site
= call_site
->tail_call_next
)
804 /* CALLER_FRAME with registers is not available for tail-call jumped
806 call_site
->iterate_over_addresses (gdbarch
, nullptr,
807 [&] (CORE_ADDR target_addr
)
809 if (target_addr
== verify_addr
)
811 struct bound_minimal_symbol msym
;
813 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
814 throw_error (NO_ENTRY_VALUE_ERROR
,
815 _("DW_OP_entry_value resolving has found "
816 "function \"%s\" at %s can call itself via tail "
818 (msym
.minsym
== NULL
? "???"
819 : msym
.minsym
->print_name ()),
820 paddress (gdbarch
, verify_addr
));
823 if (addr_hash
.insert (target_addr
).second
)
824 todo
.push_back (target_addr
);
830 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
831 ENTRY_VALUES_DEBUG. */
834 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
836 CORE_ADDR addr
= call_site
->pc ();
837 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
839 gdb_printf (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
840 (msym
.minsym
== NULL
? "???"
841 : msym
.minsym
->print_name ()));
845 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
846 only top callers and bottom callees which are present in both. GDBARCH is
847 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
848 no remaining possibilities to provide unambiguous non-trivial result.
849 RESULTP should point to NULL on the first (initialization) call. Caller is
850 responsible for xfree of any RESULTP data. */
853 chain_candidate (struct gdbarch
*gdbarch
,
854 gdb::unique_xmalloc_ptr
<struct call_site_chain
> *resultp
,
855 const std::vector
<struct call_site
*> &chain
)
857 long length
= chain
.size ();
858 int callers
, callees
, idx
;
860 if (*resultp
== NULL
)
862 /* Create the initial chain containing all the passed PCs. */
864 struct call_site_chain
*result
865 = ((struct call_site_chain
*)
866 xmalloc (sizeof (*result
)
867 + sizeof (*result
->call_site
) * (length
- 1)));
868 result
->length
= length
;
869 result
->callers
= result
->callees
= length
;
871 memcpy (result
->call_site
, chain
.data (),
872 sizeof (*result
->call_site
) * length
);
873 resultp
->reset (result
);
875 if (entry_values_debug
)
877 gdb_printf (gdb_stdlog
, "tailcall: initial:");
878 for (idx
= 0; idx
< length
; idx
++)
879 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
880 gdb_putc ('\n', gdb_stdlog
);
886 if (entry_values_debug
)
888 gdb_printf (gdb_stdlog
, "tailcall: compare:");
889 for (idx
= 0; idx
< length
; idx
++)
890 tailcall_dump (gdbarch
, chain
[idx
]);
891 gdb_putc ('\n', gdb_stdlog
);
894 /* Intersect callers. */
896 callers
= std::min ((long) (*resultp
)->callers
, length
);
897 for (idx
= 0; idx
< callers
; idx
++)
898 if ((*resultp
)->call_site
[idx
] != chain
[idx
])
900 (*resultp
)->callers
= idx
;
904 /* Intersect callees. */
906 callees
= std::min ((long) (*resultp
)->callees
, length
);
907 for (idx
= 0; idx
< callees
; idx
++)
908 if ((*resultp
)->call_site
[(*resultp
)->length
- 1 - idx
]
909 != chain
[length
- 1 - idx
])
911 (*resultp
)->callees
= idx
;
915 if (entry_values_debug
)
917 gdb_printf (gdb_stdlog
, "tailcall: reduced:");
918 for (idx
= 0; idx
< (*resultp
)->callers
; idx
++)
919 tailcall_dump (gdbarch
, (*resultp
)->call_site
[idx
]);
920 gdb_puts (" |", gdb_stdlog
);
921 for (idx
= 0; idx
< (*resultp
)->callees
; idx
++)
922 tailcall_dump (gdbarch
,
923 (*resultp
)->call_site
[(*resultp
)->length
924 - (*resultp
)->callees
+ idx
]);
925 gdb_putc ('\n', gdb_stdlog
);
928 if ((*resultp
)->callers
== 0 && (*resultp
)->callees
== 0)
930 /* There are no common callers or callees. It could be also a direct
931 call (which has length 0) with ambiguous possibility of an indirect
932 call - CALLERS == CALLEES == 0 is valid during the first allocation
933 but any subsequence processing of such entry means ambiguity. */
934 resultp
->reset (NULL
);
938 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
939 PC again. In such case there must be two different code paths to reach
940 it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
941 gdb_assert ((*resultp
)->callers
+ (*resultp
)->callees
<= (*resultp
)->length
);
944 /* Recursively try to construct the call chain. GDBARCH, RESULTP, and
945 CHAIN are passed to chain_candidate. ADDR_HASH tracks which
946 addresses have already been seen along the current chain.
947 CALL_SITE is the call site to visit, and CALLEE_PC is the PC we're
948 trying to "reach". Returns false if an error has already been
949 detected and so an early return can be done. If it makes sense to
950 keep trying (even if no answer has yet been found), returns
954 call_site_find_chain_2
955 (struct gdbarch
*gdbarch
,
956 gdb::unique_xmalloc_ptr
<struct call_site_chain
> *resultp
,
957 std::vector
<struct call_site
*> &chain
,
958 std::unordered_set
<CORE_ADDR
> &addr_hash
,
959 struct call_site
*call_site
,
962 std::vector
<CORE_ADDR
> addresses
;
963 bool found_exact
= false;
964 call_site
->iterate_over_addresses (gdbarch
, nullptr,
967 if (addr
== callee_pc
)
970 addresses
.push_back (addr
);
975 chain_candidate (gdbarch
, resultp
, chain
);
976 /* If RESULTP was reset, then chain_candidate failed, and so we
977 can tell our callers to early-return. */
978 return *resultp
!= nullptr;
981 for (CORE_ADDR target_func_addr
: addresses
)
983 struct symbol
*target_func
984 = func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
985 for (struct call_site
*target_call_site
986 = TYPE_TAIL_CALL_LIST (target_func
->type ());
987 target_call_site
!= nullptr;
988 target_call_site
= target_call_site
->tail_call_next
)
990 if (addr_hash
.insert (target_call_site
->pc ()).second
)
992 /* Successfully entered TARGET_CALL_SITE. */
993 chain
.push_back (target_call_site
);
995 if (!call_site_find_chain_2 (gdbarch
, resultp
, chain
,
996 addr_hash
, target_call_site
,
1000 size_t removed
= addr_hash
.erase (target_call_site
->pc ());
1001 gdb_assert (removed
== 1);
1010 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All
1011 the assumed frames between them use GDBARCH. Any unreliability
1012 results in thrown NO_ENTRY_VALUE_ERROR. */
1014 static gdb::unique_xmalloc_ptr
<call_site_chain
>
1015 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1016 CORE_ADDR callee_pc
)
1018 CORE_ADDR save_callee_pc
= callee_pc
;
1019 gdb::unique_xmalloc_ptr
<struct call_site_chain
> retval
;
1020 struct call_site
*call_site
;
1022 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
1023 call_site nor any possible call_site at CALLEE_PC's function is there.
1024 Any CALL_SITE in CHAIN will be iterated to its siblings - via
1025 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
1026 std::vector
<struct call_site
*> chain
;
1028 /* A given call site may have multiple associated addresses. This
1029 can happen if, e.g., the caller is split by hot/cold
1030 partitioning. This vector tracks the ones we haven't visited
1032 std::vector
<std::vector
<CORE_ADDR
>> unvisited_addresses
;
1034 /* We are not interested in the specific PC inside the callee function. */
1035 callee_pc
= get_pc_function_start (callee_pc
);
1037 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
1038 paddress (gdbarch
, save_callee_pc
));
1040 /* Mark CALL_SITEs so we do not visit the same ones twice. */
1041 std::unordered_set
<CORE_ADDR
> addr_hash
;
1043 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
1044 at the target's function. All the possible tail call sites in the
1045 target's function will get iterated as already pushed into CHAIN via their
1047 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1048 /* No need to check the return value here, because we no longer care
1049 about possible early returns. */
1050 call_site_find_chain_2 (gdbarch
, &retval
, chain
, addr_hash
, call_site
,
1055 struct bound_minimal_symbol msym_caller
, msym_callee
;
1057 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
1058 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
1059 throw_error (NO_ENTRY_VALUE_ERROR
,
1060 _("There are no unambiguously determinable intermediate "
1061 "callers or callees between caller function \"%s\" at %s "
1062 "and callee function \"%s\" at %s"),
1063 (msym_caller
.minsym
== NULL
1064 ? "???" : msym_caller
.minsym
->print_name ()),
1065 paddress (gdbarch
, caller_pc
),
1066 (msym_callee
.minsym
== NULL
1067 ? "???" : msym_callee
.minsym
->print_name ()),
1068 paddress (gdbarch
, callee_pc
));
1074 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1075 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
1076 constructed return NULL. */
1078 gdb::unique_xmalloc_ptr
<call_site_chain
>
1079 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1080 CORE_ADDR callee_pc
)
1082 gdb::unique_xmalloc_ptr
<call_site_chain
> retval
;
1086 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
1088 catch (const gdb_exception_error
&e
)
1090 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
1092 if (entry_values_debug
)
1093 exception_print (gdb_stdout
, e
);
1104 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1107 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1108 enum call_site_parameter_kind kind
,
1109 union call_site_parameter_u kind_u
)
1111 if (kind
== parameter
->kind
)
1114 case CALL_SITE_PARAMETER_DWARF_REG
:
1115 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1117 case CALL_SITE_PARAMETER_FB_OFFSET
:
1118 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1120 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1121 return kind_u
.param_cu_off
== parameter
->u
.param_cu_off
;
1128 struct call_site_parameter
*
1129 dwarf_expr_reg_to_entry_parameter (frame_info_ptr frame
,
1130 enum call_site_parameter_kind kind
,
1131 union call_site_parameter_u kind_u
,
1132 dwarf2_per_cu_data
**per_cu_return
,
1133 dwarf2_per_objfile
**per_objfile_return
)
1135 CORE_ADDR func_addr
, caller_pc
;
1136 struct gdbarch
*gdbarch
;
1137 frame_info_ptr caller_frame
;
1138 struct call_site
*call_site
;
1140 /* Initialize it just to avoid a GCC false warning. */
1141 struct call_site_parameter
*parameter
= NULL
;
1142 CORE_ADDR target_addr
;
1144 while (get_frame_type (frame
) == INLINE_FRAME
)
1146 frame
= get_prev_frame (frame
);
1147 gdb_assert (frame
!= NULL
);
1150 func_addr
= get_frame_func (frame
);
1151 gdbarch
= get_frame_arch (frame
);
1152 caller_frame
= get_prev_frame (frame
);
1153 if (gdbarch
!= frame_unwind_arch (frame
))
1155 struct bound_minimal_symbol msym
1156 = lookup_minimal_symbol_by_pc (func_addr
);
1157 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1159 throw_error (NO_ENTRY_VALUE_ERROR
,
1160 _("DW_OP_entry_value resolving callee gdbarch %s "
1161 "(of %s (%s)) does not match caller gdbarch %s"),
1162 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1163 paddress (gdbarch
, func_addr
),
1164 (msym
.minsym
== NULL
? "???"
1165 : msym
.minsym
->print_name ()),
1166 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1169 if (caller_frame
== NULL
)
1171 struct bound_minimal_symbol msym
1172 = lookup_minimal_symbol_by_pc (func_addr
);
1174 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_entry_value resolving "
1175 "requires caller of %s (%s)"),
1176 paddress (gdbarch
, func_addr
),
1177 (msym
.minsym
== NULL
? "???"
1178 : msym
.minsym
->print_name ()));
1180 caller_pc
= get_frame_pc (caller_frame
);
1181 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1185 call_site
->iterate_over_addresses (gdbarch
, caller_frame
,
1186 [&] (CORE_ADDR addr
)
1188 /* Preserve any address. */
1191 if (addr
== func_addr
)
1196 struct minimal_symbol
*target_msym
, *func_msym
;
1198 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1199 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1200 throw_error (NO_ENTRY_VALUE_ERROR
,
1201 _("DW_OP_entry_value resolving expects callee %s at %s %s"
1202 "but the called frame is for %s at %s"),
1203 (target_msym
== NULL
? "???"
1204 : target_msym
->print_name ()),
1205 paddress (gdbarch
, target_addr
),
1207 ? _("(but note there are multiple addresses not listed)")
1209 func_msym
== NULL
? "???" : func_msym
->print_name (),
1210 paddress (gdbarch
, func_addr
));
1213 /* No entry value based parameters would be reliable if this function can
1214 call itself via tail calls. */
1215 func_verify_no_selftailcall (gdbarch
, func_addr
);
1217 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1219 parameter
= &call_site
->parameter
[iparams
];
1220 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1223 if (iparams
== call_site
->parameter_count
)
1225 struct minimal_symbol
*msym
1226 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1228 /* DW_TAG_call_site_parameter will be missing just if GCC could not
1229 determine its value. */
1230 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1231 "at DW_TAG_call_site %s at %s"),
1232 paddress (gdbarch
, caller_pc
),
1233 msym
== NULL
? "???" : msym
->print_name ());
1236 *per_cu_return
= call_site
->per_cu
;
1237 *per_objfile_return
= call_site
->per_objfile
;
1241 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1242 the normal DW_AT_call_value block. Otherwise return the
1243 DW_AT_call_data_value (dereferenced) block.
1245 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1248 Function always returns non-NULL, non-optimized out value. It throws
1249 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1251 static struct value
*
1252 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1253 CORE_ADDR deref_size
, struct type
*type
,
1254 frame_info_ptr caller_frame
,
1255 dwarf2_per_cu_data
*per_cu
,
1256 dwarf2_per_objfile
*per_objfile
)
1258 const gdb_byte
*data_src
;
1261 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1262 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1264 /* DEREF_SIZE size is not verified here. */
1265 if (data_src
== NULL
)
1266 throw_error (NO_ENTRY_VALUE_ERROR
,
1267 _("Cannot resolve DW_AT_call_data_value"));
1269 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data_src
, size
, per_cu
,
1270 per_objfile
, false);
1273 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1274 the indirect method on it, that is use its stored target value, the sole
1275 purpose of entry_data_value_funcs.. */
1277 static struct value
*
1278 entry_data_value_coerce_ref (const struct value
*value
)
1280 struct type
*checked_type
= check_typedef (value_type (value
));
1281 struct value
*target_val
;
1283 if (!TYPE_IS_REFERENCE (checked_type
))
1286 target_val
= (struct value
*) value_computed_closure (value
);
1287 value_incref (target_val
);
1291 /* Implement copy_closure. */
1294 entry_data_value_copy_closure (const struct value
*v
)
1296 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1298 value_incref (target_val
);
1302 /* Implement free_closure. */
1305 entry_data_value_free_closure (struct value
*v
)
1307 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1309 value_decref (target_val
);
1312 /* Vector for methods for an entry value reference where the referenced value
1313 is stored in the caller. On the first dereference use
1314 DW_AT_call_data_value in the caller. */
1316 static const struct lval_funcs entry_data_value_funcs
=
1321 NULL
, /* indirect */
1322 entry_data_value_coerce_ref
,
1323 NULL
, /* check_synthetic_pointer */
1324 entry_data_value_copy_closure
,
1325 entry_data_value_free_closure
1328 /* See dwarf2/loc.h. */
1330 value_of_dwarf_reg_entry (struct type
*type
, frame_info_ptr frame
,
1331 enum call_site_parameter_kind kind
,
1332 union call_site_parameter_u kind_u
)
1334 struct type
*checked_type
= check_typedef (type
);
1335 struct type
*target_type
= checked_type
->target_type ();
1336 frame_info_ptr caller_frame
= get_prev_frame (frame
);
1337 struct value
*outer_val
, *target_val
, *val
;
1338 struct call_site_parameter
*parameter
;
1339 dwarf2_per_cu_data
*caller_per_cu
;
1340 dwarf2_per_objfile
*caller_per_objfile
;
1342 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1344 &caller_per_objfile
);
1346 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1349 caller_per_objfile
);
1351 /* Check if DW_AT_call_data_value cannot be used. If it should be
1352 used and it is not available do not fall back to OUTER_VAL - dereferencing
1353 TYPE_CODE_REF with non-entry data value would give current value - not the
1356 if (!TYPE_IS_REFERENCE (checked_type
)
1357 || checked_type
->target_type () == NULL
)
1360 target_val
= dwarf_entry_parameter_to_value (parameter
,
1361 target_type
->length (),
1362 target_type
, caller_frame
,
1364 caller_per_objfile
);
1366 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1367 release_value (target_val
).release ());
1369 /* Copy the referencing pointer to the new computed value. */
1370 memcpy (value_contents_raw (val
).data (),
1371 value_contents_raw (outer_val
).data (),
1372 checked_type
->length ());
1373 set_value_lazy (val
, 0);
1378 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1379 SIZE are DWARF block used to match DW_AT_location at the caller's
1380 DW_TAG_call_site_parameter.
1382 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1383 cannot resolve the parameter for any reason. */
1385 static struct value
*
1386 value_of_dwarf_block_entry (struct type
*type
, frame_info_ptr frame
,
1387 const gdb_byte
*block
, size_t block_len
)
1389 union call_site_parameter_u kind_u
;
1391 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1392 if (kind_u
.dwarf_reg
!= -1)
1393 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1396 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1397 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1400 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1401 suppressed during normal operation. The expression can be arbitrary if
1402 there is no caller-callee entry value binding expected. */
1403 throw_error (NO_ENTRY_VALUE_ERROR
,
1404 _("DWARF-2 expression error: DW_OP_entry_value is supported "
1405 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1408 /* Fetch a DW_AT_const_value through a synthetic pointer. */
1410 static struct value
*
1411 fetch_const_value_from_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
1412 dwarf2_per_cu_data
*per_cu
,
1413 dwarf2_per_objfile
*per_objfile
,
1416 struct value
*result
= NULL
;
1417 const gdb_byte
*bytes
;
1420 auto_obstack temp_obstack
;
1421 bytes
= dwarf2_fetch_constant_bytes (die
, per_cu
, per_objfile
,
1422 &temp_obstack
, &len
);
1426 if (byte_offset
>= 0
1427 && byte_offset
+ type
->target_type ()->length () <= len
)
1429 bytes
+= byte_offset
;
1430 result
= value_from_contents (type
->target_type (), bytes
);
1433 invalid_synthetic_pointer ();
1436 result
= allocate_optimized_out_value (type
->target_type ());
1444 indirect_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
1445 dwarf2_per_cu_data
*per_cu
,
1446 dwarf2_per_objfile
*per_objfile
,
1447 frame_info_ptr frame
, struct type
*type
,
1448 bool resolve_abstract_p
)
1450 /* Fetch the location expression of the DIE we're pointing to. */
1451 auto get_frame_address_in_block_wrapper
= [frame
] ()
1453 return get_frame_address_in_block (frame
);
1455 struct dwarf2_locexpr_baton baton
1456 = dwarf2_fetch_die_loc_sect_off (die
, per_cu
, per_objfile
,
1457 get_frame_address_in_block_wrapper
,
1458 resolve_abstract_p
);
1460 /* Get type of pointed-to DIE. */
1461 struct type
*orig_type
= dwarf2_fetch_die_type_sect_off (die
, per_cu
,
1463 if (orig_type
== NULL
)
1464 invalid_synthetic_pointer ();
1466 /* If pointed-to DIE has a DW_AT_location, evaluate it and return the
1467 resulting value. Otherwise, it may have a DW_AT_const_value instead,
1468 or it may've been optimized out. */
1469 if (baton
.data
!= NULL
)
1470 return dwarf2_evaluate_loc_desc_full (orig_type
, frame
, baton
.data
,
1471 baton
.size
, baton
.per_cu
,
1473 type
->target_type (),
1476 return fetch_const_value_from_synthetic_pointer (die
, byte_offset
, per_cu
,
1480 /* Evaluate a location description, starting at DATA and with length
1481 SIZE, to find the current location of variable of TYPE in the
1482 context of FRAME. If SUBOBJ_TYPE is non-NULL, return instead the
1483 location of the subobject of type SUBOBJ_TYPE at byte offset
1484 SUBOBJ_BYTE_OFFSET within the variable of type TYPE. */
1486 static struct value
*
1487 dwarf2_evaluate_loc_desc_full (struct type
*type
, frame_info_ptr frame
,
1488 const gdb_byte
*data
, size_t size
,
1489 dwarf2_per_cu_data
*per_cu
,
1490 dwarf2_per_objfile
*per_objfile
,
1491 struct type
*subobj_type
,
1492 LONGEST subobj_byte_offset
,
1495 if (subobj_type
== NULL
)
1498 subobj_byte_offset
= 0;
1500 else if (subobj_byte_offset
< 0)
1501 invalid_synthetic_pointer ();
1504 return allocate_optimized_out_value (subobj_type
);
1506 dwarf_expr_context
ctx (per_objfile
, per_cu
->addr_size ());
1509 scoped_value_mark free_values
;
1513 retval
= ctx
.evaluate (data
, size
, as_lval
, per_cu
, frame
, nullptr,
1514 type
, subobj_type
, subobj_byte_offset
);
1516 catch (const gdb_exception_error
&ex
)
1518 if (ex
.error
== NOT_AVAILABLE_ERROR
)
1520 free_values
.free_to_mark ();
1521 retval
= allocate_value (subobj_type
);
1522 mark_value_bytes_unavailable (retval
, 0,
1523 subobj_type
->length ());
1526 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
1528 if (entry_values_debug
)
1529 exception_print (gdb_stdout
, ex
);
1530 free_values
.free_to_mark ();
1531 return allocate_optimized_out_value (subobj_type
);
1537 /* We need to clean up all the values that are not needed any more.
1538 The problem with a value_ref_ptr class is that it disconnects the
1539 RETVAL from the value garbage collection, so we need to make
1540 a copy of that value on the stack to keep everything consistent.
1541 The value_ref_ptr will clean up after itself at the end of this block. */
1542 value_ref_ptr value_holder
= value_ref_ptr::new_reference (retval
);
1543 free_values
.free_to_mark ();
1545 return value_copy (retval
);
1548 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
1549 passes 0 as the byte_offset. */
1552 dwarf2_evaluate_loc_desc (struct type
*type
, frame_info_ptr frame
,
1553 const gdb_byte
*data
, size_t size
,
1554 dwarf2_per_cu_data
*per_cu
,
1555 dwarf2_per_objfile
*per_objfile
, bool as_lval
)
1557 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
,
1558 per_objfile
, NULL
, 0, as_lval
);
1561 /* Evaluates a dwarf expression and stores the result in VAL,
1562 expecting that the dwarf expression only produces a single
1563 CORE_ADDR. FRAME is the frame in which the expression is
1564 evaluated. ADDR_STACK is a context (location of a variable) and
1565 might be needed to evaluate the location expression.
1567 PUSH_VALUES is an array of values to be pushed to the expression stack
1568 before evaluation starts. PUSH_VALUES[0] is pushed first, then
1569 PUSH_VALUES[1], and so on.
1571 Returns 1 on success, 0 otherwise. */
1574 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton
*dlbaton
,
1575 frame_info_ptr frame
,
1576 const struct property_addr_info
*addr_stack
,
1578 gdb::array_view
<CORE_ADDR
> push_values
,
1581 if (dlbaton
== NULL
|| dlbaton
->size
== 0)
1584 dwarf2_per_objfile
*per_objfile
= dlbaton
->per_objfile
;
1585 dwarf2_per_cu_data
*per_cu
= dlbaton
->per_cu
;
1586 dwarf_expr_context
ctx (per_objfile
, per_cu
->addr_size ());
1589 scoped_value_mark free_values
;
1591 /* Place any initial values onto the expression stack. */
1592 for (const auto &val
: push_values
)
1593 ctx
.push_address (val
, false);
1597 result
= ctx
.evaluate (dlbaton
->data
, dlbaton
->size
,
1598 true, per_cu
, frame
, addr_stack
);
1600 catch (const gdb_exception_error
&ex
)
1602 if (ex
.error
== NOT_AVAILABLE_ERROR
)
1606 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
1608 if (entry_values_debug
)
1609 exception_print (gdb_stdout
, ex
);
1616 if (value_optimized_out (result
))
1619 if (VALUE_LVAL (result
) == lval_memory
)
1620 *valp
= value_address (result
);
1623 if (VALUE_LVAL (result
) == not_lval
)
1624 *is_reference
= false;
1626 *valp
= value_as_address (result
);
1632 /* See dwarf2/loc.h. */
1635 dwarf2_evaluate_property (const struct dynamic_prop
*prop
,
1636 frame_info_ptr frame
,
1637 const struct property_addr_info
*addr_stack
,
1639 gdb::array_view
<CORE_ADDR
> push_values
)
1644 /* Evaluating a property should not change the current language.
1645 Without this here this could happen if the code below selects a
1647 scoped_restore_current_language save_language
;
1649 if (frame
== NULL
&& has_stack_frames ())
1650 frame
= get_selected_frame (NULL
);
1652 switch (prop
->kind ())
1656 const struct dwarf2_property_baton
*baton
1657 = (const struct dwarf2_property_baton
*) prop
->baton ();
1658 gdb_assert (baton
->property_type
!= NULL
);
1660 bool is_reference
= baton
->locexpr
.is_reference
;
1661 if (dwarf2_locexpr_baton_eval (&baton
->locexpr
, frame
, addr_stack
,
1662 value
, push_values
, &is_reference
))
1666 struct value
*val
= value_at (baton
->property_type
, *value
);
1667 *value
= value_as_address (val
);
1671 gdb_assert (baton
->property_type
!= NULL
);
1673 struct type
*type
= check_typedef (baton
->property_type
);
1674 if (type
->length () < sizeof (CORE_ADDR
)
1675 && !type
->is_unsigned ())
1677 /* If we have a valid return candidate and it's value
1678 is signed, we have to sign-extend the value because
1679 CORE_ADDR on 64bit machine has 8 bytes but address
1680 size of an 32bit application is bytes. */
1682 = (baton
->locexpr
.per_cu
->addr_size ()
1684 const CORE_ADDR neg_mask
1685 = (~((CORE_ADDR
) 0) << (addr_size
- 1));
1687 /* Check if signed bit is set and sign-extend values. */
1688 if (*value
& neg_mask
)
1699 struct dwarf2_property_baton
*baton
1700 = (struct dwarf2_property_baton
*) prop
->baton ();
1702 const gdb_byte
*data
;
1707 || !get_frame_address_in_block_if_available (frame
, &pc
))
1710 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
1713 val
= dwarf2_evaluate_loc_desc (baton
->property_type
, frame
, data
,
1714 size
, baton
->loclist
.per_cu
,
1715 baton
->loclist
.per_objfile
);
1716 if (!value_optimized_out (val
))
1718 *value
= value_as_address (val
);
1726 *value
= prop
->const_val ();
1729 case PROP_ADDR_OFFSET
:
1731 struct dwarf2_property_baton
*baton
1732 = (struct dwarf2_property_baton
*) prop
->baton ();
1733 const struct property_addr_info
*pinfo
;
1736 for (pinfo
= addr_stack
; pinfo
!= NULL
; pinfo
= pinfo
->next
)
1738 /* This approach lets us avoid checking the qualifiers. */
1739 if (TYPE_MAIN_TYPE (pinfo
->type
)
1740 == TYPE_MAIN_TYPE (baton
->property_type
))
1744 error (_("cannot find reference address for offset property"));
1745 if (pinfo
->valaddr
.data () != NULL
)
1746 val
= value_from_contents
1747 (baton
->offset_info
.type
,
1748 pinfo
->valaddr
.data () + baton
->offset_info
.offset
);
1750 val
= value_at (baton
->offset_info
.type
,
1751 pinfo
->addr
+ baton
->offset_info
.offset
);
1752 *value
= value_as_address (val
);
1756 case PROP_VARIABLE_NAME
:
1758 struct value
*val
= compute_var_value (prop
->variable_name ());
1761 *value
= value_as_long (val
);
1771 /* See dwarf2/loc.h. */
1774 dwarf2_compile_property_to_c (string_file
*stream
,
1775 const char *result_name
,
1776 struct gdbarch
*gdbarch
,
1777 std::vector
<bool> ®isters_used
,
1778 const struct dynamic_prop
*prop
,
1782 struct dwarf2_property_baton
*baton
1783 = (struct dwarf2_property_baton
*) prop
->baton ();
1784 const gdb_byte
*data
;
1786 dwarf2_per_cu_data
*per_cu
;
1787 dwarf2_per_objfile
*per_objfile
;
1789 if (prop
->kind () == PROP_LOCEXPR
)
1791 data
= baton
->locexpr
.data
;
1792 size
= baton
->locexpr
.size
;
1793 per_cu
= baton
->locexpr
.per_cu
;
1794 per_objfile
= baton
->locexpr
.per_objfile
;
1798 gdb_assert (prop
->kind () == PROP_LOCLIST
);
1800 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
1801 per_cu
= baton
->loclist
.per_cu
;
1802 per_objfile
= baton
->loclist
.per_objfile
;
1805 compile_dwarf_bounds_to_c (stream
, result_name
, prop
, sym
, pc
,
1806 gdbarch
, registers_used
,
1807 per_cu
->addr_size (),
1808 data
, data
+ size
, per_cu
, per_objfile
);
1811 /* Compute the correct symbol_needs_kind value for the location
1814 Implemented by traversing the logical control flow graph of the
1817 static enum symbol_needs_kind
1818 dwarf2_get_symbol_read_needs (gdb::array_view
<const gdb_byte
> expr
,
1819 dwarf2_per_cu_data
*per_cu
,
1820 dwarf2_per_objfile
*per_objfile
,
1821 bfd_endian byte_order
,
1826 enum symbol_needs_kind symbol_needs
= SYMBOL_NEEDS_NONE
;
1828 /* If the expression is empty, we have nothing to do. */
1830 return symbol_needs
;
1832 const gdb_byte
*expr_end
= expr
.data () + expr
.size ();
1834 /* List of operations to visit. Operations in this list are not visited yet,
1835 so are not in VISITED_OPS (and vice-versa). */
1836 std::vector
<const gdb_byte
*> ops_to_visit
;
1838 /* Operations already visited. */
1839 std::unordered_set
<const gdb_byte
*> visited_ops
;
1841 /* Insert OP in OPS_TO_VISIT if it is within the expression's range and
1842 hasn't been visited yet. */
1843 auto insert_in_ops_to_visit
1844 = [expr_end
, &visited_ops
, &ops_to_visit
] (const gdb_byte
*op_ptr
)
1846 if (op_ptr
>= expr_end
)
1849 if (visited_ops
.find (op_ptr
) != visited_ops
.end ())
1852 ops_to_visit
.push_back (op_ptr
);
1855 /* Expressions can invoke other expressions with DW_OP_call*. Protect against
1857 const int max_depth
= 256;
1859 if (depth
> max_depth
)
1860 error (_("DWARF-2 expression error: Loop detected."));
1864 /* Initialize the to-visit list with the first operation. */
1865 insert_in_ops_to_visit (&expr
[0]);
1867 while (!ops_to_visit
.empty ())
1869 /* Pop one op to visit, mark it as visited. */
1870 const gdb_byte
*op_ptr
= ops_to_visit
.back ();
1871 ops_to_visit
.pop_back ();
1872 gdb_assert (visited_ops
.find (op_ptr
) == visited_ops
.end ());
1873 visited_ops
.insert (op_ptr
);
1875 dwarf_location_atom op
= (dwarf_location_atom
) *op_ptr
;
1877 /* Most operations have a single possible following operation
1878 (they are not conditional branches). The code below updates
1879 OP_PTR to point to that following operation, which is pushed
1880 back to OPS_TO_VISIT, if needed, at the bottom. Here, leave
1881 OP_PTR pointing just after the operand. */
1884 /* The DWARF expression might have a bug causing an infinite
1885 loop. In that case, quitting is the only way out. */
1922 case DW_OP_stack_value
:
1949 case DW_OP_GNU_push_tls_address
:
1951 case DW_OP_GNU_uninit
:
1952 case DW_OP_push_object_address
:
1955 case DW_OP_form_tls_address
:
1956 if (symbol_needs
<= SYMBOL_NEEDS_REGISTERS
)
1957 symbol_needs
= SYMBOL_NEEDS_REGISTERS
;
1961 case DW_OP_GNU_convert
:
1962 case DW_OP_reinterpret
:
1963 case DW_OP_GNU_reinterpret
:
1965 case DW_OP_GNU_addr_index
:
1966 case DW_OP_GNU_const_index
:
1968 case DW_OP_plus_uconst
:
1970 op_ptr
= safe_skip_leb128 (op_ptr
, expr_end
);
1974 op_ptr
= safe_skip_leb128 (op_ptr
, expr_end
);
1977 case DW_OP_bit_piece
:
1978 op_ptr
= safe_skip_leb128 (op_ptr
, expr_end
);
1979 op_ptr
= safe_skip_leb128 (op_ptr
, expr_end
);
1982 case DW_OP_deref_type
:
1983 case DW_OP_GNU_deref_type
:
1985 op_ptr
= safe_skip_leb128 (op_ptr
, expr_end
);
1989 op_ptr
+= addr_size
;
2079 case DW_OP_call_frame_cfa
:
2080 case DW_OP_entry_value
:
2081 case DW_OP_GNU_entry_value
:
2082 case DW_OP_GNU_parameter_ref
:
2083 case DW_OP_regval_type
:
2084 case DW_OP_GNU_regval_type
:
2085 symbol_needs
= SYMBOL_NEEDS_FRAME
;
2088 case DW_OP_implicit_value
:
2091 op_ptr
= safe_read_uleb128 (op_ptr
, expr_end
, &uoffset
);
2096 case DW_OP_implicit_pointer
:
2097 case DW_OP_GNU_implicit_pointer
:
2098 op_ptr
+= ref_addr_size
;
2099 op_ptr
= safe_skip_leb128 (op_ptr
, expr_end
);
2102 case DW_OP_deref_size
:
2109 int64_t offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
2117 /* This is the only operation that pushes two operations in
2118 the to-visit list, so handle it all here. */
2119 LONGEST offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
2122 insert_in_ops_to_visit (op_ptr
+ offset
);
2123 insert_in_ops_to_visit (op_ptr
);
2130 unsigned int len
= op
== DW_OP_call2
? 2 : 4;
2132 = (cu_offset
) extract_unsigned_integer (op_ptr
, len
, byte_order
);
2135 auto get_frame_pc
= [&symbol_needs
] ()
2137 symbol_needs
= SYMBOL_NEEDS_FRAME
;
2141 struct dwarf2_locexpr_baton baton
2142 = dwarf2_fetch_die_loc_cu_off (cu_off
, per_cu
,
2146 /* If SYMBOL_NEEDS_FRAME is returned from the previous call,
2147 we dont have to check the baton content. */
2148 if (symbol_needs
!= SYMBOL_NEEDS_FRAME
)
2150 gdbarch
*arch
= baton
.per_objfile
->objfile
->arch ();
2151 gdb::array_view
<const gdb_byte
> sub_expr (baton
.data
,
2154 = dwarf2_get_symbol_read_needs (sub_expr
,
2157 gdbarch_byte_order (arch
),
2158 baton
.per_cu
->addr_size (),
2159 baton
.per_cu
->ref_addr_size (),
2165 case DW_OP_GNU_variable_value
:
2167 sect_offset sect_off
2168 = (sect_offset
) extract_unsigned_integer (op_ptr
,
2171 op_ptr
+= ref_addr_size
;
2173 struct type
*die_type
2174 = dwarf2_fetch_die_type_sect_off (sect_off
, per_cu
,
2177 if (die_type
== NULL
)
2178 error (_("Bad DW_OP_GNU_variable_value DIE."));
2180 /* Note: Things still work when the following test is
2181 removed. This test and error is here to conform to the
2182 proposed specification. */
2183 if (die_type
->code () != TYPE_CODE_INT
2184 && die_type
->code () != TYPE_CODE_PTR
)
2185 error (_("Type of DW_OP_GNU_variable_value DIE must be "
2186 "an integer or pointer."));
2188 auto get_frame_pc
= [&symbol_needs
] ()
2190 symbol_needs
= SYMBOL_NEEDS_FRAME
;
2194 struct dwarf2_locexpr_baton baton
2195 = dwarf2_fetch_die_loc_sect_off (sect_off
, per_cu
,
2197 get_frame_pc
, true);
2199 /* If SYMBOL_NEEDS_FRAME is returned from the previous call,
2200 we dont have to check the baton content. */
2201 if (symbol_needs
!= SYMBOL_NEEDS_FRAME
)
2203 gdbarch
*arch
= baton
.per_objfile
->objfile
->arch ();
2204 gdb::array_view
<const gdb_byte
> sub_expr (baton
.data
,
2207 = dwarf2_get_symbol_read_needs (sub_expr
,
2210 gdbarch_byte_order (arch
),
2211 baton
.per_cu
->addr_size (),
2212 baton
.per_cu
->ref_addr_size (),
2218 case DW_OP_const_type
:
2219 case DW_OP_GNU_const_type
:
2222 op_ptr
= safe_read_uleb128 (op_ptr
, expr_end
, &uoffset
);
2223 gdb_byte offset
= *op_ptr
++;
2229 error (_("Unhandled DWARF expression opcode 0x%x"), op
);
2232 /* If it is known that a frame information is
2233 needed we can stop parsing the expression. */
2234 if (symbol_needs
== SYMBOL_NEEDS_FRAME
)
2237 insert_in_ops_to_visit (op_ptr
);
2240 return symbol_needs
;
2243 /* A helper function that throws an unimplemented error mentioning a
2244 given DWARF operator. */
2246 static void ATTRIBUTE_NORETURN
2247 unimplemented (unsigned int op
)
2249 const char *name
= get_DW_OP_name (op
);
2252 error (_("DWARF operator %s cannot be translated to an agent expression"),
2255 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2256 "to an agent expression"),
2260 /* See dwarf2/loc.h.
2262 This is basically a wrapper on gdbarch_dwarf2_reg_to_regnum so that we
2263 can issue a complaint, which is better than having every target's
2264 implementation of dwarf2_reg_to_regnum do it. */
2267 dwarf_reg_to_regnum (struct gdbarch
*arch
, int dwarf_reg
)
2269 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2273 complaint (_("bad DWARF register number %d"), dwarf_reg
);
2278 /* Subroutine of dwarf_reg_to_regnum_or_error to simplify it.
2279 Throw an error because DWARF_REG is bad. */
2282 throw_bad_regnum_error (ULONGEST dwarf_reg
)
2284 /* Still want to print -1 as "-1".
2285 We *could* have int and ULONGEST versions of dwarf2_reg_to_regnum_or_error
2286 but that's overkill for now. */
2287 if ((int) dwarf_reg
== dwarf_reg
)
2288 error (_("Unable to access DWARF register number %d"), (int) dwarf_reg
);
2289 error (_("Unable to access DWARF register number %s"),
2290 pulongest (dwarf_reg
));
2293 /* See dwarf2/loc.h. */
2296 dwarf_reg_to_regnum_or_error (struct gdbarch
*arch
, ULONGEST dwarf_reg
)
2300 if (dwarf_reg
> INT_MAX
)
2301 throw_bad_regnum_error (dwarf_reg
);
2302 /* Yes, we will end up issuing a complaint and an error if DWARF_REG is
2303 bad, but that's ok. */
2304 reg
= dwarf_reg_to_regnum (arch
, (int) dwarf_reg
);
2306 throw_bad_regnum_error (dwarf_reg
);
2310 /* A helper function that emits an access to memory. ARCH is the
2311 target architecture. EXPR is the expression which we are building.
2312 NBITS is the number of bits we want to read. This emits the
2313 opcodes needed to read the memory and then extract the desired
2317 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2319 ULONGEST nbytes
= (nbits
+ 7) / 8;
2321 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2324 ax_trace_quick (expr
, nbytes
);
2327 ax_simple (expr
, aop_ref8
);
2328 else if (nbits
<= 16)
2329 ax_simple (expr
, aop_ref16
);
2330 else if (nbits
<= 32)
2331 ax_simple (expr
, aop_ref32
);
2333 ax_simple (expr
, aop_ref64
);
2335 /* If we read exactly the number of bytes we wanted, we're done. */
2336 if (8 * nbytes
== nbits
)
2339 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
)
2341 /* On a bits-big-endian machine, we want the high-order
2343 ax_const_l (expr
, 8 * nbytes
- nbits
);
2344 ax_simple (expr
, aop_rsh_unsigned
);
2348 /* On a bits-little-endian box, we want the low-order NBITS. */
2349 ax_zero_ext (expr
, nbits
);
2353 /* Compile a DWARF location expression to an agent expression.
2355 EXPR is the agent expression we are building.
2356 LOC is the agent value we modify.
2357 ARCH is the architecture.
2358 ADDR_SIZE is the size of addresses, in bytes.
2359 OP_PTR is the start of the location expression.
2360 OP_END is one past the last byte of the location expression.
2362 This will throw an exception for various kinds of errors -- for
2363 example, if the expression cannot be compiled, or if the expression
2367 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2368 unsigned int addr_size
, const gdb_byte
*op_ptr
,
2369 const gdb_byte
*op_end
,
2370 dwarf2_per_cu_data
*per_cu
,
2371 dwarf2_per_objfile
*per_objfile
)
2373 gdbarch
*arch
= expr
->gdbarch
;
2374 std::vector
<int> dw_labels
, patches
;
2375 const gdb_byte
* const base
= op_ptr
;
2376 const gdb_byte
*previous_piece
= op_ptr
;
2377 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2378 ULONGEST bits_collected
= 0;
2379 unsigned int addr_size_bits
= 8 * addr_size
;
2380 bool bits_big_endian
= byte_order
== BFD_ENDIAN_BIG
;
2382 std::vector
<int> offsets (op_end
- op_ptr
, -1);
2384 /* By default we are making an address. */
2385 loc
->kind
= axs_lvalue_memory
;
2387 while (op_ptr
< op_end
)
2389 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
2390 uint64_t uoffset
, reg
;
2394 offsets
[op_ptr
- base
] = expr
->len
;
2397 /* Our basic approach to code generation is to map DWARF
2398 operations directly to AX operations. However, there are
2401 First, DWARF works on address-sized units, but AX always uses
2402 LONGEST. For most operations we simply ignore this
2403 difference; instead we generate sign extensions as needed
2404 before division and comparison operations. It would be nice
2405 to omit the sign extensions, but there is no way to determine
2406 the size of the target's LONGEST. (This code uses the size
2407 of the host LONGEST in some cases -- that is a bug but it is
2410 Second, some DWARF operations cannot be translated to AX.
2411 For these we simply fail. See
2412 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2447 ax_const_l (expr
, op
- DW_OP_lit0
);
2451 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
2452 op_ptr
+= addr_size
;
2453 /* Some versions of GCC emit DW_OP_addr before
2454 DW_OP_GNU_push_tls_address. In this case the value is an
2455 index, not an address. We don't support things like
2456 branching between the address and the TLS op. */
2457 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
2458 uoffset
+= per_objfile
->objfile
->text_section_offset ();
2459 ax_const_l (expr
, uoffset
);
2463 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
2468 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
2473 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
2478 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
2483 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
2488 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
2493 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
2498 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
2503 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
2504 ax_const_l (expr
, uoffset
);
2508 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2509 ax_const_l (expr
, offset
);
2544 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2545 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_reg0
);
2546 loc
->kind
= axs_lvalue_register
;
2550 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2551 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2552 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, reg
);
2553 loc
->kind
= axs_lvalue_register
;
2556 case DW_OP_implicit_value
:
2560 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
2561 if (op_ptr
+ len
> op_end
)
2562 error (_("DW_OP_implicit_value: too few bytes available."));
2563 if (len
> sizeof (ULONGEST
))
2564 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
2567 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
2570 dwarf_expr_require_composition (op_ptr
, op_end
,
2571 "DW_OP_implicit_value");
2573 loc
->kind
= axs_rvalue
;
2577 case DW_OP_stack_value
:
2578 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
2579 loc
->kind
= axs_rvalue
;
2614 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2615 i
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_breg0
);
2619 ax_const_l (expr
, offset
);
2620 ax_simple (expr
, aop_add
);
2626 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2627 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2628 i
= dwarf_reg_to_regnum_or_error (arch
, reg
);
2632 ax_const_l (expr
, offset
);
2633 ax_simple (expr
, aop_add
);
2640 const gdb_byte
*datastart
;
2642 const struct block
*b
;
2643 struct symbol
*framefunc
;
2645 b
= block_for_pc (expr
->scope
);
2648 error (_("No block found for address"));
2650 framefunc
= block_linkage_function (b
);
2653 error (_("No function found for block"));
2655 func_get_frame_base_dwarf_block (framefunc
, expr
->scope
,
2656 &datastart
, &datalen
);
2658 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2659 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, datastart
,
2660 datastart
+ datalen
, per_cu
,
2662 if (loc
->kind
== axs_lvalue_register
)
2663 require_rvalue (expr
, loc
);
2667 ax_const_l (expr
, offset
);
2668 ax_simple (expr
, aop_add
);
2671 loc
->kind
= axs_lvalue_memory
;
2676 ax_simple (expr
, aop_dup
);
2680 ax_simple (expr
, aop_pop
);
2685 ax_pick (expr
, offset
);
2689 ax_simple (expr
, aop_swap
);
2697 ax_simple (expr
, aop_rot
);
2701 case DW_OP_deref_size
:
2705 if (op
== DW_OP_deref_size
)
2710 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
2711 error (_("Unsupported size %d in %s"),
2712 size
, get_DW_OP_name (op
));
2713 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
2718 /* Sign extend the operand. */
2719 ax_ext (expr
, addr_size_bits
);
2720 ax_simple (expr
, aop_dup
);
2721 ax_const_l (expr
, 0);
2722 ax_simple (expr
, aop_less_signed
);
2723 ax_simple (expr
, aop_log_not
);
2724 i
= ax_goto (expr
, aop_if_goto
);
2725 /* We have to emit 0 - X. */
2726 ax_const_l (expr
, 0);
2727 ax_simple (expr
, aop_swap
);
2728 ax_simple (expr
, aop_sub
);
2729 ax_label (expr
, i
, expr
->len
);
2733 /* No need to sign extend here. */
2734 ax_const_l (expr
, 0);
2735 ax_simple (expr
, aop_swap
);
2736 ax_simple (expr
, aop_sub
);
2740 /* Sign extend the operand. */
2741 ax_ext (expr
, addr_size_bits
);
2742 ax_simple (expr
, aop_bit_not
);
2745 case DW_OP_plus_uconst
:
2746 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2747 /* It would be really weird to emit `DW_OP_plus_uconst 0',
2748 but we micro-optimize anyhow. */
2751 ax_const_l (expr
, reg
);
2752 ax_simple (expr
, aop_add
);
2757 ax_simple (expr
, aop_bit_and
);
2761 /* Sign extend the operands. */
2762 ax_ext (expr
, addr_size_bits
);
2763 ax_simple (expr
, aop_swap
);
2764 ax_ext (expr
, addr_size_bits
);
2765 ax_simple (expr
, aop_swap
);
2766 ax_simple (expr
, aop_div_signed
);
2770 ax_simple (expr
, aop_sub
);
2774 ax_simple (expr
, aop_rem_unsigned
);
2778 ax_simple (expr
, aop_mul
);
2782 ax_simple (expr
, aop_bit_or
);
2786 ax_simple (expr
, aop_add
);
2790 ax_simple (expr
, aop_lsh
);
2794 ax_simple (expr
, aop_rsh_unsigned
);
2798 ax_simple (expr
, aop_rsh_signed
);
2802 ax_simple (expr
, aop_bit_xor
);
2806 /* Sign extend the operands. */
2807 ax_ext (expr
, addr_size_bits
);
2808 ax_simple (expr
, aop_swap
);
2809 ax_ext (expr
, addr_size_bits
);
2810 /* Note no swap here: A <= B is !(B < A). */
2811 ax_simple (expr
, aop_less_signed
);
2812 ax_simple (expr
, aop_log_not
);
2816 /* Sign extend the operands. */
2817 ax_ext (expr
, addr_size_bits
);
2818 ax_simple (expr
, aop_swap
);
2819 ax_ext (expr
, addr_size_bits
);
2820 ax_simple (expr
, aop_swap
);
2821 /* A >= B is !(A < B). */
2822 ax_simple (expr
, aop_less_signed
);
2823 ax_simple (expr
, aop_log_not
);
2827 /* Sign extend the operands. */
2828 ax_ext (expr
, addr_size_bits
);
2829 ax_simple (expr
, aop_swap
);
2830 ax_ext (expr
, addr_size_bits
);
2831 /* No need for a second swap here. */
2832 ax_simple (expr
, aop_equal
);
2836 /* Sign extend the operands. */
2837 ax_ext (expr
, addr_size_bits
);
2838 ax_simple (expr
, aop_swap
);
2839 ax_ext (expr
, addr_size_bits
);
2840 ax_simple (expr
, aop_swap
);
2841 ax_simple (expr
, aop_less_signed
);
2845 /* Sign extend the operands. */
2846 ax_ext (expr
, addr_size_bits
);
2847 ax_simple (expr
, aop_swap
);
2848 ax_ext (expr
, addr_size_bits
);
2849 /* Note no swap here: A > B is B < A. */
2850 ax_simple (expr
, aop_less_signed
);
2854 /* Sign extend the operands. */
2855 ax_ext (expr
, addr_size_bits
);
2856 ax_simple (expr
, aop_swap
);
2857 ax_ext (expr
, addr_size_bits
);
2858 /* No need for a swap here. */
2859 ax_simple (expr
, aop_equal
);
2860 ax_simple (expr
, aop_log_not
);
2863 case DW_OP_call_frame_cfa
:
2866 CORE_ADDR text_offset
;
2868 const gdb_byte
*cfa_start
, *cfa_end
;
2870 if (dwarf2_fetch_cfa_info (arch
, expr
->scope
, per_cu
,
2872 &text_offset
, &cfa_start
, &cfa_end
))
2875 ax_reg (expr
, regnum
);
2878 ax_const_l (expr
, off
);
2879 ax_simple (expr
, aop_add
);
2884 /* Another expression. */
2885 ax_const_l (expr
, text_offset
);
2886 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, cfa_start
,
2887 cfa_end
, per_cu
, per_objfile
);
2890 loc
->kind
= axs_lvalue_memory
;
2894 case DW_OP_GNU_push_tls_address
:
2895 case DW_OP_form_tls_address
:
2899 case DW_OP_push_object_address
:
2904 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
2906 i
= ax_goto (expr
, aop_goto
);
2907 dw_labels
.push_back (op_ptr
+ offset
- base
);
2908 patches
.push_back (i
);
2912 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
2914 /* Zero extend the operand. */
2915 ax_zero_ext (expr
, addr_size_bits
);
2916 i
= ax_goto (expr
, aop_if_goto
);
2917 dw_labels
.push_back (op_ptr
+ offset
- base
);
2918 patches
.push_back (i
);
2925 case DW_OP_bit_piece
:
2929 if (op_ptr
- 1 == previous_piece
)
2930 error (_("Cannot translate empty pieces to agent expressions"));
2931 previous_piece
= op_ptr
- 1;
2933 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
2934 if (op
== DW_OP_piece
)
2940 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
2942 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
2943 error (_("Expression pieces exceed word size"));
2945 /* Access the bits. */
2948 case axs_lvalue_register
:
2949 ax_reg (expr
, loc
->u
.reg
);
2952 case axs_lvalue_memory
:
2953 /* Offset the pointer, if needed. */
2956 ax_const_l (expr
, uoffset
/ 8);
2957 ax_simple (expr
, aop_add
);
2960 access_memory (arch
, expr
, size
);
2964 /* For a bits-big-endian target, shift up what we already
2965 have. For a bits-little-endian target, shift up the
2966 new data. Note that there is a potential bug here if
2967 the DWARF expression leaves multiple values on the
2969 if (bits_collected
> 0)
2971 if (bits_big_endian
)
2973 ax_simple (expr
, aop_swap
);
2974 ax_const_l (expr
, size
);
2975 ax_simple (expr
, aop_lsh
);
2976 /* We don't need a second swap here, because
2977 aop_bit_or is symmetric. */
2981 ax_const_l (expr
, size
);
2982 ax_simple (expr
, aop_lsh
);
2984 ax_simple (expr
, aop_bit_or
);
2987 bits_collected
+= size
;
2988 loc
->kind
= axs_rvalue
;
2992 case DW_OP_GNU_uninit
:
2998 struct dwarf2_locexpr_baton block
;
2999 int size
= (op
== DW_OP_call2
? 2 : 4);
3001 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3004 auto get_frame_pc_from_expr
= [expr
] ()
3008 cu_offset cuoffset
= (cu_offset
) uoffset
;
3009 block
= dwarf2_fetch_die_loc_cu_off (cuoffset
, per_cu
, per_objfile
,
3010 get_frame_pc_from_expr
);
3012 /* DW_OP_call_ref is currently not supported. */
3013 gdb_assert (block
.per_cu
== per_cu
);
3015 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, block
.data
,
3016 block
.data
+ block
.size
, per_cu
,
3021 case DW_OP_call_ref
:
3024 case DW_OP_GNU_variable_value
:
3032 /* Patch all the branches we emitted. */
3033 for (int i
= 0; i
< patches
.size (); ++i
)
3035 int targ
= offsets
[dw_labels
[i
]];
3037 internal_error (_("invalid label"));
3038 ax_label (expr
, patches
[i
], targ
);
3043 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3044 evaluator to calculate the location. */
3045 static struct value
*
3046 locexpr_read_variable (struct symbol
*symbol
, frame_info_ptr frame
)
3048 struct dwarf2_locexpr_baton
*dlbaton
3049 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3052 val
= dwarf2_evaluate_loc_desc (symbol
->type (), frame
, dlbaton
->data
,
3053 dlbaton
->size
, dlbaton
->per_cu
,
3054 dlbaton
->per_objfile
);
3059 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3060 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3063 static struct value
*
3064 locexpr_read_variable_at_entry (struct symbol
*symbol
, frame_info_ptr frame
)
3066 struct dwarf2_locexpr_baton
*dlbaton
3067 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3069 return value_of_dwarf_block_entry (symbol
->type (), frame
, dlbaton
->data
,
3073 /* Implementation of get_symbol_read_needs from
3074 symbol_computed_ops. */
3076 static enum symbol_needs_kind
3077 locexpr_get_symbol_read_needs (struct symbol
*symbol
)
3079 struct dwarf2_locexpr_baton
*dlbaton
3080 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3082 gdbarch
*arch
= dlbaton
->per_objfile
->objfile
->arch ();
3083 gdb::array_view
<const gdb_byte
> expr (dlbaton
->data
, dlbaton
->size
);
3085 return dwarf2_get_symbol_read_needs (expr
,
3087 dlbaton
->per_objfile
,
3088 gdbarch_byte_order (arch
),
3089 dlbaton
->per_cu
->addr_size (),
3090 dlbaton
->per_cu
->ref_addr_size ());
3093 /* Return true if DATA points to the end of a piece. END is one past
3094 the last byte in the expression. */
3097 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3099 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3102 /* Helper for locexpr_describe_location_piece that finds the name of a
3106 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3110 /* This doesn't use dwarf_reg_to_regnum_or_error on purpose.
3111 We'd rather print *something* here than throw an error. */
3112 regnum
= dwarf_reg_to_regnum (gdbarch
, dwarf_regnum
);
3113 /* gdbarch_register_name may just return "", return something more
3114 descriptive for bad register numbers. */
3117 /* The text is output as "$bad_register_number".
3118 That is why we use the underscores. */
3119 return _("bad_register_number");
3121 return gdbarch_register_name (gdbarch
, regnum
);
3124 /* Nicely describe a single piece of a location, returning an updated
3125 position in the bytecode sequence. This function cannot recognize
3126 all locations; if a location is not recognized, it simply returns
3127 DATA. If there is an error during reading, e.g. we run off the end
3128 of the buffer, an error is thrown. */
3130 static const gdb_byte
*
3131 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3132 CORE_ADDR addr
, dwarf2_per_cu_data
*per_cu
,
3133 dwarf2_per_objfile
*per_objfile
,
3134 const gdb_byte
*data
, const gdb_byte
*end
,
3135 unsigned int addr_size
)
3137 objfile
*objfile
= per_objfile
->objfile
;
3138 struct gdbarch
*gdbarch
= objfile
->arch ();
3141 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3143 gdb_printf (stream
, _("a variable in $%s"),
3144 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3147 else if (data
[0] == DW_OP_regx
)
3151 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3152 gdb_printf (stream
, _("a variable in $%s"),
3153 locexpr_regname (gdbarch
, reg
));
3155 else if (data
[0] == DW_OP_fbreg
)
3157 const struct block
*b
;
3158 struct symbol
*framefunc
;
3160 int64_t frame_offset
;
3161 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3163 int64_t base_offset
= 0;
3165 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3166 if (!piece_end_p (new_data
, end
))
3170 b
= block_for_pc (addr
);
3173 error (_("No block found for address for symbol \"%s\"."),
3174 symbol
->print_name ());
3176 framefunc
= block_linkage_function (b
);
3179 error (_("No function found for block for symbol \"%s\"."),
3180 symbol
->print_name ());
3182 func_get_frame_base_dwarf_block (framefunc
, addr
, &base_data
, &base_size
);
3184 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3186 const gdb_byte
*buf_end
;
3188 frame_reg
= base_data
[0] - DW_OP_breg0
;
3189 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3191 if (buf_end
!= base_data
+ base_size
)
3192 error (_("Unexpected opcode after "
3193 "DW_OP_breg%u for symbol \"%s\"."),
3194 frame_reg
, symbol
->print_name ());
3196 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3198 /* The frame base is just the register, with no offset. */
3199 frame_reg
= base_data
[0] - DW_OP_reg0
;
3204 /* We don't know what to do with the frame base expression,
3205 so we can't trace this variable; give up. */
3210 _("a variable at frame base reg $%s offset %s+%s"),
3211 locexpr_regname (gdbarch
, frame_reg
),
3212 plongest (base_offset
), plongest (frame_offset
));
3214 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3215 && piece_end_p (data
, end
))
3219 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3222 _("a variable at offset %s from base reg $%s"),
3224 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3227 /* The location expression for a TLS variable looks like this (on a
3230 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3231 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3233 0x3 is the encoding for DW_OP_addr, which has an operand as long
3234 as the size of an address on the target machine (here is 8
3235 bytes). Note that more recent version of GCC emit DW_OP_const4u
3236 or DW_OP_const8u, depending on address size, rather than
3237 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3238 The operand represents the offset at which the variable is within
3239 the thread local storage. */
3241 else if (data
+ 1 + addr_size
< end
3242 && (data
[0] == DW_OP_addr
3243 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3244 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3245 && (data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3246 || data
[1 + addr_size
] == DW_OP_form_tls_address
)
3247 && piece_end_p (data
+ 2 + addr_size
, end
))
3250 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3251 gdbarch_byte_order (gdbarch
));
3254 _("a thread-local variable at offset 0x%s "
3255 "in the thread-local storage for `%s'"),
3256 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3258 data
+= 1 + addr_size
+ 1;
3261 /* With -gsplit-dwarf a TLS variable can also look like this:
3262 DW_AT_location : 3 byte block: fc 4 e0
3263 (DW_OP_GNU_const_index: 4;
3264 DW_OP_GNU_push_tls_address) */
3265 else if (data
+ 3 <= end
3266 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3267 && data
[0] == DW_OP_GNU_const_index
3269 && (data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3270 || data
[1 + leb128_size
] == DW_OP_form_tls_address
)
3271 && piece_end_p (data
+ 2 + leb128_size
, end
))
3275 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3276 offset
= dwarf2_read_addr_index (per_cu
, per_objfile
, offset
);
3278 _("a thread-local variable at offset 0x%s "
3279 "in the thread-local storage for `%s'"),
3280 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3284 else if (data
[0] >= DW_OP_lit0
3285 && data
[0] <= DW_OP_lit31
3287 && data
[1] == DW_OP_stack_value
)
3289 gdb_printf (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3296 /* Disassemble an expression, stopping at the end of a piece or at the
3297 end of the expression. Returns a pointer to the next unread byte
3298 in the input expression. If ALL is nonzero, then this function
3299 will keep going until it reaches the end of the expression.
3300 If there is an error during reading, e.g. we run off the end
3301 of the buffer, an error is thrown. */
3303 static const gdb_byte
*
3304 disassemble_dwarf_expression (struct ui_file
*stream
,
3305 struct gdbarch
*arch
, unsigned int addr_size
,
3306 int offset_size
, const gdb_byte
*start
,
3307 const gdb_byte
*data
, const gdb_byte
*end
,
3308 int indent
, int all
,
3309 dwarf2_per_cu_data
*per_cu
,
3310 dwarf2_per_objfile
*per_objfile
)
3314 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3316 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *data
++;
3321 name
= get_DW_OP_name (op
);
3324 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3325 op
, (long) (data
- 1 - start
));
3326 gdb_printf (stream
, " %*ld: %s", indent
+ 4,
3327 (long) (data
- 1 - start
), name
);
3332 ul
= extract_unsigned_integer (data
, addr_size
,
3333 gdbarch_byte_order (arch
));
3335 gdb_printf (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3339 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3341 gdb_printf (stream
, " %s", pulongest (ul
));
3345 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3347 gdb_printf (stream
, " %s", plongest (l
));
3351 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3353 gdb_printf (stream
, " %s", pulongest (ul
));
3357 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3359 gdb_printf (stream
, " %s", plongest (l
));
3363 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3365 gdb_printf (stream
, " %s", pulongest (ul
));
3369 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3371 gdb_printf (stream
, " %s", plongest (l
));
3375 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3377 gdb_printf (stream
, " %s", pulongest (ul
));
3381 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3383 gdb_printf (stream
, " %s", plongest (l
));
3387 data
= safe_read_uleb128 (data
, end
, &ul
);
3388 gdb_printf (stream
, " %s", pulongest (ul
));
3392 data
= safe_read_sleb128 (data
, end
, &l
);
3393 gdb_printf (stream
, " %s", plongest (l
));
3428 gdb_printf (stream
, " [$%s]",
3429 locexpr_regname (arch
, op
- DW_OP_reg0
));
3433 data
= safe_read_uleb128 (data
, end
, &ul
);
3434 gdb_printf (stream
, " %s [$%s]", pulongest (ul
),
3435 locexpr_regname (arch
, (int) ul
));
3438 case DW_OP_implicit_value
:
3439 data
= safe_read_uleb128 (data
, end
, &ul
);
3441 gdb_printf (stream
, " %s", pulongest (ul
));
3476 data
= safe_read_sleb128 (data
, end
, &l
);
3477 gdb_printf (stream
, " %s [$%s]", plongest (l
),
3478 locexpr_regname (arch
, op
- DW_OP_breg0
));
3482 data
= safe_read_uleb128 (data
, end
, &ul
);
3483 data
= safe_read_sleb128 (data
, end
, &l
);
3484 gdb_printf (stream
, " register %s [$%s] offset %s",
3486 locexpr_regname (arch
, (int) ul
),
3491 data
= safe_read_sleb128 (data
, end
, &l
);
3492 gdb_printf (stream
, " %s", plongest (l
));
3495 case DW_OP_xderef_size
:
3496 case DW_OP_deref_size
:
3498 gdb_printf (stream
, " %d", *data
);
3502 case DW_OP_plus_uconst
:
3503 data
= safe_read_uleb128 (data
, end
, &ul
);
3504 gdb_printf (stream
, " %s", pulongest (ul
));
3508 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3510 gdb_printf (stream
, " to %ld",
3511 (long) (data
+ l
- start
));
3515 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3517 gdb_printf (stream
, " %ld",
3518 (long) (data
+ l
- start
));
3522 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3524 gdb_printf (stream
, " offset %s", phex_nz (ul
, 2));
3528 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3530 gdb_printf (stream
, " offset %s", phex_nz (ul
, 4));
3533 case DW_OP_call_ref
:
3534 ul
= extract_unsigned_integer (data
, offset_size
,
3535 gdbarch_byte_order (arch
));
3536 data
+= offset_size
;
3537 gdb_printf (stream
, " offset %s", phex_nz (ul
, offset_size
));
3541 data
= safe_read_uleb128 (data
, end
, &ul
);
3542 gdb_printf (stream
, " %s (bytes)", pulongest (ul
));
3545 case DW_OP_bit_piece
:
3549 data
= safe_read_uleb128 (data
, end
, &ul
);
3550 data
= safe_read_uleb128 (data
, end
, &offset
);
3551 gdb_printf (stream
, " size %s offset %s (bits)",
3552 pulongest (ul
), pulongest (offset
));
3556 case DW_OP_implicit_pointer
:
3557 case DW_OP_GNU_implicit_pointer
:
3559 ul
= extract_unsigned_integer (data
, offset_size
,
3560 gdbarch_byte_order (arch
));
3561 data
+= offset_size
;
3563 data
= safe_read_sleb128 (data
, end
, &l
);
3565 gdb_printf (stream
, " DIE %s offset %s",
3566 phex_nz (ul
, offset_size
),
3571 case DW_OP_deref_type
:
3572 case DW_OP_GNU_deref_type
:
3574 int deref_addr_size
= *data
++;
3577 data
= safe_read_uleb128 (data
, end
, &ul
);
3578 cu_offset offset
= (cu_offset
) ul
;
3579 type
= dwarf2_get_die_type (offset
, per_cu
, per_objfile
);
3580 gdb_printf (stream
, "<");
3581 type_print (type
, "", stream
, -1);
3582 gdb_printf (stream
, " [0x%s]> %d",
3583 phex_nz (to_underlying (offset
), 0),
3588 case DW_OP_const_type
:
3589 case DW_OP_GNU_const_type
:
3593 data
= safe_read_uleb128 (data
, end
, &ul
);
3594 cu_offset type_die
= (cu_offset
) ul
;
3595 type
= dwarf2_get_die_type (type_die
, per_cu
, per_objfile
);
3596 gdb_printf (stream
, "<");
3597 type_print (type
, "", stream
, -1);
3598 gdb_printf (stream
, " [0x%s]>",
3599 phex_nz (to_underlying (type_die
), 0));
3602 gdb_printf (stream
, " %d byte block:", n
);
3603 for (int i
= 0; i
< n
; ++i
)
3604 gdb_printf (stream
, " %02x", data
[i
]);
3609 case DW_OP_regval_type
:
3610 case DW_OP_GNU_regval_type
:
3615 data
= safe_read_uleb128 (data
, end
, ®
);
3616 data
= safe_read_uleb128 (data
, end
, &ul
);
3617 cu_offset type_die
= (cu_offset
) ul
;
3619 type
= dwarf2_get_die_type (type_die
, per_cu
, per_objfile
);
3620 gdb_printf (stream
, "<");
3621 type_print (type
, "", stream
, -1);
3622 gdb_printf (stream
, " [0x%s]> [$%s]",
3623 phex_nz (to_underlying (type_die
), 0),
3624 locexpr_regname (arch
, reg
));
3629 case DW_OP_GNU_convert
:
3630 case DW_OP_reinterpret
:
3631 case DW_OP_GNU_reinterpret
:
3633 data
= safe_read_uleb128 (data
, end
, &ul
);
3634 cu_offset type_die
= (cu_offset
) ul
;
3636 if (to_underlying (type_die
) == 0)
3637 gdb_printf (stream
, "<0>");
3642 type
= dwarf2_get_die_type (type_die
, per_cu
, per_objfile
);
3643 gdb_printf (stream
, "<");
3644 type_print (type
, "", stream
, -1);
3645 gdb_printf (stream
, " [0x%s]>",
3646 phex_nz (to_underlying (type_die
), 0));
3651 case DW_OP_entry_value
:
3652 case DW_OP_GNU_entry_value
:
3653 data
= safe_read_uleb128 (data
, end
, &ul
);
3654 gdb_putc ('\n', stream
);
3655 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
3656 start
, data
, data
+ ul
, indent
+ 2,
3657 all
, per_cu
, per_objfile
);
3661 case DW_OP_GNU_parameter_ref
:
3662 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3664 gdb_printf (stream
, " offset %s", phex_nz (ul
, 4));
3668 case DW_OP_GNU_addr_index
:
3669 data
= safe_read_uleb128 (data
, end
, &ul
);
3670 ul
= dwarf2_read_addr_index (per_cu
, per_objfile
, ul
);
3671 gdb_printf (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3674 case DW_OP_GNU_const_index
:
3675 data
= safe_read_uleb128 (data
, end
, &ul
);
3676 ul
= dwarf2_read_addr_index (per_cu
, per_objfile
, ul
);
3677 gdb_printf (stream
, " %s", pulongest (ul
));
3680 case DW_OP_GNU_variable_value
:
3681 ul
= extract_unsigned_integer (data
, offset_size
,
3682 gdbarch_byte_order (arch
));
3683 data
+= offset_size
;
3684 gdb_printf (stream
, " offset %s", phex_nz (ul
, offset_size
));
3688 gdb_printf (stream
, "\n");
3694 static bool dwarf_always_disassemble
;
3697 show_dwarf_always_disassemble (struct ui_file
*file
, int from_tty
,
3698 struct cmd_list_element
*c
, const char *value
)
3701 _("Whether to always disassemble "
3702 "DWARF expressions is %s.\n"),
3706 /* Describe a single location, which may in turn consist of multiple
3710 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
3711 struct ui_file
*stream
,
3712 const gdb_byte
*data
, size_t size
,
3713 unsigned int addr_size
,
3714 int offset_size
, dwarf2_per_cu_data
*per_cu
,
3715 dwarf2_per_objfile
*per_objfile
)
3717 const gdb_byte
*end
= data
+ size
;
3718 int first_piece
= 1, bad
= 0;
3719 objfile
*objfile
= per_objfile
->objfile
;
3723 const gdb_byte
*here
= data
;
3724 int disassemble
= 1;
3729 gdb_printf (stream
, _(", and "));
3731 if (!dwarf_always_disassemble
)
3733 data
= locexpr_describe_location_piece (symbol
, stream
,
3734 addr
, per_cu
, per_objfile
,
3735 data
, end
, addr_size
);
3736 /* If we printed anything, or if we have an empty piece,
3737 then don't disassemble. */
3739 || data
[0] == DW_OP_piece
3740 || data
[0] == DW_OP_bit_piece
)
3745 gdb_printf (stream
, _("a complex DWARF expression:\n"));
3746 data
= disassemble_dwarf_expression (stream
,
3748 addr_size
, offset_size
, data
,
3750 dwarf_always_disassemble
,
3751 per_cu
, per_objfile
);
3756 int empty
= data
== here
;
3759 gdb_printf (stream
, " ");
3760 if (data
[0] == DW_OP_piece
)
3764 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
3767 gdb_printf (stream
, _("an empty %s-byte piece"),
3770 gdb_printf (stream
, _(" [%s-byte piece]"),
3773 else if (data
[0] == DW_OP_bit_piece
)
3775 uint64_t bits
, offset
;
3777 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
3778 data
= safe_read_uleb128 (data
, end
, &offset
);
3782 _("an empty %s-bit piece"),
3786 _(" [%s-bit piece, offset %s bits]"),
3787 pulongest (bits
), pulongest (offset
));
3797 if (bad
|| data
> end
)
3798 error (_("Corrupted DWARF2 expression for \"%s\"."),
3799 symbol
->print_name ());
3802 /* Print a natural-language description of SYMBOL to STREAM. This
3803 version is for a symbol with a single location. */
3806 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
3807 struct ui_file
*stream
)
3809 struct dwarf2_locexpr_baton
*dlbaton
3810 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3811 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
3812 int offset_size
= dlbaton
->per_cu
->offset_size ();
3814 locexpr_describe_location_1 (symbol
, addr
, stream
,
3815 dlbaton
->data
, dlbaton
->size
,
3816 addr_size
, offset_size
,
3817 dlbaton
->per_cu
, dlbaton
->per_objfile
);
3820 /* Describe the location of SYMBOL as an agent value in VALUE, generating
3821 any necessary bytecode in AX. */
3824 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
3825 struct axs_value
*value
)
3827 struct dwarf2_locexpr_baton
*dlbaton
3828 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3829 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
3831 if (dlbaton
->size
== 0)
3832 value
->optimized_out
= 1;
3834 dwarf2_compile_expr_to_ax (ax
, value
, addr_size
, dlbaton
->data
,
3835 dlbaton
->data
+ dlbaton
->size
, dlbaton
->per_cu
,
3836 dlbaton
->per_objfile
);
3839 /* symbol_computed_ops 'generate_c_location' method. */
3842 locexpr_generate_c_location (struct symbol
*sym
, string_file
*stream
,
3843 struct gdbarch
*gdbarch
,
3844 std::vector
<bool> ®isters_used
,
3845 CORE_ADDR pc
, const char *result_name
)
3847 struct dwarf2_locexpr_baton
*dlbaton
3848 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (sym
);
3849 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
3851 if (dlbaton
->size
== 0)
3852 error (_("symbol \"%s\" is optimized out"), sym
->natural_name ());
3854 compile_dwarf_expr_to_c (stream
, result_name
,
3855 sym
, pc
, gdbarch
, registers_used
, addr_size
,
3856 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
3857 dlbaton
->per_cu
, dlbaton
->per_objfile
);
3860 /* The set of location functions used with the DWARF-2 expression
3862 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
3863 locexpr_read_variable
,
3864 locexpr_read_variable_at_entry
,
3865 locexpr_get_symbol_read_needs
,
3866 locexpr_describe_location
,
3867 0, /* location_has_loclist */
3868 locexpr_tracepoint_var_ref
,
3869 locexpr_generate_c_location
3873 /* Wrapper functions for location lists. These generally find
3874 the appropriate location expression and call something above. */
3876 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3877 evaluator to calculate the location. */
3878 static struct value
*
3879 loclist_read_variable (struct symbol
*symbol
, frame_info_ptr frame
)
3881 struct dwarf2_loclist_baton
*dlbaton
3882 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3884 const gdb_byte
*data
;
3886 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
3888 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
3889 val
= dwarf2_evaluate_loc_desc (symbol
->type (), frame
, data
, size
,
3890 dlbaton
->per_cu
, dlbaton
->per_objfile
);
3895 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
3896 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3899 Function always returns non-NULL value, it may be marked optimized out if
3900 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
3901 if it cannot resolve the parameter for any reason. */
3903 static struct value
*
3904 loclist_read_variable_at_entry (struct symbol
*symbol
, frame_info_ptr frame
)
3906 struct dwarf2_loclist_baton
*dlbaton
3907 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3908 const gdb_byte
*data
;
3912 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
3913 return allocate_optimized_out_value (symbol
->type ());
3915 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
3917 return allocate_optimized_out_value (symbol
->type ());
3919 return value_of_dwarf_block_entry (symbol
->type (), frame
, data
, size
);
3922 /* Implementation of get_symbol_read_needs from
3923 symbol_computed_ops. */
3925 static enum symbol_needs_kind
3926 loclist_symbol_needs (struct symbol
*symbol
)
3928 /* If there's a location list, then assume we need to have a frame
3929 to choose the appropriate location expression. With tracking of
3930 global variables this is not necessarily true, but such tracking
3931 is disabled in GCC at the moment until we figure out how to
3934 return SYMBOL_NEEDS_FRAME
;
3937 /* Print a natural-language description of SYMBOL to STREAM. This
3938 version applies when there is a list of different locations, each
3939 with a specified address range. */
3942 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
3943 struct ui_file
*stream
)
3945 struct dwarf2_loclist_baton
*dlbaton
3946 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3947 const gdb_byte
*loc_ptr
, *buf_end
;
3948 dwarf2_per_objfile
*per_objfile
= dlbaton
->per_objfile
;
3949 struct objfile
*objfile
= per_objfile
->objfile
;
3950 struct gdbarch
*gdbarch
= objfile
->arch ();
3951 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3952 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
3953 int offset_size
= dlbaton
->per_cu
->offset_size ();
3954 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
.get ());
3955 /* Adjustment for relocatable objects. */
3956 CORE_ADDR text_offset
= objfile
->text_section_offset ();
3957 CORE_ADDR base_address
= dlbaton
->base_address
;
3960 loc_ptr
= dlbaton
->data
;
3961 buf_end
= dlbaton
->data
+ dlbaton
->size
;
3963 gdb_printf (stream
, _("multi-location:\n"));
3965 /* Iterate through locations until we run out. */
3968 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
3970 enum debug_loc_kind kind
;
3971 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
3973 if (dlbaton
->per_cu
->version () < 5 && dlbaton
->from_dwo
)
3974 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
3975 dlbaton
->per_objfile
,
3976 loc_ptr
, buf_end
, &new_ptr
,
3977 &low
, &high
, byte_order
);
3978 else if (dlbaton
->per_cu
->version () < 5)
3979 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
3981 byte_order
, addr_size
,
3984 kind
= decode_debug_loclists_addresses (dlbaton
->per_cu
,
3985 dlbaton
->per_objfile
,
3986 loc_ptr
, buf_end
, &new_ptr
,
3987 &low
, &high
, byte_order
,
3988 addr_size
, signed_addr_p
);
3992 case DEBUG_LOC_END_OF_LIST
:
3996 case DEBUG_LOC_BASE_ADDRESS
:
3997 base_address
= high
;
3998 gdb_printf (stream
, _(" Base address %s"),
3999 paddress (gdbarch
, base_address
));
4002 case DEBUG_LOC_START_END
:
4003 case DEBUG_LOC_START_LENGTH
:
4004 case DEBUG_LOC_OFFSET_PAIR
:
4007 case DEBUG_LOC_BUFFER_OVERFLOW
:
4008 case DEBUG_LOC_INVALID_ENTRY
:
4009 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4010 symbol
->print_name ());
4013 gdb_assert_not_reached ("bad debug_loc_kind");
4016 /* Otherwise, a location expression entry. */
4018 high
+= text_offset
;
4019 if (!dlbaton
->from_dwo
&& kind
== DEBUG_LOC_OFFSET_PAIR
)
4021 low
+= base_address
;
4022 high
+= base_address
;
4025 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
);
4026 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
);
4028 if (dlbaton
->per_cu
->version () < 5)
4030 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4035 unsigned int bytes_read
;
4036 length
= read_unsigned_leb128 (NULL
, loc_ptr
, &bytes_read
);
4037 loc_ptr
+= bytes_read
;
4040 /* (It would improve readability to print only the minimum
4041 necessary digits of the second number of the range.) */
4042 gdb_printf (stream
, _(" Range %s-%s: "),
4043 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4045 /* Now describe this particular location. */
4046 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4047 addr_size
, offset_size
,
4048 dlbaton
->per_cu
, dlbaton
->per_objfile
);
4050 gdb_printf (stream
, "\n");
4056 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4057 any necessary bytecode in AX. */
4059 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
4060 struct axs_value
*value
)
4062 struct dwarf2_loclist_baton
*dlbaton
4063 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4064 const gdb_byte
*data
;
4066 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4068 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4070 value
->optimized_out
= 1;
4072 dwarf2_compile_expr_to_ax (ax
, value
, addr_size
, data
, data
+ size
,
4073 dlbaton
->per_cu
, dlbaton
->per_objfile
);
4076 /* symbol_computed_ops 'generate_c_location' method. */
4079 loclist_generate_c_location (struct symbol
*sym
, string_file
*stream
,
4080 struct gdbarch
*gdbarch
,
4081 std::vector
<bool> ®isters_used
,
4082 CORE_ADDR pc
, const char *result_name
)
4084 struct dwarf2_loclist_baton
*dlbaton
4085 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (sym
);
4086 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4087 const gdb_byte
*data
;
4090 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4092 error (_("symbol \"%s\" is optimized out"), sym
->natural_name ());
4094 compile_dwarf_expr_to_c (stream
, result_name
,
4095 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4098 dlbaton
->per_objfile
);
4101 /* The set of location functions used with the DWARF-2 expression
4102 evaluator and location lists. */
4103 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4104 loclist_read_variable
,
4105 loclist_read_variable_at_entry
,
4106 loclist_symbol_needs
,
4107 loclist_describe_location
,
4108 1, /* location_has_loclist */
4109 loclist_tracepoint_var_ref
,
4110 loclist_generate_c_location
4113 void _initialize_dwarf2loc ();
4115 _initialize_dwarf2loc ()
4117 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4118 &entry_values_debug
,
4119 _("Set entry values and tail call frames "
4121 _("Show entry values and tail call frames "
4123 _("When non-zero, the process of determining "
4124 "parameter values from function entry point "
4125 "and tail call frames will be printed."),
4127 show_entry_values_debug
,
4128 &setdebuglist
, &showdebuglist
);
4130 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
4131 &dwarf_always_disassemble
, _("\
4132 Set whether `info address' always disassembles DWARF expressions."), _("\
4133 Show whether `info address' always disassembles DWARF expressions."), _("\
4134 When enabled, DWARF expressions are always printed in an assembly-like\n\
4135 syntax. When disabled, expressions will be printed in a more\n\
4136 conversational style, when possible."),
4138 show_dwarf_always_disassemble
,
4140 &show_dwarf_cmdlist
);