1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003-2020 Free Software Foundation, Inc.
5 Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
35 #include "complaints.h"
37 #include "dwarf2/expr.h"
38 #include "dwarf2/loc.h"
39 #include "dwarf2/read.h"
40 #include "dwarf2/frame.h"
41 #include "dwarf2/leb.h"
42 #include "compile/compile.h"
43 #include "gdbsupport/selftest.h"
46 #include <unordered_set>
47 #include "gdbsupport/underlying.h"
48 #include "gdbsupport/byte-vector.h"
50 static struct value
*dwarf2_evaluate_loc_desc_full
51 (struct type
*type
, struct frame_info
*frame
, const gdb_byte
*data
,
52 size_t size
, dwarf2_per_cu_data
*per_cu
, dwarf2_per_objfile
*per_objfile
,
53 struct type
*subobj_type
, LONGEST subobj_byte_offset
);
55 static struct call_site_parameter
*dwarf_expr_reg_to_entry_parameter
56 (struct frame_info
*frame
,
57 enum call_site_parameter_kind kind
,
58 union call_site_parameter_u kind_u
,
59 dwarf2_per_cu_data
**per_cu_return
,
60 dwarf2_per_objfile
**per_objfile_return
);
62 static struct value
*indirect_synthetic_pointer
63 (sect_offset die
, LONGEST byte_offset
,
64 dwarf2_per_cu_data
*per_cu
,
65 dwarf2_per_objfile
*per_objfile
,
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 /* This is followed by two unsigned LEB128 operands. The values of these
95 operands are the starting and ending offsets, respectively, relative to
96 the applicable base address. */
97 DEBUG_LOC_OFFSET_PAIR
= 4,
99 /* An internal value indicating there is insufficient data. */
100 DEBUG_LOC_BUFFER_OVERFLOW
= -1,
102 /* An internal value indicating an invalid kind of entry was found. */
103 DEBUG_LOC_INVALID_ENTRY
= -2
106 /* Helper function which throws an error if a synthetic pointer is
110 invalid_synthetic_pointer (void)
112 error (_("access outside bounds of object "
113 "referenced via synthetic pointer"));
116 /* Decode the addresses in a non-dwo .debug_loc entry.
117 A pointer to the next byte to examine is returned in *NEW_PTR.
118 The encoded low,high addresses are return in *LOW,*HIGH.
119 The result indicates the kind of entry found. */
121 static enum debug_loc_kind
122 decode_debug_loc_addresses (const gdb_byte
*loc_ptr
, const gdb_byte
*buf_end
,
123 const gdb_byte
**new_ptr
,
124 CORE_ADDR
*low
, CORE_ADDR
*high
,
125 enum bfd_endian byte_order
,
126 unsigned int addr_size
,
129 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
131 if (buf_end
- loc_ptr
< 2 * addr_size
)
132 return DEBUG_LOC_BUFFER_OVERFLOW
;
135 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
137 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
138 loc_ptr
+= addr_size
;
141 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
143 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
144 loc_ptr
+= addr_size
;
148 /* A base-address-selection entry. */
149 if ((*low
& base_mask
) == base_mask
)
150 return DEBUG_LOC_BASE_ADDRESS
;
152 /* An end-of-list entry. */
153 if (*low
== 0 && *high
== 0)
154 return DEBUG_LOC_END_OF_LIST
;
156 return DEBUG_LOC_START_END
;
159 /* Decode the addresses in .debug_loclists entry.
160 A pointer to the next byte to examine is returned in *NEW_PTR.
161 The encoded low,high addresses are return in *LOW,*HIGH.
162 The result indicates the kind of entry found. */
164 static enum debug_loc_kind
165 decode_debug_loclists_addresses (dwarf2_per_cu_data
*per_cu
,
166 dwarf2_per_objfile
*per_objfile
,
167 const gdb_byte
*loc_ptr
,
168 const gdb_byte
*buf_end
,
169 const gdb_byte
**new_ptr
,
170 CORE_ADDR
*low
, CORE_ADDR
*high
,
171 enum bfd_endian byte_order
,
172 unsigned int addr_size
,
177 if (loc_ptr
== buf_end
)
178 return DEBUG_LOC_BUFFER_OVERFLOW
;
182 case DW_LLE_base_addressx
:
184 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
186 return DEBUG_LOC_BUFFER_OVERFLOW
;
187 *high
= dwarf2_read_addr_index (per_cu
, per_objfile
, u64
);
189 return DEBUG_LOC_BASE_ADDRESS
;
190 case DW_LLE_startx_length
:
191 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
193 return DEBUG_LOC_BUFFER_OVERFLOW
;
194 *low
= dwarf2_read_addr_index (per_cu
, per_objfile
, u64
);
196 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
198 return DEBUG_LOC_BUFFER_OVERFLOW
;
201 return DEBUG_LOC_START_LENGTH
;
202 case DW_LLE_start_length
:
203 if (buf_end
- loc_ptr
< addr_size
)
204 return DEBUG_LOC_BUFFER_OVERFLOW
;
206 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
208 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
209 loc_ptr
+= addr_size
;
211 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
213 return DEBUG_LOC_BUFFER_OVERFLOW
;
216 return DEBUG_LOC_START_LENGTH
;
217 case DW_LLE_end_of_list
:
219 return DEBUG_LOC_END_OF_LIST
;
220 case DW_LLE_base_address
:
221 if (loc_ptr
+ addr_size
> buf_end
)
222 return DEBUG_LOC_BUFFER_OVERFLOW
;
224 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
226 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
227 loc_ptr
+= addr_size
;
229 return DEBUG_LOC_BASE_ADDRESS
;
230 case DW_LLE_offset_pair
:
231 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
233 return DEBUG_LOC_BUFFER_OVERFLOW
;
235 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
237 return DEBUG_LOC_BUFFER_OVERFLOW
;
240 return DEBUG_LOC_OFFSET_PAIR
;
241 /* Following cases are not supported yet. */
242 case DW_LLE_startx_endx
:
243 case DW_LLE_start_end
:
244 case DW_LLE_default_location
:
246 return DEBUG_LOC_INVALID_ENTRY
;
250 /* Decode the addresses in .debug_loc.dwo entry.
251 A pointer to the next byte to examine is returned in *NEW_PTR.
252 The encoded low,high addresses are return in *LOW,*HIGH.
253 The result indicates the kind of entry found. */
255 static enum debug_loc_kind
256 decode_debug_loc_dwo_addresses (dwarf2_per_cu_data
*per_cu
,
257 dwarf2_per_objfile
*per_objfile
,
258 const gdb_byte
*loc_ptr
,
259 const gdb_byte
*buf_end
,
260 const gdb_byte
**new_ptr
,
261 CORE_ADDR
*low
, CORE_ADDR
*high
,
262 enum bfd_endian byte_order
)
264 uint64_t low_index
, high_index
;
266 if (loc_ptr
== buf_end
)
267 return DEBUG_LOC_BUFFER_OVERFLOW
;
271 case DW_LLE_GNU_end_of_list_entry
:
273 return DEBUG_LOC_END_OF_LIST
;
274 case DW_LLE_GNU_base_address_selection_entry
:
276 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
278 return DEBUG_LOC_BUFFER_OVERFLOW
;
279 *high
= dwarf2_read_addr_index (per_cu
, per_objfile
, high_index
);
281 return DEBUG_LOC_BASE_ADDRESS
;
282 case DW_LLE_GNU_start_end_entry
:
283 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
285 return DEBUG_LOC_BUFFER_OVERFLOW
;
286 *low
= dwarf2_read_addr_index (per_cu
, per_objfile
, low_index
);
287 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
289 return DEBUG_LOC_BUFFER_OVERFLOW
;
290 *high
= dwarf2_read_addr_index (per_cu
, per_objfile
, high_index
);
292 return DEBUG_LOC_START_END
;
293 case DW_LLE_GNU_start_length_entry
:
294 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
296 return DEBUG_LOC_BUFFER_OVERFLOW
;
297 *low
= dwarf2_read_addr_index (per_cu
, per_objfile
, low_index
);
298 if (loc_ptr
+ 4 > buf_end
)
299 return DEBUG_LOC_BUFFER_OVERFLOW
;
301 *high
+= extract_unsigned_integer (loc_ptr
, 4, byte_order
);
302 *new_ptr
= loc_ptr
+ 4;
303 return DEBUG_LOC_START_LENGTH
;
305 return DEBUG_LOC_INVALID_ENTRY
;
309 /* A function for dealing with location lists. Given a
310 symbol baton (BATON) and a pc value (PC), find the appropriate
311 location expression, set *LOCEXPR_LENGTH, and return a pointer
312 to the beginning of the expression. Returns NULL on failure.
314 For now, only return the first matching location expression; there
315 can be more than one in the list. */
318 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
319 size_t *locexpr_length
, CORE_ADDR pc
)
321 dwarf2_per_objfile
*per_objfile
= baton
->per_objfile
;
322 struct objfile
*objfile
= per_objfile
->objfile
;
323 struct gdbarch
*gdbarch
= objfile
->arch ();
324 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
325 unsigned int addr_size
= baton
->per_cu
->addr_size ();
326 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
327 /* Adjust base_address for relocatable objects. */
328 CORE_ADDR base_offset
= baton
->per_objfile
->objfile
->text_section_offset ();
329 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
330 const gdb_byte
*loc_ptr
, *buf_end
;
332 loc_ptr
= baton
->data
;
333 buf_end
= baton
->data
+ baton
->size
;
337 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
339 enum debug_loc_kind kind
;
340 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
342 if (baton
->per_cu
->version () < 5 && baton
->from_dwo
)
343 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
345 loc_ptr
, buf_end
, &new_ptr
,
346 &low
, &high
, byte_order
);
347 else if (baton
->per_cu
->version () < 5)
348 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
350 byte_order
, addr_size
,
353 kind
= decode_debug_loclists_addresses (baton
->per_cu
,
355 loc_ptr
, buf_end
, &new_ptr
,
356 &low
, &high
, byte_order
,
357 addr_size
, signed_addr_p
);
362 case DEBUG_LOC_END_OF_LIST
:
365 case DEBUG_LOC_BASE_ADDRESS
:
366 base_address
= high
+ base_offset
;
368 case DEBUG_LOC_START_END
:
369 case DEBUG_LOC_START_LENGTH
:
370 case DEBUG_LOC_OFFSET_PAIR
:
372 case DEBUG_LOC_BUFFER_OVERFLOW
:
373 case DEBUG_LOC_INVALID_ENTRY
:
374 error (_("dwarf2_find_location_expression: "
375 "Corrupted DWARF expression."));
377 gdb_assert_not_reached ("bad debug_loc_kind");
380 /* Otherwise, a location expression entry.
381 If the entry is from a DWO, don't add base address: the entry is from
382 .debug_addr which already has the DWARF "base address". We still add
383 base_offset in case we're debugging a PIE executable. However, if the
384 entry is DW_LLE_offset_pair from a DWO, add the base address as the
385 operands are offsets relative to the applicable base address. */
386 if (baton
->from_dwo
&& kind
!= DEBUG_LOC_OFFSET_PAIR
)
394 high
+= base_address
;
397 if (baton
->per_cu
->version () < 5)
399 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
404 unsigned int bytes_read
;
406 length
= read_unsigned_leb128 (NULL
, loc_ptr
, &bytes_read
);
407 loc_ptr
+= bytes_read
;
410 if (low
== high
&& pc
== low
)
412 /* This is entry PC record present only at entry point
413 of a function. Verify it is really the function entry point. */
415 const struct block
*pc_block
= block_for_pc (pc
);
416 struct symbol
*pc_func
= NULL
;
419 pc_func
= block_linkage_function (pc_block
);
421 if (pc_func
&& pc
== BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (pc_func
)))
423 *locexpr_length
= length
;
428 if (pc
>= low
&& pc
< high
)
430 *locexpr_length
= length
;
438 /* Implement find_frame_base_location method for LOC_BLOCK functions using
439 DWARF expression for its DW_AT_frame_base. */
442 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
443 const gdb_byte
**start
, size_t *length
)
445 struct dwarf2_locexpr_baton
*symbaton
446 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
448 *length
= symbaton
->size
;
449 *start
= symbaton
->data
;
452 /* Implement the struct symbol_block_ops::get_frame_base method for
453 LOC_BLOCK functions using a DWARF expression as its DW_AT_frame_base. */
456 locexpr_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
458 struct gdbarch
*gdbarch
;
460 struct dwarf2_locexpr_baton
*dlbaton
;
461 const gdb_byte
*start
;
463 struct value
*result
;
465 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
466 Thus, it's supposed to provide the find_frame_base_location method as
468 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
470 gdbarch
= get_frame_arch (frame
);
471 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
472 dlbaton
= (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
474 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
475 (framefunc
, get_frame_pc (frame
), &start
, &length
);
476 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
477 dlbaton
->per_cu
, dlbaton
->per_objfile
);
479 /* The DW_AT_frame_base attribute contains a location description which
480 computes the base address itself. However, the call to
481 dwarf2_evaluate_loc_desc returns a value representing a variable at
482 that address. The frame base address is thus this variable's
484 return value_address (result
);
487 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
488 function uses DWARF expression for its DW_AT_frame_base. */
490 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
492 locexpr_find_frame_base_location
,
493 locexpr_get_frame_base
496 /* Implement find_frame_base_location method for LOC_BLOCK functions using
497 DWARF location list for its DW_AT_frame_base. */
500 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
501 const gdb_byte
**start
, size_t *length
)
503 struct dwarf2_loclist_baton
*symbaton
504 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
506 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
509 /* Implement the struct symbol_block_ops::get_frame_base method for
510 LOC_BLOCK functions using a DWARF location list as its DW_AT_frame_base. */
513 loclist_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
515 struct gdbarch
*gdbarch
;
517 struct dwarf2_loclist_baton
*dlbaton
;
518 const gdb_byte
*start
;
520 struct value
*result
;
522 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
523 Thus, it's supposed to provide the find_frame_base_location method as
525 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
527 gdbarch
= get_frame_arch (frame
);
528 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
529 dlbaton
= (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
531 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
532 (framefunc
, get_frame_pc (frame
), &start
, &length
);
533 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
534 dlbaton
->per_cu
, dlbaton
->per_objfile
);
536 /* The DW_AT_frame_base attribute contains a location description which
537 computes the base address itself. However, the call to
538 dwarf2_evaluate_loc_desc returns a value representing a variable at
539 that address. The frame base address is thus this variable's
541 return value_address (result
);
544 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
545 function uses DWARF location list for its DW_AT_frame_base. */
547 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
549 loclist_find_frame_base_location
,
550 loclist_get_frame_base
553 /* See dwarf2loc.h. */
556 func_get_frame_base_dwarf_block (struct symbol
*framefunc
, CORE_ADDR pc
,
557 const gdb_byte
**start
, size_t *length
)
559 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
561 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
563 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
569 error (_("Could not find the frame base for \"%s\"."),
570 framefunc
->natural_name ());
574 get_frame_pc_for_per_cu_dwarf_call (void *baton
)
576 dwarf_expr_context
*ctx
= (dwarf_expr_context
*) baton
;
578 return ctx
->get_frame_pc ();
582 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
583 dwarf2_per_cu_data
*per_cu
, dwarf2_per_objfile
*per_objfile
)
585 struct dwarf2_locexpr_baton block
;
587 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
, per_objfile
,
588 get_frame_pc_for_per_cu_dwarf_call
,
591 /* DW_OP_call_ref is currently not supported. */
592 gdb_assert (block
.per_cu
== per_cu
);
594 ctx
->eval (block
.data
, block
.size
);
597 /* Given context CTX, section offset SECT_OFF, and compilation unit
598 data PER_CU, execute the "variable value" operation on the DIE
599 found at SECT_OFF. */
601 static struct value
*
602 sect_variable_value (struct dwarf_expr_context
*ctx
, sect_offset sect_off
,
603 dwarf2_per_cu_data
*per_cu
,
604 dwarf2_per_objfile
*per_objfile
)
606 struct type
*die_type
607 = dwarf2_fetch_die_type_sect_off (sect_off
, per_cu
, per_objfile
);
609 if (die_type
== NULL
)
610 error (_("Bad DW_OP_GNU_variable_value DIE."));
612 /* Note: Things still work when the following test is removed. This
613 test and error is here to conform to the proposed specification. */
614 if (die_type
->code () != TYPE_CODE_INT
615 && die_type
->code () != TYPE_CODE_PTR
)
616 error (_("Type of DW_OP_GNU_variable_value DIE must be an integer or pointer."));
618 struct type
*type
= lookup_pointer_type (die_type
);
619 struct frame_info
*frame
= get_selected_frame (_("No frame selected."));
620 return indirect_synthetic_pointer (sect_off
, 0, per_cu
, per_objfile
, frame
,
624 class dwarf_evaluate_loc_desc
: public dwarf_expr_context
627 dwarf_evaluate_loc_desc (dwarf2_per_objfile
*per_objfile
)
628 : dwarf_expr_context (per_objfile
)
631 struct frame_info
*frame
;
632 struct dwarf2_per_cu_data
*per_cu
;
633 CORE_ADDR obj_address
;
635 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
636 the frame in BATON. */
638 CORE_ADDR
get_frame_cfa () override
640 return dwarf2_frame_cfa (frame
);
643 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
644 the frame in BATON. */
646 CORE_ADDR
get_frame_pc () override
648 return get_frame_address_in_block (frame
);
651 /* Using the objfile specified in BATON, find the address for the
652 current thread's thread-local storage with offset OFFSET. */
653 CORE_ADDR
get_tls_address (CORE_ADDR offset
) override
655 return target_translate_tls_address (per_objfile
->objfile
, offset
);
658 /* Helper interface of per_cu_dwarf_call for
659 dwarf2_evaluate_loc_desc. */
661 void dwarf_call (cu_offset die_offset
) override
663 per_cu_dwarf_call (this, die_offset
, per_cu
, per_objfile
);
666 /* Helper interface of sect_variable_value for
667 dwarf2_evaluate_loc_desc. */
669 struct value
*dwarf_variable_value (sect_offset sect_off
) override
671 return sect_variable_value (this, sect_off
, per_cu
, per_objfile
);
674 struct type
*get_base_type (cu_offset die_offset
, int size
) override
676 struct type
*result
= dwarf2_get_die_type (die_offset
, per_cu
, per_objfile
);
678 error (_("Could not find type for DW_OP_const_type"));
679 if (size
!= 0 && TYPE_LENGTH (result
) != size
)
680 error (_("DW_OP_const_type has different sizes for type and data"));
684 /* Callback function for dwarf2_evaluate_loc_desc.
685 Fetch the address indexed by DW_OP_addrx or DW_OP_GNU_addr_index. */
687 CORE_ADDR
get_addr_index (unsigned int index
) override
689 return dwarf2_read_addr_index (per_cu
, per_objfile
, index
);
692 /* Callback function for get_object_address. Return the address of the VLA
695 CORE_ADDR
get_object_address () override
697 if (obj_address
== 0)
698 error (_("Location address is not set."));
702 /* Execute DWARF block of call_site_parameter which matches KIND and
703 KIND_U. Choose DEREF_SIZE value of that parameter. Search
704 caller of this objects's frame.
706 The caller can be from a different CU - per_cu_dwarf_call
707 implementation can be more simple as it does not support cross-CU
710 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
711 union call_site_parameter_u kind_u
,
712 int deref_size
) override
714 struct frame_info
*caller_frame
;
715 dwarf2_per_cu_data
*caller_per_cu
;
716 dwarf2_per_objfile
*caller_per_objfile
;
717 struct call_site_parameter
*parameter
;
718 const gdb_byte
*data_src
;
721 caller_frame
= get_prev_frame (frame
);
723 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
725 &caller_per_objfile
);
726 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
727 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
729 /* DEREF_SIZE size is not verified here. */
730 if (data_src
== NULL
)
731 throw_error (NO_ENTRY_VALUE_ERROR
,
732 _("Cannot resolve DW_AT_call_data_value"));
734 /* We are about to evaluate an expression in the context of the caller
735 of the current frame. This evaluation context may be different from
736 the current (callee's) context), so temporarily set the caller's context.
738 It is possible for the caller to be from a different objfile from the
739 callee if the call is made through a function pointer. */
740 scoped_restore save_frame
= make_scoped_restore (&this->frame
,
742 scoped_restore save_per_cu
= make_scoped_restore (&this->per_cu
,
744 scoped_restore save_obj_addr
= make_scoped_restore (&this->obj_address
,
746 scoped_restore save_per_objfile
= make_scoped_restore (&this->per_objfile
,
749 scoped_restore save_arch
= make_scoped_restore (&this->gdbarch
);
750 this->gdbarch
= this->per_objfile
->objfile
->arch ();
751 scoped_restore save_addr_size
= make_scoped_restore (&this->addr_size
);
752 this->addr_size
= this->per_cu
->addr_size ();
754 this->eval (data_src
, size
);
757 /* Using the frame specified in BATON, find the location expression
758 describing the frame base. Return a pointer to it in START and
759 its length in LENGTH. */
760 void get_frame_base (const gdb_byte
**start
, size_t * length
) override
762 /* FIXME: cagney/2003-03-26: This code should be using
763 get_frame_base_address(), and then implement a dwarf2 specific
765 struct symbol
*framefunc
;
766 const struct block
*bl
= get_frame_block (frame
, NULL
);
769 error (_("frame address is not available."));
771 /* Use block_linkage_function, which returns a real (not inlined)
772 function, instead of get_frame_function, which may return an
774 framefunc
= block_linkage_function (bl
);
776 /* If we found a frame-relative symbol then it was certainly within
777 some function associated with a frame. If we can't find the frame,
778 something has gone wrong. */
779 gdb_assert (framefunc
!= NULL
);
781 func_get_frame_base_dwarf_block (framefunc
,
782 get_frame_address_in_block (frame
),
786 /* Read memory at ADDR (length LEN) into BUF. */
788 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
790 read_memory (addr
, buf
, len
);
793 /* Using the frame specified in BATON, return the value of register
794 REGNUM, treated as a pointer. */
795 CORE_ADDR
read_addr_from_reg (int dwarf_regnum
) override
797 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
798 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
800 return address_from_register (regnum
, frame
);
803 /* Implement "get_reg_value" callback. */
805 struct value
*get_reg_value (struct type
*type
, int dwarf_regnum
) override
807 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
808 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
810 return value_from_register (type
, regnum
, frame
);
814 /* See dwarf2loc.h. */
816 unsigned int entry_values_debug
= 0;
818 /* Helper to set entry_values_debug. */
821 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
822 struct cmd_list_element
*c
, const char *value
)
824 fprintf_filtered (file
,
825 _("Entry values and tail call frames debugging is %s.\n"),
829 /* Find DW_TAG_call_site's DW_AT_call_target address.
830 CALLER_FRAME (for registers) can be NULL if it is not known. This function
831 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
834 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
835 struct call_site
*call_site
,
836 struct frame_info
*caller_frame
)
838 switch (FIELD_LOC_KIND (call_site
->target
))
840 case FIELD_LOC_KIND_DWARF_BLOCK
:
842 struct dwarf2_locexpr_baton
*dwarf_block
;
844 struct type
*caller_core_addr_type
;
845 struct gdbarch
*caller_arch
;
847 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
848 if (dwarf_block
== NULL
)
850 struct bound_minimal_symbol msym
;
852 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
853 throw_error (NO_ENTRY_VALUE_ERROR
,
854 _("DW_AT_call_target is not specified at %s in %s"),
855 paddress (call_site_gdbarch
, call_site
->pc
),
856 (msym
.minsym
== NULL
? "???"
857 : msym
.minsym
->print_name ()));
860 if (caller_frame
== NULL
)
862 struct bound_minimal_symbol msym
;
864 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
865 throw_error (NO_ENTRY_VALUE_ERROR
,
866 _("DW_AT_call_target DWARF block resolving "
867 "requires known frame which is currently not "
868 "available at %s in %s"),
869 paddress (call_site_gdbarch
, call_site
->pc
),
870 (msym
.minsym
== NULL
? "???"
871 : msym
.minsym
->print_name ()));
874 caller_arch
= get_frame_arch (caller_frame
);
875 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
876 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
877 dwarf_block
->data
, dwarf_block
->size
,
879 dwarf_block
->per_objfile
);
880 /* DW_AT_call_target is a DWARF expression, not a DWARF location. */
881 if (VALUE_LVAL (val
) == lval_memory
)
882 return value_address (val
);
884 return value_as_address (val
);
887 case FIELD_LOC_KIND_PHYSNAME
:
889 const char *physname
;
890 struct bound_minimal_symbol msym
;
892 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
894 /* Handle both the mangled and demangled PHYSNAME. */
895 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
896 if (msym
.minsym
== NULL
)
898 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
899 throw_error (NO_ENTRY_VALUE_ERROR
,
900 _("Cannot find function \"%s\" for a call site target "
902 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
903 (msym
.minsym
== NULL
? "???"
904 : msym
.minsym
->print_name ()));
907 return BMSYMBOL_VALUE_ADDRESS (msym
);
910 case FIELD_LOC_KIND_PHYSADDR
:
911 return FIELD_STATIC_PHYSADDR (call_site
->target
);
914 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
918 /* Convert function entry point exact address ADDR to the function which is
919 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
920 NO_ENTRY_VALUE_ERROR otherwise. */
922 static struct symbol
*
923 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
925 struct symbol
*sym
= find_pc_function (addr
);
928 if (sym
== NULL
|| BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
929 throw_error (NO_ENTRY_VALUE_ERROR
,
930 _("DW_TAG_call_site resolving failed to find function "
931 "name for address %s"),
932 paddress (gdbarch
, addr
));
934 type
= SYMBOL_TYPE (sym
);
935 gdb_assert (type
->code () == TYPE_CODE_FUNC
);
936 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
941 /* Verify function with entry point exact address ADDR can never call itself
942 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
943 can call itself via tail calls.
945 If a funtion can tail call itself its entry value based parameters are
946 unreliable. There is no verification whether the value of some/all
947 parameters is unchanged through the self tail call, we expect if there is
948 a self tail call all the parameters can be modified. */
951 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
955 /* The verification is completely unordered. Track here function addresses
956 which still need to be iterated. */
957 std::vector
<CORE_ADDR
> todo
;
959 /* Track here CORE_ADDRs which were already visited. */
960 std::unordered_set
<CORE_ADDR
> addr_hash
;
962 todo
.push_back (verify_addr
);
963 while (!todo
.empty ())
965 struct symbol
*func_sym
;
966 struct call_site
*call_site
;
971 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
973 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
974 call_site
; call_site
= call_site
->tail_call_next
)
976 CORE_ADDR target_addr
;
978 /* CALLER_FRAME with registers is not available for tail-call jumped
980 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
982 if (target_addr
== verify_addr
)
984 struct bound_minimal_symbol msym
;
986 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
987 throw_error (NO_ENTRY_VALUE_ERROR
,
988 _("DW_OP_entry_value resolving has found "
989 "function \"%s\" at %s can call itself via tail "
991 (msym
.minsym
== NULL
? "???"
992 : msym
.minsym
->print_name ()),
993 paddress (gdbarch
, verify_addr
));
996 if (addr_hash
.insert (target_addr
).second
)
997 todo
.push_back (target_addr
);
1002 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
1003 ENTRY_VALUES_DEBUG. */
1006 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
1008 CORE_ADDR addr
= call_site
->pc
;
1009 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
1011 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
1012 (msym
.minsym
== NULL
? "???"
1013 : msym
.minsym
->print_name ()));
1017 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
1018 only top callers and bottom callees which are present in both. GDBARCH is
1019 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
1020 no remaining possibilities to provide unambiguous non-trivial result.
1021 RESULTP should point to NULL on the first (initialization) call. Caller is
1022 responsible for xfree of any RESULTP data. */
1025 chain_candidate (struct gdbarch
*gdbarch
,
1026 gdb::unique_xmalloc_ptr
<struct call_site_chain
> *resultp
,
1027 std::vector
<struct call_site
*> *chain
)
1029 long length
= chain
->size ();
1030 int callers
, callees
, idx
;
1032 if (*resultp
== NULL
)
1034 /* Create the initial chain containing all the passed PCs. */
1036 struct call_site_chain
*result
1037 = ((struct call_site_chain
*)
1038 xmalloc (sizeof (*result
)
1039 + sizeof (*result
->call_site
) * (length
- 1)));
1040 result
->length
= length
;
1041 result
->callers
= result
->callees
= length
;
1042 if (!chain
->empty ())
1043 memcpy (result
->call_site
, chain
->data (),
1044 sizeof (*result
->call_site
) * length
);
1045 resultp
->reset (result
);
1047 if (entry_values_debug
)
1049 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
1050 for (idx
= 0; idx
< length
; idx
++)
1051 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
1052 fputc_unfiltered ('\n', gdb_stdlog
);
1058 if (entry_values_debug
)
1060 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
1061 for (idx
= 0; idx
< length
; idx
++)
1062 tailcall_dump (gdbarch
, chain
->at (idx
));
1063 fputc_unfiltered ('\n', gdb_stdlog
);
1066 /* Intersect callers. */
1068 callers
= std::min ((long) (*resultp
)->callers
, length
);
1069 for (idx
= 0; idx
< callers
; idx
++)
1070 if ((*resultp
)->call_site
[idx
] != chain
->at (idx
))
1072 (*resultp
)->callers
= idx
;
1076 /* Intersect callees. */
1078 callees
= std::min ((long) (*resultp
)->callees
, length
);
1079 for (idx
= 0; idx
< callees
; idx
++)
1080 if ((*resultp
)->call_site
[(*resultp
)->length
- 1 - idx
]
1081 != chain
->at (length
- 1 - idx
))
1083 (*resultp
)->callees
= idx
;
1087 if (entry_values_debug
)
1089 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
1090 for (idx
= 0; idx
< (*resultp
)->callers
; idx
++)
1091 tailcall_dump (gdbarch
, (*resultp
)->call_site
[idx
]);
1092 fputs_unfiltered (" |", gdb_stdlog
);
1093 for (idx
= 0; idx
< (*resultp
)->callees
; idx
++)
1094 tailcall_dump (gdbarch
,
1095 (*resultp
)->call_site
[(*resultp
)->length
1096 - (*resultp
)->callees
+ idx
]);
1097 fputc_unfiltered ('\n', gdb_stdlog
);
1100 if ((*resultp
)->callers
== 0 && (*resultp
)->callees
== 0)
1102 /* There are no common callers or callees. It could be also a direct
1103 call (which has length 0) with ambiguous possibility of an indirect
1104 call - CALLERS == CALLEES == 0 is valid during the first allocation
1105 but any subsequence processing of such entry means ambiguity. */
1106 resultp
->reset (NULL
);
1110 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
1111 PC again. In such case there must be two different code paths to reach
1112 it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
1113 gdb_assert ((*resultp
)->callers
+ (*resultp
)->callees
<= (*resultp
)->length
);
1116 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1117 assumed frames between them use GDBARCH. Use depth first search so we can
1118 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
1119 would have needless GDB stack overhead. Any unreliability results
1120 in thrown NO_ENTRY_VALUE_ERROR. */
1122 static gdb::unique_xmalloc_ptr
<call_site_chain
>
1123 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1124 CORE_ADDR callee_pc
)
1126 CORE_ADDR save_callee_pc
= callee_pc
;
1127 gdb::unique_xmalloc_ptr
<struct call_site_chain
> retval
;
1128 struct call_site
*call_site
;
1130 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
1131 call_site nor any possible call_site at CALLEE_PC's function is there.
1132 Any CALL_SITE in CHAIN will be iterated to its siblings - via
1133 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
1134 std::vector
<struct call_site
*> chain
;
1136 /* We are not interested in the specific PC inside the callee function. */
1137 callee_pc
= get_pc_function_start (callee_pc
);
1139 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
1140 paddress (gdbarch
, save_callee_pc
));
1142 /* Mark CALL_SITEs so we do not visit the same ones twice. */
1143 std::unordered_set
<CORE_ADDR
> addr_hash
;
1145 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
1146 at the target's function. All the possible tail call sites in the
1147 target's function will get iterated as already pushed into CHAIN via their
1149 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1153 CORE_ADDR target_func_addr
;
1154 struct call_site
*target_call_site
;
1156 /* CALLER_FRAME with registers is not available for tail-call jumped
1158 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
1160 if (target_func_addr
== callee_pc
)
1162 chain_candidate (gdbarch
, &retval
, &chain
);
1166 /* There is no way to reach CALLEE_PC again as we would prevent
1167 entering it twice as being already marked in ADDR_HASH. */
1168 target_call_site
= NULL
;
1172 struct symbol
*target_func
;
1174 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
1175 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
1180 /* Attempt to visit TARGET_CALL_SITE. */
1182 if (target_call_site
)
1184 if (addr_hash
.insert (target_call_site
->pc
).second
)
1186 /* Successfully entered TARGET_CALL_SITE. */
1188 chain
.push_back (target_call_site
);
1193 /* Backtrack (without revisiting the originating call_site). Try the
1194 callers's sibling; if there isn't any try the callers's callers's
1197 target_call_site
= NULL
;
1198 while (!chain
.empty ())
1200 call_site
= chain
.back ();
1203 size_t removed
= addr_hash
.erase (call_site
->pc
);
1204 gdb_assert (removed
== 1);
1206 target_call_site
= call_site
->tail_call_next
;
1207 if (target_call_site
)
1211 while (target_call_site
);
1216 call_site
= chain
.back ();
1221 struct bound_minimal_symbol msym_caller
, msym_callee
;
1223 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
1224 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
1225 throw_error (NO_ENTRY_VALUE_ERROR
,
1226 _("There are no unambiguously determinable intermediate "
1227 "callers or callees between caller function \"%s\" at %s "
1228 "and callee function \"%s\" at %s"),
1229 (msym_caller
.minsym
== NULL
1230 ? "???" : msym_caller
.minsym
->print_name ()),
1231 paddress (gdbarch
, caller_pc
),
1232 (msym_callee
.minsym
== NULL
1233 ? "???" : msym_callee
.minsym
->print_name ()),
1234 paddress (gdbarch
, callee_pc
));
1240 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1241 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
1242 constructed return NULL. */
1244 gdb::unique_xmalloc_ptr
<call_site_chain
>
1245 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1246 CORE_ADDR callee_pc
)
1248 gdb::unique_xmalloc_ptr
<call_site_chain
> retval
;
1252 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
1254 catch (const gdb_exception_error
&e
)
1256 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
1258 if (entry_values_debug
)
1259 exception_print (gdb_stdout
, e
);
1270 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1273 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1274 enum call_site_parameter_kind kind
,
1275 union call_site_parameter_u kind_u
)
1277 if (kind
== parameter
->kind
)
1280 case CALL_SITE_PARAMETER_DWARF_REG
:
1281 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1282 case CALL_SITE_PARAMETER_FB_OFFSET
:
1283 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1284 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1285 return kind_u
.param_cu_off
== parameter
->u
.param_cu_off
;
1290 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1291 FRAME is for callee.
1293 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1296 static struct call_site_parameter
*
1297 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1298 enum call_site_parameter_kind kind
,
1299 union call_site_parameter_u kind_u
,
1300 dwarf2_per_cu_data
**per_cu_return
,
1301 dwarf2_per_objfile
**per_objfile_return
)
1303 CORE_ADDR func_addr
, caller_pc
;
1304 struct gdbarch
*gdbarch
;
1305 struct frame_info
*caller_frame
;
1306 struct call_site
*call_site
;
1308 /* Initialize it just to avoid a GCC false warning. */
1309 struct call_site_parameter
*parameter
= NULL
;
1310 CORE_ADDR target_addr
;
1312 while (get_frame_type (frame
) == INLINE_FRAME
)
1314 frame
= get_prev_frame (frame
);
1315 gdb_assert (frame
!= NULL
);
1318 func_addr
= get_frame_func (frame
);
1319 gdbarch
= get_frame_arch (frame
);
1320 caller_frame
= get_prev_frame (frame
);
1321 if (gdbarch
!= frame_unwind_arch (frame
))
1323 struct bound_minimal_symbol msym
1324 = lookup_minimal_symbol_by_pc (func_addr
);
1325 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1327 throw_error (NO_ENTRY_VALUE_ERROR
,
1328 _("DW_OP_entry_value resolving callee gdbarch %s "
1329 "(of %s (%s)) does not match caller gdbarch %s"),
1330 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1331 paddress (gdbarch
, func_addr
),
1332 (msym
.minsym
== NULL
? "???"
1333 : msym
.minsym
->print_name ()),
1334 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1337 if (caller_frame
== NULL
)
1339 struct bound_minimal_symbol msym
1340 = lookup_minimal_symbol_by_pc (func_addr
);
1342 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_entry_value resolving "
1343 "requires caller of %s (%s)"),
1344 paddress (gdbarch
, func_addr
),
1345 (msym
.minsym
== NULL
? "???"
1346 : msym
.minsym
->print_name ()));
1348 caller_pc
= get_frame_pc (caller_frame
);
1349 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1351 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1352 if (target_addr
!= func_addr
)
1354 struct minimal_symbol
*target_msym
, *func_msym
;
1356 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1357 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1358 throw_error (NO_ENTRY_VALUE_ERROR
,
1359 _("DW_OP_entry_value resolving expects callee %s at %s "
1360 "but the called frame is for %s at %s"),
1361 (target_msym
== NULL
? "???"
1362 : target_msym
->print_name ()),
1363 paddress (gdbarch
, target_addr
),
1364 func_msym
== NULL
? "???" : func_msym
->print_name (),
1365 paddress (gdbarch
, func_addr
));
1368 /* No entry value based parameters would be reliable if this function can
1369 call itself via tail calls. */
1370 func_verify_no_selftailcall (gdbarch
, func_addr
);
1372 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1374 parameter
= &call_site
->parameter
[iparams
];
1375 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1378 if (iparams
== call_site
->parameter_count
)
1380 struct minimal_symbol
*msym
1381 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1383 /* DW_TAG_call_site_parameter will be missing just if GCC could not
1384 determine its value. */
1385 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1386 "at DW_TAG_call_site %s at %s"),
1387 paddress (gdbarch
, caller_pc
),
1388 msym
== NULL
? "???" : msym
->print_name ());
1391 *per_cu_return
= call_site
->per_cu
;
1392 *per_objfile_return
= call_site
->per_objfile
;
1396 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1397 the normal DW_AT_call_value block. Otherwise return the
1398 DW_AT_call_data_value (dereferenced) block.
1400 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1403 Function always returns non-NULL, non-optimized out value. It throws
1404 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1406 static struct value
*
1407 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1408 CORE_ADDR deref_size
, struct type
*type
,
1409 struct frame_info
*caller_frame
,
1410 dwarf2_per_cu_data
*per_cu
,
1411 dwarf2_per_objfile
*per_objfile
)
1413 const gdb_byte
*data_src
;
1417 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1418 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1420 /* DEREF_SIZE size is not verified here. */
1421 if (data_src
== NULL
)
1422 throw_error (NO_ENTRY_VALUE_ERROR
,
1423 _("Cannot resolve DW_AT_call_data_value"));
1425 /* DW_AT_call_value is a DWARF expression, not a DWARF
1426 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1428 data
= (gdb_byte
*) alloca (size
+ 1);
1429 memcpy (data
, data_src
, size
);
1430 data
[size
] = DW_OP_stack_value
;
1432 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
,
1436 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1437 the indirect method on it, that is use its stored target value, the sole
1438 purpose of entry_data_value_funcs.. */
1440 static struct value
*
1441 entry_data_value_coerce_ref (const struct value
*value
)
1443 struct type
*checked_type
= check_typedef (value_type (value
));
1444 struct value
*target_val
;
1446 if (!TYPE_IS_REFERENCE (checked_type
))
1449 target_val
= (struct value
*) value_computed_closure (value
);
1450 value_incref (target_val
);
1454 /* Implement copy_closure. */
1457 entry_data_value_copy_closure (const struct value
*v
)
1459 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1461 value_incref (target_val
);
1465 /* Implement free_closure. */
1468 entry_data_value_free_closure (struct value
*v
)
1470 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1472 value_decref (target_val
);
1475 /* Vector for methods for an entry value reference where the referenced value
1476 is stored in the caller. On the first dereference use
1477 DW_AT_call_data_value in the caller. */
1479 static const struct lval_funcs entry_data_value_funcs
=
1483 NULL
, /* indirect */
1484 entry_data_value_coerce_ref
,
1485 NULL
, /* check_synthetic_pointer */
1486 entry_data_value_copy_closure
,
1487 entry_data_value_free_closure
1490 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1491 are used to match DW_AT_location at the caller's
1492 DW_TAG_call_site_parameter.
1494 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1495 cannot resolve the parameter for any reason. */
1497 static struct value
*
1498 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1499 enum call_site_parameter_kind kind
,
1500 union call_site_parameter_u kind_u
)
1502 struct type
*checked_type
= check_typedef (type
);
1503 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1504 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1505 struct value
*outer_val
, *target_val
, *val
;
1506 struct call_site_parameter
*parameter
;
1507 dwarf2_per_cu_data
*caller_per_cu
;
1508 dwarf2_per_objfile
*caller_per_objfile
;
1510 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1512 &caller_per_objfile
);
1514 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1517 caller_per_objfile
);
1519 /* Check if DW_AT_call_data_value cannot be used. If it should be
1520 used and it is not available do not fall back to OUTER_VAL - dereferencing
1521 TYPE_CODE_REF with non-entry data value would give current value - not the
1524 if (!TYPE_IS_REFERENCE (checked_type
)
1525 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1528 target_val
= dwarf_entry_parameter_to_value (parameter
,
1529 TYPE_LENGTH (target_type
),
1530 target_type
, caller_frame
,
1532 caller_per_objfile
);
1534 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1535 release_value (target_val
).release ());
1537 /* Copy the referencing pointer to the new computed value. */
1538 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1539 TYPE_LENGTH (checked_type
));
1540 set_value_lazy (val
, 0);
1545 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1546 SIZE are DWARF block used to match DW_AT_location at the caller's
1547 DW_TAG_call_site_parameter.
1549 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1550 cannot resolve the parameter for any reason. */
1552 static struct value
*
1553 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1554 const gdb_byte
*block
, size_t block_len
)
1556 union call_site_parameter_u kind_u
;
1558 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1559 if (kind_u
.dwarf_reg
!= -1)
1560 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1563 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1564 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1567 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1568 suppressed during normal operation. The expression can be arbitrary if
1569 there is no caller-callee entry value binding expected. */
1570 throw_error (NO_ENTRY_VALUE_ERROR
,
1571 _("DWARF-2 expression error: DW_OP_entry_value is supported "
1572 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1575 struct piece_closure
1577 /* Reference count. */
1580 /* The objfile from which this closure's expression came. */
1581 dwarf2_per_objfile
*per_objfile
= nullptr;
1583 /* The CU from which this closure's expression came. */
1584 struct dwarf2_per_cu_data
*per_cu
= NULL
;
1586 /* The pieces describing this variable. */
1587 std::vector
<dwarf_expr_piece
> pieces
;
1589 /* Frame ID of frame to which a register value is relative, used
1590 only by DWARF_VALUE_REGISTER. */
1591 struct frame_id frame_id
;
1594 /* Allocate a closure for a value formed from separately-described
1597 static struct piece_closure
*
1598 allocate_piece_closure (dwarf2_per_cu_data
*per_cu
,
1599 dwarf2_per_objfile
*per_objfile
,
1600 std::vector
<dwarf_expr_piece
> &&pieces
,
1601 struct frame_info
*frame
)
1603 struct piece_closure
*c
= new piece_closure
;
1606 /* We must capture this here due to sharing of DWARF state. */
1607 c
->per_objfile
= per_objfile
;
1609 c
->pieces
= std::move (pieces
);
1611 c
->frame_id
= null_frame_id
;
1613 c
->frame_id
= get_frame_id (frame
);
1615 for (dwarf_expr_piece
&piece
: c
->pieces
)
1616 if (piece
.location
== DWARF_VALUE_STACK
)
1617 value_incref (piece
.v
.value
);
1622 /* Return the number of bytes overlapping a contiguous chunk of N_BITS
1623 bits whose first bit is located at bit offset START. */
1626 bits_to_bytes (ULONGEST start
, ULONGEST n_bits
)
1628 return (start
% 8 + n_bits
+ 7) / 8;
1631 /* Read or write a pieced value V. If FROM != NULL, operate in "write
1632 mode": copy FROM into the pieces comprising V. If FROM == NULL,
1633 operate in "read mode": fetch the contents of the (lazy) value V by
1634 composing it from its pieces. */
1637 rw_pieced_value (struct value
*v
, struct value
*from
)
1640 LONGEST offset
= 0, max_offset
;
1641 ULONGEST bits_to_skip
;
1642 gdb_byte
*v_contents
;
1643 const gdb_byte
*from_contents
;
1644 struct piece_closure
*c
1645 = (struct piece_closure
*) value_computed_closure (v
);
1646 gdb::byte_vector buffer
;
1647 bool bits_big_endian
= type_byte_order (value_type (v
)) == BFD_ENDIAN_BIG
;
1651 from_contents
= value_contents (from
);
1656 if (value_type (v
) != value_enclosing_type (v
))
1657 internal_error (__FILE__
, __LINE__
,
1658 _("Should not be able to create a lazy value with "
1659 "an enclosing type"));
1660 v_contents
= value_contents_raw (v
);
1661 from_contents
= NULL
;
1664 bits_to_skip
= 8 * value_offset (v
);
1665 if (value_bitsize (v
))
1667 bits_to_skip
+= (8 * value_offset (value_parent (v
))
1668 + value_bitpos (v
));
1670 && (type_byte_order (value_type (from
))
1673 /* Use the least significant bits of FROM. */
1674 max_offset
= 8 * TYPE_LENGTH (value_type (from
));
1675 offset
= max_offset
- value_bitsize (v
);
1678 max_offset
= value_bitsize (v
);
1681 max_offset
= 8 * TYPE_LENGTH (value_type (v
));
1683 /* Advance to the first non-skipped piece. */
1684 for (i
= 0; i
< c
->pieces
.size () && bits_to_skip
>= c
->pieces
[i
].size
; i
++)
1685 bits_to_skip
-= c
->pieces
[i
].size
;
1687 for (; i
< c
->pieces
.size () && offset
< max_offset
; i
++)
1689 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1690 size_t this_size_bits
, this_size
;
1692 this_size_bits
= p
->size
- bits_to_skip
;
1693 if (this_size_bits
> max_offset
- offset
)
1694 this_size_bits
= max_offset
- offset
;
1696 switch (p
->location
)
1698 case DWARF_VALUE_REGISTER
:
1700 struct frame_info
*frame
= frame_find_by_id (c
->frame_id
);
1701 struct gdbarch
*arch
= get_frame_arch (frame
);
1702 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, p
->v
.regno
);
1703 ULONGEST reg_bits
= 8 * register_size (arch
, gdb_regnum
);
1706 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1707 && p
->offset
+ p
->size
< reg_bits
)
1709 /* Big-endian, and we want less than full size. */
1710 bits_to_skip
+= reg_bits
- (p
->offset
+ p
->size
);
1713 bits_to_skip
+= p
->offset
;
1715 this_size
= bits_to_bytes (bits_to_skip
, this_size_bits
);
1716 buffer
.resize (this_size
);
1721 if (!get_frame_register_bytes (frame
, gdb_regnum
,
1723 this_size
, buffer
.data (),
1727 mark_value_bits_optimized_out (v
, offset
,
1730 mark_value_bits_unavailable (v
, offset
,
1735 copy_bitwise (v_contents
, offset
,
1736 buffer
.data (), bits_to_skip
% 8,
1737 this_size_bits
, bits_big_endian
);
1742 if (bits_to_skip
% 8 != 0 || this_size_bits
% 8 != 0)
1744 /* Data is copied non-byte-aligned into the register.
1745 Need some bits from original register value. */
1746 get_frame_register_bytes (frame
, gdb_regnum
,
1748 this_size
, buffer
.data (),
1751 throw_error (OPTIMIZED_OUT_ERROR
,
1752 _("Can't do read-modify-write to "
1753 "update bitfield; containing word "
1754 "has been optimized out"));
1756 throw_error (NOT_AVAILABLE_ERROR
,
1757 _("Can't do read-modify-write to "
1758 "update bitfield; containing word "
1762 copy_bitwise (buffer
.data (), bits_to_skip
% 8,
1763 from_contents
, offset
,
1764 this_size_bits
, bits_big_endian
);
1765 put_frame_register_bytes (frame
, gdb_regnum
,
1767 this_size
, buffer
.data ());
1772 case DWARF_VALUE_MEMORY
:
1774 bits_to_skip
+= p
->offset
;
1776 CORE_ADDR start_addr
= p
->v
.mem
.addr
+ bits_to_skip
/ 8;
1778 if (bits_to_skip
% 8 == 0 && this_size_bits
% 8 == 0
1781 /* Everything is byte-aligned; no buffer needed. */
1783 write_memory_with_notification (start_addr
,
1786 this_size_bits
/ 8);
1788 read_value_memory (v
, offset
,
1789 p
->v
.mem
.in_stack_memory
,
1790 p
->v
.mem
.addr
+ bits_to_skip
/ 8,
1791 v_contents
+ offset
/ 8,
1792 this_size_bits
/ 8);
1796 this_size
= bits_to_bytes (bits_to_skip
, this_size_bits
);
1797 buffer
.resize (this_size
);
1802 read_value_memory (v
, offset
,
1803 p
->v
.mem
.in_stack_memory
,
1804 p
->v
.mem
.addr
+ bits_to_skip
/ 8,
1805 buffer
.data (), this_size
);
1806 copy_bitwise (v_contents
, offset
,
1807 buffer
.data (), bits_to_skip
% 8,
1808 this_size_bits
, bits_big_endian
);
1813 if (bits_to_skip
% 8 != 0 || this_size_bits
% 8 != 0)
1817 /* Perform a single read for small sizes. */
1818 read_memory (start_addr
, buffer
.data (),
1823 /* Only the first and last bytes can possibly have
1825 read_memory (start_addr
, buffer
.data (), 1);
1826 read_memory (start_addr
+ this_size
- 1,
1827 &buffer
[this_size
- 1], 1);
1831 copy_bitwise (buffer
.data (), bits_to_skip
% 8,
1832 from_contents
, offset
,
1833 this_size_bits
, bits_big_endian
);
1834 write_memory_with_notification (start_addr
,
1841 case DWARF_VALUE_STACK
:
1845 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1849 gdbarch
*objfile_gdbarch
= c
->per_objfile
->objfile
->arch ();
1850 ULONGEST stack_value_size_bits
1851 = 8 * TYPE_LENGTH (value_type (p
->v
.value
));
1853 /* Use zeroes if piece reaches beyond stack value. */
1854 if (p
->offset
+ p
->size
> stack_value_size_bits
)
1857 /* Piece is anchored at least significant bit end. */
1858 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
1859 bits_to_skip
+= stack_value_size_bits
- p
->offset
- p
->size
;
1861 bits_to_skip
+= p
->offset
;
1863 copy_bitwise (v_contents
, offset
,
1864 value_contents_all (p
->v
.value
),
1866 this_size_bits
, bits_big_endian
);
1870 case DWARF_VALUE_LITERAL
:
1874 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1878 ULONGEST literal_size_bits
= 8 * p
->v
.literal
.length
;
1879 size_t n
= this_size_bits
;
1881 /* Cut off at the end of the implicit value. */
1882 bits_to_skip
+= p
->offset
;
1883 if (bits_to_skip
>= literal_size_bits
)
1885 if (n
> literal_size_bits
- bits_to_skip
)
1886 n
= literal_size_bits
- bits_to_skip
;
1888 copy_bitwise (v_contents
, offset
,
1889 p
->v
.literal
.data
, bits_to_skip
,
1890 n
, bits_big_endian
);
1894 case DWARF_VALUE_IMPLICIT_POINTER
:
1897 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1901 /* These bits show up as zeros -- but do not cause the value to
1902 be considered optimized-out. */
1905 case DWARF_VALUE_OPTIMIZED_OUT
:
1906 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1910 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1913 offset
+= this_size_bits
;
1920 read_pieced_value (struct value
*v
)
1922 rw_pieced_value (v
, NULL
);
1926 write_pieced_value (struct value
*to
, struct value
*from
)
1928 rw_pieced_value (to
, from
);
1931 /* An implementation of an lval_funcs method to see whether a value is
1932 a synthetic pointer. */
1935 check_pieced_synthetic_pointer (const struct value
*value
, LONGEST bit_offset
,
1938 struct piece_closure
*c
1939 = (struct piece_closure
*) value_computed_closure (value
);
1942 bit_offset
+= 8 * value_offset (value
);
1943 if (value_bitsize (value
))
1944 bit_offset
+= value_bitpos (value
);
1946 for (i
= 0; i
< c
->pieces
.size () && bit_length
> 0; i
++)
1948 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1949 size_t this_size_bits
= p
->size
;
1953 if (bit_offset
>= this_size_bits
)
1955 bit_offset
-= this_size_bits
;
1959 bit_length
-= this_size_bits
- bit_offset
;
1963 bit_length
-= this_size_bits
;
1965 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1972 /* A wrapper function for get_frame_address_in_block. */
1975 get_frame_address_in_block_wrapper (void *baton
)
1977 return get_frame_address_in_block ((struct frame_info
*) baton
);
1980 /* Fetch a DW_AT_const_value through a synthetic pointer. */
1982 static struct value
*
1983 fetch_const_value_from_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
1984 dwarf2_per_cu_data
*per_cu
,
1985 dwarf2_per_objfile
*per_objfile
,
1988 struct value
*result
= NULL
;
1989 const gdb_byte
*bytes
;
1992 auto_obstack temp_obstack
;
1993 bytes
= dwarf2_fetch_constant_bytes (die
, per_cu
, per_objfile
,
1994 &temp_obstack
, &len
);
1998 if (byte_offset
>= 0
1999 && byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) <= len
)
2001 bytes
+= byte_offset
;
2002 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
2005 invalid_synthetic_pointer ();
2008 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
2013 /* Fetch the value pointed to by a synthetic pointer. */
2015 static struct value
*
2016 indirect_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
2017 dwarf2_per_cu_data
*per_cu
,
2018 dwarf2_per_objfile
*per_objfile
,
2019 struct frame_info
*frame
, struct type
*type
,
2020 bool resolve_abstract_p
)
2022 /* Fetch the location expression of the DIE we're pointing to. */
2023 struct dwarf2_locexpr_baton baton
2024 = dwarf2_fetch_die_loc_sect_off (die
, per_cu
, per_objfile
,
2025 get_frame_address_in_block_wrapper
, frame
,
2026 resolve_abstract_p
);
2028 /* Get type of pointed-to DIE. */
2029 struct type
*orig_type
= dwarf2_fetch_die_type_sect_off (die
, per_cu
,
2031 if (orig_type
== NULL
)
2032 invalid_synthetic_pointer ();
2034 /* If pointed-to DIE has a DW_AT_location, evaluate it and return the
2035 resulting value. Otherwise, it may have a DW_AT_const_value instead,
2036 or it may've been optimized out. */
2037 if (baton
.data
!= NULL
)
2038 return dwarf2_evaluate_loc_desc_full (orig_type
, frame
, baton
.data
,
2039 baton
.size
, baton
.per_cu
,
2041 TYPE_TARGET_TYPE (type
),
2044 return fetch_const_value_from_synthetic_pointer (die
, byte_offset
, per_cu
,
2048 /* An implementation of an lval_funcs method to indirect through a
2049 pointer. This handles the synthetic pointer case when needed. */
2051 static struct value
*
2052 indirect_pieced_value (struct value
*value
)
2054 struct piece_closure
*c
2055 = (struct piece_closure
*) value_computed_closure (value
);
2057 struct frame_info
*frame
;
2060 struct dwarf_expr_piece
*piece
= NULL
;
2061 LONGEST byte_offset
;
2062 enum bfd_endian byte_order
;
2064 type
= check_typedef (value_type (value
));
2065 if (type
->code () != TYPE_CODE_PTR
)
2068 bit_length
= 8 * TYPE_LENGTH (type
);
2069 bit_offset
= 8 * value_offset (value
);
2070 if (value_bitsize (value
))
2071 bit_offset
+= value_bitpos (value
);
2073 for (i
= 0; i
< c
->pieces
.size () && bit_length
> 0; i
++)
2075 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2076 size_t this_size_bits
= p
->size
;
2080 if (bit_offset
>= this_size_bits
)
2082 bit_offset
-= this_size_bits
;
2086 bit_length
-= this_size_bits
- bit_offset
;
2090 bit_length
-= this_size_bits
;
2092 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2095 if (bit_length
!= 0)
2096 error (_("Invalid use of DW_OP_implicit_pointer"));
2102 gdb_assert (piece
!= NULL
);
2103 frame
= get_selected_frame (_("No frame selected."));
2105 /* This is an offset requested by GDB, such as value subscripts.
2106 However, due to how synthetic pointers are implemented, this is
2107 always presented to us as a pointer type. This means we have to
2108 sign-extend it manually as appropriate. Use raw
2109 extract_signed_integer directly rather than value_as_address and
2110 sign extend afterwards on architectures that would need it
2111 (mostly everywhere except MIPS, which has signed addresses) as
2112 the later would go through gdbarch_pointer_to_address and thus
2113 return a CORE_ADDR with high bits set on architectures that
2114 encode address spaces and other things in CORE_ADDR. */
2115 byte_order
= gdbarch_byte_order (get_frame_arch (frame
));
2116 byte_offset
= extract_signed_integer (value_contents (value
),
2117 TYPE_LENGTH (type
), byte_order
);
2118 byte_offset
+= piece
->v
.ptr
.offset
;
2120 return indirect_synthetic_pointer (piece
->v
.ptr
.die_sect_off
,
2121 byte_offset
, c
->per_cu
,
2122 c
->per_objfile
, frame
, type
);
2125 /* Implementation of the coerce_ref method of lval_funcs for synthetic C++
2128 static struct value
*
2129 coerce_pieced_ref (const struct value
*value
)
2131 struct type
*type
= check_typedef (value_type (value
));
2133 if (value_bits_synthetic_pointer (value
, value_embedded_offset (value
),
2134 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
2136 const struct piece_closure
*closure
2137 = (struct piece_closure
*) value_computed_closure (value
);
2138 struct frame_info
*frame
2139 = get_selected_frame (_("No frame selected."));
2141 /* gdb represents synthetic pointers as pieced values with a single
2143 gdb_assert (closure
!= NULL
);
2144 gdb_assert (closure
->pieces
.size () == 1);
2146 return indirect_synthetic_pointer
2147 (closure
->pieces
[0].v
.ptr
.die_sect_off
,
2148 closure
->pieces
[0].v
.ptr
.offset
,
2149 closure
->per_cu
, closure
->per_objfile
, frame
, type
);
2153 /* Else: not a synthetic reference; do nothing. */
2159 copy_pieced_value_closure (const struct value
*v
)
2161 struct piece_closure
*c
2162 = (struct piece_closure
*) value_computed_closure (v
);
2169 free_pieced_value_closure (struct value
*v
)
2171 struct piece_closure
*c
2172 = (struct piece_closure
*) value_computed_closure (v
);
2177 for (dwarf_expr_piece
&p
: c
->pieces
)
2178 if (p
.location
== DWARF_VALUE_STACK
)
2179 value_decref (p
.v
.value
);
2185 /* Functions for accessing a variable described by DW_OP_piece. */
2186 static const struct lval_funcs pieced_value_funcs
= {
2189 indirect_pieced_value
,
2191 check_pieced_synthetic_pointer
,
2192 copy_pieced_value_closure
,
2193 free_pieced_value_closure
2196 /* Evaluate a location description, starting at DATA and with length
2197 SIZE, to find the current location of variable of TYPE in the
2198 context of FRAME. If SUBOBJ_TYPE is non-NULL, return instead the
2199 location of the subobject of type SUBOBJ_TYPE at byte offset
2200 SUBOBJ_BYTE_OFFSET within the variable of type TYPE. */
2202 static struct value
*
2203 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2204 const gdb_byte
*data
, size_t size
,
2205 dwarf2_per_cu_data
*per_cu
,
2206 dwarf2_per_objfile
*per_objfile
,
2207 struct type
*subobj_type
,
2208 LONGEST subobj_byte_offset
)
2210 struct value
*retval
;
2212 if (subobj_type
== NULL
)
2215 subobj_byte_offset
= 0;
2217 else if (subobj_byte_offset
< 0)
2218 invalid_synthetic_pointer ();
2221 return allocate_optimized_out_value (subobj_type
);
2223 dwarf_evaluate_loc_desc
ctx (per_objfile
);
2225 ctx
.per_cu
= per_cu
;
2226 ctx
.obj_address
= 0;
2228 scoped_value_mark free_values
;
2230 ctx
.gdbarch
= per_objfile
->objfile
->arch ();
2231 ctx
.addr_size
= per_cu
->addr_size ();
2232 ctx
.ref_addr_size
= per_cu
->ref_addr_size ();
2236 ctx
.eval (data
, size
);
2238 catch (const gdb_exception_error
&ex
)
2240 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2242 free_values
.free_to_mark ();
2243 retval
= allocate_value (subobj_type
);
2244 mark_value_bytes_unavailable (retval
, 0,
2245 TYPE_LENGTH (subobj_type
));
2248 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2250 if (entry_values_debug
)
2251 exception_print (gdb_stdout
, ex
);
2252 free_values
.free_to_mark ();
2253 return allocate_optimized_out_value (subobj_type
);
2259 if (ctx
.pieces
.size () > 0)
2261 struct piece_closure
*c
;
2262 ULONGEST bit_size
= 0;
2264 for (dwarf_expr_piece
&piece
: ctx
.pieces
)
2265 bit_size
+= piece
.size
;
2266 /* Complain if the expression is larger than the size of the
2268 if (bit_size
> 8 * TYPE_LENGTH (type
))
2269 invalid_synthetic_pointer ();
2271 c
= allocate_piece_closure (per_cu
, per_objfile
, std::move (ctx
.pieces
),
2273 /* We must clean up the value chain after creating the piece
2274 closure but before allocating the result. */
2275 free_values
.free_to_mark ();
2276 retval
= allocate_computed_value (subobj_type
,
2277 &pieced_value_funcs
, c
);
2278 set_value_offset (retval
, subobj_byte_offset
);
2282 switch (ctx
.location
)
2284 case DWARF_VALUE_REGISTER
:
2286 struct gdbarch
*arch
= get_frame_arch (frame
);
2288 = longest_to_int (value_as_long (ctx
.fetch (0)));
2289 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, dwarf_regnum
);
2291 if (subobj_byte_offset
!= 0)
2292 error (_("cannot use offset on synthetic pointer to register"));
2293 free_values
.free_to_mark ();
2294 retval
= value_from_register (subobj_type
, gdb_regnum
, frame
);
2295 if (value_optimized_out (retval
))
2299 /* This means the register has undefined value / was
2300 not saved. As we're computing the location of some
2301 variable etc. in the program, not a value for
2302 inspecting a register ($pc, $sp, etc.), return a
2303 generic optimized out value instead, so that we show
2304 <optimized out> instead of <not saved>. */
2305 tmp
= allocate_value (subobj_type
);
2306 value_contents_copy (tmp
, 0, retval
, 0,
2307 TYPE_LENGTH (subobj_type
));
2313 case DWARF_VALUE_MEMORY
:
2315 struct type
*ptr_type
;
2316 CORE_ADDR address
= ctx
.fetch_address (0);
2317 bool in_stack_memory
= ctx
.fetch_in_stack_memory (0);
2319 /* DW_OP_deref_size (and possibly other operations too) may
2320 create a pointer instead of an address. Ideally, the
2321 pointer to address conversion would be performed as part
2322 of those operations, but the type of the object to
2323 which the address refers is not known at the time of
2324 the operation. Therefore, we do the conversion here
2325 since the type is readily available. */
2327 switch (subobj_type
->code ())
2329 case TYPE_CODE_FUNC
:
2330 case TYPE_CODE_METHOD
:
2331 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_func_ptr
;
2334 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_data_ptr
;
2337 address
= value_as_address (value_from_pointer (ptr_type
, address
));
2339 free_values
.free_to_mark ();
2340 retval
= value_at_lazy (subobj_type
,
2341 address
+ subobj_byte_offset
);
2342 if (in_stack_memory
)
2343 set_value_stack (retval
, 1);
2347 case DWARF_VALUE_STACK
:
2349 struct value
*value
= ctx
.fetch (0);
2350 size_t n
= TYPE_LENGTH (value_type (value
));
2351 size_t len
= TYPE_LENGTH (subobj_type
);
2352 size_t max
= TYPE_LENGTH (type
);
2353 gdbarch
*objfile_gdbarch
= per_objfile
->objfile
->arch ();
2355 if (subobj_byte_offset
+ len
> max
)
2356 invalid_synthetic_pointer ();
2358 /* Preserve VALUE because we are going to free values back
2359 to the mark, but we still need the value contents
2361 value_ref_ptr value_holder
= value_ref_ptr::new_reference (value
);
2362 free_values
.free_to_mark ();
2364 retval
= allocate_value (subobj_type
);
2366 /* The given offset is relative to the actual object. */
2367 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2368 subobj_byte_offset
+= n
- max
;
2370 memcpy (value_contents_raw (retval
),
2371 value_contents_all (value
) + subobj_byte_offset
, len
);
2375 case DWARF_VALUE_LITERAL
:
2378 size_t n
= TYPE_LENGTH (subobj_type
);
2380 if (subobj_byte_offset
+ n
> ctx
.len
)
2381 invalid_synthetic_pointer ();
2383 free_values
.free_to_mark ();
2384 retval
= allocate_value (subobj_type
);
2385 contents
= value_contents_raw (retval
);
2386 memcpy (contents
, ctx
.data
+ subobj_byte_offset
, n
);
2390 case DWARF_VALUE_OPTIMIZED_OUT
:
2391 free_values
.free_to_mark ();
2392 retval
= allocate_optimized_out_value (subobj_type
);
2395 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2396 operation by execute_stack_op. */
2397 case DWARF_VALUE_IMPLICIT_POINTER
:
2398 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2399 it can only be encountered when making a piece. */
2401 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2405 set_value_initialized (retval
, ctx
.initialized
);
2410 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2411 passes 0 as the byte_offset. */
2414 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2415 const gdb_byte
*data
, size_t size
,
2416 dwarf2_per_cu_data
*per_cu
,
2417 dwarf2_per_objfile
*per_objfile
)
2419 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
,
2420 per_objfile
, NULL
, 0);
2423 /* A specialization of dwarf_evaluate_loc_desc that is used by
2424 dwarf2_locexpr_baton_eval. This subclass exists to handle the case
2425 where a caller of dwarf2_locexpr_baton_eval passes in some data,
2426 but with the address being 0. In this situation, we arrange for
2427 memory reads to come from the passed-in buffer. */
2429 struct evaluate_for_locexpr_baton
: public dwarf_evaluate_loc_desc
2431 evaluate_for_locexpr_baton (dwarf2_per_objfile
*per_objfile
)
2432 : dwarf_evaluate_loc_desc (per_objfile
)
2435 /* The data that was passed in. */
2436 gdb::array_view
<const gdb_byte
> data_view
;
2438 CORE_ADDR
get_object_address () override
2440 if (data_view
.data () == nullptr && obj_address
== 0)
2441 error (_("Location address is not set."));
2445 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
2450 /* Prefer the passed-in memory, if it exists. */
2451 CORE_ADDR offset
= addr
- obj_address
;
2452 if (offset
< data_view
.size () && offset
+ len
<= data_view
.size ())
2454 memcpy (buf
, data_view
.data (), len
);
2458 read_memory (addr
, buf
, len
);
2462 /* Evaluates a dwarf expression and stores the result in VAL,
2463 expecting that the dwarf expression only produces a single
2464 CORE_ADDR. FRAME is the frame in which the expression is
2465 evaluated. ADDR_STACK is a context (location of a variable) and
2466 might be needed to evaluate the location expression.
2467 PUSH_INITIAL_VALUE is true if the address (either from ADDR_STACK,
2468 or the default of 0) should be pushed on the DWARF expression
2469 evaluation stack before evaluating the expression; this is required
2470 by certain forms of DWARF expression. Returns 1 on success, 0
2474 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton
*dlbaton
,
2475 struct frame_info
*frame
,
2476 const struct property_addr_info
*addr_stack
,
2478 bool push_initial_value
)
2480 if (dlbaton
== NULL
|| dlbaton
->size
== 0)
2483 dwarf2_per_objfile
*per_objfile
= dlbaton
->per_objfile
;
2484 evaluate_for_locexpr_baton
ctx (per_objfile
);
2487 ctx
.per_cu
= dlbaton
->per_cu
;
2488 if (addr_stack
== nullptr)
2489 ctx
.obj_address
= 0;
2492 ctx
.obj_address
= addr_stack
->addr
;
2493 ctx
.data_view
= addr_stack
->valaddr
;
2496 ctx
.gdbarch
= per_objfile
->objfile
->arch ();
2497 ctx
.addr_size
= dlbaton
->per_cu
->addr_size ();
2498 ctx
.ref_addr_size
= dlbaton
->per_cu
->ref_addr_size ();
2500 if (push_initial_value
)
2501 ctx
.push_address (ctx
.obj_address
, false);
2505 ctx
.eval (dlbaton
->data
, dlbaton
->size
);
2507 catch (const gdb_exception_error
&ex
)
2509 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2513 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2515 if (entry_values_debug
)
2516 exception_print (gdb_stdout
, ex
);
2523 switch (ctx
.location
)
2525 case DWARF_VALUE_REGISTER
:
2526 case DWARF_VALUE_MEMORY
:
2527 case DWARF_VALUE_STACK
:
2528 *valp
= ctx
.fetch_address (0);
2529 if (ctx
.location
== DWARF_VALUE_REGISTER
)
2530 *valp
= ctx
.read_addr_from_reg (*valp
);
2532 case DWARF_VALUE_LITERAL
:
2533 *valp
= extract_signed_integer (ctx
.data
, ctx
.len
,
2534 gdbarch_byte_order (ctx
.gdbarch
));
2536 /* Unsupported dwarf values. */
2537 case DWARF_VALUE_OPTIMIZED_OUT
:
2538 case DWARF_VALUE_IMPLICIT_POINTER
:
2545 /* See dwarf2loc.h. */
2548 dwarf2_evaluate_property (const struct dynamic_prop
*prop
,
2549 struct frame_info
*frame
,
2550 const struct property_addr_info
*addr_stack
,
2552 bool push_initial_value
)
2557 if (frame
== NULL
&& has_stack_frames ())
2558 frame
= get_selected_frame (NULL
);
2564 const struct dwarf2_property_baton
*baton
2565 = (const struct dwarf2_property_baton
*) prop
->data
.baton
;
2566 gdb_assert (baton
->property_type
!= NULL
);
2568 if (dwarf2_locexpr_baton_eval (&baton
->locexpr
, frame
, addr_stack
,
2569 value
, push_initial_value
))
2571 if (baton
->locexpr
.is_reference
)
2573 struct value
*val
= value_at (baton
->property_type
, *value
);
2574 *value
= value_as_address (val
);
2578 gdb_assert (baton
->property_type
!= NULL
);
2580 struct type
*type
= check_typedef (baton
->property_type
);
2581 if (TYPE_LENGTH (type
) < sizeof (CORE_ADDR
)
2582 && !TYPE_UNSIGNED (type
))
2584 /* If we have a valid return candidate and it's value
2585 is signed, we have to sign-extend the value because
2586 CORE_ADDR on 64bit machine has 8 bytes but address
2587 size of an 32bit application is bytes. */
2589 = (baton
->locexpr
.per_cu
->addr_size ()
2591 const CORE_ADDR neg_mask
2592 = (~((CORE_ADDR
) 0) << (addr_size
- 1));
2594 /* Check if signed bit is set and sign-extend values. */
2595 if (*value
& neg_mask
)
2606 struct dwarf2_property_baton
*baton
2607 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2609 const gdb_byte
*data
;
2614 || !get_frame_address_in_block_if_available (frame
, &pc
))
2617 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2620 val
= dwarf2_evaluate_loc_desc (baton
->property_type
, frame
, data
,
2621 size
, baton
->loclist
.per_cu
,
2622 baton
->loclist
.per_objfile
);
2623 if (!value_optimized_out (val
))
2625 *value
= value_as_address (val
);
2633 *value
= prop
->data
.const_val
;
2636 case PROP_ADDR_OFFSET
:
2638 struct dwarf2_property_baton
*baton
2639 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2640 const struct property_addr_info
*pinfo
;
2643 for (pinfo
= addr_stack
; pinfo
!= NULL
; pinfo
= pinfo
->next
)
2645 /* This approach lets us avoid checking the qualifiers. */
2646 if (TYPE_MAIN_TYPE (pinfo
->type
)
2647 == TYPE_MAIN_TYPE (baton
->property_type
))
2651 error (_("cannot find reference address for offset property"));
2652 if (pinfo
->valaddr
.data () != NULL
)
2653 val
= value_from_contents
2654 (baton
->offset_info
.type
,
2655 pinfo
->valaddr
.data () + baton
->offset_info
.offset
);
2657 val
= value_at (baton
->offset_info
.type
,
2658 pinfo
->addr
+ baton
->offset_info
.offset
);
2659 *value
= value_as_address (val
);
2667 /* See dwarf2loc.h. */
2670 dwarf2_compile_property_to_c (string_file
*stream
,
2671 const char *result_name
,
2672 struct gdbarch
*gdbarch
,
2673 unsigned char *registers_used
,
2674 const struct dynamic_prop
*prop
,
2678 struct dwarf2_property_baton
*baton
2679 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2680 const gdb_byte
*data
;
2682 dwarf2_per_cu_data
*per_cu
;
2683 dwarf2_per_objfile
*per_objfile
;
2685 if (prop
->kind
== PROP_LOCEXPR
)
2687 data
= baton
->locexpr
.data
;
2688 size
= baton
->locexpr
.size
;
2689 per_cu
= baton
->locexpr
.per_cu
;
2690 per_objfile
= baton
->locexpr
.per_objfile
;
2694 gdb_assert (prop
->kind
== PROP_LOCLIST
);
2696 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2697 per_cu
= baton
->loclist
.per_cu
;
2698 per_objfile
= baton
->loclist
.per_objfile
;
2701 compile_dwarf_bounds_to_c (stream
, result_name
, prop
, sym
, pc
,
2702 gdbarch
, registers_used
,
2703 per_cu
->addr_size (),
2704 data
, data
+ size
, per_cu
, per_objfile
);
2708 /* Helper functions and baton for dwarf2_loc_desc_get_symbol_read_needs. */
2710 class symbol_needs_eval_context
: public dwarf_expr_context
2713 symbol_needs_eval_context (dwarf2_per_objfile
*per_objfile
)
2714 : dwarf_expr_context (per_objfile
)
2717 enum symbol_needs_kind needs
;
2718 struct dwarf2_per_cu_data
*per_cu
;
2720 /* Reads from registers do require a frame. */
2721 CORE_ADDR
read_addr_from_reg (int regnum
) override
2723 needs
= SYMBOL_NEEDS_FRAME
;
2727 /* "get_reg_value" callback: Reads from registers do require a
2730 struct value
*get_reg_value (struct type
*type
, int regnum
) override
2732 needs
= SYMBOL_NEEDS_FRAME
;
2733 return value_zero (type
, not_lval
);
2736 /* Reads from memory do not require a frame. */
2737 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
2739 memset (buf
, 0, len
);
2742 /* Frame-relative accesses do require a frame. */
2743 void get_frame_base (const gdb_byte
**start
, size_t *length
) override
2745 static gdb_byte lit0
= DW_OP_lit0
;
2750 needs
= SYMBOL_NEEDS_FRAME
;
2753 /* CFA accesses require a frame. */
2754 CORE_ADDR
get_frame_cfa () override
2756 needs
= SYMBOL_NEEDS_FRAME
;
2760 CORE_ADDR
get_frame_pc () override
2762 needs
= SYMBOL_NEEDS_FRAME
;
2766 /* Thread-local accesses require registers, but not a frame. */
2767 CORE_ADDR
get_tls_address (CORE_ADDR offset
) override
2769 if (needs
<= SYMBOL_NEEDS_REGISTERS
)
2770 needs
= SYMBOL_NEEDS_REGISTERS
;
2774 /* Helper interface of per_cu_dwarf_call for
2775 dwarf2_loc_desc_get_symbol_read_needs. */
2777 void dwarf_call (cu_offset die_offset
) override
2779 per_cu_dwarf_call (this, die_offset
, per_cu
, per_objfile
);
2782 /* Helper interface of sect_variable_value for
2783 dwarf2_loc_desc_get_symbol_read_needs. */
2785 struct value
*dwarf_variable_value (sect_offset sect_off
) override
2787 return sect_variable_value (this, sect_off
, per_cu
, per_objfile
);
2790 /* DW_OP_entry_value accesses require a caller, therefore a
2793 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
2794 union call_site_parameter_u kind_u
,
2795 int deref_size
) override
2797 needs
= SYMBOL_NEEDS_FRAME
;
2799 /* The expression may require some stub values on DWARF stack. */
2800 push_address (0, 0);
2803 /* DW_OP_addrx and DW_OP_GNU_addr_index doesn't require a frame. */
2805 CORE_ADDR
get_addr_index (unsigned int index
) override
2807 /* Nothing to do. */
2811 /* DW_OP_push_object_address has a frame already passed through. */
2813 CORE_ADDR
get_object_address () override
2815 /* Nothing to do. */
2820 /* Compute the correct symbol_needs_kind value for the location
2821 expression at DATA (length SIZE). */
2823 static enum symbol_needs_kind
2824 dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte
*data
, size_t size
,
2825 dwarf2_per_cu_data
*per_cu
,
2826 dwarf2_per_objfile
*per_objfile
)
2830 scoped_value_mark free_values
;
2832 symbol_needs_eval_context
ctx (per_objfile
);
2834 ctx
.needs
= SYMBOL_NEEDS_NONE
;
2835 ctx
.per_cu
= per_cu
;
2836 ctx
.gdbarch
= per_objfile
->objfile
->arch ();
2837 ctx
.addr_size
= per_cu
->addr_size ();
2838 ctx
.ref_addr_size
= per_cu
->ref_addr_size ();
2840 ctx
.eval (data
, size
);
2842 in_reg
= ctx
.location
== DWARF_VALUE_REGISTER
;
2844 /* If the location has several pieces, and any of them are in
2845 registers, then we will need a frame to fetch them from. */
2846 for (dwarf_expr_piece
&p
: ctx
.pieces
)
2847 if (p
.location
== DWARF_VALUE_REGISTER
)
2851 ctx
.needs
= SYMBOL_NEEDS_FRAME
;
2855 /* A helper function that throws an unimplemented error mentioning a
2856 given DWARF operator. */
2858 static void ATTRIBUTE_NORETURN
2859 unimplemented (unsigned int op
)
2861 const char *name
= get_DW_OP_name (op
);
2864 error (_("DWARF operator %s cannot be translated to an agent expression"),
2867 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2868 "to an agent expression"),
2874 This is basically a wrapper on gdbarch_dwarf2_reg_to_regnum so that we
2875 can issue a complaint, which is better than having every target's
2876 implementation of dwarf2_reg_to_regnum do it. */
2879 dwarf_reg_to_regnum (struct gdbarch
*arch
, int dwarf_reg
)
2881 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2885 complaint (_("bad DWARF register number %d"), dwarf_reg
);
2890 /* Subroutine of dwarf_reg_to_regnum_or_error to simplify it.
2891 Throw an error because DWARF_REG is bad. */
2894 throw_bad_regnum_error (ULONGEST dwarf_reg
)
2896 /* Still want to print -1 as "-1".
2897 We *could* have int and ULONGEST versions of dwarf2_reg_to_regnum_or_error
2898 but that's overkill for now. */
2899 if ((int) dwarf_reg
== dwarf_reg
)
2900 error (_("Unable to access DWARF register number %d"), (int) dwarf_reg
);
2901 error (_("Unable to access DWARF register number %s"),
2902 pulongest (dwarf_reg
));
2905 /* See dwarf2loc.h. */
2908 dwarf_reg_to_regnum_or_error (struct gdbarch
*arch
, ULONGEST dwarf_reg
)
2912 if (dwarf_reg
> INT_MAX
)
2913 throw_bad_regnum_error (dwarf_reg
);
2914 /* Yes, we will end up issuing a complaint and an error if DWARF_REG is
2915 bad, but that's ok. */
2916 reg
= dwarf_reg_to_regnum (arch
, (int) dwarf_reg
);
2918 throw_bad_regnum_error (dwarf_reg
);
2922 /* A helper function that emits an access to memory. ARCH is the
2923 target architecture. EXPR is the expression which we are building.
2924 NBITS is the number of bits we want to read. This emits the
2925 opcodes needed to read the memory and then extract the desired
2929 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2931 ULONGEST nbytes
= (nbits
+ 7) / 8;
2933 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2936 ax_trace_quick (expr
, nbytes
);
2939 ax_simple (expr
, aop_ref8
);
2940 else if (nbits
<= 16)
2941 ax_simple (expr
, aop_ref16
);
2942 else if (nbits
<= 32)
2943 ax_simple (expr
, aop_ref32
);
2945 ax_simple (expr
, aop_ref64
);
2947 /* If we read exactly the number of bytes we wanted, we're done. */
2948 if (8 * nbytes
== nbits
)
2951 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
)
2953 /* On a bits-big-endian machine, we want the high-order
2955 ax_const_l (expr
, 8 * nbytes
- nbits
);
2956 ax_simple (expr
, aop_rsh_unsigned
);
2960 /* On a bits-little-endian box, we want the low-order NBITS. */
2961 ax_zero_ext (expr
, nbits
);
2965 /* A helper function to return the frame's PC. */
2968 get_ax_pc (void *baton
)
2970 struct agent_expr
*expr
= (struct agent_expr
*) baton
;
2975 /* Compile a DWARF location expression to an agent expression.
2977 EXPR is the agent expression we are building.
2978 LOC is the agent value we modify.
2979 ARCH is the architecture.
2980 ADDR_SIZE is the size of addresses, in bytes.
2981 OP_PTR is the start of the location expression.
2982 OP_END is one past the last byte of the location expression.
2984 This will throw an exception for various kinds of errors -- for
2985 example, if the expression cannot be compiled, or if the expression
2989 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2990 unsigned int addr_size
, const gdb_byte
*op_ptr
,
2991 const gdb_byte
*op_end
,
2992 dwarf2_per_cu_data
*per_cu
,
2993 dwarf2_per_objfile
*per_objfile
)
2995 gdbarch
*arch
= expr
->gdbarch
;
2996 std::vector
<int> dw_labels
, patches
;
2997 const gdb_byte
* const base
= op_ptr
;
2998 const gdb_byte
*previous_piece
= op_ptr
;
2999 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
3000 ULONGEST bits_collected
= 0;
3001 unsigned int addr_size_bits
= 8 * addr_size
;
3002 bool bits_big_endian
= byte_order
== BFD_ENDIAN_BIG
;
3004 std::vector
<int> offsets (op_end
- op_ptr
, -1);
3006 /* By default we are making an address. */
3007 loc
->kind
= axs_lvalue_memory
;
3009 while (op_ptr
< op_end
)
3011 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
3012 uint64_t uoffset
, reg
;
3016 offsets
[op_ptr
- base
] = expr
->len
;
3019 /* Our basic approach to code generation is to map DWARF
3020 operations directly to AX operations. However, there are
3023 First, DWARF works on address-sized units, but AX always uses
3024 LONGEST. For most operations we simply ignore this
3025 difference; instead we generate sign extensions as needed
3026 before division and comparison operations. It would be nice
3027 to omit the sign extensions, but there is no way to determine
3028 the size of the target's LONGEST. (This code uses the size
3029 of the host LONGEST in some cases -- that is a bug but it is
3032 Second, some DWARF operations cannot be translated to AX.
3033 For these we simply fail. See
3034 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
3069 ax_const_l (expr
, op
- DW_OP_lit0
);
3073 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
3074 op_ptr
+= addr_size
;
3075 /* Some versions of GCC emit DW_OP_addr before
3076 DW_OP_GNU_push_tls_address. In this case the value is an
3077 index, not an address. We don't support things like
3078 branching between the address and the TLS op. */
3079 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
3080 uoffset
+= per_objfile
->objfile
->text_section_offset ();
3081 ax_const_l (expr
, uoffset
);
3085 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
3089 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
3093 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
3097 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
3101 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
3105 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
3109 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
3113 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
3117 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3118 ax_const_l (expr
, uoffset
);
3121 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3122 ax_const_l (expr
, offset
);
3157 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3158 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_reg0
);
3159 loc
->kind
= axs_lvalue_register
;
3163 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3164 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3165 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3166 loc
->kind
= axs_lvalue_register
;
3169 case DW_OP_implicit_value
:
3173 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
3174 if (op_ptr
+ len
> op_end
)
3175 error (_("DW_OP_implicit_value: too few bytes available."));
3176 if (len
> sizeof (ULONGEST
))
3177 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
3180 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
3183 dwarf_expr_require_composition (op_ptr
, op_end
,
3184 "DW_OP_implicit_value");
3186 loc
->kind
= axs_rvalue
;
3190 case DW_OP_stack_value
:
3191 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
3192 loc
->kind
= axs_rvalue
;
3227 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3228 i
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_breg0
);
3232 ax_const_l (expr
, offset
);
3233 ax_simple (expr
, aop_add
);
3238 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3239 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3240 i
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3244 ax_const_l (expr
, offset
);
3245 ax_simple (expr
, aop_add
);
3251 const gdb_byte
*datastart
;
3253 const struct block
*b
;
3254 struct symbol
*framefunc
;
3256 b
= block_for_pc (expr
->scope
);
3259 error (_("No block found for address"));
3261 framefunc
= block_linkage_function (b
);
3264 error (_("No function found for block"));
3266 func_get_frame_base_dwarf_block (framefunc
, expr
->scope
,
3267 &datastart
, &datalen
);
3269 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3270 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, datastart
,
3271 datastart
+ datalen
, per_cu
,
3273 if (loc
->kind
== axs_lvalue_register
)
3274 require_rvalue (expr
, loc
);
3278 ax_const_l (expr
, offset
);
3279 ax_simple (expr
, aop_add
);
3282 loc
->kind
= axs_lvalue_memory
;
3287 ax_simple (expr
, aop_dup
);
3291 ax_simple (expr
, aop_pop
);
3296 ax_pick (expr
, offset
);
3300 ax_simple (expr
, aop_swap
);
3308 ax_simple (expr
, aop_rot
);
3312 case DW_OP_deref_size
:
3316 if (op
== DW_OP_deref_size
)
3321 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3322 error (_("Unsupported size %d in %s"),
3323 size
, get_DW_OP_name (op
));
3324 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3329 /* Sign extend the operand. */
3330 ax_ext (expr
, addr_size_bits
);
3331 ax_simple (expr
, aop_dup
);
3332 ax_const_l (expr
, 0);
3333 ax_simple (expr
, aop_less_signed
);
3334 ax_simple (expr
, aop_log_not
);
3335 i
= ax_goto (expr
, aop_if_goto
);
3336 /* We have to emit 0 - X. */
3337 ax_const_l (expr
, 0);
3338 ax_simple (expr
, aop_swap
);
3339 ax_simple (expr
, aop_sub
);
3340 ax_label (expr
, i
, expr
->len
);
3344 /* No need to sign extend here. */
3345 ax_const_l (expr
, 0);
3346 ax_simple (expr
, aop_swap
);
3347 ax_simple (expr
, aop_sub
);
3351 /* Sign extend the operand. */
3352 ax_ext (expr
, addr_size_bits
);
3353 ax_simple (expr
, aop_bit_not
);
3356 case DW_OP_plus_uconst
:
3357 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3358 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3359 but we micro-optimize anyhow. */
3362 ax_const_l (expr
, reg
);
3363 ax_simple (expr
, aop_add
);
3368 ax_simple (expr
, aop_bit_and
);
3372 /* Sign extend the operands. */
3373 ax_ext (expr
, addr_size_bits
);
3374 ax_simple (expr
, aop_swap
);
3375 ax_ext (expr
, addr_size_bits
);
3376 ax_simple (expr
, aop_swap
);
3377 ax_simple (expr
, aop_div_signed
);
3381 ax_simple (expr
, aop_sub
);
3385 ax_simple (expr
, aop_rem_unsigned
);
3389 ax_simple (expr
, aop_mul
);
3393 ax_simple (expr
, aop_bit_or
);
3397 ax_simple (expr
, aop_add
);
3401 ax_simple (expr
, aop_lsh
);
3405 ax_simple (expr
, aop_rsh_unsigned
);
3409 ax_simple (expr
, aop_rsh_signed
);
3413 ax_simple (expr
, aop_bit_xor
);
3417 /* Sign extend the operands. */
3418 ax_ext (expr
, addr_size_bits
);
3419 ax_simple (expr
, aop_swap
);
3420 ax_ext (expr
, addr_size_bits
);
3421 /* Note no swap here: A <= B is !(B < A). */
3422 ax_simple (expr
, aop_less_signed
);
3423 ax_simple (expr
, aop_log_not
);
3427 /* Sign extend the operands. */
3428 ax_ext (expr
, addr_size_bits
);
3429 ax_simple (expr
, aop_swap
);
3430 ax_ext (expr
, addr_size_bits
);
3431 ax_simple (expr
, aop_swap
);
3432 /* A >= B is !(A < B). */
3433 ax_simple (expr
, aop_less_signed
);
3434 ax_simple (expr
, aop_log_not
);
3438 /* Sign extend the operands. */
3439 ax_ext (expr
, addr_size_bits
);
3440 ax_simple (expr
, aop_swap
);
3441 ax_ext (expr
, addr_size_bits
);
3442 /* No need for a second swap here. */
3443 ax_simple (expr
, aop_equal
);
3447 /* Sign extend the operands. */
3448 ax_ext (expr
, addr_size_bits
);
3449 ax_simple (expr
, aop_swap
);
3450 ax_ext (expr
, addr_size_bits
);
3451 ax_simple (expr
, aop_swap
);
3452 ax_simple (expr
, aop_less_signed
);
3456 /* Sign extend the operands. */
3457 ax_ext (expr
, addr_size_bits
);
3458 ax_simple (expr
, aop_swap
);
3459 ax_ext (expr
, addr_size_bits
);
3460 /* Note no swap here: A > B is B < A. */
3461 ax_simple (expr
, aop_less_signed
);
3465 /* Sign extend the operands. */
3466 ax_ext (expr
, addr_size_bits
);
3467 ax_simple (expr
, aop_swap
);
3468 ax_ext (expr
, addr_size_bits
);
3469 /* No need for a swap here. */
3470 ax_simple (expr
, aop_equal
);
3471 ax_simple (expr
, aop_log_not
);
3474 case DW_OP_call_frame_cfa
:
3477 CORE_ADDR text_offset
;
3479 const gdb_byte
*cfa_start
, *cfa_end
;
3481 if (dwarf2_fetch_cfa_info (arch
, expr
->scope
, per_cu
,
3483 &text_offset
, &cfa_start
, &cfa_end
))
3486 ax_reg (expr
, regnum
);
3489 ax_const_l (expr
, off
);
3490 ax_simple (expr
, aop_add
);
3495 /* Another expression. */
3496 ax_const_l (expr
, text_offset
);
3497 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, cfa_start
,
3498 cfa_end
, per_cu
, per_objfile
);
3501 loc
->kind
= axs_lvalue_memory
;
3505 case DW_OP_GNU_push_tls_address
:
3506 case DW_OP_form_tls_address
:
3510 case DW_OP_push_object_address
:
3515 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3517 i
= ax_goto (expr
, aop_goto
);
3518 dw_labels
.push_back (op_ptr
+ offset
- base
);
3519 patches
.push_back (i
);
3523 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3525 /* Zero extend the operand. */
3526 ax_zero_ext (expr
, addr_size_bits
);
3527 i
= ax_goto (expr
, aop_if_goto
);
3528 dw_labels
.push_back (op_ptr
+ offset
- base
);
3529 patches
.push_back (i
);
3536 case DW_OP_bit_piece
:
3540 if (op_ptr
- 1 == previous_piece
)
3541 error (_("Cannot translate empty pieces to agent expressions"));
3542 previous_piece
= op_ptr
- 1;
3544 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3545 if (op
== DW_OP_piece
)
3551 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3553 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3554 error (_("Expression pieces exceed word size"));
3556 /* Access the bits. */
3559 case axs_lvalue_register
:
3560 ax_reg (expr
, loc
->u
.reg
);
3563 case axs_lvalue_memory
:
3564 /* Offset the pointer, if needed. */
3567 ax_const_l (expr
, uoffset
/ 8);
3568 ax_simple (expr
, aop_add
);
3571 access_memory (arch
, expr
, size
);
3575 /* For a bits-big-endian target, shift up what we already
3576 have. For a bits-little-endian target, shift up the
3577 new data. Note that there is a potential bug here if
3578 the DWARF expression leaves multiple values on the
3580 if (bits_collected
> 0)
3582 if (bits_big_endian
)
3584 ax_simple (expr
, aop_swap
);
3585 ax_const_l (expr
, size
);
3586 ax_simple (expr
, aop_lsh
);
3587 /* We don't need a second swap here, because
3588 aop_bit_or is symmetric. */
3592 ax_const_l (expr
, size
);
3593 ax_simple (expr
, aop_lsh
);
3595 ax_simple (expr
, aop_bit_or
);
3598 bits_collected
+= size
;
3599 loc
->kind
= axs_rvalue
;
3603 case DW_OP_GNU_uninit
:
3609 struct dwarf2_locexpr_baton block
;
3610 int size
= (op
== DW_OP_call2
? 2 : 4);
3612 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3615 cu_offset cuoffset
= (cu_offset
) uoffset
;
3616 block
= dwarf2_fetch_die_loc_cu_off (cuoffset
, per_cu
, per_objfile
,
3619 /* DW_OP_call_ref is currently not supported. */
3620 gdb_assert (block
.per_cu
== per_cu
);
3622 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, block
.data
,
3623 block
.data
+ block
.size
, per_cu
,
3628 case DW_OP_call_ref
:
3631 case DW_OP_GNU_variable_value
:
3639 /* Patch all the branches we emitted. */
3640 for (int i
= 0; i
< patches
.size (); ++i
)
3642 int targ
= offsets
[dw_labels
[i
]];
3644 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3645 ax_label (expr
, patches
[i
], targ
);
3650 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3651 evaluator to calculate the location. */
3652 static struct value
*
3653 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3655 struct dwarf2_locexpr_baton
*dlbaton
3656 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3659 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3660 dlbaton
->size
, dlbaton
->per_cu
,
3661 dlbaton
->per_objfile
);
3666 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3667 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3670 static struct value
*
3671 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3673 struct dwarf2_locexpr_baton
*dlbaton
3674 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3676 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3680 /* Implementation of get_symbol_read_needs from
3681 symbol_computed_ops. */
3683 static enum symbol_needs_kind
3684 locexpr_get_symbol_read_needs (struct symbol
*symbol
)
3686 struct dwarf2_locexpr_baton
*dlbaton
3687 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3689 return dwarf2_loc_desc_get_symbol_read_needs (dlbaton
->data
, dlbaton
->size
,
3691 dlbaton
->per_objfile
);
3694 /* Return true if DATA points to the end of a piece. END is one past
3695 the last byte in the expression. */
3698 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3700 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3703 /* Helper for locexpr_describe_location_piece that finds the name of a
3707 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3711 /* This doesn't use dwarf_reg_to_regnum_or_error on purpose.
3712 We'd rather print *something* here than throw an error. */
3713 regnum
= dwarf_reg_to_regnum (gdbarch
, dwarf_regnum
);
3714 /* gdbarch_register_name may just return "", return something more
3715 descriptive for bad register numbers. */
3718 /* The text is output as "$bad_register_number".
3719 That is why we use the underscores. */
3720 return _("bad_register_number");
3722 return gdbarch_register_name (gdbarch
, regnum
);
3725 /* Nicely describe a single piece of a location, returning an updated
3726 position in the bytecode sequence. This function cannot recognize
3727 all locations; if a location is not recognized, it simply returns
3728 DATA. If there is an error during reading, e.g. we run off the end
3729 of the buffer, an error is thrown. */
3731 static const gdb_byte
*
3732 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3733 CORE_ADDR addr
, dwarf2_per_cu_data
*per_cu
,
3734 dwarf2_per_objfile
*per_objfile
,
3735 const gdb_byte
*data
, const gdb_byte
*end
,
3736 unsigned int addr_size
)
3738 objfile
*objfile
= per_objfile
->objfile
;
3739 struct gdbarch
*gdbarch
= objfile
->arch ();
3742 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3744 fprintf_filtered (stream
, _("a variable in $%s"),
3745 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3748 else if (data
[0] == DW_OP_regx
)
3752 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3753 fprintf_filtered (stream
, _("a variable in $%s"),
3754 locexpr_regname (gdbarch
, reg
));
3756 else if (data
[0] == DW_OP_fbreg
)
3758 const struct block
*b
;
3759 struct symbol
*framefunc
;
3761 int64_t frame_offset
;
3762 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3764 int64_t base_offset
= 0;
3766 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3767 if (!piece_end_p (new_data
, end
))
3771 b
= block_for_pc (addr
);
3774 error (_("No block found for address for symbol \"%s\"."),
3775 symbol
->print_name ());
3777 framefunc
= block_linkage_function (b
);
3780 error (_("No function found for block for symbol \"%s\"."),
3781 symbol
->print_name ());
3783 func_get_frame_base_dwarf_block (framefunc
, addr
, &base_data
, &base_size
);
3785 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3787 const gdb_byte
*buf_end
;
3789 frame_reg
= base_data
[0] - DW_OP_breg0
;
3790 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3792 if (buf_end
!= base_data
+ base_size
)
3793 error (_("Unexpected opcode after "
3794 "DW_OP_breg%u for symbol \"%s\"."),
3795 frame_reg
, symbol
->print_name ());
3797 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3799 /* The frame base is just the register, with no offset. */
3800 frame_reg
= base_data
[0] - DW_OP_reg0
;
3805 /* We don't know what to do with the frame base expression,
3806 so we can't trace this variable; give up. */
3810 fprintf_filtered (stream
,
3811 _("a variable at frame base reg $%s offset %s+%s"),
3812 locexpr_regname (gdbarch
, frame_reg
),
3813 plongest (base_offset
), plongest (frame_offset
));
3815 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3816 && piece_end_p (data
, end
))
3820 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3822 fprintf_filtered (stream
,
3823 _("a variable at offset %s from base reg $%s"),
3825 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3828 /* The location expression for a TLS variable looks like this (on a
3831 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3832 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3834 0x3 is the encoding for DW_OP_addr, which has an operand as long
3835 as the size of an address on the target machine (here is 8
3836 bytes). Note that more recent version of GCC emit DW_OP_const4u
3837 or DW_OP_const8u, depending on address size, rather than
3838 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3839 The operand represents the offset at which the variable is within
3840 the thread local storage. */
3842 else if (data
+ 1 + addr_size
< end
3843 && (data
[0] == DW_OP_addr
3844 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3845 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3846 && (data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3847 || data
[1 + addr_size
] == DW_OP_form_tls_address
)
3848 && piece_end_p (data
+ 2 + addr_size
, end
))
3851 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3852 gdbarch_byte_order (gdbarch
));
3854 fprintf_filtered (stream
,
3855 _("a thread-local variable at offset 0x%s "
3856 "in the thread-local storage for `%s'"),
3857 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3859 data
+= 1 + addr_size
+ 1;
3862 /* With -gsplit-dwarf a TLS variable can also look like this:
3863 DW_AT_location : 3 byte block: fc 4 e0
3864 (DW_OP_GNU_const_index: 4;
3865 DW_OP_GNU_push_tls_address) */
3866 else if (data
+ 3 <= end
3867 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3868 && data
[0] == DW_OP_GNU_const_index
3870 && (data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3871 || data
[1 + leb128_size
] == DW_OP_form_tls_address
)
3872 && piece_end_p (data
+ 2 + leb128_size
, end
))
3876 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3877 offset
= dwarf2_read_addr_index (per_cu
, per_objfile
, offset
);
3878 fprintf_filtered (stream
,
3879 _("a thread-local variable at offset 0x%s "
3880 "in the thread-local storage for `%s'"),
3881 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3885 else if (data
[0] >= DW_OP_lit0
3886 && data
[0] <= DW_OP_lit31
3888 && data
[1] == DW_OP_stack_value
)
3890 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3897 /* Disassemble an expression, stopping at the end of a piece or at the
3898 end of the expression. Returns a pointer to the next unread byte
3899 in the input expression. If ALL is nonzero, then this function
3900 will keep going until it reaches the end of the expression.
3901 If there is an error during reading, e.g. we run off the end
3902 of the buffer, an error is thrown. */
3904 static const gdb_byte
*
3905 disassemble_dwarf_expression (struct ui_file
*stream
,
3906 struct gdbarch
*arch
, unsigned int addr_size
,
3907 int offset_size
, const gdb_byte
*start
,
3908 const gdb_byte
*data
, const gdb_byte
*end
,
3909 int indent
, int all
,
3910 dwarf2_per_cu_data
*per_cu
,
3911 dwarf2_per_objfile
*per_objfile
)
3915 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3917 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *data
++;
3922 name
= get_DW_OP_name (op
);
3925 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3926 op
, (long) (data
- 1 - start
));
3927 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3928 (long) (data
- 1 - start
), name
);
3933 ul
= extract_unsigned_integer (data
, addr_size
,
3934 gdbarch_byte_order (arch
));
3936 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3940 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3942 fprintf_filtered (stream
, " %s", pulongest (ul
));
3945 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3947 fprintf_filtered (stream
, " %s", plongest (l
));
3950 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3952 fprintf_filtered (stream
, " %s", pulongest (ul
));
3955 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3957 fprintf_filtered (stream
, " %s", plongest (l
));
3960 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3962 fprintf_filtered (stream
, " %s", pulongest (ul
));
3965 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3967 fprintf_filtered (stream
, " %s", plongest (l
));
3970 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3972 fprintf_filtered (stream
, " %s", pulongest (ul
));
3975 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3977 fprintf_filtered (stream
, " %s", plongest (l
));
3980 data
= safe_read_uleb128 (data
, end
, &ul
);
3981 fprintf_filtered (stream
, " %s", pulongest (ul
));
3984 data
= safe_read_sleb128 (data
, end
, &l
);
3985 fprintf_filtered (stream
, " %s", plongest (l
));
4020 fprintf_filtered (stream
, " [$%s]",
4021 locexpr_regname (arch
, op
- DW_OP_reg0
));
4025 data
= safe_read_uleb128 (data
, end
, &ul
);
4026 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
4027 locexpr_regname (arch
, (int) ul
));
4030 case DW_OP_implicit_value
:
4031 data
= safe_read_uleb128 (data
, end
, &ul
);
4033 fprintf_filtered (stream
, " %s", pulongest (ul
));
4068 data
= safe_read_sleb128 (data
, end
, &l
);
4069 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
4070 locexpr_regname (arch
, op
- DW_OP_breg0
));
4074 data
= safe_read_uleb128 (data
, end
, &ul
);
4075 data
= safe_read_sleb128 (data
, end
, &l
);
4076 fprintf_filtered (stream
, " register %s [$%s] offset %s",
4078 locexpr_regname (arch
, (int) ul
),
4083 data
= safe_read_sleb128 (data
, end
, &l
);
4084 fprintf_filtered (stream
, " %s", plongest (l
));
4087 case DW_OP_xderef_size
:
4088 case DW_OP_deref_size
:
4090 fprintf_filtered (stream
, " %d", *data
);
4094 case DW_OP_plus_uconst
:
4095 data
= safe_read_uleb128 (data
, end
, &ul
);
4096 fprintf_filtered (stream
, " %s", pulongest (ul
));
4100 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4102 fprintf_filtered (stream
, " to %ld",
4103 (long) (data
+ l
- start
));
4107 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4109 fprintf_filtered (stream
, " %ld",
4110 (long) (data
+ l
- start
));
4114 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
4116 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
4120 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4122 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4125 case DW_OP_call_ref
:
4126 ul
= extract_unsigned_integer (data
, offset_size
,
4127 gdbarch_byte_order (arch
));
4128 data
+= offset_size
;
4129 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4133 data
= safe_read_uleb128 (data
, end
, &ul
);
4134 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
4137 case DW_OP_bit_piece
:
4141 data
= safe_read_uleb128 (data
, end
, &ul
);
4142 data
= safe_read_uleb128 (data
, end
, &offset
);
4143 fprintf_filtered (stream
, " size %s offset %s (bits)",
4144 pulongest (ul
), pulongest (offset
));
4148 case DW_OP_implicit_pointer
:
4149 case DW_OP_GNU_implicit_pointer
:
4151 ul
= extract_unsigned_integer (data
, offset_size
,
4152 gdbarch_byte_order (arch
));
4153 data
+= offset_size
;
4155 data
= safe_read_sleb128 (data
, end
, &l
);
4157 fprintf_filtered (stream
, " DIE %s offset %s",
4158 phex_nz (ul
, offset_size
),
4163 case DW_OP_deref_type
:
4164 case DW_OP_GNU_deref_type
:
4166 int deref_addr_size
= *data
++;
4169 data
= safe_read_uleb128 (data
, end
, &ul
);
4170 cu_offset offset
= (cu_offset
) ul
;
4171 type
= dwarf2_get_die_type (offset
, per_cu
, per_objfile
);
4172 fprintf_filtered (stream
, "<");
4173 type_print (type
, "", stream
, -1);
4174 fprintf_filtered (stream
, " [0x%s]> %d",
4175 phex_nz (to_underlying (offset
), 0),
4180 case DW_OP_const_type
:
4181 case DW_OP_GNU_const_type
:
4185 data
= safe_read_uleb128 (data
, end
, &ul
);
4186 cu_offset type_die
= (cu_offset
) ul
;
4187 type
= dwarf2_get_die_type (type_die
, per_cu
, per_objfile
);
4188 fprintf_filtered (stream
, "<");
4189 type_print (type
, "", stream
, -1);
4190 fprintf_filtered (stream
, " [0x%s]>",
4191 phex_nz (to_underlying (type_die
), 0));
4194 fprintf_filtered (stream
, " %d byte block:", n
);
4195 for (int i
= 0; i
< n
; ++i
)
4196 fprintf_filtered (stream
, " %02x", data
[i
]);
4201 case DW_OP_regval_type
:
4202 case DW_OP_GNU_regval_type
:
4207 data
= safe_read_uleb128 (data
, end
, ®
);
4208 data
= safe_read_uleb128 (data
, end
, &ul
);
4209 cu_offset type_die
= (cu_offset
) ul
;
4211 type
= dwarf2_get_die_type (type_die
, per_cu
, per_objfile
);
4212 fprintf_filtered (stream
, "<");
4213 type_print (type
, "", stream
, -1);
4214 fprintf_filtered (stream
, " [0x%s]> [$%s]",
4215 phex_nz (to_underlying (type_die
), 0),
4216 locexpr_regname (arch
, reg
));
4221 case DW_OP_GNU_convert
:
4222 case DW_OP_reinterpret
:
4223 case DW_OP_GNU_reinterpret
:
4225 data
= safe_read_uleb128 (data
, end
, &ul
);
4226 cu_offset type_die
= (cu_offset
) ul
;
4228 if (to_underlying (type_die
) == 0)
4229 fprintf_filtered (stream
, "<0>");
4234 type
= dwarf2_get_die_type (type_die
, per_cu
, per_objfile
);
4235 fprintf_filtered (stream
, "<");
4236 type_print (type
, "", stream
, -1);
4237 fprintf_filtered (stream
, " [0x%s]>",
4238 phex_nz (to_underlying (type_die
), 0));
4243 case DW_OP_entry_value
:
4244 case DW_OP_GNU_entry_value
:
4245 data
= safe_read_uleb128 (data
, end
, &ul
);
4246 fputc_filtered ('\n', stream
);
4247 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
4248 start
, data
, data
+ ul
, indent
+ 2,
4249 all
, per_cu
, per_objfile
);
4253 case DW_OP_GNU_parameter_ref
:
4254 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4256 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4260 case DW_OP_GNU_addr_index
:
4261 data
= safe_read_uleb128 (data
, end
, &ul
);
4262 ul
= dwarf2_read_addr_index (per_cu
, per_objfile
, ul
);
4263 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
4265 case DW_OP_GNU_const_index
:
4266 data
= safe_read_uleb128 (data
, end
, &ul
);
4267 ul
= dwarf2_read_addr_index (per_cu
, per_objfile
, ul
);
4268 fprintf_filtered (stream
, " %s", pulongest (ul
));
4271 case DW_OP_GNU_variable_value
:
4272 ul
= extract_unsigned_integer (data
, offset_size
,
4273 gdbarch_byte_order (arch
));
4274 data
+= offset_size
;
4275 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4279 fprintf_filtered (stream
, "\n");
4285 static bool dwarf_always_disassemble
;
4288 show_dwarf_always_disassemble (struct ui_file
*file
, int from_tty
,
4289 struct cmd_list_element
*c
, const char *value
)
4291 fprintf_filtered (file
,
4292 _("Whether to always disassemble "
4293 "DWARF expressions is %s.\n"),
4297 /* Describe a single location, which may in turn consist of multiple
4301 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
4302 struct ui_file
*stream
,
4303 const gdb_byte
*data
, size_t size
,
4304 unsigned int addr_size
,
4305 int offset_size
, dwarf2_per_cu_data
*per_cu
,
4306 dwarf2_per_objfile
*per_objfile
)
4308 const gdb_byte
*end
= data
+ size
;
4309 int first_piece
= 1, bad
= 0;
4310 objfile
*objfile
= per_objfile
->objfile
;
4314 const gdb_byte
*here
= data
;
4315 int disassemble
= 1;
4320 fprintf_filtered (stream
, _(", and "));
4322 if (!dwarf_always_disassemble
)
4324 data
= locexpr_describe_location_piece (symbol
, stream
,
4325 addr
, per_cu
, per_objfile
,
4326 data
, end
, addr_size
);
4327 /* If we printed anything, or if we have an empty piece,
4328 then don't disassemble. */
4330 || data
[0] == DW_OP_piece
4331 || data
[0] == DW_OP_bit_piece
)
4336 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
4337 data
= disassemble_dwarf_expression (stream
,
4339 addr_size
, offset_size
, data
,
4341 dwarf_always_disassemble
,
4342 per_cu
, per_objfile
);
4347 int empty
= data
== here
;
4350 fprintf_filtered (stream
, " ");
4351 if (data
[0] == DW_OP_piece
)
4355 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
4358 fprintf_filtered (stream
, _("an empty %s-byte piece"),
4361 fprintf_filtered (stream
, _(" [%s-byte piece]"),
4364 else if (data
[0] == DW_OP_bit_piece
)
4366 uint64_t bits
, offset
;
4368 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
4369 data
= safe_read_uleb128 (data
, end
, &offset
);
4372 fprintf_filtered (stream
,
4373 _("an empty %s-bit piece"),
4376 fprintf_filtered (stream
,
4377 _(" [%s-bit piece, offset %s bits]"),
4378 pulongest (bits
), pulongest (offset
));
4388 if (bad
|| data
> end
)
4389 error (_("Corrupted DWARF2 expression for \"%s\"."),
4390 symbol
->print_name ());
4393 /* Print a natural-language description of SYMBOL to STREAM. This
4394 version is for a symbol with a single location. */
4397 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4398 struct ui_file
*stream
)
4400 struct dwarf2_locexpr_baton
*dlbaton
4401 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4402 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4403 int offset_size
= dlbaton
->per_cu
->offset_size ();
4405 locexpr_describe_location_1 (symbol
, addr
, stream
,
4406 dlbaton
->data
, dlbaton
->size
,
4407 addr_size
, offset_size
,
4408 dlbaton
->per_cu
, dlbaton
->per_objfile
);
4411 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4412 any necessary bytecode in AX. */
4415 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
4416 struct axs_value
*value
)
4418 struct dwarf2_locexpr_baton
*dlbaton
4419 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4420 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4422 if (dlbaton
->size
== 0)
4423 value
->optimized_out
= 1;
4425 dwarf2_compile_expr_to_ax (ax
, value
, addr_size
, dlbaton
->data
,
4426 dlbaton
->data
+ dlbaton
->size
, dlbaton
->per_cu
,
4427 dlbaton
->per_objfile
);
4430 /* symbol_computed_ops 'generate_c_location' method. */
4433 locexpr_generate_c_location (struct symbol
*sym
, string_file
*stream
,
4434 struct gdbarch
*gdbarch
,
4435 unsigned char *registers_used
,
4436 CORE_ADDR pc
, const char *result_name
)
4438 struct dwarf2_locexpr_baton
*dlbaton
4439 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (sym
);
4440 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4442 if (dlbaton
->size
== 0)
4443 error (_("symbol \"%s\" is optimized out"), sym
->natural_name ());
4445 compile_dwarf_expr_to_c (stream
, result_name
,
4446 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4447 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4448 dlbaton
->per_cu
, dlbaton
->per_objfile
);
4451 /* The set of location functions used with the DWARF-2 expression
4453 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4454 locexpr_read_variable
,
4455 locexpr_read_variable_at_entry
,
4456 locexpr_get_symbol_read_needs
,
4457 locexpr_describe_location
,
4458 0, /* location_has_loclist */
4459 locexpr_tracepoint_var_ref
,
4460 locexpr_generate_c_location
4464 /* Wrapper functions for location lists. These generally find
4465 the appropriate location expression and call something above. */
4467 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4468 evaluator to calculate the location. */
4469 static struct value
*
4470 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4472 struct dwarf2_loclist_baton
*dlbaton
4473 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4475 const gdb_byte
*data
;
4477 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4479 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4480 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4481 dlbaton
->per_cu
, dlbaton
->per_objfile
);
4486 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4487 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4490 Function always returns non-NULL value, it may be marked optimized out if
4491 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4492 if it cannot resolve the parameter for any reason. */
4494 static struct value
*
4495 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4497 struct dwarf2_loclist_baton
*dlbaton
4498 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4499 const gdb_byte
*data
;
4503 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4504 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4506 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4508 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4510 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4513 /* Implementation of get_symbol_read_needs from
4514 symbol_computed_ops. */
4516 static enum symbol_needs_kind
4517 loclist_symbol_needs (struct symbol
*symbol
)
4519 /* If there's a location list, then assume we need to have a frame
4520 to choose the appropriate location expression. With tracking of
4521 global variables this is not necessarily true, but such tracking
4522 is disabled in GCC at the moment until we figure out how to
4525 return SYMBOL_NEEDS_FRAME
;
4528 /* Print a natural-language description of SYMBOL to STREAM. This
4529 version applies when there is a list of different locations, each
4530 with a specified address range. */
4533 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4534 struct ui_file
*stream
)
4536 struct dwarf2_loclist_baton
*dlbaton
4537 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4538 const gdb_byte
*loc_ptr
, *buf_end
;
4539 dwarf2_per_objfile
*per_objfile
= dlbaton
->per_objfile
;
4540 struct objfile
*objfile
= per_objfile
->objfile
;
4541 struct gdbarch
*gdbarch
= objfile
->arch ();
4542 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4543 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4544 int offset_size
= dlbaton
->per_cu
->offset_size ();
4545 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4546 /* Adjust base_address for relocatable objects. */
4547 CORE_ADDR base_offset
= objfile
->text_section_offset ();
4548 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4551 loc_ptr
= dlbaton
->data
;
4552 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4554 fprintf_filtered (stream
, _("multi-location:\n"));
4556 /* Iterate through locations until we run out. */
4559 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4561 enum debug_loc_kind kind
;
4562 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4564 if (dlbaton
->per_cu
->version () < 5 && dlbaton
->from_dwo
)
4565 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4566 dlbaton
->per_objfile
,
4567 loc_ptr
, buf_end
, &new_ptr
,
4568 &low
, &high
, byte_order
);
4569 else if (dlbaton
->per_cu
->version () < 5)
4570 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4572 byte_order
, addr_size
,
4575 kind
= decode_debug_loclists_addresses (dlbaton
->per_cu
,
4576 dlbaton
->per_objfile
,
4577 loc_ptr
, buf_end
, &new_ptr
,
4578 &low
, &high
, byte_order
,
4579 addr_size
, signed_addr_p
);
4583 case DEBUG_LOC_END_OF_LIST
:
4586 case DEBUG_LOC_BASE_ADDRESS
:
4587 base_address
= high
+ base_offset
;
4588 fprintf_filtered (stream
, _(" Base address %s"),
4589 paddress (gdbarch
, base_address
));
4591 case DEBUG_LOC_START_END
:
4592 case DEBUG_LOC_START_LENGTH
:
4593 case DEBUG_LOC_OFFSET_PAIR
:
4595 case DEBUG_LOC_BUFFER_OVERFLOW
:
4596 case DEBUG_LOC_INVALID_ENTRY
:
4597 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4598 symbol
->print_name ());
4600 gdb_assert_not_reached ("bad debug_loc_kind");
4603 /* Otherwise, a location expression entry. */
4604 low
+= base_address
;
4605 high
+= base_address
;
4607 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
);
4608 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
);
4610 if (dlbaton
->per_cu
->version () < 5)
4612 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4617 unsigned int bytes_read
;
4618 length
= read_unsigned_leb128 (NULL
, loc_ptr
, &bytes_read
);
4619 loc_ptr
+= bytes_read
;
4622 /* (It would improve readability to print only the minimum
4623 necessary digits of the second number of the range.) */
4624 fprintf_filtered (stream
, _(" Range %s-%s: "),
4625 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4627 /* Now describe this particular location. */
4628 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4629 addr_size
, offset_size
,
4630 dlbaton
->per_cu
, dlbaton
->per_objfile
);
4632 fprintf_filtered (stream
, "\n");
4638 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4639 any necessary bytecode in AX. */
4641 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
4642 struct axs_value
*value
)
4644 struct dwarf2_loclist_baton
*dlbaton
4645 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4646 const gdb_byte
*data
;
4648 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4650 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4652 value
->optimized_out
= 1;
4654 dwarf2_compile_expr_to_ax (ax
, value
, addr_size
, data
, data
+ size
,
4655 dlbaton
->per_cu
, dlbaton
->per_objfile
);
4658 /* symbol_computed_ops 'generate_c_location' method. */
4661 loclist_generate_c_location (struct symbol
*sym
, string_file
*stream
,
4662 struct gdbarch
*gdbarch
,
4663 unsigned char *registers_used
,
4664 CORE_ADDR pc
, const char *result_name
)
4666 struct dwarf2_loclist_baton
*dlbaton
4667 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (sym
);
4668 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4669 const gdb_byte
*data
;
4672 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4674 error (_("symbol \"%s\" is optimized out"), sym
->natural_name ());
4676 compile_dwarf_expr_to_c (stream
, result_name
,
4677 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4680 dlbaton
->per_objfile
);
4683 /* The set of location functions used with the DWARF-2 expression
4684 evaluator and location lists. */
4685 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4686 loclist_read_variable
,
4687 loclist_read_variable_at_entry
,
4688 loclist_symbol_needs
,
4689 loclist_describe_location
,
4690 1, /* location_has_loclist */
4691 loclist_tracepoint_var_ref
,
4692 loclist_generate_c_location
4695 void _initialize_dwarf2loc ();
4697 _initialize_dwarf2loc ()
4699 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4700 &entry_values_debug
,
4701 _("Set entry values and tail call frames "
4703 _("Show entry values and tail call frames "
4705 _("When non-zero, the process of determining "
4706 "parameter values from function entry point "
4707 "and tail call frames will be printed."),
4709 show_entry_values_debug
,
4710 &setdebuglist
, &showdebuglist
);
4712 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
4713 &dwarf_always_disassemble
, _("\
4714 Set whether `info address' always disassembles DWARF expressions."), _("\
4715 Show whether `info address' always disassembles DWARF expressions."), _("\
4716 When enabled, DWARF expressions are always printed in an assembly-like\n\
4717 syntax. When disabled, expressions will be printed in a more\n\
4718 conversational style, when possible."),
4720 show_dwarf_always_disassemble
,
4722 &show_dwarf_cmdlist
);