1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003-2020 Free Software Foundation, Inc.
5 Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
35 #include "complaints.h"
37 #include "dwarf2/expr.h"
38 #include "dwarf2/loc.h"
39 #include "dwarf2/read.h"
40 #include "dwarf2/frame.h"
41 #include "dwarf2/leb.h"
42 #include "compile/compile.h"
43 #include "gdbsupport/selftest.h"
46 #include <unordered_set>
47 #include "gdbsupport/underlying.h"
48 #include "gdbsupport/byte-vector.h"
50 static struct value
*dwarf2_evaluate_loc_desc_full (struct type
*type
,
51 struct frame_info
*frame
,
54 struct dwarf2_per_cu_data
*per_cu
,
55 struct type
*subobj_type
,
56 LONGEST subobj_byte_offset
);
58 static struct call_site_parameter
*dwarf_expr_reg_to_entry_parameter
59 (struct frame_info
*frame
,
60 enum call_site_parameter_kind kind
,
61 union call_site_parameter_u kind_u
,
62 struct dwarf2_per_cu_data
**per_cu_return
);
64 static struct value
*indirect_synthetic_pointer
65 (sect_offset die
, LONGEST byte_offset
,
66 struct dwarf2_per_cu_data
*per_cu
,
67 struct frame_info
*frame
,
68 struct type
*type
, bool resolve_abstract_p
= false);
70 /* Until these have formal names, we define these here.
71 ref: http://gcc.gnu.org/wiki/DebugFission
72 Each entry in .debug_loc.dwo begins with a byte that describes the entry,
73 and is then followed by data specific to that entry. */
77 /* Indicates the end of the list of entries. */
78 DEBUG_LOC_END_OF_LIST
= 0,
80 /* This is followed by an unsigned LEB128 number that is an index into
81 .debug_addr and specifies the base address for all following entries. */
82 DEBUG_LOC_BASE_ADDRESS
= 1,
84 /* This is followed by two unsigned LEB128 numbers that are indices into
85 .debug_addr and specify the beginning and ending addresses, and then
86 a normal location expression as in .debug_loc. */
87 DEBUG_LOC_START_END
= 2,
89 /* This is followed by an unsigned LEB128 number that is an index into
90 .debug_addr and specifies the beginning address, and a 4 byte unsigned
91 number that specifies the length, and then a normal location expression
93 DEBUG_LOC_START_LENGTH
= 3,
95 /* This is followed by two unsigned LEB128 operands. The values of these
96 operands are the starting and ending offsets, respectively, relative to
97 the applicable base address. */
98 DEBUG_LOC_OFFSET_PAIR
= 4,
100 /* An internal value indicating there is insufficient data. */
101 DEBUG_LOC_BUFFER_OVERFLOW
= -1,
103 /* An internal value indicating an invalid kind of entry was found. */
104 DEBUG_LOC_INVALID_ENTRY
= -2
107 /* Helper function which throws an error if a synthetic pointer is
111 invalid_synthetic_pointer (void)
113 error (_("access outside bounds of object "
114 "referenced via synthetic pointer"));
117 /* Decode the addresses in a non-dwo .debug_loc entry.
118 A pointer to the next byte to examine is returned in *NEW_PTR.
119 The encoded low,high addresses are return in *LOW,*HIGH.
120 The result indicates the kind of entry found. */
122 static enum debug_loc_kind
123 decode_debug_loc_addresses (const gdb_byte
*loc_ptr
, const gdb_byte
*buf_end
,
124 const gdb_byte
**new_ptr
,
125 CORE_ADDR
*low
, CORE_ADDR
*high
,
126 enum bfd_endian byte_order
,
127 unsigned int addr_size
,
130 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
132 if (buf_end
- loc_ptr
< 2 * addr_size
)
133 return DEBUG_LOC_BUFFER_OVERFLOW
;
136 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
138 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
139 loc_ptr
+= addr_size
;
142 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
144 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
145 loc_ptr
+= addr_size
;
149 /* A base-address-selection entry. */
150 if ((*low
& base_mask
) == base_mask
)
151 return DEBUG_LOC_BASE_ADDRESS
;
153 /* An end-of-list entry. */
154 if (*low
== 0 && *high
== 0)
155 return DEBUG_LOC_END_OF_LIST
;
157 return DEBUG_LOC_START_END
;
160 /* Decode the addresses in .debug_loclists entry.
161 A pointer to the next byte to examine is returned in *NEW_PTR.
162 The encoded low,high addresses are return in *LOW,*HIGH.
163 The result indicates the kind of entry found. */
165 static enum debug_loc_kind
166 decode_debug_loclists_addresses (dwarf2_per_cu_data
*per_cu
,
167 dwarf2_per_objfile
*per_objfile
,
168 const gdb_byte
*loc_ptr
,
169 const gdb_byte
*buf_end
,
170 const gdb_byte
**new_ptr
,
171 CORE_ADDR
*low
, CORE_ADDR
*high
,
172 enum bfd_endian byte_order
,
173 unsigned int addr_size
,
178 if (loc_ptr
== buf_end
)
179 return DEBUG_LOC_BUFFER_OVERFLOW
;
183 case DW_LLE_base_addressx
:
185 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
187 return DEBUG_LOC_BUFFER_OVERFLOW
;
188 *high
= dwarf2_read_addr_index (per_cu
, per_objfile
, u64
);
190 return DEBUG_LOC_BASE_ADDRESS
;
191 case DW_LLE_startx_length
:
192 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
194 return DEBUG_LOC_BUFFER_OVERFLOW
;
195 *low
= dwarf2_read_addr_index (per_cu
, per_objfile
, u64
);
197 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
199 return DEBUG_LOC_BUFFER_OVERFLOW
;
202 return DEBUG_LOC_START_LENGTH
;
203 case DW_LLE_start_length
:
204 if (buf_end
- loc_ptr
< addr_size
)
205 return DEBUG_LOC_BUFFER_OVERFLOW
;
207 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
209 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
210 loc_ptr
+= addr_size
;
212 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
214 return DEBUG_LOC_BUFFER_OVERFLOW
;
217 return DEBUG_LOC_START_LENGTH
;
218 case DW_LLE_end_of_list
:
220 return DEBUG_LOC_END_OF_LIST
;
221 case DW_LLE_base_address
:
222 if (loc_ptr
+ addr_size
> buf_end
)
223 return DEBUG_LOC_BUFFER_OVERFLOW
;
225 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
227 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
228 loc_ptr
+= addr_size
;
230 return DEBUG_LOC_BASE_ADDRESS
;
231 case DW_LLE_offset_pair
:
232 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
234 return DEBUG_LOC_BUFFER_OVERFLOW
;
236 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
238 return DEBUG_LOC_BUFFER_OVERFLOW
;
241 return DEBUG_LOC_OFFSET_PAIR
;
242 /* Following cases are not supported yet. */
243 case DW_LLE_startx_endx
:
244 case DW_LLE_start_end
:
245 case DW_LLE_default_location
:
247 return DEBUG_LOC_INVALID_ENTRY
;
251 /* Decode the addresses in .debug_loc.dwo entry.
252 A pointer to the next byte to examine is returned in *NEW_PTR.
253 The encoded low,high addresses are return in *LOW,*HIGH.
254 The result indicates the kind of entry found. */
256 static enum debug_loc_kind
257 decode_debug_loc_dwo_addresses (dwarf2_per_cu_data
*per_cu
,
258 dwarf2_per_objfile
*per_objfile
,
259 const gdb_byte
*loc_ptr
,
260 const gdb_byte
*buf_end
,
261 const gdb_byte
**new_ptr
,
262 CORE_ADDR
*low
, CORE_ADDR
*high
,
263 enum bfd_endian byte_order
)
265 uint64_t low_index
, high_index
;
267 if (loc_ptr
== buf_end
)
268 return DEBUG_LOC_BUFFER_OVERFLOW
;
272 case DW_LLE_GNU_end_of_list_entry
:
274 return DEBUG_LOC_END_OF_LIST
;
275 case DW_LLE_GNU_base_address_selection_entry
:
277 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
279 return DEBUG_LOC_BUFFER_OVERFLOW
;
280 *high
= dwarf2_read_addr_index (per_cu
, per_objfile
, high_index
);
282 return DEBUG_LOC_BASE_ADDRESS
;
283 case DW_LLE_GNU_start_end_entry
:
284 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
286 return DEBUG_LOC_BUFFER_OVERFLOW
;
287 *low
= dwarf2_read_addr_index (per_cu
, per_objfile
, low_index
);
288 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
290 return DEBUG_LOC_BUFFER_OVERFLOW
;
291 *high
= dwarf2_read_addr_index (per_cu
, per_objfile
, high_index
);
293 return DEBUG_LOC_START_END
;
294 case DW_LLE_GNU_start_length_entry
:
295 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
297 return DEBUG_LOC_BUFFER_OVERFLOW
;
298 *low
= dwarf2_read_addr_index (per_cu
, per_objfile
, low_index
);
299 if (loc_ptr
+ 4 > buf_end
)
300 return DEBUG_LOC_BUFFER_OVERFLOW
;
302 *high
+= extract_unsigned_integer (loc_ptr
, 4, byte_order
);
303 *new_ptr
= loc_ptr
+ 4;
304 return DEBUG_LOC_START_LENGTH
;
306 return DEBUG_LOC_INVALID_ENTRY
;
310 /* A function for dealing with location lists. Given a
311 symbol baton (BATON) and a pc value (PC), find the appropriate
312 location expression, set *LOCEXPR_LENGTH, and return a pointer
313 to the beginning of the expression. Returns NULL on failure.
315 For now, only return the first matching location expression; there
316 can be more than one in the list. */
319 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
320 size_t *locexpr_length
, CORE_ADDR pc
)
322 dwarf2_per_objfile
*per_objfile
= baton
->per_objfile
;
323 struct objfile
*objfile
= per_objfile
->objfile
;
324 struct gdbarch
*gdbarch
= objfile
->arch ();
325 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
326 unsigned int addr_size
= baton
->per_cu
->addr_size ();
327 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
328 /* Adjust base_address for relocatable objects. */
329 CORE_ADDR base_offset
= baton
->per_objfile
->objfile
->text_section_offset ();
330 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
331 const gdb_byte
*loc_ptr
, *buf_end
;
333 loc_ptr
= baton
->data
;
334 buf_end
= baton
->data
+ baton
->size
;
338 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
340 enum debug_loc_kind kind
;
341 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
343 if (baton
->per_cu
->version () < 5 && baton
->from_dwo
)
344 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
346 loc_ptr
, buf_end
, &new_ptr
,
347 &low
, &high
, byte_order
);
348 else if (baton
->per_cu
->version () < 5)
349 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
351 byte_order
, addr_size
,
354 kind
= decode_debug_loclists_addresses (baton
->per_cu
,
356 loc_ptr
, buf_end
, &new_ptr
,
357 &low
, &high
, byte_order
,
358 addr_size
, signed_addr_p
);
363 case DEBUG_LOC_END_OF_LIST
:
366 case DEBUG_LOC_BASE_ADDRESS
:
367 base_address
= high
+ base_offset
;
369 case DEBUG_LOC_START_END
:
370 case DEBUG_LOC_START_LENGTH
:
371 case DEBUG_LOC_OFFSET_PAIR
:
373 case DEBUG_LOC_BUFFER_OVERFLOW
:
374 case DEBUG_LOC_INVALID_ENTRY
:
375 error (_("dwarf2_find_location_expression: "
376 "Corrupted DWARF expression."));
378 gdb_assert_not_reached ("bad debug_loc_kind");
381 /* Otherwise, a location expression entry.
382 If the entry is from a DWO, don't add base address: the entry is from
383 .debug_addr which already has the DWARF "base address". We still add
384 base_offset in case we're debugging a PIE executable. However, if the
385 entry is DW_LLE_offset_pair from a DWO, add the base address as the
386 operands are offsets relative to the applicable base address. */
387 if (baton
->from_dwo
&& kind
!= DEBUG_LOC_OFFSET_PAIR
)
395 high
+= base_address
;
398 if (baton
->per_cu
->version () < 5)
400 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
405 unsigned int bytes_read
;
407 length
= read_unsigned_leb128 (NULL
, loc_ptr
, &bytes_read
);
408 loc_ptr
+= bytes_read
;
411 if (low
== high
&& pc
== low
)
413 /* This is entry PC record present only at entry point
414 of a function. Verify it is really the function entry point. */
416 const struct block
*pc_block
= block_for_pc (pc
);
417 struct symbol
*pc_func
= NULL
;
420 pc_func
= block_linkage_function (pc_block
);
422 if (pc_func
&& pc
== BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (pc_func
)))
424 *locexpr_length
= length
;
429 if (pc
>= low
&& pc
< high
)
431 *locexpr_length
= length
;
439 /* Implement find_frame_base_location method for LOC_BLOCK functions using
440 DWARF expression for its DW_AT_frame_base. */
443 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
444 const gdb_byte
**start
, size_t *length
)
446 struct dwarf2_locexpr_baton
*symbaton
447 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
449 *length
= symbaton
->size
;
450 *start
= symbaton
->data
;
453 /* Implement the struct symbol_block_ops::get_frame_base method for
454 LOC_BLOCK functions using a DWARF expression as its DW_AT_frame_base. */
457 locexpr_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
459 struct gdbarch
*gdbarch
;
461 struct dwarf2_locexpr_baton
*dlbaton
;
462 const gdb_byte
*start
;
464 struct value
*result
;
466 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
467 Thus, it's supposed to provide the find_frame_base_location method as
469 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
471 gdbarch
= get_frame_arch (frame
);
472 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
473 dlbaton
= (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
475 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
476 (framefunc
, get_frame_pc (frame
), &start
, &length
);
477 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
480 /* The DW_AT_frame_base attribute contains a location description which
481 computes the base address itself. However, the call to
482 dwarf2_evaluate_loc_desc returns a value representing a variable at
483 that address. The frame base address is thus this variable's
485 return value_address (result
);
488 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
489 function uses DWARF expression for its DW_AT_frame_base. */
491 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
493 locexpr_find_frame_base_location
,
494 locexpr_get_frame_base
497 /* Implement find_frame_base_location method for LOC_BLOCK functions using
498 DWARF location list for its DW_AT_frame_base. */
501 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
502 const gdb_byte
**start
, size_t *length
)
504 struct dwarf2_loclist_baton
*symbaton
505 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
507 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
510 /* Implement the struct symbol_block_ops::get_frame_base method for
511 LOC_BLOCK functions using a DWARF location list as its DW_AT_frame_base. */
514 loclist_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
516 struct gdbarch
*gdbarch
;
518 struct dwarf2_loclist_baton
*dlbaton
;
519 const gdb_byte
*start
;
521 struct value
*result
;
523 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
524 Thus, it's supposed to provide the find_frame_base_location method as
526 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
528 gdbarch
= get_frame_arch (frame
);
529 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
530 dlbaton
= (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
532 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
533 (framefunc
, get_frame_pc (frame
), &start
, &length
);
534 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
537 /* The DW_AT_frame_base attribute contains a location description which
538 computes the base address itself. However, the call to
539 dwarf2_evaluate_loc_desc returns a value representing a variable at
540 that address. The frame base address is thus this variable's
542 return value_address (result
);
545 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
546 function uses DWARF location list for its DW_AT_frame_base. */
548 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
550 loclist_find_frame_base_location
,
551 loclist_get_frame_base
554 /* See dwarf2loc.h. */
557 func_get_frame_base_dwarf_block (struct symbol
*framefunc
, CORE_ADDR pc
,
558 const gdb_byte
**start
, size_t *length
)
560 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
562 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
564 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
570 error (_("Could not find the frame base for \"%s\"."),
571 framefunc
->natural_name ());
575 get_frame_pc_for_per_cu_dwarf_call (void *baton
)
577 dwarf_expr_context
*ctx
= (dwarf_expr_context
*) baton
;
579 return ctx
->get_frame_pc ();
583 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
584 struct dwarf2_per_cu_data
*per_cu
)
586 struct dwarf2_locexpr_baton block
;
588 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
,
589 get_frame_pc_for_per_cu_dwarf_call
,
592 /* DW_OP_call_ref is currently not supported. */
593 gdb_assert (block
.per_cu
== per_cu
);
595 ctx
->eval (block
.data
, block
.size
);
598 /* Given context CTX, section offset SECT_OFF, and compilation unit
599 data PER_CU, execute the "variable value" operation on the DIE
600 found at SECT_OFF. */
602 static struct value
*
603 sect_variable_value (struct dwarf_expr_context
*ctx
, sect_offset sect_off
,
604 struct dwarf2_per_cu_data
*per_cu
)
606 struct type
*die_type
= dwarf2_fetch_die_type_sect_off (sect_off
, per_cu
);
608 if (die_type
== NULL
)
609 error (_("Bad DW_OP_GNU_variable_value DIE."));
611 /* Note: Things still work when the following test is removed. This
612 test and error is here to conform to the proposed specification. */
613 if (die_type
->code () != TYPE_CODE_INT
614 && die_type
->code () != TYPE_CODE_PTR
)
615 error (_("Type of DW_OP_GNU_variable_value DIE must be an integer or pointer."));
617 struct type
*type
= lookup_pointer_type (die_type
);
618 struct frame_info
*frame
= get_selected_frame (_("No frame selected."));
619 return indirect_synthetic_pointer (sect_off
, 0, per_cu
, frame
, type
, true);
622 class dwarf_evaluate_loc_desc
: public dwarf_expr_context
625 dwarf_evaluate_loc_desc (dwarf2_per_objfile
*per_objfile
)
626 : dwarf_expr_context (per_objfile
)
629 struct frame_info
*frame
;
630 struct dwarf2_per_cu_data
*per_cu
;
631 CORE_ADDR obj_address
;
633 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
634 the frame in BATON. */
636 CORE_ADDR
get_frame_cfa () override
638 return dwarf2_frame_cfa (frame
);
641 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
642 the frame in BATON. */
644 CORE_ADDR
get_frame_pc () override
646 return get_frame_address_in_block (frame
);
649 /* Using the objfile specified in BATON, find the address for the
650 current thread's thread-local storage with offset OFFSET. */
651 CORE_ADDR
get_tls_address (CORE_ADDR offset
) override
653 struct objfile
*objfile
= per_cu
->objfile ();
655 return target_translate_tls_address (objfile
, offset
);
658 /* Helper interface of per_cu_dwarf_call for
659 dwarf2_evaluate_loc_desc. */
661 void dwarf_call (cu_offset die_offset
) override
663 per_cu_dwarf_call (this, die_offset
, per_cu
);
666 /* Helper interface of sect_variable_value for
667 dwarf2_evaluate_loc_desc. */
669 struct value
*dwarf_variable_value (sect_offset sect_off
) override
671 return sect_variable_value (this, sect_off
, per_cu
);
674 struct type
*get_base_type (cu_offset die_offset
, int size
) override
676 struct type
*result
= dwarf2_get_die_type (die_offset
, per_cu
);
678 error (_("Could not find type for DW_OP_const_type"));
679 if (size
!= 0 && TYPE_LENGTH (result
) != size
)
680 error (_("DW_OP_const_type has different sizes for type and data"));
684 /* Callback function for dwarf2_evaluate_loc_desc.
685 Fetch the address indexed by DW_OP_addrx or DW_OP_GNU_addr_index. */
687 CORE_ADDR
get_addr_index (unsigned int index
) override
689 return dwarf2_read_addr_index (per_cu
, per_objfile
, index
);
692 /* Callback function for get_object_address. Return the address of the VLA
695 CORE_ADDR
get_object_address () override
697 if (obj_address
== 0)
698 error (_("Location address is not set."));
702 /* Execute DWARF block of call_site_parameter which matches KIND and
703 KIND_U. Choose DEREF_SIZE value of that parameter. Search
704 caller of this objects's frame.
706 The caller can be from a different CU - per_cu_dwarf_call
707 implementation can be more simple as it does not support cross-CU
710 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
711 union call_site_parameter_u kind_u
,
712 int deref_size
) override
714 struct frame_info
*caller_frame
;
715 struct dwarf2_per_cu_data
*caller_per_cu
;
716 struct call_site_parameter
*parameter
;
717 const gdb_byte
*data_src
;
720 caller_frame
= get_prev_frame (frame
);
722 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
724 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
725 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
727 /* DEREF_SIZE size is not verified here. */
728 if (data_src
== NULL
)
729 throw_error (NO_ENTRY_VALUE_ERROR
,
730 _("Cannot resolve DW_AT_call_data_value"));
732 scoped_restore save_frame
= make_scoped_restore (&this->frame
,
734 scoped_restore save_per_cu
= make_scoped_restore (&this->per_cu
,
736 scoped_restore save_obj_addr
= make_scoped_restore (&this->obj_address
,
739 scoped_restore save_arch
= make_scoped_restore (&this->gdbarch
);
740 this->gdbarch
= per_cu
->objfile ()->arch ();
741 scoped_restore save_addr_size
= make_scoped_restore (&this->addr_size
);
742 this->addr_size
= per_cu
->addr_size ();
744 this->eval (data_src
, size
);
747 /* Using the frame specified in BATON, find the location expression
748 describing the frame base. Return a pointer to it in START and
749 its length in LENGTH. */
750 void get_frame_base (const gdb_byte
**start
, size_t * length
) override
752 /* FIXME: cagney/2003-03-26: This code should be using
753 get_frame_base_address(), and then implement a dwarf2 specific
755 struct symbol
*framefunc
;
756 const struct block
*bl
= get_frame_block (frame
, NULL
);
759 error (_("frame address is not available."));
761 /* Use block_linkage_function, which returns a real (not inlined)
762 function, instead of get_frame_function, which may return an
764 framefunc
= block_linkage_function (bl
);
766 /* If we found a frame-relative symbol then it was certainly within
767 some function associated with a frame. If we can't find the frame,
768 something has gone wrong. */
769 gdb_assert (framefunc
!= NULL
);
771 func_get_frame_base_dwarf_block (framefunc
,
772 get_frame_address_in_block (frame
),
776 /* Read memory at ADDR (length LEN) into BUF. */
778 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
780 read_memory (addr
, buf
, len
);
783 /* Using the frame specified in BATON, return the value of register
784 REGNUM, treated as a pointer. */
785 CORE_ADDR
read_addr_from_reg (int dwarf_regnum
) override
787 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
788 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
790 return address_from_register (regnum
, frame
);
793 /* Implement "get_reg_value" callback. */
795 struct value
*get_reg_value (struct type
*type
, int dwarf_regnum
) override
797 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
798 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
800 return value_from_register (type
, regnum
, frame
);
804 /* See dwarf2loc.h. */
806 unsigned int entry_values_debug
= 0;
808 /* Helper to set entry_values_debug. */
811 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
812 struct cmd_list_element
*c
, const char *value
)
814 fprintf_filtered (file
,
815 _("Entry values and tail call frames debugging is %s.\n"),
819 /* Find DW_TAG_call_site's DW_AT_call_target address.
820 CALLER_FRAME (for registers) can be NULL if it is not known. This function
821 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
824 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
825 struct call_site
*call_site
,
826 struct frame_info
*caller_frame
)
828 switch (FIELD_LOC_KIND (call_site
->target
))
830 case FIELD_LOC_KIND_DWARF_BLOCK
:
832 struct dwarf2_locexpr_baton
*dwarf_block
;
834 struct type
*caller_core_addr_type
;
835 struct gdbarch
*caller_arch
;
837 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
838 if (dwarf_block
== NULL
)
840 struct bound_minimal_symbol msym
;
842 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
843 throw_error (NO_ENTRY_VALUE_ERROR
,
844 _("DW_AT_call_target is not specified at %s in %s"),
845 paddress (call_site_gdbarch
, call_site
->pc
),
846 (msym
.minsym
== NULL
? "???"
847 : msym
.minsym
->print_name ()));
850 if (caller_frame
== NULL
)
852 struct bound_minimal_symbol msym
;
854 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
855 throw_error (NO_ENTRY_VALUE_ERROR
,
856 _("DW_AT_call_target DWARF block resolving "
857 "requires known frame which is currently not "
858 "available at %s in %s"),
859 paddress (call_site_gdbarch
, call_site
->pc
),
860 (msym
.minsym
== NULL
? "???"
861 : msym
.minsym
->print_name ()));
864 caller_arch
= get_frame_arch (caller_frame
);
865 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
866 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
867 dwarf_block
->data
, dwarf_block
->size
,
868 dwarf_block
->per_cu
);
869 /* DW_AT_call_target is a DWARF expression, not a DWARF location. */
870 if (VALUE_LVAL (val
) == lval_memory
)
871 return value_address (val
);
873 return value_as_address (val
);
876 case FIELD_LOC_KIND_PHYSNAME
:
878 const char *physname
;
879 struct bound_minimal_symbol msym
;
881 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
883 /* Handle both the mangled and demangled PHYSNAME. */
884 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
885 if (msym
.minsym
== NULL
)
887 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
888 throw_error (NO_ENTRY_VALUE_ERROR
,
889 _("Cannot find function \"%s\" for a call site target "
891 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
892 (msym
.minsym
== NULL
? "???"
893 : msym
.minsym
->print_name ()));
896 return BMSYMBOL_VALUE_ADDRESS (msym
);
899 case FIELD_LOC_KIND_PHYSADDR
:
900 return FIELD_STATIC_PHYSADDR (call_site
->target
);
903 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
907 /* Convert function entry point exact address ADDR to the function which is
908 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
909 NO_ENTRY_VALUE_ERROR otherwise. */
911 static struct symbol
*
912 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
914 struct symbol
*sym
= find_pc_function (addr
);
917 if (sym
== NULL
|| BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
918 throw_error (NO_ENTRY_VALUE_ERROR
,
919 _("DW_TAG_call_site resolving failed to find function "
920 "name for address %s"),
921 paddress (gdbarch
, addr
));
923 type
= SYMBOL_TYPE (sym
);
924 gdb_assert (type
->code () == TYPE_CODE_FUNC
);
925 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
930 /* Verify function with entry point exact address ADDR can never call itself
931 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
932 can call itself via tail calls.
934 If a funtion can tail call itself its entry value based parameters are
935 unreliable. There is no verification whether the value of some/all
936 parameters is unchanged through the self tail call, we expect if there is
937 a self tail call all the parameters can be modified. */
940 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
944 /* The verification is completely unordered. Track here function addresses
945 which still need to be iterated. */
946 std::vector
<CORE_ADDR
> todo
;
948 /* Track here CORE_ADDRs which were already visited. */
949 std::unordered_set
<CORE_ADDR
> addr_hash
;
951 todo
.push_back (verify_addr
);
952 while (!todo
.empty ())
954 struct symbol
*func_sym
;
955 struct call_site
*call_site
;
960 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
962 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
963 call_site
; call_site
= call_site
->tail_call_next
)
965 CORE_ADDR target_addr
;
967 /* CALLER_FRAME with registers is not available for tail-call jumped
969 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
971 if (target_addr
== verify_addr
)
973 struct bound_minimal_symbol msym
;
975 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
976 throw_error (NO_ENTRY_VALUE_ERROR
,
977 _("DW_OP_entry_value resolving has found "
978 "function \"%s\" at %s can call itself via tail "
980 (msym
.minsym
== NULL
? "???"
981 : msym
.minsym
->print_name ()),
982 paddress (gdbarch
, verify_addr
));
985 if (addr_hash
.insert (target_addr
).second
)
986 todo
.push_back (target_addr
);
991 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
992 ENTRY_VALUES_DEBUG. */
995 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
997 CORE_ADDR addr
= call_site
->pc
;
998 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
1000 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
1001 (msym
.minsym
== NULL
? "???"
1002 : msym
.minsym
->print_name ()));
1006 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
1007 only top callers and bottom callees which are present in both. GDBARCH is
1008 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
1009 no remaining possibilities to provide unambiguous non-trivial result.
1010 RESULTP should point to NULL on the first (initialization) call. Caller is
1011 responsible for xfree of any RESULTP data. */
1014 chain_candidate (struct gdbarch
*gdbarch
,
1015 gdb::unique_xmalloc_ptr
<struct call_site_chain
> *resultp
,
1016 std::vector
<struct call_site
*> *chain
)
1018 long length
= chain
->size ();
1019 int callers
, callees
, idx
;
1021 if (*resultp
== NULL
)
1023 /* Create the initial chain containing all the passed PCs. */
1025 struct call_site_chain
*result
1026 = ((struct call_site_chain
*)
1027 xmalloc (sizeof (*result
)
1028 + sizeof (*result
->call_site
) * (length
- 1)));
1029 result
->length
= length
;
1030 result
->callers
= result
->callees
= length
;
1031 if (!chain
->empty ())
1032 memcpy (result
->call_site
, chain
->data (),
1033 sizeof (*result
->call_site
) * length
);
1034 resultp
->reset (result
);
1036 if (entry_values_debug
)
1038 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
1039 for (idx
= 0; idx
< length
; idx
++)
1040 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
1041 fputc_unfiltered ('\n', gdb_stdlog
);
1047 if (entry_values_debug
)
1049 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
1050 for (idx
= 0; idx
< length
; idx
++)
1051 tailcall_dump (gdbarch
, chain
->at (idx
));
1052 fputc_unfiltered ('\n', gdb_stdlog
);
1055 /* Intersect callers. */
1057 callers
= std::min ((long) (*resultp
)->callers
, length
);
1058 for (idx
= 0; idx
< callers
; idx
++)
1059 if ((*resultp
)->call_site
[idx
] != chain
->at (idx
))
1061 (*resultp
)->callers
= idx
;
1065 /* Intersect callees. */
1067 callees
= std::min ((long) (*resultp
)->callees
, length
);
1068 for (idx
= 0; idx
< callees
; idx
++)
1069 if ((*resultp
)->call_site
[(*resultp
)->length
- 1 - idx
]
1070 != chain
->at (length
- 1 - idx
))
1072 (*resultp
)->callees
= idx
;
1076 if (entry_values_debug
)
1078 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
1079 for (idx
= 0; idx
< (*resultp
)->callers
; idx
++)
1080 tailcall_dump (gdbarch
, (*resultp
)->call_site
[idx
]);
1081 fputs_unfiltered (" |", gdb_stdlog
);
1082 for (idx
= 0; idx
< (*resultp
)->callees
; idx
++)
1083 tailcall_dump (gdbarch
,
1084 (*resultp
)->call_site
[(*resultp
)->length
1085 - (*resultp
)->callees
+ idx
]);
1086 fputc_unfiltered ('\n', gdb_stdlog
);
1089 if ((*resultp
)->callers
== 0 && (*resultp
)->callees
== 0)
1091 /* There are no common callers or callees. It could be also a direct
1092 call (which has length 0) with ambiguous possibility of an indirect
1093 call - CALLERS == CALLEES == 0 is valid during the first allocation
1094 but any subsequence processing of such entry means ambiguity. */
1095 resultp
->reset (NULL
);
1099 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
1100 PC again. In such case there must be two different code paths to reach
1101 it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
1102 gdb_assert ((*resultp
)->callers
+ (*resultp
)->callees
<= (*resultp
)->length
);
1105 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1106 assumed frames between them use GDBARCH. Use depth first search so we can
1107 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
1108 would have needless GDB stack overhead. Any unreliability results
1109 in thrown NO_ENTRY_VALUE_ERROR. */
1111 static gdb::unique_xmalloc_ptr
<call_site_chain
>
1112 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1113 CORE_ADDR callee_pc
)
1115 CORE_ADDR save_callee_pc
= callee_pc
;
1116 gdb::unique_xmalloc_ptr
<struct call_site_chain
> retval
;
1117 struct call_site
*call_site
;
1119 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
1120 call_site nor any possible call_site at CALLEE_PC's function is there.
1121 Any CALL_SITE in CHAIN will be iterated to its siblings - via
1122 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
1123 std::vector
<struct call_site
*> chain
;
1125 /* We are not interested in the specific PC inside the callee function. */
1126 callee_pc
= get_pc_function_start (callee_pc
);
1128 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
1129 paddress (gdbarch
, save_callee_pc
));
1131 /* Mark CALL_SITEs so we do not visit the same ones twice. */
1132 std::unordered_set
<CORE_ADDR
> addr_hash
;
1134 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
1135 at the target's function. All the possible tail call sites in the
1136 target's function will get iterated as already pushed into CHAIN via their
1138 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1142 CORE_ADDR target_func_addr
;
1143 struct call_site
*target_call_site
;
1145 /* CALLER_FRAME with registers is not available for tail-call jumped
1147 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
1149 if (target_func_addr
== callee_pc
)
1151 chain_candidate (gdbarch
, &retval
, &chain
);
1155 /* There is no way to reach CALLEE_PC again as we would prevent
1156 entering it twice as being already marked in ADDR_HASH. */
1157 target_call_site
= NULL
;
1161 struct symbol
*target_func
;
1163 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
1164 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
1169 /* Attempt to visit TARGET_CALL_SITE. */
1171 if (target_call_site
)
1173 if (addr_hash
.insert (target_call_site
->pc
).second
)
1175 /* Successfully entered TARGET_CALL_SITE. */
1177 chain
.push_back (target_call_site
);
1182 /* Backtrack (without revisiting the originating call_site). Try the
1183 callers's sibling; if there isn't any try the callers's callers's
1186 target_call_site
= NULL
;
1187 while (!chain
.empty ())
1189 call_site
= chain
.back ();
1192 size_t removed
= addr_hash
.erase (call_site
->pc
);
1193 gdb_assert (removed
== 1);
1195 target_call_site
= call_site
->tail_call_next
;
1196 if (target_call_site
)
1200 while (target_call_site
);
1205 call_site
= chain
.back ();
1210 struct bound_minimal_symbol msym_caller
, msym_callee
;
1212 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
1213 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
1214 throw_error (NO_ENTRY_VALUE_ERROR
,
1215 _("There are no unambiguously determinable intermediate "
1216 "callers or callees between caller function \"%s\" at %s "
1217 "and callee function \"%s\" at %s"),
1218 (msym_caller
.minsym
== NULL
1219 ? "???" : msym_caller
.minsym
->print_name ()),
1220 paddress (gdbarch
, caller_pc
),
1221 (msym_callee
.minsym
== NULL
1222 ? "???" : msym_callee
.minsym
->print_name ()),
1223 paddress (gdbarch
, callee_pc
));
1229 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1230 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
1231 constructed return NULL. */
1233 gdb::unique_xmalloc_ptr
<call_site_chain
>
1234 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1235 CORE_ADDR callee_pc
)
1237 gdb::unique_xmalloc_ptr
<call_site_chain
> retval
;
1241 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
1243 catch (const gdb_exception_error
&e
)
1245 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
1247 if (entry_values_debug
)
1248 exception_print (gdb_stdout
, e
);
1259 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1262 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1263 enum call_site_parameter_kind kind
,
1264 union call_site_parameter_u kind_u
)
1266 if (kind
== parameter
->kind
)
1269 case CALL_SITE_PARAMETER_DWARF_REG
:
1270 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1271 case CALL_SITE_PARAMETER_FB_OFFSET
:
1272 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1273 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1274 return kind_u
.param_cu_off
== parameter
->u
.param_cu_off
;
1279 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1280 FRAME is for callee.
1282 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1285 static struct call_site_parameter
*
1286 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1287 enum call_site_parameter_kind kind
,
1288 union call_site_parameter_u kind_u
,
1289 struct dwarf2_per_cu_data
**per_cu_return
)
1291 CORE_ADDR func_addr
, caller_pc
;
1292 struct gdbarch
*gdbarch
;
1293 struct frame_info
*caller_frame
;
1294 struct call_site
*call_site
;
1296 /* Initialize it just to avoid a GCC false warning. */
1297 struct call_site_parameter
*parameter
= NULL
;
1298 CORE_ADDR target_addr
;
1300 while (get_frame_type (frame
) == INLINE_FRAME
)
1302 frame
= get_prev_frame (frame
);
1303 gdb_assert (frame
!= NULL
);
1306 func_addr
= get_frame_func (frame
);
1307 gdbarch
= get_frame_arch (frame
);
1308 caller_frame
= get_prev_frame (frame
);
1309 if (gdbarch
!= frame_unwind_arch (frame
))
1311 struct bound_minimal_symbol msym
1312 = lookup_minimal_symbol_by_pc (func_addr
);
1313 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1315 throw_error (NO_ENTRY_VALUE_ERROR
,
1316 _("DW_OP_entry_value resolving callee gdbarch %s "
1317 "(of %s (%s)) does not match caller gdbarch %s"),
1318 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1319 paddress (gdbarch
, func_addr
),
1320 (msym
.minsym
== NULL
? "???"
1321 : msym
.minsym
->print_name ()),
1322 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1325 if (caller_frame
== NULL
)
1327 struct bound_minimal_symbol msym
1328 = lookup_minimal_symbol_by_pc (func_addr
);
1330 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_entry_value resolving "
1331 "requires caller of %s (%s)"),
1332 paddress (gdbarch
, func_addr
),
1333 (msym
.minsym
== NULL
? "???"
1334 : msym
.minsym
->print_name ()));
1336 caller_pc
= get_frame_pc (caller_frame
);
1337 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1339 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1340 if (target_addr
!= func_addr
)
1342 struct minimal_symbol
*target_msym
, *func_msym
;
1344 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1345 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1346 throw_error (NO_ENTRY_VALUE_ERROR
,
1347 _("DW_OP_entry_value resolving expects callee %s at %s "
1348 "but the called frame is for %s at %s"),
1349 (target_msym
== NULL
? "???"
1350 : target_msym
->print_name ()),
1351 paddress (gdbarch
, target_addr
),
1352 func_msym
== NULL
? "???" : func_msym
->print_name (),
1353 paddress (gdbarch
, func_addr
));
1356 /* No entry value based parameters would be reliable if this function can
1357 call itself via tail calls. */
1358 func_verify_no_selftailcall (gdbarch
, func_addr
);
1360 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1362 parameter
= &call_site
->parameter
[iparams
];
1363 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1366 if (iparams
== call_site
->parameter_count
)
1368 struct minimal_symbol
*msym
1369 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1371 /* DW_TAG_call_site_parameter will be missing just if GCC could not
1372 determine its value. */
1373 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1374 "at DW_TAG_call_site %s at %s"),
1375 paddress (gdbarch
, caller_pc
),
1376 msym
== NULL
? "???" : msym
->print_name ());
1379 *per_cu_return
= call_site
->per_cu
;
1383 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1384 the normal DW_AT_call_value block. Otherwise return the
1385 DW_AT_call_data_value (dereferenced) block.
1387 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1390 Function always returns non-NULL, non-optimized out value. It throws
1391 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1393 static struct value
*
1394 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1395 CORE_ADDR deref_size
, struct type
*type
,
1396 struct frame_info
*caller_frame
,
1397 struct dwarf2_per_cu_data
*per_cu
)
1399 const gdb_byte
*data_src
;
1403 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1404 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1406 /* DEREF_SIZE size is not verified here. */
1407 if (data_src
== NULL
)
1408 throw_error (NO_ENTRY_VALUE_ERROR
,
1409 _("Cannot resolve DW_AT_call_data_value"));
1411 /* DW_AT_call_value is a DWARF expression, not a DWARF
1412 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1414 data
= (gdb_byte
*) alloca (size
+ 1);
1415 memcpy (data
, data_src
, size
);
1416 data
[size
] = DW_OP_stack_value
;
1418 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1421 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1422 the indirect method on it, that is use its stored target value, the sole
1423 purpose of entry_data_value_funcs.. */
1425 static struct value
*
1426 entry_data_value_coerce_ref (const struct value
*value
)
1428 struct type
*checked_type
= check_typedef (value_type (value
));
1429 struct value
*target_val
;
1431 if (!TYPE_IS_REFERENCE (checked_type
))
1434 target_val
= (struct value
*) value_computed_closure (value
);
1435 value_incref (target_val
);
1439 /* Implement copy_closure. */
1442 entry_data_value_copy_closure (const struct value
*v
)
1444 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1446 value_incref (target_val
);
1450 /* Implement free_closure. */
1453 entry_data_value_free_closure (struct value
*v
)
1455 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1457 value_decref (target_val
);
1460 /* Vector for methods for an entry value reference where the referenced value
1461 is stored in the caller. On the first dereference use
1462 DW_AT_call_data_value in the caller. */
1464 static const struct lval_funcs entry_data_value_funcs
=
1468 NULL
, /* indirect */
1469 entry_data_value_coerce_ref
,
1470 NULL
, /* check_synthetic_pointer */
1471 entry_data_value_copy_closure
,
1472 entry_data_value_free_closure
1475 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1476 are used to match DW_AT_location at the caller's
1477 DW_TAG_call_site_parameter.
1479 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1480 cannot resolve the parameter for any reason. */
1482 static struct value
*
1483 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1484 enum call_site_parameter_kind kind
,
1485 union call_site_parameter_u kind_u
)
1487 struct type
*checked_type
= check_typedef (type
);
1488 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1489 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1490 struct value
*outer_val
, *target_val
, *val
;
1491 struct call_site_parameter
*parameter
;
1492 struct dwarf2_per_cu_data
*caller_per_cu
;
1494 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1497 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1501 /* Check if DW_AT_call_data_value cannot be used. If it should be
1502 used and it is not available do not fall back to OUTER_VAL - dereferencing
1503 TYPE_CODE_REF with non-entry data value would give current value - not the
1506 if (!TYPE_IS_REFERENCE (checked_type
)
1507 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1510 target_val
= dwarf_entry_parameter_to_value (parameter
,
1511 TYPE_LENGTH (target_type
),
1512 target_type
, caller_frame
,
1515 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1516 release_value (target_val
).release ());
1518 /* Copy the referencing pointer to the new computed value. */
1519 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1520 TYPE_LENGTH (checked_type
));
1521 set_value_lazy (val
, 0);
1526 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1527 SIZE are DWARF block used to match DW_AT_location at the caller's
1528 DW_TAG_call_site_parameter.
1530 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1531 cannot resolve the parameter for any reason. */
1533 static struct value
*
1534 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1535 const gdb_byte
*block
, size_t block_len
)
1537 union call_site_parameter_u kind_u
;
1539 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1540 if (kind_u
.dwarf_reg
!= -1)
1541 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1544 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1545 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1548 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1549 suppressed during normal operation. The expression can be arbitrary if
1550 there is no caller-callee entry value binding expected. */
1551 throw_error (NO_ENTRY_VALUE_ERROR
,
1552 _("DWARF-2 expression error: DW_OP_entry_value is supported "
1553 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1556 struct piece_closure
1558 /* Reference count. */
1561 /* The objfile from which this closure's expression came. */
1562 dwarf2_per_objfile
*per_objfile
= nullptr;
1564 /* The CU from which this closure's expression came. */
1565 struct dwarf2_per_cu_data
*per_cu
= NULL
;
1567 /* The pieces describing this variable. */
1568 std::vector
<dwarf_expr_piece
> pieces
;
1570 /* Frame ID of frame to which a register value is relative, used
1571 only by DWARF_VALUE_REGISTER. */
1572 struct frame_id frame_id
;
1575 /* Allocate a closure for a value formed from separately-described
1578 static struct piece_closure
*
1579 allocate_piece_closure (dwarf2_per_cu_data
*per_cu
,
1580 dwarf2_per_objfile
*per_objfile
,
1581 std::vector
<dwarf_expr_piece
> &&pieces
,
1582 struct frame_info
*frame
)
1584 struct piece_closure
*c
= new piece_closure
;
1587 /* We must capture this here due to sharing of DWARF state. */
1588 c
->per_objfile
= per_objfile
;
1590 c
->pieces
= std::move (pieces
);
1592 c
->frame_id
= null_frame_id
;
1594 c
->frame_id
= get_frame_id (frame
);
1596 for (dwarf_expr_piece
&piece
: c
->pieces
)
1597 if (piece
.location
== DWARF_VALUE_STACK
)
1598 value_incref (piece
.v
.value
);
1603 /* Return the number of bytes overlapping a contiguous chunk of N_BITS
1604 bits whose first bit is located at bit offset START. */
1607 bits_to_bytes (ULONGEST start
, ULONGEST n_bits
)
1609 return (start
% 8 + n_bits
+ 7) / 8;
1612 /* Read or write a pieced value V. If FROM != NULL, operate in "write
1613 mode": copy FROM into the pieces comprising V. If FROM == NULL,
1614 operate in "read mode": fetch the contents of the (lazy) value V by
1615 composing it from its pieces. */
1618 rw_pieced_value (struct value
*v
, struct value
*from
)
1621 LONGEST offset
= 0, max_offset
;
1622 ULONGEST bits_to_skip
;
1623 gdb_byte
*v_contents
;
1624 const gdb_byte
*from_contents
;
1625 struct piece_closure
*c
1626 = (struct piece_closure
*) value_computed_closure (v
);
1627 gdb::byte_vector buffer
;
1628 bool bits_big_endian
= type_byte_order (value_type (v
)) == BFD_ENDIAN_BIG
;
1632 from_contents
= value_contents (from
);
1637 if (value_type (v
) != value_enclosing_type (v
))
1638 internal_error (__FILE__
, __LINE__
,
1639 _("Should not be able to create a lazy value with "
1640 "an enclosing type"));
1641 v_contents
= value_contents_raw (v
);
1642 from_contents
= NULL
;
1645 bits_to_skip
= 8 * value_offset (v
);
1646 if (value_bitsize (v
))
1648 bits_to_skip
+= (8 * value_offset (value_parent (v
))
1649 + value_bitpos (v
));
1651 && (type_byte_order (value_type (from
))
1654 /* Use the least significant bits of FROM. */
1655 max_offset
= 8 * TYPE_LENGTH (value_type (from
));
1656 offset
= max_offset
- value_bitsize (v
);
1659 max_offset
= value_bitsize (v
);
1662 max_offset
= 8 * TYPE_LENGTH (value_type (v
));
1664 /* Advance to the first non-skipped piece. */
1665 for (i
= 0; i
< c
->pieces
.size () && bits_to_skip
>= c
->pieces
[i
].size
; i
++)
1666 bits_to_skip
-= c
->pieces
[i
].size
;
1668 for (; i
< c
->pieces
.size () && offset
< max_offset
; i
++)
1670 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1671 size_t this_size_bits
, this_size
;
1673 this_size_bits
= p
->size
- bits_to_skip
;
1674 if (this_size_bits
> max_offset
- offset
)
1675 this_size_bits
= max_offset
- offset
;
1677 switch (p
->location
)
1679 case DWARF_VALUE_REGISTER
:
1681 struct frame_info
*frame
= frame_find_by_id (c
->frame_id
);
1682 struct gdbarch
*arch
= get_frame_arch (frame
);
1683 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, p
->v
.regno
);
1684 ULONGEST reg_bits
= 8 * register_size (arch
, gdb_regnum
);
1687 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1688 && p
->offset
+ p
->size
< reg_bits
)
1690 /* Big-endian, and we want less than full size. */
1691 bits_to_skip
+= reg_bits
- (p
->offset
+ p
->size
);
1694 bits_to_skip
+= p
->offset
;
1696 this_size
= bits_to_bytes (bits_to_skip
, this_size_bits
);
1697 buffer
.resize (this_size
);
1702 if (!get_frame_register_bytes (frame
, gdb_regnum
,
1704 this_size
, buffer
.data (),
1708 mark_value_bits_optimized_out (v
, offset
,
1711 mark_value_bits_unavailable (v
, offset
,
1716 copy_bitwise (v_contents
, offset
,
1717 buffer
.data (), bits_to_skip
% 8,
1718 this_size_bits
, bits_big_endian
);
1723 if (bits_to_skip
% 8 != 0 || this_size_bits
% 8 != 0)
1725 /* Data is copied non-byte-aligned into the register.
1726 Need some bits from original register value. */
1727 get_frame_register_bytes (frame
, gdb_regnum
,
1729 this_size
, buffer
.data (),
1732 throw_error (OPTIMIZED_OUT_ERROR
,
1733 _("Can't do read-modify-write to "
1734 "update bitfield; containing word "
1735 "has been optimized out"));
1737 throw_error (NOT_AVAILABLE_ERROR
,
1738 _("Can't do read-modify-write to "
1739 "update bitfield; containing word "
1743 copy_bitwise (buffer
.data (), bits_to_skip
% 8,
1744 from_contents
, offset
,
1745 this_size_bits
, bits_big_endian
);
1746 put_frame_register_bytes (frame
, gdb_regnum
,
1748 this_size
, buffer
.data ());
1753 case DWARF_VALUE_MEMORY
:
1755 bits_to_skip
+= p
->offset
;
1757 CORE_ADDR start_addr
= p
->v
.mem
.addr
+ bits_to_skip
/ 8;
1759 if (bits_to_skip
% 8 == 0 && this_size_bits
% 8 == 0
1762 /* Everything is byte-aligned; no buffer needed. */
1764 write_memory_with_notification (start_addr
,
1767 this_size_bits
/ 8);
1769 read_value_memory (v
, offset
,
1770 p
->v
.mem
.in_stack_memory
,
1771 p
->v
.mem
.addr
+ bits_to_skip
/ 8,
1772 v_contents
+ offset
/ 8,
1773 this_size_bits
/ 8);
1777 this_size
= bits_to_bytes (bits_to_skip
, this_size_bits
);
1778 buffer
.resize (this_size
);
1783 read_value_memory (v
, offset
,
1784 p
->v
.mem
.in_stack_memory
,
1785 p
->v
.mem
.addr
+ bits_to_skip
/ 8,
1786 buffer
.data (), this_size
);
1787 copy_bitwise (v_contents
, offset
,
1788 buffer
.data (), bits_to_skip
% 8,
1789 this_size_bits
, bits_big_endian
);
1794 if (bits_to_skip
% 8 != 0 || this_size_bits
% 8 != 0)
1798 /* Perform a single read for small sizes. */
1799 read_memory (start_addr
, buffer
.data (),
1804 /* Only the first and last bytes can possibly have
1806 read_memory (start_addr
, buffer
.data (), 1);
1807 read_memory (start_addr
+ this_size
- 1,
1808 &buffer
[this_size
- 1], 1);
1812 copy_bitwise (buffer
.data (), bits_to_skip
% 8,
1813 from_contents
, offset
,
1814 this_size_bits
, bits_big_endian
);
1815 write_memory_with_notification (start_addr
,
1822 case DWARF_VALUE_STACK
:
1826 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1830 struct objfile
*objfile
= c
->per_cu
->objfile ();
1831 struct gdbarch
*objfile_gdbarch
= objfile
->arch ();
1832 ULONGEST stack_value_size_bits
1833 = 8 * TYPE_LENGTH (value_type (p
->v
.value
));
1835 /* Use zeroes if piece reaches beyond stack value. */
1836 if (p
->offset
+ p
->size
> stack_value_size_bits
)
1839 /* Piece is anchored at least significant bit end. */
1840 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
1841 bits_to_skip
+= stack_value_size_bits
- p
->offset
- p
->size
;
1843 bits_to_skip
+= p
->offset
;
1845 copy_bitwise (v_contents
, offset
,
1846 value_contents_all (p
->v
.value
),
1848 this_size_bits
, bits_big_endian
);
1852 case DWARF_VALUE_LITERAL
:
1856 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1860 ULONGEST literal_size_bits
= 8 * p
->v
.literal
.length
;
1861 size_t n
= this_size_bits
;
1863 /* Cut off at the end of the implicit value. */
1864 bits_to_skip
+= p
->offset
;
1865 if (bits_to_skip
>= literal_size_bits
)
1867 if (n
> literal_size_bits
- bits_to_skip
)
1868 n
= literal_size_bits
- bits_to_skip
;
1870 copy_bitwise (v_contents
, offset
,
1871 p
->v
.literal
.data
, bits_to_skip
,
1872 n
, bits_big_endian
);
1876 case DWARF_VALUE_IMPLICIT_POINTER
:
1879 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1883 /* These bits show up as zeros -- but do not cause the value to
1884 be considered optimized-out. */
1887 case DWARF_VALUE_OPTIMIZED_OUT
:
1888 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1892 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1895 offset
+= this_size_bits
;
1902 read_pieced_value (struct value
*v
)
1904 rw_pieced_value (v
, NULL
);
1908 write_pieced_value (struct value
*to
, struct value
*from
)
1910 rw_pieced_value (to
, from
);
1913 /* An implementation of an lval_funcs method to see whether a value is
1914 a synthetic pointer. */
1917 check_pieced_synthetic_pointer (const struct value
*value
, LONGEST bit_offset
,
1920 struct piece_closure
*c
1921 = (struct piece_closure
*) value_computed_closure (value
);
1924 bit_offset
+= 8 * value_offset (value
);
1925 if (value_bitsize (value
))
1926 bit_offset
+= value_bitpos (value
);
1928 for (i
= 0; i
< c
->pieces
.size () && bit_length
> 0; i
++)
1930 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1931 size_t this_size_bits
= p
->size
;
1935 if (bit_offset
>= this_size_bits
)
1937 bit_offset
-= this_size_bits
;
1941 bit_length
-= this_size_bits
- bit_offset
;
1945 bit_length
-= this_size_bits
;
1947 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1954 /* A wrapper function for get_frame_address_in_block. */
1957 get_frame_address_in_block_wrapper (void *baton
)
1959 return get_frame_address_in_block ((struct frame_info
*) baton
);
1962 /* Fetch a DW_AT_const_value through a synthetic pointer. */
1964 static struct value
*
1965 fetch_const_value_from_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
1966 struct dwarf2_per_cu_data
*per_cu
,
1969 struct value
*result
= NULL
;
1970 const gdb_byte
*bytes
;
1973 auto_obstack temp_obstack
;
1974 bytes
= dwarf2_fetch_constant_bytes (die
, per_cu
, &temp_obstack
, &len
);
1978 if (byte_offset
>= 0
1979 && byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) <= len
)
1981 bytes
+= byte_offset
;
1982 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
1985 invalid_synthetic_pointer ();
1988 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
1993 /* Fetch the value pointed to by a synthetic pointer. */
1995 static struct value
*
1996 indirect_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
1997 struct dwarf2_per_cu_data
*per_cu
,
1998 struct frame_info
*frame
, struct type
*type
,
1999 bool resolve_abstract_p
)
2001 /* Fetch the location expression of the DIE we're pointing to. */
2002 struct dwarf2_locexpr_baton baton
2003 = dwarf2_fetch_die_loc_sect_off (die
, per_cu
,
2004 get_frame_address_in_block_wrapper
, frame
,
2005 resolve_abstract_p
);
2007 /* Get type of pointed-to DIE. */
2008 struct type
*orig_type
= dwarf2_fetch_die_type_sect_off (die
, per_cu
);
2009 if (orig_type
== NULL
)
2010 invalid_synthetic_pointer ();
2012 /* If pointed-to DIE has a DW_AT_location, evaluate it and return the
2013 resulting value. Otherwise, it may have a DW_AT_const_value instead,
2014 or it may've been optimized out. */
2015 if (baton
.data
!= NULL
)
2016 return dwarf2_evaluate_loc_desc_full (orig_type
, frame
, baton
.data
,
2017 baton
.size
, baton
.per_cu
,
2018 TYPE_TARGET_TYPE (type
),
2021 return fetch_const_value_from_synthetic_pointer (die
, byte_offset
, per_cu
,
2025 /* An implementation of an lval_funcs method to indirect through a
2026 pointer. This handles the synthetic pointer case when needed. */
2028 static struct value
*
2029 indirect_pieced_value (struct value
*value
)
2031 struct piece_closure
*c
2032 = (struct piece_closure
*) value_computed_closure (value
);
2034 struct frame_info
*frame
;
2037 struct dwarf_expr_piece
*piece
= NULL
;
2038 LONGEST byte_offset
;
2039 enum bfd_endian byte_order
;
2041 type
= check_typedef (value_type (value
));
2042 if (type
->code () != TYPE_CODE_PTR
)
2045 bit_length
= 8 * TYPE_LENGTH (type
);
2046 bit_offset
= 8 * value_offset (value
);
2047 if (value_bitsize (value
))
2048 bit_offset
+= value_bitpos (value
);
2050 for (i
= 0; i
< c
->pieces
.size () && bit_length
> 0; i
++)
2052 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2053 size_t this_size_bits
= p
->size
;
2057 if (bit_offset
>= this_size_bits
)
2059 bit_offset
-= this_size_bits
;
2063 bit_length
-= this_size_bits
- bit_offset
;
2067 bit_length
-= this_size_bits
;
2069 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2072 if (bit_length
!= 0)
2073 error (_("Invalid use of DW_OP_implicit_pointer"));
2079 gdb_assert (piece
!= NULL
);
2080 frame
= get_selected_frame (_("No frame selected."));
2082 /* This is an offset requested by GDB, such as value subscripts.
2083 However, due to how synthetic pointers are implemented, this is
2084 always presented to us as a pointer type. This means we have to
2085 sign-extend it manually as appropriate. Use raw
2086 extract_signed_integer directly rather than value_as_address and
2087 sign extend afterwards on architectures that would need it
2088 (mostly everywhere except MIPS, which has signed addresses) as
2089 the later would go through gdbarch_pointer_to_address and thus
2090 return a CORE_ADDR with high bits set on architectures that
2091 encode address spaces and other things in CORE_ADDR. */
2092 byte_order
= gdbarch_byte_order (get_frame_arch (frame
));
2093 byte_offset
= extract_signed_integer (value_contents (value
),
2094 TYPE_LENGTH (type
), byte_order
);
2095 byte_offset
+= piece
->v
.ptr
.offset
;
2097 return indirect_synthetic_pointer (piece
->v
.ptr
.die_sect_off
,
2098 byte_offset
, c
->per_cu
,
2102 /* Implementation of the coerce_ref method of lval_funcs for synthetic C++
2105 static struct value
*
2106 coerce_pieced_ref (const struct value
*value
)
2108 struct type
*type
= check_typedef (value_type (value
));
2110 if (value_bits_synthetic_pointer (value
, value_embedded_offset (value
),
2111 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
2113 const struct piece_closure
*closure
2114 = (struct piece_closure
*) value_computed_closure (value
);
2115 struct frame_info
*frame
2116 = get_selected_frame (_("No frame selected."));
2118 /* gdb represents synthetic pointers as pieced values with a single
2120 gdb_assert (closure
!= NULL
);
2121 gdb_assert (closure
->pieces
.size () == 1);
2123 return indirect_synthetic_pointer
2124 (closure
->pieces
[0].v
.ptr
.die_sect_off
,
2125 closure
->pieces
[0].v
.ptr
.offset
,
2126 closure
->per_cu
, frame
, type
);
2130 /* Else: not a synthetic reference; do nothing. */
2136 copy_pieced_value_closure (const struct value
*v
)
2138 struct piece_closure
*c
2139 = (struct piece_closure
*) value_computed_closure (v
);
2146 free_pieced_value_closure (struct value
*v
)
2148 struct piece_closure
*c
2149 = (struct piece_closure
*) value_computed_closure (v
);
2154 for (dwarf_expr_piece
&p
: c
->pieces
)
2155 if (p
.location
== DWARF_VALUE_STACK
)
2156 value_decref (p
.v
.value
);
2162 /* Functions for accessing a variable described by DW_OP_piece. */
2163 static const struct lval_funcs pieced_value_funcs
= {
2166 indirect_pieced_value
,
2168 check_pieced_synthetic_pointer
,
2169 copy_pieced_value_closure
,
2170 free_pieced_value_closure
2173 /* Evaluate a location description, starting at DATA and with length
2174 SIZE, to find the current location of variable of TYPE in the
2175 context of FRAME. If SUBOBJ_TYPE is non-NULL, return instead the
2176 location of the subobject of type SUBOBJ_TYPE at byte offset
2177 SUBOBJ_BYTE_OFFSET within the variable of type TYPE. */
2179 static struct value
*
2180 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2181 const gdb_byte
*data
, size_t size
,
2182 struct dwarf2_per_cu_data
*per_cu
,
2183 struct type
*subobj_type
,
2184 LONGEST subobj_byte_offset
)
2186 struct value
*retval
;
2187 struct objfile
*objfile
= per_cu
->objfile ();
2189 if (subobj_type
== NULL
)
2192 subobj_byte_offset
= 0;
2194 else if (subobj_byte_offset
< 0)
2195 invalid_synthetic_pointer ();
2198 return allocate_optimized_out_value (subobj_type
);
2200 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
2201 dwarf_evaluate_loc_desc
ctx (per_objfile
);
2203 ctx
.per_cu
= per_cu
;
2204 ctx
.obj_address
= 0;
2206 scoped_value_mark free_values
;
2208 ctx
.gdbarch
= objfile
->arch ();
2209 ctx
.addr_size
= per_cu
->addr_size ();
2210 ctx
.ref_addr_size
= per_cu
->ref_addr_size ();
2214 ctx
.eval (data
, size
);
2216 catch (const gdb_exception_error
&ex
)
2218 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2220 free_values
.free_to_mark ();
2221 retval
= allocate_value (subobj_type
);
2222 mark_value_bytes_unavailable (retval
, 0,
2223 TYPE_LENGTH (subobj_type
));
2226 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2228 if (entry_values_debug
)
2229 exception_print (gdb_stdout
, ex
);
2230 free_values
.free_to_mark ();
2231 return allocate_optimized_out_value (subobj_type
);
2237 if (ctx
.pieces
.size () > 0)
2239 struct piece_closure
*c
;
2240 ULONGEST bit_size
= 0;
2242 for (dwarf_expr_piece
&piece
: ctx
.pieces
)
2243 bit_size
+= piece
.size
;
2244 /* Complain if the expression is larger than the size of the
2246 if (bit_size
> 8 * TYPE_LENGTH (type
))
2247 invalid_synthetic_pointer ();
2249 c
= allocate_piece_closure (per_cu
, per_objfile
, std::move (ctx
.pieces
),
2251 /* We must clean up the value chain after creating the piece
2252 closure but before allocating the result. */
2253 free_values
.free_to_mark ();
2254 retval
= allocate_computed_value (subobj_type
,
2255 &pieced_value_funcs
, c
);
2256 set_value_offset (retval
, subobj_byte_offset
);
2260 switch (ctx
.location
)
2262 case DWARF_VALUE_REGISTER
:
2264 struct gdbarch
*arch
= get_frame_arch (frame
);
2266 = longest_to_int (value_as_long (ctx
.fetch (0)));
2267 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, dwarf_regnum
);
2269 if (subobj_byte_offset
!= 0)
2270 error (_("cannot use offset on synthetic pointer to register"));
2271 free_values
.free_to_mark ();
2272 retval
= value_from_register (subobj_type
, gdb_regnum
, frame
);
2273 if (value_optimized_out (retval
))
2277 /* This means the register has undefined value / was
2278 not saved. As we're computing the location of some
2279 variable etc. in the program, not a value for
2280 inspecting a register ($pc, $sp, etc.), return a
2281 generic optimized out value instead, so that we show
2282 <optimized out> instead of <not saved>. */
2283 tmp
= allocate_value (subobj_type
);
2284 value_contents_copy (tmp
, 0, retval
, 0,
2285 TYPE_LENGTH (subobj_type
));
2291 case DWARF_VALUE_MEMORY
:
2293 struct type
*ptr_type
;
2294 CORE_ADDR address
= ctx
.fetch_address (0);
2295 bool in_stack_memory
= ctx
.fetch_in_stack_memory (0);
2297 /* DW_OP_deref_size (and possibly other operations too) may
2298 create a pointer instead of an address. Ideally, the
2299 pointer to address conversion would be performed as part
2300 of those operations, but the type of the object to
2301 which the address refers is not known at the time of
2302 the operation. Therefore, we do the conversion here
2303 since the type is readily available. */
2305 switch (subobj_type
->code ())
2307 case TYPE_CODE_FUNC
:
2308 case TYPE_CODE_METHOD
:
2309 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_func_ptr
;
2312 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_data_ptr
;
2315 address
= value_as_address (value_from_pointer (ptr_type
, address
));
2317 free_values
.free_to_mark ();
2318 retval
= value_at_lazy (subobj_type
,
2319 address
+ subobj_byte_offset
);
2320 if (in_stack_memory
)
2321 set_value_stack (retval
, 1);
2325 case DWARF_VALUE_STACK
:
2327 struct value
*value
= ctx
.fetch (0);
2328 size_t n
= TYPE_LENGTH (value_type (value
));
2329 size_t len
= TYPE_LENGTH (subobj_type
);
2330 size_t max
= TYPE_LENGTH (type
);
2331 struct gdbarch
*objfile_gdbarch
= objfile
->arch ();
2333 if (subobj_byte_offset
+ len
> max
)
2334 invalid_synthetic_pointer ();
2336 /* Preserve VALUE because we are going to free values back
2337 to the mark, but we still need the value contents
2339 value_ref_ptr value_holder
= value_ref_ptr::new_reference (value
);
2340 free_values
.free_to_mark ();
2342 retval
= allocate_value (subobj_type
);
2344 /* The given offset is relative to the actual object. */
2345 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2346 subobj_byte_offset
+= n
- max
;
2348 memcpy (value_contents_raw (retval
),
2349 value_contents_all (value
) + subobj_byte_offset
, len
);
2353 case DWARF_VALUE_LITERAL
:
2356 size_t n
= TYPE_LENGTH (subobj_type
);
2358 if (subobj_byte_offset
+ n
> ctx
.len
)
2359 invalid_synthetic_pointer ();
2361 free_values
.free_to_mark ();
2362 retval
= allocate_value (subobj_type
);
2363 contents
= value_contents_raw (retval
);
2364 memcpy (contents
, ctx
.data
+ subobj_byte_offset
, n
);
2368 case DWARF_VALUE_OPTIMIZED_OUT
:
2369 free_values
.free_to_mark ();
2370 retval
= allocate_optimized_out_value (subobj_type
);
2373 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2374 operation by execute_stack_op. */
2375 case DWARF_VALUE_IMPLICIT_POINTER
:
2376 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2377 it can only be encountered when making a piece. */
2379 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2383 set_value_initialized (retval
, ctx
.initialized
);
2388 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2389 passes 0 as the byte_offset. */
2392 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2393 const gdb_byte
*data
, size_t size
,
2394 struct dwarf2_per_cu_data
*per_cu
)
2396 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
,
2400 /* A specialization of dwarf_evaluate_loc_desc that is used by
2401 dwarf2_locexpr_baton_eval. This subclass exists to handle the case
2402 where a caller of dwarf2_locexpr_baton_eval passes in some data,
2403 but with the address being 0. In this situation, we arrange for
2404 memory reads to come from the passed-in buffer. */
2406 struct evaluate_for_locexpr_baton
: public dwarf_evaluate_loc_desc
2408 evaluate_for_locexpr_baton (dwarf2_per_objfile
*per_objfile
)
2409 : dwarf_evaluate_loc_desc (per_objfile
)
2412 /* The data that was passed in. */
2413 gdb::array_view
<const gdb_byte
> data_view
;
2415 CORE_ADDR
get_object_address () override
2417 if (data_view
.data () == nullptr && obj_address
== 0)
2418 error (_("Location address is not set."));
2422 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
2427 /* Prefer the passed-in memory, if it exists. */
2428 CORE_ADDR offset
= addr
- obj_address
;
2429 if (offset
< data_view
.size () && offset
+ len
<= data_view
.size ())
2431 memcpy (buf
, data_view
.data (), len
);
2435 read_memory (addr
, buf
, len
);
2439 /* Evaluates a dwarf expression and stores the result in VAL,
2440 expecting that the dwarf expression only produces a single
2441 CORE_ADDR. FRAME is the frame in which the expression is
2442 evaluated. ADDR_STACK is a context (location of a variable) and
2443 might be needed to evaluate the location expression.
2444 PUSH_INITIAL_VALUE is true if the address (either from ADDR_STACK,
2445 or the default of 0) should be pushed on the DWARF expression
2446 evaluation stack before evaluating the expression; this is required
2447 by certain forms of DWARF expression. Returns 1 on success, 0
2451 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton
*dlbaton
,
2452 struct frame_info
*frame
,
2453 const struct property_addr_info
*addr_stack
,
2455 bool push_initial_value
)
2457 if (dlbaton
== NULL
|| dlbaton
->size
== 0)
2460 dwarf2_per_objfile
*per_objfile
= dlbaton
->per_objfile
;
2461 evaluate_for_locexpr_baton
ctx (per_objfile
);
2464 ctx
.per_cu
= dlbaton
->per_cu
;
2465 if (addr_stack
== nullptr)
2466 ctx
.obj_address
= 0;
2469 ctx
.obj_address
= addr_stack
->addr
;
2470 ctx
.data_view
= addr_stack
->valaddr
;
2473 ctx
.gdbarch
= per_objfile
->objfile
->arch ();
2474 ctx
.addr_size
= dlbaton
->per_cu
->addr_size ();
2475 ctx
.ref_addr_size
= dlbaton
->per_cu
->ref_addr_size ();
2477 if (push_initial_value
)
2478 ctx
.push_address (ctx
.obj_address
, false);
2482 ctx
.eval (dlbaton
->data
, dlbaton
->size
);
2484 catch (const gdb_exception_error
&ex
)
2486 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2490 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2492 if (entry_values_debug
)
2493 exception_print (gdb_stdout
, ex
);
2500 switch (ctx
.location
)
2502 case DWARF_VALUE_REGISTER
:
2503 case DWARF_VALUE_MEMORY
:
2504 case DWARF_VALUE_STACK
:
2505 *valp
= ctx
.fetch_address (0);
2506 if (ctx
.location
== DWARF_VALUE_REGISTER
)
2507 *valp
= ctx
.read_addr_from_reg (*valp
);
2509 case DWARF_VALUE_LITERAL
:
2510 *valp
= extract_signed_integer (ctx
.data
, ctx
.len
,
2511 gdbarch_byte_order (ctx
.gdbarch
));
2513 /* Unsupported dwarf values. */
2514 case DWARF_VALUE_OPTIMIZED_OUT
:
2515 case DWARF_VALUE_IMPLICIT_POINTER
:
2522 /* See dwarf2loc.h. */
2525 dwarf2_evaluate_property (const struct dynamic_prop
*prop
,
2526 struct frame_info
*frame
,
2527 const struct property_addr_info
*addr_stack
,
2529 bool push_initial_value
)
2534 if (frame
== NULL
&& has_stack_frames ())
2535 frame
= get_selected_frame (NULL
);
2541 const struct dwarf2_property_baton
*baton
2542 = (const struct dwarf2_property_baton
*) prop
->data
.baton
;
2543 gdb_assert (baton
->property_type
!= NULL
);
2545 if (dwarf2_locexpr_baton_eval (&baton
->locexpr
, frame
, addr_stack
,
2546 value
, push_initial_value
))
2548 if (baton
->locexpr
.is_reference
)
2550 struct value
*val
= value_at (baton
->property_type
, *value
);
2551 *value
= value_as_address (val
);
2555 gdb_assert (baton
->property_type
!= NULL
);
2557 struct type
*type
= check_typedef (baton
->property_type
);
2558 if (TYPE_LENGTH (type
) < sizeof (CORE_ADDR
)
2559 && !TYPE_UNSIGNED (type
))
2561 /* If we have a valid return candidate and it's value
2562 is signed, we have to sign-extend the value because
2563 CORE_ADDR on 64bit machine has 8 bytes but address
2564 size of an 32bit application is bytes. */
2566 = (baton
->locexpr
.per_cu
->addr_size ()
2568 const CORE_ADDR neg_mask
2569 = (~((CORE_ADDR
) 0) << (addr_size
- 1));
2571 /* Check if signed bit is set and sign-extend values. */
2572 if (*value
& neg_mask
)
2583 struct dwarf2_property_baton
*baton
2584 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2586 const gdb_byte
*data
;
2591 || !get_frame_address_in_block_if_available (frame
, &pc
))
2594 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2597 val
= dwarf2_evaluate_loc_desc (baton
->property_type
, frame
, data
,
2598 size
, baton
->loclist
.per_cu
);
2599 if (!value_optimized_out (val
))
2601 *value
= value_as_address (val
);
2609 *value
= prop
->data
.const_val
;
2612 case PROP_ADDR_OFFSET
:
2614 struct dwarf2_property_baton
*baton
2615 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2616 const struct property_addr_info
*pinfo
;
2619 for (pinfo
= addr_stack
; pinfo
!= NULL
; pinfo
= pinfo
->next
)
2621 /* This approach lets us avoid checking the qualifiers. */
2622 if (TYPE_MAIN_TYPE (pinfo
->type
)
2623 == TYPE_MAIN_TYPE (baton
->property_type
))
2627 error (_("cannot find reference address for offset property"));
2628 if (pinfo
->valaddr
.data () != NULL
)
2629 val
= value_from_contents
2630 (baton
->offset_info
.type
,
2631 pinfo
->valaddr
.data () + baton
->offset_info
.offset
);
2633 val
= value_at (baton
->offset_info
.type
,
2634 pinfo
->addr
+ baton
->offset_info
.offset
);
2635 *value
= value_as_address (val
);
2643 /* See dwarf2loc.h. */
2646 dwarf2_compile_property_to_c (string_file
*stream
,
2647 const char *result_name
,
2648 struct gdbarch
*gdbarch
,
2649 unsigned char *registers_used
,
2650 const struct dynamic_prop
*prop
,
2654 struct dwarf2_property_baton
*baton
2655 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2656 const gdb_byte
*data
;
2658 dwarf2_per_cu_data
*per_cu
;
2659 dwarf2_per_objfile
*per_objfile
;
2661 if (prop
->kind
== PROP_LOCEXPR
)
2663 data
= baton
->locexpr
.data
;
2664 size
= baton
->locexpr
.size
;
2665 per_cu
= baton
->locexpr
.per_cu
;
2666 per_objfile
= baton
->locexpr
.per_objfile
;
2670 gdb_assert (prop
->kind
== PROP_LOCLIST
);
2672 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2673 per_cu
= baton
->loclist
.per_cu
;
2674 per_objfile
= baton
->loclist
.per_objfile
;
2677 compile_dwarf_bounds_to_c (stream
, result_name
, prop
, sym
, pc
,
2678 gdbarch
, registers_used
,
2679 per_cu
->addr_size (),
2680 data
, data
+ size
, per_cu
, per_objfile
);
2684 /* Helper functions and baton for dwarf2_loc_desc_get_symbol_read_needs. */
2686 class symbol_needs_eval_context
: public dwarf_expr_context
2689 symbol_needs_eval_context (dwarf2_per_objfile
*per_objfile
)
2690 : dwarf_expr_context (per_objfile
)
2693 enum symbol_needs_kind needs
;
2694 struct dwarf2_per_cu_data
*per_cu
;
2696 /* Reads from registers do require a frame. */
2697 CORE_ADDR
read_addr_from_reg (int regnum
) override
2699 needs
= SYMBOL_NEEDS_FRAME
;
2703 /* "get_reg_value" callback: Reads from registers do require a
2706 struct value
*get_reg_value (struct type
*type
, int regnum
) override
2708 needs
= SYMBOL_NEEDS_FRAME
;
2709 return value_zero (type
, not_lval
);
2712 /* Reads from memory do not require a frame. */
2713 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
2715 memset (buf
, 0, len
);
2718 /* Frame-relative accesses do require a frame. */
2719 void get_frame_base (const gdb_byte
**start
, size_t *length
) override
2721 static gdb_byte lit0
= DW_OP_lit0
;
2726 needs
= SYMBOL_NEEDS_FRAME
;
2729 /* CFA accesses require a frame. */
2730 CORE_ADDR
get_frame_cfa () override
2732 needs
= SYMBOL_NEEDS_FRAME
;
2736 CORE_ADDR
get_frame_pc () override
2738 needs
= SYMBOL_NEEDS_FRAME
;
2742 /* Thread-local accesses require registers, but not a frame. */
2743 CORE_ADDR
get_tls_address (CORE_ADDR offset
) override
2745 if (needs
<= SYMBOL_NEEDS_REGISTERS
)
2746 needs
= SYMBOL_NEEDS_REGISTERS
;
2750 /* Helper interface of per_cu_dwarf_call for
2751 dwarf2_loc_desc_get_symbol_read_needs. */
2753 void dwarf_call (cu_offset die_offset
) override
2755 per_cu_dwarf_call (this, die_offset
, per_cu
);
2758 /* Helper interface of sect_variable_value for
2759 dwarf2_loc_desc_get_symbol_read_needs. */
2761 struct value
*dwarf_variable_value (sect_offset sect_off
) override
2763 return sect_variable_value (this, sect_off
, per_cu
);
2766 /* DW_OP_entry_value accesses require a caller, therefore a
2769 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
2770 union call_site_parameter_u kind_u
,
2771 int deref_size
) override
2773 needs
= SYMBOL_NEEDS_FRAME
;
2775 /* The expression may require some stub values on DWARF stack. */
2776 push_address (0, 0);
2779 /* DW_OP_addrx and DW_OP_GNU_addr_index doesn't require a frame. */
2781 CORE_ADDR
get_addr_index (unsigned int index
) override
2783 /* Nothing to do. */
2787 /* DW_OP_push_object_address has a frame already passed through. */
2789 CORE_ADDR
get_object_address () override
2791 /* Nothing to do. */
2796 /* Compute the correct symbol_needs_kind value for the location
2797 expression at DATA (length SIZE). */
2799 static enum symbol_needs_kind
2800 dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte
*data
, size_t size
,
2801 struct dwarf2_per_cu_data
*per_cu
)
2804 struct objfile
*objfile
= per_cu
->objfile ();
2806 scoped_value_mark free_values
;
2808 symbol_needs_eval_context
ctx (get_dwarf2_per_objfile (objfile
));
2810 ctx
.needs
= SYMBOL_NEEDS_NONE
;
2811 ctx
.per_cu
= per_cu
;
2812 ctx
.gdbarch
= objfile
->arch ();
2813 ctx
.addr_size
= per_cu
->addr_size ();
2814 ctx
.ref_addr_size
= per_cu
->ref_addr_size ();
2816 ctx
.eval (data
, size
);
2818 in_reg
= ctx
.location
== DWARF_VALUE_REGISTER
;
2820 /* If the location has several pieces, and any of them are in
2821 registers, then we will need a frame to fetch them from. */
2822 for (dwarf_expr_piece
&p
: ctx
.pieces
)
2823 if (p
.location
== DWARF_VALUE_REGISTER
)
2827 ctx
.needs
= SYMBOL_NEEDS_FRAME
;
2831 /* A helper function that throws an unimplemented error mentioning a
2832 given DWARF operator. */
2834 static void ATTRIBUTE_NORETURN
2835 unimplemented (unsigned int op
)
2837 const char *name
= get_DW_OP_name (op
);
2840 error (_("DWARF operator %s cannot be translated to an agent expression"),
2843 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2844 "to an agent expression"),
2850 This is basically a wrapper on gdbarch_dwarf2_reg_to_regnum so that we
2851 can issue a complaint, which is better than having every target's
2852 implementation of dwarf2_reg_to_regnum do it. */
2855 dwarf_reg_to_regnum (struct gdbarch
*arch
, int dwarf_reg
)
2857 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2861 complaint (_("bad DWARF register number %d"), dwarf_reg
);
2866 /* Subroutine of dwarf_reg_to_regnum_or_error to simplify it.
2867 Throw an error because DWARF_REG is bad. */
2870 throw_bad_regnum_error (ULONGEST dwarf_reg
)
2872 /* Still want to print -1 as "-1".
2873 We *could* have int and ULONGEST versions of dwarf2_reg_to_regnum_or_error
2874 but that's overkill for now. */
2875 if ((int) dwarf_reg
== dwarf_reg
)
2876 error (_("Unable to access DWARF register number %d"), (int) dwarf_reg
);
2877 error (_("Unable to access DWARF register number %s"),
2878 pulongest (dwarf_reg
));
2881 /* See dwarf2loc.h. */
2884 dwarf_reg_to_regnum_or_error (struct gdbarch
*arch
, ULONGEST dwarf_reg
)
2888 if (dwarf_reg
> INT_MAX
)
2889 throw_bad_regnum_error (dwarf_reg
);
2890 /* Yes, we will end up issuing a complaint and an error if DWARF_REG is
2891 bad, but that's ok. */
2892 reg
= dwarf_reg_to_regnum (arch
, (int) dwarf_reg
);
2894 throw_bad_regnum_error (dwarf_reg
);
2898 /* A helper function that emits an access to memory. ARCH is the
2899 target architecture. EXPR is the expression which we are building.
2900 NBITS is the number of bits we want to read. This emits the
2901 opcodes needed to read the memory and then extract the desired
2905 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2907 ULONGEST nbytes
= (nbits
+ 7) / 8;
2909 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2912 ax_trace_quick (expr
, nbytes
);
2915 ax_simple (expr
, aop_ref8
);
2916 else if (nbits
<= 16)
2917 ax_simple (expr
, aop_ref16
);
2918 else if (nbits
<= 32)
2919 ax_simple (expr
, aop_ref32
);
2921 ax_simple (expr
, aop_ref64
);
2923 /* If we read exactly the number of bytes we wanted, we're done. */
2924 if (8 * nbytes
== nbits
)
2927 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
)
2929 /* On a bits-big-endian machine, we want the high-order
2931 ax_const_l (expr
, 8 * nbytes
- nbits
);
2932 ax_simple (expr
, aop_rsh_unsigned
);
2936 /* On a bits-little-endian box, we want the low-order NBITS. */
2937 ax_zero_ext (expr
, nbits
);
2941 /* A helper function to return the frame's PC. */
2944 get_ax_pc (void *baton
)
2946 struct agent_expr
*expr
= (struct agent_expr
*) baton
;
2951 /* Compile a DWARF location expression to an agent expression.
2953 EXPR is the agent expression we are building.
2954 LOC is the agent value we modify.
2955 ARCH is the architecture.
2956 ADDR_SIZE is the size of addresses, in bytes.
2957 OP_PTR is the start of the location expression.
2958 OP_END is one past the last byte of the location expression.
2960 This will throw an exception for various kinds of errors -- for
2961 example, if the expression cannot be compiled, or if the expression
2965 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2966 unsigned int addr_size
, const gdb_byte
*op_ptr
,
2967 const gdb_byte
*op_end
,
2968 dwarf2_per_cu_data
*per_cu
,
2969 dwarf2_per_objfile
*per_objfile
)
2971 gdbarch
*arch
= expr
->gdbarch
;
2972 std::vector
<int> dw_labels
, patches
;
2973 const gdb_byte
* const base
= op_ptr
;
2974 const gdb_byte
*previous_piece
= op_ptr
;
2975 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2976 ULONGEST bits_collected
= 0;
2977 unsigned int addr_size_bits
= 8 * addr_size
;
2978 bool bits_big_endian
= byte_order
== BFD_ENDIAN_BIG
;
2980 std::vector
<int> offsets (op_end
- op_ptr
, -1);
2982 /* By default we are making an address. */
2983 loc
->kind
= axs_lvalue_memory
;
2985 while (op_ptr
< op_end
)
2987 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
2988 uint64_t uoffset
, reg
;
2992 offsets
[op_ptr
- base
] = expr
->len
;
2995 /* Our basic approach to code generation is to map DWARF
2996 operations directly to AX operations. However, there are
2999 First, DWARF works on address-sized units, but AX always uses
3000 LONGEST. For most operations we simply ignore this
3001 difference; instead we generate sign extensions as needed
3002 before division and comparison operations. It would be nice
3003 to omit the sign extensions, but there is no way to determine
3004 the size of the target's LONGEST. (This code uses the size
3005 of the host LONGEST in some cases -- that is a bug but it is
3008 Second, some DWARF operations cannot be translated to AX.
3009 For these we simply fail. See
3010 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
3045 ax_const_l (expr
, op
- DW_OP_lit0
);
3049 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
3050 op_ptr
+= addr_size
;
3051 /* Some versions of GCC emit DW_OP_addr before
3052 DW_OP_GNU_push_tls_address. In this case the value is an
3053 index, not an address. We don't support things like
3054 branching between the address and the TLS op. */
3055 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
3056 uoffset
+= per_objfile
->objfile
->text_section_offset ();
3057 ax_const_l (expr
, uoffset
);
3061 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
3065 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
3069 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
3073 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
3077 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
3081 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
3085 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
3089 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
3093 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3094 ax_const_l (expr
, uoffset
);
3097 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3098 ax_const_l (expr
, offset
);
3133 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3134 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_reg0
);
3135 loc
->kind
= axs_lvalue_register
;
3139 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3140 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3141 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3142 loc
->kind
= axs_lvalue_register
;
3145 case DW_OP_implicit_value
:
3149 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
3150 if (op_ptr
+ len
> op_end
)
3151 error (_("DW_OP_implicit_value: too few bytes available."));
3152 if (len
> sizeof (ULONGEST
))
3153 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
3156 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
3159 dwarf_expr_require_composition (op_ptr
, op_end
,
3160 "DW_OP_implicit_value");
3162 loc
->kind
= axs_rvalue
;
3166 case DW_OP_stack_value
:
3167 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
3168 loc
->kind
= axs_rvalue
;
3203 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3204 i
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_breg0
);
3208 ax_const_l (expr
, offset
);
3209 ax_simple (expr
, aop_add
);
3214 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3215 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3216 i
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3220 ax_const_l (expr
, offset
);
3221 ax_simple (expr
, aop_add
);
3227 const gdb_byte
*datastart
;
3229 const struct block
*b
;
3230 struct symbol
*framefunc
;
3232 b
= block_for_pc (expr
->scope
);
3235 error (_("No block found for address"));
3237 framefunc
= block_linkage_function (b
);
3240 error (_("No function found for block"));
3242 func_get_frame_base_dwarf_block (framefunc
, expr
->scope
,
3243 &datastart
, &datalen
);
3245 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3246 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, datastart
,
3247 datastart
+ datalen
, per_cu
,
3249 if (loc
->kind
== axs_lvalue_register
)
3250 require_rvalue (expr
, loc
);
3254 ax_const_l (expr
, offset
);
3255 ax_simple (expr
, aop_add
);
3258 loc
->kind
= axs_lvalue_memory
;
3263 ax_simple (expr
, aop_dup
);
3267 ax_simple (expr
, aop_pop
);
3272 ax_pick (expr
, offset
);
3276 ax_simple (expr
, aop_swap
);
3284 ax_simple (expr
, aop_rot
);
3288 case DW_OP_deref_size
:
3292 if (op
== DW_OP_deref_size
)
3297 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3298 error (_("Unsupported size %d in %s"),
3299 size
, get_DW_OP_name (op
));
3300 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3305 /* Sign extend the operand. */
3306 ax_ext (expr
, addr_size_bits
);
3307 ax_simple (expr
, aop_dup
);
3308 ax_const_l (expr
, 0);
3309 ax_simple (expr
, aop_less_signed
);
3310 ax_simple (expr
, aop_log_not
);
3311 i
= ax_goto (expr
, aop_if_goto
);
3312 /* We have to emit 0 - X. */
3313 ax_const_l (expr
, 0);
3314 ax_simple (expr
, aop_swap
);
3315 ax_simple (expr
, aop_sub
);
3316 ax_label (expr
, i
, expr
->len
);
3320 /* No need to sign extend here. */
3321 ax_const_l (expr
, 0);
3322 ax_simple (expr
, aop_swap
);
3323 ax_simple (expr
, aop_sub
);
3327 /* Sign extend the operand. */
3328 ax_ext (expr
, addr_size_bits
);
3329 ax_simple (expr
, aop_bit_not
);
3332 case DW_OP_plus_uconst
:
3333 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3334 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3335 but we micro-optimize anyhow. */
3338 ax_const_l (expr
, reg
);
3339 ax_simple (expr
, aop_add
);
3344 ax_simple (expr
, aop_bit_and
);
3348 /* Sign extend the operands. */
3349 ax_ext (expr
, addr_size_bits
);
3350 ax_simple (expr
, aop_swap
);
3351 ax_ext (expr
, addr_size_bits
);
3352 ax_simple (expr
, aop_swap
);
3353 ax_simple (expr
, aop_div_signed
);
3357 ax_simple (expr
, aop_sub
);
3361 ax_simple (expr
, aop_rem_unsigned
);
3365 ax_simple (expr
, aop_mul
);
3369 ax_simple (expr
, aop_bit_or
);
3373 ax_simple (expr
, aop_add
);
3377 ax_simple (expr
, aop_lsh
);
3381 ax_simple (expr
, aop_rsh_unsigned
);
3385 ax_simple (expr
, aop_rsh_signed
);
3389 ax_simple (expr
, aop_bit_xor
);
3393 /* Sign extend the operands. */
3394 ax_ext (expr
, addr_size_bits
);
3395 ax_simple (expr
, aop_swap
);
3396 ax_ext (expr
, addr_size_bits
);
3397 /* Note no swap here: A <= B is !(B < A). */
3398 ax_simple (expr
, aop_less_signed
);
3399 ax_simple (expr
, aop_log_not
);
3403 /* Sign extend the operands. */
3404 ax_ext (expr
, addr_size_bits
);
3405 ax_simple (expr
, aop_swap
);
3406 ax_ext (expr
, addr_size_bits
);
3407 ax_simple (expr
, aop_swap
);
3408 /* A >= B is !(A < B). */
3409 ax_simple (expr
, aop_less_signed
);
3410 ax_simple (expr
, aop_log_not
);
3414 /* Sign extend the operands. */
3415 ax_ext (expr
, addr_size_bits
);
3416 ax_simple (expr
, aop_swap
);
3417 ax_ext (expr
, addr_size_bits
);
3418 /* No need for a second swap here. */
3419 ax_simple (expr
, aop_equal
);
3423 /* Sign extend the operands. */
3424 ax_ext (expr
, addr_size_bits
);
3425 ax_simple (expr
, aop_swap
);
3426 ax_ext (expr
, addr_size_bits
);
3427 ax_simple (expr
, aop_swap
);
3428 ax_simple (expr
, aop_less_signed
);
3432 /* Sign extend the operands. */
3433 ax_ext (expr
, addr_size_bits
);
3434 ax_simple (expr
, aop_swap
);
3435 ax_ext (expr
, addr_size_bits
);
3436 /* Note no swap here: A > B is B < A. */
3437 ax_simple (expr
, aop_less_signed
);
3441 /* Sign extend the operands. */
3442 ax_ext (expr
, addr_size_bits
);
3443 ax_simple (expr
, aop_swap
);
3444 ax_ext (expr
, addr_size_bits
);
3445 /* No need for a swap here. */
3446 ax_simple (expr
, aop_equal
);
3447 ax_simple (expr
, aop_log_not
);
3450 case DW_OP_call_frame_cfa
:
3453 CORE_ADDR text_offset
;
3455 const gdb_byte
*cfa_start
, *cfa_end
;
3457 if (dwarf2_fetch_cfa_info (arch
, expr
->scope
, per_cu
,
3459 &text_offset
, &cfa_start
, &cfa_end
))
3462 ax_reg (expr
, regnum
);
3465 ax_const_l (expr
, off
);
3466 ax_simple (expr
, aop_add
);
3471 /* Another expression. */
3472 ax_const_l (expr
, text_offset
);
3473 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, cfa_start
,
3474 cfa_end
, per_cu
, per_objfile
);
3477 loc
->kind
= axs_lvalue_memory
;
3481 case DW_OP_GNU_push_tls_address
:
3482 case DW_OP_form_tls_address
:
3486 case DW_OP_push_object_address
:
3491 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3493 i
= ax_goto (expr
, aop_goto
);
3494 dw_labels
.push_back (op_ptr
+ offset
- base
);
3495 patches
.push_back (i
);
3499 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3501 /* Zero extend the operand. */
3502 ax_zero_ext (expr
, addr_size_bits
);
3503 i
= ax_goto (expr
, aop_if_goto
);
3504 dw_labels
.push_back (op_ptr
+ offset
- base
);
3505 patches
.push_back (i
);
3512 case DW_OP_bit_piece
:
3516 if (op_ptr
- 1 == previous_piece
)
3517 error (_("Cannot translate empty pieces to agent expressions"));
3518 previous_piece
= op_ptr
- 1;
3520 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3521 if (op
== DW_OP_piece
)
3527 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3529 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3530 error (_("Expression pieces exceed word size"));
3532 /* Access the bits. */
3535 case axs_lvalue_register
:
3536 ax_reg (expr
, loc
->u
.reg
);
3539 case axs_lvalue_memory
:
3540 /* Offset the pointer, if needed. */
3543 ax_const_l (expr
, uoffset
/ 8);
3544 ax_simple (expr
, aop_add
);
3547 access_memory (arch
, expr
, size
);
3551 /* For a bits-big-endian target, shift up what we already
3552 have. For a bits-little-endian target, shift up the
3553 new data. Note that there is a potential bug here if
3554 the DWARF expression leaves multiple values on the
3556 if (bits_collected
> 0)
3558 if (bits_big_endian
)
3560 ax_simple (expr
, aop_swap
);
3561 ax_const_l (expr
, size
);
3562 ax_simple (expr
, aop_lsh
);
3563 /* We don't need a second swap here, because
3564 aop_bit_or is symmetric. */
3568 ax_const_l (expr
, size
);
3569 ax_simple (expr
, aop_lsh
);
3571 ax_simple (expr
, aop_bit_or
);
3574 bits_collected
+= size
;
3575 loc
->kind
= axs_rvalue
;
3579 case DW_OP_GNU_uninit
:
3585 struct dwarf2_locexpr_baton block
;
3586 int size
= (op
== DW_OP_call2
? 2 : 4);
3588 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3591 cu_offset cuoffset
= (cu_offset
) uoffset
;
3592 block
= dwarf2_fetch_die_loc_cu_off (cuoffset
, per_cu
,
3595 /* DW_OP_call_ref is currently not supported. */
3596 gdb_assert (block
.per_cu
== per_cu
);
3598 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, block
.data
,
3599 block
.data
+ block
.size
, per_cu
,
3604 case DW_OP_call_ref
:
3607 case DW_OP_GNU_variable_value
:
3615 /* Patch all the branches we emitted. */
3616 for (int i
= 0; i
< patches
.size (); ++i
)
3618 int targ
= offsets
[dw_labels
[i
]];
3620 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3621 ax_label (expr
, patches
[i
], targ
);
3626 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3627 evaluator to calculate the location. */
3628 static struct value
*
3629 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3631 struct dwarf2_locexpr_baton
*dlbaton
3632 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3635 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3636 dlbaton
->size
, dlbaton
->per_cu
);
3641 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3642 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3645 static struct value
*
3646 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3648 struct dwarf2_locexpr_baton
*dlbaton
3649 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3651 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3655 /* Implementation of get_symbol_read_needs from
3656 symbol_computed_ops. */
3658 static enum symbol_needs_kind
3659 locexpr_get_symbol_read_needs (struct symbol
*symbol
)
3661 struct dwarf2_locexpr_baton
*dlbaton
3662 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3664 return dwarf2_loc_desc_get_symbol_read_needs (dlbaton
->data
, dlbaton
->size
,
3668 /* Return true if DATA points to the end of a piece. END is one past
3669 the last byte in the expression. */
3672 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3674 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3677 /* Helper for locexpr_describe_location_piece that finds the name of a
3681 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3685 /* This doesn't use dwarf_reg_to_regnum_or_error on purpose.
3686 We'd rather print *something* here than throw an error. */
3687 regnum
= dwarf_reg_to_regnum (gdbarch
, dwarf_regnum
);
3688 /* gdbarch_register_name may just return "", return something more
3689 descriptive for bad register numbers. */
3692 /* The text is output as "$bad_register_number".
3693 That is why we use the underscores. */
3694 return _("bad_register_number");
3696 return gdbarch_register_name (gdbarch
, regnum
);
3699 /* Nicely describe a single piece of a location, returning an updated
3700 position in the bytecode sequence. This function cannot recognize
3701 all locations; if a location is not recognized, it simply returns
3702 DATA. If there is an error during reading, e.g. we run off the end
3703 of the buffer, an error is thrown. */
3705 static const gdb_byte
*
3706 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3707 CORE_ADDR addr
, dwarf2_per_cu_data
*per_cu
,
3708 dwarf2_per_objfile
*per_objfile
,
3709 const gdb_byte
*data
, const gdb_byte
*end
,
3710 unsigned int addr_size
)
3712 objfile
*objfile
= per_objfile
->objfile
;
3713 struct gdbarch
*gdbarch
= objfile
->arch ();
3716 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3718 fprintf_filtered (stream
, _("a variable in $%s"),
3719 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3722 else if (data
[0] == DW_OP_regx
)
3726 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3727 fprintf_filtered (stream
, _("a variable in $%s"),
3728 locexpr_regname (gdbarch
, reg
));
3730 else if (data
[0] == DW_OP_fbreg
)
3732 const struct block
*b
;
3733 struct symbol
*framefunc
;
3735 int64_t frame_offset
;
3736 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3738 int64_t base_offset
= 0;
3740 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3741 if (!piece_end_p (new_data
, end
))
3745 b
= block_for_pc (addr
);
3748 error (_("No block found for address for symbol \"%s\"."),
3749 symbol
->print_name ());
3751 framefunc
= block_linkage_function (b
);
3754 error (_("No function found for block for symbol \"%s\"."),
3755 symbol
->print_name ());
3757 func_get_frame_base_dwarf_block (framefunc
, addr
, &base_data
, &base_size
);
3759 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3761 const gdb_byte
*buf_end
;
3763 frame_reg
= base_data
[0] - DW_OP_breg0
;
3764 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3766 if (buf_end
!= base_data
+ base_size
)
3767 error (_("Unexpected opcode after "
3768 "DW_OP_breg%u for symbol \"%s\"."),
3769 frame_reg
, symbol
->print_name ());
3771 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3773 /* The frame base is just the register, with no offset. */
3774 frame_reg
= base_data
[0] - DW_OP_reg0
;
3779 /* We don't know what to do with the frame base expression,
3780 so we can't trace this variable; give up. */
3784 fprintf_filtered (stream
,
3785 _("a variable at frame base reg $%s offset %s+%s"),
3786 locexpr_regname (gdbarch
, frame_reg
),
3787 plongest (base_offset
), plongest (frame_offset
));
3789 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3790 && piece_end_p (data
, end
))
3794 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3796 fprintf_filtered (stream
,
3797 _("a variable at offset %s from base reg $%s"),
3799 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3802 /* The location expression for a TLS variable looks like this (on a
3805 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3806 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3808 0x3 is the encoding for DW_OP_addr, which has an operand as long
3809 as the size of an address on the target machine (here is 8
3810 bytes). Note that more recent version of GCC emit DW_OP_const4u
3811 or DW_OP_const8u, depending on address size, rather than
3812 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3813 The operand represents the offset at which the variable is within
3814 the thread local storage. */
3816 else if (data
+ 1 + addr_size
< end
3817 && (data
[0] == DW_OP_addr
3818 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3819 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3820 && (data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3821 || data
[1 + addr_size
] == DW_OP_form_tls_address
)
3822 && piece_end_p (data
+ 2 + addr_size
, end
))
3825 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3826 gdbarch_byte_order (gdbarch
));
3828 fprintf_filtered (stream
,
3829 _("a thread-local variable at offset 0x%s "
3830 "in the thread-local storage for `%s'"),
3831 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3833 data
+= 1 + addr_size
+ 1;
3836 /* With -gsplit-dwarf a TLS variable can also look like this:
3837 DW_AT_location : 3 byte block: fc 4 e0
3838 (DW_OP_GNU_const_index: 4;
3839 DW_OP_GNU_push_tls_address) */
3840 else if (data
+ 3 <= end
3841 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3842 && data
[0] == DW_OP_GNU_const_index
3844 && (data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3845 || data
[1 + leb128_size
] == DW_OP_form_tls_address
)
3846 && piece_end_p (data
+ 2 + leb128_size
, end
))
3850 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3851 offset
= dwarf2_read_addr_index (per_cu
, per_objfile
, offset
);
3852 fprintf_filtered (stream
,
3853 _("a thread-local variable at offset 0x%s "
3854 "in the thread-local storage for `%s'"),
3855 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3859 else if (data
[0] >= DW_OP_lit0
3860 && data
[0] <= DW_OP_lit31
3862 && data
[1] == DW_OP_stack_value
)
3864 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3871 /* Disassemble an expression, stopping at the end of a piece or at the
3872 end of the expression. Returns a pointer to the next unread byte
3873 in the input expression. If ALL is nonzero, then this function
3874 will keep going until it reaches the end of the expression.
3875 If there is an error during reading, e.g. we run off the end
3876 of the buffer, an error is thrown. */
3878 static const gdb_byte
*
3879 disassemble_dwarf_expression (struct ui_file
*stream
,
3880 struct gdbarch
*arch
, unsigned int addr_size
,
3881 int offset_size
, const gdb_byte
*start
,
3882 const gdb_byte
*data
, const gdb_byte
*end
,
3883 int indent
, int all
,
3884 dwarf2_per_cu_data
*per_cu
,
3885 dwarf2_per_objfile
*per_objfile
)
3889 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3891 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *data
++;
3896 name
= get_DW_OP_name (op
);
3899 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3900 op
, (long) (data
- 1 - start
));
3901 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3902 (long) (data
- 1 - start
), name
);
3907 ul
= extract_unsigned_integer (data
, addr_size
,
3908 gdbarch_byte_order (arch
));
3910 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3914 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3916 fprintf_filtered (stream
, " %s", pulongest (ul
));
3919 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3921 fprintf_filtered (stream
, " %s", plongest (l
));
3924 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3926 fprintf_filtered (stream
, " %s", pulongest (ul
));
3929 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3931 fprintf_filtered (stream
, " %s", plongest (l
));
3934 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3936 fprintf_filtered (stream
, " %s", pulongest (ul
));
3939 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3941 fprintf_filtered (stream
, " %s", plongest (l
));
3944 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3946 fprintf_filtered (stream
, " %s", pulongest (ul
));
3949 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3951 fprintf_filtered (stream
, " %s", plongest (l
));
3954 data
= safe_read_uleb128 (data
, end
, &ul
);
3955 fprintf_filtered (stream
, " %s", pulongest (ul
));
3958 data
= safe_read_sleb128 (data
, end
, &l
);
3959 fprintf_filtered (stream
, " %s", plongest (l
));
3994 fprintf_filtered (stream
, " [$%s]",
3995 locexpr_regname (arch
, op
- DW_OP_reg0
));
3999 data
= safe_read_uleb128 (data
, end
, &ul
);
4000 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
4001 locexpr_regname (arch
, (int) ul
));
4004 case DW_OP_implicit_value
:
4005 data
= safe_read_uleb128 (data
, end
, &ul
);
4007 fprintf_filtered (stream
, " %s", pulongest (ul
));
4042 data
= safe_read_sleb128 (data
, end
, &l
);
4043 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
4044 locexpr_regname (arch
, op
- DW_OP_breg0
));
4048 data
= safe_read_uleb128 (data
, end
, &ul
);
4049 data
= safe_read_sleb128 (data
, end
, &l
);
4050 fprintf_filtered (stream
, " register %s [$%s] offset %s",
4052 locexpr_regname (arch
, (int) ul
),
4057 data
= safe_read_sleb128 (data
, end
, &l
);
4058 fprintf_filtered (stream
, " %s", plongest (l
));
4061 case DW_OP_xderef_size
:
4062 case DW_OP_deref_size
:
4064 fprintf_filtered (stream
, " %d", *data
);
4068 case DW_OP_plus_uconst
:
4069 data
= safe_read_uleb128 (data
, end
, &ul
);
4070 fprintf_filtered (stream
, " %s", pulongest (ul
));
4074 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4076 fprintf_filtered (stream
, " to %ld",
4077 (long) (data
+ l
- start
));
4081 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4083 fprintf_filtered (stream
, " %ld",
4084 (long) (data
+ l
- start
));
4088 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
4090 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
4094 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4096 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4099 case DW_OP_call_ref
:
4100 ul
= extract_unsigned_integer (data
, offset_size
,
4101 gdbarch_byte_order (arch
));
4102 data
+= offset_size
;
4103 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4107 data
= safe_read_uleb128 (data
, end
, &ul
);
4108 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
4111 case DW_OP_bit_piece
:
4115 data
= safe_read_uleb128 (data
, end
, &ul
);
4116 data
= safe_read_uleb128 (data
, end
, &offset
);
4117 fprintf_filtered (stream
, " size %s offset %s (bits)",
4118 pulongest (ul
), pulongest (offset
));
4122 case DW_OP_implicit_pointer
:
4123 case DW_OP_GNU_implicit_pointer
:
4125 ul
= extract_unsigned_integer (data
, offset_size
,
4126 gdbarch_byte_order (arch
));
4127 data
+= offset_size
;
4129 data
= safe_read_sleb128 (data
, end
, &l
);
4131 fprintf_filtered (stream
, " DIE %s offset %s",
4132 phex_nz (ul
, offset_size
),
4137 case DW_OP_deref_type
:
4138 case DW_OP_GNU_deref_type
:
4140 int deref_addr_size
= *data
++;
4143 data
= safe_read_uleb128 (data
, end
, &ul
);
4144 cu_offset offset
= (cu_offset
) ul
;
4145 type
= dwarf2_get_die_type (offset
, per_cu
);
4146 fprintf_filtered (stream
, "<");
4147 type_print (type
, "", stream
, -1);
4148 fprintf_filtered (stream
, " [0x%s]> %d",
4149 phex_nz (to_underlying (offset
), 0),
4154 case DW_OP_const_type
:
4155 case DW_OP_GNU_const_type
:
4159 data
= safe_read_uleb128 (data
, end
, &ul
);
4160 cu_offset type_die
= (cu_offset
) ul
;
4161 type
= dwarf2_get_die_type (type_die
, per_cu
);
4162 fprintf_filtered (stream
, "<");
4163 type_print (type
, "", stream
, -1);
4164 fprintf_filtered (stream
, " [0x%s]>",
4165 phex_nz (to_underlying (type_die
), 0));
4168 fprintf_filtered (stream
, " %d byte block:", n
);
4169 for (int i
= 0; i
< n
; ++i
)
4170 fprintf_filtered (stream
, " %02x", data
[i
]);
4175 case DW_OP_regval_type
:
4176 case DW_OP_GNU_regval_type
:
4181 data
= safe_read_uleb128 (data
, end
, ®
);
4182 data
= safe_read_uleb128 (data
, end
, &ul
);
4183 cu_offset type_die
= (cu_offset
) ul
;
4185 type
= dwarf2_get_die_type (type_die
, per_cu
);
4186 fprintf_filtered (stream
, "<");
4187 type_print (type
, "", stream
, -1);
4188 fprintf_filtered (stream
, " [0x%s]> [$%s]",
4189 phex_nz (to_underlying (type_die
), 0),
4190 locexpr_regname (arch
, reg
));
4195 case DW_OP_GNU_convert
:
4196 case DW_OP_reinterpret
:
4197 case DW_OP_GNU_reinterpret
:
4199 data
= safe_read_uleb128 (data
, end
, &ul
);
4200 cu_offset type_die
= (cu_offset
) ul
;
4202 if (to_underlying (type_die
) == 0)
4203 fprintf_filtered (stream
, "<0>");
4208 type
= dwarf2_get_die_type (type_die
, per_cu
);
4209 fprintf_filtered (stream
, "<");
4210 type_print (type
, "", stream
, -1);
4211 fprintf_filtered (stream
, " [0x%s]>",
4212 phex_nz (to_underlying (type_die
), 0));
4217 case DW_OP_entry_value
:
4218 case DW_OP_GNU_entry_value
:
4219 data
= safe_read_uleb128 (data
, end
, &ul
);
4220 fputc_filtered ('\n', stream
);
4221 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
4222 start
, data
, data
+ ul
, indent
+ 2,
4223 all
, per_cu
, per_objfile
);
4227 case DW_OP_GNU_parameter_ref
:
4228 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4230 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4234 case DW_OP_GNU_addr_index
:
4235 data
= safe_read_uleb128 (data
, end
, &ul
);
4236 ul
= dwarf2_read_addr_index (per_cu
, per_objfile
, ul
);
4237 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
4239 case DW_OP_GNU_const_index
:
4240 data
= safe_read_uleb128 (data
, end
, &ul
);
4241 ul
= dwarf2_read_addr_index (per_cu
, per_objfile
, ul
);
4242 fprintf_filtered (stream
, " %s", pulongest (ul
));
4245 case DW_OP_GNU_variable_value
:
4246 ul
= extract_unsigned_integer (data
, offset_size
,
4247 gdbarch_byte_order (arch
));
4248 data
+= offset_size
;
4249 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4253 fprintf_filtered (stream
, "\n");
4259 static bool dwarf_always_disassemble
;
4262 show_dwarf_always_disassemble (struct ui_file
*file
, int from_tty
,
4263 struct cmd_list_element
*c
, const char *value
)
4265 fprintf_filtered (file
,
4266 _("Whether to always disassemble "
4267 "DWARF expressions is %s.\n"),
4271 /* Describe a single location, which may in turn consist of multiple
4275 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
4276 struct ui_file
*stream
,
4277 const gdb_byte
*data
, size_t size
,
4278 unsigned int addr_size
,
4279 int offset_size
, dwarf2_per_cu_data
*per_cu
,
4280 dwarf2_per_objfile
*per_objfile
)
4282 const gdb_byte
*end
= data
+ size
;
4283 int first_piece
= 1, bad
= 0;
4284 objfile
*objfile
= per_objfile
->objfile
;
4288 const gdb_byte
*here
= data
;
4289 int disassemble
= 1;
4294 fprintf_filtered (stream
, _(", and "));
4296 if (!dwarf_always_disassemble
)
4298 data
= locexpr_describe_location_piece (symbol
, stream
,
4299 addr
, per_cu
, per_objfile
,
4300 data
, end
, addr_size
);
4301 /* If we printed anything, or if we have an empty piece,
4302 then don't disassemble. */
4304 || data
[0] == DW_OP_piece
4305 || data
[0] == DW_OP_bit_piece
)
4310 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
4311 data
= disassemble_dwarf_expression (stream
,
4313 addr_size
, offset_size
, data
,
4315 dwarf_always_disassemble
,
4316 per_cu
, per_objfile
);
4321 int empty
= data
== here
;
4324 fprintf_filtered (stream
, " ");
4325 if (data
[0] == DW_OP_piece
)
4329 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
4332 fprintf_filtered (stream
, _("an empty %s-byte piece"),
4335 fprintf_filtered (stream
, _(" [%s-byte piece]"),
4338 else if (data
[0] == DW_OP_bit_piece
)
4340 uint64_t bits
, offset
;
4342 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
4343 data
= safe_read_uleb128 (data
, end
, &offset
);
4346 fprintf_filtered (stream
,
4347 _("an empty %s-bit piece"),
4350 fprintf_filtered (stream
,
4351 _(" [%s-bit piece, offset %s bits]"),
4352 pulongest (bits
), pulongest (offset
));
4362 if (bad
|| data
> end
)
4363 error (_("Corrupted DWARF2 expression for \"%s\"."),
4364 symbol
->print_name ());
4367 /* Print a natural-language description of SYMBOL to STREAM. This
4368 version is for a symbol with a single location. */
4371 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4372 struct ui_file
*stream
)
4374 struct dwarf2_locexpr_baton
*dlbaton
4375 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4376 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4377 int offset_size
= dlbaton
->per_cu
->offset_size ();
4379 locexpr_describe_location_1 (symbol
, addr
, stream
,
4380 dlbaton
->data
, dlbaton
->size
,
4381 addr_size
, offset_size
,
4382 dlbaton
->per_cu
, dlbaton
->per_objfile
);
4385 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4386 any necessary bytecode in AX. */
4389 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
4390 struct axs_value
*value
)
4392 struct dwarf2_locexpr_baton
*dlbaton
4393 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4394 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4396 if (dlbaton
->size
== 0)
4397 value
->optimized_out
= 1;
4399 dwarf2_compile_expr_to_ax (ax
, value
, addr_size
, dlbaton
->data
,
4400 dlbaton
->data
+ dlbaton
->size
, dlbaton
->per_cu
,
4401 dlbaton
->per_objfile
);
4404 /* symbol_computed_ops 'generate_c_location' method. */
4407 locexpr_generate_c_location (struct symbol
*sym
, string_file
*stream
,
4408 struct gdbarch
*gdbarch
,
4409 unsigned char *registers_used
,
4410 CORE_ADDR pc
, const char *result_name
)
4412 struct dwarf2_locexpr_baton
*dlbaton
4413 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (sym
);
4414 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4416 if (dlbaton
->size
== 0)
4417 error (_("symbol \"%s\" is optimized out"), sym
->natural_name ());
4419 compile_dwarf_expr_to_c (stream
, result_name
,
4420 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4421 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4422 dlbaton
->per_cu
, dlbaton
->per_objfile
);
4425 /* The set of location functions used with the DWARF-2 expression
4427 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4428 locexpr_read_variable
,
4429 locexpr_read_variable_at_entry
,
4430 locexpr_get_symbol_read_needs
,
4431 locexpr_describe_location
,
4432 0, /* location_has_loclist */
4433 locexpr_tracepoint_var_ref
,
4434 locexpr_generate_c_location
4438 /* Wrapper functions for location lists. These generally find
4439 the appropriate location expression and call something above. */
4441 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4442 evaluator to calculate the location. */
4443 static struct value
*
4444 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4446 struct dwarf2_loclist_baton
*dlbaton
4447 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4449 const gdb_byte
*data
;
4451 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4453 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4454 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4460 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4461 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4464 Function always returns non-NULL value, it may be marked optimized out if
4465 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4466 if it cannot resolve the parameter for any reason. */
4468 static struct value
*
4469 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4471 struct dwarf2_loclist_baton
*dlbaton
4472 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4473 const gdb_byte
*data
;
4477 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4478 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4480 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4482 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4484 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4487 /* Implementation of get_symbol_read_needs from
4488 symbol_computed_ops. */
4490 static enum symbol_needs_kind
4491 loclist_symbol_needs (struct symbol
*symbol
)
4493 /* If there's a location list, then assume we need to have a frame
4494 to choose the appropriate location expression. With tracking of
4495 global variables this is not necessarily true, but such tracking
4496 is disabled in GCC at the moment until we figure out how to
4499 return SYMBOL_NEEDS_FRAME
;
4502 /* Print a natural-language description of SYMBOL to STREAM. This
4503 version applies when there is a list of different locations, each
4504 with a specified address range. */
4507 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4508 struct ui_file
*stream
)
4510 struct dwarf2_loclist_baton
*dlbaton
4511 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4512 const gdb_byte
*loc_ptr
, *buf_end
;
4513 dwarf2_per_objfile
*per_objfile
= dlbaton
->per_objfile
;
4514 struct objfile
*objfile
= per_objfile
->objfile
;
4515 struct gdbarch
*gdbarch
= objfile
->arch ();
4516 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4517 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4518 int offset_size
= dlbaton
->per_cu
->offset_size ();
4519 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4520 /* Adjust base_address for relocatable objects. */
4521 CORE_ADDR base_offset
= objfile
->text_section_offset ();
4522 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4525 loc_ptr
= dlbaton
->data
;
4526 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4528 fprintf_filtered (stream
, _("multi-location:\n"));
4530 /* Iterate through locations until we run out. */
4533 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4535 enum debug_loc_kind kind
;
4536 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4538 if (dlbaton
->per_cu
->version () < 5 && dlbaton
->from_dwo
)
4539 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4540 dlbaton
->per_objfile
,
4541 loc_ptr
, buf_end
, &new_ptr
,
4542 &low
, &high
, byte_order
);
4543 else if (dlbaton
->per_cu
->version () < 5)
4544 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4546 byte_order
, addr_size
,
4549 kind
= decode_debug_loclists_addresses (dlbaton
->per_cu
,
4550 dlbaton
->per_objfile
,
4551 loc_ptr
, buf_end
, &new_ptr
,
4552 &low
, &high
, byte_order
,
4553 addr_size
, signed_addr_p
);
4557 case DEBUG_LOC_END_OF_LIST
:
4560 case DEBUG_LOC_BASE_ADDRESS
:
4561 base_address
= high
+ base_offset
;
4562 fprintf_filtered (stream
, _(" Base address %s"),
4563 paddress (gdbarch
, base_address
));
4565 case DEBUG_LOC_START_END
:
4566 case DEBUG_LOC_START_LENGTH
:
4567 case DEBUG_LOC_OFFSET_PAIR
:
4569 case DEBUG_LOC_BUFFER_OVERFLOW
:
4570 case DEBUG_LOC_INVALID_ENTRY
:
4571 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4572 symbol
->print_name ());
4574 gdb_assert_not_reached ("bad debug_loc_kind");
4577 /* Otherwise, a location expression entry. */
4578 low
+= base_address
;
4579 high
+= base_address
;
4581 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
);
4582 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
);
4584 if (dlbaton
->per_cu
->version () < 5)
4586 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4591 unsigned int bytes_read
;
4592 length
= read_unsigned_leb128 (NULL
, loc_ptr
, &bytes_read
);
4593 loc_ptr
+= bytes_read
;
4596 /* (It would improve readability to print only the minimum
4597 necessary digits of the second number of the range.) */
4598 fprintf_filtered (stream
, _(" Range %s-%s: "),
4599 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4601 /* Now describe this particular location. */
4602 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4603 addr_size
, offset_size
,
4604 dlbaton
->per_cu
, dlbaton
->per_objfile
);
4606 fprintf_filtered (stream
, "\n");
4612 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4613 any necessary bytecode in AX. */
4615 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
4616 struct axs_value
*value
)
4618 struct dwarf2_loclist_baton
*dlbaton
4619 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4620 const gdb_byte
*data
;
4622 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4624 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4626 value
->optimized_out
= 1;
4628 dwarf2_compile_expr_to_ax (ax
, value
, addr_size
, data
, data
+ size
,
4629 dlbaton
->per_cu
, dlbaton
->per_objfile
);
4632 /* symbol_computed_ops 'generate_c_location' method. */
4635 loclist_generate_c_location (struct symbol
*sym
, string_file
*stream
,
4636 struct gdbarch
*gdbarch
,
4637 unsigned char *registers_used
,
4638 CORE_ADDR pc
, const char *result_name
)
4640 struct dwarf2_loclist_baton
*dlbaton
4641 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (sym
);
4642 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4643 const gdb_byte
*data
;
4646 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4648 error (_("symbol \"%s\" is optimized out"), sym
->natural_name ());
4650 compile_dwarf_expr_to_c (stream
, result_name
,
4651 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4654 dlbaton
->per_objfile
);
4657 /* The set of location functions used with the DWARF-2 expression
4658 evaluator and location lists. */
4659 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4660 loclist_read_variable
,
4661 loclist_read_variable_at_entry
,
4662 loclist_symbol_needs
,
4663 loclist_describe_location
,
4664 1, /* location_has_loclist */
4665 loclist_tracepoint_var_ref
,
4666 loclist_generate_c_location
4669 void _initialize_dwarf2loc ();
4671 _initialize_dwarf2loc ()
4673 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4674 &entry_values_debug
,
4675 _("Set entry values and tail call frames "
4677 _("Show entry values and tail call frames "
4679 _("When non-zero, the process of determining "
4680 "parameter values from function entry point "
4681 "and tail call frames will be printed."),
4683 show_entry_values_debug
,
4684 &setdebuglist
, &showdebuglist
);
4686 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
4687 &dwarf_always_disassemble
, _("\
4688 Set whether `info address' always disassembles DWARF expressions."), _("\
4689 Show whether `info address' always disassembles DWARF expressions."), _("\
4690 When enabled, DWARF expressions are always printed in an assembly-like\n\
4691 syntax. When disabled, expressions will be printed in a more\n\
4692 conversational style, when possible."),
4694 show_dwarf_always_disassemble
,
4696 &show_dwarf_cmdlist
);