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 gdb_assert (this->per_objfile
== caller_per_objfile
);
731 /* DEREF_SIZE size is not verified here. */
732 if (data_src
== NULL
)
733 throw_error (NO_ENTRY_VALUE_ERROR
,
734 _("Cannot resolve DW_AT_call_data_value"));
736 scoped_restore save_frame
= make_scoped_restore (&this->frame
,
738 scoped_restore save_per_cu
= make_scoped_restore (&this->per_cu
,
740 scoped_restore save_obj_addr
= make_scoped_restore (&this->obj_address
,
743 scoped_restore save_arch
= make_scoped_restore (&this->gdbarch
);
744 this->gdbarch
= this->per_objfile
->objfile
->arch ();
745 scoped_restore save_addr_size
= make_scoped_restore (&this->addr_size
);
746 this->addr_size
= per_cu
->addr_size ();
748 this->eval (data_src
, size
);
751 /* Using the frame specified in BATON, find the location expression
752 describing the frame base. Return a pointer to it in START and
753 its length in LENGTH. */
754 void get_frame_base (const gdb_byte
**start
, size_t * length
) override
756 /* FIXME: cagney/2003-03-26: This code should be using
757 get_frame_base_address(), and then implement a dwarf2 specific
759 struct symbol
*framefunc
;
760 const struct block
*bl
= get_frame_block (frame
, NULL
);
763 error (_("frame address is not available."));
765 /* Use block_linkage_function, which returns a real (not inlined)
766 function, instead of get_frame_function, which may return an
768 framefunc
= block_linkage_function (bl
);
770 /* If we found a frame-relative symbol then it was certainly within
771 some function associated with a frame. If we can't find the frame,
772 something has gone wrong. */
773 gdb_assert (framefunc
!= NULL
);
775 func_get_frame_base_dwarf_block (framefunc
,
776 get_frame_address_in_block (frame
),
780 /* Read memory at ADDR (length LEN) into BUF. */
782 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
784 read_memory (addr
, buf
, len
);
787 /* Using the frame specified in BATON, return the value of register
788 REGNUM, treated as a pointer. */
789 CORE_ADDR
read_addr_from_reg (int dwarf_regnum
) override
791 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
792 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
794 return address_from_register (regnum
, frame
);
797 /* Implement "get_reg_value" callback. */
799 struct value
*get_reg_value (struct type
*type
, int dwarf_regnum
) override
801 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
802 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
804 return value_from_register (type
, regnum
, frame
);
808 /* See dwarf2loc.h. */
810 unsigned int entry_values_debug
= 0;
812 /* Helper to set entry_values_debug. */
815 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
816 struct cmd_list_element
*c
, const char *value
)
818 fprintf_filtered (file
,
819 _("Entry values and tail call frames debugging is %s.\n"),
823 /* Find DW_TAG_call_site's DW_AT_call_target address.
824 CALLER_FRAME (for registers) can be NULL if it is not known. This function
825 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
828 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
829 struct call_site
*call_site
,
830 struct frame_info
*caller_frame
)
832 switch (FIELD_LOC_KIND (call_site
->target
))
834 case FIELD_LOC_KIND_DWARF_BLOCK
:
836 struct dwarf2_locexpr_baton
*dwarf_block
;
838 struct type
*caller_core_addr_type
;
839 struct gdbarch
*caller_arch
;
841 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
842 if (dwarf_block
== NULL
)
844 struct bound_minimal_symbol msym
;
846 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
847 throw_error (NO_ENTRY_VALUE_ERROR
,
848 _("DW_AT_call_target is not specified at %s in %s"),
849 paddress (call_site_gdbarch
, call_site
->pc
),
850 (msym
.minsym
== NULL
? "???"
851 : msym
.minsym
->print_name ()));
854 if (caller_frame
== NULL
)
856 struct bound_minimal_symbol msym
;
858 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
859 throw_error (NO_ENTRY_VALUE_ERROR
,
860 _("DW_AT_call_target DWARF block resolving "
861 "requires known frame which is currently not "
862 "available at %s in %s"),
863 paddress (call_site_gdbarch
, call_site
->pc
),
864 (msym
.minsym
== NULL
? "???"
865 : msym
.minsym
->print_name ()));
868 caller_arch
= get_frame_arch (caller_frame
);
869 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
870 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
871 dwarf_block
->data
, dwarf_block
->size
,
873 dwarf_block
->per_objfile
);
874 /* DW_AT_call_target is a DWARF expression, not a DWARF location. */
875 if (VALUE_LVAL (val
) == lval_memory
)
876 return value_address (val
);
878 return value_as_address (val
);
881 case FIELD_LOC_KIND_PHYSNAME
:
883 const char *physname
;
884 struct bound_minimal_symbol msym
;
886 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
888 /* Handle both the mangled and demangled PHYSNAME. */
889 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
890 if (msym
.minsym
== NULL
)
892 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
893 throw_error (NO_ENTRY_VALUE_ERROR
,
894 _("Cannot find function \"%s\" for a call site target "
896 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
897 (msym
.minsym
== NULL
? "???"
898 : msym
.minsym
->print_name ()));
901 return BMSYMBOL_VALUE_ADDRESS (msym
);
904 case FIELD_LOC_KIND_PHYSADDR
:
905 return FIELD_STATIC_PHYSADDR (call_site
->target
);
908 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
912 /* Convert function entry point exact address ADDR to the function which is
913 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
914 NO_ENTRY_VALUE_ERROR otherwise. */
916 static struct symbol
*
917 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
919 struct symbol
*sym
= find_pc_function (addr
);
922 if (sym
== NULL
|| BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
923 throw_error (NO_ENTRY_VALUE_ERROR
,
924 _("DW_TAG_call_site resolving failed to find function "
925 "name for address %s"),
926 paddress (gdbarch
, addr
));
928 type
= SYMBOL_TYPE (sym
);
929 gdb_assert (type
->code () == TYPE_CODE_FUNC
);
930 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
935 /* Verify function with entry point exact address ADDR can never call itself
936 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
937 can call itself via tail calls.
939 If a funtion can tail call itself its entry value based parameters are
940 unreliable. There is no verification whether the value of some/all
941 parameters is unchanged through the self tail call, we expect if there is
942 a self tail call all the parameters can be modified. */
945 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
949 /* The verification is completely unordered. Track here function addresses
950 which still need to be iterated. */
951 std::vector
<CORE_ADDR
> todo
;
953 /* Track here CORE_ADDRs which were already visited. */
954 std::unordered_set
<CORE_ADDR
> addr_hash
;
956 todo
.push_back (verify_addr
);
957 while (!todo
.empty ())
959 struct symbol
*func_sym
;
960 struct call_site
*call_site
;
965 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
967 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
968 call_site
; call_site
= call_site
->tail_call_next
)
970 CORE_ADDR target_addr
;
972 /* CALLER_FRAME with registers is not available for tail-call jumped
974 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
976 if (target_addr
== verify_addr
)
978 struct bound_minimal_symbol msym
;
980 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
981 throw_error (NO_ENTRY_VALUE_ERROR
,
982 _("DW_OP_entry_value resolving has found "
983 "function \"%s\" at %s can call itself via tail "
985 (msym
.minsym
== NULL
? "???"
986 : msym
.minsym
->print_name ()),
987 paddress (gdbarch
, verify_addr
));
990 if (addr_hash
.insert (target_addr
).second
)
991 todo
.push_back (target_addr
);
996 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
997 ENTRY_VALUES_DEBUG. */
1000 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
1002 CORE_ADDR addr
= call_site
->pc
;
1003 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
1005 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
1006 (msym
.minsym
== NULL
? "???"
1007 : msym
.minsym
->print_name ()));
1011 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
1012 only top callers and bottom callees which are present in both. GDBARCH is
1013 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
1014 no remaining possibilities to provide unambiguous non-trivial result.
1015 RESULTP should point to NULL on the first (initialization) call. Caller is
1016 responsible for xfree of any RESULTP data. */
1019 chain_candidate (struct gdbarch
*gdbarch
,
1020 gdb::unique_xmalloc_ptr
<struct call_site_chain
> *resultp
,
1021 std::vector
<struct call_site
*> *chain
)
1023 long length
= chain
->size ();
1024 int callers
, callees
, idx
;
1026 if (*resultp
== NULL
)
1028 /* Create the initial chain containing all the passed PCs. */
1030 struct call_site_chain
*result
1031 = ((struct call_site_chain
*)
1032 xmalloc (sizeof (*result
)
1033 + sizeof (*result
->call_site
) * (length
- 1)));
1034 result
->length
= length
;
1035 result
->callers
= result
->callees
= length
;
1036 if (!chain
->empty ())
1037 memcpy (result
->call_site
, chain
->data (),
1038 sizeof (*result
->call_site
) * length
);
1039 resultp
->reset (result
);
1041 if (entry_values_debug
)
1043 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
1044 for (idx
= 0; idx
< length
; idx
++)
1045 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
1046 fputc_unfiltered ('\n', gdb_stdlog
);
1052 if (entry_values_debug
)
1054 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
1055 for (idx
= 0; idx
< length
; idx
++)
1056 tailcall_dump (gdbarch
, chain
->at (idx
));
1057 fputc_unfiltered ('\n', gdb_stdlog
);
1060 /* Intersect callers. */
1062 callers
= std::min ((long) (*resultp
)->callers
, length
);
1063 for (idx
= 0; idx
< callers
; idx
++)
1064 if ((*resultp
)->call_site
[idx
] != chain
->at (idx
))
1066 (*resultp
)->callers
= idx
;
1070 /* Intersect callees. */
1072 callees
= std::min ((long) (*resultp
)->callees
, length
);
1073 for (idx
= 0; idx
< callees
; idx
++)
1074 if ((*resultp
)->call_site
[(*resultp
)->length
- 1 - idx
]
1075 != chain
->at (length
- 1 - idx
))
1077 (*resultp
)->callees
= idx
;
1081 if (entry_values_debug
)
1083 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
1084 for (idx
= 0; idx
< (*resultp
)->callers
; idx
++)
1085 tailcall_dump (gdbarch
, (*resultp
)->call_site
[idx
]);
1086 fputs_unfiltered (" |", gdb_stdlog
);
1087 for (idx
= 0; idx
< (*resultp
)->callees
; idx
++)
1088 tailcall_dump (gdbarch
,
1089 (*resultp
)->call_site
[(*resultp
)->length
1090 - (*resultp
)->callees
+ idx
]);
1091 fputc_unfiltered ('\n', gdb_stdlog
);
1094 if ((*resultp
)->callers
== 0 && (*resultp
)->callees
== 0)
1096 /* There are no common callers or callees. It could be also a direct
1097 call (which has length 0) with ambiguous possibility of an indirect
1098 call - CALLERS == CALLEES == 0 is valid during the first allocation
1099 but any subsequence processing of such entry means ambiguity. */
1100 resultp
->reset (NULL
);
1104 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
1105 PC again. In such case there must be two different code paths to reach
1106 it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
1107 gdb_assert ((*resultp
)->callers
+ (*resultp
)->callees
<= (*resultp
)->length
);
1110 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1111 assumed frames between them use GDBARCH. Use depth first search so we can
1112 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
1113 would have needless GDB stack overhead. Any unreliability results
1114 in thrown NO_ENTRY_VALUE_ERROR. */
1116 static gdb::unique_xmalloc_ptr
<call_site_chain
>
1117 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1118 CORE_ADDR callee_pc
)
1120 CORE_ADDR save_callee_pc
= callee_pc
;
1121 gdb::unique_xmalloc_ptr
<struct call_site_chain
> retval
;
1122 struct call_site
*call_site
;
1124 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
1125 call_site nor any possible call_site at CALLEE_PC's function is there.
1126 Any CALL_SITE in CHAIN will be iterated to its siblings - via
1127 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
1128 std::vector
<struct call_site
*> chain
;
1130 /* We are not interested in the specific PC inside the callee function. */
1131 callee_pc
= get_pc_function_start (callee_pc
);
1133 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
1134 paddress (gdbarch
, save_callee_pc
));
1136 /* Mark CALL_SITEs so we do not visit the same ones twice. */
1137 std::unordered_set
<CORE_ADDR
> addr_hash
;
1139 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
1140 at the target's function. All the possible tail call sites in the
1141 target's function will get iterated as already pushed into CHAIN via their
1143 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1147 CORE_ADDR target_func_addr
;
1148 struct call_site
*target_call_site
;
1150 /* CALLER_FRAME with registers is not available for tail-call jumped
1152 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
1154 if (target_func_addr
== callee_pc
)
1156 chain_candidate (gdbarch
, &retval
, &chain
);
1160 /* There is no way to reach CALLEE_PC again as we would prevent
1161 entering it twice as being already marked in ADDR_HASH. */
1162 target_call_site
= NULL
;
1166 struct symbol
*target_func
;
1168 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
1169 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
1174 /* Attempt to visit TARGET_CALL_SITE. */
1176 if (target_call_site
)
1178 if (addr_hash
.insert (target_call_site
->pc
).second
)
1180 /* Successfully entered TARGET_CALL_SITE. */
1182 chain
.push_back (target_call_site
);
1187 /* Backtrack (without revisiting the originating call_site). Try the
1188 callers's sibling; if there isn't any try the callers's callers's
1191 target_call_site
= NULL
;
1192 while (!chain
.empty ())
1194 call_site
= chain
.back ();
1197 size_t removed
= addr_hash
.erase (call_site
->pc
);
1198 gdb_assert (removed
== 1);
1200 target_call_site
= call_site
->tail_call_next
;
1201 if (target_call_site
)
1205 while (target_call_site
);
1210 call_site
= chain
.back ();
1215 struct bound_minimal_symbol msym_caller
, msym_callee
;
1217 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
1218 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
1219 throw_error (NO_ENTRY_VALUE_ERROR
,
1220 _("There are no unambiguously determinable intermediate "
1221 "callers or callees between caller function \"%s\" at %s "
1222 "and callee function \"%s\" at %s"),
1223 (msym_caller
.minsym
== NULL
1224 ? "???" : msym_caller
.minsym
->print_name ()),
1225 paddress (gdbarch
, caller_pc
),
1226 (msym_callee
.minsym
== NULL
1227 ? "???" : msym_callee
.minsym
->print_name ()),
1228 paddress (gdbarch
, callee_pc
));
1234 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1235 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
1236 constructed return NULL. */
1238 gdb::unique_xmalloc_ptr
<call_site_chain
>
1239 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1240 CORE_ADDR callee_pc
)
1242 gdb::unique_xmalloc_ptr
<call_site_chain
> retval
;
1246 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
1248 catch (const gdb_exception_error
&e
)
1250 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
1252 if (entry_values_debug
)
1253 exception_print (gdb_stdout
, e
);
1264 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1267 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1268 enum call_site_parameter_kind kind
,
1269 union call_site_parameter_u kind_u
)
1271 if (kind
== parameter
->kind
)
1274 case CALL_SITE_PARAMETER_DWARF_REG
:
1275 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1276 case CALL_SITE_PARAMETER_FB_OFFSET
:
1277 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1278 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1279 return kind_u
.param_cu_off
== parameter
->u
.param_cu_off
;
1284 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1285 FRAME is for callee.
1287 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1290 static struct call_site_parameter
*
1291 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1292 enum call_site_parameter_kind kind
,
1293 union call_site_parameter_u kind_u
,
1294 dwarf2_per_cu_data
**per_cu_return
,
1295 dwarf2_per_objfile
**per_objfile_return
)
1297 CORE_ADDR func_addr
, caller_pc
;
1298 struct gdbarch
*gdbarch
;
1299 struct frame_info
*caller_frame
;
1300 struct call_site
*call_site
;
1302 /* Initialize it just to avoid a GCC false warning. */
1303 struct call_site_parameter
*parameter
= NULL
;
1304 CORE_ADDR target_addr
;
1306 while (get_frame_type (frame
) == INLINE_FRAME
)
1308 frame
= get_prev_frame (frame
);
1309 gdb_assert (frame
!= NULL
);
1312 func_addr
= get_frame_func (frame
);
1313 gdbarch
= get_frame_arch (frame
);
1314 caller_frame
= get_prev_frame (frame
);
1315 if (gdbarch
!= frame_unwind_arch (frame
))
1317 struct bound_minimal_symbol msym
1318 = lookup_minimal_symbol_by_pc (func_addr
);
1319 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1321 throw_error (NO_ENTRY_VALUE_ERROR
,
1322 _("DW_OP_entry_value resolving callee gdbarch %s "
1323 "(of %s (%s)) does not match caller gdbarch %s"),
1324 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1325 paddress (gdbarch
, func_addr
),
1326 (msym
.minsym
== NULL
? "???"
1327 : msym
.minsym
->print_name ()),
1328 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1331 if (caller_frame
== NULL
)
1333 struct bound_minimal_symbol msym
1334 = lookup_minimal_symbol_by_pc (func_addr
);
1336 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_entry_value resolving "
1337 "requires caller of %s (%s)"),
1338 paddress (gdbarch
, func_addr
),
1339 (msym
.minsym
== NULL
? "???"
1340 : msym
.minsym
->print_name ()));
1342 caller_pc
= get_frame_pc (caller_frame
);
1343 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1345 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1346 if (target_addr
!= func_addr
)
1348 struct minimal_symbol
*target_msym
, *func_msym
;
1350 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1351 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1352 throw_error (NO_ENTRY_VALUE_ERROR
,
1353 _("DW_OP_entry_value resolving expects callee %s at %s "
1354 "but the called frame is for %s at %s"),
1355 (target_msym
== NULL
? "???"
1356 : target_msym
->print_name ()),
1357 paddress (gdbarch
, target_addr
),
1358 func_msym
== NULL
? "???" : func_msym
->print_name (),
1359 paddress (gdbarch
, func_addr
));
1362 /* No entry value based parameters would be reliable if this function can
1363 call itself via tail calls. */
1364 func_verify_no_selftailcall (gdbarch
, func_addr
);
1366 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1368 parameter
= &call_site
->parameter
[iparams
];
1369 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1372 if (iparams
== call_site
->parameter_count
)
1374 struct minimal_symbol
*msym
1375 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1377 /* DW_TAG_call_site_parameter will be missing just if GCC could not
1378 determine its value. */
1379 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1380 "at DW_TAG_call_site %s at %s"),
1381 paddress (gdbarch
, caller_pc
),
1382 msym
== NULL
? "???" : msym
->print_name ());
1385 *per_cu_return
= call_site
->per_cu
;
1386 *per_objfile_return
= call_site
->per_objfile
;
1390 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1391 the normal DW_AT_call_value block. Otherwise return the
1392 DW_AT_call_data_value (dereferenced) block.
1394 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1397 Function always returns non-NULL, non-optimized out value. It throws
1398 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1400 static struct value
*
1401 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1402 CORE_ADDR deref_size
, struct type
*type
,
1403 struct frame_info
*caller_frame
,
1404 dwarf2_per_cu_data
*per_cu
,
1405 dwarf2_per_objfile
*per_objfile
)
1407 const gdb_byte
*data_src
;
1411 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1412 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1414 /* DEREF_SIZE size is not verified here. */
1415 if (data_src
== NULL
)
1416 throw_error (NO_ENTRY_VALUE_ERROR
,
1417 _("Cannot resolve DW_AT_call_data_value"));
1419 /* DW_AT_call_value is a DWARF expression, not a DWARF
1420 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1422 data
= (gdb_byte
*) alloca (size
+ 1);
1423 memcpy (data
, data_src
, size
);
1424 data
[size
] = DW_OP_stack_value
;
1426 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
,
1430 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1431 the indirect method on it, that is use its stored target value, the sole
1432 purpose of entry_data_value_funcs.. */
1434 static struct value
*
1435 entry_data_value_coerce_ref (const struct value
*value
)
1437 struct type
*checked_type
= check_typedef (value_type (value
));
1438 struct value
*target_val
;
1440 if (!TYPE_IS_REFERENCE (checked_type
))
1443 target_val
= (struct value
*) value_computed_closure (value
);
1444 value_incref (target_val
);
1448 /* Implement copy_closure. */
1451 entry_data_value_copy_closure (const struct value
*v
)
1453 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1455 value_incref (target_val
);
1459 /* Implement free_closure. */
1462 entry_data_value_free_closure (struct value
*v
)
1464 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1466 value_decref (target_val
);
1469 /* Vector for methods for an entry value reference where the referenced value
1470 is stored in the caller. On the first dereference use
1471 DW_AT_call_data_value in the caller. */
1473 static const struct lval_funcs entry_data_value_funcs
=
1477 NULL
, /* indirect */
1478 entry_data_value_coerce_ref
,
1479 NULL
, /* check_synthetic_pointer */
1480 entry_data_value_copy_closure
,
1481 entry_data_value_free_closure
1484 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1485 are used to match DW_AT_location at the caller's
1486 DW_TAG_call_site_parameter.
1488 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1489 cannot resolve the parameter for any reason. */
1491 static struct value
*
1492 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1493 enum call_site_parameter_kind kind
,
1494 union call_site_parameter_u kind_u
)
1496 struct type
*checked_type
= check_typedef (type
);
1497 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1498 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1499 struct value
*outer_val
, *target_val
, *val
;
1500 struct call_site_parameter
*parameter
;
1501 dwarf2_per_cu_data
*caller_per_cu
;
1502 dwarf2_per_objfile
*caller_per_objfile
;
1504 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1506 &caller_per_objfile
);
1508 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1511 caller_per_objfile
);
1513 /* Check if DW_AT_call_data_value cannot be used. If it should be
1514 used and it is not available do not fall back to OUTER_VAL - dereferencing
1515 TYPE_CODE_REF with non-entry data value would give current value - not the
1518 if (!TYPE_IS_REFERENCE (checked_type
)
1519 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1522 target_val
= dwarf_entry_parameter_to_value (parameter
,
1523 TYPE_LENGTH (target_type
),
1524 target_type
, caller_frame
,
1526 caller_per_objfile
);
1528 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1529 release_value (target_val
).release ());
1531 /* Copy the referencing pointer to the new computed value. */
1532 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1533 TYPE_LENGTH (checked_type
));
1534 set_value_lazy (val
, 0);
1539 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1540 SIZE are DWARF block used to match DW_AT_location at the caller's
1541 DW_TAG_call_site_parameter.
1543 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1544 cannot resolve the parameter for any reason. */
1546 static struct value
*
1547 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1548 const gdb_byte
*block
, size_t block_len
)
1550 union call_site_parameter_u kind_u
;
1552 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1553 if (kind_u
.dwarf_reg
!= -1)
1554 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1557 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1558 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1561 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1562 suppressed during normal operation. The expression can be arbitrary if
1563 there is no caller-callee entry value binding expected. */
1564 throw_error (NO_ENTRY_VALUE_ERROR
,
1565 _("DWARF-2 expression error: DW_OP_entry_value is supported "
1566 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1569 struct piece_closure
1571 /* Reference count. */
1574 /* The objfile from which this closure's expression came. */
1575 dwarf2_per_objfile
*per_objfile
= nullptr;
1577 /* The CU from which this closure's expression came. */
1578 struct dwarf2_per_cu_data
*per_cu
= NULL
;
1580 /* The pieces describing this variable. */
1581 std::vector
<dwarf_expr_piece
> pieces
;
1583 /* Frame ID of frame to which a register value is relative, used
1584 only by DWARF_VALUE_REGISTER. */
1585 struct frame_id frame_id
;
1588 /* Allocate a closure for a value formed from separately-described
1591 static struct piece_closure
*
1592 allocate_piece_closure (dwarf2_per_cu_data
*per_cu
,
1593 dwarf2_per_objfile
*per_objfile
,
1594 std::vector
<dwarf_expr_piece
> &&pieces
,
1595 struct frame_info
*frame
)
1597 struct piece_closure
*c
= new piece_closure
;
1600 /* We must capture this here due to sharing of DWARF state. */
1601 c
->per_objfile
= per_objfile
;
1603 c
->pieces
= std::move (pieces
);
1605 c
->frame_id
= null_frame_id
;
1607 c
->frame_id
= get_frame_id (frame
);
1609 for (dwarf_expr_piece
&piece
: c
->pieces
)
1610 if (piece
.location
== DWARF_VALUE_STACK
)
1611 value_incref (piece
.v
.value
);
1616 /* Return the number of bytes overlapping a contiguous chunk of N_BITS
1617 bits whose first bit is located at bit offset START. */
1620 bits_to_bytes (ULONGEST start
, ULONGEST n_bits
)
1622 return (start
% 8 + n_bits
+ 7) / 8;
1625 /* Read or write a pieced value V. If FROM != NULL, operate in "write
1626 mode": copy FROM into the pieces comprising V. If FROM == NULL,
1627 operate in "read mode": fetch the contents of the (lazy) value V by
1628 composing it from its pieces. */
1631 rw_pieced_value (struct value
*v
, struct value
*from
)
1634 LONGEST offset
= 0, max_offset
;
1635 ULONGEST bits_to_skip
;
1636 gdb_byte
*v_contents
;
1637 const gdb_byte
*from_contents
;
1638 struct piece_closure
*c
1639 = (struct piece_closure
*) value_computed_closure (v
);
1640 gdb::byte_vector buffer
;
1641 bool bits_big_endian
= type_byte_order (value_type (v
)) == BFD_ENDIAN_BIG
;
1645 from_contents
= value_contents (from
);
1650 if (value_type (v
) != value_enclosing_type (v
))
1651 internal_error (__FILE__
, __LINE__
,
1652 _("Should not be able to create a lazy value with "
1653 "an enclosing type"));
1654 v_contents
= value_contents_raw (v
);
1655 from_contents
= NULL
;
1658 bits_to_skip
= 8 * value_offset (v
);
1659 if (value_bitsize (v
))
1661 bits_to_skip
+= (8 * value_offset (value_parent (v
))
1662 + value_bitpos (v
));
1664 && (type_byte_order (value_type (from
))
1667 /* Use the least significant bits of FROM. */
1668 max_offset
= 8 * TYPE_LENGTH (value_type (from
));
1669 offset
= max_offset
- value_bitsize (v
);
1672 max_offset
= value_bitsize (v
);
1675 max_offset
= 8 * TYPE_LENGTH (value_type (v
));
1677 /* Advance to the first non-skipped piece. */
1678 for (i
= 0; i
< c
->pieces
.size () && bits_to_skip
>= c
->pieces
[i
].size
; i
++)
1679 bits_to_skip
-= c
->pieces
[i
].size
;
1681 for (; i
< c
->pieces
.size () && offset
< max_offset
; i
++)
1683 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1684 size_t this_size_bits
, this_size
;
1686 this_size_bits
= p
->size
- bits_to_skip
;
1687 if (this_size_bits
> max_offset
- offset
)
1688 this_size_bits
= max_offset
- offset
;
1690 switch (p
->location
)
1692 case DWARF_VALUE_REGISTER
:
1694 struct frame_info
*frame
= frame_find_by_id (c
->frame_id
);
1695 struct gdbarch
*arch
= get_frame_arch (frame
);
1696 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, p
->v
.regno
);
1697 ULONGEST reg_bits
= 8 * register_size (arch
, gdb_regnum
);
1700 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1701 && p
->offset
+ p
->size
< reg_bits
)
1703 /* Big-endian, and we want less than full size. */
1704 bits_to_skip
+= reg_bits
- (p
->offset
+ p
->size
);
1707 bits_to_skip
+= p
->offset
;
1709 this_size
= bits_to_bytes (bits_to_skip
, this_size_bits
);
1710 buffer
.resize (this_size
);
1715 if (!get_frame_register_bytes (frame
, gdb_regnum
,
1717 this_size
, buffer
.data (),
1721 mark_value_bits_optimized_out (v
, offset
,
1724 mark_value_bits_unavailable (v
, offset
,
1729 copy_bitwise (v_contents
, offset
,
1730 buffer
.data (), bits_to_skip
% 8,
1731 this_size_bits
, bits_big_endian
);
1736 if (bits_to_skip
% 8 != 0 || this_size_bits
% 8 != 0)
1738 /* Data is copied non-byte-aligned into the register.
1739 Need some bits from original register value. */
1740 get_frame_register_bytes (frame
, gdb_regnum
,
1742 this_size
, buffer
.data (),
1745 throw_error (OPTIMIZED_OUT_ERROR
,
1746 _("Can't do read-modify-write to "
1747 "update bitfield; containing word "
1748 "has been optimized out"));
1750 throw_error (NOT_AVAILABLE_ERROR
,
1751 _("Can't do read-modify-write to "
1752 "update bitfield; containing word "
1756 copy_bitwise (buffer
.data (), bits_to_skip
% 8,
1757 from_contents
, offset
,
1758 this_size_bits
, bits_big_endian
);
1759 put_frame_register_bytes (frame
, gdb_regnum
,
1761 this_size
, buffer
.data ());
1766 case DWARF_VALUE_MEMORY
:
1768 bits_to_skip
+= p
->offset
;
1770 CORE_ADDR start_addr
= p
->v
.mem
.addr
+ bits_to_skip
/ 8;
1772 if (bits_to_skip
% 8 == 0 && this_size_bits
% 8 == 0
1775 /* Everything is byte-aligned; no buffer needed. */
1777 write_memory_with_notification (start_addr
,
1780 this_size_bits
/ 8);
1782 read_value_memory (v
, offset
,
1783 p
->v
.mem
.in_stack_memory
,
1784 p
->v
.mem
.addr
+ bits_to_skip
/ 8,
1785 v_contents
+ offset
/ 8,
1786 this_size_bits
/ 8);
1790 this_size
= bits_to_bytes (bits_to_skip
, this_size_bits
);
1791 buffer
.resize (this_size
);
1796 read_value_memory (v
, offset
,
1797 p
->v
.mem
.in_stack_memory
,
1798 p
->v
.mem
.addr
+ bits_to_skip
/ 8,
1799 buffer
.data (), this_size
);
1800 copy_bitwise (v_contents
, offset
,
1801 buffer
.data (), bits_to_skip
% 8,
1802 this_size_bits
, bits_big_endian
);
1807 if (bits_to_skip
% 8 != 0 || this_size_bits
% 8 != 0)
1811 /* Perform a single read for small sizes. */
1812 read_memory (start_addr
, buffer
.data (),
1817 /* Only the first and last bytes can possibly have
1819 read_memory (start_addr
, buffer
.data (), 1);
1820 read_memory (start_addr
+ this_size
- 1,
1821 &buffer
[this_size
- 1], 1);
1825 copy_bitwise (buffer
.data (), bits_to_skip
% 8,
1826 from_contents
, offset
,
1827 this_size_bits
, bits_big_endian
);
1828 write_memory_with_notification (start_addr
,
1835 case DWARF_VALUE_STACK
:
1839 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1843 gdbarch
*objfile_gdbarch
= c
->per_objfile
->objfile
->arch ();
1844 ULONGEST stack_value_size_bits
1845 = 8 * TYPE_LENGTH (value_type (p
->v
.value
));
1847 /* Use zeroes if piece reaches beyond stack value. */
1848 if (p
->offset
+ p
->size
> stack_value_size_bits
)
1851 /* Piece is anchored at least significant bit end. */
1852 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
1853 bits_to_skip
+= stack_value_size_bits
- p
->offset
- p
->size
;
1855 bits_to_skip
+= p
->offset
;
1857 copy_bitwise (v_contents
, offset
,
1858 value_contents_all (p
->v
.value
),
1860 this_size_bits
, bits_big_endian
);
1864 case DWARF_VALUE_LITERAL
:
1868 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1872 ULONGEST literal_size_bits
= 8 * p
->v
.literal
.length
;
1873 size_t n
= this_size_bits
;
1875 /* Cut off at the end of the implicit value. */
1876 bits_to_skip
+= p
->offset
;
1877 if (bits_to_skip
>= literal_size_bits
)
1879 if (n
> literal_size_bits
- bits_to_skip
)
1880 n
= literal_size_bits
- bits_to_skip
;
1882 copy_bitwise (v_contents
, offset
,
1883 p
->v
.literal
.data
, bits_to_skip
,
1884 n
, bits_big_endian
);
1888 case DWARF_VALUE_IMPLICIT_POINTER
:
1891 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1895 /* These bits show up as zeros -- but do not cause the value to
1896 be considered optimized-out. */
1899 case DWARF_VALUE_OPTIMIZED_OUT
:
1900 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1904 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1907 offset
+= this_size_bits
;
1914 read_pieced_value (struct value
*v
)
1916 rw_pieced_value (v
, NULL
);
1920 write_pieced_value (struct value
*to
, struct value
*from
)
1922 rw_pieced_value (to
, from
);
1925 /* An implementation of an lval_funcs method to see whether a value is
1926 a synthetic pointer. */
1929 check_pieced_synthetic_pointer (const struct value
*value
, LONGEST bit_offset
,
1932 struct piece_closure
*c
1933 = (struct piece_closure
*) value_computed_closure (value
);
1936 bit_offset
+= 8 * value_offset (value
);
1937 if (value_bitsize (value
))
1938 bit_offset
+= value_bitpos (value
);
1940 for (i
= 0; i
< c
->pieces
.size () && bit_length
> 0; i
++)
1942 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1943 size_t this_size_bits
= p
->size
;
1947 if (bit_offset
>= this_size_bits
)
1949 bit_offset
-= this_size_bits
;
1953 bit_length
-= this_size_bits
- bit_offset
;
1957 bit_length
-= this_size_bits
;
1959 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1966 /* A wrapper function for get_frame_address_in_block. */
1969 get_frame_address_in_block_wrapper (void *baton
)
1971 return get_frame_address_in_block ((struct frame_info
*) baton
);
1974 /* Fetch a DW_AT_const_value through a synthetic pointer. */
1976 static struct value
*
1977 fetch_const_value_from_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
1978 dwarf2_per_cu_data
*per_cu
,
1979 dwarf2_per_objfile
*per_objfile
,
1982 struct value
*result
= NULL
;
1983 const gdb_byte
*bytes
;
1986 auto_obstack temp_obstack
;
1987 bytes
= dwarf2_fetch_constant_bytes (die
, per_cu
, per_objfile
,
1988 &temp_obstack
, &len
);
1992 if (byte_offset
>= 0
1993 && byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) <= len
)
1995 bytes
+= byte_offset
;
1996 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
1999 invalid_synthetic_pointer ();
2002 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
2007 /* Fetch the value pointed to by a synthetic pointer. */
2009 static struct value
*
2010 indirect_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
2011 dwarf2_per_cu_data
*per_cu
,
2012 dwarf2_per_objfile
*per_objfile
,
2013 struct frame_info
*frame
, struct type
*type
,
2014 bool resolve_abstract_p
)
2016 /* Fetch the location expression of the DIE we're pointing to. */
2017 struct dwarf2_locexpr_baton baton
2018 = dwarf2_fetch_die_loc_sect_off (die
, per_cu
, per_objfile
,
2019 get_frame_address_in_block_wrapper
, frame
,
2020 resolve_abstract_p
);
2022 /* Get type of pointed-to DIE. */
2023 struct type
*orig_type
= dwarf2_fetch_die_type_sect_off (die
, per_cu
,
2025 if (orig_type
== NULL
)
2026 invalid_synthetic_pointer ();
2028 /* If pointed-to DIE has a DW_AT_location, evaluate it and return the
2029 resulting value. Otherwise, it may have a DW_AT_const_value instead,
2030 or it may've been optimized out. */
2031 if (baton
.data
!= NULL
)
2032 return dwarf2_evaluate_loc_desc_full (orig_type
, frame
, baton
.data
,
2033 baton
.size
, baton
.per_cu
,
2035 TYPE_TARGET_TYPE (type
),
2038 return fetch_const_value_from_synthetic_pointer (die
, byte_offset
, per_cu
,
2042 /* An implementation of an lval_funcs method to indirect through a
2043 pointer. This handles the synthetic pointer case when needed. */
2045 static struct value
*
2046 indirect_pieced_value (struct value
*value
)
2048 struct piece_closure
*c
2049 = (struct piece_closure
*) value_computed_closure (value
);
2051 struct frame_info
*frame
;
2054 struct dwarf_expr_piece
*piece
= NULL
;
2055 LONGEST byte_offset
;
2056 enum bfd_endian byte_order
;
2058 type
= check_typedef (value_type (value
));
2059 if (type
->code () != TYPE_CODE_PTR
)
2062 bit_length
= 8 * TYPE_LENGTH (type
);
2063 bit_offset
= 8 * value_offset (value
);
2064 if (value_bitsize (value
))
2065 bit_offset
+= value_bitpos (value
);
2067 for (i
= 0; i
< c
->pieces
.size () && bit_length
> 0; i
++)
2069 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2070 size_t this_size_bits
= p
->size
;
2074 if (bit_offset
>= this_size_bits
)
2076 bit_offset
-= this_size_bits
;
2080 bit_length
-= this_size_bits
- bit_offset
;
2084 bit_length
-= this_size_bits
;
2086 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2089 if (bit_length
!= 0)
2090 error (_("Invalid use of DW_OP_implicit_pointer"));
2096 gdb_assert (piece
!= NULL
);
2097 frame
= get_selected_frame (_("No frame selected."));
2099 /* This is an offset requested by GDB, such as value subscripts.
2100 However, due to how synthetic pointers are implemented, this is
2101 always presented to us as a pointer type. This means we have to
2102 sign-extend it manually as appropriate. Use raw
2103 extract_signed_integer directly rather than value_as_address and
2104 sign extend afterwards on architectures that would need it
2105 (mostly everywhere except MIPS, which has signed addresses) as
2106 the later would go through gdbarch_pointer_to_address and thus
2107 return a CORE_ADDR with high bits set on architectures that
2108 encode address spaces and other things in CORE_ADDR. */
2109 byte_order
= gdbarch_byte_order (get_frame_arch (frame
));
2110 byte_offset
= extract_signed_integer (value_contents (value
),
2111 TYPE_LENGTH (type
), byte_order
);
2112 byte_offset
+= piece
->v
.ptr
.offset
;
2114 return indirect_synthetic_pointer (piece
->v
.ptr
.die_sect_off
,
2115 byte_offset
, c
->per_cu
,
2116 c
->per_objfile
, frame
, type
);
2119 /* Implementation of the coerce_ref method of lval_funcs for synthetic C++
2122 static struct value
*
2123 coerce_pieced_ref (const struct value
*value
)
2125 struct type
*type
= check_typedef (value_type (value
));
2127 if (value_bits_synthetic_pointer (value
, value_embedded_offset (value
),
2128 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
2130 const struct piece_closure
*closure
2131 = (struct piece_closure
*) value_computed_closure (value
);
2132 struct frame_info
*frame
2133 = get_selected_frame (_("No frame selected."));
2135 /* gdb represents synthetic pointers as pieced values with a single
2137 gdb_assert (closure
!= NULL
);
2138 gdb_assert (closure
->pieces
.size () == 1);
2140 return indirect_synthetic_pointer
2141 (closure
->pieces
[0].v
.ptr
.die_sect_off
,
2142 closure
->pieces
[0].v
.ptr
.offset
,
2143 closure
->per_cu
, closure
->per_objfile
, frame
, type
);
2147 /* Else: not a synthetic reference; do nothing. */
2153 copy_pieced_value_closure (const struct value
*v
)
2155 struct piece_closure
*c
2156 = (struct piece_closure
*) value_computed_closure (v
);
2163 free_pieced_value_closure (struct value
*v
)
2165 struct piece_closure
*c
2166 = (struct piece_closure
*) value_computed_closure (v
);
2171 for (dwarf_expr_piece
&p
: c
->pieces
)
2172 if (p
.location
== DWARF_VALUE_STACK
)
2173 value_decref (p
.v
.value
);
2179 /* Functions for accessing a variable described by DW_OP_piece. */
2180 static const struct lval_funcs pieced_value_funcs
= {
2183 indirect_pieced_value
,
2185 check_pieced_synthetic_pointer
,
2186 copy_pieced_value_closure
,
2187 free_pieced_value_closure
2190 /* Evaluate a location description, starting at DATA and with length
2191 SIZE, to find the current location of variable of TYPE in the
2192 context of FRAME. If SUBOBJ_TYPE is non-NULL, return instead the
2193 location of the subobject of type SUBOBJ_TYPE at byte offset
2194 SUBOBJ_BYTE_OFFSET within the variable of type TYPE. */
2196 static struct value
*
2197 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2198 const gdb_byte
*data
, size_t size
,
2199 dwarf2_per_cu_data
*per_cu
,
2200 dwarf2_per_objfile
*per_objfile
,
2201 struct type
*subobj_type
,
2202 LONGEST subobj_byte_offset
)
2204 struct value
*retval
;
2206 if (subobj_type
== NULL
)
2209 subobj_byte_offset
= 0;
2211 else if (subobj_byte_offset
< 0)
2212 invalid_synthetic_pointer ();
2215 return allocate_optimized_out_value (subobj_type
);
2217 dwarf_evaluate_loc_desc
ctx (per_objfile
);
2219 ctx
.per_cu
= per_cu
;
2220 ctx
.obj_address
= 0;
2222 scoped_value_mark free_values
;
2224 ctx
.gdbarch
= per_objfile
->objfile
->arch ();
2225 ctx
.addr_size
= per_cu
->addr_size ();
2226 ctx
.ref_addr_size
= per_cu
->ref_addr_size ();
2230 ctx
.eval (data
, size
);
2232 catch (const gdb_exception_error
&ex
)
2234 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2236 free_values
.free_to_mark ();
2237 retval
= allocate_value (subobj_type
);
2238 mark_value_bytes_unavailable (retval
, 0,
2239 TYPE_LENGTH (subobj_type
));
2242 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2244 if (entry_values_debug
)
2245 exception_print (gdb_stdout
, ex
);
2246 free_values
.free_to_mark ();
2247 return allocate_optimized_out_value (subobj_type
);
2253 if (ctx
.pieces
.size () > 0)
2255 struct piece_closure
*c
;
2256 ULONGEST bit_size
= 0;
2258 for (dwarf_expr_piece
&piece
: ctx
.pieces
)
2259 bit_size
+= piece
.size
;
2260 /* Complain if the expression is larger than the size of the
2262 if (bit_size
> 8 * TYPE_LENGTH (type
))
2263 invalid_synthetic_pointer ();
2265 c
= allocate_piece_closure (per_cu
, per_objfile
, std::move (ctx
.pieces
),
2267 /* We must clean up the value chain after creating the piece
2268 closure but before allocating the result. */
2269 free_values
.free_to_mark ();
2270 retval
= allocate_computed_value (subobj_type
,
2271 &pieced_value_funcs
, c
);
2272 set_value_offset (retval
, subobj_byte_offset
);
2276 switch (ctx
.location
)
2278 case DWARF_VALUE_REGISTER
:
2280 struct gdbarch
*arch
= get_frame_arch (frame
);
2282 = longest_to_int (value_as_long (ctx
.fetch (0)));
2283 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, dwarf_regnum
);
2285 if (subobj_byte_offset
!= 0)
2286 error (_("cannot use offset on synthetic pointer to register"));
2287 free_values
.free_to_mark ();
2288 retval
= value_from_register (subobj_type
, gdb_regnum
, frame
);
2289 if (value_optimized_out (retval
))
2293 /* This means the register has undefined value / was
2294 not saved. As we're computing the location of some
2295 variable etc. in the program, not a value for
2296 inspecting a register ($pc, $sp, etc.), return a
2297 generic optimized out value instead, so that we show
2298 <optimized out> instead of <not saved>. */
2299 tmp
= allocate_value (subobj_type
);
2300 value_contents_copy (tmp
, 0, retval
, 0,
2301 TYPE_LENGTH (subobj_type
));
2307 case DWARF_VALUE_MEMORY
:
2309 struct type
*ptr_type
;
2310 CORE_ADDR address
= ctx
.fetch_address (0);
2311 bool in_stack_memory
= ctx
.fetch_in_stack_memory (0);
2313 /* DW_OP_deref_size (and possibly other operations too) may
2314 create a pointer instead of an address. Ideally, the
2315 pointer to address conversion would be performed as part
2316 of those operations, but the type of the object to
2317 which the address refers is not known at the time of
2318 the operation. Therefore, we do the conversion here
2319 since the type is readily available. */
2321 switch (subobj_type
->code ())
2323 case TYPE_CODE_FUNC
:
2324 case TYPE_CODE_METHOD
:
2325 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_func_ptr
;
2328 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_data_ptr
;
2331 address
= value_as_address (value_from_pointer (ptr_type
, address
));
2333 free_values
.free_to_mark ();
2334 retval
= value_at_lazy (subobj_type
,
2335 address
+ subobj_byte_offset
);
2336 if (in_stack_memory
)
2337 set_value_stack (retval
, 1);
2341 case DWARF_VALUE_STACK
:
2343 struct value
*value
= ctx
.fetch (0);
2344 size_t n
= TYPE_LENGTH (value_type (value
));
2345 size_t len
= TYPE_LENGTH (subobj_type
);
2346 size_t max
= TYPE_LENGTH (type
);
2347 gdbarch
*objfile_gdbarch
= per_objfile
->objfile
->arch ();
2349 if (subobj_byte_offset
+ len
> max
)
2350 invalid_synthetic_pointer ();
2352 /* Preserve VALUE because we are going to free values back
2353 to the mark, but we still need the value contents
2355 value_ref_ptr value_holder
= value_ref_ptr::new_reference (value
);
2356 free_values
.free_to_mark ();
2358 retval
= allocate_value (subobj_type
);
2360 /* The given offset is relative to the actual object. */
2361 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2362 subobj_byte_offset
+= n
- max
;
2364 memcpy (value_contents_raw (retval
),
2365 value_contents_all (value
) + subobj_byte_offset
, len
);
2369 case DWARF_VALUE_LITERAL
:
2372 size_t n
= TYPE_LENGTH (subobj_type
);
2374 if (subobj_byte_offset
+ n
> ctx
.len
)
2375 invalid_synthetic_pointer ();
2377 free_values
.free_to_mark ();
2378 retval
= allocate_value (subobj_type
);
2379 contents
= value_contents_raw (retval
);
2380 memcpy (contents
, ctx
.data
+ subobj_byte_offset
, n
);
2384 case DWARF_VALUE_OPTIMIZED_OUT
:
2385 free_values
.free_to_mark ();
2386 retval
= allocate_optimized_out_value (subobj_type
);
2389 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2390 operation by execute_stack_op. */
2391 case DWARF_VALUE_IMPLICIT_POINTER
:
2392 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2393 it can only be encountered when making a piece. */
2395 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2399 set_value_initialized (retval
, ctx
.initialized
);
2404 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2405 passes 0 as the byte_offset. */
2408 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2409 const gdb_byte
*data
, size_t size
,
2410 dwarf2_per_cu_data
*per_cu
,
2411 dwarf2_per_objfile
*per_objfile
)
2413 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
,
2414 per_objfile
, NULL
, 0);
2417 /* A specialization of dwarf_evaluate_loc_desc that is used by
2418 dwarf2_locexpr_baton_eval. This subclass exists to handle the case
2419 where a caller of dwarf2_locexpr_baton_eval passes in some data,
2420 but with the address being 0. In this situation, we arrange for
2421 memory reads to come from the passed-in buffer. */
2423 struct evaluate_for_locexpr_baton
: public dwarf_evaluate_loc_desc
2425 evaluate_for_locexpr_baton (dwarf2_per_objfile
*per_objfile
)
2426 : dwarf_evaluate_loc_desc (per_objfile
)
2429 /* The data that was passed in. */
2430 gdb::array_view
<const gdb_byte
> data_view
;
2432 CORE_ADDR
get_object_address () override
2434 if (data_view
.data () == nullptr && obj_address
== 0)
2435 error (_("Location address is not set."));
2439 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
2444 /* Prefer the passed-in memory, if it exists. */
2445 CORE_ADDR offset
= addr
- obj_address
;
2446 if (offset
< data_view
.size () && offset
+ len
<= data_view
.size ())
2448 memcpy (buf
, data_view
.data (), len
);
2452 read_memory (addr
, buf
, len
);
2456 /* Evaluates a dwarf expression and stores the result in VAL,
2457 expecting that the dwarf expression only produces a single
2458 CORE_ADDR. FRAME is the frame in which the expression is
2459 evaluated. ADDR_STACK is a context (location of a variable) and
2460 might be needed to evaluate the location expression.
2461 PUSH_INITIAL_VALUE is true if the address (either from ADDR_STACK,
2462 or the default of 0) should be pushed on the DWARF expression
2463 evaluation stack before evaluating the expression; this is required
2464 by certain forms of DWARF expression. Returns 1 on success, 0
2468 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton
*dlbaton
,
2469 struct frame_info
*frame
,
2470 const struct property_addr_info
*addr_stack
,
2472 bool push_initial_value
)
2474 if (dlbaton
== NULL
|| dlbaton
->size
== 0)
2477 dwarf2_per_objfile
*per_objfile
= dlbaton
->per_objfile
;
2478 evaluate_for_locexpr_baton
ctx (per_objfile
);
2481 ctx
.per_cu
= dlbaton
->per_cu
;
2482 if (addr_stack
== nullptr)
2483 ctx
.obj_address
= 0;
2486 ctx
.obj_address
= addr_stack
->addr
;
2487 ctx
.data_view
= addr_stack
->valaddr
;
2490 ctx
.gdbarch
= per_objfile
->objfile
->arch ();
2491 ctx
.addr_size
= dlbaton
->per_cu
->addr_size ();
2492 ctx
.ref_addr_size
= dlbaton
->per_cu
->ref_addr_size ();
2494 if (push_initial_value
)
2495 ctx
.push_address (ctx
.obj_address
, false);
2499 ctx
.eval (dlbaton
->data
, dlbaton
->size
);
2501 catch (const gdb_exception_error
&ex
)
2503 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2507 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2509 if (entry_values_debug
)
2510 exception_print (gdb_stdout
, ex
);
2517 switch (ctx
.location
)
2519 case DWARF_VALUE_REGISTER
:
2520 case DWARF_VALUE_MEMORY
:
2521 case DWARF_VALUE_STACK
:
2522 *valp
= ctx
.fetch_address (0);
2523 if (ctx
.location
== DWARF_VALUE_REGISTER
)
2524 *valp
= ctx
.read_addr_from_reg (*valp
);
2526 case DWARF_VALUE_LITERAL
:
2527 *valp
= extract_signed_integer (ctx
.data
, ctx
.len
,
2528 gdbarch_byte_order (ctx
.gdbarch
));
2530 /* Unsupported dwarf values. */
2531 case DWARF_VALUE_OPTIMIZED_OUT
:
2532 case DWARF_VALUE_IMPLICIT_POINTER
:
2539 /* See dwarf2loc.h. */
2542 dwarf2_evaluate_property (const struct dynamic_prop
*prop
,
2543 struct frame_info
*frame
,
2544 const struct property_addr_info
*addr_stack
,
2546 bool push_initial_value
)
2551 if (frame
== NULL
&& has_stack_frames ())
2552 frame
= get_selected_frame (NULL
);
2558 const struct dwarf2_property_baton
*baton
2559 = (const struct dwarf2_property_baton
*) prop
->data
.baton
;
2560 gdb_assert (baton
->property_type
!= NULL
);
2562 if (dwarf2_locexpr_baton_eval (&baton
->locexpr
, frame
, addr_stack
,
2563 value
, push_initial_value
))
2565 if (baton
->locexpr
.is_reference
)
2567 struct value
*val
= value_at (baton
->property_type
, *value
);
2568 *value
= value_as_address (val
);
2572 gdb_assert (baton
->property_type
!= NULL
);
2574 struct type
*type
= check_typedef (baton
->property_type
);
2575 if (TYPE_LENGTH (type
) < sizeof (CORE_ADDR
)
2576 && !TYPE_UNSIGNED (type
))
2578 /* If we have a valid return candidate and it's value
2579 is signed, we have to sign-extend the value because
2580 CORE_ADDR on 64bit machine has 8 bytes but address
2581 size of an 32bit application is bytes. */
2583 = (baton
->locexpr
.per_cu
->addr_size ()
2585 const CORE_ADDR neg_mask
2586 = (~((CORE_ADDR
) 0) << (addr_size
- 1));
2588 /* Check if signed bit is set and sign-extend values. */
2589 if (*value
& neg_mask
)
2600 struct dwarf2_property_baton
*baton
2601 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2603 const gdb_byte
*data
;
2608 || !get_frame_address_in_block_if_available (frame
, &pc
))
2611 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2614 val
= dwarf2_evaluate_loc_desc (baton
->property_type
, frame
, data
,
2615 size
, baton
->loclist
.per_cu
,
2616 baton
->loclist
.per_objfile
);
2617 if (!value_optimized_out (val
))
2619 *value
= value_as_address (val
);
2627 *value
= prop
->data
.const_val
;
2630 case PROP_ADDR_OFFSET
:
2632 struct dwarf2_property_baton
*baton
2633 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2634 const struct property_addr_info
*pinfo
;
2637 for (pinfo
= addr_stack
; pinfo
!= NULL
; pinfo
= pinfo
->next
)
2639 /* This approach lets us avoid checking the qualifiers. */
2640 if (TYPE_MAIN_TYPE (pinfo
->type
)
2641 == TYPE_MAIN_TYPE (baton
->property_type
))
2645 error (_("cannot find reference address for offset property"));
2646 if (pinfo
->valaddr
.data () != NULL
)
2647 val
= value_from_contents
2648 (baton
->offset_info
.type
,
2649 pinfo
->valaddr
.data () + baton
->offset_info
.offset
);
2651 val
= value_at (baton
->offset_info
.type
,
2652 pinfo
->addr
+ baton
->offset_info
.offset
);
2653 *value
= value_as_address (val
);
2661 /* See dwarf2loc.h. */
2664 dwarf2_compile_property_to_c (string_file
*stream
,
2665 const char *result_name
,
2666 struct gdbarch
*gdbarch
,
2667 unsigned char *registers_used
,
2668 const struct dynamic_prop
*prop
,
2672 struct dwarf2_property_baton
*baton
2673 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2674 const gdb_byte
*data
;
2676 dwarf2_per_cu_data
*per_cu
;
2677 dwarf2_per_objfile
*per_objfile
;
2679 if (prop
->kind
== PROP_LOCEXPR
)
2681 data
= baton
->locexpr
.data
;
2682 size
= baton
->locexpr
.size
;
2683 per_cu
= baton
->locexpr
.per_cu
;
2684 per_objfile
= baton
->locexpr
.per_objfile
;
2688 gdb_assert (prop
->kind
== PROP_LOCLIST
);
2690 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2691 per_cu
= baton
->loclist
.per_cu
;
2692 per_objfile
= baton
->loclist
.per_objfile
;
2695 compile_dwarf_bounds_to_c (stream
, result_name
, prop
, sym
, pc
,
2696 gdbarch
, registers_used
,
2697 per_cu
->addr_size (),
2698 data
, data
+ size
, per_cu
, per_objfile
);
2702 /* Helper functions and baton for dwarf2_loc_desc_get_symbol_read_needs. */
2704 class symbol_needs_eval_context
: public dwarf_expr_context
2707 symbol_needs_eval_context (dwarf2_per_objfile
*per_objfile
)
2708 : dwarf_expr_context (per_objfile
)
2711 enum symbol_needs_kind needs
;
2712 struct dwarf2_per_cu_data
*per_cu
;
2714 /* Reads from registers do require a frame. */
2715 CORE_ADDR
read_addr_from_reg (int regnum
) override
2717 needs
= SYMBOL_NEEDS_FRAME
;
2721 /* "get_reg_value" callback: Reads from registers do require a
2724 struct value
*get_reg_value (struct type
*type
, int regnum
) override
2726 needs
= SYMBOL_NEEDS_FRAME
;
2727 return value_zero (type
, not_lval
);
2730 /* Reads from memory do not require a frame. */
2731 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
2733 memset (buf
, 0, len
);
2736 /* Frame-relative accesses do require a frame. */
2737 void get_frame_base (const gdb_byte
**start
, size_t *length
) override
2739 static gdb_byte lit0
= DW_OP_lit0
;
2744 needs
= SYMBOL_NEEDS_FRAME
;
2747 /* CFA accesses require a frame. */
2748 CORE_ADDR
get_frame_cfa () override
2750 needs
= SYMBOL_NEEDS_FRAME
;
2754 CORE_ADDR
get_frame_pc () override
2756 needs
= SYMBOL_NEEDS_FRAME
;
2760 /* Thread-local accesses require registers, but not a frame. */
2761 CORE_ADDR
get_tls_address (CORE_ADDR offset
) override
2763 if (needs
<= SYMBOL_NEEDS_REGISTERS
)
2764 needs
= SYMBOL_NEEDS_REGISTERS
;
2768 /* Helper interface of per_cu_dwarf_call for
2769 dwarf2_loc_desc_get_symbol_read_needs. */
2771 void dwarf_call (cu_offset die_offset
) override
2773 per_cu_dwarf_call (this, die_offset
, per_cu
, per_objfile
);
2776 /* Helper interface of sect_variable_value for
2777 dwarf2_loc_desc_get_symbol_read_needs. */
2779 struct value
*dwarf_variable_value (sect_offset sect_off
) override
2781 return sect_variable_value (this, sect_off
, per_cu
, per_objfile
);
2784 /* DW_OP_entry_value accesses require a caller, therefore a
2787 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
2788 union call_site_parameter_u kind_u
,
2789 int deref_size
) override
2791 needs
= SYMBOL_NEEDS_FRAME
;
2793 /* The expression may require some stub values on DWARF stack. */
2794 push_address (0, 0);
2797 /* DW_OP_addrx and DW_OP_GNU_addr_index doesn't require a frame. */
2799 CORE_ADDR
get_addr_index (unsigned int index
) override
2801 /* Nothing to do. */
2805 /* DW_OP_push_object_address has a frame already passed through. */
2807 CORE_ADDR
get_object_address () override
2809 /* Nothing to do. */
2814 /* Compute the correct symbol_needs_kind value for the location
2815 expression at DATA (length SIZE). */
2817 static enum symbol_needs_kind
2818 dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte
*data
, size_t size
,
2819 dwarf2_per_cu_data
*per_cu
,
2820 dwarf2_per_objfile
*per_objfile
)
2824 scoped_value_mark free_values
;
2826 symbol_needs_eval_context
ctx (per_objfile
);
2828 ctx
.needs
= SYMBOL_NEEDS_NONE
;
2829 ctx
.per_cu
= per_cu
;
2830 ctx
.gdbarch
= per_objfile
->objfile
->arch ();
2831 ctx
.addr_size
= per_cu
->addr_size ();
2832 ctx
.ref_addr_size
= per_cu
->ref_addr_size ();
2834 ctx
.eval (data
, size
);
2836 in_reg
= ctx
.location
== DWARF_VALUE_REGISTER
;
2838 /* If the location has several pieces, and any of them are in
2839 registers, then we will need a frame to fetch them from. */
2840 for (dwarf_expr_piece
&p
: ctx
.pieces
)
2841 if (p
.location
== DWARF_VALUE_REGISTER
)
2845 ctx
.needs
= SYMBOL_NEEDS_FRAME
;
2849 /* A helper function that throws an unimplemented error mentioning a
2850 given DWARF operator. */
2852 static void ATTRIBUTE_NORETURN
2853 unimplemented (unsigned int op
)
2855 const char *name
= get_DW_OP_name (op
);
2858 error (_("DWARF operator %s cannot be translated to an agent expression"),
2861 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2862 "to an agent expression"),
2868 This is basically a wrapper on gdbarch_dwarf2_reg_to_regnum so that we
2869 can issue a complaint, which is better than having every target's
2870 implementation of dwarf2_reg_to_regnum do it. */
2873 dwarf_reg_to_regnum (struct gdbarch
*arch
, int dwarf_reg
)
2875 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2879 complaint (_("bad DWARF register number %d"), dwarf_reg
);
2884 /* Subroutine of dwarf_reg_to_regnum_or_error to simplify it.
2885 Throw an error because DWARF_REG is bad. */
2888 throw_bad_regnum_error (ULONGEST dwarf_reg
)
2890 /* Still want to print -1 as "-1".
2891 We *could* have int and ULONGEST versions of dwarf2_reg_to_regnum_or_error
2892 but that's overkill for now. */
2893 if ((int) dwarf_reg
== dwarf_reg
)
2894 error (_("Unable to access DWARF register number %d"), (int) dwarf_reg
);
2895 error (_("Unable to access DWARF register number %s"),
2896 pulongest (dwarf_reg
));
2899 /* See dwarf2loc.h. */
2902 dwarf_reg_to_regnum_or_error (struct gdbarch
*arch
, ULONGEST dwarf_reg
)
2906 if (dwarf_reg
> INT_MAX
)
2907 throw_bad_regnum_error (dwarf_reg
);
2908 /* Yes, we will end up issuing a complaint and an error if DWARF_REG is
2909 bad, but that's ok. */
2910 reg
= dwarf_reg_to_regnum (arch
, (int) dwarf_reg
);
2912 throw_bad_regnum_error (dwarf_reg
);
2916 /* A helper function that emits an access to memory. ARCH is the
2917 target architecture. EXPR is the expression which we are building.
2918 NBITS is the number of bits we want to read. This emits the
2919 opcodes needed to read the memory and then extract the desired
2923 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2925 ULONGEST nbytes
= (nbits
+ 7) / 8;
2927 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2930 ax_trace_quick (expr
, nbytes
);
2933 ax_simple (expr
, aop_ref8
);
2934 else if (nbits
<= 16)
2935 ax_simple (expr
, aop_ref16
);
2936 else if (nbits
<= 32)
2937 ax_simple (expr
, aop_ref32
);
2939 ax_simple (expr
, aop_ref64
);
2941 /* If we read exactly the number of bytes we wanted, we're done. */
2942 if (8 * nbytes
== nbits
)
2945 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
)
2947 /* On a bits-big-endian machine, we want the high-order
2949 ax_const_l (expr
, 8 * nbytes
- nbits
);
2950 ax_simple (expr
, aop_rsh_unsigned
);
2954 /* On a bits-little-endian box, we want the low-order NBITS. */
2955 ax_zero_ext (expr
, nbits
);
2959 /* A helper function to return the frame's PC. */
2962 get_ax_pc (void *baton
)
2964 struct agent_expr
*expr
= (struct agent_expr
*) baton
;
2969 /* Compile a DWARF location expression to an agent expression.
2971 EXPR is the agent expression we are building.
2972 LOC is the agent value we modify.
2973 ARCH is the architecture.
2974 ADDR_SIZE is the size of addresses, in bytes.
2975 OP_PTR is the start of the location expression.
2976 OP_END is one past the last byte of the location expression.
2978 This will throw an exception for various kinds of errors -- for
2979 example, if the expression cannot be compiled, or if the expression
2983 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2984 unsigned int addr_size
, const gdb_byte
*op_ptr
,
2985 const gdb_byte
*op_end
,
2986 dwarf2_per_cu_data
*per_cu
,
2987 dwarf2_per_objfile
*per_objfile
)
2989 gdbarch
*arch
= expr
->gdbarch
;
2990 std::vector
<int> dw_labels
, patches
;
2991 const gdb_byte
* const base
= op_ptr
;
2992 const gdb_byte
*previous_piece
= op_ptr
;
2993 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2994 ULONGEST bits_collected
= 0;
2995 unsigned int addr_size_bits
= 8 * addr_size
;
2996 bool bits_big_endian
= byte_order
== BFD_ENDIAN_BIG
;
2998 std::vector
<int> offsets (op_end
- op_ptr
, -1);
3000 /* By default we are making an address. */
3001 loc
->kind
= axs_lvalue_memory
;
3003 while (op_ptr
< op_end
)
3005 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
3006 uint64_t uoffset
, reg
;
3010 offsets
[op_ptr
- base
] = expr
->len
;
3013 /* Our basic approach to code generation is to map DWARF
3014 operations directly to AX operations. However, there are
3017 First, DWARF works on address-sized units, but AX always uses
3018 LONGEST. For most operations we simply ignore this
3019 difference; instead we generate sign extensions as needed
3020 before division and comparison operations. It would be nice
3021 to omit the sign extensions, but there is no way to determine
3022 the size of the target's LONGEST. (This code uses the size
3023 of the host LONGEST in some cases -- that is a bug but it is
3026 Second, some DWARF operations cannot be translated to AX.
3027 For these we simply fail. See
3028 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
3063 ax_const_l (expr
, op
- DW_OP_lit0
);
3067 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
3068 op_ptr
+= addr_size
;
3069 /* Some versions of GCC emit DW_OP_addr before
3070 DW_OP_GNU_push_tls_address. In this case the value is an
3071 index, not an address. We don't support things like
3072 branching between the address and the TLS op. */
3073 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
3074 uoffset
+= per_objfile
->objfile
->text_section_offset ();
3075 ax_const_l (expr
, uoffset
);
3079 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
3083 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
3087 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
3091 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
3095 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
3099 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
3103 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
3107 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
3111 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3112 ax_const_l (expr
, uoffset
);
3115 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3116 ax_const_l (expr
, offset
);
3151 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3152 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_reg0
);
3153 loc
->kind
= axs_lvalue_register
;
3157 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3158 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3159 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3160 loc
->kind
= axs_lvalue_register
;
3163 case DW_OP_implicit_value
:
3167 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
3168 if (op_ptr
+ len
> op_end
)
3169 error (_("DW_OP_implicit_value: too few bytes available."));
3170 if (len
> sizeof (ULONGEST
))
3171 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
3174 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
3177 dwarf_expr_require_composition (op_ptr
, op_end
,
3178 "DW_OP_implicit_value");
3180 loc
->kind
= axs_rvalue
;
3184 case DW_OP_stack_value
:
3185 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
3186 loc
->kind
= axs_rvalue
;
3221 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3222 i
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_breg0
);
3226 ax_const_l (expr
, offset
);
3227 ax_simple (expr
, aop_add
);
3232 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3233 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3234 i
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3238 ax_const_l (expr
, offset
);
3239 ax_simple (expr
, aop_add
);
3245 const gdb_byte
*datastart
;
3247 const struct block
*b
;
3248 struct symbol
*framefunc
;
3250 b
= block_for_pc (expr
->scope
);
3253 error (_("No block found for address"));
3255 framefunc
= block_linkage_function (b
);
3258 error (_("No function found for block"));
3260 func_get_frame_base_dwarf_block (framefunc
, expr
->scope
,
3261 &datastart
, &datalen
);
3263 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3264 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, datastart
,
3265 datastart
+ datalen
, per_cu
,
3267 if (loc
->kind
== axs_lvalue_register
)
3268 require_rvalue (expr
, loc
);
3272 ax_const_l (expr
, offset
);
3273 ax_simple (expr
, aop_add
);
3276 loc
->kind
= axs_lvalue_memory
;
3281 ax_simple (expr
, aop_dup
);
3285 ax_simple (expr
, aop_pop
);
3290 ax_pick (expr
, offset
);
3294 ax_simple (expr
, aop_swap
);
3302 ax_simple (expr
, aop_rot
);
3306 case DW_OP_deref_size
:
3310 if (op
== DW_OP_deref_size
)
3315 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3316 error (_("Unsupported size %d in %s"),
3317 size
, get_DW_OP_name (op
));
3318 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3323 /* Sign extend the operand. */
3324 ax_ext (expr
, addr_size_bits
);
3325 ax_simple (expr
, aop_dup
);
3326 ax_const_l (expr
, 0);
3327 ax_simple (expr
, aop_less_signed
);
3328 ax_simple (expr
, aop_log_not
);
3329 i
= ax_goto (expr
, aop_if_goto
);
3330 /* We have to emit 0 - X. */
3331 ax_const_l (expr
, 0);
3332 ax_simple (expr
, aop_swap
);
3333 ax_simple (expr
, aop_sub
);
3334 ax_label (expr
, i
, expr
->len
);
3338 /* No need to sign extend here. */
3339 ax_const_l (expr
, 0);
3340 ax_simple (expr
, aop_swap
);
3341 ax_simple (expr
, aop_sub
);
3345 /* Sign extend the operand. */
3346 ax_ext (expr
, addr_size_bits
);
3347 ax_simple (expr
, aop_bit_not
);
3350 case DW_OP_plus_uconst
:
3351 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3352 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3353 but we micro-optimize anyhow. */
3356 ax_const_l (expr
, reg
);
3357 ax_simple (expr
, aop_add
);
3362 ax_simple (expr
, aop_bit_and
);
3366 /* Sign extend the operands. */
3367 ax_ext (expr
, addr_size_bits
);
3368 ax_simple (expr
, aop_swap
);
3369 ax_ext (expr
, addr_size_bits
);
3370 ax_simple (expr
, aop_swap
);
3371 ax_simple (expr
, aop_div_signed
);
3375 ax_simple (expr
, aop_sub
);
3379 ax_simple (expr
, aop_rem_unsigned
);
3383 ax_simple (expr
, aop_mul
);
3387 ax_simple (expr
, aop_bit_or
);
3391 ax_simple (expr
, aop_add
);
3395 ax_simple (expr
, aop_lsh
);
3399 ax_simple (expr
, aop_rsh_unsigned
);
3403 ax_simple (expr
, aop_rsh_signed
);
3407 ax_simple (expr
, aop_bit_xor
);
3411 /* Sign extend the operands. */
3412 ax_ext (expr
, addr_size_bits
);
3413 ax_simple (expr
, aop_swap
);
3414 ax_ext (expr
, addr_size_bits
);
3415 /* Note no swap here: A <= B is !(B < A). */
3416 ax_simple (expr
, aop_less_signed
);
3417 ax_simple (expr
, aop_log_not
);
3421 /* Sign extend the operands. */
3422 ax_ext (expr
, addr_size_bits
);
3423 ax_simple (expr
, aop_swap
);
3424 ax_ext (expr
, addr_size_bits
);
3425 ax_simple (expr
, aop_swap
);
3426 /* A >= B is !(A < B). */
3427 ax_simple (expr
, aop_less_signed
);
3428 ax_simple (expr
, aop_log_not
);
3432 /* Sign extend the operands. */
3433 ax_ext (expr
, addr_size_bits
);
3434 ax_simple (expr
, aop_swap
);
3435 ax_ext (expr
, addr_size_bits
);
3436 /* No need for a second swap here. */
3437 ax_simple (expr
, aop_equal
);
3441 /* Sign extend the operands. */
3442 ax_ext (expr
, addr_size_bits
);
3443 ax_simple (expr
, aop_swap
);
3444 ax_ext (expr
, addr_size_bits
);
3445 ax_simple (expr
, aop_swap
);
3446 ax_simple (expr
, aop_less_signed
);
3450 /* Sign extend the operands. */
3451 ax_ext (expr
, addr_size_bits
);
3452 ax_simple (expr
, aop_swap
);
3453 ax_ext (expr
, addr_size_bits
);
3454 /* Note no swap here: A > B is B < A. */
3455 ax_simple (expr
, aop_less_signed
);
3459 /* Sign extend the operands. */
3460 ax_ext (expr
, addr_size_bits
);
3461 ax_simple (expr
, aop_swap
);
3462 ax_ext (expr
, addr_size_bits
);
3463 /* No need for a swap here. */
3464 ax_simple (expr
, aop_equal
);
3465 ax_simple (expr
, aop_log_not
);
3468 case DW_OP_call_frame_cfa
:
3471 CORE_ADDR text_offset
;
3473 const gdb_byte
*cfa_start
, *cfa_end
;
3475 if (dwarf2_fetch_cfa_info (arch
, expr
->scope
, per_cu
,
3477 &text_offset
, &cfa_start
, &cfa_end
))
3480 ax_reg (expr
, regnum
);
3483 ax_const_l (expr
, off
);
3484 ax_simple (expr
, aop_add
);
3489 /* Another expression. */
3490 ax_const_l (expr
, text_offset
);
3491 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, cfa_start
,
3492 cfa_end
, per_cu
, per_objfile
);
3495 loc
->kind
= axs_lvalue_memory
;
3499 case DW_OP_GNU_push_tls_address
:
3500 case DW_OP_form_tls_address
:
3504 case DW_OP_push_object_address
:
3509 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3511 i
= ax_goto (expr
, aop_goto
);
3512 dw_labels
.push_back (op_ptr
+ offset
- base
);
3513 patches
.push_back (i
);
3517 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3519 /* Zero extend the operand. */
3520 ax_zero_ext (expr
, addr_size_bits
);
3521 i
= ax_goto (expr
, aop_if_goto
);
3522 dw_labels
.push_back (op_ptr
+ offset
- base
);
3523 patches
.push_back (i
);
3530 case DW_OP_bit_piece
:
3534 if (op_ptr
- 1 == previous_piece
)
3535 error (_("Cannot translate empty pieces to agent expressions"));
3536 previous_piece
= op_ptr
- 1;
3538 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3539 if (op
== DW_OP_piece
)
3545 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3547 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3548 error (_("Expression pieces exceed word size"));
3550 /* Access the bits. */
3553 case axs_lvalue_register
:
3554 ax_reg (expr
, loc
->u
.reg
);
3557 case axs_lvalue_memory
:
3558 /* Offset the pointer, if needed. */
3561 ax_const_l (expr
, uoffset
/ 8);
3562 ax_simple (expr
, aop_add
);
3565 access_memory (arch
, expr
, size
);
3569 /* For a bits-big-endian target, shift up what we already
3570 have. For a bits-little-endian target, shift up the
3571 new data. Note that there is a potential bug here if
3572 the DWARF expression leaves multiple values on the
3574 if (bits_collected
> 0)
3576 if (bits_big_endian
)
3578 ax_simple (expr
, aop_swap
);
3579 ax_const_l (expr
, size
);
3580 ax_simple (expr
, aop_lsh
);
3581 /* We don't need a second swap here, because
3582 aop_bit_or is symmetric. */
3586 ax_const_l (expr
, size
);
3587 ax_simple (expr
, aop_lsh
);
3589 ax_simple (expr
, aop_bit_or
);
3592 bits_collected
+= size
;
3593 loc
->kind
= axs_rvalue
;
3597 case DW_OP_GNU_uninit
:
3603 struct dwarf2_locexpr_baton block
;
3604 int size
= (op
== DW_OP_call2
? 2 : 4);
3606 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3609 cu_offset cuoffset
= (cu_offset
) uoffset
;
3610 block
= dwarf2_fetch_die_loc_cu_off (cuoffset
, per_cu
, per_objfile
,
3613 /* DW_OP_call_ref is currently not supported. */
3614 gdb_assert (block
.per_cu
== per_cu
);
3616 dwarf2_compile_expr_to_ax (expr
, loc
, addr_size
, block
.data
,
3617 block
.data
+ block
.size
, per_cu
,
3622 case DW_OP_call_ref
:
3625 case DW_OP_GNU_variable_value
:
3633 /* Patch all the branches we emitted. */
3634 for (int i
= 0; i
< patches
.size (); ++i
)
3636 int targ
= offsets
[dw_labels
[i
]];
3638 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3639 ax_label (expr
, patches
[i
], targ
);
3644 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3645 evaluator to calculate the location. */
3646 static struct value
*
3647 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3649 struct dwarf2_locexpr_baton
*dlbaton
3650 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3653 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3654 dlbaton
->size
, dlbaton
->per_cu
,
3655 dlbaton
->per_objfile
);
3660 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3661 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3664 static struct value
*
3665 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3667 struct dwarf2_locexpr_baton
*dlbaton
3668 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3670 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3674 /* Implementation of get_symbol_read_needs from
3675 symbol_computed_ops. */
3677 static enum symbol_needs_kind
3678 locexpr_get_symbol_read_needs (struct symbol
*symbol
)
3680 struct dwarf2_locexpr_baton
*dlbaton
3681 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3683 return dwarf2_loc_desc_get_symbol_read_needs (dlbaton
->data
, dlbaton
->size
,
3685 dlbaton
->per_objfile
);
3688 /* Return true if DATA points to the end of a piece. END is one past
3689 the last byte in the expression. */
3692 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3694 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3697 /* Helper for locexpr_describe_location_piece that finds the name of a
3701 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3705 /* This doesn't use dwarf_reg_to_regnum_or_error on purpose.
3706 We'd rather print *something* here than throw an error. */
3707 regnum
= dwarf_reg_to_regnum (gdbarch
, dwarf_regnum
);
3708 /* gdbarch_register_name may just return "", return something more
3709 descriptive for bad register numbers. */
3712 /* The text is output as "$bad_register_number".
3713 That is why we use the underscores. */
3714 return _("bad_register_number");
3716 return gdbarch_register_name (gdbarch
, regnum
);
3719 /* Nicely describe a single piece of a location, returning an updated
3720 position in the bytecode sequence. This function cannot recognize
3721 all locations; if a location is not recognized, it simply returns
3722 DATA. If there is an error during reading, e.g. we run off the end
3723 of the buffer, an error is thrown. */
3725 static const gdb_byte
*
3726 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3727 CORE_ADDR addr
, dwarf2_per_cu_data
*per_cu
,
3728 dwarf2_per_objfile
*per_objfile
,
3729 const gdb_byte
*data
, const gdb_byte
*end
,
3730 unsigned int addr_size
)
3732 objfile
*objfile
= per_objfile
->objfile
;
3733 struct gdbarch
*gdbarch
= objfile
->arch ();
3736 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3738 fprintf_filtered (stream
, _("a variable in $%s"),
3739 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3742 else if (data
[0] == DW_OP_regx
)
3746 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3747 fprintf_filtered (stream
, _("a variable in $%s"),
3748 locexpr_regname (gdbarch
, reg
));
3750 else if (data
[0] == DW_OP_fbreg
)
3752 const struct block
*b
;
3753 struct symbol
*framefunc
;
3755 int64_t frame_offset
;
3756 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3758 int64_t base_offset
= 0;
3760 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3761 if (!piece_end_p (new_data
, end
))
3765 b
= block_for_pc (addr
);
3768 error (_("No block found for address for symbol \"%s\"."),
3769 symbol
->print_name ());
3771 framefunc
= block_linkage_function (b
);
3774 error (_("No function found for block for symbol \"%s\"."),
3775 symbol
->print_name ());
3777 func_get_frame_base_dwarf_block (framefunc
, addr
, &base_data
, &base_size
);
3779 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3781 const gdb_byte
*buf_end
;
3783 frame_reg
= base_data
[0] - DW_OP_breg0
;
3784 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3786 if (buf_end
!= base_data
+ base_size
)
3787 error (_("Unexpected opcode after "
3788 "DW_OP_breg%u for symbol \"%s\"."),
3789 frame_reg
, symbol
->print_name ());
3791 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3793 /* The frame base is just the register, with no offset. */
3794 frame_reg
= base_data
[0] - DW_OP_reg0
;
3799 /* We don't know what to do with the frame base expression,
3800 so we can't trace this variable; give up. */
3804 fprintf_filtered (stream
,
3805 _("a variable at frame base reg $%s offset %s+%s"),
3806 locexpr_regname (gdbarch
, frame_reg
),
3807 plongest (base_offset
), plongest (frame_offset
));
3809 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3810 && piece_end_p (data
, end
))
3814 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3816 fprintf_filtered (stream
,
3817 _("a variable at offset %s from base reg $%s"),
3819 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3822 /* The location expression for a TLS variable looks like this (on a
3825 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3826 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3828 0x3 is the encoding for DW_OP_addr, which has an operand as long
3829 as the size of an address on the target machine (here is 8
3830 bytes). Note that more recent version of GCC emit DW_OP_const4u
3831 or DW_OP_const8u, depending on address size, rather than
3832 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3833 The operand represents the offset at which the variable is within
3834 the thread local storage. */
3836 else if (data
+ 1 + addr_size
< end
3837 && (data
[0] == DW_OP_addr
3838 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3839 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3840 && (data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3841 || data
[1 + addr_size
] == DW_OP_form_tls_address
)
3842 && piece_end_p (data
+ 2 + addr_size
, end
))
3845 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3846 gdbarch_byte_order (gdbarch
));
3848 fprintf_filtered (stream
,
3849 _("a thread-local variable at offset 0x%s "
3850 "in the thread-local storage for `%s'"),
3851 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3853 data
+= 1 + addr_size
+ 1;
3856 /* With -gsplit-dwarf a TLS variable can also look like this:
3857 DW_AT_location : 3 byte block: fc 4 e0
3858 (DW_OP_GNU_const_index: 4;
3859 DW_OP_GNU_push_tls_address) */
3860 else if (data
+ 3 <= end
3861 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3862 && data
[0] == DW_OP_GNU_const_index
3864 && (data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3865 || data
[1 + leb128_size
] == DW_OP_form_tls_address
)
3866 && piece_end_p (data
+ 2 + leb128_size
, end
))
3870 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3871 offset
= dwarf2_read_addr_index (per_cu
, per_objfile
, offset
);
3872 fprintf_filtered (stream
,
3873 _("a thread-local variable at offset 0x%s "
3874 "in the thread-local storage for `%s'"),
3875 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3879 else if (data
[0] >= DW_OP_lit0
3880 && data
[0] <= DW_OP_lit31
3882 && data
[1] == DW_OP_stack_value
)
3884 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3891 /* Disassemble an expression, stopping at the end of a piece or at the
3892 end of the expression. Returns a pointer to the next unread byte
3893 in the input expression. If ALL is nonzero, then this function
3894 will keep going until it reaches the end of the expression.
3895 If there is an error during reading, e.g. we run off the end
3896 of the buffer, an error is thrown. */
3898 static const gdb_byte
*
3899 disassemble_dwarf_expression (struct ui_file
*stream
,
3900 struct gdbarch
*arch
, unsigned int addr_size
,
3901 int offset_size
, const gdb_byte
*start
,
3902 const gdb_byte
*data
, const gdb_byte
*end
,
3903 int indent
, int all
,
3904 dwarf2_per_cu_data
*per_cu
,
3905 dwarf2_per_objfile
*per_objfile
)
3909 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3911 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *data
++;
3916 name
= get_DW_OP_name (op
);
3919 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3920 op
, (long) (data
- 1 - start
));
3921 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3922 (long) (data
- 1 - start
), name
);
3927 ul
= extract_unsigned_integer (data
, addr_size
,
3928 gdbarch_byte_order (arch
));
3930 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3934 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3936 fprintf_filtered (stream
, " %s", pulongest (ul
));
3939 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3941 fprintf_filtered (stream
, " %s", plongest (l
));
3944 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3946 fprintf_filtered (stream
, " %s", pulongest (ul
));
3949 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3951 fprintf_filtered (stream
, " %s", plongest (l
));
3954 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3956 fprintf_filtered (stream
, " %s", pulongest (ul
));
3959 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3961 fprintf_filtered (stream
, " %s", plongest (l
));
3964 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3966 fprintf_filtered (stream
, " %s", pulongest (ul
));
3969 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3971 fprintf_filtered (stream
, " %s", plongest (l
));
3974 data
= safe_read_uleb128 (data
, end
, &ul
);
3975 fprintf_filtered (stream
, " %s", pulongest (ul
));
3978 data
= safe_read_sleb128 (data
, end
, &l
);
3979 fprintf_filtered (stream
, " %s", plongest (l
));
4014 fprintf_filtered (stream
, " [$%s]",
4015 locexpr_regname (arch
, op
- DW_OP_reg0
));
4019 data
= safe_read_uleb128 (data
, end
, &ul
);
4020 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
4021 locexpr_regname (arch
, (int) ul
));
4024 case DW_OP_implicit_value
:
4025 data
= safe_read_uleb128 (data
, end
, &ul
);
4027 fprintf_filtered (stream
, " %s", pulongest (ul
));
4062 data
= safe_read_sleb128 (data
, end
, &l
);
4063 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
4064 locexpr_regname (arch
, op
- DW_OP_breg0
));
4068 data
= safe_read_uleb128 (data
, end
, &ul
);
4069 data
= safe_read_sleb128 (data
, end
, &l
);
4070 fprintf_filtered (stream
, " register %s [$%s] offset %s",
4072 locexpr_regname (arch
, (int) ul
),
4077 data
= safe_read_sleb128 (data
, end
, &l
);
4078 fprintf_filtered (stream
, " %s", plongest (l
));
4081 case DW_OP_xderef_size
:
4082 case DW_OP_deref_size
:
4084 fprintf_filtered (stream
, " %d", *data
);
4088 case DW_OP_plus_uconst
:
4089 data
= safe_read_uleb128 (data
, end
, &ul
);
4090 fprintf_filtered (stream
, " %s", pulongest (ul
));
4094 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4096 fprintf_filtered (stream
, " to %ld",
4097 (long) (data
+ l
- start
));
4101 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4103 fprintf_filtered (stream
, " %ld",
4104 (long) (data
+ l
- start
));
4108 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
4110 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
4114 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4116 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4119 case DW_OP_call_ref
:
4120 ul
= extract_unsigned_integer (data
, offset_size
,
4121 gdbarch_byte_order (arch
));
4122 data
+= offset_size
;
4123 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4127 data
= safe_read_uleb128 (data
, end
, &ul
);
4128 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
4131 case DW_OP_bit_piece
:
4135 data
= safe_read_uleb128 (data
, end
, &ul
);
4136 data
= safe_read_uleb128 (data
, end
, &offset
);
4137 fprintf_filtered (stream
, " size %s offset %s (bits)",
4138 pulongest (ul
), pulongest (offset
));
4142 case DW_OP_implicit_pointer
:
4143 case DW_OP_GNU_implicit_pointer
:
4145 ul
= extract_unsigned_integer (data
, offset_size
,
4146 gdbarch_byte_order (arch
));
4147 data
+= offset_size
;
4149 data
= safe_read_sleb128 (data
, end
, &l
);
4151 fprintf_filtered (stream
, " DIE %s offset %s",
4152 phex_nz (ul
, offset_size
),
4157 case DW_OP_deref_type
:
4158 case DW_OP_GNU_deref_type
:
4160 int deref_addr_size
= *data
++;
4163 data
= safe_read_uleb128 (data
, end
, &ul
);
4164 cu_offset offset
= (cu_offset
) ul
;
4165 type
= dwarf2_get_die_type (offset
, per_cu
, per_objfile
);
4166 fprintf_filtered (stream
, "<");
4167 type_print (type
, "", stream
, -1);
4168 fprintf_filtered (stream
, " [0x%s]> %d",
4169 phex_nz (to_underlying (offset
), 0),
4174 case DW_OP_const_type
:
4175 case DW_OP_GNU_const_type
:
4179 data
= safe_read_uleb128 (data
, end
, &ul
);
4180 cu_offset type_die
= (cu_offset
) ul
;
4181 type
= dwarf2_get_die_type (type_die
, per_cu
, per_objfile
);
4182 fprintf_filtered (stream
, "<");
4183 type_print (type
, "", stream
, -1);
4184 fprintf_filtered (stream
, " [0x%s]>",
4185 phex_nz (to_underlying (type_die
), 0));
4188 fprintf_filtered (stream
, " %d byte block:", n
);
4189 for (int i
= 0; i
< n
; ++i
)
4190 fprintf_filtered (stream
, " %02x", data
[i
]);
4195 case DW_OP_regval_type
:
4196 case DW_OP_GNU_regval_type
:
4201 data
= safe_read_uleb128 (data
, end
, ®
);
4202 data
= safe_read_uleb128 (data
, end
, &ul
);
4203 cu_offset type_die
= (cu_offset
) ul
;
4205 type
= dwarf2_get_die_type (type_die
, per_cu
, per_objfile
);
4206 fprintf_filtered (stream
, "<");
4207 type_print (type
, "", stream
, -1);
4208 fprintf_filtered (stream
, " [0x%s]> [$%s]",
4209 phex_nz (to_underlying (type_die
), 0),
4210 locexpr_regname (arch
, reg
));
4215 case DW_OP_GNU_convert
:
4216 case DW_OP_reinterpret
:
4217 case DW_OP_GNU_reinterpret
:
4219 data
= safe_read_uleb128 (data
, end
, &ul
);
4220 cu_offset type_die
= (cu_offset
) ul
;
4222 if (to_underlying (type_die
) == 0)
4223 fprintf_filtered (stream
, "<0>");
4228 type
= dwarf2_get_die_type (type_die
, per_cu
, per_objfile
);
4229 fprintf_filtered (stream
, "<");
4230 type_print (type
, "", stream
, -1);
4231 fprintf_filtered (stream
, " [0x%s]>",
4232 phex_nz (to_underlying (type_die
), 0));
4237 case DW_OP_entry_value
:
4238 case DW_OP_GNU_entry_value
:
4239 data
= safe_read_uleb128 (data
, end
, &ul
);
4240 fputc_filtered ('\n', stream
);
4241 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
4242 start
, data
, data
+ ul
, indent
+ 2,
4243 all
, per_cu
, per_objfile
);
4247 case DW_OP_GNU_parameter_ref
:
4248 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4250 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4254 case DW_OP_GNU_addr_index
:
4255 data
= safe_read_uleb128 (data
, end
, &ul
);
4256 ul
= dwarf2_read_addr_index (per_cu
, per_objfile
, ul
);
4257 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
4259 case DW_OP_GNU_const_index
:
4260 data
= safe_read_uleb128 (data
, end
, &ul
);
4261 ul
= dwarf2_read_addr_index (per_cu
, per_objfile
, ul
);
4262 fprintf_filtered (stream
, " %s", pulongest (ul
));
4265 case DW_OP_GNU_variable_value
:
4266 ul
= extract_unsigned_integer (data
, offset_size
,
4267 gdbarch_byte_order (arch
));
4268 data
+= offset_size
;
4269 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4273 fprintf_filtered (stream
, "\n");
4279 static bool dwarf_always_disassemble
;
4282 show_dwarf_always_disassemble (struct ui_file
*file
, int from_tty
,
4283 struct cmd_list_element
*c
, const char *value
)
4285 fprintf_filtered (file
,
4286 _("Whether to always disassemble "
4287 "DWARF expressions is %s.\n"),
4291 /* Describe a single location, which may in turn consist of multiple
4295 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
4296 struct ui_file
*stream
,
4297 const gdb_byte
*data
, size_t size
,
4298 unsigned int addr_size
,
4299 int offset_size
, dwarf2_per_cu_data
*per_cu
,
4300 dwarf2_per_objfile
*per_objfile
)
4302 const gdb_byte
*end
= data
+ size
;
4303 int first_piece
= 1, bad
= 0;
4304 objfile
*objfile
= per_objfile
->objfile
;
4308 const gdb_byte
*here
= data
;
4309 int disassemble
= 1;
4314 fprintf_filtered (stream
, _(", and "));
4316 if (!dwarf_always_disassemble
)
4318 data
= locexpr_describe_location_piece (symbol
, stream
,
4319 addr
, per_cu
, per_objfile
,
4320 data
, end
, addr_size
);
4321 /* If we printed anything, or if we have an empty piece,
4322 then don't disassemble. */
4324 || data
[0] == DW_OP_piece
4325 || data
[0] == DW_OP_bit_piece
)
4330 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
4331 data
= disassemble_dwarf_expression (stream
,
4333 addr_size
, offset_size
, data
,
4335 dwarf_always_disassemble
,
4336 per_cu
, per_objfile
);
4341 int empty
= data
== here
;
4344 fprintf_filtered (stream
, " ");
4345 if (data
[0] == DW_OP_piece
)
4349 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
4352 fprintf_filtered (stream
, _("an empty %s-byte piece"),
4355 fprintf_filtered (stream
, _(" [%s-byte piece]"),
4358 else if (data
[0] == DW_OP_bit_piece
)
4360 uint64_t bits
, offset
;
4362 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
4363 data
= safe_read_uleb128 (data
, end
, &offset
);
4366 fprintf_filtered (stream
,
4367 _("an empty %s-bit piece"),
4370 fprintf_filtered (stream
,
4371 _(" [%s-bit piece, offset %s bits]"),
4372 pulongest (bits
), pulongest (offset
));
4382 if (bad
|| data
> end
)
4383 error (_("Corrupted DWARF2 expression for \"%s\"."),
4384 symbol
->print_name ());
4387 /* Print a natural-language description of SYMBOL to STREAM. This
4388 version is for a symbol with a single location. */
4391 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4392 struct ui_file
*stream
)
4394 struct dwarf2_locexpr_baton
*dlbaton
4395 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4396 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4397 int offset_size
= dlbaton
->per_cu
->offset_size ();
4399 locexpr_describe_location_1 (symbol
, addr
, stream
,
4400 dlbaton
->data
, dlbaton
->size
,
4401 addr_size
, offset_size
,
4402 dlbaton
->per_cu
, dlbaton
->per_objfile
);
4405 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4406 any necessary bytecode in AX. */
4409 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
4410 struct axs_value
*value
)
4412 struct dwarf2_locexpr_baton
*dlbaton
4413 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4414 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4416 if (dlbaton
->size
== 0)
4417 value
->optimized_out
= 1;
4419 dwarf2_compile_expr_to_ax (ax
, value
, addr_size
, dlbaton
->data
,
4420 dlbaton
->data
+ dlbaton
->size
, dlbaton
->per_cu
,
4421 dlbaton
->per_objfile
);
4424 /* symbol_computed_ops 'generate_c_location' method. */
4427 locexpr_generate_c_location (struct symbol
*sym
, string_file
*stream
,
4428 struct gdbarch
*gdbarch
,
4429 unsigned char *registers_used
,
4430 CORE_ADDR pc
, const char *result_name
)
4432 struct dwarf2_locexpr_baton
*dlbaton
4433 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (sym
);
4434 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4436 if (dlbaton
->size
== 0)
4437 error (_("symbol \"%s\" is optimized out"), sym
->natural_name ());
4439 compile_dwarf_expr_to_c (stream
, result_name
,
4440 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4441 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4442 dlbaton
->per_cu
, dlbaton
->per_objfile
);
4445 /* The set of location functions used with the DWARF-2 expression
4447 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4448 locexpr_read_variable
,
4449 locexpr_read_variable_at_entry
,
4450 locexpr_get_symbol_read_needs
,
4451 locexpr_describe_location
,
4452 0, /* location_has_loclist */
4453 locexpr_tracepoint_var_ref
,
4454 locexpr_generate_c_location
4458 /* Wrapper functions for location lists. These generally find
4459 the appropriate location expression and call something above. */
4461 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4462 evaluator to calculate the location. */
4463 static struct value
*
4464 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4466 struct dwarf2_loclist_baton
*dlbaton
4467 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4469 const gdb_byte
*data
;
4471 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4473 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4474 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4475 dlbaton
->per_cu
, dlbaton
->per_objfile
);
4480 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4481 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4484 Function always returns non-NULL value, it may be marked optimized out if
4485 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4486 if it cannot resolve the parameter for any reason. */
4488 static struct value
*
4489 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4491 struct dwarf2_loclist_baton
*dlbaton
4492 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4493 const gdb_byte
*data
;
4497 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4498 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4500 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4502 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4504 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4507 /* Implementation of get_symbol_read_needs from
4508 symbol_computed_ops. */
4510 static enum symbol_needs_kind
4511 loclist_symbol_needs (struct symbol
*symbol
)
4513 /* If there's a location list, then assume we need to have a frame
4514 to choose the appropriate location expression. With tracking of
4515 global variables this is not necessarily true, but such tracking
4516 is disabled in GCC at the moment until we figure out how to
4519 return SYMBOL_NEEDS_FRAME
;
4522 /* Print a natural-language description of SYMBOL to STREAM. This
4523 version applies when there is a list of different locations, each
4524 with a specified address range. */
4527 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4528 struct ui_file
*stream
)
4530 struct dwarf2_loclist_baton
*dlbaton
4531 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4532 const gdb_byte
*loc_ptr
, *buf_end
;
4533 dwarf2_per_objfile
*per_objfile
= dlbaton
->per_objfile
;
4534 struct objfile
*objfile
= per_objfile
->objfile
;
4535 struct gdbarch
*gdbarch
= objfile
->arch ();
4536 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4537 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4538 int offset_size
= dlbaton
->per_cu
->offset_size ();
4539 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4540 /* Adjust base_address for relocatable objects. */
4541 CORE_ADDR base_offset
= objfile
->text_section_offset ();
4542 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4545 loc_ptr
= dlbaton
->data
;
4546 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4548 fprintf_filtered (stream
, _("multi-location:\n"));
4550 /* Iterate through locations until we run out. */
4553 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4555 enum debug_loc_kind kind
;
4556 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4558 if (dlbaton
->per_cu
->version () < 5 && dlbaton
->from_dwo
)
4559 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4560 dlbaton
->per_objfile
,
4561 loc_ptr
, buf_end
, &new_ptr
,
4562 &low
, &high
, byte_order
);
4563 else if (dlbaton
->per_cu
->version () < 5)
4564 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4566 byte_order
, addr_size
,
4569 kind
= decode_debug_loclists_addresses (dlbaton
->per_cu
,
4570 dlbaton
->per_objfile
,
4571 loc_ptr
, buf_end
, &new_ptr
,
4572 &low
, &high
, byte_order
,
4573 addr_size
, signed_addr_p
);
4577 case DEBUG_LOC_END_OF_LIST
:
4580 case DEBUG_LOC_BASE_ADDRESS
:
4581 base_address
= high
+ base_offset
;
4582 fprintf_filtered (stream
, _(" Base address %s"),
4583 paddress (gdbarch
, base_address
));
4585 case DEBUG_LOC_START_END
:
4586 case DEBUG_LOC_START_LENGTH
:
4587 case DEBUG_LOC_OFFSET_PAIR
:
4589 case DEBUG_LOC_BUFFER_OVERFLOW
:
4590 case DEBUG_LOC_INVALID_ENTRY
:
4591 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4592 symbol
->print_name ());
4594 gdb_assert_not_reached ("bad debug_loc_kind");
4597 /* Otherwise, a location expression entry. */
4598 low
+= base_address
;
4599 high
+= base_address
;
4601 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
);
4602 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
);
4604 if (dlbaton
->per_cu
->version () < 5)
4606 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4611 unsigned int bytes_read
;
4612 length
= read_unsigned_leb128 (NULL
, loc_ptr
, &bytes_read
);
4613 loc_ptr
+= bytes_read
;
4616 /* (It would improve readability to print only the minimum
4617 necessary digits of the second number of the range.) */
4618 fprintf_filtered (stream
, _(" Range %s-%s: "),
4619 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4621 /* Now describe this particular location. */
4622 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4623 addr_size
, offset_size
,
4624 dlbaton
->per_cu
, dlbaton
->per_objfile
);
4626 fprintf_filtered (stream
, "\n");
4632 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4633 any necessary bytecode in AX. */
4635 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct agent_expr
*ax
,
4636 struct axs_value
*value
)
4638 struct dwarf2_loclist_baton
*dlbaton
4639 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4640 const gdb_byte
*data
;
4642 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4644 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4646 value
->optimized_out
= 1;
4648 dwarf2_compile_expr_to_ax (ax
, value
, addr_size
, data
, data
+ size
,
4649 dlbaton
->per_cu
, dlbaton
->per_objfile
);
4652 /* symbol_computed_ops 'generate_c_location' method. */
4655 loclist_generate_c_location (struct symbol
*sym
, string_file
*stream
,
4656 struct gdbarch
*gdbarch
,
4657 unsigned char *registers_used
,
4658 CORE_ADDR pc
, const char *result_name
)
4660 struct dwarf2_loclist_baton
*dlbaton
4661 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (sym
);
4662 unsigned int addr_size
= dlbaton
->per_cu
->addr_size ();
4663 const gdb_byte
*data
;
4666 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4668 error (_("symbol \"%s\" is optimized out"), sym
->natural_name ());
4670 compile_dwarf_expr_to_c (stream
, result_name
,
4671 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4674 dlbaton
->per_objfile
);
4677 /* The set of location functions used with the DWARF-2 expression
4678 evaluator and location lists. */
4679 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4680 loclist_read_variable
,
4681 loclist_read_variable_at_entry
,
4682 loclist_symbol_needs
,
4683 loclist_describe_location
,
4684 1, /* location_has_loclist */
4685 loclist_tracepoint_var_ref
,
4686 loclist_generate_c_location
4689 void _initialize_dwarf2loc ();
4691 _initialize_dwarf2loc ()
4693 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4694 &entry_values_debug
,
4695 _("Set entry values and tail call frames "
4697 _("Show entry values and tail call frames "
4699 _("When non-zero, the process of determining "
4700 "parameter values from function entry point "
4701 "and tail call frames will be printed."),
4703 show_entry_values_debug
,
4704 &setdebuglist
, &showdebuglist
);
4706 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
4707 &dwarf_always_disassemble
, _("\
4708 Set whether `info address' always disassembles DWARF expressions."), _("\
4709 Show whether `info address' always disassembles DWARF expressions."), _("\
4710 When enabled, DWARF expressions are always printed in an assembly-like\n\
4711 syntax. When disabled, expressions will be printed in a more\n\
4712 conversational style, when possible."),
4714 show_dwarf_always_disassemble
,
4716 &show_dwarf_cmdlist
);