1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003-2017 Free Software Foundation, Inc.
5 Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
35 #include "complaints.h"
37 #include "dwarf2expr.h"
38 #include "dwarf2loc.h"
39 #include "dwarf2-frame.h"
40 #include "compile/compile.h"
44 #include <unordered_set>
46 extern int dwarf_always_disassemble
;
48 static struct value
*dwarf2_evaluate_loc_desc_full (struct type
*type
,
49 struct frame_info
*frame
,
52 struct dwarf2_per_cu_data
*per_cu
,
53 struct type
*subobj_type
,
54 LONGEST subobj_byte_offset
);
56 static struct call_site_parameter
*dwarf_expr_reg_to_entry_parameter
57 (struct frame_info
*frame
,
58 enum call_site_parameter_kind kind
,
59 union call_site_parameter_u kind_u
,
60 struct dwarf2_per_cu_data
**per_cu_return
);
62 /* Until these have formal names, we define these here.
63 ref: http://gcc.gnu.org/wiki/DebugFission
64 Each entry in .debug_loc.dwo begins with a byte that describes the entry,
65 and is then followed by data specific to that entry. */
69 /* Indicates the end of the list of entries. */
70 DEBUG_LOC_END_OF_LIST
= 0,
72 /* This is followed by an unsigned LEB128 number that is an index into
73 .debug_addr and specifies the base address for all following entries. */
74 DEBUG_LOC_BASE_ADDRESS
= 1,
76 /* This is followed by two unsigned LEB128 numbers that are indices into
77 .debug_addr and specify the beginning and ending addresses, and then
78 a normal location expression as in .debug_loc. */
79 DEBUG_LOC_START_END
= 2,
81 /* This is followed by an unsigned LEB128 number that is an index into
82 .debug_addr and specifies the beginning address, and a 4 byte unsigned
83 number that specifies the length, and then a normal location expression
85 DEBUG_LOC_START_LENGTH
= 3,
87 /* An internal value indicating there is insufficient data. */
88 DEBUG_LOC_BUFFER_OVERFLOW
= -1,
90 /* An internal value indicating an invalid kind of entry was found. */
91 DEBUG_LOC_INVALID_ENTRY
= -2
94 /* Helper function which throws an error if a synthetic pointer is
98 invalid_synthetic_pointer (void)
100 error (_("access outside bounds of object "
101 "referenced via synthetic pointer"));
104 /* Decode the addresses in a non-dwo .debug_loc entry.
105 A pointer to the next byte to examine is returned in *NEW_PTR.
106 The encoded low,high addresses are return in *LOW,*HIGH.
107 The result indicates the kind of entry found. */
109 static enum debug_loc_kind
110 decode_debug_loc_addresses (const gdb_byte
*loc_ptr
, const gdb_byte
*buf_end
,
111 const gdb_byte
**new_ptr
,
112 CORE_ADDR
*low
, CORE_ADDR
*high
,
113 enum bfd_endian byte_order
,
114 unsigned int addr_size
,
117 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
119 if (buf_end
- loc_ptr
< 2 * addr_size
)
120 return DEBUG_LOC_BUFFER_OVERFLOW
;
123 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
125 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
126 loc_ptr
+= addr_size
;
129 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
131 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
132 loc_ptr
+= addr_size
;
136 /* A base-address-selection entry. */
137 if ((*low
& base_mask
) == base_mask
)
138 return DEBUG_LOC_BASE_ADDRESS
;
140 /* An end-of-list entry. */
141 if (*low
== 0 && *high
== 0)
142 return DEBUG_LOC_END_OF_LIST
;
144 return DEBUG_LOC_START_END
;
147 /* Decode the addresses in .debug_loclists entry.
148 A pointer to the next byte to examine is returned in *NEW_PTR.
149 The encoded low,high addresses are return in *LOW,*HIGH.
150 The result indicates the kind of entry found. */
152 static enum debug_loc_kind
153 decode_debug_loclists_addresses (struct dwarf2_per_cu_data
*per_cu
,
154 const gdb_byte
*loc_ptr
,
155 const gdb_byte
*buf_end
,
156 const gdb_byte
**new_ptr
,
157 CORE_ADDR
*low
, CORE_ADDR
*high
,
158 enum bfd_endian byte_order
,
159 unsigned int addr_size
,
164 if (loc_ptr
== buf_end
)
165 return DEBUG_LOC_BUFFER_OVERFLOW
;
169 case DW_LLE_end_of_list
:
171 return DEBUG_LOC_END_OF_LIST
;
172 case DW_LLE_base_address
:
173 if (loc_ptr
+ addr_size
> buf_end
)
174 return DEBUG_LOC_BUFFER_OVERFLOW
;
176 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
178 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
179 loc_ptr
+= addr_size
;
181 return DEBUG_LOC_BASE_ADDRESS
;
182 case DW_LLE_offset_pair
:
183 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
185 return DEBUG_LOC_BUFFER_OVERFLOW
;
187 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
189 return DEBUG_LOC_BUFFER_OVERFLOW
;
192 return DEBUG_LOC_START_END
;
194 return DEBUG_LOC_INVALID_ENTRY
;
198 /* Decode the addresses in .debug_loc.dwo entry.
199 A pointer to the next byte to examine is returned in *NEW_PTR.
200 The encoded low,high addresses are return in *LOW,*HIGH.
201 The result indicates the kind of entry found. */
203 static enum debug_loc_kind
204 decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data
*per_cu
,
205 const gdb_byte
*loc_ptr
,
206 const gdb_byte
*buf_end
,
207 const gdb_byte
**new_ptr
,
208 CORE_ADDR
*low
, CORE_ADDR
*high
,
209 enum bfd_endian byte_order
)
211 uint64_t low_index
, high_index
;
213 if (loc_ptr
== buf_end
)
214 return DEBUG_LOC_BUFFER_OVERFLOW
;
218 case DW_LLE_GNU_end_of_list_entry
:
220 return DEBUG_LOC_END_OF_LIST
;
221 case DW_LLE_GNU_base_address_selection_entry
:
223 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
225 return DEBUG_LOC_BUFFER_OVERFLOW
;
226 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
228 return DEBUG_LOC_BASE_ADDRESS
;
229 case DW_LLE_GNU_start_end_entry
:
230 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
232 return DEBUG_LOC_BUFFER_OVERFLOW
;
233 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
234 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
236 return DEBUG_LOC_BUFFER_OVERFLOW
;
237 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
239 return DEBUG_LOC_START_END
;
240 case DW_LLE_GNU_start_length_entry
:
241 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
243 return DEBUG_LOC_BUFFER_OVERFLOW
;
244 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
245 if (loc_ptr
+ 4 > buf_end
)
246 return DEBUG_LOC_BUFFER_OVERFLOW
;
248 *high
+= extract_unsigned_integer (loc_ptr
, 4, byte_order
);
249 *new_ptr
= loc_ptr
+ 4;
250 return DEBUG_LOC_START_LENGTH
;
252 return DEBUG_LOC_INVALID_ENTRY
;
256 /* A function for dealing with location lists. Given a
257 symbol baton (BATON) and a pc value (PC), find the appropriate
258 location expression, set *LOCEXPR_LENGTH, and return a pointer
259 to the beginning of the expression. Returns NULL on failure.
261 For now, only return the first matching location expression; there
262 can be more than one in the list. */
265 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
266 size_t *locexpr_length
, CORE_ADDR pc
)
268 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
269 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
270 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
271 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
272 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
273 /* Adjust base_address for relocatable objects. */
274 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (baton
->per_cu
);
275 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
276 const gdb_byte
*loc_ptr
, *buf_end
;
278 loc_ptr
= baton
->data
;
279 buf_end
= baton
->data
+ baton
->size
;
283 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
285 enum debug_loc_kind kind
;
286 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
289 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
290 loc_ptr
, buf_end
, &new_ptr
,
291 &low
, &high
, byte_order
);
292 else if (dwarf2_version (baton
->per_cu
) < 5)
293 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
295 byte_order
, addr_size
,
298 kind
= decode_debug_loclists_addresses (baton
->per_cu
,
299 loc_ptr
, buf_end
, &new_ptr
,
300 &low
, &high
, byte_order
,
301 addr_size
, signed_addr_p
);
306 case DEBUG_LOC_END_OF_LIST
:
309 case DEBUG_LOC_BASE_ADDRESS
:
310 base_address
= high
+ base_offset
;
312 case DEBUG_LOC_START_END
:
313 case DEBUG_LOC_START_LENGTH
:
315 case DEBUG_LOC_BUFFER_OVERFLOW
:
316 case DEBUG_LOC_INVALID_ENTRY
:
317 error (_("dwarf2_find_location_expression: "
318 "Corrupted DWARF expression."));
320 gdb_assert_not_reached ("bad debug_loc_kind");
323 /* Otherwise, a location expression entry.
324 If the entry is from a DWO, don't add base address: the entry is from
325 .debug_addr which already has the DWARF "base address". We still add
326 base_offset in case we're debugging a PIE executable. */
335 high
+= base_address
;
338 if (dwarf2_version (baton
->per_cu
) < 5)
340 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
345 unsigned int bytes_read
;
347 length
= read_unsigned_leb128 (NULL
, loc_ptr
, &bytes_read
);
348 loc_ptr
+= bytes_read
;
351 if (low
== high
&& pc
== low
)
353 /* This is entry PC record present only at entry point
354 of a function. Verify it is really the function entry point. */
356 const struct block
*pc_block
= block_for_pc (pc
);
357 struct symbol
*pc_func
= NULL
;
360 pc_func
= block_linkage_function (pc_block
);
362 if (pc_func
&& pc
== BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func
)))
364 *locexpr_length
= length
;
369 if (pc
>= low
&& pc
< high
)
371 *locexpr_length
= length
;
379 /* This is the baton used when performing dwarf2 expression
381 struct dwarf_expr_baton
383 struct frame_info
*frame
;
384 struct dwarf2_per_cu_data
*per_cu
;
385 CORE_ADDR obj_address
;
388 /* Implement find_frame_base_location method for LOC_BLOCK functions using
389 DWARF expression for its DW_AT_frame_base. */
392 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
393 const gdb_byte
**start
, size_t *length
)
395 struct dwarf2_locexpr_baton
*symbaton
396 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
398 *length
= symbaton
->size
;
399 *start
= symbaton
->data
;
402 /* Implement the struct symbol_block_ops::get_frame_base method for
403 LOC_BLOCK functions using a DWARF expression as its DW_AT_frame_base. */
406 locexpr_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
408 struct gdbarch
*gdbarch
;
410 struct dwarf2_locexpr_baton
*dlbaton
;
411 const gdb_byte
*start
;
413 struct value
*result
;
415 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
416 Thus, it's supposed to provide the find_frame_base_location method as
418 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
420 gdbarch
= get_frame_arch (frame
);
421 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
422 dlbaton
= (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
424 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
425 (framefunc
, get_frame_pc (frame
), &start
, &length
);
426 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
429 /* The DW_AT_frame_base attribute contains a location description which
430 computes the base address itself. However, the call to
431 dwarf2_evaluate_loc_desc returns a value representing a variable at
432 that address. The frame base address is thus this variable's
434 return value_address (result
);
437 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
438 function uses DWARF expression for its DW_AT_frame_base. */
440 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
442 locexpr_find_frame_base_location
,
443 locexpr_get_frame_base
446 /* Implement find_frame_base_location method for LOC_BLOCK functions using
447 DWARF location list for its DW_AT_frame_base. */
450 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
451 const gdb_byte
**start
, size_t *length
)
453 struct dwarf2_loclist_baton
*symbaton
454 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
456 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
459 /* Implement the struct symbol_block_ops::get_frame_base method for
460 LOC_BLOCK functions using a DWARF location list as its DW_AT_frame_base. */
463 loclist_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
465 struct gdbarch
*gdbarch
;
467 struct dwarf2_loclist_baton
*dlbaton
;
468 const gdb_byte
*start
;
470 struct value
*result
;
472 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
473 Thus, it's supposed to provide the find_frame_base_location method as
475 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
477 gdbarch
= get_frame_arch (frame
);
478 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
479 dlbaton
= (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
481 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
482 (framefunc
, get_frame_pc (frame
), &start
, &length
);
483 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
486 /* The DW_AT_frame_base attribute contains a location description which
487 computes the base address itself. However, the call to
488 dwarf2_evaluate_loc_desc returns a value representing a variable at
489 that address. The frame base address is thus this variable's
491 return value_address (result
);
494 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
495 function uses DWARF location list for its DW_AT_frame_base. */
497 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
499 loclist_find_frame_base_location
,
500 loclist_get_frame_base
503 /* See dwarf2loc.h. */
506 func_get_frame_base_dwarf_block (struct symbol
*framefunc
, CORE_ADDR pc
,
507 const gdb_byte
**start
, size_t *length
)
509 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
511 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
513 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
519 error (_("Could not find the frame base for \"%s\"."),
520 SYMBOL_NATURAL_NAME (framefunc
));
524 get_frame_pc_for_per_cu_dwarf_call (void *baton
)
526 dwarf_expr_context
*ctx
= (dwarf_expr_context
*) baton
;
528 return ctx
->get_frame_pc ();
532 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
533 struct dwarf2_per_cu_data
*per_cu
)
535 struct dwarf2_locexpr_baton block
;
537 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
,
538 get_frame_pc_for_per_cu_dwarf_call
,
541 /* DW_OP_call_ref is currently not supported. */
542 gdb_assert (block
.per_cu
== per_cu
);
544 ctx
->eval (block
.data
, block
.size
);
547 class dwarf_evaluate_loc_desc
: public dwarf_expr_context
551 struct frame_info
*frame
;
552 struct dwarf2_per_cu_data
*per_cu
;
553 CORE_ADDR obj_address
;
555 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
556 the frame in BATON. */
558 CORE_ADDR
get_frame_cfa () OVERRIDE
560 return dwarf2_frame_cfa (frame
);
563 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
564 the frame in BATON. */
566 CORE_ADDR
get_frame_pc () OVERRIDE
568 return get_frame_address_in_block (frame
);
571 /* Using the objfile specified in BATON, find the address for the
572 current thread's thread-local storage with offset OFFSET. */
573 CORE_ADDR
get_tls_address (CORE_ADDR offset
) OVERRIDE
575 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
577 return target_translate_tls_address (objfile
, offset
);
580 /* Helper interface of per_cu_dwarf_call for
581 dwarf2_evaluate_loc_desc. */
583 void dwarf_call (cu_offset die_offset
) OVERRIDE
585 per_cu_dwarf_call (this, die_offset
, per_cu
);
588 struct type
*get_base_type (cu_offset die_offset
, int size
) OVERRIDE
590 struct type
*result
= dwarf2_get_die_type (die_offset
, per_cu
);
592 error (_("Could not find type for DW_OP_const_type"));
593 if (size
!= 0 && TYPE_LENGTH (result
) != size
)
594 error (_("DW_OP_const_type has different sizes for type and data"));
598 /* Callback function for dwarf2_evaluate_loc_desc.
599 Fetch the address indexed by DW_OP_GNU_addr_index. */
601 CORE_ADDR
get_addr_index (unsigned int index
) OVERRIDE
603 return dwarf2_read_addr_index (per_cu
, index
);
606 /* Callback function for get_object_address. Return the address of the VLA
609 CORE_ADDR
get_object_address () OVERRIDE
611 if (obj_address
== 0)
612 error (_("Location address is not set."));
616 /* Execute DWARF block of call_site_parameter which matches KIND and
617 KIND_U. Choose DEREF_SIZE value of that parameter. Search
618 caller of this objects's frame.
620 The caller can be from a different CU - per_cu_dwarf_call
621 implementation can be more simple as it does not support cross-CU
624 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
625 union call_site_parameter_u kind_u
,
626 int deref_size
) OVERRIDE
628 struct frame_info
*caller_frame
;
629 struct dwarf2_per_cu_data
*caller_per_cu
;
630 struct call_site_parameter
*parameter
;
631 const gdb_byte
*data_src
;
634 caller_frame
= get_prev_frame (frame
);
636 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
638 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
639 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
641 /* DEREF_SIZE size is not verified here. */
642 if (data_src
== NULL
)
643 throw_error (NO_ENTRY_VALUE_ERROR
,
644 _("Cannot resolve DW_AT_call_data_value"));
646 scoped_restore save_frame
= make_scoped_restore (&this->frame
,
648 scoped_restore save_per_cu
= make_scoped_restore (&this->per_cu
,
650 scoped_restore save_obj_addr
= make_scoped_restore (&this->obj_address
,
653 scoped_restore save_arch
= make_scoped_restore (&this->gdbarch
);
655 = get_objfile_arch (dwarf2_per_cu_objfile (per_cu
));
656 scoped_restore save_addr_size
= make_scoped_restore (&this->addr_size
);
657 this->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
658 scoped_restore save_offset
= make_scoped_restore (&this->offset
);
659 this->offset
= dwarf2_per_cu_text_offset (per_cu
);
661 this->eval (data_src
, size
);
664 /* Using the frame specified in BATON, find the location expression
665 describing the frame base. Return a pointer to it in START and
666 its length in LENGTH. */
667 void get_frame_base (const gdb_byte
**start
, size_t * length
) OVERRIDE
669 /* FIXME: cagney/2003-03-26: This code should be using
670 get_frame_base_address(), and then implement a dwarf2 specific
672 struct symbol
*framefunc
;
673 const struct block
*bl
= get_frame_block (frame
, NULL
);
676 error (_("frame address is not available."));
678 /* Use block_linkage_function, which returns a real (not inlined)
679 function, instead of get_frame_function, which may return an
681 framefunc
= block_linkage_function (bl
);
683 /* If we found a frame-relative symbol then it was certainly within
684 some function associated with a frame. If we can't find the frame,
685 something has gone wrong. */
686 gdb_assert (framefunc
!= NULL
);
688 func_get_frame_base_dwarf_block (framefunc
,
689 get_frame_address_in_block (frame
),
693 /* Read memory at ADDR (length LEN) into BUF. */
695 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) OVERRIDE
697 read_memory (addr
, buf
, len
);
700 /* Using the frame specified in BATON, return the value of register
701 REGNUM, treated as a pointer. */
702 CORE_ADDR
read_addr_from_reg (int dwarf_regnum
) OVERRIDE
704 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
705 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
707 return address_from_register (regnum
, frame
);
710 /* Implement "get_reg_value" callback. */
712 struct value
*get_reg_value (struct type
*type
, int dwarf_regnum
) OVERRIDE
714 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
715 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
717 return value_from_register (type
, regnum
, frame
);
721 /* See dwarf2loc.h. */
723 unsigned int entry_values_debug
= 0;
725 /* Helper to set entry_values_debug. */
728 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
729 struct cmd_list_element
*c
, const char *value
)
731 fprintf_filtered (file
,
732 _("Entry values and tail call frames debugging is %s.\n"),
736 /* Find DW_TAG_call_site's DW_AT_call_target address.
737 CALLER_FRAME (for registers) can be NULL if it is not known. This function
738 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
741 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
742 struct call_site
*call_site
,
743 struct frame_info
*caller_frame
)
745 switch (FIELD_LOC_KIND (call_site
->target
))
747 case FIELD_LOC_KIND_DWARF_BLOCK
:
749 struct dwarf2_locexpr_baton
*dwarf_block
;
751 struct type
*caller_core_addr_type
;
752 struct gdbarch
*caller_arch
;
754 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
755 if (dwarf_block
== NULL
)
757 struct bound_minimal_symbol msym
;
759 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
760 throw_error (NO_ENTRY_VALUE_ERROR
,
761 _("DW_AT_call_target is not specified at %s in %s"),
762 paddress (call_site_gdbarch
, call_site
->pc
),
763 (msym
.minsym
== NULL
? "???"
764 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
767 if (caller_frame
== NULL
)
769 struct bound_minimal_symbol msym
;
771 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
772 throw_error (NO_ENTRY_VALUE_ERROR
,
773 _("DW_AT_call_target DWARF block resolving "
774 "requires known frame which is currently not "
775 "available at %s in %s"),
776 paddress (call_site_gdbarch
, call_site
->pc
),
777 (msym
.minsym
== NULL
? "???"
778 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
781 caller_arch
= get_frame_arch (caller_frame
);
782 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
783 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
784 dwarf_block
->data
, dwarf_block
->size
,
785 dwarf_block
->per_cu
);
786 /* DW_AT_call_target is a DWARF expression, not a DWARF location. */
787 if (VALUE_LVAL (val
) == lval_memory
)
788 return value_address (val
);
790 return value_as_address (val
);
793 case FIELD_LOC_KIND_PHYSNAME
:
795 const char *physname
;
796 struct bound_minimal_symbol msym
;
798 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
800 /* Handle both the mangled and demangled PHYSNAME. */
801 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
802 if (msym
.minsym
== NULL
)
804 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
805 throw_error (NO_ENTRY_VALUE_ERROR
,
806 _("Cannot find function \"%s\" for a call site target "
808 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
809 (msym
.minsym
== NULL
? "???"
810 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
813 return BMSYMBOL_VALUE_ADDRESS (msym
);
816 case FIELD_LOC_KIND_PHYSADDR
:
817 return FIELD_STATIC_PHYSADDR (call_site
->target
);
820 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
824 /* Convert function entry point exact address ADDR to the function which is
825 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
826 NO_ENTRY_VALUE_ERROR otherwise. */
828 static struct symbol
*
829 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
831 struct symbol
*sym
= find_pc_function (addr
);
834 if (sym
== NULL
|| BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
835 throw_error (NO_ENTRY_VALUE_ERROR
,
836 _("DW_TAG_call_site resolving failed to find function "
837 "name for address %s"),
838 paddress (gdbarch
, addr
));
840 type
= SYMBOL_TYPE (sym
);
841 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
842 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
847 /* Verify function with entry point exact address ADDR can never call itself
848 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
849 can call itself via tail calls.
851 If a funtion can tail call itself its entry value based parameters are
852 unreliable. There is no verification whether the value of some/all
853 parameters is unchanged through the self tail call, we expect if there is
854 a self tail call all the parameters can be modified. */
857 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
861 /* The verification is completely unordered. Track here function addresses
862 which still need to be iterated. */
863 std::vector
<CORE_ADDR
> todo
;
865 /* Track here CORE_ADDRs which were already visited. */
866 std::unordered_set
<CORE_ADDR
> addr_hash
;
868 todo
.push_back (verify_addr
);
869 while (!todo
.empty ())
871 struct symbol
*func_sym
;
872 struct call_site
*call_site
;
877 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
879 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
880 call_site
; call_site
= call_site
->tail_call_next
)
882 CORE_ADDR target_addr
;
884 /* CALLER_FRAME with registers is not available for tail-call jumped
886 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
888 if (target_addr
== verify_addr
)
890 struct bound_minimal_symbol msym
;
892 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
893 throw_error (NO_ENTRY_VALUE_ERROR
,
894 _("DW_OP_entry_value resolving has found "
895 "function \"%s\" at %s can call itself via tail "
897 (msym
.minsym
== NULL
? "???"
898 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
899 paddress (gdbarch
, verify_addr
));
902 if (addr_hash
.insert (target_addr
).second
)
903 todo
.push_back (target_addr
);
908 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
909 ENTRY_VALUES_DEBUG. */
912 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
914 CORE_ADDR addr
= call_site
->pc
;
915 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
917 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
918 (msym
.minsym
== NULL
? "???"
919 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
923 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
924 only top callers and bottom callees which are present in both. GDBARCH is
925 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
926 no remaining possibilities to provide unambiguous non-trivial result.
927 RESULTP should point to NULL on the first (initialization) call. Caller is
928 responsible for xfree of any RESULTP data. */
931 chain_candidate (struct gdbarch
*gdbarch
,
932 gdb::unique_xmalloc_ptr
<struct call_site_chain
> *resultp
,
933 std::vector
<struct call_site
*> *chain
)
935 long length
= chain
->size ();
936 int callers
, callees
, idx
;
938 if (*resultp
== NULL
)
940 /* Create the initial chain containing all the passed PCs. */
942 struct call_site_chain
*result
943 = ((struct call_site_chain
*)
944 xmalloc (sizeof (*result
)
945 + sizeof (*result
->call_site
) * (length
- 1)));
946 result
->length
= length
;
947 result
->callers
= result
->callees
= length
;
948 if (!chain
->empty ())
949 memcpy (result
->call_site
, chain
->data (),
950 sizeof (*result
->call_site
) * length
);
951 resultp
->reset (result
);
953 if (entry_values_debug
)
955 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
956 for (idx
= 0; idx
< length
; idx
++)
957 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
958 fputc_unfiltered ('\n', gdb_stdlog
);
964 if (entry_values_debug
)
966 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
967 for (idx
= 0; idx
< length
; idx
++)
968 tailcall_dump (gdbarch
, chain
->at (idx
));
969 fputc_unfiltered ('\n', gdb_stdlog
);
972 /* Intersect callers. */
974 callers
= std::min ((long) (*resultp
)->callers
, length
);
975 for (idx
= 0; idx
< callers
; idx
++)
976 if ((*resultp
)->call_site
[idx
] != chain
->at (idx
))
978 (*resultp
)->callers
= idx
;
982 /* Intersect callees. */
984 callees
= std::min ((long) (*resultp
)->callees
, length
);
985 for (idx
= 0; idx
< callees
; idx
++)
986 if ((*resultp
)->call_site
[(*resultp
)->length
- 1 - idx
]
987 != chain
->at (length
- 1 - idx
))
989 (*resultp
)->callees
= idx
;
993 if (entry_values_debug
)
995 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
996 for (idx
= 0; idx
< (*resultp
)->callers
; idx
++)
997 tailcall_dump (gdbarch
, (*resultp
)->call_site
[idx
]);
998 fputs_unfiltered (" |", gdb_stdlog
);
999 for (idx
= 0; idx
< (*resultp
)->callees
; idx
++)
1000 tailcall_dump (gdbarch
,
1001 (*resultp
)->call_site
[(*resultp
)->length
1002 - (*resultp
)->callees
+ idx
]);
1003 fputc_unfiltered ('\n', gdb_stdlog
);
1006 if ((*resultp
)->callers
== 0 && (*resultp
)->callees
== 0)
1008 /* There are no common callers or callees. It could be also a direct
1009 call (which has length 0) with ambiguous possibility of an indirect
1010 call - CALLERS == CALLEES == 0 is valid during the first allocation
1011 but any subsequence processing of such entry means ambiguity. */
1012 resultp
->reset (NULL
);
1016 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
1017 PC again. In such case there must be two different code paths to reach
1018 it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
1019 gdb_assert ((*resultp
)->callers
+ (*resultp
)->callees
<= (*resultp
)->length
);
1022 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1023 assumed frames between them use GDBARCH. Use depth first search so we can
1024 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
1025 would have needless GDB stack overhead. Caller is responsible for xfree of
1026 the returned result. Any unreliability results in thrown
1027 NO_ENTRY_VALUE_ERROR. */
1029 static struct call_site_chain
*
1030 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1031 CORE_ADDR callee_pc
)
1033 CORE_ADDR save_callee_pc
= callee_pc
;
1034 gdb::unique_xmalloc_ptr
<struct call_site_chain
> retval
;
1035 struct call_site
*call_site
;
1037 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
1038 call_site nor any possible call_site at CALLEE_PC's function is there.
1039 Any CALL_SITE in CHAIN will be iterated to its siblings - via
1040 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
1041 std::vector
<struct call_site
*> chain
;
1043 /* We are not interested in the specific PC inside the callee function. */
1044 callee_pc
= get_pc_function_start (callee_pc
);
1046 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
1047 paddress (gdbarch
, save_callee_pc
));
1049 /* Mark CALL_SITEs so we do not visit the same ones twice. */
1050 std::unordered_set
<CORE_ADDR
> addr_hash
;
1052 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
1053 at the target's function. All the possible tail call sites in the
1054 target's function will get iterated as already pushed into CHAIN via their
1056 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1060 CORE_ADDR target_func_addr
;
1061 struct call_site
*target_call_site
;
1063 /* CALLER_FRAME with registers is not available for tail-call jumped
1065 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
1067 if (target_func_addr
== callee_pc
)
1069 chain_candidate (gdbarch
, &retval
, &chain
);
1073 /* There is no way to reach CALLEE_PC again as we would prevent
1074 entering it twice as being already marked in ADDR_HASH. */
1075 target_call_site
= NULL
;
1079 struct symbol
*target_func
;
1081 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
1082 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
1087 /* Attempt to visit TARGET_CALL_SITE. */
1089 if (target_call_site
)
1091 if (addr_hash
.insert (target_call_site
->pc
).second
)
1093 /* Successfully entered TARGET_CALL_SITE. */
1095 chain
.push_back (target_call_site
);
1100 /* Backtrack (without revisiting the originating call_site). Try the
1101 callers's sibling; if there isn't any try the callers's callers's
1104 target_call_site
= NULL
;
1105 while (!chain
.empty ())
1107 call_site
= chain
.back ();
1110 size_t removed
= addr_hash
.erase (call_site
->pc
);
1111 gdb_assert (removed
== 1);
1113 target_call_site
= call_site
->tail_call_next
;
1114 if (target_call_site
)
1118 while (target_call_site
);
1123 call_site
= chain
.back ();
1128 struct bound_minimal_symbol msym_caller
, msym_callee
;
1130 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
1131 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
1132 throw_error (NO_ENTRY_VALUE_ERROR
,
1133 _("There are no unambiguously determinable intermediate "
1134 "callers or callees between caller function \"%s\" at %s "
1135 "and callee function \"%s\" at %s"),
1136 (msym_caller
.minsym
== NULL
1137 ? "???" : MSYMBOL_PRINT_NAME (msym_caller
.minsym
)),
1138 paddress (gdbarch
, caller_pc
),
1139 (msym_callee
.minsym
== NULL
1140 ? "???" : MSYMBOL_PRINT_NAME (msym_callee
.minsym
)),
1141 paddress (gdbarch
, callee_pc
));
1144 return retval
.release ();
1147 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1148 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
1149 constructed return NULL. Caller is responsible for xfree of the returned
1152 struct call_site_chain
*
1153 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1154 CORE_ADDR callee_pc
)
1156 struct call_site_chain
*retval
= NULL
;
1160 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
1162 CATCH (e
, RETURN_MASK_ERROR
)
1164 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
1166 if (entry_values_debug
)
1167 exception_print (gdb_stdout
, e
);
1172 throw_exception (e
);
1179 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1182 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1183 enum call_site_parameter_kind kind
,
1184 union call_site_parameter_u kind_u
)
1186 if (kind
== parameter
->kind
)
1189 case CALL_SITE_PARAMETER_DWARF_REG
:
1190 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1191 case CALL_SITE_PARAMETER_FB_OFFSET
:
1192 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1193 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1194 return kind_u
.param_offset
.cu_off
== parameter
->u
.param_offset
.cu_off
;
1199 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1200 FRAME is for callee.
1202 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1205 static struct call_site_parameter
*
1206 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1207 enum call_site_parameter_kind kind
,
1208 union call_site_parameter_u kind_u
,
1209 struct dwarf2_per_cu_data
**per_cu_return
)
1211 CORE_ADDR func_addr
, caller_pc
;
1212 struct gdbarch
*gdbarch
;
1213 struct frame_info
*caller_frame
;
1214 struct call_site
*call_site
;
1216 /* Initialize it just to avoid a GCC false warning. */
1217 struct call_site_parameter
*parameter
= NULL
;
1218 CORE_ADDR target_addr
;
1220 while (get_frame_type (frame
) == INLINE_FRAME
)
1222 frame
= get_prev_frame (frame
);
1223 gdb_assert (frame
!= NULL
);
1226 func_addr
= get_frame_func (frame
);
1227 gdbarch
= get_frame_arch (frame
);
1228 caller_frame
= get_prev_frame (frame
);
1229 if (gdbarch
!= frame_unwind_arch (frame
))
1231 struct bound_minimal_symbol msym
1232 = lookup_minimal_symbol_by_pc (func_addr
);
1233 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1235 throw_error (NO_ENTRY_VALUE_ERROR
,
1236 _("DW_OP_entry_value resolving callee gdbarch %s "
1237 "(of %s (%s)) does not match caller gdbarch %s"),
1238 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1239 paddress (gdbarch
, func_addr
),
1240 (msym
.minsym
== NULL
? "???"
1241 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
1242 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1245 if (caller_frame
== NULL
)
1247 struct bound_minimal_symbol msym
1248 = lookup_minimal_symbol_by_pc (func_addr
);
1250 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_entry_value resolving "
1251 "requires caller of %s (%s)"),
1252 paddress (gdbarch
, func_addr
),
1253 (msym
.minsym
== NULL
? "???"
1254 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
1256 caller_pc
= get_frame_pc (caller_frame
);
1257 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1259 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1260 if (target_addr
!= func_addr
)
1262 struct minimal_symbol
*target_msym
, *func_msym
;
1264 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1265 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1266 throw_error (NO_ENTRY_VALUE_ERROR
,
1267 _("DW_OP_entry_value resolving expects callee %s at %s "
1268 "but the called frame is for %s at %s"),
1269 (target_msym
== NULL
? "???"
1270 : MSYMBOL_PRINT_NAME (target_msym
)),
1271 paddress (gdbarch
, target_addr
),
1272 func_msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (func_msym
),
1273 paddress (gdbarch
, func_addr
));
1276 /* No entry value based parameters would be reliable if this function can
1277 call itself via tail calls. */
1278 func_verify_no_selftailcall (gdbarch
, func_addr
);
1280 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1282 parameter
= &call_site
->parameter
[iparams
];
1283 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1286 if (iparams
== call_site
->parameter_count
)
1288 struct minimal_symbol
*msym
1289 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1291 /* DW_TAG_call_site_parameter will be missing just if GCC could not
1292 determine its value. */
1293 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1294 "at DW_TAG_call_site %s at %s"),
1295 paddress (gdbarch
, caller_pc
),
1296 msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (msym
));
1299 *per_cu_return
= call_site
->per_cu
;
1303 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1304 the normal DW_AT_call_value block. Otherwise return the
1305 DW_AT_call_data_value (dereferenced) block.
1307 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1310 Function always returns non-NULL, non-optimized out value. It throws
1311 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1313 static struct value
*
1314 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1315 CORE_ADDR deref_size
, struct type
*type
,
1316 struct frame_info
*caller_frame
,
1317 struct dwarf2_per_cu_data
*per_cu
)
1319 const gdb_byte
*data_src
;
1323 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1324 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1326 /* DEREF_SIZE size is not verified here. */
1327 if (data_src
== NULL
)
1328 throw_error (NO_ENTRY_VALUE_ERROR
,
1329 _("Cannot resolve DW_AT_call_data_value"));
1331 /* DW_AT_call_value is a DWARF expression, not a DWARF
1332 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1334 data
= (gdb_byte
*) alloca (size
+ 1);
1335 memcpy (data
, data_src
, size
);
1336 data
[size
] = DW_OP_stack_value
;
1338 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1341 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1342 the indirect method on it, that is use its stored target value, the sole
1343 purpose of entry_data_value_funcs.. */
1345 static struct value
*
1346 entry_data_value_coerce_ref (const struct value
*value
)
1348 struct type
*checked_type
= check_typedef (value_type (value
));
1349 struct value
*target_val
;
1351 if (!TYPE_IS_REFERENCE (checked_type
))
1354 target_val
= (struct value
*) value_computed_closure (value
);
1355 value_incref (target_val
);
1359 /* Implement copy_closure. */
1362 entry_data_value_copy_closure (const struct value
*v
)
1364 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1366 value_incref (target_val
);
1370 /* Implement free_closure. */
1373 entry_data_value_free_closure (struct value
*v
)
1375 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1377 value_free (target_val
);
1380 /* Vector for methods for an entry value reference where the referenced value
1381 is stored in the caller. On the first dereference use
1382 DW_AT_call_data_value in the caller. */
1384 static const struct lval_funcs entry_data_value_funcs
=
1388 NULL
, /* indirect */
1389 entry_data_value_coerce_ref
,
1390 NULL
, /* check_synthetic_pointer */
1391 entry_data_value_copy_closure
,
1392 entry_data_value_free_closure
1395 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1396 are used to match DW_AT_location at the caller's
1397 DW_TAG_call_site_parameter.
1399 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1400 cannot resolve the parameter for any reason. */
1402 static struct value
*
1403 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1404 enum call_site_parameter_kind kind
,
1405 union call_site_parameter_u kind_u
)
1407 struct type
*checked_type
= check_typedef (type
);
1408 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1409 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1410 struct value
*outer_val
, *target_val
, *val
;
1411 struct call_site_parameter
*parameter
;
1412 struct dwarf2_per_cu_data
*caller_per_cu
;
1414 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1417 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1421 /* Check if DW_AT_call_data_value cannot be used. If it should be
1422 used and it is not available do not fall back to OUTER_VAL - dereferencing
1423 TYPE_CODE_REF with non-entry data value would give current value - not the
1426 if (!TYPE_IS_REFERENCE (checked_type
)
1427 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1430 target_val
= dwarf_entry_parameter_to_value (parameter
,
1431 TYPE_LENGTH (target_type
),
1432 target_type
, caller_frame
,
1435 release_value (target_val
);
1436 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1437 target_val
/* closure */);
1439 /* Copy the referencing pointer to the new computed value. */
1440 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1441 TYPE_LENGTH (checked_type
));
1442 set_value_lazy (val
, 0);
1447 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1448 SIZE are DWARF block used to match DW_AT_location at the caller's
1449 DW_TAG_call_site_parameter.
1451 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1452 cannot resolve the parameter for any reason. */
1454 static struct value
*
1455 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1456 const gdb_byte
*block
, size_t block_len
)
1458 union call_site_parameter_u kind_u
;
1460 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1461 if (kind_u
.dwarf_reg
!= -1)
1462 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1465 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1466 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1469 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1470 suppressed during normal operation. The expression can be arbitrary if
1471 there is no caller-callee entry value binding expected. */
1472 throw_error (NO_ENTRY_VALUE_ERROR
,
1473 _("DWARF-2 expression error: DW_OP_entry_value is supported "
1474 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1477 struct piece_closure
1479 /* Reference count. */
1482 /* The CU from which this closure's expression came. */
1483 struct dwarf2_per_cu_data
*per_cu
;
1485 /* The number of pieces used to describe this variable. */
1488 /* The target address size, used only for DWARF_VALUE_STACK. */
1491 /* The pieces themselves. */
1492 struct dwarf_expr_piece
*pieces
;
1494 /* Frame ID of frame to which a register value is relative, used
1495 only by DWARF_VALUE_REGISTER. */
1496 struct frame_id frame_id
;
1499 /* Allocate a closure for a value formed from separately-described
1502 static struct piece_closure
*
1503 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1504 int n_pieces
, struct dwarf_expr_piece
*pieces
,
1505 int addr_size
, struct frame_info
*frame
)
1507 struct piece_closure
*c
= XCNEW (struct piece_closure
);
1512 c
->n_pieces
= n_pieces
;
1513 c
->addr_size
= addr_size
;
1514 c
->pieces
= XCNEWVEC (struct dwarf_expr_piece
, n_pieces
);
1516 c
->frame_id
= null_frame_id
;
1518 c
->frame_id
= get_frame_id (frame
);
1520 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
1521 for (i
= 0; i
< n_pieces
; ++i
)
1522 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1523 value_incref (c
->pieces
[i
].v
.value
);
1528 /* Copy NBITS bits from SOURCE to DEST starting at the given bit
1529 offsets. Use the bit order as specified by BITS_BIG_ENDIAN.
1530 Source and destination buffers must not overlap. */
1533 copy_bitwise (gdb_byte
*dest
, ULONGEST dest_offset
,
1534 const gdb_byte
*source
, ULONGEST source_offset
,
1535 ULONGEST nbits
, int bits_big_endian
)
1537 unsigned int buf
, avail
;
1542 if (bits_big_endian
)
1544 /* Start from the end, then work backwards. */
1545 dest_offset
+= nbits
- 1;
1546 dest
+= dest_offset
/ 8;
1547 dest_offset
= 7 - dest_offset
% 8;
1548 source_offset
+= nbits
- 1;
1549 source
+= source_offset
/ 8;
1550 source_offset
= 7 - source_offset
% 8;
1554 dest
+= dest_offset
/ 8;
1556 source
+= source_offset
/ 8;
1560 /* Fill BUF with DEST_OFFSET bits from the destination and 8 -
1561 SOURCE_OFFSET bits from the source. */
1562 buf
= *(bits_big_endian
? source
-- : source
++) >> source_offset
;
1563 buf
<<= dest_offset
;
1564 buf
|= *dest
& ((1 << dest_offset
) - 1);
1566 /* NBITS: bits yet to be written; AVAIL: BUF's fill level. */
1567 nbits
+= dest_offset
;
1568 avail
= dest_offset
+ 8 - source_offset
;
1570 /* Flush 8 bits from BUF, if appropriate. */
1571 if (nbits
>= 8 && avail
>= 8)
1573 *(bits_big_endian
? dest
-- : dest
++) = buf
;
1579 /* Copy the middle part. */
1582 size_t len
= nbits
/ 8;
1584 /* Use a faster method for byte-aligned copies. */
1587 if (bits_big_endian
)
1591 memcpy (dest
+ 1, source
+ 1, len
);
1595 memcpy (dest
, source
, len
);
1604 buf
|= *(bits_big_endian
? source
-- : source
++) << avail
;
1605 *(bits_big_endian
? dest
-- : dest
++) = buf
;
1612 /* Write the last byte. */
1616 buf
|= *source
<< avail
;
1618 buf
&= (1 << nbits
) - 1;
1619 *dest
= (*dest
& (~0 << nbits
)) | buf
;
1625 namespace selftests
{
1627 /* Helper function for the unit test of copy_bitwise. Convert NBITS bits
1628 out of BITS, starting at OFFS, to the respective '0'/'1'-string. MSB0
1629 specifies whether to assume big endian bit numbering. Store the
1630 resulting (not null-terminated) string at STR. */
1633 bits_to_str (char *str
, const gdb_byte
*bits
, ULONGEST offs
,
1634 ULONGEST nbits
, int msb0
)
1639 for (i
= offs
/ 8, j
= offs
% 8; nbits
; i
++, j
= 0)
1641 unsigned int ch
= bits
[i
];
1642 for (; j
< 8 && nbits
; j
++, nbits
--)
1643 *str
++ = (ch
& (msb0
? (1 << (7 - j
)) : (1 << j
))) ? '1' : '0';
1647 /* Check one invocation of copy_bitwise with the given parameters. */
1650 check_copy_bitwise (const gdb_byte
*dest
, unsigned int dest_offset
,
1651 const gdb_byte
*source
, unsigned int source_offset
,
1652 unsigned int nbits
, int msb0
)
1654 size_t len
= align_up (dest_offset
+ nbits
, 8);
1655 char *expected
= (char *) alloca (len
+ 1);
1656 char *actual
= (char *) alloca (len
+ 1);
1657 gdb_byte
*buf
= (gdb_byte
*) alloca (len
/ 8);
1659 /* Compose a '0'/'1'-string that represents the expected result of
1661 Bits from [0, DEST_OFFSET) are filled from DEST.
1662 Bits from [DEST_OFFSET, DEST_OFFSET + NBITS) are filled from SOURCE.
1663 Bits from [DEST_OFFSET + NBITS, LEN) are filled from DEST.
1672 We should end up with:
1674 DDDDSSDD (D=dest, S=source)
1676 bits_to_str (expected
, dest
, 0, len
, msb0
);
1677 bits_to_str (expected
+ dest_offset
, source
, source_offset
, nbits
, msb0
);
1679 /* Fill BUF with data from DEST, apply copy_bitwise, and convert the
1680 result to a '0'/'1'-string. */
1681 memcpy (buf
, dest
, len
/ 8);
1682 copy_bitwise (buf
, dest_offset
, source
, source_offset
, nbits
, msb0
);
1683 bits_to_str (actual
, buf
, 0, len
, msb0
);
1685 /* Compare the resulting strings. */
1686 expected
[len
] = actual
[len
] = '\0';
1687 if (strcmp (expected
, actual
) != 0)
1688 error (_("copy_bitwise %s != %s (%u+%u -> %u)"),
1689 expected
, actual
, source_offset
, nbits
, dest_offset
);
1692 /* Unit test for copy_bitwise. */
1695 copy_bitwise_tests (void)
1697 /* Data to be used as both source and destination buffers. The two
1698 arrays below represent the lsb0- and msb0- encoded versions of the
1699 following bit string, respectively:
1700 00000000 00011111 11111111 01001000 10100101 11110010
1701 This pattern is chosen such that it contains:
1702 - constant 0- and 1- chunks of more than a full byte;
1703 - 0/1- and 1/0 transitions on all bit positions within a byte;
1704 - several sufficiently asymmetric bytes.
1706 static const gdb_byte data_lsb0
[] = {
1707 0x00, 0xf8, 0xff, 0x12, 0xa5, 0x4f
1709 static const gdb_byte data_msb0
[] = {
1710 0x00, 0x1f, 0xff, 0x48, 0xa5, 0xf2
1713 constexpr size_t data_nbits
= 8 * sizeof (data_lsb0
);
1714 constexpr unsigned max_nbits
= 24;
1716 /* Try all combinations of:
1717 lsb0/msb0 bit order (using the respective data array)
1718 X [0, MAX_NBITS] copy bit width
1719 X feasible source offsets for the given copy bit width
1720 X feasible destination offsets
1722 for (int msb0
= 0; msb0
< 2; msb0
++)
1724 const gdb_byte
*data
= msb0
? data_msb0
: data_lsb0
;
1726 for (unsigned int nbits
= 1; nbits
<= max_nbits
; nbits
++)
1728 const unsigned int max_offset
= data_nbits
- nbits
;
1730 for (unsigned source_offset
= 0;
1731 source_offset
<= max_offset
;
1734 for (unsigned dest_offset
= 0;
1735 dest_offset
<= max_offset
;
1738 check_copy_bitwise (data
+ dest_offset
/ 8,
1740 data
+ source_offset
/ 8,
1747 /* Special cases: copy all, copy nothing. */
1748 check_copy_bitwise (data_lsb0
, 0, data_msb0
, 0, data_nbits
, msb0
);
1749 check_copy_bitwise (data_msb0
, 0, data_lsb0
, 0, data_nbits
, msb0
);
1750 check_copy_bitwise (data
, data_nbits
- 7, data
, 9, 0, msb0
);
1754 } /* namespace selftests */
1756 #endif /* GDB_SELF_TEST */
1759 read_pieced_value (struct value
*v
)
1763 ULONGEST bits_to_skip
;
1765 struct piece_closure
*c
1766 = (struct piece_closure
*) value_computed_closure (v
);
1768 size_t buffer_size
= 0;
1769 std::vector
<gdb_byte
> buffer
;
1771 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1773 if (value_type (v
) != value_enclosing_type (v
))
1774 internal_error (__FILE__
, __LINE__
,
1775 _("Should not be able to create a lazy value with "
1776 "an enclosing type"));
1778 contents
= value_contents_raw (v
);
1779 bits_to_skip
= 8 * value_offset (v
);
1780 if (value_bitsize (v
))
1782 bits_to_skip
+= value_bitpos (v
);
1783 type_len
= value_bitsize (v
);
1786 type_len
= 8 * TYPE_LENGTH (value_type (v
));
1788 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1790 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1791 size_t this_size
, this_size_bits
;
1792 long dest_offset_bits
, source_offset_bits
, source_offset
;
1793 const gdb_byte
*intermediate_buffer
;
1795 /* Compute size, source, and destination offsets for copying, in
1797 this_size_bits
= p
->size
;
1798 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1800 bits_to_skip
-= this_size_bits
;
1803 if (bits_to_skip
> 0)
1805 dest_offset_bits
= 0;
1806 source_offset_bits
= bits_to_skip
;
1807 this_size_bits
-= bits_to_skip
;
1812 dest_offset_bits
= offset
;
1813 source_offset_bits
= 0;
1815 if (this_size_bits
> type_len
- offset
)
1816 this_size_bits
= type_len
- offset
;
1818 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1819 source_offset
= source_offset_bits
/ 8;
1820 if (buffer_size
< this_size
)
1822 buffer_size
= this_size
;
1823 buffer
.reserve (buffer_size
);
1825 intermediate_buffer
= buffer
.data ();
1827 /* Copy from the source to DEST_BUFFER. */
1828 switch (p
->location
)
1830 case DWARF_VALUE_REGISTER
:
1832 struct frame_info
*frame
= frame_find_by_id (c
->frame_id
);
1833 struct gdbarch
*arch
= get_frame_arch (frame
);
1834 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, p
->v
.regno
);
1836 LONGEST reg_offset
= source_offset
;
1838 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1839 && this_size
< register_size (arch
, gdb_regnum
))
1841 /* Big-endian, and we want less than full size. */
1842 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1843 /* We want the lower-order THIS_SIZE_BITS of the bytes
1844 we extract from the register. */
1845 source_offset_bits
+= 8 * this_size
- this_size_bits
;
1848 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1849 this_size
, buffer
.data (),
1852 /* Just so garbage doesn't ever shine through. */
1853 memset (buffer
.data (), 0, this_size
);
1856 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1858 mark_value_bits_unavailable (v
, offset
, this_size_bits
);
1863 case DWARF_VALUE_MEMORY
:
1864 read_value_memory (v
, offset
,
1865 p
->v
.mem
.in_stack_memory
,
1866 p
->v
.mem
.addr
+ source_offset
,
1867 buffer
.data (), this_size
);
1870 case DWARF_VALUE_STACK
:
1872 size_t n
= this_size
;
1874 if (n
> c
->addr_size
- source_offset
)
1875 n
= (c
->addr_size
>= source_offset
1876 ? c
->addr_size
- source_offset
1884 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
1886 intermediate_buffer
= val_bytes
+ source_offset
;
1891 case DWARF_VALUE_LITERAL
:
1893 size_t n
= this_size
;
1895 if (n
> p
->v
.literal
.length
- source_offset
)
1896 n
= (p
->v
.literal
.length
>= source_offset
1897 ? p
->v
.literal
.length
- source_offset
1900 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
1904 /* These bits show up as zeros -- but do not cause the value
1905 to be considered optimized-out. */
1906 case DWARF_VALUE_IMPLICIT_POINTER
:
1909 case DWARF_VALUE_OPTIMIZED_OUT
:
1910 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1914 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1917 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
1918 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1919 copy_bitwise (contents
, dest_offset_bits
,
1920 intermediate_buffer
, source_offset_bits
% 8,
1921 this_size_bits
, bits_big_endian
);
1923 offset
+= this_size_bits
;
1928 write_pieced_value (struct value
*to
, struct value
*from
)
1932 ULONGEST bits_to_skip
;
1933 const gdb_byte
*contents
;
1934 struct piece_closure
*c
1935 = (struct piece_closure
*) value_computed_closure (to
);
1937 size_t buffer_size
= 0;
1938 std::vector
<gdb_byte
> buffer
;
1940 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
1942 contents
= value_contents (from
);
1943 bits_to_skip
= 8 * value_offset (to
);
1944 if (value_bitsize (to
))
1946 bits_to_skip
+= value_bitpos (to
);
1947 type_len
= value_bitsize (to
);
1950 type_len
= 8 * TYPE_LENGTH (value_type (to
));
1952 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1954 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1955 size_t this_size_bits
, this_size
;
1956 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
1958 const gdb_byte
*source_buffer
;
1960 this_size_bits
= p
->size
;
1961 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1963 bits_to_skip
-= this_size_bits
;
1966 if (this_size_bits
> type_len
- offset
)
1967 this_size_bits
= type_len
- offset
;
1968 if (bits_to_skip
> 0)
1970 dest_offset_bits
= bits_to_skip
;
1971 source_offset_bits
= 0;
1972 this_size_bits
-= bits_to_skip
;
1977 dest_offset_bits
= 0;
1978 source_offset_bits
= offset
;
1981 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1982 source_offset
= source_offset_bits
/ 8;
1983 dest_offset
= dest_offset_bits
/ 8;
1984 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
1986 source_buffer
= contents
+ source_offset
;
1991 if (buffer_size
< this_size
)
1993 buffer_size
= this_size
;
1994 buffer
.reserve (buffer_size
);
1996 source_buffer
= buffer
.data ();
2000 switch (p
->location
)
2002 case DWARF_VALUE_REGISTER
:
2004 struct frame_info
*frame
= frame_find_by_id (c
->frame_id
);
2005 struct gdbarch
*arch
= get_frame_arch (frame
);
2006 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, p
->v
.regno
);
2007 int reg_offset
= dest_offset
;
2009 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
2010 && this_size
<= register_size (arch
, gdb_regnum
))
2012 /* Big-endian, and we want less than full size. */
2013 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
2020 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
2021 this_size
, buffer
.data (),
2025 throw_error (OPTIMIZED_OUT_ERROR
,
2026 _("Can't do read-modify-write to "
2027 "update bitfield; containing word "
2028 "has been optimized out"));
2030 throw_error (NOT_AVAILABLE_ERROR
,
2031 _("Can't do read-modify-write to update "
2032 "bitfield; containing word "
2035 copy_bitwise (buffer
.data (), dest_offset_bits
,
2036 contents
, source_offset_bits
,
2041 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
2042 this_size
, source_buffer
);
2045 case DWARF_VALUE_MEMORY
:
2048 /* Only the first and last bytes can possibly have any
2050 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
.data (), 1);
2051 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
2052 &buffer
[this_size
- 1], 1);
2053 copy_bitwise (buffer
.data (), dest_offset_bits
,
2054 contents
, source_offset_bits
,
2059 write_memory (p
->v
.mem
.addr
+ dest_offset
,
2060 source_buffer
, this_size
);
2063 mark_value_bytes_optimized_out (to
, 0, TYPE_LENGTH (value_type (to
)));
2066 offset
+= this_size_bits
;
2070 /* An implementation of an lval_funcs method to see whether a value is
2071 a synthetic pointer. */
2074 check_pieced_synthetic_pointer (const struct value
*value
, LONGEST bit_offset
,
2077 struct piece_closure
*c
2078 = (struct piece_closure
*) value_computed_closure (value
);
2081 bit_offset
+= 8 * value_offset (value
);
2082 if (value_bitsize (value
))
2083 bit_offset
+= value_bitpos (value
);
2085 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2087 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2088 size_t this_size_bits
= p
->size
;
2092 if (bit_offset
>= this_size_bits
)
2094 bit_offset
-= this_size_bits
;
2098 bit_length
-= this_size_bits
- bit_offset
;
2102 bit_length
-= this_size_bits
;
2104 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2111 /* A wrapper function for get_frame_address_in_block. */
2114 get_frame_address_in_block_wrapper (void *baton
)
2116 return get_frame_address_in_block ((struct frame_info
*) baton
);
2119 /* Fetch a DW_AT_const_value through a synthetic pointer. */
2121 static struct value
*
2122 fetch_const_value_from_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
2123 struct dwarf2_per_cu_data
*per_cu
,
2126 struct value
*result
= NULL
;
2127 struct obstack temp_obstack
;
2128 struct cleanup
*cleanup
;
2129 const gdb_byte
*bytes
;
2132 obstack_init (&temp_obstack
);
2133 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2134 bytes
= dwarf2_fetch_constant_bytes (die
, per_cu
, &temp_obstack
, &len
);
2138 if (byte_offset
>= 0
2139 && byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) <= len
)
2141 bytes
+= byte_offset
;
2142 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
2145 invalid_synthetic_pointer ();
2148 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
2150 do_cleanups (cleanup
);
2155 /* Fetch the value pointed to by a synthetic pointer. */
2157 static struct value
*
2158 indirect_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
2159 struct dwarf2_per_cu_data
*per_cu
,
2160 struct frame_info
*frame
, struct type
*type
)
2162 /* Fetch the location expression of the DIE we're pointing to. */
2163 struct dwarf2_locexpr_baton baton
2164 = dwarf2_fetch_die_loc_sect_off (die
, per_cu
,
2165 get_frame_address_in_block_wrapper
, frame
);
2167 /* Get type of pointed-to DIE. */
2168 struct type
*orig_type
= dwarf2_fetch_die_type_sect_off (die
, per_cu
);
2169 if (orig_type
== NULL
)
2170 invalid_synthetic_pointer ();
2172 /* If pointed-to DIE has a DW_AT_location, evaluate it and return the
2173 resulting value. Otherwise, it may have a DW_AT_const_value instead,
2174 or it may've been optimized out. */
2175 if (baton
.data
!= NULL
)
2176 return dwarf2_evaluate_loc_desc_full (orig_type
, frame
, baton
.data
,
2177 baton
.size
, baton
.per_cu
,
2178 TYPE_TARGET_TYPE (type
),
2181 return fetch_const_value_from_synthetic_pointer (die
, byte_offset
, per_cu
,
2185 /* An implementation of an lval_funcs method to indirect through a
2186 pointer. This handles the synthetic pointer case when needed. */
2188 static struct value
*
2189 indirect_pieced_value (struct value
*value
)
2191 struct piece_closure
*c
2192 = (struct piece_closure
*) value_computed_closure (value
);
2194 struct frame_info
*frame
;
2195 struct dwarf2_locexpr_baton baton
;
2198 struct dwarf_expr_piece
*piece
= NULL
;
2199 LONGEST byte_offset
;
2200 enum bfd_endian byte_order
;
2202 type
= check_typedef (value_type (value
));
2203 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
2206 bit_length
= 8 * TYPE_LENGTH (type
);
2207 bit_offset
= 8 * value_offset (value
);
2208 if (value_bitsize (value
))
2209 bit_offset
+= value_bitpos (value
);
2211 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2213 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2214 size_t this_size_bits
= p
->size
;
2218 if (bit_offset
>= this_size_bits
)
2220 bit_offset
-= this_size_bits
;
2224 bit_length
-= this_size_bits
- bit_offset
;
2228 bit_length
-= this_size_bits
;
2230 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2233 if (bit_length
!= 0)
2234 error (_("Invalid use of DW_OP_implicit_pointer"));
2240 gdb_assert (piece
!= NULL
);
2241 frame
= get_selected_frame (_("No frame selected."));
2243 /* This is an offset requested by GDB, such as value subscripts.
2244 However, due to how synthetic pointers are implemented, this is
2245 always presented to us as a pointer type. This means we have to
2246 sign-extend it manually as appropriate. Use raw
2247 extract_signed_integer directly rather than value_as_address and
2248 sign extend afterwards on architectures that would need it
2249 (mostly everywhere except MIPS, which has signed addresses) as
2250 the later would go through gdbarch_pointer_to_address and thus
2251 return a CORE_ADDR with high bits set on architectures that
2252 encode address spaces and other things in CORE_ADDR. */
2253 byte_order
= gdbarch_byte_order (get_frame_arch (frame
));
2254 byte_offset
= extract_signed_integer (value_contents (value
),
2255 TYPE_LENGTH (type
), byte_order
);
2256 byte_offset
+= piece
->v
.ptr
.offset
;
2258 return indirect_synthetic_pointer (piece
->v
.ptr
.die
, byte_offset
, c
->per_cu
,
2262 /* Implementation of the coerce_ref method of lval_funcs for synthetic C++
2265 static struct value
*
2266 coerce_pieced_ref (const struct value
*value
)
2268 struct type
*type
= check_typedef (value_type (value
));
2270 if (value_bits_synthetic_pointer (value
, value_embedded_offset (value
),
2271 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
2273 const struct piece_closure
*closure
2274 = (struct piece_closure
*) value_computed_closure (value
);
2275 struct frame_info
*frame
2276 = get_selected_frame (_("No frame selected."));
2278 /* gdb represents synthetic pointers as pieced values with a single
2280 gdb_assert (closure
!= NULL
);
2281 gdb_assert (closure
->n_pieces
== 1);
2283 return indirect_synthetic_pointer (closure
->pieces
->v
.ptr
.die
,
2284 closure
->pieces
->v
.ptr
.offset
,
2285 closure
->per_cu
, frame
, type
);
2289 /* Else: not a synthetic reference; do nothing. */
2295 copy_pieced_value_closure (const struct value
*v
)
2297 struct piece_closure
*c
2298 = (struct piece_closure
*) value_computed_closure (v
);
2305 free_pieced_value_closure (struct value
*v
)
2307 struct piece_closure
*c
2308 = (struct piece_closure
*) value_computed_closure (v
);
2315 for (i
= 0; i
< c
->n_pieces
; ++i
)
2316 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
2317 value_free (c
->pieces
[i
].v
.value
);
2324 /* Functions for accessing a variable described by DW_OP_piece. */
2325 static const struct lval_funcs pieced_value_funcs
= {
2328 indirect_pieced_value
,
2330 check_pieced_synthetic_pointer
,
2331 copy_pieced_value_closure
,
2332 free_pieced_value_closure
2335 /* Evaluate a location description, starting at DATA and with length
2336 SIZE, to find the current location of variable of TYPE in the
2337 context of FRAME. If SUBOBJ_TYPE is non-NULL, return instead the
2338 location of the subobject of type SUBOBJ_TYPE at byte offset
2339 SUBOBJ_BYTE_OFFSET within the variable of type TYPE. */
2341 static struct value
*
2342 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2343 const gdb_byte
*data
, size_t size
,
2344 struct dwarf2_per_cu_data
*per_cu
,
2345 struct type
*subobj_type
,
2346 LONGEST subobj_byte_offset
)
2348 struct value
*retval
;
2349 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2351 if (subobj_type
== NULL
)
2354 subobj_byte_offset
= 0;
2356 else if (subobj_byte_offset
< 0)
2357 invalid_synthetic_pointer ();
2360 return allocate_optimized_out_value (subobj_type
);
2362 dwarf_evaluate_loc_desc ctx
;
2364 ctx
.per_cu
= per_cu
;
2365 ctx
.obj_address
= 0;
2367 scoped_value_mark free_values
;
2369 ctx
.gdbarch
= get_objfile_arch (objfile
);
2370 ctx
.addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2371 ctx
.ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2372 ctx
.offset
= dwarf2_per_cu_text_offset (per_cu
);
2376 ctx
.eval (data
, size
);
2378 CATCH (ex
, RETURN_MASK_ERROR
)
2380 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2382 free_values
.free_to_mark ();
2383 retval
= allocate_value (subobj_type
);
2384 mark_value_bytes_unavailable (retval
, 0,
2385 TYPE_LENGTH (subobj_type
));
2388 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2390 if (entry_values_debug
)
2391 exception_print (gdb_stdout
, ex
);
2392 free_values
.free_to_mark ();
2393 return allocate_optimized_out_value (subobj_type
);
2396 throw_exception (ex
);
2400 if (ctx
.num_pieces
> 0)
2402 struct piece_closure
*c
;
2403 ULONGEST bit_size
= 0;
2406 for (i
= 0; i
< ctx
.num_pieces
; ++i
)
2407 bit_size
+= ctx
.pieces
[i
].size
;
2408 if (8 * (subobj_byte_offset
+ TYPE_LENGTH (subobj_type
)) > bit_size
)
2409 invalid_synthetic_pointer ();
2411 c
= allocate_piece_closure (per_cu
, ctx
.num_pieces
, ctx
.pieces
,
2412 ctx
.addr_size
, frame
);
2413 /* We must clean up the value chain after creating the piece
2414 closure but before allocating the result. */
2415 free_values
.free_to_mark ();
2416 retval
= allocate_computed_value (subobj_type
,
2417 &pieced_value_funcs
, c
);
2418 set_value_offset (retval
, subobj_byte_offset
);
2422 switch (ctx
.location
)
2424 case DWARF_VALUE_REGISTER
:
2426 struct gdbarch
*arch
= get_frame_arch (frame
);
2428 = longest_to_int (value_as_long (ctx
.fetch (0)));
2429 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, dwarf_regnum
);
2431 if (subobj_byte_offset
!= 0)
2432 error (_("cannot use offset on synthetic pointer to register"));
2433 free_values
.free_to_mark ();
2434 retval
= value_from_register (subobj_type
, gdb_regnum
, frame
);
2435 if (value_optimized_out (retval
))
2439 /* This means the register has undefined value / was
2440 not saved. As we're computing the location of some
2441 variable etc. in the program, not a value for
2442 inspecting a register ($pc, $sp, etc.), return a
2443 generic optimized out value instead, so that we show
2444 <optimized out> instead of <not saved>. */
2445 tmp
= allocate_value (subobj_type
);
2446 value_contents_copy (tmp
, 0, retval
, 0,
2447 TYPE_LENGTH (subobj_type
));
2453 case DWARF_VALUE_MEMORY
:
2455 struct type
*ptr_type
;
2456 CORE_ADDR address
= ctx
.fetch_address (0);
2457 int in_stack_memory
= ctx
.fetch_in_stack_memory (0);
2459 /* DW_OP_deref_size (and possibly other operations too) may
2460 create a pointer instead of an address. Ideally, the
2461 pointer to address conversion would be performed as part
2462 of those operations, but the type of the object to
2463 which the address refers is not known at the time of
2464 the operation. Therefore, we do the conversion here
2465 since the type is readily available. */
2467 switch (TYPE_CODE (subobj_type
))
2469 case TYPE_CODE_FUNC
:
2470 case TYPE_CODE_METHOD
:
2471 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_func_ptr
;
2474 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_data_ptr
;
2477 address
= value_as_address (value_from_pointer (ptr_type
, address
));
2479 free_values
.free_to_mark ();
2480 retval
= value_at_lazy (subobj_type
,
2481 address
+ subobj_byte_offset
);
2482 if (in_stack_memory
)
2483 set_value_stack (retval
, 1);
2487 case DWARF_VALUE_STACK
:
2489 struct value
*value
= ctx
.fetch (0);
2490 size_t n
= TYPE_LENGTH (value_type (value
));
2491 size_t len
= TYPE_LENGTH (subobj_type
);
2492 size_t max
= TYPE_LENGTH (type
);
2493 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2494 struct cleanup
*cleanup
;
2496 if (subobj_byte_offset
+ len
> max
)
2497 invalid_synthetic_pointer ();
2499 /* Preserve VALUE because we are going to free values back
2500 to the mark, but we still need the value contents
2502 value_incref (value
);
2503 free_values
.free_to_mark ();
2504 cleanup
= make_cleanup_value_free (value
);
2506 retval
= allocate_value (subobj_type
);
2508 /* The given offset is relative to the actual object. */
2509 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2510 subobj_byte_offset
+= n
- max
;
2512 memcpy (value_contents_raw (retval
),
2513 value_contents_all (value
) + subobj_byte_offset
, len
);
2515 do_cleanups (cleanup
);
2519 case DWARF_VALUE_LITERAL
:
2522 size_t n
= TYPE_LENGTH (subobj_type
);
2524 if (subobj_byte_offset
+ n
> ctx
.len
)
2525 invalid_synthetic_pointer ();
2527 free_values
.free_to_mark ();
2528 retval
= allocate_value (subobj_type
);
2529 contents
= value_contents_raw (retval
);
2530 memcpy (contents
, ctx
.data
+ subobj_byte_offset
, n
);
2534 case DWARF_VALUE_OPTIMIZED_OUT
:
2535 free_values
.free_to_mark ();
2536 retval
= allocate_optimized_out_value (subobj_type
);
2539 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2540 operation by execute_stack_op. */
2541 case DWARF_VALUE_IMPLICIT_POINTER
:
2542 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2543 it can only be encountered when making a piece. */
2545 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2549 set_value_initialized (retval
, ctx
.initialized
);
2554 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2555 passes 0 as the byte_offset. */
2558 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2559 const gdb_byte
*data
, size_t size
,
2560 struct dwarf2_per_cu_data
*per_cu
)
2562 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
,
2566 /* Evaluates a dwarf expression and stores the result in VAL, expecting
2567 that the dwarf expression only produces a single CORE_ADDR. FRAME is the
2568 frame in which the expression is evaluated. ADDR is a context (location of
2569 a variable) and might be needed to evaluate the location expression.
2570 Returns 1 on success, 0 otherwise. */
2573 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton
*dlbaton
,
2574 struct frame_info
*frame
,
2578 struct objfile
*objfile
;
2580 if (dlbaton
== NULL
|| dlbaton
->size
== 0)
2583 dwarf_evaluate_loc_desc ctx
;
2586 ctx
.per_cu
= dlbaton
->per_cu
;
2587 ctx
.obj_address
= addr
;
2589 objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2591 ctx
.gdbarch
= get_objfile_arch (objfile
);
2592 ctx
.addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2593 ctx
.ref_addr_size
= dwarf2_per_cu_ref_addr_size (dlbaton
->per_cu
);
2594 ctx
.offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
2596 ctx
.eval (dlbaton
->data
, dlbaton
->size
);
2598 switch (ctx
.location
)
2600 case DWARF_VALUE_REGISTER
:
2601 case DWARF_VALUE_MEMORY
:
2602 case DWARF_VALUE_STACK
:
2603 *valp
= ctx
.fetch_address (0);
2604 if (ctx
.location
== DWARF_VALUE_REGISTER
)
2605 *valp
= ctx
.read_addr_from_reg (*valp
);
2607 case DWARF_VALUE_LITERAL
:
2608 *valp
= extract_signed_integer (ctx
.data
, ctx
.len
,
2609 gdbarch_byte_order (ctx
.gdbarch
));
2611 /* Unsupported dwarf values. */
2612 case DWARF_VALUE_OPTIMIZED_OUT
:
2613 case DWARF_VALUE_IMPLICIT_POINTER
:
2620 /* See dwarf2loc.h. */
2623 dwarf2_evaluate_property (const struct dynamic_prop
*prop
,
2624 struct frame_info
*frame
,
2625 struct property_addr_info
*addr_stack
,
2631 if (frame
== NULL
&& has_stack_frames ())
2632 frame
= get_selected_frame (NULL
);
2638 const struct dwarf2_property_baton
*baton
2639 = (const struct dwarf2_property_baton
*) prop
->data
.baton
;
2641 if (dwarf2_locexpr_baton_eval (&baton
->locexpr
, frame
,
2642 addr_stack
? addr_stack
->addr
: 0,
2645 if (baton
->referenced_type
)
2647 struct value
*val
= value_at (baton
->referenced_type
, *value
);
2649 *value
= value_as_address (val
);
2658 struct dwarf2_property_baton
*baton
2659 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2660 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2661 const gdb_byte
*data
;
2665 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2668 val
= dwarf2_evaluate_loc_desc (baton
->referenced_type
, frame
, data
,
2669 size
, baton
->loclist
.per_cu
);
2670 if (!value_optimized_out (val
))
2672 *value
= value_as_address (val
);
2680 *value
= prop
->data
.const_val
;
2683 case PROP_ADDR_OFFSET
:
2685 struct dwarf2_property_baton
*baton
2686 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2687 struct property_addr_info
*pinfo
;
2690 for (pinfo
= addr_stack
; pinfo
!= NULL
; pinfo
= pinfo
->next
)
2691 if (pinfo
->type
== baton
->referenced_type
)
2694 error (_("cannot find reference address for offset property"));
2695 if (pinfo
->valaddr
!= NULL
)
2696 val
= value_from_contents
2697 (baton
->offset_info
.type
,
2698 pinfo
->valaddr
+ baton
->offset_info
.offset
);
2700 val
= value_at (baton
->offset_info
.type
,
2701 pinfo
->addr
+ baton
->offset_info
.offset
);
2702 *value
= value_as_address (val
);
2710 /* See dwarf2loc.h. */
2713 dwarf2_compile_property_to_c (string_file
&stream
,
2714 const char *result_name
,
2715 struct gdbarch
*gdbarch
,
2716 unsigned char *registers_used
,
2717 const struct dynamic_prop
*prop
,
2721 struct dwarf2_property_baton
*baton
2722 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2723 const gdb_byte
*data
;
2725 struct dwarf2_per_cu_data
*per_cu
;
2727 if (prop
->kind
== PROP_LOCEXPR
)
2729 data
= baton
->locexpr
.data
;
2730 size
= baton
->locexpr
.size
;
2731 per_cu
= baton
->locexpr
.per_cu
;
2735 gdb_assert (prop
->kind
== PROP_LOCLIST
);
2737 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2738 per_cu
= baton
->loclist
.per_cu
;
2741 compile_dwarf_bounds_to_c (stream
, result_name
, prop
, sym
, pc
,
2742 gdbarch
, registers_used
,
2743 dwarf2_per_cu_addr_size (per_cu
),
2744 data
, data
+ size
, per_cu
);
2748 /* Helper functions and baton for dwarf2_loc_desc_get_symbol_read_needs. */
2750 class symbol_needs_eval_context
: public dwarf_expr_context
2754 enum symbol_needs_kind needs
;
2755 struct dwarf2_per_cu_data
*per_cu
;
2757 /* Reads from registers do require a frame. */
2758 CORE_ADDR
read_addr_from_reg (int regnum
) OVERRIDE
2760 needs
= SYMBOL_NEEDS_FRAME
;
2764 /* "get_reg_value" callback: Reads from registers do require a
2767 struct value
*get_reg_value (struct type
*type
, int regnum
) OVERRIDE
2769 needs
= SYMBOL_NEEDS_FRAME
;
2770 return value_zero (type
, not_lval
);
2773 /* Reads from memory do not require a frame. */
2774 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) OVERRIDE
2776 memset (buf
, 0, len
);
2779 /* Frame-relative accesses do require a frame. */
2780 void get_frame_base (const gdb_byte
**start
, size_t *length
) OVERRIDE
2782 static gdb_byte lit0
= DW_OP_lit0
;
2787 needs
= SYMBOL_NEEDS_FRAME
;
2790 /* CFA accesses require a frame. */
2791 CORE_ADDR
get_frame_cfa () OVERRIDE
2793 needs
= SYMBOL_NEEDS_FRAME
;
2797 CORE_ADDR
get_frame_pc () OVERRIDE
2799 needs
= SYMBOL_NEEDS_FRAME
;
2803 /* Thread-local accesses require registers, but not a frame. */
2804 CORE_ADDR
get_tls_address (CORE_ADDR offset
) OVERRIDE
2806 if (needs
<= SYMBOL_NEEDS_REGISTERS
)
2807 needs
= SYMBOL_NEEDS_REGISTERS
;
2811 /* Helper interface of per_cu_dwarf_call for
2812 dwarf2_loc_desc_get_symbol_read_needs. */
2814 void dwarf_call (cu_offset die_offset
) OVERRIDE
2816 per_cu_dwarf_call (this, die_offset
, per_cu
);
2819 /* DW_OP_entry_value accesses require a caller, therefore a
2822 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
2823 union call_site_parameter_u kind_u
,
2824 int deref_size
) OVERRIDE
2826 needs
= SYMBOL_NEEDS_FRAME
;
2828 /* The expression may require some stub values on DWARF stack. */
2829 push_address (0, 0);
2832 /* DW_OP_GNU_addr_index doesn't require a frame. */
2834 CORE_ADDR
get_addr_index (unsigned int index
) OVERRIDE
2836 /* Nothing to do. */
2840 /* DW_OP_push_object_address has a frame already passed through. */
2842 CORE_ADDR
get_object_address () OVERRIDE
2844 /* Nothing to do. */
2849 /* Compute the correct symbol_needs_kind value for the location
2850 expression at DATA (length SIZE). */
2852 static enum symbol_needs_kind
2853 dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte
*data
, size_t size
,
2854 struct dwarf2_per_cu_data
*per_cu
)
2857 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2859 scoped_value_mark free_values
;
2861 symbol_needs_eval_context ctx
;
2863 ctx
.needs
= SYMBOL_NEEDS_NONE
;
2864 ctx
.per_cu
= per_cu
;
2865 ctx
.gdbarch
= get_objfile_arch (objfile
);
2866 ctx
.addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2867 ctx
.ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2868 ctx
.offset
= dwarf2_per_cu_text_offset (per_cu
);
2870 ctx
.eval (data
, size
);
2872 in_reg
= ctx
.location
== DWARF_VALUE_REGISTER
;
2874 if (ctx
.num_pieces
> 0)
2878 /* If the location has several pieces, and any of them are in
2879 registers, then we will need a frame to fetch them from. */
2880 for (i
= 0; i
< ctx
.num_pieces
; i
++)
2881 if (ctx
.pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2886 ctx
.needs
= SYMBOL_NEEDS_FRAME
;
2890 /* A helper function that throws an unimplemented error mentioning a
2891 given DWARF operator. */
2894 unimplemented (unsigned int op
)
2896 const char *name
= get_DW_OP_name (op
);
2899 error (_("DWARF operator %s cannot be translated to an agent expression"),
2902 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2903 "to an agent expression"),
2909 This is basically a wrapper on gdbarch_dwarf2_reg_to_regnum so that we
2910 can issue a complaint, which is better than having every target's
2911 implementation of dwarf2_reg_to_regnum do it. */
2914 dwarf_reg_to_regnum (struct gdbarch
*arch
, int dwarf_reg
)
2916 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2920 complaint (&symfile_complaints
,
2921 _("bad DWARF register number %d"), dwarf_reg
);
2926 /* Subroutine of dwarf_reg_to_regnum_or_error to simplify it.
2927 Throw an error because DWARF_REG is bad. */
2930 throw_bad_regnum_error (ULONGEST dwarf_reg
)
2932 /* Still want to print -1 as "-1".
2933 We *could* have int and ULONGEST versions of dwarf2_reg_to_regnum_or_error
2934 but that's overkill for now. */
2935 if ((int) dwarf_reg
== dwarf_reg
)
2936 error (_("Unable to access DWARF register number %d"), (int) dwarf_reg
);
2937 error (_("Unable to access DWARF register number %s"),
2938 pulongest (dwarf_reg
));
2941 /* See dwarf2loc.h. */
2944 dwarf_reg_to_regnum_or_error (struct gdbarch
*arch
, ULONGEST dwarf_reg
)
2948 if (dwarf_reg
> INT_MAX
)
2949 throw_bad_regnum_error (dwarf_reg
);
2950 /* Yes, we will end up issuing a complaint and an error if DWARF_REG is
2951 bad, but that's ok. */
2952 reg
= dwarf_reg_to_regnum (arch
, (int) dwarf_reg
);
2954 throw_bad_regnum_error (dwarf_reg
);
2958 /* A helper function that emits an access to memory. ARCH is the
2959 target architecture. EXPR is the expression which we are building.
2960 NBITS is the number of bits we want to read. This emits the
2961 opcodes needed to read the memory and then extract the desired
2965 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2967 ULONGEST nbytes
= (nbits
+ 7) / 8;
2969 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2972 ax_trace_quick (expr
, nbytes
);
2975 ax_simple (expr
, aop_ref8
);
2976 else if (nbits
<= 16)
2977 ax_simple (expr
, aop_ref16
);
2978 else if (nbits
<= 32)
2979 ax_simple (expr
, aop_ref32
);
2981 ax_simple (expr
, aop_ref64
);
2983 /* If we read exactly the number of bytes we wanted, we're done. */
2984 if (8 * nbytes
== nbits
)
2987 if (gdbarch_bits_big_endian (arch
))
2989 /* On a bits-big-endian machine, we want the high-order
2991 ax_const_l (expr
, 8 * nbytes
- nbits
);
2992 ax_simple (expr
, aop_rsh_unsigned
);
2996 /* On a bits-little-endian box, we want the low-order NBITS. */
2997 ax_zero_ext (expr
, nbits
);
3001 /* A helper function to return the frame's PC. */
3004 get_ax_pc (void *baton
)
3006 struct agent_expr
*expr
= (struct agent_expr
*) baton
;
3011 /* Compile a DWARF location expression to an agent expression.
3013 EXPR is the agent expression we are building.
3014 LOC is the agent value we modify.
3015 ARCH is the architecture.
3016 ADDR_SIZE is the size of addresses, in bytes.
3017 OP_PTR is the start of the location expression.
3018 OP_END is one past the last byte of the location expression.
3020 This will throw an exception for various kinds of errors -- for
3021 example, if the expression cannot be compiled, or if the expression
3025 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
3026 struct gdbarch
*arch
, unsigned int addr_size
,
3027 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
3028 struct dwarf2_per_cu_data
*per_cu
)
3031 std::vector
<int> dw_labels
, patches
;
3032 const gdb_byte
* const base
= op_ptr
;
3033 const gdb_byte
*previous_piece
= op_ptr
;
3034 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
3035 ULONGEST bits_collected
= 0;
3036 unsigned int addr_size_bits
= 8 * addr_size
;
3037 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
3039 std::vector
<int> offsets (op_end
- op_ptr
, -1);
3041 /* By default we are making an address. */
3042 loc
->kind
= axs_lvalue_memory
;
3044 while (op_ptr
< op_end
)
3046 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
3047 uint64_t uoffset
, reg
;
3051 offsets
[op_ptr
- base
] = expr
->len
;
3054 /* Our basic approach to code generation is to map DWARF
3055 operations directly to AX operations. However, there are
3058 First, DWARF works on address-sized units, but AX always uses
3059 LONGEST. For most operations we simply ignore this
3060 difference; instead we generate sign extensions as needed
3061 before division and comparison operations. It would be nice
3062 to omit the sign extensions, but there is no way to determine
3063 the size of the target's LONGEST. (This code uses the size
3064 of the host LONGEST in some cases -- that is a bug but it is
3067 Second, some DWARF operations cannot be translated to AX.
3068 For these we simply fail. See
3069 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
3104 ax_const_l (expr
, op
- DW_OP_lit0
);
3108 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
3109 op_ptr
+= addr_size
;
3110 /* Some versions of GCC emit DW_OP_addr before
3111 DW_OP_GNU_push_tls_address. In this case the value is an
3112 index, not an address. We don't support things like
3113 branching between the address and the TLS op. */
3114 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
3115 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
3116 ax_const_l (expr
, uoffset
);
3120 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
3124 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
3128 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
3132 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
3136 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
3140 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
3144 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
3148 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
3152 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3153 ax_const_l (expr
, uoffset
);
3156 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3157 ax_const_l (expr
, offset
);
3192 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3193 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_reg0
);
3194 loc
->kind
= axs_lvalue_register
;
3198 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3199 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3200 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3201 loc
->kind
= axs_lvalue_register
;
3204 case DW_OP_implicit_value
:
3208 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
3209 if (op_ptr
+ len
> op_end
)
3210 error (_("DW_OP_implicit_value: too few bytes available."));
3211 if (len
> sizeof (ULONGEST
))
3212 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
3215 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
3218 dwarf_expr_require_composition (op_ptr
, op_end
,
3219 "DW_OP_implicit_value");
3221 loc
->kind
= axs_rvalue
;
3225 case DW_OP_stack_value
:
3226 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
3227 loc
->kind
= axs_rvalue
;
3262 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3263 i
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_breg0
);
3267 ax_const_l (expr
, offset
);
3268 ax_simple (expr
, aop_add
);
3273 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3274 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3275 i
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3279 ax_const_l (expr
, offset
);
3280 ax_simple (expr
, aop_add
);
3286 const gdb_byte
*datastart
;
3288 const struct block
*b
;
3289 struct symbol
*framefunc
;
3291 b
= block_for_pc (expr
->scope
);
3294 error (_("No block found for address"));
3296 framefunc
= block_linkage_function (b
);
3299 error (_("No function found for block"));
3301 func_get_frame_base_dwarf_block (framefunc
, expr
->scope
,
3302 &datastart
, &datalen
);
3304 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3305 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
3306 datastart
+ datalen
, per_cu
);
3307 if (loc
->kind
== axs_lvalue_register
)
3308 require_rvalue (expr
, loc
);
3312 ax_const_l (expr
, offset
);
3313 ax_simple (expr
, aop_add
);
3316 loc
->kind
= axs_lvalue_memory
;
3321 ax_simple (expr
, aop_dup
);
3325 ax_simple (expr
, aop_pop
);
3330 ax_pick (expr
, offset
);
3334 ax_simple (expr
, aop_swap
);
3342 ax_simple (expr
, aop_rot
);
3346 case DW_OP_deref_size
:
3350 if (op
== DW_OP_deref_size
)
3355 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3356 error (_("Unsupported size %d in %s"),
3357 size
, get_DW_OP_name (op
));
3358 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3363 /* Sign extend the operand. */
3364 ax_ext (expr
, addr_size_bits
);
3365 ax_simple (expr
, aop_dup
);
3366 ax_const_l (expr
, 0);
3367 ax_simple (expr
, aop_less_signed
);
3368 ax_simple (expr
, aop_log_not
);
3369 i
= ax_goto (expr
, aop_if_goto
);
3370 /* We have to emit 0 - X. */
3371 ax_const_l (expr
, 0);
3372 ax_simple (expr
, aop_swap
);
3373 ax_simple (expr
, aop_sub
);
3374 ax_label (expr
, i
, expr
->len
);
3378 /* No need to sign extend here. */
3379 ax_const_l (expr
, 0);
3380 ax_simple (expr
, aop_swap
);
3381 ax_simple (expr
, aop_sub
);
3385 /* Sign extend the operand. */
3386 ax_ext (expr
, addr_size_bits
);
3387 ax_simple (expr
, aop_bit_not
);
3390 case DW_OP_plus_uconst
:
3391 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3392 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3393 but we micro-optimize anyhow. */
3396 ax_const_l (expr
, reg
);
3397 ax_simple (expr
, aop_add
);
3402 ax_simple (expr
, aop_bit_and
);
3406 /* Sign extend the operands. */
3407 ax_ext (expr
, addr_size_bits
);
3408 ax_simple (expr
, aop_swap
);
3409 ax_ext (expr
, addr_size_bits
);
3410 ax_simple (expr
, aop_swap
);
3411 ax_simple (expr
, aop_div_signed
);
3415 ax_simple (expr
, aop_sub
);
3419 ax_simple (expr
, aop_rem_unsigned
);
3423 ax_simple (expr
, aop_mul
);
3427 ax_simple (expr
, aop_bit_or
);
3431 ax_simple (expr
, aop_add
);
3435 ax_simple (expr
, aop_lsh
);
3439 ax_simple (expr
, aop_rsh_unsigned
);
3443 ax_simple (expr
, aop_rsh_signed
);
3447 ax_simple (expr
, aop_bit_xor
);
3451 /* Sign extend the operands. */
3452 ax_ext (expr
, addr_size_bits
);
3453 ax_simple (expr
, aop_swap
);
3454 ax_ext (expr
, addr_size_bits
);
3455 /* Note no swap here: A <= B is !(B < A). */
3456 ax_simple (expr
, aop_less_signed
);
3457 ax_simple (expr
, aop_log_not
);
3461 /* Sign extend the operands. */
3462 ax_ext (expr
, addr_size_bits
);
3463 ax_simple (expr
, aop_swap
);
3464 ax_ext (expr
, addr_size_bits
);
3465 ax_simple (expr
, aop_swap
);
3466 /* A >= B is !(A < B). */
3467 ax_simple (expr
, aop_less_signed
);
3468 ax_simple (expr
, aop_log_not
);
3472 /* Sign extend the operands. */
3473 ax_ext (expr
, addr_size_bits
);
3474 ax_simple (expr
, aop_swap
);
3475 ax_ext (expr
, addr_size_bits
);
3476 /* No need for a second swap here. */
3477 ax_simple (expr
, aop_equal
);
3481 /* Sign extend the operands. */
3482 ax_ext (expr
, addr_size_bits
);
3483 ax_simple (expr
, aop_swap
);
3484 ax_ext (expr
, addr_size_bits
);
3485 ax_simple (expr
, aop_swap
);
3486 ax_simple (expr
, aop_less_signed
);
3490 /* Sign extend the operands. */
3491 ax_ext (expr
, addr_size_bits
);
3492 ax_simple (expr
, aop_swap
);
3493 ax_ext (expr
, addr_size_bits
);
3494 /* Note no swap here: A > B is B < A. */
3495 ax_simple (expr
, aop_less_signed
);
3499 /* Sign extend the operands. */
3500 ax_ext (expr
, addr_size_bits
);
3501 ax_simple (expr
, aop_swap
);
3502 ax_ext (expr
, addr_size_bits
);
3503 /* No need for a swap here. */
3504 ax_simple (expr
, aop_equal
);
3505 ax_simple (expr
, aop_log_not
);
3508 case DW_OP_call_frame_cfa
:
3511 CORE_ADDR text_offset
;
3513 const gdb_byte
*cfa_start
, *cfa_end
;
3515 if (dwarf2_fetch_cfa_info (arch
, expr
->scope
, per_cu
,
3517 &text_offset
, &cfa_start
, &cfa_end
))
3520 ax_reg (expr
, regnum
);
3523 ax_const_l (expr
, off
);
3524 ax_simple (expr
, aop_add
);
3529 /* Another expression. */
3530 ax_const_l (expr
, text_offset
);
3531 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3532 cfa_start
, cfa_end
, per_cu
);
3535 loc
->kind
= axs_lvalue_memory
;
3539 case DW_OP_GNU_push_tls_address
:
3540 case DW_OP_form_tls_address
:
3544 case DW_OP_push_object_address
:
3549 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3551 i
= ax_goto (expr
, aop_goto
);
3552 dw_labels
.push_back (op_ptr
+ offset
- base
);
3553 patches
.push_back (i
);
3557 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3559 /* Zero extend the operand. */
3560 ax_zero_ext (expr
, addr_size_bits
);
3561 i
= ax_goto (expr
, aop_if_goto
);
3562 dw_labels
.push_back (op_ptr
+ offset
- base
);
3563 patches
.push_back (i
);
3570 case DW_OP_bit_piece
:
3572 uint64_t size
, offset
;
3574 if (op_ptr
- 1 == previous_piece
)
3575 error (_("Cannot translate empty pieces to agent expressions"));
3576 previous_piece
= op_ptr
- 1;
3578 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3579 if (op
== DW_OP_piece
)
3585 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
3587 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3588 error (_("Expression pieces exceed word size"));
3590 /* Access the bits. */
3593 case axs_lvalue_register
:
3594 ax_reg (expr
, loc
->u
.reg
);
3597 case axs_lvalue_memory
:
3598 /* Offset the pointer, if needed. */
3601 ax_const_l (expr
, offset
/ 8);
3602 ax_simple (expr
, aop_add
);
3605 access_memory (arch
, expr
, size
);
3609 /* For a bits-big-endian target, shift up what we already
3610 have. For a bits-little-endian target, shift up the
3611 new data. Note that there is a potential bug here if
3612 the DWARF expression leaves multiple values on the
3614 if (bits_collected
> 0)
3616 if (bits_big_endian
)
3618 ax_simple (expr
, aop_swap
);
3619 ax_const_l (expr
, size
);
3620 ax_simple (expr
, aop_lsh
);
3621 /* We don't need a second swap here, because
3622 aop_bit_or is symmetric. */
3626 ax_const_l (expr
, size
);
3627 ax_simple (expr
, aop_lsh
);
3629 ax_simple (expr
, aop_bit_or
);
3632 bits_collected
+= size
;
3633 loc
->kind
= axs_rvalue
;
3637 case DW_OP_GNU_uninit
:
3643 struct dwarf2_locexpr_baton block
;
3644 int size
= (op
== DW_OP_call2
? 2 : 4);
3647 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3650 offset
.cu_off
= uoffset
;
3651 block
= dwarf2_fetch_die_loc_cu_off (offset
, per_cu
,
3654 /* DW_OP_call_ref is currently not supported. */
3655 gdb_assert (block
.per_cu
== per_cu
);
3657 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3658 block
.data
, block
.data
+ block
.size
,
3663 case DW_OP_call_ref
:
3671 /* Patch all the branches we emitted. */
3672 for (i
= 0; i
< patches
.size (); ++i
)
3674 int targ
= offsets
[dw_labels
[i
]];
3676 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3677 ax_label (expr
, patches
[i
], targ
);
3682 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3683 evaluator to calculate the location. */
3684 static struct value
*
3685 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3687 struct dwarf2_locexpr_baton
*dlbaton
3688 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3691 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3692 dlbaton
->size
, dlbaton
->per_cu
);
3697 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3698 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3701 static struct value
*
3702 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3704 struct dwarf2_locexpr_baton
*dlbaton
3705 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3707 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3711 /* Implementation of get_symbol_read_needs from
3712 symbol_computed_ops. */
3714 static enum symbol_needs_kind
3715 locexpr_get_symbol_read_needs (struct symbol
*symbol
)
3717 struct dwarf2_locexpr_baton
*dlbaton
3718 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3720 return dwarf2_loc_desc_get_symbol_read_needs (dlbaton
->data
, dlbaton
->size
,
3724 /* Return true if DATA points to the end of a piece. END is one past
3725 the last byte in the expression. */
3728 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3730 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3733 /* Helper for locexpr_describe_location_piece that finds the name of a
3737 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3741 /* This doesn't use dwarf_reg_to_regnum_or_error on purpose.
3742 We'd rather print *something* here than throw an error. */
3743 regnum
= dwarf_reg_to_regnum (gdbarch
, dwarf_regnum
);
3744 /* gdbarch_register_name may just return "", return something more
3745 descriptive for bad register numbers. */
3748 /* The text is output as "$bad_register_number".
3749 That is why we use the underscores. */
3750 return _("bad_register_number");
3752 return gdbarch_register_name (gdbarch
, regnum
);
3755 /* Nicely describe a single piece of a location, returning an updated
3756 position in the bytecode sequence. This function cannot recognize
3757 all locations; if a location is not recognized, it simply returns
3758 DATA. If there is an error during reading, e.g. we run off the end
3759 of the buffer, an error is thrown. */
3761 static const gdb_byte
*
3762 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3763 CORE_ADDR addr
, struct objfile
*objfile
,
3764 struct dwarf2_per_cu_data
*per_cu
,
3765 const gdb_byte
*data
, const gdb_byte
*end
,
3766 unsigned int addr_size
)
3768 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3771 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3773 fprintf_filtered (stream
, _("a variable in $%s"),
3774 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3777 else if (data
[0] == DW_OP_regx
)
3781 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3782 fprintf_filtered (stream
, _("a variable in $%s"),
3783 locexpr_regname (gdbarch
, reg
));
3785 else if (data
[0] == DW_OP_fbreg
)
3787 const struct block
*b
;
3788 struct symbol
*framefunc
;
3790 int64_t frame_offset
;
3791 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3793 int64_t base_offset
= 0;
3795 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3796 if (!piece_end_p (new_data
, end
))
3800 b
= block_for_pc (addr
);
3803 error (_("No block found for address for symbol \"%s\"."),
3804 SYMBOL_PRINT_NAME (symbol
));
3806 framefunc
= block_linkage_function (b
);
3809 error (_("No function found for block for symbol \"%s\"."),
3810 SYMBOL_PRINT_NAME (symbol
));
3812 func_get_frame_base_dwarf_block (framefunc
, addr
, &base_data
, &base_size
);
3814 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3816 const gdb_byte
*buf_end
;
3818 frame_reg
= base_data
[0] - DW_OP_breg0
;
3819 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3821 if (buf_end
!= base_data
+ base_size
)
3822 error (_("Unexpected opcode after "
3823 "DW_OP_breg%u for symbol \"%s\"."),
3824 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3826 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3828 /* The frame base is just the register, with no offset. */
3829 frame_reg
= base_data
[0] - DW_OP_reg0
;
3834 /* We don't know what to do with the frame base expression,
3835 so we can't trace this variable; give up. */
3839 fprintf_filtered (stream
,
3840 _("a variable at frame base reg $%s offset %s+%s"),
3841 locexpr_regname (gdbarch
, frame_reg
),
3842 plongest (base_offset
), plongest (frame_offset
));
3844 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3845 && piece_end_p (data
, end
))
3849 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3851 fprintf_filtered (stream
,
3852 _("a variable at offset %s from base reg $%s"),
3854 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3857 /* The location expression for a TLS variable looks like this (on a
3860 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3861 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3863 0x3 is the encoding for DW_OP_addr, which has an operand as long
3864 as the size of an address on the target machine (here is 8
3865 bytes). Note that more recent version of GCC emit DW_OP_const4u
3866 or DW_OP_const8u, depending on address size, rather than
3867 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3868 The operand represents the offset at which the variable is within
3869 the thread local storage. */
3871 else if (data
+ 1 + addr_size
< end
3872 && (data
[0] == DW_OP_addr
3873 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3874 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3875 && (data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3876 || data
[1 + addr_size
] == DW_OP_form_tls_address
)
3877 && piece_end_p (data
+ 2 + addr_size
, end
))
3880 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3881 gdbarch_byte_order (gdbarch
));
3883 fprintf_filtered (stream
,
3884 _("a thread-local variable at offset 0x%s "
3885 "in the thread-local storage for `%s'"),
3886 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3888 data
+= 1 + addr_size
+ 1;
3891 /* With -gsplit-dwarf a TLS variable can also look like this:
3892 DW_AT_location : 3 byte block: fc 4 e0
3893 (DW_OP_GNU_const_index: 4;
3894 DW_OP_GNU_push_tls_address) */
3895 else if (data
+ 3 <= end
3896 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3897 && data
[0] == DW_OP_GNU_const_index
3899 && (data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3900 || data
[1 + leb128_size
] == DW_OP_form_tls_address
)
3901 && piece_end_p (data
+ 2 + leb128_size
, end
))
3905 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3906 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3907 fprintf_filtered (stream
,
3908 _("a thread-local variable at offset 0x%s "
3909 "in the thread-local storage for `%s'"),
3910 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3914 else if (data
[0] >= DW_OP_lit0
3915 && data
[0] <= DW_OP_lit31
3917 && data
[1] == DW_OP_stack_value
)
3919 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3926 /* Disassemble an expression, stopping at the end of a piece or at the
3927 end of the expression. Returns a pointer to the next unread byte
3928 in the input expression. If ALL is nonzero, then this function
3929 will keep going until it reaches the end of the expression.
3930 If there is an error during reading, e.g. we run off the end
3931 of the buffer, an error is thrown. */
3933 static const gdb_byte
*
3934 disassemble_dwarf_expression (struct ui_file
*stream
,
3935 struct gdbarch
*arch
, unsigned int addr_size
,
3936 int offset_size
, const gdb_byte
*start
,
3937 const gdb_byte
*data
, const gdb_byte
*end
,
3938 int indent
, int all
,
3939 struct dwarf2_per_cu_data
*per_cu
)
3943 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3945 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *data
++;
3950 name
= get_DW_OP_name (op
);
3953 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3954 op
, (long) (data
- 1 - start
));
3955 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3956 (long) (data
- 1 - start
), name
);
3961 ul
= extract_unsigned_integer (data
, addr_size
,
3962 gdbarch_byte_order (arch
));
3964 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3968 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3970 fprintf_filtered (stream
, " %s", pulongest (ul
));
3973 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3975 fprintf_filtered (stream
, " %s", plongest (l
));
3978 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3980 fprintf_filtered (stream
, " %s", pulongest (ul
));
3983 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3985 fprintf_filtered (stream
, " %s", plongest (l
));
3988 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3990 fprintf_filtered (stream
, " %s", pulongest (ul
));
3993 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3995 fprintf_filtered (stream
, " %s", plongest (l
));
3998 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
4000 fprintf_filtered (stream
, " %s", pulongest (ul
));
4003 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
4005 fprintf_filtered (stream
, " %s", plongest (l
));
4008 data
= safe_read_uleb128 (data
, end
, &ul
);
4009 fprintf_filtered (stream
, " %s", pulongest (ul
));
4012 data
= safe_read_sleb128 (data
, end
, &l
);
4013 fprintf_filtered (stream
, " %s", plongest (l
));
4048 fprintf_filtered (stream
, " [$%s]",
4049 locexpr_regname (arch
, op
- DW_OP_reg0
));
4053 data
= safe_read_uleb128 (data
, end
, &ul
);
4054 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
4055 locexpr_regname (arch
, (int) ul
));
4058 case DW_OP_implicit_value
:
4059 data
= safe_read_uleb128 (data
, end
, &ul
);
4061 fprintf_filtered (stream
, " %s", pulongest (ul
));
4096 data
= safe_read_sleb128 (data
, end
, &l
);
4097 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
4098 locexpr_regname (arch
, op
- DW_OP_breg0
));
4102 data
= safe_read_uleb128 (data
, end
, &ul
);
4103 data
= safe_read_sleb128 (data
, end
, &l
);
4104 fprintf_filtered (stream
, " register %s [$%s] offset %s",
4106 locexpr_regname (arch
, (int) ul
),
4111 data
= safe_read_sleb128 (data
, end
, &l
);
4112 fprintf_filtered (stream
, " %s", plongest (l
));
4115 case DW_OP_xderef_size
:
4116 case DW_OP_deref_size
:
4118 fprintf_filtered (stream
, " %d", *data
);
4122 case DW_OP_plus_uconst
:
4123 data
= safe_read_uleb128 (data
, end
, &ul
);
4124 fprintf_filtered (stream
, " %s", pulongest (ul
));
4128 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4130 fprintf_filtered (stream
, " to %ld",
4131 (long) (data
+ l
- start
));
4135 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4137 fprintf_filtered (stream
, " %ld",
4138 (long) (data
+ l
- start
));
4142 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
4144 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
4148 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4150 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4153 case DW_OP_call_ref
:
4154 ul
= extract_unsigned_integer (data
, offset_size
,
4155 gdbarch_byte_order (arch
));
4156 data
+= offset_size
;
4157 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4161 data
= safe_read_uleb128 (data
, end
, &ul
);
4162 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
4165 case DW_OP_bit_piece
:
4169 data
= safe_read_uleb128 (data
, end
, &ul
);
4170 data
= safe_read_uleb128 (data
, end
, &offset
);
4171 fprintf_filtered (stream
, " size %s offset %s (bits)",
4172 pulongest (ul
), pulongest (offset
));
4176 case DW_OP_implicit_pointer
:
4177 case DW_OP_GNU_implicit_pointer
:
4179 ul
= extract_unsigned_integer (data
, offset_size
,
4180 gdbarch_byte_order (arch
));
4181 data
+= offset_size
;
4183 data
= safe_read_sleb128 (data
, end
, &l
);
4185 fprintf_filtered (stream
, " DIE %s offset %s",
4186 phex_nz (ul
, offset_size
),
4191 case DW_OP_deref_type
:
4192 case DW_OP_GNU_deref_type
:
4194 int addr_size
= *data
++;
4198 data
= safe_read_uleb128 (data
, end
, &ul
);
4200 type
= dwarf2_get_die_type (offset
, per_cu
);
4201 fprintf_filtered (stream
, "<");
4202 type_print (type
, "", stream
, -1);
4203 fprintf_filtered (stream
, " [0x%s]> %d", phex_nz (offset
.cu_off
, 0),
4208 case DW_OP_const_type
:
4209 case DW_OP_GNU_const_type
:
4214 data
= safe_read_uleb128 (data
, end
, &ul
);
4215 type_die
.cu_off
= ul
;
4216 type
= dwarf2_get_die_type (type_die
, per_cu
);
4217 fprintf_filtered (stream
, "<");
4218 type_print (type
, "", stream
, -1);
4219 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
4223 case DW_OP_regval_type
:
4224 case DW_OP_GNU_regval_type
:
4230 data
= safe_read_uleb128 (data
, end
, ®
);
4231 data
= safe_read_uleb128 (data
, end
, &ul
);
4232 type_die
.cu_off
= ul
;
4234 type
= dwarf2_get_die_type (type_die
, per_cu
);
4235 fprintf_filtered (stream
, "<");
4236 type_print (type
, "", stream
, -1);
4237 fprintf_filtered (stream
, " [0x%s]> [$%s]",
4238 phex_nz (type_die
.cu_off
, 0),
4239 locexpr_regname (arch
, reg
));
4244 case DW_OP_GNU_convert
:
4245 case DW_OP_reinterpret
:
4246 case DW_OP_GNU_reinterpret
:
4250 data
= safe_read_uleb128 (data
, end
, &ul
);
4251 type_die
.cu_off
= ul
;
4253 if (type_die
.cu_off
== 0)
4254 fprintf_filtered (stream
, "<0>");
4259 type
= dwarf2_get_die_type (type_die
, per_cu
);
4260 fprintf_filtered (stream
, "<");
4261 type_print (type
, "", stream
, -1);
4262 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
4267 case DW_OP_entry_value
:
4268 case DW_OP_GNU_entry_value
:
4269 data
= safe_read_uleb128 (data
, end
, &ul
);
4270 fputc_filtered ('\n', stream
);
4271 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
4272 start
, data
, data
+ ul
, indent
+ 2,
4277 case DW_OP_GNU_parameter_ref
:
4278 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4280 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4283 case DW_OP_GNU_addr_index
:
4284 data
= safe_read_uleb128 (data
, end
, &ul
);
4285 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4286 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
4288 case DW_OP_GNU_const_index
:
4289 data
= safe_read_uleb128 (data
, end
, &ul
);
4290 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4291 fprintf_filtered (stream
, " %s", pulongest (ul
));
4295 fprintf_filtered (stream
, "\n");
4301 /* Describe a single location, which may in turn consist of multiple
4305 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
4306 struct ui_file
*stream
,
4307 const gdb_byte
*data
, size_t size
,
4308 struct objfile
*objfile
, unsigned int addr_size
,
4309 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
4311 const gdb_byte
*end
= data
+ size
;
4312 int first_piece
= 1, bad
= 0;
4316 const gdb_byte
*here
= data
;
4317 int disassemble
= 1;
4322 fprintf_filtered (stream
, _(", and "));
4324 if (!dwarf_always_disassemble
)
4326 data
= locexpr_describe_location_piece (symbol
, stream
,
4327 addr
, objfile
, per_cu
,
4328 data
, end
, addr_size
);
4329 /* If we printed anything, or if we have an empty piece,
4330 then don't disassemble. */
4332 || data
[0] == DW_OP_piece
4333 || data
[0] == DW_OP_bit_piece
)
4338 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
4339 data
= disassemble_dwarf_expression (stream
,
4340 get_objfile_arch (objfile
),
4341 addr_size
, offset_size
, data
,
4343 dwarf_always_disassemble
,
4349 int empty
= data
== here
;
4352 fprintf_filtered (stream
, " ");
4353 if (data
[0] == DW_OP_piece
)
4357 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
4360 fprintf_filtered (stream
, _("an empty %s-byte piece"),
4363 fprintf_filtered (stream
, _(" [%s-byte piece]"),
4366 else if (data
[0] == DW_OP_bit_piece
)
4368 uint64_t bits
, offset
;
4370 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
4371 data
= safe_read_uleb128 (data
, end
, &offset
);
4374 fprintf_filtered (stream
,
4375 _("an empty %s-bit piece"),
4378 fprintf_filtered (stream
,
4379 _(" [%s-bit piece, offset %s bits]"),
4380 pulongest (bits
), pulongest (offset
));
4390 if (bad
|| data
> end
)
4391 error (_("Corrupted DWARF2 expression for \"%s\"."),
4392 SYMBOL_PRINT_NAME (symbol
));
4395 /* Print a natural-language description of SYMBOL to STREAM. This
4396 version is for a symbol with a single location. */
4399 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4400 struct ui_file
*stream
)
4402 struct dwarf2_locexpr_baton
*dlbaton
4403 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4404 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4405 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4406 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4408 locexpr_describe_location_1 (symbol
, addr
, stream
,
4409 dlbaton
->data
, dlbaton
->size
,
4410 objfile
, addr_size
, offset_size
,
4414 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4415 any necessary bytecode in AX. */
4418 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4419 struct agent_expr
*ax
, struct axs_value
*value
)
4421 struct dwarf2_locexpr_baton
*dlbaton
4422 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4423 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4425 if (dlbaton
->size
== 0)
4426 value
->optimized_out
= 1;
4428 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
4429 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4433 /* symbol_computed_ops 'generate_c_location' method. */
4436 locexpr_generate_c_location (struct symbol
*sym
, string_file
&stream
,
4437 struct gdbarch
*gdbarch
,
4438 unsigned char *registers_used
,
4439 CORE_ADDR pc
, const char *result_name
)
4441 struct dwarf2_locexpr_baton
*dlbaton
4442 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (sym
);
4443 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4445 if (dlbaton
->size
== 0)
4446 error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym
));
4448 compile_dwarf_expr_to_c (stream
, result_name
,
4449 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4450 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4454 /* The set of location functions used with the DWARF-2 expression
4456 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4457 locexpr_read_variable
,
4458 locexpr_read_variable_at_entry
,
4459 locexpr_get_symbol_read_needs
,
4460 locexpr_describe_location
,
4461 0, /* location_has_loclist */
4462 locexpr_tracepoint_var_ref
,
4463 locexpr_generate_c_location
4467 /* Wrapper functions for location lists. These generally find
4468 the appropriate location expression and call something above. */
4470 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4471 evaluator to calculate the location. */
4472 static struct value
*
4473 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4475 struct dwarf2_loclist_baton
*dlbaton
4476 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4478 const gdb_byte
*data
;
4480 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4482 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4483 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4489 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4490 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4493 Function always returns non-NULL value, it may be marked optimized out if
4494 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4495 if it cannot resolve the parameter for any reason. */
4497 static struct value
*
4498 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4500 struct dwarf2_loclist_baton
*dlbaton
4501 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4502 const gdb_byte
*data
;
4506 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4507 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4509 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4511 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4513 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4516 /* Implementation of get_symbol_read_needs from
4517 symbol_computed_ops. */
4519 static enum symbol_needs_kind
4520 loclist_symbol_needs (struct symbol
*symbol
)
4522 /* If there's a location list, then assume we need to have a frame
4523 to choose the appropriate location expression. With tracking of
4524 global variables this is not necessarily true, but such tracking
4525 is disabled in GCC at the moment until we figure out how to
4528 return SYMBOL_NEEDS_FRAME
;
4531 /* Print a natural-language description of SYMBOL to STREAM. This
4532 version applies when there is a list of different locations, each
4533 with a specified address range. */
4536 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4537 struct ui_file
*stream
)
4539 struct dwarf2_loclist_baton
*dlbaton
4540 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4541 const gdb_byte
*loc_ptr
, *buf_end
;
4542 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4543 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4544 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4545 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4546 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4547 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4548 /* Adjust base_address for relocatable objects. */
4549 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4550 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4553 loc_ptr
= dlbaton
->data
;
4554 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4556 fprintf_filtered (stream
, _("multi-location:\n"));
4558 /* Iterate through locations until we run out. */
4561 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4563 enum debug_loc_kind kind
;
4564 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4566 if (dlbaton
->from_dwo
)
4567 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4568 loc_ptr
, buf_end
, &new_ptr
,
4569 &low
, &high
, byte_order
);
4571 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4573 byte_order
, addr_size
,
4578 case DEBUG_LOC_END_OF_LIST
:
4581 case DEBUG_LOC_BASE_ADDRESS
:
4582 base_address
= high
+ base_offset
;
4583 fprintf_filtered (stream
, _(" Base address %s"),
4584 paddress (gdbarch
, base_address
));
4586 case DEBUG_LOC_START_END
:
4587 case DEBUG_LOC_START_LENGTH
:
4589 case DEBUG_LOC_BUFFER_OVERFLOW
:
4590 case DEBUG_LOC_INVALID_ENTRY
:
4591 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4592 SYMBOL_PRINT_NAME (symbol
));
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 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4607 /* (It would improve readability to print only the minimum
4608 necessary digits of the second number of the range.) */
4609 fprintf_filtered (stream
, _(" Range %s-%s: "),
4610 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4612 /* Now describe this particular location. */
4613 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4614 objfile
, addr_size
, offset_size
,
4617 fprintf_filtered (stream
, "\n");
4623 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4624 any necessary bytecode in AX. */
4626 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4627 struct agent_expr
*ax
, struct axs_value
*value
)
4629 struct dwarf2_loclist_baton
*dlbaton
4630 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4631 const gdb_byte
*data
;
4633 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4635 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4637 value
->optimized_out
= 1;
4639 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
4643 /* symbol_computed_ops 'generate_c_location' method. */
4646 loclist_generate_c_location (struct symbol
*sym
, string_file
&stream
,
4647 struct gdbarch
*gdbarch
,
4648 unsigned char *registers_used
,
4649 CORE_ADDR pc
, const char *result_name
)
4651 struct dwarf2_loclist_baton
*dlbaton
4652 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (sym
);
4653 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4654 const gdb_byte
*data
;
4657 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4659 error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym
));
4661 compile_dwarf_expr_to_c (stream
, result_name
,
4662 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4667 /* The set of location functions used with the DWARF-2 expression
4668 evaluator and location lists. */
4669 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4670 loclist_read_variable
,
4671 loclist_read_variable_at_entry
,
4672 loclist_symbol_needs
,
4673 loclist_describe_location
,
4674 1, /* location_has_loclist */
4675 loclist_tracepoint_var_ref
,
4676 loclist_generate_c_location
4679 /* Provide a prototype to silence -Wmissing-prototypes. */
4680 extern initialize_file_ftype _initialize_dwarf2loc
;
4683 _initialize_dwarf2loc (void)
4685 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4686 &entry_values_debug
,
4687 _("Set entry values and tail call frames "
4689 _("Show entry values and tail call frames "
4691 _("When non-zero, the process of determining "
4692 "parameter values from function entry point "
4693 "and tail call frames will be printed."),
4695 show_entry_values_debug
,
4696 &setdebuglist
, &showdebuglist
);
4699 register_self_test (selftests::copy_bitwise_tests
);