1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003-2019 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 "dwarf2expr.h"
38 #include "dwarf2loc.h"
39 #include "dwarf2read.h"
40 #include "dwarf2-frame.h"
41 #include "compile/compile.h"
42 #include "gdbsupport/selftest.h"
45 #include <unordered_set>
46 #include "gdbsupport/underlying.h"
47 #include "gdbsupport/byte-vector.h"
49 static struct value
*dwarf2_evaluate_loc_desc_full (struct type
*type
,
50 struct frame_info
*frame
,
53 struct dwarf2_per_cu_data
*per_cu
,
54 struct type
*subobj_type
,
55 LONGEST subobj_byte_offset
);
57 static struct call_site_parameter
*dwarf_expr_reg_to_entry_parameter
58 (struct frame_info
*frame
,
59 enum call_site_parameter_kind kind
,
60 union call_site_parameter_u kind_u
,
61 struct dwarf2_per_cu_data
**per_cu_return
);
63 static struct value
*indirect_synthetic_pointer
64 (sect_offset die
, LONGEST byte_offset
,
65 struct dwarf2_per_cu_data
*per_cu
,
66 struct frame_info
*frame
,
67 struct type
*type
, bool resolve_abstract_p
= false);
69 /* Until these have formal names, we define these here.
70 ref: http://gcc.gnu.org/wiki/DebugFission
71 Each entry in .debug_loc.dwo begins with a byte that describes the entry,
72 and is then followed by data specific to that entry. */
76 /* Indicates the end of the list of entries. */
77 DEBUG_LOC_END_OF_LIST
= 0,
79 /* This is followed by an unsigned LEB128 number that is an index into
80 .debug_addr and specifies the base address for all following entries. */
81 DEBUG_LOC_BASE_ADDRESS
= 1,
83 /* This is followed by two unsigned LEB128 numbers that are indices into
84 .debug_addr and specify the beginning and ending addresses, and then
85 a normal location expression as in .debug_loc. */
86 DEBUG_LOC_START_END
= 2,
88 /* This is followed by an unsigned LEB128 number that is an index into
89 .debug_addr and specifies the beginning address, and a 4 byte unsigned
90 number that specifies the length, and then a normal location expression
92 DEBUG_LOC_START_LENGTH
= 3,
94 /* An internal value indicating there is insufficient data. */
95 DEBUG_LOC_BUFFER_OVERFLOW
= -1,
97 /* An internal value indicating an invalid kind of entry was found. */
98 DEBUG_LOC_INVALID_ENTRY
= -2
101 /* Helper function which throws an error if a synthetic pointer is
105 invalid_synthetic_pointer (void)
107 error (_("access outside bounds of object "
108 "referenced via synthetic pointer"));
111 /* Decode the addresses in a non-dwo .debug_loc entry.
112 A pointer to the next byte to examine is returned in *NEW_PTR.
113 The encoded low,high addresses are return in *LOW,*HIGH.
114 The result indicates the kind of entry found. */
116 static enum debug_loc_kind
117 decode_debug_loc_addresses (const gdb_byte
*loc_ptr
, const gdb_byte
*buf_end
,
118 const gdb_byte
**new_ptr
,
119 CORE_ADDR
*low
, CORE_ADDR
*high
,
120 enum bfd_endian byte_order
,
121 unsigned int addr_size
,
124 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
126 if (buf_end
- loc_ptr
< 2 * addr_size
)
127 return DEBUG_LOC_BUFFER_OVERFLOW
;
130 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
132 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
133 loc_ptr
+= addr_size
;
136 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
138 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
139 loc_ptr
+= addr_size
;
143 /* A base-address-selection entry. */
144 if ((*low
& base_mask
) == base_mask
)
145 return DEBUG_LOC_BASE_ADDRESS
;
147 /* An end-of-list entry. */
148 if (*low
== 0 && *high
== 0)
149 return DEBUG_LOC_END_OF_LIST
;
151 return DEBUG_LOC_START_END
;
154 /* Decode the addresses in .debug_loclists entry.
155 A pointer to the next byte to examine is returned in *NEW_PTR.
156 The encoded low,high addresses are return in *LOW,*HIGH.
157 The result indicates the kind of entry found. */
159 static enum debug_loc_kind
160 decode_debug_loclists_addresses (struct dwarf2_per_cu_data
*per_cu
,
161 const gdb_byte
*loc_ptr
,
162 const gdb_byte
*buf_end
,
163 const gdb_byte
**new_ptr
,
164 CORE_ADDR
*low
, CORE_ADDR
*high
,
165 enum bfd_endian byte_order
,
166 unsigned int addr_size
,
171 if (loc_ptr
== buf_end
)
172 return DEBUG_LOC_BUFFER_OVERFLOW
;
176 case DW_LLE_end_of_list
:
178 return DEBUG_LOC_END_OF_LIST
;
179 case DW_LLE_base_address
:
180 if (loc_ptr
+ addr_size
> buf_end
)
181 return DEBUG_LOC_BUFFER_OVERFLOW
;
183 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
185 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
186 loc_ptr
+= addr_size
;
188 return DEBUG_LOC_BASE_ADDRESS
;
189 case DW_LLE_offset_pair
:
190 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
192 return DEBUG_LOC_BUFFER_OVERFLOW
;
194 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
196 return DEBUG_LOC_BUFFER_OVERFLOW
;
199 return DEBUG_LOC_START_END
;
201 return DEBUG_LOC_INVALID_ENTRY
;
205 /* Decode the addresses in .debug_loc.dwo entry.
206 A pointer to the next byte to examine is returned in *NEW_PTR.
207 The encoded low,high addresses are return in *LOW,*HIGH.
208 The result indicates the kind of entry found. */
210 static enum debug_loc_kind
211 decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data
*per_cu
,
212 const gdb_byte
*loc_ptr
,
213 const gdb_byte
*buf_end
,
214 const gdb_byte
**new_ptr
,
215 CORE_ADDR
*low
, CORE_ADDR
*high
,
216 enum bfd_endian byte_order
)
218 uint64_t low_index
, high_index
;
220 if (loc_ptr
== buf_end
)
221 return DEBUG_LOC_BUFFER_OVERFLOW
;
225 case DW_LLE_GNU_end_of_list_entry
:
227 return DEBUG_LOC_END_OF_LIST
;
228 case DW_LLE_GNU_base_address_selection_entry
:
230 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
232 return DEBUG_LOC_BUFFER_OVERFLOW
;
233 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
235 return DEBUG_LOC_BASE_ADDRESS
;
236 case DW_LLE_GNU_start_end_entry
:
237 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
239 return DEBUG_LOC_BUFFER_OVERFLOW
;
240 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
241 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
243 return DEBUG_LOC_BUFFER_OVERFLOW
;
244 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
246 return DEBUG_LOC_START_END
;
247 case DW_LLE_GNU_start_length_entry
:
248 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
250 return DEBUG_LOC_BUFFER_OVERFLOW
;
251 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
252 if (loc_ptr
+ 4 > buf_end
)
253 return DEBUG_LOC_BUFFER_OVERFLOW
;
255 *high
+= extract_unsigned_integer (loc_ptr
, 4, byte_order
);
256 *new_ptr
= loc_ptr
+ 4;
257 return DEBUG_LOC_START_LENGTH
;
259 return DEBUG_LOC_INVALID_ENTRY
;
263 /* A function for dealing with location lists. Given a
264 symbol baton (BATON) and a pc value (PC), find the appropriate
265 location expression, set *LOCEXPR_LENGTH, and return a pointer
266 to the beginning of the expression. Returns NULL on failure.
268 For now, only return the first matching location expression; there
269 can be more than one in the list. */
272 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
273 size_t *locexpr_length
, CORE_ADDR pc
)
275 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
276 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
277 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
278 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
279 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
280 /* Adjust base_address for relocatable objects. */
281 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (baton
->per_cu
);
282 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
283 const gdb_byte
*loc_ptr
, *buf_end
;
285 loc_ptr
= baton
->data
;
286 buf_end
= baton
->data
+ baton
->size
;
290 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
292 enum debug_loc_kind kind
;
293 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
296 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
297 loc_ptr
, buf_end
, &new_ptr
,
298 &low
, &high
, byte_order
);
299 else if (dwarf2_version (baton
->per_cu
) < 5)
300 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
302 byte_order
, addr_size
,
305 kind
= decode_debug_loclists_addresses (baton
->per_cu
,
306 loc_ptr
, buf_end
, &new_ptr
,
307 &low
, &high
, byte_order
,
308 addr_size
, signed_addr_p
);
313 case DEBUG_LOC_END_OF_LIST
:
316 case DEBUG_LOC_BASE_ADDRESS
:
317 base_address
= high
+ base_offset
;
319 case DEBUG_LOC_START_END
:
320 case DEBUG_LOC_START_LENGTH
:
322 case DEBUG_LOC_BUFFER_OVERFLOW
:
323 case DEBUG_LOC_INVALID_ENTRY
:
324 error (_("dwarf2_find_location_expression: "
325 "Corrupted DWARF expression."));
327 gdb_assert_not_reached ("bad debug_loc_kind");
330 /* Otherwise, a location expression entry.
331 If the entry is from a DWO, don't add base address: the entry is from
332 .debug_addr which already has the DWARF "base address". We still add
333 base_offset in case we're debugging a PIE executable. */
342 high
+= base_address
;
345 if (dwarf2_version (baton
->per_cu
) < 5)
347 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
352 unsigned int bytes_read
;
354 length
= read_unsigned_leb128 (NULL
, loc_ptr
, &bytes_read
);
355 loc_ptr
+= bytes_read
;
358 if (low
== high
&& pc
== low
)
360 /* This is entry PC record present only at entry point
361 of a function. Verify it is really the function entry point. */
363 const struct block
*pc_block
= block_for_pc (pc
);
364 struct symbol
*pc_func
= NULL
;
367 pc_func
= block_linkage_function (pc_block
);
369 if (pc_func
&& pc
== BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (pc_func
)))
371 *locexpr_length
= length
;
376 if (pc
>= low
&& pc
< high
)
378 *locexpr_length
= length
;
386 /* This is the baton used when performing dwarf2 expression
388 struct dwarf_expr_baton
390 struct frame_info
*frame
;
391 struct dwarf2_per_cu_data
*per_cu
;
392 CORE_ADDR obj_address
;
395 /* Implement find_frame_base_location method for LOC_BLOCK functions using
396 DWARF expression for its DW_AT_frame_base. */
399 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
400 const gdb_byte
**start
, size_t *length
)
402 struct dwarf2_locexpr_baton
*symbaton
403 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
405 *length
= symbaton
->size
;
406 *start
= symbaton
->data
;
409 /* Implement the struct symbol_block_ops::get_frame_base method for
410 LOC_BLOCK functions using a DWARF expression as its DW_AT_frame_base. */
413 locexpr_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
415 struct gdbarch
*gdbarch
;
417 struct dwarf2_locexpr_baton
*dlbaton
;
418 const gdb_byte
*start
;
420 struct value
*result
;
422 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
423 Thus, it's supposed to provide the find_frame_base_location method as
425 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
427 gdbarch
= get_frame_arch (frame
);
428 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
429 dlbaton
= (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
431 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
432 (framefunc
, get_frame_pc (frame
), &start
, &length
);
433 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
436 /* The DW_AT_frame_base attribute contains a location description which
437 computes the base address itself. However, the call to
438 dwarf2_evaluate_loc_desc returns a value representing a variable at
439 that address. The frame base address is thus this variable's
441 return value_address (result
);
444 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
445 function uses DWARF expression for its DW_AT_frame_base. */
447 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
449 locexpr_find_frame_base_location
,
450 locexpr_get_frame_base
453 /* Implement find_frame_base_location method for LOC_BLOCK functions using
454 DWARF location list for its DW_AT_frame_base. */
457 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
458 const gdb_byte
**start
, size_t *length
)
460 struct dwarf2_loclist_baton
*symbaton
461 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
463 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
466 /* Implement the struct symbol_block_ops::get_frame_base method for
467 LOC_BLOCK functions using a DWARF location list as its DW_AT_frame_base. */
470 loclist_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
472 struct gdbarch
*gdbarch
;
474 struct dwarf2_loclist_baton
*dlbaton
;
475 const gdb_byte
*start
;
477 struct value
*result
;
479 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
480 Thus, it's supposed to provide the find_frame_base_location method as
482 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
484 gdbarch
= get_frame_arch (frame
);
485 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
486 dlbaton
= (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
488 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
489 (framefunc
, get_frame_pc (frame
), &start
, &length
);
490 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
493 /* The DW_AT_frame_base attribute contains a location description which
494 computes the base address itself. However, the call to
495 dwarf2_evaluate_loc_desc returns a value representing a variable at
496 that address. The frame base address is thus this variable's
498 return value_address (result
);
501 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
502 function uses DWARF location list for its DW_AT_frame_base. */
504 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
506 loclist_find_frame_base_location
,
507 loclist_get_frame_base
510 /* See dwarf2loc.h. */
513 func_get_frame_base_dwarf_block (struct symbol
*framefunc
, CORE_ADDR pc
,
514 const gdb_byte
**start
, size_t *length
)
516 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
518 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
520 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
526 error (_("Could not find the frame base for \"%s\"."),
527 SYMBOL_NATURAL_NAME (framefunc
));
531 get_frame_pc_for_per_cu_dwarf_call (void *baton
)
533 dwarf_expr_context
*ctx
= (dwarf_expr_context
*) baton
;
535 return ctx
->get_frame_pc ();
539 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
540 struct dwarf2_per_cu_data
*per_cu
)
542 struct dwarf2_locexpr_baton block
;
544 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
,
545 get_frame_pc_for_per_cu_dwarf_call
,
548 /* DW_OP_call_ref is currently not supported. */
549 gdb_assert (block
.per_cu
== per_cu
);
551 ctx
->eval (block
.data
, block
.size
);
554 /* Given context CTX, section offset SECT_OFF, and compilation unit
555 data PER_CU, execute the "variable value" operation on the DIE
556 found at SECT_OFF. */
558 static struct value
*
559 sect_variable_value (struct dwarf_expr_context
*ctx
, sect_offset sect_off
,
560 struct dwarf2_per_cu_data
*per_cu
)
562 struct type
*die_type
= dwarf2_fetch_die_type_sect_off (sect_off
, per_cu
);
564 if (die_type
== NULL
)
565 error (_("Bad DW_OP_GNU_variable_value DIE."));
567 /* Note: Things still work when the following test is removed. This
568 test and error is here to conform to the proposed specification. */
569 if (TYPE_CODE (die_type
) != TYPE_CODE_INT
570 && TYPE_CODE (die_type
) != TYPE_CODE_PTR
)
571 error (_("Type of DW_OP_GNU_variable_value DIE must be an integer or pointer."));
573 struct type
*type
= lookup_pointer_type (die_type
);
574 struct frame_info
*frame
= get_selected_frame (_("No frame selected."));
575 return indirect_synthetic_pointer (sect_off
, 0, per_cu
, frame
, type
, true);
578 class dwarf_evaluate_loc_desc
: public dwarf_expr_context
582 struct frame_info
*frame
;
583 struct dwarf2_per_cu_data
*per_cu
;
584 CORE_ADDR obj_address
;
586 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
587 the frame in BATON. */
589 CORE_ADDR
get_frame_cfa () override
591 return dwarf2_frame_cfa (frame
);
594 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
595 the frame in BATON. */
597 CORE_ADDR
get_frame_pc () override
599 return get_frame_address_in_block (frame
);
602 /* Using the objfile specified in BATON, find the address for the
603 current thread's thread-local storage with offset OFFSET. */
604 CORE_ADDR
get_tls_address (CORE_ADDR offset
) override
606 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
608 return target_translate_tls_address (objfile
, offset
);
611 /* Helper interface of per_cu_dwarf_call for
612 dwarf2_evaluate_loc_desc. */
614 void dwarf_call (cu_offset die_offset
) override
616 per_cu_dwarf_call (this, die_offset
, per_cu
);
619 /* Helper interface of sect_variable_value for
620 dwarf2_evaluate_loc_desc. */
622 struct value
*dwarf_variable_value (sect_offset sect_off
) override
624 return sect_variable_value (this, sect_off
, per_cu
);
627 struct type
*get_base_type (cu_offset die_offset
, int size
) override
629 struct type
*result
= dwarf2_get_die_type (die_offset
, per_cu
);
631 error (_("Could not find type for DW_OP_const_type"));
632 if (size
!= 0 && TYPE_LENGTH (result
) != size
)
633 error (_("DW_OP_const_type has different sizes for type and data"));
637 /* Callback function for dwarf2_evaluate_loc_desc.
638 Fetch the address indexed by DW_OP_addrx or DW_OP_GNU_addr_index. */
640 CORE_ADDR
get_addr_index (unsigned int index
) override
642 return dwarf2_read_addr_index (per_cu
, index
);
645 /* Callback function for get_object_address. Return the address of the VLA
648 CORE_ADDR
get_object_address () override
650 if (obj_address
== 0)
651 error (_("Location address is not set."));
655 /* Execute DWARF block of call_site_parameter which matches KIND and
656 KIND_U. Choose DEREF_SIZE value of that parameter. Search
657 caller of this objects's frame.
659 The caller can be from a different CU - per_cu_dwarf_call
660 implementation can be more simple as it does not support cross-CU
663 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
664 union call_site_parameter_u kind_u
,
665 int deref_size
) override
667 struct frame_info
*caller_frame
;
668 struct dwarf2_per_cu_data
*caller_per_cu
;
669 struct call_site_parameter
*parameter
;
670 const gdb_byte
*data_src
;
673 caller_frame
= get_prev_frame (frame
);
675 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
677 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
678 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
680 /* DEREF_SIZE size is not verified here. */
681 if (data_src
== NULL
)
682 throw_error (NO_ENTRY_VALUE_ERROR
,
683 _("Cannot resolve DW_AT_call_data_value"));
685 scoped_restore save_frame
= make_scoped_restore (&this->frame
,
687 scoped_restore save_per_cu
= make_scoped_restore (&this->per_cu
,
689 scoped_restore save_obj_addr
= make_scoped_restore (&this->obj_address
,
692 scoped_restore save_arch
= make_scoped_restore (&this->gdbarch
);
694 = get_objfile_arch (dwarf2_per_cu_objfile (per_cu
));
695 scoped_restore save_addr_size
= make_scoped_restore (&this->addr_size
);
696 this->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
697 scoped_restore save_offset
= make_scoped_restore (&this->offset
);
698 this->offset
= dwarf2_per_cu_text_offset (per_cu
);
700 this->eval (data_src
, size
);
703 /* Using the frame specified in BATON, find the location expression
704 describing the frame base. Return a pointer to it in START and
705 its length in LENGTH. */
706 void get_frame_base (const gdb_byte
**start
, size_t * length
) override
708 /* FIXME: cagney/2003-03-26: This code should be using
709 get_frame_base_address(), and then implement a dwarf2 specific
711 struct symbol
*framefunc
;
712 const struct block
*bl
= get_frame_block (frame
, NULL
);
715 error (_("frame address is not available."));
717 /* Use block_linkage_function, which returns a real (not inlined)
718 function, instead of get_frame_function, which may return an
720 framefunc
= block_linkage_function (bl
);
722 /* If we found a frame-relative symbol then it was certainly within
723 some function associated with a frame. If we can't find the frame,
724 something has gone wrong. */
725 gdb_assert (framefunc
!= NULL
);
727 func_get_frame_base_dwarf_block (framefunc
,
728 get_frame_address_in_block (frame
),
732 /* Read memory at ADDR (length LEN) into BUF. */
734 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
736 read_memory (addr
, buf
, len
);
739 /* Using the frame specified in BATON, return the value of register
740 REGNUM, treated as a pointer. */
741 CORE_ADDR
read_addr_from_reg (int dwarf_regnum
) override
743 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
744 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
746 return address_from_register (regnum
, frame
);
749 /* Implement "get_reg_value" callback. */
751 struct value
*get_reg_value (struct type
*type
, int dwarf_regnum
) override
753 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
754 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
756 return value_from_register (type
, regnum
, frame
);
760 /* See dwarf2loc.h. */
762 unsigned int entry_values_debug
= 0;
764 /* Helper to set entry_values_debug. */
767 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
768 struct cmd_list_element
*c
, const char *value
)
770 fprintf_filtered (file
,
771 _("Entry values and tail call frames debugging is %s.\n"),
775 /* Find DW_TAG_call_site's DW_AT_call_target address.
776 CALLER_FRAME (for registers) can be NULL if it is not known. This function
777 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
780 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
781 struct call_site
*call_site
,
782 struct frame_info
*caller_frame
)
784 switch (FIELD_LOC_KIND (call_site
->target
))
786 case FIELD_LOC_KIND_DWARF_BLOCK
:
788 struct dwarf2_locexpr_baton
*dwarf_block
;
790 struct type
*caller_core_addr_type
;
791 struct gdbarch
*caller_arch
;
793 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
794 if (dwarf_block
== NULL
)
796 struct bound_minimal_symbol msym
;
798 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
799 throw_error (NO_ENTRY_VALUE_ERROR
,
800 _("DW_AT_call_target is not specified at %s in %s"),
801 paddress (call_site_gdbarch
, call_site
->pc
),
802 (msym
.minsym
== NULL
? "???"
803 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
806 if (caller_frame
== NULL
)
808 struct bound_minimal_symbol msym
;
810 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
811 throw_error (NO_ENTRY_VALUE_ERROR
,
812 _("DW_AT_call_target DWARF block resolving "
813 "requires known frame which is currently not "
814 "available at %s in %s"),
815 paddress (call_site_gdbarch
, call_site
->pc
),
816 (msym
.minsym
== NULL
? "???"
817 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
820 caller_arch
= get_frame_arch (caller_frame
);
821 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
822 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
823 dwarf_block
->data
, dwarf_block
->size
,
824 dwarf_block
->per_cu
);
825 /* DW_AT_call_target is a DWARF expression, not a DWARF location. */
826 if (VALUE_LVAL (val
) == lval_memory
)
827 return value_address (val
);
829 return value_as_address (val
);
832 case FIELD_LOC_KIND_PHYSNAME
:
834 const char *physname
;
835 struct bound_minimal_symbol msym
;
837 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
839 /* Handle both the mangled and demangled PHYSNAME. */
840 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
841 if (msym
.minsym
== NULL
)
843 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
844 throw_error (NO_ENTRY_VALUE_ERROR
,
845 _("Cannot find function \"%s\" for a call site target "
847 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
848 (msym
.minsym
== NULL
? "???"
849 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
852 return BMSYMBOL_VALUE_ADDRESS (msym
);
855 case FIELD_LOC_KIND_PHYSADDR
:
856 return FIELD_STATIC_PHYSADDR (call_site
->target
);
859 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
863 /* Convert function entry point exact address ADDR to the function which is
864 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
865 NO_ENTRY_VALUE_ERROR otherwise. */
867 static struct symbol
*
868 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
870 struct symbol
*sym
= find_pc_function (addr
);
873 if (sym
== NULL
|| BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
874 throw_error (NO_ENTRY_VALUE_ERROR
,
875 _("DW_TAG_call_site resolving failed to find function "
876 "name for address %s"),
877 paddress (gdbarch
, addr
));
879 type
= SYMBOL_TYPE (sym
);
880 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
881 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
886 /* Verify function with entry point exact address ADDR can never call itself
887 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
888 can call itself via tail calls.
890 If a funtion can tail call itself its entry value based parameters are
891 unreliable. There is no verification whether the value of some/all
892 parameters is unchanged through the self tail call, we expect if there is
893 a self tail call all the parameters can be modified. */
896 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
900 /* The verification is completely unordered. Track here function addresses
901 which still need to be iterated. */
902 std::vector
<CORE_ADDR
> todo
;
904 /* Track here CORE_ADDRs which were already visited. */
905 std::unordered_set
<CORE_ADDR
> addr_hash
;
907 todo
.push_back (verify_addr
);
908 while (!todo
.empty ())
910 struct symbol
*func_sym
;
911 struct call_site
*call_site
;
916 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
918 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
919 call_site
; call_site
= call_site
->tail_call_next
)
921 CORE_ADDR target_addr
;
923 /* CALLER_FRAME with registers is not available for tail-call jumped
925 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
927 if (target_addr
== verify_addr
)
929 struct bound_minimal_symbol msym
;
931 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
932 throw_error (NO_ENTRY_VALUE_ERROR
,
933 _("DW_OP_entry_value resolving has found "
934 "function \"%s\" at %s can call itself via tail "
936 (msym
.minsym
== NULL
? "???"
937 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
938 paddress (gdbarch
, verify_addr
));
941 if (addr_hash
.insert (target_addr
).second
)
942 todo
.push_back (target_addr
);
947 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
948 ENTRY_VALUES_DEBUG. */
951 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
953 CORE_ADDR addr
= call_site
->pc
;
954 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
956 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
957 (msym
.minsym
== NULL
? "???"
958 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
962 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
963 only top callers and bottom callees which are present in both. GDBARCH is
964 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
965 no remaining possibilities to provide unambiguous non-trivial result.
966 RESULTP should point to NULL on the first (initialization) call. Caller is
967 responsible for xfree of any RESULTP data. */
970 chain_candidate (struct gdbarch
*gdbarch
,
971 gdb::unique_xmalloc_ptr
<struct call_site_chain
> *resultp
,
972 std::vector
<struct call_site
*> *chain
)
974 long length
= chain
->size ();
975 int callers
, callees
, idx
;
977 if (*resultp
== NULL
)
979 /* Create the initial chain containing all the passed PCs. */
981 struct call_site_chain
*result
982 = ((struct call_site_chain
*)
983 xmalloc (sizeof (*result
)
984 + sizeof (*result
->call_site
) * (length
- 1)));
985 result
->length
= length
;
986 result
->callers
= result
->callees
= length
;
987 if (!chain
->empty ())
988 memcpy (result
->call_site
, chain
->data (),
989 sizeof (*result
->call_site
) * length
);
990 resultp
->reset (result
);
992 if (entry_values_debug
)
994 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
995 for (idx
= 0; idx
< length
; idx
++)
996 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
997 fputc_unfiltered ('\n', gdb_stdlog
);
1003 if (entry_values_debug
)
1005 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
1006 for (idx
= 0; idx
< length
; idx
++)
1007 tailcall_dump (gdbarch
, chain
->at (idx
));
1008 fputc_unfiltered ('\n', gdb_stdlog
);
1011 /* Intersect callers. */
1013 callers
= std::min ((long) (*resultp
)->callers
, length
);
1014 for (idx
= 0; idx
< callers
; idx
++)
1015 if ((*resultp
)->call_site
[idx
] != chain
->at (idx
))
1017 (*resultp
)->callers
= idx
;
1021 /* Intersect callees. */
1023 callees
= std::min ((long) (*resultp
)->callees
, length
);
1024 for (idx
= 0; idx
< callees
; idx
++)
1025 if ((*resultp
)->call_site
[(*resultp
)->length
- 1 - idx
]
1026 != chain
->at (length
- 1 - idx
))
1028 (*resultp
)->callees
= idx
;
1032 if (entry_values_debug
)
1034 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
1035 for (idx
= 0; idx
< (*resultp
)->callers
; idx
++)
1036 tailcall_dump (gdbarch
, (*resultp
)->call_site
[idx
]);
1037 fputs_unfiltered (" |", gdb_stdlog
);
1038 for (idx
= 0; idx
< (*resultp
)->callees
; idx
++)
1039 tailcall_dump (gdbarch
,
1040 (*resultp
)->call_site
[(*resultp
)->length
1041 - (*resultp
)->callees
+ idx
]);
1042 fputc_unfiltered ('\n', gdb_stdlog
);
1045 if ((*resultp
)->callers
== 0 && (*resultp
)->callees
== 0)
1047 /* There are no common callers or callees. It could be also a direct
1048 call (which has length 0) with ambiguous possibility of an indirect
1049 call - CALLERS == CALLEES == 0 is valid during the first allocation
1050 but any subsequence processing of such entry means ambiguity. */
1051 resultp
->reset (NULL
);
1055 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
1056 PC again. In such case there must be two different code paths to reach
1057 it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
1058 gdb_assert ((*resultp
)->callers
+ (*resultp
)->callees
<= (*resultp
)->length
);
1061 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1062 assumed frames between them use GDBARCH. Use depth first search so we can
1063 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
1064 would have needless GDB stack overhead. Caller is responsible for xfree of
1065 the returned result. Any unreliability results in thrown
1066 NO_ENTRY_VALUE_ERROR. */
1068 static struct call_site_chain
*
1069 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1070 CORE_ADDR callee_pc
)
1072 CORE_ADDR save_callee_pc
= callee_pc
;
1073 gdb::unique_xmalloc_ptr
<struct call_site_chain
> retval
;
1074 struct call_site
*call_site
;
1076 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
1077 call_site nor any possible call_site at CALLEE_PC's function is there.
1078 Any CALL_SITE in CHAIN will be iterated to its siblings - via
1079 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
1080 std::vector
<struct call_site
*> chain
;
1082 /* We are not interested in the specific PC inside the callee function. */
1083 callee_pc
= get_pc_function_start (callee_pc
);
1085 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
1086 paddress (gdbarch
, save_callee_pc
));
1088 /* Mark CALL_SITEs so we do not visit the same ones twice. */
1089 std::unordered_set
<CORE_ADDR
> addr_hash
;
1091 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
1092 at the target's function. All the possible tail call sites in the
1093 target's function will get iterated as already pushed into CHAIN via their
1095 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1099 CORE_ADDR target_func_addr
;
1100 struct call_site
*target_call_site
;
1102 /* CALLER_FRAME with registers is not available for tail-call jumped
1104 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
1106 if (target_func_addr
== callee_pc
)
1108 chain_candidate (gdbarch
, &retval
, &chain
);
1112 /* There is no way to reach CALLEE_PC again as we would prevent
1113 entering it twice as being already marked in ADDR_HASH. */
1114 target_call_site
= NULL
;
1118 struct symbol
*target_func
;
1120 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
1121 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
1126 /* Attempt to visit TARGET_CALL_SITE. */
1128 if (target_call_site
)
1130 if (addr_hash
.insert (target_call_site
->pc
).second
)
1132 /* Successfully entered TARGET_CALL_SITE. */
1134 chain
.push_back (target_call_site
);
1139 /* Backtrack (without revisiting the originating call_site). Try the
1140 callers's sibling; if there isn't any try the callers's callers's
1143 target_call_site
= NULL
;
1144 while (!chain
.empty ())
1146 call_site
= chain
.back ();
1149 size_t removed
= addr_hash
.erase (call_site
->pc
);
1150 gdb_assert (removed
== 1);
1152 target_call_site
= call_site
->tail_call_next
;
1153 if (target_call_site
)
1157 while (target_call_site
);
1162 call_site
= chain
.back ();
1167 struct bound_minimal_symbol msym_caller
, msym_callee
;
1169 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
1170 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
1171 throw_error (NO_ENTRY_VALUE_ERROR
,
1172 _("There are no unambiguously determinable intermediate "
1173 "callers or callees between caller function \"%s\" at %s "
1174 "and callee function \"%s\" at %s"),
1175 (msym_caller
.minsym
== NULL
1176 ? "???" : MSYMBOL_PRINT_NAME (msym_caller
.minsym
)),
1177 paddress (gdbarch
, caller_pc
),
1178 (msym_callee
.minsym
== NULL
1179 ? "???" : MSYMBOL_PRINT_NAME (msym_callee
.minsym
)),
1180 paddress (gdbarch
, callee_pc
));
1183 return retval
.release ();
1186 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1187 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
1188 constructed return NULL. Caller is responsible for xfree of the returned
1191 struct call_site_chain
*
1192 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1193 CORE_ADDR callee_pc
)
1195 struct call_site_chain
*retval
= NULL
;
1199 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
1201 catch (const gdb_exception_error
&e
)
1203 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
1205 if (entry_values_debug
)
1206 exception_print (gdb_stdout
, e
);
1217 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1220 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1221 enum call_site_parameter_kind kind
,
1222 union call_site_parameter_u kind_u
)
1224 if (kind
== parameter
->kind
)
1227 case CALL_SITE_PARAMETER_DWARF_REG
:
1228 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1229 case CALL_SITE_PARAMETER_FB_OFFSET
:
1230 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1231 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1232 return kind_u
.param_cu_off
== parameter
->u
.param_cu_off
;
1237 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1238 FRAME is for callee.
1240 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1243 static struct call_site_parameter
*
1244 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1245 enum call_site_parameter_kind kind
,
1246 union call_site_parameter_u kind_u
,
1247 struct dwarf2_per_cu_data
**per_cu_return
)
1249 CORE_ADDR func_addr
, caller_pc
;
1250 struct gdbarch
*gdbarch
;
1251 struct frame_info
*caller_frame
;
1252 struct call_site
*call_site
;
1254 /* Initialize it just to avoid a GCC false warning. */
1255 struct call_site_parameter
*parameter
= NULL
;
1256 CORE_ADDR target_addr
;
1258 while (get_frame_type (frame
) == INLINE_FRAME
)
1260 frame
= get_prev_frame (frame
);
1261 gdb_assert (frame
!= NULL
);
1264 func_addr
= get_frame_func (frame
);
1265 gdbarch
= get_frame_arch (frame
);
1266 caller_frame
= get_prev_frame (frame
);
1267 if (gdbarch
!= frame_unwind_arch (frame
))
1269 struct bound_minimal_symbol msym
1270 = lookup_minimal_symbol_by_pc (func_addr
);
1271 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1273 throw_error (NO_ENTRY_VALUE_ERROR
,
1274 _("DW_OP_entry_value resolving callee gdbarch %s "
1275 "(of %s (%s)) does not match caller gdbarch %s"),
1276 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1277 paddress (gdbarch
, func_addr
),
1278 (msym
.minsym
== NULL
? "???"
1279 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
1280 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1283 if (caller_frame
== NULL
)
1285 struct bound_minimal_symbol msym
1286 = lookup_minimal_symbol_by_pc (func_addr
);
1288 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_entry_value resolving "
1289 "requires caller of %s (%s)"),
1290 paddress (gdbarch
, func_addr
),
1291 (msym
.minsym
== NULL
? "???"
1292 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
1294 caller_pc
= get_frame_pc (caller_frame
);
1295 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1297 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1298 if (target_addr
!= func_addr
)
1300 struct minimal_symbol
*target_msym
, *func_msym
;
1302 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1303 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1304 throw_error (NO_ENTRY_VALUE_ERROR
,
1305 _("DW_OP_entry_value resolving expects callee %s at %s "
1306 "but the called frame is for %s at %s"),
1307 (target_msym
== NULL
? "???"
1308 : MSYMBOL_PRINT_NAME (target_msym
)),
1309 paddress (gdbarch
, target_addr
),
1310 func_msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (func_msym
),
1311 paddress (gdbarch
, func_addr
));
1314 /* No entry value based parameters would be reliable if this function can
1315 call itself via tail calls. */
1316 func_verify_no_selftailcall (gdbarch
, func_addr
);
1318 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1320 parameter
= &call_site
->parameter
[iparams
];
1321 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1324 if (iparams
== call_site
->parameter_count
)
1326 struct minimal_symbol
*msym
1327 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1329 /* DW_TAG_call_site_parameter will be missing just if GCC could not
1330 determine its value. */
1331 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1332 "at DW_TAG_call_site %s at %s"),
1333 paddress (gdbarch
, caller_pc
),
1334 msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (msym
));
1337 *per_cu_return
= call_site
->per_cu
;
1341 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1342 the normal DW_AT_call_value block. Otherwise return the
1343 DW_AT_call_data_value (dereferenced) block.
1345 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1348 Function always returns non-NULL, non-optimized out value. It throws
1349 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1351 static struct value
*
1352 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1353 CORE_ADDR deref_size
, struct type
*type
,
1354 struct frame_info
*caller_frame
,
1355 struct dwarf2_per_cu_data
*per_cu
)
1357 const gdb_byte
*data_src
;
1361 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1362 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1364 /* DEREF_SIZE size is not verified here. */
1365 if (data_src
== NULL
)
1366 throw_error (NO_ENTRY_VALUE_ERROR
,
1367 _("Cannot resolve DW_AT_call_data_value"));
1369 /* DW_AT_call_value is a DWARF expression, not a DWARF
1370 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1372 data
= (gdb_byte
*) alloca (size
+ 1);
1373 memcpy (data
, data_src
, size
);
1374 data
[size
] = DW_OP_stack_value
;
1376 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1379 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1380 the indirect method on it, that is use its stored target value, the sole
1381 purpose of entry_data_value_funcs.. */
1383 static struct value
*
1384 entry_data_value_coerce_ref (const struct value
*value
)
1386 struct type
*checked_type
= check_typedef (value_type (value
));
1387 struct value
*target_val
;
1389 if (!TYPE_IS_REFERENCE (checked_type
))
1392 target_val
= (struct value
*) value_computed_closure (value
);
1393 value_incref (target_val
);
1397 /* Implement copy_closure. */
1400 entry_data_value_copy_closure (const struct value
*v
)
1402 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1404 value_incref (target_val
);
1408 /* Implement free_closure. */
1411 entry_data_value_free_closure (struct value
*v
)
1413 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1415 value_decref (target_val
);
1418 /* Vector for methods for an entry value reference where the referenced value
1419 is stored in the caller. On the first dereference use
1420 DW_AT_call_data_value in the caller. */
1422 static const struct lval_funcs entry_data_value_funcs
=
1426 NULL
, /* indirect */
1427 entry_data_value_coerce_ref
,
1428 NULL
, /* check_synthetic_pointer */
1429 entry_data_value_copy_closure
,
1430 entry_data_value_free_closure
1433 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1434 are used to match DW_AT_location at the caller's
1435 DW_TAG_call_site_parameter.
1437 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1438 cannot resolve the parameter for any reason. */
1440 static struct value
*
1441 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1442 enum call_site_parameter_kind kind
,
1443 union call_site_parameter_u kind_u
)
1445 struct type
*checked_type
= check_typedef (type
);
1446 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1447 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1448 struct value
*outer_val
, *target_val
, *val
;
1449 struct call_site_parameter
*parameter
;
1450 struct dwarf2_per_cu_data
*caller_per_cu
;
1452 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1455 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1459 /* Check if DW_AT_call_data_value cannot be used. If it should be
1460 used and it is not available do not fall back to OUTER_VAL - dereferencing
1461 TYPE_CODE_REF with non-entry data value would give current value - not the
1464 if (!TYPE_IS_REFERENCE (checked_type
)
1465 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1468 target_val
= dwarf_entry_parameter_to_value (parameter
,
1469 TYPE_LENGTH (target_type
),
1470 target_type
, caller_frame
,
1473 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1474 release_value (target_val
).release ());
1476 /* Copy the referencing pointer to the new computed value. */
1477 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1478 TYPE_LENGTH (checked_type
));
1479 set_value_lazy (val
, 0);
1484 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1485 SIZE are DWARF block used to match DW_AT_location at the caller's
1486 DW_TAG_call_site_parameter.
1488 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1489 cannot resolve the parameter for any reason. */
1491 static struct value
*
1492 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1493 const gdb_byte
*block
, size_t block_len
)
1495 union call_site_parameter_u kind_u
;
1497 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1498 if (kind_u
.dwarf_reg
!= -1)
1499 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1502 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1503 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1506 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1507 suppressed during normal operation. The expression can be arbitrary if
1508 there is no caller-callee entry value binding expected. */
1509 throw_error (NO_ENTRY_VALUE_ERROR
,
1510 _("DWARF-2 expression error: DW_OP_entry_value is supported "
1511 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1514 struct piece_closure
1516 /* Reference count. */
1519 /* The CU from which this closure's expression came. */
1520 struct dwarf2_per_cu_data
*per_cu
= NULL
;
1522 /* The pieces describing this variable. */
1523 std::vector
<dwarf_expr_piece
> pieces
;
1525 /* Frame ID of frame to which a register value is relative, used
1526 only by DWARF_VALUE_REGISTER. */
1527 struct frame_id frame_id
;
1530 /* Allocate a closure for a value formed from separately-described
1533 static struct piece_closure
*
1534 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1535 std::vector
<dwarf_expr_piece
> &&pieces
,
1536 struct frame_info
*frame
)
1538 struct piece_closure
*c
= new piece_closure
;
1542 c
->pieces
= std::move (pieces
);
1544 c
->frame_id
= null_frame_id
;
1546 c
->frame_id
= get_frame_id (frame
);
1548 for (dwarf_expr_piece
&piece
: c
->pieces
)
1549 if (piece
.location
== DWARF_VALUE_STACK
)
1550 value_incref (piece
.v
.value
);
1555 /* Return the number of bytes overlapping a contiguous chunk of N_BITS
1556 bits whose first bit is located at bit offset START. */
1559 bits_to_bytes (ULONGEST start
, ULONGEST n_bits
)
1561 return (start
% 8 + n_bits
+ 7) / 8;
1564 /* Read or write a pieced value V. If FROM != NULL, operate in "write
1565 mode": copy FROM into the pieces comprising V. If FROM == NULL,
1566 operate in "read mode": fetch the contents of the (lazy) value V by
1567 composing it from its pieces. */
1570 rw_pieced_value (struct value
*v
, struct value
*from
)
1573 LONGEST offset
= 0, max_offset
;
1574 ULONGEST bits_to_skip
;
1575 gdb_byte
*v_contents
;
1576 const gdb_byte
*from_contents
;
1577 struct piece_closure
*c
1578 = (struct piece_closure
*) value_computed_closure (v
);
1579 gdb::byte_vector buffer
;
1581 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1585 from_contents
= value_contents (from
);
1590 if (value_type (v
) != value_enclosing_type (v
))
1591 internal_error (__FILE__
, __LINE__
,
1592 _("Should not be able to create a lazy value with "
1593 "an enclosing type"));
1594 v_contents
= value_contents_raw (v
);
1595 from_contents
= NULL
;
1598 bits_to_skip
= 8 * value_offset (v
);
1599 if (value_bitsize (v
))
1601 bits_to_skip
+= (8 * value_offset (value_parent (v
))
1602 + value_bitpos (v
));
1604 && (gdbarch_byte_order (get_type_arch (value_type (from
)))
1607 /* Use the least significant bits of FROM. */
1608 max_offset
= 8 * TYPE_LENGTH (value_type (from
));
1609 offset
= max_offset
- value_bitsize (v
);
1612 max_offset
= value_bitsize (v
);
1615 max_offset
= 8 * TYPE_LENGTH (value_type (v
));
1617 /* Advance to the first non-skipped piece. */
1618 for (i
= 0; i
< c
->pieces
.size () && bits_to_skip
>= c
->pieces
[i
].size
; i
++)
1619 bits_to_skip
-= c
->pieces
[i
].size
;
1621 for (; i
< c
->pieces
.size () && offset
< max_offset
; i
++)
1623 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1624 size_t this_size_bits
, this_size
;
1626 this_size_bits
= p
->size
- bits_to_skip
;
1627 if (this_size_bits
> max_offset
- offset
)
1628 this_size_bits
= max_offset
- offset
;
1630 switch (p
->location
)
1632 case DWARF_VALUE_REGISTER
:
1634 struct frame_info
*frame
= frame_find_by_id (c
->frame_id
);
1635 struct gdbarch
*arch
= get_frame_arch (frame
);
1636 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, p
->v
.regno
);
1637 ULONGEST reg_bits
= 8 * register_size (arch
, gdb_regnum
);
1640 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1641 && p
->offset
+ p
->size
< reg_bits
)
1643 /* Big-endian, and we want less than full size. */
1644 bits_to_skip
+= reg_bits
- (p
->offset
+ p
->size
);
1647 bits_to_skip
+= p
->offset
;
1649 this_size
= bits_to_bytes (bits_to_skip
, this_size_bits
);
1650 buffer
.resize (this_size
);
1655 if (!get_frame_register_bytes (frame
, gdb_regnum
,
1657 this_size
, buffer
.data (),
1661 mark_value_bits_optimized_out (v
, offset
,
1664 mark_value_bits_unavailable (v
, offset
,
1669 copy_bitwise (v_contents
, offset
,
1670 buffer
.data (), bits_to_skip
% 8,
1671 this_size_bits
, bits_big_endian
);
1676 if (bits_to_skip
% 8 != 0 || this_size_bits
% 8 != 0)
1678 /* Data is copied non-byte-aligned into the register.
1679 Need some bits from original register value. */
1680 get_frame_register_bytes (frame
, gdb_regnum
,
1682 this_size
, buffer
.data (),
1685 throw_error (OPTIMIZED_OUT_ERROR
,
1686 _("Can't do read-modify-write to "
1687 "update bitfield; containing word "
1688 "has been optimized out"));
1690 throw_error (NOT_AVAILABLE_ERROR
,
1691 _("Can't do read-modify-write to "
1692 "update bitfield; containing word "
1696 copy_bitwise (buffer
.data (), bits_to_skip
% 8,
1697 from_contents
, offset
,
1698 this_size_bits
, bits_big_endian
);
1699 put_frame_register_bytes (frame
, gdb_regnum
,
1701 this_size
, buffer
.data ());
1706 case DWARF_VALUE_MEMORY
:
1708 bits_to_skip
+= p
->offset
;
1710 CORE_ADDR start_addr
= p
->v
.mem
.addr
+ bits_to_skip
/ 8;
1712 if (bits_to_skip
% 8 == 0 && this_size_bits
% 8 == 0
1715 /* Everything is byte-aligned; no buffer needed. */
1717 write_memory_with_notification (start_addr
,
1720 this_size_bits
/ 8);
1722 read_value_memory (v
, offset
,
1723 p
->v
.mem
.in_stack_memory
,
1724 p
->v
.mem
.addr
+ bits_to_skip
/ 8,
1725 v_contents
+ offset
/ 8,
1726 this_size_bits
/ 8);
1730 this_size
= bits_to_bytes (bits_to_skip
, this_size_bits
);
1731 buffer
.resize (this_size
);
1736 read_value_memory (v
, offset
,
1737 p
->v
.mem
.in_stack_memory
,
1738 p
->v
.mem
.addr
+ bits_to_skip
/ 8,
1739 buffer
.data (), this_size
);
1740 copy_bitwise (v_contents
, offset
,
1741 buffer
.data (), bits_to_skip
% 8,
1742 this_size_bits
, bits_big_endian
);
1747 if (bits_to_skip
% 8 != 0 || this_size_bits
% 8 != 0)
1751 /* Perform a single read for small sizes. */
1752 read_memory (start_addr
, buffer
.data (),
1757 /* Only the first and last bytes can possibly have
1759 read_memory (start_addr
, buffer
.data (), 1);
1760 read_memory (start_addr
+ this_size
- 1,
1761 &buffer
[this_size
- 1], 1);
1765 copy_bitwise (buffer
.data (), bits_to_skip
% 8,
1766 from_contents
, offset
,
1767 this_size_bits
, bits_big_endian
);
1768 write_memory_with_notification (start_addr
,
1775 case DWARF_VALUE_STACK
:
1779 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1783 struct objfile
*objfile
= dwarf2_per_cu_objfile (c
->per_cu
);
1784 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
1785 ULONGEST stack_value_size_bits
1786 = 8 * TYPE_LENGTH (value_type (p
->v
.value
));
1788 /* Use zeroes if piece reaches beyond stack value. */
1789 if (p
->offset
+ p
->size
> stack_value_size_bits
)
1792 /* Piece is anchored at least significant bit end. */
1793 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
1794 bits_to_skip
+= stack_value_size_bits
- p
->offset
- p
->size
;
1796 bits_to_skip
+= p
->offset
;
1798 copy_bitwise (v_contents
, offset
,
1799 value_contents_all (p
->v
.value
),
1801 this_size_bits
, bits_big_endian
);
1805 case DWARF_VALUE_LITERAL
:
1809 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1813 ULONGEST literal_size_bits
= 8 * p
->v
.literal
.length
;
1814 size_t n
= this_size_bits
;
1816 /* Cut off at the end of the implicit value. */
1817 bits_to_skip
+= p
->offset
;
1818 if (bits_to_skip
>= literal_size_bits
)
1820 if (n
> literal_size_bits
- bits_to_skip
)
1821 n
= literal_size_bits
- bits_to_skip
;
1823 copy_bitwise (v_contents
, offset
,
1824 p
->v
.literal
.data
, bits_to_skip
,
1825 n
, bits_big_endian
);
1829 case DWARF_VALUE_IMPLICIT_POINTER
:
1832 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1836 /* These bits show up as zeros -- but do not cause the value to
1837 be considered optimized-out. */
1840 case DWARF_VALUE_OPTIMIZED_OUT
:
1841 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1845 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1848 offset
+= this_size_bits
;
1855 read_pieced_value (struct value
*v
)
1857 rw_pieced_value (v
, NULL
);
1861 write_pieced_value (struct value
*to
, struct value
*from
)
1863 rw_pieced_value (to
, from
);
1866 /* An implementation of an lval_funcs method to see whether a value is
1867 a synthetic pointer. */
1870 check_pieced_synthetic_pointer (const struct value
*value
, LONGEST bit_offset
,
1873 struct piece_closure
*c
1874 = (struct piece_closure
*) value_computed_closure (value
);
1877 bit_offset
+= 8 * value_offset (value
);
1878 if (value_bitsize (value
))
1879 bit_offset
+= value_bitpos (value
);
1881 for (i
= 0; i
< c
->pieces
.size () && bit_length
> 0; i
++)
1883 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1884 size_t this_size_bits
= p
->size
;
1888 if (bit_offset
>= this_size_bits
)
1890 bit_offset
-= this_size_bits
;
1894 bit_length
-= this_size_bits
- bit_offset
;
1898 bit_length
-= this_size_bits
;
1900 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1907 /* A wrapper function for get_frame_address_in_block. */
1910 get_frame_address_in_block_wrapper (void *baton
)
1912 return get_frame_address_in_block ((struct frame_info
*) baton
);
1915 /* Fetch a DW_AT_const_value through a synthetic pointer. */
1917 static struct value
*
1918 fetch_const_value_from_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
1919 struct dwarf2_per_cu_data
*per_cu
,
1922 struct value
*result
= NULL
;
1923 const gdb_byte
*bytes
;
1926 auto_obstack temp_obstack
;
1927 bytes
= dwarf2_fetch_constant_bytes (die
, per_cu
, &temp_obstack
, &len
);
1931 if (byte_offset
>= 0
1932 && byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) <= len
)
1934 bytes
+= byte_offset
;
1935 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
1938 invalid_synthetic_pointer ();
1941 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
1946 /* Fetch the value pointed to by a synthetic pointer. */
1948 static struct value
*
1949 indirect_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
1950 struct dwarf2_per_cu_data
*per_cu
,
1951 struct frame_info
*frame
, struct type
*type
,
1952 bool resolve_abstract_p
)
1954 /* Fetch the location expression of the DIE we're pointing to. */
1955 struct dwarf2_locexpr_baton baton
1956 = dwarf2_fetch_die_loc_sect_off (die
, per_cu
,
1957 get_frame_address_in_block_wrapper
, frame
,
1958 resolve_abstract_p
);
1960 /* Get type of pointed-to DIE. */
1961 struct type
*orig_type
= dwarf2_fetch_die_type_sect_off (die
, per_cu
);
1962 if (orig_type
== NULL
)
1963 invalid_synthetic_pointer ();
1965 /* If pointed-to DIE has a DW_AT_location, evaluate it and return the
1966 resulting value. Otherwise, it may have a DW_AT_const_value instead,
1967 or it may've been optimized out. */
1968 if (baton
.data
!= NULL
)
1969 return dwarf2_evaluate_loc_desc_full (orig_type
, frame
, baton
.data
,
1970 baton
.size
, baton
.per_cu
,
1971 TYPE_TARGET_TYPE (type
),
1974 return fetch_const_value_from_synthetic_pointer (die
, byte_offset
, per_cu
,
1978 /* An implementation of an lval_funcs method to indirect through a
1979 pointer. This handles the synthetic pointer case when needed. */
1981 static struct value
*
1982 indirect_pieced_value (struct value
*value
)
1984 struct piece_closure
*c
1985 = (struct piece_closure
*) value_computed_closure (value
);
1987 struct frame_info
*frame
;
1990 struct dwarf_expr_piece
*piece
= NULL
;
1991 LONGEST byte_offset
;
1992 enum bfd_endian byte_order
;
1994 type
= check_typedef (value_type (value
));
1995 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
1998 bit_length
= 8 * TYPE_LENGTH (type
);
1999 bit_offset
= 8 * value_offset (value
);
2000 if (value_bitsize (value
))
2001 bit_offset
+= value_bitpos (value
);
2003 for (i
= 0; i
< c
->pieces
.size () && bit_length
> 0; i
++)
2005 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2006 size_t this_size_bits
= p
->size
;
2010 if (bit_offset
>= this_size_bits
)
2012 bit_offset
-= this_size_bits
;
2016 bit_length
-= this_size_bits
- bit_offset
;
2020 bit_length
-= this_size_bits
;
2022 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2025 if (bit_length
!= 0)
2026 error (_("Invalid use of DW_OP_implicit_pointer"));
2032 gdb_assert (piece
!= NULL
);
2033 frame
= get_selected_frame (_("No frame selected."));
2035 /* This is an offset requested by GDB, such as value subscripts.
2036 However, due to how synthetic pointers are implemented, this is
2037 always presented to us as a pointer type. This means we have to
2038 sign-extend it manually as appropriate. Use raw
2039 extract_signed_integer directly rather than value_as_address and
2040 sign extend afterwards on architectures that would need it
2041 (mostly everywhere except MIPS, which has signed addresses) as
2042 the later would go through gdbarch_pointer_to_address and thus
2043 return a CORE_ADDR with high bits set on architectures that
2044 encode address spaces and other things in CORE_ADDR. */
2045 byte_order
= gdbarch_byte_order (get_frame_arch (frame
));
2046 byte_offset
= extract_signed_integer (value_contents (value
),
2047 TYPE_LENGTH (type
), byte_order
);
2048 byte_offset
+= piece
->v
.ptr
.offset
;
2050 return indirect_synthetic_pointer (piece
->v
.ptr
.die_sect_off
,
2051 byte_offset
, c
->per_cu
,
2055 /* Implementation of the coerce_ref method of lval_funcs for synthetic C++
2058 static struct value
*
2059 coerce_pieced_ref (const struct value
*value
)
2061 struct type
*type
= check_typedef (value_type (value
));
2063 if (value_bits_synthetic_pointer (value
, value_embedded_offset (value
),
2064 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
2066 const struct piece_closure
*closure
2067 = (struct piece_closure
*) value_computed_closure (value
);
2068 struct frame_info
*frame
2069 = get_selected_frame (_("No frame selected."));
2071 /* gdb represents synthetic pointers as pieced values with a single
2073 gdb_assert (closure
!= NULL
);
2074 gdb_assert (closure
->pieces
.size () == 1);
2076 return indirect_synthetic_pointer
2077 (closure
->pieces
[0].v
.ptr
.die_sect_off
,
2078 closure
->pieces
[0].v
.ptr
.offset
,
2079 closure
->per_cu
, frame
, type
);
2083 /* Else: not a synthetic reference; do nothing. */
2089 copy_pieced_value_closure (const struct value
*v
)
2091 struct piece_closure
*c
2092 = (struct piece_closure
*) value_computed_closure (v
);
2099 free_pieced_value_closure (struct value
*v
)
2101 struct piece_closure
*c
2102 = (struct piece_closure
*) value_computed_closure (v
);
2107 for (dwarf_expr_piece
&p
: c
->pieces
)
2108 if (p
.location
== DWARF_VALUE_STACK
)
2109 value_decref (p
.v
.value
);
2115 /* Functions for accessing a variable described by DW_OP_piece. */
2116 static const struct lval_funcs pieced_value_funcs
= {
2119 indirect_pieced_value
,
2121 check_pieced_synthetic_pointer
,
2122 copy_pieced_value_closure
,
2123 free_pieced_value_closure
2126 /* Evaluate a location description, starting at DATA and with length
2127 SIZE, to find the current location of variable of TYPE in the
2128 context of FRAME. If SUBOBJ_TYPE is non-NULL, return instead the
2129 location of the subobject of type SUBOBJ_TYPE at byte offset
2130 SUBOBJ_BYTE_OFFSET within the variable of type TYPE. */
2132 static struct value
*
2133 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2134 const gdb_byte
*data
, size_t size
,
2135 struct dwarf2_per_cu_data
*per_cu
,
2136 struct type
*subobj_type
,
2137 LONGEST subobj_byte_offset
)
2139 struct value
*retval
;
2140 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2142 if (subobj_type
== NULL
)
2145 subobj_byte_offset
= 0;
2147 else if (subobj_byte_offset
< 0)
2148 invalid_synthetic_pointer ();
2151 return allocate_optimized_out_value (subobj_type
);
2153 dwarf_evaluate_loc_desc ctx
;
2155 ctx
.per_cu
= per_cu
;
2156 ctx
.obj_address
= 0;
2158 scoped_value_mark free_values
;
2160 ctx
.gdbarch
= get_objfile_arch (objfile
);
2161 ctx
.addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2162 ctx
.ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2163 ctx
.offset
= dwarf2_per_cu_text_offset (per_cu
);
2167 ctx
.eval (data
, size
);
2169 catch (const gdb_exception_error
&ex
)
2171 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2173 free_values
.free_to_mark ();
2174 retval
= allocate_value (subobj_type
);
2175 mark_value_bytes_unavailable (retval
, 0,
2176 TYPE_LENGTH (subobj_type
));
2179 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2181 if (entry_values_debug
)
2182 exception_print (gdb_stdout
, ex
);
2183 free_values
.free_to_mark ();
2184 return allocate_optimized_out_value (subobj_type
);
2190 if (ctx
.pieces
.size () > 0)
2192 struct piece_closure
*c
;
2193 ULONGEST bit_size
= 0;
2195 for (dwarf_expr_piece
&piece
: ctx
.pieces
)
2196 bit_size
+= piece
.size
;
2197 /* Complain if the expression is larger than the size of the
2199 if (bit_size
> 8 * TYPE_LENGTH (type
))
2200 invalid_synthetic_pointer ();
2202 c
= allocate_piece_closure (per_cu
, std::move (ctx
.pieces
), frame
);
2203 /* We must clean up the value chain after creating the piece
2204 closure but before allocating the result. */
2205 free_values
.free_to_mark ();
2206 retval
= allocate_computed_value (subobj_type
,
2207 &pieced_value_funcs
, c
);
2208 set_value_offset (retval
, subobj_byte_offset
);
2212 switch (ctx
.location
)
2214 case DWARF_VALUE_REGISTER
:
2216 struct gdbarch
*arch
= get_frame_arch (frame
);
2218 = longest_to_int (value_as_long (ctx
.fetch (0)));
2219 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, dwarf_regnum
);
2221 if (subobj_byte_offset
!= 0)
2222 error (_("cannot use offset on synthetic pointer to register"));
2223 free_values
.free_to_mark ();
2224 retval
= value_from_register (subobj_type
, gdb_regnum
, frame
);
2225 if (value_optimized_out (retval
))
2229 /* This means the register has undefined value / was
2230 not saved. As we're computing the location of some
2231 variable etc. in the program, not a value for
2232 inspecting a register ($pc, $sp, etc.), return a
2233 generic optimized out value instead, so that we show
2234 <optimized out> instead of <not saved>. */
2235 tmp
= allocate_value (subobj_type
);
2236 value_contents_copy (tmp
, 0, retval
, 0,
2237 TYPE_LENGTH (subobj_type
));
2243 case DWARF_VALUE_MEMORY
:
2245 struct type
*ptr_type
;
2246 CORE_ADDR address
= ctx
.fetch_address (0);
2247 bool in_stack_memory
= ctx
.fetch_in_stack_memory (0);
2249 /* DW_OP_deref_size (and possibly other operations too) may
2250 create a pointer instead of an address. Ideally, the
2251 pointer to address conversion would be performed as part
2252 of those operations, but the type of the object to
2253 which the address refers is not known at the time of
2254 the operation. Therefore, we do the conversion here
2255 since the type is readily available. */
2257 switch (TYPE_CODE (subobj_type
))
2259 case TYPE_CODE_FUNC
:
2260 case TYPE_CODE_METHOD
:
2261 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_func_ptr
;
2264 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_data_ptr
;
2267 address
= value_as_address (value_from_pointer (ptr_type
, address
));
2269 free_values
.free_to_mark ();
2270 retval
= value_at_lazy (subobj_type
,
2271 address
+ subobj_byte_offset
);
2272 if (in_stack_memory
)
2273 set_value_stack (retval
, 1);
2277 case DWARF_VALUE_STACK
:
2279 struct value
*value
= ctx
.fetch (0);
2280 size_t n
= TYPE_LENGTH (value_type (value
));
2281 size_t len
= TYPE_LENGTH (subobj_type
);
2282 size_t max
= TYPE_LENGTH (type
);
2283 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2285 if (subobj_byte_offset
+ len
> max
)
2286 invalid_synthetic_pointer ();
2288 /* Preserve VALUE because we are going to free values back
2289 to the mark, but we still need the value contents
2291 value_ref_ptr value_holder
= value_ref_ptr::new_reference (value
);
2292 free_values
.free_to_mark ();
2294 retval
= allocate_value (subobj_type
);
2296 /* The given offset is relative to the actual object. */
2297 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2298 subobj_byte_offset
+= n
- max
;
2300 memcpy (value_contents_raw (retval
),
2301 value_contents_all (value
) + subobj_byte_offset
, len
);
2305 case DWARF_VALUE_LITERAL
:
2308 size_t n
= TYPE_LENGTH (subobj_type
);
2310 if (subobj_byte_offset
+ n
> ctx
.len
)
2311 invalid_synthetic_pointer ();
2313 free_values
.free_to_mark ();
2314 retval
= allocate_value (subobj_type
);
2315 contents
= value_contents_raw (retval
);
2316 memcpy (contents
, ctx
.data
+ subobj_byte_offset
, n
);
2320 case DWARF_VALUE_OPTIMIZED_OUT
:
2321 free_values
.free_to_mark ();
2322 retval
= allocate_optimized_out_value (subobj_type
);
2325 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2326 operation by execute_stack_op. */
2327 case DWARF_VALUE_IMPLICIT_POINTER
:
2328 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2329 it can only be encountered when making a piece. */
2331 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2335 set_value_initialized (retval
, ctx
.initialized
);
2340 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2341 passes 0 as the byte_offset. */
2344 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2345 const gdb_byte
*data
, size_t size
,
2346 struct dwarf2_per_cu_data
*per_cu
)
2348 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
,
2352 /* Evaluates a dwarf expression and stores the result in VAL, expecting
2353 that the dwarf expression only produces a single CORE_ADDR. FRAME is the
2354 frame in which the expression is evaluated. ADDR is a context (location of
2355 a variable) and might be needed to evaluate the location expression.
2356 Returns 1 on success, 0 otherwise. */
2359 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton
*dlbaton
,
2360 struct frame_info
*frame
,
2364 struct objfile
*objfile
;
2366 if (dlbaton
== NULL
|| dlbaton
->size
== 0)
2369 dwarf_evaluate_loc_desc ctx
;
2372 ctx
.per_cu
= dlbaton
->per_cu
;
2373 ctx
.obj_address
= addr
;
2375 objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2377 ctx
.gdbarch
= get_objfile_arch (objfile
);
2378 ctx
.addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2379 ctx
.ref_addr_size
= dwarf2_per_cu_ref_addr_size (dlbaton
->per_cu
);
2380 ctx
.offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
2384 ctx
.eval (dlbaton
->data
, dlbaton
->size
);
2386 catch (const gdb_exception_error
&ex
)
2388 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2392 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2394 if (entry_values_debug
)
2395 exception_print (gdb_stdout
, ex
);
2402 switch (ctx
.location
)
2404 case DWARF_VALUE_REGISTER
:
2405 case DWARF_VALUE_MEMORY
:
2406 case DWARF_VALUE_STACK
:
2407 *valp
= ctx
.fetch_address (0);
2408 if (ctx
.location
== DWARF_VALUE_REGISTER
)
2409 *valp
= ctx
.read_addr_from_reg (*valp
);
2411 case DWARF_VALUE_LITERAL
:
2412 *valp
= extract_signed_integer (ctx
.data
, ctx
.len
,
2413 gdbarch_byte_order (ctx
.gdbarch
));
2415 /* Unsupported dwarf values. */
2416 case DWARF_VALUE_OPTIMIZED_OUT
:
2417 case DWARF_VALUE_IMPLICIT_POINTER
:
2424 /* See dwarf2loc.h. */
2427 dwarf2_evaluate_property (const struct dynamic_prop
*prop
,
2428 struct frame_info
*frame
,
2429 struct property_addr_info
*addr_stack
,
2435 if (frame
== NULL
&& has_stack_frames ())
2436 frame
= get_selected_frame (NULL
);
2442 const struct dwarf2_property_baton
*baton
2443 = (const struct dwarf2_property_baton
*) prop
->data
.baton
;
2444 gdb_assert (baton
->property_type
!= NULL
);
2446 if (dwarf2_locexpr_baton_eval (&baton
->locexpr
, frame
,
2447 addr_stack
? addr_stack
->addr
: 0,
2450 if (baton
->locexpr
.is_reference
)
2452 struct value
*val
= value_at (baton
->property_type
, *value
);
2453 *value
= value_as_address (val
);
2457 gdb_assert (baton
->property_type
!= NULL
);
2459 struct type
*type
= check_typedef (baton
->property_type
);
2460 if (TYPE_LENGTH (type
) < sizeof (CORE_ADDR
)
2461 && !TYPE_UNSIGNED (type
))
2463 /* If we have a valid return candidate and it's value
2464 is signed, we have to sign-extend the value because
2465 CORE_ADDR on 64bit machine has 8 bytes but address
2466 size of an 32bit application is bytes. */
2468 = (dwarf2_per_cu_addr_size (baton
->locexpr
.per_cu
)
2470 const CORE_ADDR neg_mask
2471 = (~((CORE_ADDR
) 0) << (addr_size
- 1));
2473 /* Check if signed bit is set and sign-extend values. */
2474 if (*value
& neg_mask
)
2485 struct dwarf2_property_baton
*baton
2486 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2487 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2488 const gdb_byte
*data
;
2492 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2495 val
= dwarf2_evaluate_loc_desc (baton
->property_type
, frame
, data
,
2496 size
, baton
->loclist
.per_cu
);
2497 if (!value_optimized_out (val
))
2499 *value
= value_as_address (val
);
2507 *value
= prop
->data
.const_val
;
2510 case PROP_ADDR_OFFSET
:
2512 struct dwarf2_property_baton
*baton
2513 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2514 struct property_addr_info
*pinfo
;
2517 for (pinfo
= addr_stack
; pinfo
!= NULL
; pinfo
= pinfo
->next
)
2519 /* This approach lets us avoid checking the qualifiers. */
2520 if (TYPE_MAIN_TYPE (pinfo
->type
)
2521 == TYPE_MAIN_TYPE (baton
->property_type
))
2525 error (_("cannot find reference address for offset property"));
2526 if (pinfo
->valaddr
!= NULL
)
2527 val
= value_from_contents
2528 (baton
->offset_info
.type
,
2529 pinfo
->valaddr
+ baton
->offset_info
.offset
);
2531 val
= value_at (baton
->offset_info
.type
,
2532 pinfo
->addr
+ baton
->offset_info
.offset
);
2533 *value
= value_as_address (val
);
2541 /* See dwarf2loc.h. */
2544 dwarf2_compile_property_to_c (string_file
*stream
,
2545 const char *result_name
,
2546 struct gdbarch
*gdbarch
,
2547 unsigned char *registers_used
,
2548 const struct dynamic_prop
*prop
,
2552 struct dwarf2_property_baton
*baton
2553 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2554 const gdb_byte
*data
;
2556 struct dwarf2_per_cu_data
*per_cu
;
2558 if (prop
->kind
== PROP_LOCEXPR
)
2560 data
= baton
->locexpr
.data
;
2561 size
= baton
->locexpr
.size
;
2562 per_cu
= baton
->locexpr
.per_cu
;
2566 gdb_assert (prop
->kind
== PROP_LOCLIST
);
2568 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2569 per_cu
= baton
->loclist
.per_cu
;
2572 compile_dwarf_bounds_to_c (stream
, result_name
, prop
, sym
, pc
,
2573 gdbarch
, registers_used
,
2574 dwarf2_per_cu_addr_size (per_cu
),
2575 data
, data
+ size
, per_cu
);
2579 /* Helper functions and baton for dwarf2_loc_desc_get_symbol_read_needs. */
2581 class symbol_needs_eval_context
: public dwarf_expr_context
2585 enum symbol_needs_kind needs
;
2586 struct dwarf2_per_cu_data
*per_cu
;
2588 /* Reads from registers do require a frame. */
2589 CORE_ADDR
read_addr_from_reg (int regnum
) override
2591 needs
= SYMBOL_NEEDS_FRAME
;
2595 /* "get_reg_value" callback: Reads from registers do require a
2598 struct value
*get_reg_value (struct type
*type
, int regnum
) override
2600 needs
= SYMBOL_NEEDS_FRAME
;
2601 return value_zero (type
, not_lval
);
2604 /* Reads from memory do not require a frame. */
2605 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
2607 memset (buf
, 0, len
);
2610 /* Frame-relative accesses do require a frame. */
2611 void get_frame_base (const gdb_byte
**start
, size_t *length
) override
2613 static gdb_byte lit0
= DW_OP_lit0
;
2618 needs
= SYMBOL_NEEDS_FRAME
;
2621 /* CFA accesses require a frame. */
2622 CORE_ADDR
get_frame_cfa () override
2624 needs
= SYMBOL_NEEDS_FRAME
;
2628 CORE_ADDR
get_frame_pc () override
2630 needs
= SYMBOL_NEEDS_FRAME
;
2634 /* Thread-local accesses require registers, but not a frame. */
2635 CORE_ADDR
get_tls_address (CORE_ADDR offset
) override
2637 if (needs
<= SYMBOL_NEEDS_REGISTERS
)
2638 needs
= SYMBOL_NEEDS_REGISTERS
;
2642 /* Helper interface of per_cu_dwarf_call for
2643 dwarf2_loc_desc_get_symbol_read_needs. */
2645 void dwarf_call (cu_offset die_offset
) override
2647 per_cu_dwarf_call (this, die_offset
, per_cu
);
2650 /* Helper interface of sect_variable_value for
2651 dwarf2_loc_desc_get_symbol_read_needs. */
2653 struct value
*dwarf_variable_value (sect_offset sect_off
) override
2655 return sect_variable_value (this, sect_off
, per_cu
);
2658 /* DW_OP_entry_value accesses require a caller, therefore a
2661 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
2662 union call_site_parameter_u kind_u
,
2663 int deref_size
) override
2665 needs
= SYMBOL_NEEDS_FRAME
;
2667 /* The expression may require some stub values on DWARF stack. */
2668 push_address (0, 0);
2671 /* DW_OP_addrx and DW_OP_GNU_addr_index doesn't require a frame. */
2673 CORE_ADDR
get_addr_index (unsigned int index
) override
2675 /* Nothing to do. */
2679 /* DW_OP_push_object_address has a frame already passed through. */
2681 CORE_ADDR
get_object_address () override
2683 /* Nothing to do. */
2688 /* Compute the correct symbol_needs_kind value for the location
2689 expression at DATA (length SIZE). */
2691 static enum symbol_needs_kind
2692 dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte
*data
, size_t size
,
2693 struct dwarf2_per_cu_data
*per_cu
)
2696 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2698 scoped_value_mark free_values
;
2700 symbol_needs_eval_context ctx
;
2702 ctx
.needs
= SYMBOL_NEEDS_NONE
;
2703 ctx
.per_cu
= per_cu
;
2704 ctx
.gdbarch
= get_objfile_arch (objfile
);
2705 ctx
.addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2706 ctx
.ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2707 ctx
.offset
= dwarf2_per_cu_text_offset (per_cu
);
2709 ctx
.eval (data
, size
);
2711 in_reg
= ctx
.location
== DWARF_VALUE_REGISTER
;
2713 /* If the location has several pieces, and any of them are in
2714 registers, then we will need a frame to fetch them from. */
2715 for (dwarf_expr_piece
&p
: ctx
.pieces
)
2716 if (p
.location
== DWARF_VALUE_REGISTER
)
2720 ctx
.needs
= SYMBOL_NEEDS_FRAME
;
2724 /* A helper function that throws an unimplemented error mentioning a
2725 given DWARF operator. */
2727 static void ATTRIBUTE_NORETURN
2728 unimplemented (unsigned int op
)
2730 const char *name
= get_DW_OP_name (op
);
2733 error (_("DWARF operator %s cannot be translated to an agent expression"),
2736 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2737 "to an agent expression"),
2743 This is basically a wrapper on gdbarch_dwarf2_reg_to_regnum so that we
2744 can issue a complaint, which is better than having every target's
2745 implementation of dwarf2_reg_to_regnum do it. */
2748 dwarf_reg_to_regnum (struct gdbarch
*arch
, int dwarf_reg
)
2750 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2754 complaint (_("bad DWARF register number %d"), dwarf_reg
);
2759 /* Subroutine of dwarf_reg_to_regnum_or_error to simplify it.
2760 Throw an error because DWARF_REG is bad. */
2763 throw_bad_regnum_error (ULONGEST dwarf_reg
)
2765 /* Still want to print -1 as "-1".
2766 We *could* have int and ULONGEST versions of dwarf2_reg_to_regnum_or_error
2767 but that's overkill for now. */
2768 if ((int) dwarf_reg
== dwarf_reg
)
2769 error (_("Unable to access DWARF register number %d"), (int) dwarf_reg
);
2770 error (_("Unable to access DWARF register number %s"),
2771 pulongest (dwarf_reg
));
2774 /* See dwarf2loc.h. */
2777 dwarf_reg_to_regnum_or_error (struct gdbarch
*arch
, ULONGEST dwarf_reg
)
2781 if (dwarf_reg
> INT_MAX
)
2782 throw_bad_regnum_error (dwarf_reg
);
2783 /* Yes, we will end up issuing a complaint and an error if DWARF_REG is
2784 bad, but that's ok. */
2785 reg
= dwarf_reg_to_regnum (arch
, (int) dwarf_reg
);
2787 throw_bad_regnum_error (dwarf_reg
);
2791 /* A helper function that emits an access to memory. ARCH is the
2792 target architecture. EXPR is the expression which we are building.
2793 NBITS is the number of bits we want to read. This emits the
2794 opcodes needed to read the memory and then extract the desired
2798 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2800 ULONGEST nbytes
= (nbits
+ 7) / 8;
2802 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2805 ax_trace_quick (expr
, nbytes
);
2808 ax_simple (expr
, aop_ref8
);
2809 else if (nbits
<= 16)
2810 ax_simple (expr
, aop_ref16
);
2811 else if (nbits
<= 32)
2812 ax_simple (expr
, aop_ref32
);
2814 ax_simple (expr
, aop_ref64
);
2816 /* If we read exactly the number of bytes we wanted, we're done. */
2817 if (8 * nbytes
== nbits
)
2820 if (gdbarch_bits_big_endian (arch
))
2822 /* On a bits-big-endian machine, we want the high-order
2824 ax_const_l (expr
, 8 * nbytes
- nbits
);
2825 ax_simple (expr
, aop_rsh_unsigned
);
2829 /* On a bits-little-endian box, we want the low-order NBITS. */
2830 ax_zero_ext (expr
, nbits
);
2834 /* A helper function to return the frame's PC. */
2837 get_ax_pc (void *baton
)
2839 struct agent_expr
*expr
= (struct agent_expr
*) baton
;
2844 /* Compile a DWARF location expression to an agent expression.
2846 EXPR is the agent expression we are building.
2847 LOC is the agent value we modify.
2848 ARCH is the architecture.
2849 ADDR_SIZE is the size of addresses, in bytes.
2850 OP_PTR is the start of the location expression.
2851 OP_END is one past the last byte of the location expression.
2853 This will throw an exception for various kinds of errors -- for
2854 example, if the expression cannot be compiled, or if the expression
2858 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2859 unsigned int addr_size
, const gdb_byte
*op_ptr
,
2860 const gdb_byte
*op_end
,
2861 struct dwarf2_per_cu_data
*per_cu
)
2863 gdbarch
*arch
= expr
->gdbarch
;
2864 std::vector
<int> dw_labels
, patches
;
2865 const gdb_byte
* const base
= op_ptr
;
2866 const gdb_byte
*previous_piece
= op_ptr
;
2867 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2868 ULONGEST bits_collected
= 0;
2869 unsigned int addr_size_bits
= 8 * addr_size
;
2870 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
2872 std::vector
<int> offsets (op_end
- op_ptr
, -1);
2874 /* By default we are making an address. */
2875 loc
->kind
= axs_lvalue_memory
;
2877 while (op_ptr
< op_end
)
2879 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
2880 uint64_t uoffset
, reg
;
2884 offsets
[op_ptr
- base
] = expr
->len
;
2887 /* Our basic approach to code generation is to map DWARF
2888 operations directly to AX operations. However, there are
2891 First, DWARF works on address-sized units, but AX always uses
2892 LONGEST. For most operations we simply ignore this
2893 difference; instead we generate sign extensions as needed
2894 before division and comparison operations. It would be nice
2895 to omit the sign extensions, but there is no way to determine
2896 the size of the target's LONGEST. (This code uses the size
2897 of the host LONGEST in some cases -- that is a bug but it is
2900 Second, some DWARF operations cannot be translated to AX.
2901 For these we simply fail. See
2902 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2937 ax_const_l (expr
, op
- DW_OP_lit0
);
2941 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
2942 op_ptr
+= addr_size
;
2943 /* Some versions of GCC emit DW_OP_addr before
2944 DW_OP_GNU_push_tls_address. In this case the value is an
2945 index, not an address. We don't support things like
2946 branching between the address and the TLS op. */
2947 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
2948 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
2949 ax_const_l (expr
, uoffset
);
2953 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
2957 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
2961 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
2965 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
2969 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
2973 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
2977 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
2981 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
2985 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
2986 ax_const_l (expr
, uoffset
);
2989 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2990 ax_const_l (expr
, offset
);
3025 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3026 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_reg0
);
3027 loc
->kind
= axs_lvalue_register
;
3031 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3032 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3033 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3034 loc
->kind
= axs_lvalue_register
;
3037 case DW_OP_implicit_value
:
3041 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
3042 if (op_ptr
+ len
> op_end
)
3043 error (_("DW_OP_implicit_value: too few bytes available."));
3044 if (len
> sizeof (ULONGEST
))
3045 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
3048 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
3051 dwarf_expr_require_composition (op_ptr
, op_end
,
3052 "DW_OP_implicit_value");
3054 loc
->kind
= axs_rvalue
;
3058 case DW_OP_stack_value
:
3059 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
3060 loc
->kind
= axs_rvalue
;
3095 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3096 i
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_breg0
);
3100 ax_const_l (expr
, offset
);
3101 ax_simple (expr
, aop_add
);
3106 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3107 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3108 i
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3112 ax_const_l (expr
, offset
);
3113 ax_simple (expr
, aop_add
);
3119 const gdb_byte
*datastart
;
3121 const struct block
*b
;
3122 struct symbol
*framefunc
;
3124 b
= block_for_pc (expr
->scope
);
3127 error (_("No block found for address"));
3129 framefunc
= block_linkage_function (b
);
3132 error (_("No function found for block"));
3134 func_get_frame_base_dwarf_block (framefunc
, expr
->scope
,
3135 &datastart
, &datalen
);
3137 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3138 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, datastart
,
3139 datastart
+ datalen
, per_cu
);
3140 if (loc
->kind
== axs_lvalue_register
)
3141 require_rvalue (expr
, loc
);
3145 ax_const_l (expr
, offset
);
3146 ax_simple (expr
, aop_add
);
3149 loc
->kind
= axs_lvalue_memory
;
3154 ax_simple (expr
, aop_dup
);
3158 ax_simple (expr
, aop_pop
);
3163 ax_pick (expr
, offset
);
3167 ax_simple (expr
, aop_swap
);
3175 ax_simple (expr
, aop_rot
);
3179 case DW_OP_deref_size
:
3183 if (op
== DW_OP_deref_size
)
3188 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3189 error (_("Unsupported size %d in %s"),
3190 size
, get_DW_OP_name (op
));
3191 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3196 /* Sign extend the operand. */
3197 ax_ext (expr
, addr_size_bits
);
3198 ax_simple (expr
, aop_dup
);
3199 ax_const_l (expr
, 0);
3200 ax_simple (expr
, aop_less_signed
);
3201 ax_simple (expr
, aop_log_not
);
3202 i
= ax_goto (expr
, aop_if_goto
);
3203 /* We have to emit 0 - X. */
3204 ax_const_l (expr
, 0);
3205 ax_simple (expr
, aop_swap
);
3206 ax_simple (expr
, aop_sub
);
3207 ax_label (expr
, i
, expr
->len
);
3211 /* No need to sign extend here. */
3212 ax_const_l (expr
, 0);
3213 ax_simple (expr
, aop_swap
);
3214 ax_simple (expr
, aop_sub
);
3218 /* Sign extend the operand. */
3219 ax_ext (expr
, addr_size_bits
);
3220 ax_simple (expr
, aop_bit_not
);
3223 case DW_OP_plus_uconst
:
3224 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3225 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3226 but we micro-optimize anyhow. */
3229 ax_const_l (expr
, reg
);
3230 ax_simple (expr
, aop_add
);
3235 ax_simple (expr
, aop_bit_and
);
3239 /* Sign extend the operands. */
3240 ax_ext (expr
, addr_size_bits
);
3241 ax_simple (expr
, aop_swap
);
3242 ax_ext (expr
, addr_size_bits
);
3243 ax_simple (expr
, aop_swap
);
3244 ax_simple (expr
, aop_div_signed
);
3248 ax_simple (expr
, aop_sub
);
3252 ax_simple (expr
, aop_rem_unsigned
);
3256 ax_simple (expr
, aop_mul
);
3260 ax_simple (expr
, aop_bit_or
);
3264 ax_simple (expr
, aop_add
);
3268 ax_simple (expr
, aop_lsh
);
3272 ax_simple (expr
, aop_rsh_unsigned
);
3276 ax_simple (expr
, aop_rsh_signed
);
3280 ax_simple (expr
, aop_bit_xor
);
3284 /* Sign extend the operands. */
3285 ax_ext (expr
, addr_size_bits
);
3286 ax_simple (expr
, aop_swap
);
3287 ax_ext (expr
, addr_size_bits
);
3288 /* Note no swap here: A <= B is !(B < A). */
3289 ax_simple (expr
, aop_less_signed
);
3290 ax_simple (expr
, aop_log_not
);
3294 /* Sign extend the operands. */
3295 ax_ext (expr
, addr_size_bits
);
3296 ax_simple (expr
, aop_swap
);
3297 ax_ext (expr
, addr_size_bits
);
3298 ax_simple (expr
, aop_swap
);
3299 /* A >= B is !(A < B). */
3300 ax_simple (expr
, aop_less_signed
);
3301 ax_simple (expr
, aop_log_not
);
3305 /* Sign extend the operands. */
3306 ax_ext (expr
, addr_size_bits
);
3307 ax_simple (expr
, aop_swap
);
3308 ax_ext (expr
, addr_size_bits
);
3309 /* No need for a second swap here. */
3310 ax_simple (expr
, aop_equal
);
3314 /* Sign extend the operands. */
3315 ax_ext (expr
, addr_size_bits
);
3316 ax_simple (expr
, aop_swap
);
3317 ax_ext (expr
, addr_size_bits
);
3318 ax_simple (expr
, aop_swap
);
3319 ax_simple (expr
, aop_less_signed
);
3323 /* Sign extend the operands. */
3324 ax_ext (expr
, addr_size_bits
);
3325 ax_simple (expr
, aop_swap
);
3326 ax_ext (expr
, addr_size_bits
);
3327 /* Note no swap here: A > B is B < A. */
3328 ax_simple (expr
, aop_less_signed
);
3332 /* Sign extend the operands. */
3333 ax_ext (expr
, addr_size_bits
);
3334 ax_simple (expr
, aop_swap
);
3335 ax_ext (expr
, addr_size_bits
);
3336 /* No need for a swap here. */
3337 ax_simple (expr
, aop_equal
);
3338 ax_simple (expr
, aop_log_not
);
3341 case DW_OP_call_frame_cfa
:
3344 CORE_ADDR text_offset
;
3346 const gdb_byte
*cfa_start
, *cfa_end
;
3348 if (dwarf2_fetch_cfa_info (arch
, expr
->scope
, per_cu
,
3350 &text_offset
, &cfa_start
, &cfa_end
))
3353 ax_reg (expr
, regnum
);
3356 ax_const_l (expr
, off
);
3357 ax_simple (expr
, aop_add
);
3362 /* Another expression. */
3363 ax_const_l (expr
, text_offset
);
3364 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, cfa_start
,
3368 loc
->kind
= axs_lvalue_memory
;
3372 case DW_OP_GNU_push_tls_address
:
3373 case DW_OP_form_tls_address
:
3377 case DW_OP_push_object_address
:
3382 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3384 i
= ax_goto (expr
, aop_goto
);
3385 dw_labels
.push_back (op_ptr
+ offset
- base
);
3386 patches
.push_back (i
);
3390 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3392 /* Zero extend the operand. */
3393 ax_zero_ext (expr
, addr_size_bits
);
3394 i
= ax_goto (expr
, aop_if_goto
);
3395 dw_labels
.push_back (op_ptr
+ offset
- base
);
3396 patches
.push_back (i
);
3403 case DW_OP_bit_piece
:
3407 if (op_ptr
- 1 == previous_piece
)
3408 error (_("Cannot translate empty pieces to agent expressions"));
3409 previous_piece
= op_ptr
- 1;
3411 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3412 if (op
== DW_OP_piece
)
3418 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3420 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3421 error (_("Expression pieces exceed word size"));
3423 /* Access the bits. */
3426 case axs_lvalue_register
:
3427 ax_reg (expr
, loc
->u
.reg
);
3430 case axs_lvalue_memory
:
3431 /* Offset the pointer, if needed. */
3434 ax_const_l (expr
, uoffset
/ 8);
3435 ax_simple (expr
, aop_add
);
3438 access_memory (arch
, expr
, size
);
3442 /* For a bits-big-endian target, shift up what we already
3443 have. For a bits-little-endian target, shift up the
3444 new data. Note that there is a potential bug here if
3445 the DWARF expression leaves multiple values on the
3447 if (bits_collected
> 0)
3449 if (bits_big_endian
)
3451 ax_simple (expr
, aop_swap
);
3452 ax_const_l (expr
, size
);
3453 ax_simple (expr
, aop_lsh
);
3454 /* We don't need a second swap here, because
3455 aop_bit_or is symmetric. */
3459 ax_const_l (expr
, size
);
3460 ax_simple (expr
, aop_lsh
);
3462 ax_simple (expr
, aop_bit_or
);
3465 bits_collected
+= size
;
3466 loc
->kind
= axs_rvalue
;
3470 case DW_OP_GNU_uninit
:
3476 struct dwarf2_locexpr_baton block
;
3477 int size
= (op
== DW_OP_call2
? 2 : 4);
3479 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3482 cu_offset cuoffset
= (cu_offset
) uoffset
;
3483 block
= dwarf2_fetch_die_loc_cu_off (cuoffset
, per_cu
,
3486 /* DW_OP_call_ref is currently not supported. */
3487 gdb_assert (block
.per_cu
== per_cu
);
3489 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, block
.data
,
3490 block
.data
+ block
.size
, per_cu
);
3494 case DW_OP_call_ref
:
3497 case DW_OP_GNU_variable_value
:
3505 /* Patch all the branches we emitted. */
3506 for (int i
= 0; i
< patches
.size (); ++i
)
3508 int targ
= offsets
[dw_labels
[i
]];
3510 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3511 ax_label (expr
, patches
[i
], targ
);
3516 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3517 evaluator to calculate the location. */
3518 static struct value
*
3519 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3521 struct dwarf2_locexpr_baton
*dlbaton
3522 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3525 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3526 dlbaton
->size
, dlbaton
->per_cu
);
3531 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3532 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3535 static struct value
*
3536 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3538 struct dwarf2_locexpr_baton
*dlbaton
3539 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3541 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3545 /* Implementation of get_symbol_read_needs from
3546 symbol_computed_ops. */
3548 static enum symbol_needs_kind
3549 locexpr_get_symbol_read_needs (struct symbol
*symbol
)
3551 struct dwarf2_locexpr_baton
*dlbaton
3552 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3554 return dwarf2_loc_desc_get_symbol_read_needs (dlbaton
->data
, dlbaton
->size
,
3558 /* Return true if DATA points to the end of a piece. END is one past
3559 the last byte in the expression. */
3562 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3564 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3567 /* Helper for locexpr_describe_location_piece that finds the name of a
3571 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3575 /* This doesn't use dwarf_reg_to_regnum_or_error on purpose.
3576 We'd rather print *something* here than throw an error. */
3577 regnum
= dwarf_reg_to_regnum (gdbarch
, dwarf_regnum
);
3578 /* gdbarch_register_name may just return "", return something more
3579 descriptive for bad register numbers. */
3582 /* The text is output as "$bad_register_number".
3583 That is why we use the underscores. */
3584 return _("bad_register_number");
3586 return gdbarch_register_name (gdbarch
, regnum
);
3589 /* Nicely describe a single piece of a location, returning an updated
3590 position in the bytecode sequence. This function cannot recognize
3591 all locations; if a location is not recognized, it simply returns
3592 DATA. If there is an error during reading, e.g. we run off the end
3593 of the buffer, an error is thrown. */
3595 static const gdb_byte
*
3596 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3597 CORE_ADDR addr
, struct objfile
*objfile
,
3598 struct dwarf2_per_cu_data
*per_cu
,
3599 const gdb_byte
*data
, const gdb_byte
*end
,
3600 unsigned int addr_size
)
3602 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3605 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3607 fprintf_filtered (stream
, _("a variable in $%s"),
3608 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3611 else if (data
[0] == DW_OP_regx
)
3615 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3616 fprintf_filtered (stream
, _("a variable in $%s"),
3617 locexpr_regname (gdbarch
, reg
));
3619 else if (data
[0] == DW_OP_fbreg
)
3621 const struct block
*b
;
3622 struct symbol
*framefunc
;
3624 int64_t frame_offset
;
3625 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3627 int64_t base_offset
= 0;
3629 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3630 if (!piece_end_p (new_data
, end
))
3634 b
= block_for_pc (addr
);
3637 error (_("No block found for address for symbol \"%s\"."),
3638 SYMBOL_PRINT_NAME (symbol
));
3640 framefunc
= block_linkage_function (b
);
3643 error (_("No function found for block for symbol \"%s\"."),
3644 SYMBOL_PRINT_NAME (symbol
));
3646 func_get_frame_base_dwarf_block (framefunc
, addr
, &base_data
, &base_size
);
3648 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3650 const gdb_byte
*buf_end
;
3652 frame_reg
= base_data
[0] - DW_OP_breg0
;
3653 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3655 if (buf_end
!= base_data
+ base_size
)
3656 error (_("Unexpected opcode after "
3657 "DW_OP_breg%u for symbol \"%s\"."),
3658 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3660 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3662 /* The frame base is just the register, with no offset. */
3663 frame_reg
= base_data
[0] - DW_OP_reg0
;
3668 /* We don't know what to do with the frame base expression,
3669 so we can't trace this variable; give up. */
3673 fprintf_filtered (stream
,
3674 _("a variable at frame base reg $%s offset %s+%s"),
3675 locexpr_regname (gdbarch
, frame_reg
),
3676 plongest (base_offset
), plongest (frame_offset
));
3678 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3679 && piece_end_p (data
, end
))
3683 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3685 fprintf_filtered (stream
,
3686 _("a variable at offset %s from base reg $%s"),
3688 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3691 /* The location expression for a TLS variable looks like this (on a
3694 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3695 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3697 0x3 is the encoding for DW_OP_addr, which has an operand as long
3698 as the size of an address on the target machine (here is 8
3699 bytes). Note that more recent version of GCC emit DW_OP_const4u
3700 or DW_OP_const8u, depending on address size, rather than
3701 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3702 The operand represents the offset at which the variable is within
3703 the thread local storage. */
3705 else if (data
+ 1 + addr_size
< end
3706 && (data
[0] == DW_OP_addr
3707 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3708 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3709 && (data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3710 || data
[1 + addr_size
] == DW_OP_form_tls_address
)
3711 && piece_end_p (data
+ 2 + addr_size
, end
))
3714 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3715 gdbarch_byte_order (gdbarch
));
3717 fprintf_filtered (stream
,
3718 _("a thread-local variable at offset 0x%s "
3719 "in the thread-local storage for `%s'"),
3720 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3722 data
+= 1 + addr_size
+ 1;
3725 /* With -gsplit-dwarf a TLS variable can also look like this:
3726 DW_AT_location : 3 byte block: fc 4 e0
3727 (DW_OP_GNU_const_index: 4;
3728 DW_OP_GNU_push_tls_address) */
3729 else if (data
+ 3 <= end
3730 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3731 && data
[0] == DW_OP_GNU_const_index
3733 && (data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3734 || data
[1 + leb128_size
] == DW_OP_form_tls_address
)
3735 && piece_end_p (data
+ 2 + leb128_size
, end
))
3739 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3740 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3741 fprintf_filtered (stream
,
3742 _("a thread-local variable at offset 0x%s "
3743 "in the thread-local storage for `%s'"),
3744 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3748 else if (data
[0] >= DW_OP_lit0
3749 && data
[0] <= DW_OP_lit31
3751 && data
[1] == DW_OP_stack_value
)
3753 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3760 /* Disassemble an expression, stopping at the end of a piece or at the
3761 end of the expression. Returns a pointer to the next unread byte
3762 in the input expression. If ALL is nonzero, then this function
3763 will keep going until it reaches the end of the expression.
3764 If there is an error during reading, e.g. we run off the end
3765 of the buffer, an error is thrown. */
3767 static const gdb_byte
*
3768 disassemble_dwarf_expression (struct ui_file
*stream
,
3769 struct gdbarch
*arch
, unsigned int addr_size
,
3770 int offset_size
, const gdb_byte
*start
,
3771 const gdb_byte
*data
, const gdb_byte
*end
,
3772 int indent
, int all
,
3773 struct dwarf2_per_cu_data
*per_cu
)
3777 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3779 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *data
++;
3784 name
= get_DW_OP_name (op
);
3787 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3788 op
, (long) (data
- 1 - start
));
3789 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3790 (long) (data
- 1 - start
), name
);
3795 ul
= extract_unsigned_integer (data
, addr_size
,
3796 gdbarch_byte_order (arch
));
3798 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3802 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3804 fprintf_filtered (stream
, " %s", pulongest (ul
));
3807 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3809 fprintf_filtered (stream
, " %s", plongest (l
));
3812 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3814 fprintf_filtered (stream
, " %s", pulongest (ul
));
3817 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3819 fprintf_filtered (stream
, " %s", plongest (l
));
3822 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3824 fprintf_filtered (stream
, " %s", pulongest (ul
));
3827 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3829 fprintf_filtered (stream
, " %s", plongest (l
));
3832 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3834 fprintf_filtered (stream
, " %s", pulongest (ul
));
3837 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3839 fprintf_filtered (stream
, " %s", plongest (l
));
3842 data
= safe_read_uleb128 (data
, end
, &ul
);
3843 fprintf_filtered (stream
, " %s", pulongest (ul
));
3846 data
= safe_read_sleb128 (data
, end
, &l
);
3847 fprintf_filtered (stream
, " %s", plongest (l
));
3882 fprintf_filtered (stream
, " [$%s]",
3883 locexpr_regname (arch
, op
- DW_OP_reg0
));
3887 data
= safe_read_uleb128 (data
, end
, &ul
);
3888 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3889 locexpr_regname (arch
, (int) ul
));
3892 case DW_OP_implicit_value
:
3893 data
= safe_read_uleb128 (data
, end
, &ul
);
3895 fprintf_filtered (stream
, " %s", pulongest (ul
));
3930 data
= safe_read_sleb128 (data
, end
, &l
);
3931 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
3932 locexpr_regname (arch
, op
- DW_OP_breg0
));
3936 data
= safe_read_uleb128 (data
, end
, &ul
);
3937 data
= safe_read_sleb128 (data
, end
, &l
);
3938 fprintf_filtered (stream
, " register %s [$%s] offset %s",
3940 locexpr_regname (arch
, (int) ul
),
3945 data
= safe_read_sleb128 (data
, end
, &l
);
3946 fprintf_filtered (stream
, " %s", plongest (l
));
3949 case DW_OP_xderef_size
:
3950 case DW_OP_deref_size
:
3952 fprintf_filtered (stream
, " %d", *data
);
3956 case DW_OP_plus_uconst
:
3957 data
= safe_read_uleb128 (data
, end
, &ul
);
3958 fprintf_filtered (stream
, " %s", pulongest (ul
));
3962 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3964 fprintf_filtered (stream
, " to %ld",
3965 (long) (data
+ l
- start
));
3969 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3971 fprintf_filtered (stream
, " %ld",
3972 (long) (data
+ l
- start
));
3976 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3978 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
3982 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3984 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3987 case DW_OP_call_ref
:
3988 ul
= extract_unsigned_integer (data
, offset_size
,
3989 gdbarch_byte_order (arch
));
3990 data
+= offset_size
;
3991 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
3995 data
= safe_read_uleb128 (data
, end
, &ul
);
3996 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
3999 case DW_OP_bit_piece
:
4003 data
= safe_read_uleb128 (data
, end
, &ul
);
4004 data
= safe_read_uleb128 (data
, end
, &offset
);
4005 fprintf_filtered (stream
, " size %s offset %s (bits)",
4006 pulongest (ul
), pulongest (offset
));
4010 case DW_OP_implicit_pointer
:
4011 case DW_OP_GNU_implicit_pointer
:
4013 ul
= extract_unsigned_integer (data
, offset_size
,
4014 gdbarch_byte_order (arch
));
4015 data
+= offset_size
;
4017 data
= safe_read_sleb128 (data
, end
, &l
);
4019 fprintf_filtered (stream
, " DIE %s offset %s",
4020 phex_nz (ul
, offset_size
),
4025 case DW_OP_deref_type
:
4026 case DW_OP_GNU_deref_type
:
4028 int deref_addr_size
= *data
++;
4031 data
= safe_read_uleb128 (data
, end
, &ul
);
4032 cu_offset offset
= (cu_offset
) ul
;
4033 type
= dwarf2_get_die_type (offset
, per_cu
);
4034 fprintf_filtered (stream
, "<");
4035 type_print (type
, "", stream
, -1);
4036 fprintf_filtered (stream
, " [0x%s]> %d",
4037 phex_nz (to_underlying (offset
), 0),
4042 case DW_OP_const_type
:
4043 case DW_OP_GNU_const_type
:
4047 data
= safe_read_uleb128 (data
, end
, &ul
);
4048 cu_offset type_die
= (cu_offset
) ul
;
4049 type
= dwarf2_get_die_type (type_die
, per_cu
);
4050 fprintf_filtered (stream
, "<");
4051 type_print (type
, "", stream
, -1);
4052 fprintf_filtered (stream
, " [0x%s]>",
4053 phex_nz (to_underlying (type_die
), 0));
4057 case DW_OP_regval_type
:
4058 case DW_OP_GNU_regval_type
:
4063 data
= safe_read_uleb128 (data
, end
, ®
);
4064 data
= safe_read_uleb128 (data
, end
, &ul
);
4065 cu_offset type_die
= (cu_offset
) ul
;
4067 type
= dwarf2_get_die_type (type_die
, per_cu
);
4068 fprintf_filtered (stream
, "<");
4069 type_print (type
, "", stream
, -1);
4070 fprintf_filtered (stream
, " [0x%s]> [$%s]",
4071 phex_nz (to_underlying (type_die
), 0),
4072 locexpr_regname (arch
, reg
));
4077 case DW_OP_GNU_convert
:
4078 case DW_OP_reinterpret
:
4079 case DW_OP_GNU_reinterpret
:
4081 data
= safe_read_uleb128 (data
, end
, &ul
);
4082 cu_offset type_die
= (cu_offset
) ul
;
4084 if (to_underlying (type_die
) == 0)
4085 fprintf_filtered (stream
, "<0>");
4090 type
= dwarf2_get_die_type (type_die
, per_cu
);
4091 fprintf_filtered (stream
, "<");
4092 type_print (type
, "", stream
, -1);
4093 fprintf_filtered (stream
, " [0x%s]>",
4094 phex_nz (to_underlying (type_die
), 0));
4099 case DW_OP_entry_value
:
4100 case DW_OP_GNU_entry_value
:
4101 data
= safe_read_uleb128 (data
, end
, &ul
);
4102 fputc_filtered ('\n', stream
);
4103 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
4104 start
, data
, data
+ ul
, indent
+ 2,
4109 case DW_OP_GNU_parameter_ref
:
4110 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4112 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4116 case DW_OP_GNU_addr_index
:
4117 data
= safe_read_uleb128 (data
, end
, &ul
);
4118 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4119 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
4121 case DW_OP_GNU_const_index
:
4122 data
= safe_read_uleb128 (data
, end
, &ul
);
4123 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4124 fprintf_filtered (stream
, " %s", pulongest (ul
));
4127 case DW_OP_GNU_variable_value
:
4128 ul
= extract_unsigned_integer (data
, offset_size
,
4129 gdbarch_byte_order (arch
));
4130 data
+= offset_size
;
4131 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4135 fprintf_filtered (stream
, "\n");
4141 /* Describe a single location, which may in turn consist of multiple
4145 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
4146 struct ui_file
*stream
,
4147 const gdb_byte
*data
, size_t size
,
4148 struct objfile
*objfile
, unsigned int addr_size
,
4149 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
4151 const gdb_byte
*end
= data
+ size
;
4152 int first_piece
= 1, bad
= 0;
4156 const gdb_byte
*here
= data
;
4157 int disassemble
= 1;
4162 fprintf_filtered (stream
, _(", and "));
4164 if (!dwarf_always_disassemble
)
4166 data
= locexpr_describe_location_piece (symbol
, stream
,
4167 addr
, objfile
, per_cu
,
4168 data
, end
, addr_size
);
4169 /* If we printed anything, or if we have an empty piece,
4170 then don't disassemble. */
4172 || data
[0] == DW_OP_piece
4173 || data
[0] == DW_OP_bit_piece
)
4178 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
4179 data
= disassemble_dwarf_expression (stream
,
4180 get_objfile_arch (objfile
),
4181 addr_size
, offset_size
, data
,
4183 dwarf_always_disassemble
,
4189 int empty
= data
== here
;
4192 fprintf_filtered (stream
, " ");
4193 if (data
[0] == DW_OP_piece
)
4197 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
4200 fprintf_filtered (stream
, _("an empty %s-byte piece"),
4203 fprintf_filtered (stream
, _(" [%s-byte piece]"),
4206 else if (data
[0] == DW_OP_bit_piece
)
4208 uint64_t bits
, offset
;
4210 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
4211 data
= safe_read_uleb128 (data
, end
, &offset
);
4214 fprintf_filtered (stream
,
4215 _("an empty %s-bit piece"),
4218 fprintf_filtered (stream
,
4219 _(" [%s-bit piece, offset %s bits]"),
4220 pulongest (bits
), pulongest (offset
));
4230 if (bad
|| data
> end
)
4231 error (_("Corrupted DWARF2 expression for \"%s\"."),
4232 SYMBOL_PRINT_NAME (symbol
));
4235 /* Print a natural-language description of SYMBOL to STREAM. This
4236 version is for a symbol with a single location. */
4239 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4240 struct ui_file
*stream
)
4242 struct dwarf2_locexpr_baton
*dlbaton
4243 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4244 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4245 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4246 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4248 locexpr_describe_location_1 (symbol
, addr
, stream
,
4249 dlbaton
->data
, dlbaton
->size
,
4250 objfile
, addr_size
, offset_size
,
4254 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4255 any necessary bytecode in AX. */
4258 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
4259 struct axs_value
*value
)
4261 struct dwarf2_locexpr_baton
*dlbaton
4262 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4263 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4265 if (dlbaton
->size
== 0)
4266 value
->optimized_out
= 1;
4268 dwarf2_compile_expr_to_ax (ax
, value
, addr_size
, dlbaton
->data
,
4269 dlbaton
->data
+ dlbaton
->size
, dlbaton
->per_cu
);
4272 /* symbol_computed_ops 'generate_c_location' method. */
4275 locexpr_generate_c_location (struct symbol
*sym
, string_file
*stream
,
4276 struct gdbarch
*gdbarch
,
4277 unsigned char *registers_used
,
4278 CORE_ADDR pc
, const char *result_name
)
4280 struct dwarf2_locexpr_baton
*dlbaton
4281 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (sym
);
4282 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4284 if (dlbaton
->size
== 0)
4285 error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym
));
4287 compile_dwarf_expr_to_c (stream
, result_name
,
4288 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4289 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4293 /* The set of location functions used with the DWARF-2 expression
4295 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4296 locexpr_read_variable
,
4297 locexpr_read_variable_at_entry
,
4298 locexpr_get_symbol_read_needs
,
4299 locexpr_describe_location
,
4300 0, /* location_has_loclist */
4301 locexpr_tracepoint_var_ref
,
4302 locexpr_generate_c_location
4306 /* Wrapper functions for location lists. These generally find
4307 the appropriate location expression and call something above. */
4309 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4310 evaluator to calculate the location. */
4311 static struct value
*
4312 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4314 struct dwarf2_loclist_baton
*dlbaton
4315 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4317 const gdb_byte
*data
;
4319 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4321 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4322 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4328 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4329 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4332 Function always returns non-NULL value, it may be marked optimized out if
4333 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4334 if it cannot resolve the parameter for any reason. */
4336 static struct value
*
4337 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4339 struct dwarf2_loclist_baton
*dlbaton
4340 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4341 const gdb_byte
*data
;
4345 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4346 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4348 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4350 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4352 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4355 /* Implementation of get_symbol_read_needs from
4356 symbol_computed_ops. */
4358 static enum symbol_needs_kind
4359 loclist_symbol_needs (struct symbol
*symbol
)
4361 /* If there's a location list, then assume we need to have a frame
4362 to choose the appropriate location expression. With tracking of
4363 global variables this is not necessarily true, but such tracking
4364 is disabled in GCC at the moment until we figure out how to
4367 return SYMBOL_NEEDS_FRAME
;
4370 /* Print a natural-language description of SYMBOL to STREAM. This
4371 version applies when there is a list of different locations, each
4372 with a specified address range. */
4375 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4376 struct ui_file
*stream
)
4378 struct dwarf2_loclist_baton
*dlbaton
4379 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4380 const gdb_byte
*loc_ptr
, *buf_end
;
4381 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4382 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4383 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4384 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4385 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4386 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4387 /* Adjust base_address for relocatable objects. */
4388 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4389 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4392 loc_ptr
= dlbaton
->data
;
4393 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4395 fprintf_filtered (stream
, _("multi-location:\n"));
4397 /* Iterate through locations until we run out. */
4400 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4402 enum debug_loc_kind kind
;
4403 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4405 if (dlbaton
->from_dwo
)
4406 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4407 loc_ptr
, buf_end
, &new_ptr
,
4408 &low
, &high
, byte_order
);
4410 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4412 byte_order
, addr_size
,
4417 case DEBUG_LOC_END_OF_LIST
:
4420 case DEBUG_LOC_BASE_ADDRESS
:
4421 base_address
= high
+ base_offset
;
4422 fprintf_filtered (stream
, _(" Base address %s"),
4423 paddress (gdbarch
, base_address
));
4425 case DEBUG_LOC_START_END
:
4426 case DEBUG_LOC_START_LENGTH
:
4428 case DEBUG_LOC_BUFFER_OVERFLOW
:
4429 case DEBUG_LOC_INVALID_ENTRY
:
4430 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4431 SYMBOL_PRINT_NAME (symbol
));
4433 gdb_assert_not_reached ("bad debug_loc_kind");
4436 /* Otherwise, a location expression entry. */
4437 low
+= base_address
;
4438 high
+= base_address
;
4440 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
);
4441 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
);
4443 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4446 /* (It would improve readability to print only the minimum
4447 necessary digits of the second number of the range.) */
4448 fprintf_filtered (stream
, _(" Range %s-%s: "),
4449 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4451 /* Now describe this particular location. */
4452 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4453 objfile
, addr_size
, offset_size
,
4456 fprintf_filtered (stream
, "\n");
4462 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4463 any necessary bytecode in AX. */
4465 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
4466 struct axs_value
*value
)
4468 struct dwarf2_loclist_baton
*dlbaton
4469 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4470 const gdb_byte
*data
;
4472 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4474 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4476 value
->optimized_out
= 1;
4478 dwarf2_compile_expr_to_ax (ax
, value
, addr_size
, data
, data
+ size
,
4482 /* symbol_computed_ops 'generate_c_location' method. */
4485 loclist_generate_c_location (struct symbol
*sym
, string_file
*stream
,
4486 struct gdbarch
*gdbarch
,
4487 unsigned char *registers_used
,
4488 CORE_ADDR pc
, const char *result_name
)
4490 struct dwarf2_loclist_baton
*dlbaton
4491 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (sym
);
4492 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4493 const gdb_byte
*data
;
4496 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4498 error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym
));
4500 compile_dwarf_expr_to_c (stream
, result_name
,
4501 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4506 /* The set of location functions used with the DWARF-2 expression
4507 evaluator and location lists. */
4508 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4509 loclist_read_variable
,
4510 loclist_read_variable_at_entry
,
4511 loclist_symbol_needs
,
4512 loclist_describe_location
,
4513 1, /* location_has_loclist */
4514 loclist_tracepoint_var_ref
,
4515 loclist_generate_c_location
4519 _initialize_dwarf2loc (void)
4521 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4522 &entry_values_debug
,
4523 _("Set entry values and tail call frames "
4525 _("Show entry values and tail call frames "
4527 _("When non-zero, the process of determining "
4528 "parameter values from function entry point "
4529 "and tail call frames will be printed."),
4531 show_entry_values_debug
,
4532 &setdebuglist
, &showdebuglist
);