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
,
55 static struct call_site_parameter
*dwarf_expr_reg_to_entry_parameter
56 (struct frame_info
*frame
,
57 enum call_site_parameter_kind kind
,
58 union call_site_parameter_u kind_u
,
59 struct dwarf2_per_cu_data
**per_cu_return
);
61 /* Until these have formal names, we define these here.
62 ref: http://gcc.gnu.org/wiki/DebugFission
63 Each entry in .debug_loc.dwo begins with a byte that describes the entry,
64 and is then followed by data specific to that entry. */
68 /* Indicates the end of the list of entries. */
69 DEBUG_LOC_END_OF_LIST
= 0,
71 /* This is followed by an unsigned LEB128 number that is an index into
72 .debug_addr and specifies the base address for all following entries. */
73 DEBUG_LOC_BASE_ADDRESS
= 1,
75 /* This is followed by two unsigned LEB128 numbers that are indices into
76 .debug_addr and specify the beginning and ending addresses, and then
77 a normal location expression as in .debug_loc. */
78 DEBUG_LOC_START_END
= 2,
80 /* This is followed by an unsigned LEB128 number that is an index into
81 .debug_addr and specifies the beginning address, and a 4 byte unsigned
82 number that specifies the length, and then a normal location expression
84 DEBUG_LOC_START_LENGTH
= 3,
86 /* An internal value indicating there is insufficient data. */
87 DEBUG_LOC_BUFFER_OVERFLOW
= -1,
89 /* An internal value indicating an invalid kind of entry was found. */
90 DEBUG_LOC_INVALID_ENTRY
= -2
93 /* Helper function which throws an error if a synthetic pointer is
97 invalid_synthetic_pointer (void)
99 error (_("access outside bounds of object "
100 "referenced via synthetic pointer"));
103 /* Decode the addresses in a non-dwo .debug_loc entry.
104 A pointer to the next byte to examine is returned in *NEW_PTR.
105 The encoded low,high addresses are return in *LOW,*HIGH.
106 The result indicates the kind of entry found. */
108 static enum debug_loc_kind
109 decode_debug_loc_addresses (const gdb_byte
*loc_ptr
, const gdb_byte
*buf_end
,
110 const gdb_byte
**new_ptr
,
111 CORE_ADDR
*low
, CORE_ADDR
*high
,
112 enum bfd_endian byte_order
,
113 unsigned int addr_size
,
116 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
118 if (buf_end
- loc_ptr
< 2 * addr_size
)
119 return DEBUG_LOC_BUFFER_OVERFLOW
;
122 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
124 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
125 loc_ptr
+= addr_size
;
128 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
130 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
131 loc_ptr
+= addr_size
;
135 /* A base-address-selection entry. */
136 if ((*low
& base_mask
) == base_mask
)
137 return DEBUG_LOC_BASE_ADDRESS
;
139 /* An end-of-list entry. */
140 if (*low
== 0 && *high
== 0)
141 return DEBUG_LOC_END_OF_LIST
;
143 return DEBUG_LOC_START_END
;
146 /* Decode the addresses in .debug_loclists entry.
147 A pointer to the next byte to examine is returned in *NEW_PTR.
148 The encoded low,high addresses are return in *LOW,*HIGH.
149 The result indicates the kind of entry found. */
151 static enum debug_loc_kind
152 decode_debug_loclists_addresses (struct dwarf2_per_cu_data
*per_cu
,
153 const gdb_byte
*loc_ptr
,
154 const gdb_byte
*buf_end
,
155 const gdb_byte
**new_ptr
,
156 CORE_ADDR
*low
, CORE_ADDR
*high
,
157 enum bfd_endian byte_order
,
158 unsigned int addr_size
,
163 if (loc_ptr
== buf_end
)
164 return DEBUG_LOC_BUFFER_OVERFLOW
;
168 case DW_LLE_end_of_list
:
170 return DEBUG_LOC_END_OF_LIST
;
171 case DW_LLE_base_address
:
172 if (loc_ptr
+ addr_size
> buf_end
)
173 return DEBUG_LOC_BUFFER_OVERFLOW
;
175 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
177 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
178 loc_ptr
+= addr_size
;
180 return DEBUG_LOC_BASE_ADDRESS
;
181 case DW_LLE_offset_pair
:
182 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
184 return DEBUG_LOC_BUFFER_OVERFLOW
;
186 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &u64
);
188 return DEBUG_LOC_BUFFER_OVERFLOW
;
191 return DEBUG_LOC_START_END
;
193 return DEBUG_LOC_INVALID_ENTRY
;
197 /* Decode the addresses in .debug_loc.dwo entry.
198 A pointer to the next byte to examine is returned in *NEW_PTR.
199 The encoded low,high addresses are return in *LOW,*HIGH.
200 The result indicates the kind of entry found. */
202 static enum debug_loc_kind
203 decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data
*per_cu
,
204 const gdb_byte
*loc_ptr
,
205 const gdb_byte
*buf_end
,
206 const gdb_byte
**new_ptr
,
207 CORE_ADDR
*low
, CORE_ADDR
*high
,
208 enum bfd_endian byte_order
)
210 uint64_t low_index
, high_index
;
212 if (loc_ptr
== buf_end
)
213 return DEBUG_LOC_BUFFER_OVERFLOW
;
217 case DW_LLE_GNU_end_of_list_entry
:
219 return DEBUG_LOC_END_OF_LIST
;
220 case DW_LLE_GNU_base_address_selection_entry
:
222 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
224 return DEBUG_LOC_BUFFER_OVERFLOW
;
225 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
227 return DEBUG_LOC_BASE_ADDRESS
;
228 case DW_LLE_GNU_start_end_entry
:
229 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
231 return DEBUG_LOC_BUFFER_OVERFLOW
;
232 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
233 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
235 return DEBUG_LOC_BUFFER_OVERFLOW
;
236 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
238 return DEBUG_LOC_START_END
;
239 case DW_LLE_GNU_start_length_entry
:
240 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
242 return DEBUG_LOC_BUFFER_OVERFLOW
;
243 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
244 if (loc_ptr
+ 4 > buf_end
)
245 return DEBUG_LOC_BUFFER_OVERFLOW
;
247 *high
+= extract_unsigned_integer (loc_ptr
, 4, byte_order
);
248 *new_ptr
= loc_ptr
+ 4;
249 return DEBUG_LOC_START_LENGTH
;
251 return DEBUG_LOC_INVALID_ENTRY
;
255 /* A function for dealing with location lists. Given a
256 symbol baton (BATON) and a pc value (PC), find the appropriate
257 location expression, set *LOCEXPR_LENGTH, and return a pointer
258 to the beginning of the expression. Returns NULL on failure.
260 For now, only return the first matching location expression; there
261 can be more than one in the list. */
264 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
265 size_t *locexpr_length
, CORE_ADDR pc
)
267 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
268 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
269 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
270 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
271 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
272 /* Adjust base_address for relocatable objects. */
273 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (baton
->per_cu
);
274 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
275 const gdb_byte
*loc_ptr
, *buf_end
;
277 loc_ptr
= baton
->data
;
278 buf_end
= baton
->data
+ baton
->size
;
282 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
284 enum debug_loc_kind kind
;
285 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
288 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
289 loc_ptr
, buf_end
, &new_ptr
,
290 &low
, &high
, byte_order
);
291 else if (dwarf2_version (baton
->per_cu
) < 5)
292 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
294 byte_order
, addr_size
,
297 kind
= decode_debug_loclists_addresses (baton
->per_cu
,
298 loc_ptr
, buf_end
, &new_ptr
,
299 &low
, &high
, byte_order
,
300 addr_size
, signed_addr_p
);
305 case DEBUG_LOC_END_OF_LIST
:
308 case DEBUG_LOC_BASE_ADDRESS
:
309 base_address
= high
+ base_offset
;
311 case DEBUG_LOC_START_END
:
312 case DEBUG_LOC_START_LENGTH
:
314 case DEBUG_LOC_BUFFER_OVERFLOW
:
315 case DEBUG_LOC_INVALID_ENTRY
:
316 error (_("dwarf2_find_location_expression: "
317 "Corrupted DWARF expression."));
319 gdb_assert_not_reached ("bad debug_loc_kind");
322 /* Otherwise, a location expression entry.
323 If the entry is from a DWO, don't add base address: the entry is from
324 .debug_addr which already has the DWARF "base address". We still add
325 base_offset in case we're debugging a PIE executable. */
334 high
+= base_address
;
337 if (dwarf2_version (baton
->per_cu
) < 5)
339 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
344 unsigned int bytes_read
;
346 length
= read_unsigned_leb128 (NULL
, loc_ptr
, &bytes_read
);
347 loc_ptr
+= bytes_read
;
350 if (low
== high
&& pc
== low
)
352 /* This is entry PC record present only at entry point
353 of a function. Verify it is really the function entry point. */
355 const struct block
*pc_block
= block_for_pc (pc
);
356 struct symbol
*pc_func
= NULL
;
359 pc_func
= block_linkage_function (pc_block
);
361 if (pc_func
&& pc
== BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func
)))
363 *locexpr_length
= length
;
368 if (pc
>= low
&& pc
< high
)
370 *locexpr_length
= length
;
378 /* This is the baton used when performing dwarf2 expression
380 struct dwarf_expr_baton
382 struct frame_info
*frame
;
383 struct dwarf2_per_cu_data
*per_cu
;
384 CORE_ADDR obj_address
;
387 /* Implement find_frame_base_location method for LOC_BLOCK functions using
388 DWARF expression for its DW_AT_frame_base. */
391 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
392 const gdb_byte
**start
, size_t *length
)
394 struct dwarf2_locexpr_baton
*symbaton
395 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
397 *length
= symbaton
->size
;
398 *start
= symbaton
->data
;
401 /* Implement the struct symbol_block_ops::get_frame_base method for
402 LOC_BLOCK functions using a DWARF expression as its DW_AT_frame_base. */
405 locexpr_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
407 struct gdbarch
*gdbarch
;
409 struct dwarf2_locexpr_baton
*dlbaton
;
410 const gdb_byte
*start
;
412 struct value
*result
;
414 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
415 Thus, it's supposed to provide the find_frame_base_location method as
417 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
419 gdbarch
= get_frame_arch (frame
);
420 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
421 dlbaton
= (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
423 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
424 (framefunc
, get_frame_pc (frame
), &start
, &length
);
425 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
428 /* The DW_AT_frame_base attribute contains a location description which
429 computes the base address itself. However, the call to
430 dwarf2_evaluate_loc_desc returns a value representing a variable at
431 that address. The frame base address is thus this variable's
433 return value_address (result
);
436 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
437 function uses DWARF expression for its DW_AT_frame_base. */
439 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
441 locexpr_find_frame_base_location
,
442 locexpr_get_frame_base
445 /* Implement find_frame_base_location method for LOC_BLOCK functions using
446 DWARF location list for its DW_AT_frame_base. */
449 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
450 const gdb_byte
**start
, size_t *length
)
452 struct dwarf2_loclist_baton
*symbaton
453 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
455 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
458 /* Implement the struct symbol_block_ops::get_frame_base method for
459 LOC_BLOCK functions using a DWARF location list as its DW_AT_frame_base. */
462 loclist_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
464 struct gdbarch
*gdbarch
;
466 struct dwarf2_loclist_baton
*dlbaton
;
467 const gdb_byte
*start
;
469 struct value
*result
;
471 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
472 Thus, it's supposed to provide the find_frame_base_location method as
474 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
476 gdbarch
= get_frame_arch (frame
);
477 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
478 dlbaton
= (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
480 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
481 (framefunc
, get_frame_pc (frame
), &start
, &length
);
482 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
485 /* The DW_AT_frame_base attribute contains a location description which
486 computes the base address itself. However, the call to
487 dwarf2_evaluate_loc_desc returns a value representing a variable at
488 that address. The frame base address is thus this variable's
490 return value_address (result
);
493 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
494 function uses DWARF location list for its DW_AT_frame_base. */
496 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
498 loclist_find_frame_base_location
,
499 loclist_get_frame_base
502 /* See dwarf2loc.h. */
505 func_get_frame_base_dwarf_block (struct symbol
*framefunc
, CORE_ADDR pc
,
506 const gdb_byte
**start
, size_t *length
)
508 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
510 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
512 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
518 error (_("Could not find the frame base for \"%s\"."),
519 SYMBOL_NATURAL_NAME (framefunc
));
523 get_frame_pc_for_per_cu_dwarf_call (void *baton
)
525 dwarf_expr_context
*ctx
= (dwarf_expr_context
*) baton
;
527 return ctx
->get_frame_pc ();
531 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
532 struct dwarf2_per_cu_data
*per_cu
)
534 struct dwarf2_locexpr_baton block
;
536 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
,
537 get_frame_pc_for_per_cu_dwarf_call
,
540 /* DW_OP_call_ref is currently not supported. */
541 gdb_assert (block
.per_cu
== per_cu
);
543 ctx
->eval (block
.data
, block
.size
);
546 class dwarf_evaluate_loc_desc
: public dwarf_expr_context
550 struct frame_info
*frame
;
551 struct dwarf2_per_cu_data
*per_cu
;
552 CORE_ADDR obj_address
;
554 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
555 the frame in BATON. */
557 CORE_ADDR
get_frame_cfa () OVERRIDE
559 return dwarf2_frame_cfa (frame
);
562 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
563 the frame in BATON. */
565 CORE_ADDR
get_frame_pc () OVERRIDE
567 return get_frame_address_in_block (frame
);
570 /* Using the objfile specified in BATON, find the address for the
571 current thread's thread-local storage with offset OFFSET. */
572 CORE_ADDR
get_tls_address (CORE_ADDR offset
) OVERRIDE
574 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
576 return target_translate_tls_address (objfile
, offset
);
579 /* Helper interface of per_cu_dwarf_call for
580 dwarf2_evaluate_loc_desc. */
582 void dwarf_call (cu_offset die_offset
) OVERRIDE
584 per_cu_dwarf_call (this, die_offset
, per_cu
);
587 struct type
*get_base_type (cu_offset die_offset
, int size
) OVERRIDE
589 struct type
*result
= dwarf2_get_die_type (die_offset
, per_cu
);
591 error (_("Could not find type for DW_OP_const_type"));
592 if (size
!= 0 && TYPE_LENGTH (result
) != size
)
593 error (_("DW_OP_const_type has different sizes for type and data"));
597 /* Callback function for dwarf2_evaluate_loc_desc.
598 Fetch the address indexed by DW_OP_GNU_addr_index. */
600 CORE_ADDR
get_addr_index (unsigned int index
) OVERRIDE
602 return dwarf2_read_addr_index (per_cu
, index
);
605 /* Callback function for get_object_address. Return the address of the VLA
608 CORE_ADDR
get_object_address () OVERRIDE
610 if (obj_address
== 0)
611 error (_("Location address is not set."));
615 /* Execute DWARF block of call_site_parameter which matches KIND and
616 KIND_U. Choose DEREF_SIZE value of that parameter. Search
617 caller of this objects's frame.
619 The caller can be from a different CU - per_cu_dwarf_call
620 implementation can be more simple as it does not support cross-CU
623 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
624 union call_site_parameter_u kind_u
,
625 int deref_size
) OVERRIDE
627 struct frame_info
*caller_frame
;
628 struct dwarf2_per_cu_data
*caller_per_cu
;
629 struct call_site_parameter
*parameter
;
630 const gdb_byte
*data_src
;
633 caller_frame
= get_prev_frame (frame
);
635 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
637 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
638 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
640 /* DEREF_SIZE size is not verified here. */
641 if (data_src
== NULL
)
642 throw_error (NO_ENTRY_VALUE_ERROR
,
643 _("Cannot resolve DW_AT_call_data_value"));
645 scoped_restore save_frame
= make_scoped_restore (&this->frame
,
647 scoped_restore save_per_cu
= make_scoped_restore (&this->per_cu
,
649 scoped_restore save_obj_addr
= make_scoped_restore (&this->obj_address
,
652 scoped_restore save_arch
= make_scoped_restore (&this->gdbarch
);
654 = get_objfile_arch (dwarf2_per_cu_objfile (per_cu
));
655 scoped_restore save_addr_size
= make_scoped_restore (&this->addr_size
);
656 this->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
657 scoped_restore save_offset
= make_scoped_restore (&this->offset
);
658 this->offset
= dwarf2_per_cu_text_offset (per_cu
);
660 this->eval (data_src
, size
);
663 /* Using the frame specified in BATON, find the location expression
664 describing the frame base. Return a pointer to it in START and
665 its length in LENGTH. */
666 void get_frame_base (const gdb_byte
**start
, size_t * length
) OVERRIDE
668 /* FIXME: cagney/2003-03-26: This code should be using
669 get_frame_base_address(), and then implement a dwarf2 specific
671 struct symbol
*framefunc
;
672 const struct block
*bl
= get_frame_block (frame
, NULL
);
675 error (_("frame address is not available."));
677 /* Use block_linkage_function, which returns a real (not inlined)
678 function, instead of get_frame_function, which may return an
680 framefunc
= block_linkage_function (bl
);
682 /* If we found a frame-relative symbol then it was certainly within
683 some function associated with a frame. If we can't find the frame,
684 something has gone wrong. */
685 gdb_assert (framefunc
!= NULL
);
687 func_get_frame_base_dwarf_block (framefunc
,
688 get_frame_address_in_block (frame
),
692 /* Read memory at ADDR (length LEN) into BUF. */
694 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) OVERRIDE
696 read_memory (addr
, buf
, len
);
699 /* Using the frame specified in BATON, return the value of register
700 REGNUM, treated as a pointer. */
701 CORE_ADDR
read_addr_from_reg (int dwarf_regnum
) OVERRIDE
703 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
704 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
706 return address_from_register (regnum
, frame
);
709 /* Implement "get_reg_value" callback. */
711 struct value
*get_reg_value (struct type
*type
, int dwarf_regnum
) OVERRIDE
713 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
714 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
716 return value_from_register (type
, regnum
, frame
);
720 /* See dwarf2loc.h. */
722 unsigned int entry_values_debug
= 0;
724 /* Helper to set entry_values_debug. */
727 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
728 struct cmd_list_element
*c
, const char *value
)
730 fprintf_filtered (file
,
731 _("Entry values and tail call frames debugging is %s.\n"),
735 /* Find DW_TAG_call_site's DW_AT_call_target address.
736 CALLER_FRAME (for registers) can be NULL if it is not known. This function
737 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
740 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
741 struct call_site
*call_site
,
742 struct frame_info
*caller_frame
)
744 switch (FIELD_LOC_KIND (call_site
->target
))
746 case FIELD_LOC_KIND_DWARF_BLOCK
:
748 struct dwarf2_locexpr_baton
*dwarf_block
;
750 struct type
*caller_core_addr_type
;
751 struct gdbarch
*caller_arch
;
753 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
754 if (dwarf_block
== NULL
)
756 struct bound_minimal_symbol msym
;
758 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
759 throw_error (NO_ENTRY_VALUE_ERROR
,
760 _("DW_AT_call_target is not specified at %s in %s"),
761 paddress (call_site_gdbarch
, call_site
->pc
),
762 (msym
.minsym
== NULL
? "???"
763 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
766 if (caller_frame
== NULL
)
768 struct bound_minimal_symbol msym
;
770 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
771 throw_error (NO_ENTRY_VALUE_ERROR
,
772 _("DW_AT_call_target DWARF block resolving "
773 "requires known frame which is currently not "
774 "available at %s in %s"),
775 paddress (call_site_gdbarch
, call_site
->pc
),
776 (msym
.minsym
== NULL
? "???"
777 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
780 caller_arch
= get_frame_arch (caller_frame
);
781 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
782 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
783 dwarf_block
->data
, dwarf_block
->size
,
784 dwarf_block
->per_cu
);
785 /* DW_AT_call_target is a DWARF expression, not a DWARF location. */
786 if (VALUE_LVAL (val
) == lval_memory
)
787 return value_address (val
);
789 return value_as_address (val
);
792 case FIELD_LOC_KIND_PHYSNAME
:
794 const char *physname
;
795 struct bound_minimal_symbol msym
;
797 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
799 /* Handle both the mangled and demangled PHYSNAME. */
800 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
801 if (msym
.minsym
== NULL
)
803 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
804 throw_error (NO_ENTRY_VALUE_ERROR
,
805 _("Cannot find function \"%s\" for a call site target "
807 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
808 (msym
.minsym
== NULL
? "???"
809 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
812 return BMSYMBOL_VALUE_ADDRESS (msym
);
815 case FIELD_LOC_KIND_PHYSADDR
:
816 return FIELD_STATIC_PHYSADDR (call_site
->target
);
819 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
823 /* Convert function entry point exact address ADDR to the function which is
824 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
825 NO_ENTRY_VALUE_ERROR otherwise. */
827 static struct symbol
*
828 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
830 struct symbol
*sym
= find_pc_function (addr
);
833 if (sym
== NULL
|| BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
834 throw_error (NO_ENTRY_VALUE_ERROR
,
835 _("DW_TAG_call_site resolving failed to find function "
836 "name for address %s"),
837 paddress (gdbarch
, addr
));
839 type
= SYMBOL_TYPE (sym
);
840 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
841 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
846 /* Verify function with entry point exact address ADDR can never call itself
847 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
848 can call itself via tail calls.
850 If a funtion can tail call itself its entry value based parameters are
851 unreliable. There is no verification whether the value of some/all
852 parameters is unchanged through the self tail call, we expect if there is
853 a self tail call all the parameters can be modified. */
856 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
860 /* The verification is completely unordered. Track here function addresses
861 which still need to be iterated. */
862 std::vector
<CORE_ADDR
> todo
;
864 /* Track here CORE_ADDRs which were already visited. */
865 std::unordered_set
<CORE_ADDR
> addr_hash
;
867 todo
.push_back (verify_addr
);
868 while (!todo
.empty ())
870 struct symbol
*func_sym
;
871 struct call_site
*call_site
;
876 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
878 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
879 call_site
; call_site
= call_site
->tail_call_next
)
881 CORE_ADDR target_addr
;
883 /* CALLER_FRAME with registers is not available for tail-call jumped
885 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
887 if (target_addr
== verify_addr
)
889 struct bound_minimal_symbol msym
;
891 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
892 throw_error (NO_ENTRY_VALUE_ERROR
,
893 _("DW_OP_entry_value resolving has found "
894 "function \"%s\" at %s can call itself via tail "
896 (msym
.minsym
== NULL
? "???"
897 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
898 paddress (gdbarch
, verify_addr
));
901 if (addr_hash
.insert (target_addr
).second
)
902 todo
.push_back (target_addr
);
907 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
908 ENTRY_VALUES_DEBUG. */
911 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
913 CORE_ADDR addr
= call_site
->pc
;
914 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
916 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
917 (msym
.minsym
== NULL
? "???"
918 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
922 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
923 only top callers and bottom callees which are present in both. GDBARCH is
924 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
925 no remaining possibilities to provide unambiguous non-trivial result.
926 RESULTP should point to NULL on the first (initialization) call. Caller is
927 responsible for xfree of any RESULTP data. */
930 chain_candidate (struct gdbarch
*gdbarch
,
931 gdb::unique_xmalloc_ptr
<struct call_site_chain
> *resultp
,
932 std::vector
<struct call_site
*> *chain
)
934 long length
= chain
->size ();
935 int callers
, callees
, idx
;
937 if (*resultp
== NULL
)
939 /* Create the initial chain containing all the passed PCs. */
941 struct call_site_chain
*result
942 = ((struct call_site_chain
*)
943 xmalloc (sizeof (*result
)
944 + sizeof (*result
->call_site
) * (length
- 1)));
945 result
->length
= length
;
946 result
->callers
= result
->callees
= length
;
947 if (!chain
->empty ())
948 memcpy (result
->call_site
, chain
->data (),
949 sizeof (*result
->call_site
) * length
);
950 resultp
->reset (result
);
952 if (entry_values_debug
)
954 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
955 for (idx
= 0; idx
< length
; idx
++)
956 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
957 fputc_unfiltered ('\n', gdb_stdlog
);
963 if (entry_values_debug
)
965 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
966 for (idx
= 0; idx
< length
; idx
++)
967 tailcall_dump (gdbarch
, chain
->at (idx
));
968 fputc_unfiltered ('\n', gdb_stdlog
);
971 /* Intersect callers. */
973 callers
= std::min ((long) (*resultp
)->callers
, length
);
974 for (idx
= 0; idx
< callers
; idx
++)
975 if ((*resultp
)->call_site
[idx
] != chain
->at (idx
))
977 (*resultp
)->callers
= idx
;
981 /* Intersect callees. */
983 callees
= std::min ((long) (*resultp
)->callees
, length
);
984 for (idx
= 0; idx
< callees
; idx
++)
985 if ((*resultp
)->call_site
[(*resultp
)->length
- 1 - idx
]
986 != chain
->at (length
- 1 - idx
))
988 (*resultp
)->callees
= idx
;
992 if (entry_values_debug
)
994 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
995 for (idx
= 0; idx
< (*resultp
)->callers
; idx
++)
996 tailcall_dump (gdbarch
, (*resultp
)->call_site
[idx
]);
997 fputs_unfiltered (" |", gdb_stdlog
);
998 for (idx
= 0; idx
< (*resultp
)->callees
; idx
++)
999 tailcall_dump (gdbarch
,
1000 (*resultp
)->call_site
[(*resultp
)->length
1001 - (*resultp
)->callees
+ idx
]);
1002 fputc_unfiltered ('\n', gdb_stdlog
);
1005 if ((*resultp
)->callers
== 0 && (*resultp
)->callees
== 0)
1007 /* There are no common callers or callees. It could be also a direct
1008 call (which has length 0) with ambiguous possibility of an indirect
1009 call - CALLERS == CALLEES == 0 is valid during the first allocation
1010 but any subsequence processing of such entry means ambiguity. */
1011 resultp
->reset (NULL
);
1015 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
1016 PC again. In such case there must be two different code paths to reach
1017 it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
1018 gdb_assert ((*resultp
)->callers
+ (*resultp
)->callees
<= (*resultp
)->length
);
1021 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1022 assumed frames between them use GDBARCH. Use depth first search so we can
1023 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
1024 would have needless GDB stack overhead. Caller is responsible for xfree of
1025 the returned result. Any unreliability results in thrown
1026 NO_ENTRY_VALUE_ERROR. */
1028 static struct call_site_chain
*
1029 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1030 CORE_ADDR callee_pc
)
1032 CORE_ADDR save_callee_pc
= callee_pc
;
1033 gdb::unique_xmalloc_ptr
<struct call_site_chain
> retval
;
1034 struct call_site
*call_site
;
1036 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
1037 call_site nor any possible call_site at CALLEE_PC's function is there.
1038 Any CALL_SITE in CHAIN will be iterated to its siblings - via
1039 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
1040 std::vector
<struct call_site
*> chain
;
1042 /* We are not interested in the specific PC inside the callee function. */
1043 callee_pc
= get_pc_function_start (callee_pc
);
1045 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
1046 paddress (gdbarch
, save_callee_pc
));
1048 /* Mark CALL_SITEs so we do not visit the same ones twice. */
1049 std::unordered_set
<CORE_ADDR
> addr_hash
;
1051 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
1052 at the target's function. All the possible tail call sites in the
1053 target's function will get iterated as already pushed into CHAIN via their
1055 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1059 CORE_ADDR target_func_addr
;
1060 struct call_site
*target_call_site
;
1062 /* CALLER_FRAME with registers is not available for tail-call jumped
1064 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
1066 if (target_func_addr
== callee_pc
)
1068 chain_candidate (gdbarch
, &retval
, &chain
);
1072 /* There is no way to reach CALLEE_PC again as we would prevent
1073 entering it twice as being already marked in ADDR_HASH. */
1074 target_call_site
= NULL
;
1078 struct symbol
*target_func
;
1080 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
1081 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
1086 /* Attempt to visit TARGET_CALL_SITE. */
1088 if (target_call_site
)
1090 if (addr_hash
.insert (target_call_site
->pc
).second
)
1092 /* Successfully entered TARGET_CALL_SITE. */
1094 chain
.push_back (target_call_site
);
1099 /* Backtrack (without revisiting the originating call_site). Try the
1100 callers's sibling; if there isn't any try the callers's callers's
1103 target_call_site
= NULL
;
1104 while (!chain
.empty ())
1106 call_site
= chain
.back ();
1109 size_t removed
= addr_hash
.erase (call_site
->pc
);
1110 gdb_assert (removed
== 1);
1112 target_call_site
= call_site
->tail_call_next
;
1113 if (target_call_site
)
1117 while (target_call_site
);
1122 call_site
= chain
.back ();
1127 struct bound_minimal_symbol msym_caller
, msym_callee
;
1129 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
1130 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
1131 throw_error (NO_ENTRY_VALUE_ERROR
,
1132 _("There are no unambiguously determinable intermediate "
1133 "callers or callees between caller function \"%s\" at %s "
1134 "and callee function \"%s\" at %s"),
1135 (msym_caller
.minsym
== NULL
1136 ? "???" : MSYMBOL_PRINT_NAME (msym_caller
.minsym
)),
1137 paddress (gdbarch
, caller_pc
),
1138 (msym_callee
.minsym
== NULL
1139 ? "???" : MSYMBOL_PRINT_NAME (msym_callee
.minsym
)),
1140 paddress (gdbarch
, callee_pc
));
1143 return retval
.release ();
1146 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1147 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
1148 constructed return NULL. Caller is responsible for xfree of the returned
1151 struct call_site_chain
*
1152 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1153 CORE_ADDR callee_pc
)
1155 struct call_site_chain
*retval
= NULL
;
1159 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
1161 CATCH (e
, RETURN_MASK_ERROR
)
1163 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
1165 if (entry_values_debug
)
1166 exception_print (gdb_stdout
, e
);
1171 throw_exception (e
);
1178 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1181 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1182 enum call_site_parameter_kind kind
,
1183 union call_site_parameter_u kind_u
)
1185 if (kind
== parameter
->kind
)
1188 case CALL_SITE_PARAMETER_DWARF_REG
:
1189 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1190 case CALL_SITE_PARAMETER_FB_OFFSET
:
1191 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1192 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1193 return kind_u
.param_offset
.cu_off
== parameter
->u
.param_offset
.cu_off
;
1198 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1199 FRAME is for callee.
1201 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1204 static struct call_site_parameter
*
1205 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1206 enum call_site_parameter_kind kind
,
1207 union call_site_parameter_u kind_u
,
1208 struct dwarf2_per_cu_data
**per_cu_return
)
1210 CORE_ADDR func_addr
, caller_pc
;
1211 struct gdbarch
*gdbarch
;
1212 struct frame_info
*caller_frame
;
1213 struct call_site
*call_site
;
1215 /* Initialize it just to avoid a GCC false warning. */
1216 struct call_site_parameter
*parameter
= NULL
;
1217 CORE_ADDR target_addr
;
1219 while (get_frame_type (frame
) == INLINE_FRAME
)
1221 frame
= get_prev_frame (frame
);
1222 gdb_assert (frame
!= NULL
);
1225 func_addr
= get_frame_func (frame
);
1226 gdbarch
= get_frame_arch (frame
);
1227 caller_frame
= get_prev_frame (frame
);
1228 if (gdbarch
!= frame_unwind_arch (frame
))
1230 struct bound_minimal_symbol msym
1231 = lookup_minimal_symbol_by_pc (func_addr
);
1232 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1234 throw_error (NO_ENTRY_VALUE_ERROR
,
1235 _("DW_OP_entry_value resolving callee gdbarch %s "
1236 "(of %s (%s)) does not match caller gdbarch %s"),
1237 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1238 paddress (gdbarch
, func_addr
),
1239 (msym
.minsym
== NULL
? "???"
1240 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
1241 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1244 if (caller_frame
== NULL
)
1246 struct bound_minimal_symbol msym
1247 = lookup_minimal_symbol_by_pc (func_addr
);
1249 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_entry_value resolving "
1250 "requires caller of %s (%s)"),
1251 paddress (gdbarch
, func_addr
),
1252 (msym
.minsym
== NULL
? "???"
1253 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
1255 caller_pc
= get_frame_pc (caller_frame
);
1256 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1258 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1259 if (target_addr
!= func_addr
)
1261 struct minimal_symbol
*target_msym
, *func_msym
;
1263 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1264 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1265 throw_error (NO_ENTRY_VALUE_ERROR
,
1266 _("DW_OP_entry_value resolving expects callee %s at %s "
1267 "but the called frame is for %s at %s"),
1268 (target_msym
== NULL
? "???"
1269 : MSYMBOL_PRINT_NAME (target_msym
)),
1270 paddress (gdbarch
, target_addr
),
1271 func_msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (func_msym
),
1272 paddress (gdbarch
, func_addr
));
1275 /* No entry value based parameters would be reliable if this function can
1276 call itself via tail calls. */
1277 func_verify_no_selftailcall (gdbarch
, func_addr
);
1279 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1281 parameter
= &call_site
->parameter
[iparams
];
1282 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1285 if (iparams
== call_site
->parameter_count
)
1287 struct minimal_symbol
*msym
1288 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1290 /* DW_TAG_call_site_parameter will be missing just if GCC could not
1291 determine its value. */
1292 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1293 "at DW_TAG_call_site %s at %s"),
1294 paddress (gdbarch
, caller_pc
),
1295 msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (msym
));
1298 *per_cu_return
= call_site
->per_cu
;
1302 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1303 the normal DW_AT_call_value block. Otherwise return the
1304 DW_AT_call_data_value (dereferenced) block.
1306 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1309 Function always returns non-NULL, non-optimized out value. It throws
1310 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1312 static struct value
*
1313 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1314 CORE_ADDR deref_size
, struct type
*type
,
1315 struct frame_info
*caller_frame
,
1316 struct dwarf2_per_cu_data
*per_cu
)
1318 const gdb_byte
*data_src
;
1322 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1323 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1325 /* DEREF_SIZE size is not verified here. */
1326 if (data_src
== NULL
)
1327 throw_error (NO_ENTRY_VALUE_ERROR
,
1328 _("Cannot resolve DW_AT_call_data_value"));
1330 /* DW_AT_call_value is a DWARF expression, not a DWARF
1331 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1333 data
= (gdb_byte
*) alloca (size
+ 1);
1334 memcpy (data
, data_src
, size
);
1335 data
[size
] = DW_OP_stack_value
;
1337 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1340 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1341 the indirect method on it, that is use its stored target value, the sole
1342 purpose of entry_data_value_funcs.. */
1344 static struct value
*
1345 entry_data_value_coerce_ref (const struct value
*value
)
1347 struct type
*checked_type
= check_typedef (value_type (value
));
1348 struct value
*target_val
;
1350 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
)
1353 target_val
= (struct value
*) value_computed_closure (value
);
1354 value_incref (target_val
);
1358 /* Implement copy_closure. */
1361 entry_data_value_copy_closure (const struct value
*v
)
1363 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1365 value_incref (target_val
);
1369 /* Implement free_closure. */
1372 entry_data_value_free_closure (struct value
*v
)
1374 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1376 value_free (target_val
);
1379 /* Vector for methods for an entry value reference where the referenced value
1380 is stored in the caller. On the first dereference use
1381 DW_AT_call_data_value in the caller. */
1383 static const struct lval_funcs entry_data_value_funcs
=
1387 NULL
, /* indirect */
1388 entry_data_value_coerce_ref
,
1389 NULL
, /* check_synthetic_pointer */
1390 entry_data_value_copy_closure
,
1391 entry_data_value_free_closure
1394 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1395 are used to match DW_AT_location at the caller's
1396 DW_TAG_call_site_parameter.
1398 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1399 cannot resolve the parameter for any reason. */
1401 static struct value
*
1402 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1403 enum call_site_parameter_kind kind
,
1404 union call_site_parameter_u kind_u
)
1406 struct type
*checked_type
= check_typedef (type
);
1407 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1408 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1409 struct value
*outer_val
, *target_val
, *val
;
1410 struct call_site_parameter
*parameter
;
1411 struct dwarf2_per_cu_data
*caller_per_cu
;
1413 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1416 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1420 /* Check if DW_AT_call_data_value cannot be used. If it should be
1421 used and it is not available do not fall back to OUTER_VAL - dereferencing
1422 TYPE_CODE_REF with non-entry data value would give current value - not the
1425 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
1426 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1429 target_val
= dwarf_entry_parameter_to_value (parameter
,
1430 TYPE_LENGTH (target_type
),
1431 target_type
, caller_frame
,
1434 release_value (target_val
);
1435 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1436 target_val
/* closure */);
1438 /* Copy the referencing pointer to the new computed value. */
1439 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1440 TYPE_LENGTH (checked_type
));
1441 set_value_lazy (val
, 0);
1446 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1447 SIZE are DWARF block used to match DW_AT_location at the caller's
1448 DW_TAG_call_site_parameter.
1450 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1451 cannot resolve the parameter for any reason. */
1453 static struct value
*
1454 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1455 const gdb_byte
*block
, size_t block_len
)
1457 union call_site_parameter_u kind_u
;
1459 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1460 if (kind_u
.dwarf_reg
!= -1)
1461 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1464 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1465 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1468 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1469 suppressed during normal operation. The expression can be arbitrary if
1470 there is no caller-callee entry value binding expected. */
1471 throw_error (NO_ENTRY_VALUE_ERROR
,
1472 _("DWARF-2 expression error: DW_OP_entry_value is supported "
1473 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1476 struct piece_closure
1478 /* Reference count. */
1481 /* The CU from which this closure's expression came. */
1482 struct dwarf2_per_cu_data
*per_cu
;
1484 /* The number of pieces used to describe this variable. */
1487 /* The target address size, used only for DWARF_VALUE_STACK. */
1490 /* The pieces themselves. */
1491 struct dwarf_expr_piece
*pieces
;
1493 /* Frame ID of frame to which a register value is relative, used
1494 only by DWARF_VALUE_REGISTER. */
1495 struct frame_id frame_id
;
1498 /* Allocate a closure for a value formed from separately-described
1501 static struct piece_closure
*
1502 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1503 int n_pieces
, struct dwarf_expr_piece
*pieces
,
1504 int addr_size
, struct frame_info
*frame
)
1506 struct piece_closure
*c
= XCNEW (struct piece_closure
);
1511 c
->n_pieces
= n_pieces
;
1512 c
->addr_size
= addr_size
;
1513 c
->pieces
= XCNEWVEC (struct dwarf_expr_piece
, n_pieces
);
1515 c
->frame_id
= null_frame_id
;
1517 c
->frame_id
= get_frame_id (frame
);
1519 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
1520 for (i
= 0; i
< n_pieces
; ++i
)
1521 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1522 value_incref (c
->pieces
[i
].v
.value
);
1527 /* Copy NBITS bits from SOURCE to DEST starting at the given bit
1528 offsets. Use the bit order as specified by BITS_BIG_ENDIAN.
1529 Source and destination buffers must not overlap. */
1532 copy_bitwise (gdb_byte
*dest
, ULONGEST dest_offset
,
1533 const gdb_byte
*source
, ULONGEST source_offset
,
1534 ULONGEST nbits
, int bits_big_endian
)
1536 unsigned int buf
, avail
;
1541 if (bits_big_endian
)
1543 /* Start from the end, then work backwards. */
1544 dest_offset
+= nbits
- 1;
1545 dest
+= dest_offset
/ 8;
1546 dest_offset
= 7 - dest_offset
% 8;
1547 source_offset
+= nbits
- 1;
1548 source
+= source_offset
/ 8;
1549 source_offset
= 7 - source_offset
% 8;
1553 dest
+= dest_offset
/ 8;
1555 source
+= source_offset
/ 8;
1559 /* Fill BUF with DEST_OFFSET bits from the destination and 8 -
1560 SOURCE_OFFSET bits from the source. */
1561 buf
= *(bits_big_endian
? source
-- : source
++) >> source_offset
;
1562 buf
<<= dest_offset
;
1563 buf
|= *dest
& ((1 << dest_offset
) - 1);
1565 /* NBITS: bits yet to be written; AVAIL: BUF's fill level. */
1566 nbits
+= dest_offset
;
1567 avail
= dest_offset
+ 8 - source_offset
;
1569 /* Flush 8 bits from BUF, if appropriate. */
1570 if (nbits
>= 8 && avail
>= 8)
1572 *(bits_big_endian
? dest
-- : dest
++) = buf
;
1578 /* Copy the middle part. */
1581 size_t len
= nbits
/ 8;
1583 /* Use a faster method for byte-aligned copies. */
1586 if (bits_big_endian
)
1590 memcpy (dest
+ 1, source
+ 1, len
);
1594 memcpy (dest
, source
, len
);
1603 buf
|= *(bits_big_endian
? source
-- : source
++) << avail
;
1604 *(bits_big_endian
? dest
-- : dest
++) = buf
;
1611 /* Write the last byte. */
1615 buf
|= *source
<< avail
;
1617 buf
&= (1 << nbits
) - 1;
1618 *dest
= (*dest
& (~0 << nbits
)) | buf
;
1624 namespace selftests
{
1626 /* Helper function for the unit test of copy_bitwise. Convert NBITS bits
1627 out of BITS, starting at OFFS, to the respective '0'/'1'-string. MSB0
1628 specifies whether to assume big endian bit numbering. Store the
1629 resulting (not null-terminated) string at STR. */
1632 bits_to_str (char *str
, const gdb_byte
*bits
, ULONGEST offs
,
1633 ULONGEST nbits
, int msb0
)
1638 for (i
= offs
/ 8, j
= offs
% 8; nbits
; i
++, j
= 0)
1640 unsigned int ch
= bits
[i
];
1641 for (; j
< 8 && nbits
; j
++, nbits
--)
1642 *str
++ = (ch
& (msb0
? (1 << (7 - j
)) : (1 << j
))) ? '1' : '0';
1646 /* Check one invocation of copy_bitwise with the given parameters. */
1649 check_copy_bitwise (const gdb_byte
*dest
, unsigned int dest_offset
,
1650 const gdb_byte
*source
, unsigned int source_offset
,
1651 unsigned int nbits
, int msb0
)
1653 size_t len
= align_up (dest_offset
+ nbits
, 8);
1654 char *expected
= (char *) alloca (len
+ 1);
1655 char *actual
= (char *) alloca (len
+ 1);
1656 gdb_byte
*buf
= (gdb_byte
*) alloca (len
/ 8);
1658 /* Compose a '0'/'1'-string that represents the expected result of
1660 Bits from [0, DEST_OFFSET) are filled from DEST.
1661 Bits from [DEST_OFFSET, DEST_OFFSET + NBITS) are filled from SOURCE.
1662 Bits from [DEST_OFFSET + NBITS, LEN) are filled from DEST.
1671 We should end up with:
1673 DDDDSSDD (D=dest, S=source)
1675 bits_to_str (expected
, dest
, 0, len
, msb0
);
1676 bits_to_str (expected
+ dest_offset
, source
, source_offset
, nbits
, msb0
);
1678 /* Fill BUF with data from DEST, apply copy_bitwise, and convert the
1679 result to a '0'/'1'-string. */
1680 memcpy (buf
, dest
, len
/ 8);
1681 copy_bitwise (buf
, dest_offset
, source
, source_offset
, nbits
, msb0
);
1682 bits_to_str (actual
, buf
, 0, len
, msb0
);
1684 /* Compare the resulting strings. */
1685 expected
[len
] = actual
[len
] = '\0';
1686 if (strcmp (expected
, actual
) != 0)
1687 error (_("copy_bitwise %s != %s (%u+%u -> %u)"),
1688 expected
, actual
, source_offset
, nbits
, dest_offset
);
1691 /* Unit test for copy_bitwise. */
1694 copy_bitwise_tests (void)
1696 /* Data to be used as both source and destination buffers. The two
1697 arrays below represent the lsb0- and msb0- encoded versions of the
1698 following bit string, respectively:
1699 00000000 00011111 11111111 01001000 10100101 11110010
1700 This pattern is chosen such that it contains:
1701 - constant 0- and 1- chunks of more than a full byte;
1702 - 0/1- and 1/0 transitions on all bit positions within a byte;
1703 - several sufficiently asymmetric bytes.
1705 static const gdb_byte data_lsb0
[] = {
1706 0x00, 0xf8, 0xff, 0x12, 0xa5, 0x4f
1708 static const gdb_byte data_msb0
[] = {
1709 0x00, 0x1f, 0xff, 0x48, 0xa5, 0xf2
1712 constexpr size_t data_nbits
= 8 * sizeof (data_lsb0
);
1713 constexpr unsigned max_nbits
= 24;
1715 /* Try all combinations of:
1716 lsb0/msb0 bit order (using the respective data array)
1717 X [0, MAX_NBITS] copy bit width
1718 X feasible source offsets for the given copy bit width
1719 X feasible destination offsets
1721 for (int msb0
= 0; msb0
< 2; msb0
++)
1723 const gdb_byte
*data
= msb0
? data_msb0
: data_lsb0
;
1725 for (unsigned int nbits
= 1; nbits
<= max_nbits
; nbits
++)
1727 const unsigned int max_offset
= data_nbits
- nbits
;
1729 for (unsigned source_offset
= 0;
1730 source_offset
<= max_offset
;
1733 for (unsigned dest_offset
= 0;
1734 dest_offset
<= max_offset
;
1737 check_copy_bitwise (data
+ dest_offset
/ 8,
1739 data
+ source_offset
/ 8,
1746 /* Special cases: copy all, copy nothing. */
1747 check_copy_bitwise (data_lsb0
, 0, data_msb0
, 0, data_nbits
, msb0
);
1748 check_copy_bitwise (data_msb0
, 0, data_lsb0
, 0, data_nbits
, msb0
);
1749 check_copy_bitwise (data
, data_nbits
- 7, data
, 9, 0, msb0
);
1753 } /* namespace selftests */
1755 #endif /* GDB_SELF_TEST */
1758 read_pieced_value (struct value
*v
)
1762 ULONGEST bits_to_skip
;
1764 struct piece_closure
*c
1765 = (struct piece_closure
*) value_computed_closure (v
);
1767 size_t buffer_size
= 0;
1768 std::vector
<gdb_byte
> buffer
;
1770 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1772 if (value_type (v
) != value_enclosing_type (v
))
1773 internal_error (__FILE__
, __LINE__
,
1774 _("Should not be able to create a lazy value with "
1775 "an enclosing type"));
1777 contents
= value_contents_raw (v
);
1778 bits_to_skip
= 8 * value_offset (v
);
1779 if (value_bitsize (v
))
1781 bits_to_skip
+= value_bitpos (v
);
1782 type_len
= value_bitsize (v
);
1785 type_len
= 8 * TYPE_LENGTH (value_type (v
));
1787 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1789 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1790 size_t this_size
, this_size_bits
;
1791 long dest_offset_bits
, source_offset_bits
, source_offset
;
1792 const gdb_byte
*intermediate_buffer
;
1794 /* Compute size, source, and destination offsets for copying, in
1796 this_size_bits
= p
->size
;
1797 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1799 bits_to_skip
-= this_size_bits
;
1802 if (bits_to_skip
> 0)
1804 dest_offset_bits
= 0;
1805 source_offset_bits
= bits_to_skip
;
1806 this_size_bits
-= bits_to_skip
;
1811 dest_offset_bits
= offset
;
1812 source_offset_bits
= 0;
1814 if (this_size_bits
> type_len
- offset
)
1815 this_size_bits
= type_len
- offset
;
1817 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1818 source_offset
= source_offset_bits
/ 8;
1819 if (buffer_size
< this_size
)
1821 buffer_size
= this_size
;
1822 buffer
.reserve (buffer_size
);
1824 intermediate_buffer
= buffer
.data ();
1826 /* Copy from the source to DEST_BUFFER. */
1827 switch (p
->location
)
1829 case DWARF_VALUE_REGISTER
:
1831 struct frame_info
*frame
= frame_find_by_id (c
->frame_id
);
1832 struct gdbarch
*arch
= get_frame_arch (frame
);
1833 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, p
->v
.regno
);
1835 LONGEST reg_offset
= source_offset
;
1837 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1838 && this_size
< register_size (arch
, gdb_regnum
))
1840 /* Big-endian, and we want less than full size. */
1841 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1842 /* We want the lower-order THIS_SIZE_BITS of the bytes
1843 we extract from the register. */
1844 source_offset_bits
+= 8 * this_size
- this_size_bits
;
1847 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1848 this_size
, buffer
.data (),
1851 /* Just so garbage doesn't ever shine through. */
1852 memset (buffer
.data (), 0, this_size
);
1855 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1857 mark_value_bits_unavailable (v
, offset
, this_size_bits
);
1862 case DWARF_VALUE_MEMORY
:
1863 read_value_memory (v
, offset
,
1864 p
->v
.mem
.in_stack_memory
,
1865 p
->v
.mem
.addr
+ source_offset
,
1866 buffer
.data (), this_size
);
1869 case DWARF_VALUE_STACK
:
1871 size_t n
= this_size
;
1873 if (n
> c
->addr_size
- source_offset
)
1874 n
= (c
->addr_size
>= source_offset
1875 ? c
->addr_size
- source_offset
1883 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
1885 intermediate_buffer
= val_bytes
+ source_offset
;
1890 case DWARF_VALUE_LITERAL
:
1892 size_t n
= this_size
;
1894 if (n
> p
->v
.literal
.length
- source_offset
)
1895 n
= (p
->v
.literal
.length
>= source_offset
1896 ? p
->v
.literal
.length
- source_offset
1899 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
1903 /* These bits show up as zeros -- but do not cause the value
1904 to be considered optimized-out. */
1905 case DWARF_VALUE_IMPLICIT_POINTER
:
1908 case DWARF_VALUE_OPTIMIZED_OUT
:
1909 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1913 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1916 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
1917 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1918 copy_bitwise (contents
, dest_offset_bits
,
1919 intermediate_buffer
, source_offset_bits
% 8,
1920 this_size_bits
, bits_big_endian
);
1922 offset
+= this_size_bits
;
1927 write_pieced_value (struct value
*to
, struct value
*from
)
1931 ULONGEST bits_to_skip
;
1932 const gdb_byte
*contents
;
1933 struct piece_closure
*c
1934 = (struct piece_closure
*) value_computed_closure (to
);
1936 size_t buffer_size
= 0;
1937 std::vector
<gdb_byte
> buffer
;
1939 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
1941 contents
= value_contents (from
);
1942 bits_to_skip
= 8 * value_offset (to
);
1943 if (value_bitsize (to
))
1945 bits_to_skip
+= value_bitpos (to
);
1946 type_len
= value_bitsize (to
);
1949 type_len
= 8 * TYPE_LENGTH (value_type (to
));
1951 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1953 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1954 size_t this_size_bits
, this_size
;
1955 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
1957 const gdb_byte
*source_buffer
;
1959 this_size_bits
= p
->size
;
1960 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1962 bits_to_skip
-= this_size_bits
;
1965 if (this_size_bits
> type_len
- offset
)
1966 this_size_bits
= type_len
- offset
;
1967 if (bits_to_skip
> 0)
1969 dest_offset_bits
= bits_to_skip
;
1970 source_offset_bits
= 0;
1971 this_size_bits
-= bits_to_skip
;
1976 dest_offset_bits
= 0;
1977 source_offset_bits
= offset
;
1980 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1981 source_offset
= source_offset_bits
/ 8;
1982 dest_offset
= dest_offset_bits
/ 8;
1983 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
1985 source_buffer
= contents
+ source_offset
;
1990 if (buffer_size
< this_size
)
1992 buffer_size
= this_size
;
1993 buffer
.reserve (buffer_size
);
1995 source_buffer
= buffer
.data ();
1999 switch (p
->location
)
2001 case DWARF_VALUE_REGISTER
:
2003 struct frame_info
*frame
= frame_find_by_id (c
->frame_id
);
2004 struct gdbarch
*arch
= get_frame_arch (frame
);
2005 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, p
->v
.regno
);
2006 int reg_offset
= dest_offset
;
2008 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
2009 && this_size
<= register_size (arch
, gdb_regnum
))
2011 /* Big-endian, and we want less than full size. */
2012 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
2019 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
2020 this_size
, buffer
.data (),
2024 throw_error (OPTIMIZED_OUT_ERROR
,
2025 _("Can't do read-modify-write to "
2026 "update bitfield; containing word "
2027 "has been optimized out"));
2029 throw_error (NOT_AVAILABLE_ERROR
,
2030 _("Can't do read-modify-write to update "
2031 "bitfield; containing word "
2034 copy_bitwise (buffer
.data (), dest_offset_bits
,
2035 contents
, source_offset_bits
,
2040 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
2041 this_size
, source_buffer
);
2044 case DWARF_VALUE_MEMORY
:
2047 /* Only the first and last bytes can possibly have any
2049 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
.data (), 1);
2050 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
2051 &buffer
[this_size
- 1], 1);
2052 copy_bitwise (buffer
.data (), dest_offset_bits
,
2053 contents
, source_offset_bits
,
2058 write_memory (p
->v
.mem
.addr
+ dest_offset
,
2059 source_buffer
, this_size
);
2062 mark_value_bytes_optimized_out (to
, 0, TYPE_LENGTH (value_type (to
)));
2065 offset
+= this_size_bits
;
2069 /* An implementation of an lval_funcs method to see whether a value is
2070 a synthetic pointer. */
2073 check_pieced_synthetic_pointer (const struct value
*value
, LONGEST bit_offset
,
2076 struct piece_closure
*c
2077 = (struct piece_closure
*) value_computed_closure (value
);
2080 bit_offset
+= 8 * value_offset (value
);
2081 if (value_bitsize (value
))
2082 bit_offset
+= value_bitpos (value
);
2084 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2086 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2087 size_t this_size_bits
= p
->size
;
2091 if (bit_offset
>= this_size_bits
)
2093 bit_offset
-= this_size_bits
;
2097 bit_length
-= this_size_bits
- bit_offset
;
2101 bit_length
-= this_size_bits
;
2103 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2110 /* A wrapper function for get_frame_address_in_block. */
2113 get_frame_address_in_block_wrapper (void *baton
)
2115 return get_frame_address_in_block ((struct frame_info
*) baton
);
2118 /* Fetch a DW_AT_const_value through a synthetic pointer. */
2120 static struct value
*
2121 fetch_const_value_from_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
2122 struct dwarf2_per_cu_data
*per_cu
,
2125 struct value
*result
= NULL
;
2126 struct obstack temp_obstack
;
2127 struct cleanup
*cleanup
;
2128 const gdb_byte
*bytes
;
2131 obstack_init (&temp_obstack
);
2132 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2133 bytes
= dwarf2_fetch_constant_bytes (die
, per_cu
, &temp_obstack
, &len
);
2137 if (byte_offset
>= 0
2138 && byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) <= len
)
2140 bytes
+= byte_offset
;
2141 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
2144 invalid_synthetic_pointer ();
2147 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
2149 do_cleanups (cleanup
);
2154 /* Fetch the value pointed to by a synthetic pointer. */
2156 static struct value
*
2157 indirect_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
2158 struct dwarf2_per_cu_data
*per_cu
,
2159 struct frame_info
*frame
, struct type
*type
)
2161 /* Fetch the location expression of the DIE we're pointing to. */
2162 struct dwarf2_locexpr_baton baton
2163 = dwarf2_fetch_die_loc_sect_off (die
, per_cu
,
2164 get_frame_address_in_block_wrapper
, frame
);
2166 /* If pointed-to DIE has a DW_AT_location, evaluate it and return the
2167 resulting value. Otherwise, it may have a DW_AT_const_value instead,
2168 or it may've been optimized out. */
2169 if (baton
.data
!= NULL
)
2170 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
2171 baton
.data
, baton
.size
, baton
.per_cu
,
2174 return fetch_const_value_from_synthetic_pointer (die
, byte_offset
, per_cu
,
2178 /* An implementation of an lval_funcs method to indirect through a
2179 pointer. This handles the synthetic pointer case when needed. */
2181 static struct value
*
2182 indirect_pieced_value (struct value
*value
)
2184 struct piece_closure
*c
2185 = (struct piece_closure
*) value_computed_closure (value
);
2187 struct frame_info
*frame
;
2188 struct dwarf2_locexpr_baton baton
;
2191 struct dwarf_expr_piece
*piece
= NULL
;
2192 LONGEST byte_offset
;
2193 enum bfd_endian byte_order
;
2195 type
= check_typedef (value_type (value
));
2196 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
2199 bit_length
= 8 * TYPE_LENGTH (type
);
2200 bit_offset
= 8 * value_offset (value
);
2201 if (value_bitsize (value
))
2202 bit_offset
+= value_bitpos (value
);
2204 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2206 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2207 size_t this_size_bits
= p
->size
;
2211 if (bit_offset
>= this_size_bits
)
2213 bit_offset
-= this_size_bits
;
2217 bit_length
-= this_size_bits
- bit_offset
;
2221 bit_length
-= this_size_bits
;
2223 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2226 if (bit_length
!= 0)
2227 error (_("Invalid use of DW_OP_implicit_pointer"));
2233 gdb_assert (piece
!= NULL
);
2234 frame
= get_selected_frame (_("No frame selected."));
2236 /* This is an offset requested by GDB, such as value subscripts.
2237 However, due to how synthetic pointers are implemented, this is
2238 always presented to us as a pointer type. This means we have to
2239 sign-extend it manually as appropriate. Use raw
2240 extract_signed_integer directly rather than value_as_address and
2241 sign extend afterwards on architectures that would need it
2242 (mostly everywhere except MIPS, which has signed addresses) as
2243 the later would go through gdbarch_pointer_to_address and thus
2244 return a CORE_ADDR with high bits set on architectures that
2245 encode address spaces and other things in CORE_ADDR. */
2246 byte_order
= gdbarch_byte_order (get_frame_arch (frame
));
2247 byte_offset
= extract_signed_integer (value_contents (value
),
2248 TYPE_LENGTH (type
), byte_order
);
2249 byte_offset
+= piece
->v
.ptr
.offset
;
2251 return indirect_synthetic_pointer (piece
->v
.ptr
.die
, byte_offset
, c
->per_cu
,
2255 /* Implementation of the coerce_ref method of lval_funcs for synthetic C++
2258 static struct value
*
2259 coerce_pieced_ref (const struct value
*value
)
2261 struct type
*type
= check_typedef (value_type (value
));
2263 if (value_bits_synthetic_pointer (value
, value_embedded_offset (value
),
2264 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
2266 const struct piece_closure
*closure
2267 = (struct piece_closure
*) value_computed_closure (value
);
2268 struct frame_info
*frame
2269 = get_selected_frame (_("No frame selected."));
2271 /* gdb represents synthetic pointers as pieced values with a single
2273 gdb_assert (closure
!= NULL
);
2274 gdb_assert (closure
->n_pieces
== 1);
2276 return indirect_synthetic_pointer (closure
->pieces
->v
.ptr
.die
,
2277 closure
->pieces
->v
.ptr
.offset
,
2278 closure
->per_cu
, frame
, type
);
2282 /* Else: not a synthetic reference; do nothing. */
2288 copy_pieced_value_closure (const struct value
*v
)
2290 struct piece_closure
*c
2291 = (struct piece_closure
*) value_computed_closure (v
);
2298 free_pieced_value_closure (struct value
*v
)
2300 struct piece_closure
*c
2301 = (struct piece_closure
*) value_computed_closure (v
);
2308 for (i
= 0; i
< c
->n_pieces
; ++i
)
2309 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
2310 value_free (c
->pieces
[i
].v
.value
);
2317 /* Functions for accessing a variable described by DW_OP_piece. */
2318 static const struct lval_funcs pieced_value_funcs
= {
2321 indirect_pieced_value
,
2323 check_pieced_synthetic_pointer
,
2324 copy_pieced_value_closure
,
2325 free_pieced_value_closure
2328 /* Evaluate a location description, starting at DATA and with length
2329 SIZE, to find the current location of variable of TYPE in the
2330 context of FRAME. BYTE_OFFSET is applied after the contents are
2333 static struct value
*
2334 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2335 const gdb_byte
*data
, size_t size
,
2336 struct dwarf2_per_cu_data
*per_cu
,
2337 LONGEST byte_offset
)
2339 struct value
*retval
;
2340 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2342 if (byte_offset
< 0)
2343 invalid_synthetic_pointer ();
2346 return allocate_optimized_out_value (type
);
2348 dwarf_evaluate_loc_desc ctx
;
2350 ctx
.per_cu
= per_cu
;
2351 ctx
.obj_address
= 0;
2353 scoped_value_mark free_values
;
2355 ctx
.gdbarch
= get_objfile_arch (objfile
);
2356 ctx
.addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2357 ctx
.ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2358 ctx
.offset
= dwarf2_per_cu_text_offset (per_cu
);
2362 ctx
.eval (data
, size
);
2364 CATCH (ex
, RETURN_MASK_ERROR
)
2366 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2368 free_values
.free_to_mark ();
2369 retval
= allocate_value (type
);
2370 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
2373 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2375 if (entry_values_debug
)
2376 exception_print (gdb_stdout
, ex
);
2377 free_values
.free_to_mark ();
2378 return allocate_optimized_out_value (type
);
2381 throw_exception (ex
);
2385 if (ctx
.num_pieces
> 0)
2387 struct piece_closure
*c
;
2388 ULONGEST bit_size
= 0;
2391 for (i
= 0; i
< ctx
.num_pieces
; ++i
)
2392 bit_size
+= ctx
.pieces
[i
].size
;
2393 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
2394 invalid_synthetic_pointer ();
2396 c
= allocate_piece_closure (per_cu
, ctx
.num_pieces
, ctx
.pieces
,
2397 ctx
.addr_size
, frame
);
2398 /* We must clean up the value chain after creating the piece
2399 closure but before allocating the result. */
2400 free_values
.free_to_mark ();
2401 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
2402 set_value_offset (retval
, byte_offset
);
2406 switch (ctx
.location
)
2408 case DWARF_VALUE_REGISTER
:
2410 struct gdbarch
*arch
= get_frame_arch (frame
);
2412 = longest_to_int (value_as_long (ctx
.fetch (0)));
2413 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, dwarf_regnum
);
2415 if (byte_offset
!= 0)
2416 error (_("cannot use offset on synthetic pointer to register"));
2417 free_values
.free_to_mark ();
2418 retval
= value_from_register (type
, gdb_regnum
, frame
);
2419 if (value_optimized_out (retval
))
2423 /* This means the register has undefined value / was
2424 not saved. As we're computing the location of some
2425 variable etc. in the program, not a value for
2426 inspecting a register ($pc, $sp, etc.), return a
2427 generic optimized out value instead, so that we show
2428 <optimized out> instead of <not saved>. */
2429 tmp
= allocate_value (type
);
2430 value_contents_copy (tmp
, 0, retval
, 0, TYPE_LENGTH (type
));
2436 case DWARF_VALUE_MEMORY
:
2438 struct type
*ptr_type
;
2439 CORE_ADDR address
= ctx
.fetch_address (0);
2440 int in_stack_memory
= ctx
.fetch_in_stack_memory (0);
2442 /* DW_OP_deref_size (and possibly other operations too) may
2443 create a pointer instead of an address. Ideally, the
2444 pointer to address conversion would be performed as part
2445 of those operations, but the type of the object to
2446 which the address refers is not known at the time of
2447 the operation. Therefore, we do the conversion here
2448 since the type is readily available. */
2450 switch (TYPE_CODE (type
))
2452 case TYPE_CODE_FUNC
:
2453 case TYPE_CODE_METHOD
:
2454 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_func_ptr
;
2457 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_data_ptr
;
2460 address
= value_as_address (value_from_pointer (ptr_type
, address
));
2462 free_values
.free_to_mark ();
2463 retval
= value_at_lazy (type
, address
+ byte_offset
);
2464 if (in_stack_memory
)
2465 set_value_stack (retval
, 1);
2469 case DWARF_VALUE_STACK
:
2471 struct value
*value
= ctx
.fetch (0);
2473 const gdb_byte
*val_bytes
;
2474 size_t n
= TYPE_LENGTH (value_type (value
));
2475 struct cleanup
*cleanup
;
2477 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2478 invalid_synthetic_pointer ();
2480 val_bytes
= value_contents_all (value
);
2481 val_bytes
+= byte_offset
;
2484 /* Preserve VALUE because we are going to free values back
2485 to the mark, but we still need the value contents
2487 value_incref (value
);
2488 free_values
.free_to_mark ();
2489 cleanup
= make_cleanup_value_free (value
);
2491 retval
= allocate_value (type
);
2492 contents
= value_contents_raw (retval
);
2493 if (n
> TYPE_LENGTH (type
))
2495 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2497 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2498 val_bytes
+= n
- TYPE_LENGTH (type
);
2499 n
= TYPE_LENGTH (type
);
2501 memcpy (contents
, val_bytes
, n
);
2503 do_cleanups (cleanup
);
2507 case DWARF_VALUE_LITERAL
:
2510 size_t n
= TYPE_LENGTH (type
);
2512 if (byte_offset
+ n
> ctx
.len
)
2513 invalid_synthetic_pointer ();
2515 free_values
.free_to_mark ();
2516 retval
= allocate_value (type
);
2517 contents
= value_contents_raw (retval
);
2518 memcpy (contents
, ctx
.data
+ byte_offset
, n
);
2522 case DWARF_VALUE_OPTIMIZED_OUT
:
2523 free_values
.free_to_mark ();
2524 retval
= allocate_optimized_out_value (type
);
2527 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2528 operation by execute_stack_op. */
2529 case DWARF_VALUE_IMPLICIT_POINTER
:
2530 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2531 it can only be encountered when making a piece. */
2533 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2537 set_value_initialized (retval
, ctx
.initialized
);
2542 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2543 passes 0 as the byte_offset. */
2546 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2547 const gdb_byte
*data
, size_t size
,
2548 struct dwarf2_per_cu_data
*per_cu
)
2550 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
2553 /* Evaluates a dwarf expression and stores the result in VAL, expecting
2554 that the dwarf expression only produces a single CORE_ADDR. FRAME is the
2555 frame in which the expression is evaluated. ADDR is a context (location of
2556 a variable) and might be needed to evaluate the location expression.
2557 Returns 1 on success, 0 otherwise. */
2560 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton
*dlbaton
,
2561 struct frame_info
*frame
,
2565 struct objfile
*objfile
;
2567 if (dlbaton
== NULL
|| dlbaton
->size
== 0)
2570 dwarf_evaluate_loc_desc ctx
;
2573 ctx
.per_cu
= dlbaton
->per_cu
;
2574 ctx
.obj_address
= addr
;
2576 objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2578 ctx
.gdbarch
= get_objfile_arch (objfile
);
2579 ctx
.addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2580 ctx
.ref_addr_size
= dwarf2_per_cu_ref_addr_size (dlbaton
->per_cu
);
2581 ctx
.offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
2583 ctx
.eval (dlbaton
->data
, dlbaton
->size
);
2585 switch (ctx
.location
)
2587 case DWARF_VALUE_REGISTER
:
2588 case DWARF_VALUE_MEMORY
:
2589 case DWARF_VALUE_STACK
:
2590 *valp
= ctx
.fetch_address (0);
2591 if (ctx
.location
== DWARF_VALUE_REGISTER
)
2592 *valp
= ctx
.read_addr_from_reg (*valp
);
2594 case DWARF_VALUE_LITERAL
:
2595 *valp
= extract_signed_integer (ctx
.data
, ctx
.len
,
2596 gdbarch_byte_order (ctx
.gdbarch
));
2598 /* Unsupported dwarf values. */
2599 case DWARF_VALUE_OPTIMIZED_OUT
:
2600 case DWARF_VALUE_IMPLICIT_POINTER
:
2607 /* See dwarf2loc.h. */
2610 dwarf2_evaluate_property (const struct dynamic_prop
*prop
,
2611 struct frame_info
*frame
,
2612 struct property_addr_info
*addr_stack
,
2618 if (frame
== NULL
&& has_stack_frames ())
2619 frame
= get_selected_frame (NULL
);
2625 const struct dwarf2_property_baton
*baton
2626 = (const struct dwarf2_property_baton
*) prop
->data
.baton
;
2628 if (dwarf2_locexpr_baton_eval (&baton
->locexpr
, frame
,
2629 addr_stack
? addr_stack
->addr
: 0,
2632 if (baton
->referenced_type
)
2634 struct value
*val
= value_at (baton
->referenced_type
, *value
);
2636 *value
= value_as_address (val
);
2645 struct dwarf2_property_baton
*baton
2646 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2647 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2648 const gdb_byte
*data
;
2652 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2655 val
= dwarf2_evaluate_loc_desc (baton
->referenced_type
, frame
, data
,
2656 size
, baton
->loclist
.per_cu
);
2657 if (!value_optimized_out (val
))
2659 *value
= value_as_address (val
);
2667 *value
= prop
->data
.const_val
;
2670 case PROP_ADDR_OFFSET
:
2672 struct dwarf2_property_baton
*baton
2673 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2674 struct property_addr_info
*pinfo
;
2677 for (pinfo
= addr_stack
; pinfo
!= NULL
; pinfo
= pinfo
->next
)
2678 if (pinfo
->type
== baton
->referenced_type
)
2681 error (_("cannot find reference address for offset property"));
2682 if (pinfo
->valaddr
!= NULL
)
2683 val
= value_from_contents
2684 (baton
->offset_info
.type
,
2685 pinfo
->valaddr
+ baton
->offset_info
.offset
);
2687 val
= value_at (baton
->offset_info
.type
,
2688 pinfo
->addr
+ baton
->offset_info
.offset
);
2689 *value
= value_as_address (val
);
2697 /* See dwarf2loc.h. */
2700 dwarf2_compile_property_to_c (string_file
&stream
,
2701 const char *result_name
,
2702 struct gdbarch
*gdbarch
,
2703 unsigned char *registers_used
,
2704 const struct dynamic_prop
*prop
,
2708 struct dwarf2_property_baton
*baton
2709 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2710 const gdb_byte
*data
;
2712 struct dwarf2_per_cu_data
*per_cu
;
2714 if (prop
->kind
== PROP_LOCEXPR
)
2716 data
= baton
->locexpr
.data
;
2717 size
= baton
->locexpr
.size
;
2718 per_cu
= baton
->locexpr
.per_cu
;
2722 gdb_assert (prop
->kind
== PROP_LOCLIST
);
2724 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2725 per_cu
= baton
->loclist
.per_cu
;
2728 compile_dwarf_bounds_to_c (stream
, result_name
, prop
, sym
, pc
,
2729 gdbarch
, registers_used
,
2730 dwarf2_per_cu_addr_size (per_cu
),
2731 data
, data
+ size
, per_cu
);
2735 /* Helper functions and baton for dwarf2_loc_desc_get_symbol_read_needs. */
2737 class symbol_needs_eval_context
: public dwarf_expr_context
2741 enum symbol_needs_kind needs
;
2742 struct dwarf2_per_cu_data
*per_cu
;
2744 /* Reads from registers do require a frame. */
2745 CORE_ADDR
read_addr_from_reg (int regnum
) OVERRIDE
2747 needs
= SYMBOL_NEEDS_FRAME
;
2751 /* "get_reg_value" callback: Reads from registers do require a
2754 struct value
*get_reg_value (struct type
*type
, int regnum
) OVERRIDE
2756 needs
= SYMBOL_NEEDS_FRAME
;
2757 return value_zero (type
, not_lval
);
2760 /* Reads from memory do not require a frame. */
2761 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) OVERRIDE
2763 memset (buf
, 0, len
);
2766 /* Frame-relative accesses do require a frame. */
2767 void get_frame_base (const gdb_byte
**start
, size_t *length
) OVERRIDE
2769 static gdb_byte lit0
= DW_OP_lit0
;
2774 needs
= SYMBOL_NEEDS_FRAME
;
2777 /* CFA accesses require a frame. */
2778 CORE_ADDR
get_frame_cfa () OVERRIDE
2780 needs
= SYMBOL_NEEDS_FRAME
;
2784 CORE_ADDR
get_frame_pc () OVERRIDE
2786 needs
= SYMBOL_NEEDS_FRAME
;
2790 /* Thread-local accesses require registers, but not a frame. */
2791 CORE_ADDR
get_tls_address (CORE_ADDR offset
) OVERRIDE
2793 if (needs
<= SYMBOL_NEEDS_REGISTERS
)
2794 needs
= SYMBOL_NEEDS_REGISTERS
;
2798 /* Helper interface of per_cu_dwarf_call for
2799 dwarf2_loc_desc_get_symbol_read_needs. */
2801 void dwarf_call (cu_offset die_offset
) OVERRIDE
2803 per_cu_dwarf_call (this, die_offset
, per_cu
);
2806 /* DW_OP_entry_value accesses require a caller, therefore a
2809 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
2810 union call_site_parameter_u kind_u
,
2811 int deref_size
) OVERRIDE
2813 needs
= SYMBOL_NEEDS_FRAME
;
2815 /* The expression may require some stub values on DWARF stack. */
2816 push_address (0, 0);
2819 /* DW_OP_GNU_addr_index doesn't require a frame. */
2821 CORE_ADDR
get_addr_index (unsigned int index
) OVERRIDE
2823 /* Nothing to do. */
2827 /* DW_OP_push_object_address has a frame already passed through. */
2829 CORE_ADDR
get_object_address () OVERRIDE
2831 /* Nothing to do. */
2836 /* Compute the correct symbol_needs_kind value for the location
2837 expression at DATA (length SIZE). */
2839 static enum symbol_needs_kind
2840 dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte
*data
, size_t size
,
2841 struct dwarf2_per_cu_data
*per_cu
)
2844 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2846 scoped_value_mark free_values
;
2848 symbol_needs_eval_context ctx
;
2850 ctx
.needs
= SYMBOL_NEEDS_NONE
;
2851 ctx
.per_cu
= per_cu
;
2852 ctx
.gdbarch
= get_objfile_arch (objfile
);
2853 ctx
.addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2854 ctx
.ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2855 ctx
.offset
= dwarf2_per_cu_text_offset (per_cu
);
2857 ctx
.eval (data
, size
);
2859 in_reg
= ctx
.location
== DWARF_VALUE_REGISTER
;
2861 if (ctx
.num_pieces
> 0)
2865 /* If the location has several pieces, and any of them are in
2866 registers, then we will need a frame to fetch them from. */
2867 for (i
= 0; i
< ctx
.num_pieces
; i
++)
2868 if (ctx
.pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2873 ctx
.needs
= SYMBOL_NEEDS_FRAME
;
2877 /* A helper function that throws an unimplemented error mentioning a
2878 given DWARF operator. */
2881 unimplemented (unsigned int op
)
2883 const char *name
= get_DW_OP_name (op
);
2886 error (_("DWARF operator %s cannot be translated to an agent expression"),
2889 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2890 "to an agent expression"),
2896 This is basically a wrapper on gdbarch_dwarf2_reg_to_regnum so that we
2897 can issue a complaint, which is better than having every target's
2898 implementation of dwarf2_reg_to_regnum do it. */
2901 dwarf_reg_to_regnum (struct gdbarch
*arch
, int dwarf_reg
)
2903 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2907 complaint (&symfile_complaints
,
2908 _("bad DWARF register number %d"), dwarf_reg
);
2913 /* Subroutine of dwarf_reg_to_regnum_or_error to simplify it.
2914 Throw an error because DWARF_REG is bad. */
2917 throw_bad_regnum_error (ULONGEST dwarf_reg
)
2919 /* Still want to print -1 as "-1".
2920 We *could* have int and ULONGEST versions of dwarf2_reg_to_regnum_or_error
2921 but that's overkill for now. */
2922 if ((int) dwarf_reg
== dwarf_reg
)
2923 error (_("Unable to access DWARF register number %d"), (int) dwarf_reg
);
2924 error (_("Unable to access DWARF register number %s"),
2925 pulongest (dwarf_reg
));
2928 /* See dwarf2loc.h. */
2931 dwarf_reg_to_regnum_or_error (struct gdbarch
*arch
, ULONGEST dwarf_reg
)
2935 if (dwarf_reg
> INT_MAX
)
2936 throw_bad_regnum_error (dwarf_reg
);
2937 /* Yes, we will end up issuing a complaint and an error if DWARF_REG is
2938 bad, but that's ok. */
2939 reg
= dwarf_reg_to_regnum (arch
, (int) dwarf_reg
);
2941 throw_bad_regnum_error (dwarf_reg
);
2945 /* A helper function that emits an access to memory. ARCH is the
2946 target architecture. EXPR is the expression which we are building.
2947 NBITS is the number of bits we want to read. This emits the
2948 opcodes needed to read the memory and then extract the desired
2952 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2954 ULONGEST nbytes
= (nbits
+ 7) / 8;
2956 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2959 ax_trace_quick (expr
, nbytes
);
2962 ax_simple (expr
, aop_ref8
);
2963 else if (nbits
<= 16)
2964 ax_simple (expr
, aop_ref16
);
2965 else if (nbits
<= 32)
2966 ax_simple (expr
, aop_ref32
);
2968 ax_simple (expr
, aop_ref64
);
2970 /* If we read exactly the number of bytes we wanted, we're done. */
2971 if (8 * nbytes
== nbits
)
2974 if (gdbarch_bits_big_endian (arch
))
2976 /* On a bits-big-endian machine, we want the high-order
2978 ax_const_l (expr
, 8 * nbytes
- nbits
);
2979 ax_simple (expr
, aop_rsh_unsigned
);
2983 /* On a bits-little-endian box, we want the low-order NBITS. */
2984 ax_zero_ext (expr
, nbits
);
2988 /* A helper function to return the frame's PC. */
2991 get_ax_pc (void *baton
)
2993 struct agent_expr
*expr
= (struct agent_expr
*) baton
;
2998 /* Compile a DWARF location expression to an agent expression.
3000 EXPR is the agent expression we are building.
3001 LOC is the agent value we modify.
3002 ARCH is the architecture.
3003 ADDR_SIZE is the size of addresses, in bytes.
3004 OP_PTR is the start of the location expression.
3005 OP_END is one past the last byte of the location expression.
3007 This will throw an exception for various kinds of errors -- for
3008 example, if the expression cannot be compiled, or if the expression
3012 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
3013 struct gdbarch
*arch
, unsigned int addr_size
,
3014 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
3015 struct dwarf2_per_cu_data
*per_cu
)
3018 std::vector
<int> dw_labels
, patches
;
3019 const gdb_byte
* const base
= op_ptr
;
3020 const gdb_byte
*previous_piece
= op_ptr
;
3021 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
3022 ULONGEST bits_collected
= 0;
3023 unsigned int addr_size_bits
= 8 * addr_size
;
3024 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
3026 std::vector
<int> offsets (op_end
- op_ptr
, -1);
3028 /* By default we are making an address. */
3029 loc
->kind
= axs_lvalue_memory
;
3031 while (op_ptr
< op_end
)
3033 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
3034 uint64_t uoffset
, reg
;
3038 offsets
[op_ptr
- base
] = expr
->len
;
3041 /* Our basic approach to code generation is to map DWARF
3042 operations directly to AX operations. However, there are
3045 First, DWARF works on address-sized units, but AX always uses
3046 LONGEST. For most operations we simply ignore this
3047 difference; instead we generate sign extensions as needed
3048 before division and comparison operations. It would be nice
3049 to omit the sign extensions, but there is no way to determine
3050 the size of the target's LONGEST. (This code uses the size
3051 of the host LONGEST in some cases -- that is a bug but it is
3054 Second, some DWARF operations cannot be translated to AX.
3055 For these we simply fail. See
3056 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
3091 ax_const_l (expr
, op
- DW_OP_lit0
);
3095 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
3096 op_ptr
+= addr_size
;
3097 /* Some versions of GCC emit DW_OP_addr before
3098 DW_OP_GNU_push_tls_address. In this case the value is an
3099 index, not an address. We don't support things like
3100 branching between the address and the TLS op. */
3101 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
3102 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
3103 ax_const_l (expr
, uoffset
);
3107 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
3111 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
3115 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
3119 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
3123 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
3127 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
3131 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
3135 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
3139 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3140 ax_const_l (expr
, uoffset
);
3143 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3144 ax_const_l (expr
, offset
);
3179 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3180 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_reg0
);
3181 loc
->kind
= axs_lvalue_register
;
3185 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3186 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3187 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3188 loc
->kind
= axs_lvalue_register
;
3191 case DW_OP_implicit_value
:
3195 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
3196 if (op_ptr
+ len
> op_end
)
3197 error (_("DW_OP_implicit_value: too few bytes available."));
3198 if (len
> sizeof (ULONGEST
))
3199 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
3202 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
3205 dwarf_expr_require_composition (op_ptr
, op_end
,
3206 "DW_OP_implicit_value");
3208 loc
->kind
= axs_rvalue
;
3212 case DW_OP_stack_value
:
3213 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
3214 loc
->kind
= axs_rvalue
;
3249 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3250 i
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_breg0
);
3254 ax_const_l (expr
, offset
);
3255 ax_simple (expr
, aop_add
);
3260 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3261 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3262 i
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3266 ax_const_l (expr
, offset
);
3267 ax_simple (expr
, aop_add
);
3273 const gdb_byte
*datastart
;
3275 const struct block
*b
;
3276 struct symbol
*framefunc
;
3278 b
= block_for_pc (expr
->scope
);
3281 error (_("No block found for address"));
3283 framefunc
= block_linkage_function (b
);
3286 error (_("No function found for block"));
3288 func_get_frame_base_dwarf_block (framefunc
, expr
->scope
,
3289 &datastart
, &datalen
);
3291 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3292 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
3293 datastart
+ datalen
, per_cu
);
3294 if (loc
->kind
== axs_lvalue_register
)
3295 require_rvalue (expr
, loc
);
3299 ax_const_l (expr
, offset
);
3300 ax_simple (expr
, aop_add
);
3303 loc
->kind
= axs_lvalue_memory
;
3308 ax_simple (expr
, aop_dup
);
3312 ax_simple (expr
, aop_pop
);
3317 ax_pick (expr
, offset
);
3321 ax_simple (expr
, aop_swap
);
3329 ax_simple (expr
, aop_rot
);
3333 case DW_OP_deref_size
:
3337 if (op
== DW_OP_deref_size
)
3342 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3343 error (_("Unsupported size %d in %s"),
3344 size
, get_DW_OP_name (op
));
3345 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3350 /* Sign extend the operand. */
3351 ax_ext (expr
, addr_size_bits
);
3352 ax_simple (expr
, aop_dup
);
3353 ax_const_l (expr
, 0);
3354 ax_simple (expr
, aop_less_signed
);
3355 ax_simple (expr
, aop_log_not
);
3356 i
= ax_goto (expr
, aop_if_goto
);
3357 /* We have to emit 0 - X. */
3358 ax_const_l (expr
, 0);
3359 ax_simple (expr
, aop_swap
);
3360 ax_simple (expr
, aop_sub
);
3361 ax_label (expr
, i
, expr
->len
);
3365 /* No need to sign extend here. */
3366 ax_const_l (expr
, 0);
3367 ax_simple (expr
, aop_swap
);
3368 ax_simple (expr
, aop_sub
);
3372 /* Sign extend the operand. */
3373 ax_ext (expr
, addr_size_bits
);
3374 ax_simple (expr
, aop_bit_not
);
3377 case DW_OP_plus_uconst
:
3378 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3379 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3380 but we micro-optimize anyhow. */
3383 ax_const_l (expr
, reg
);
3384 ax_simple (expr
, aop_add
);
3389 ax_simple (expr
, aop_bit_and
);
3393 /* Sign extend the operands. */
3394 ax_ext (expr
, addr_size_bits
);
3395 ax_simple (expr
, aop_swap
);
3396 ax_ext (expr
, addr_size_bits
);
3397 ax_simple (expr
, aop_swap
);
3398 ax_simple (expr
, aop_div_signed
);
3402 ax_simple (expr
, aop_sub
);
3406 ax_simple (expr
, aop_rem_unsigned
);
3410 ax_simple (expr
, aop_mul
);
3414 ax_simple (expr
, aop_bit_or
);
3418 ax_simple (expr
, aop_add
);
3422 ax_simple (expr
, aop_lsh
);
3426 ax_simple (expr
, aop_rsh_unsigned
);
3430 ax_simple (expr
, aop_rsh_signed
);
3434 ax_simple (expr
, aop_bit_xor
);
3438 /* Sign extend the operands. */
3439 ax_ext (expr
, addr_size_bits
);
3440 ax_simple (expr
, aop_swap
);
3441 ax_ext (expr
, addr_size_bits
);
3442 /* Note no swap here: A <= B is !(B < A). */
3443 ax_simple (expr
, aop_less_signed
);
3444 ax_simple (expr
, aop_log_not
);
3448 /* Sign extend the operands. */
3449 ax_ext (expr
, addr_size_bits
);
3450 ax_simple (expr
, aop_swap
);
3451 ax_ext (expr
, addr_size_bits
);
3452 ax_simple (expr
, aop_swap
);
3453 /* A >= B is !(A < B). */
3454 ax_simple (expr
, aop_less_signed
);
3455 ax_simple (expr
, aop_log_not
);
3459 /* Sign extend the operands. */
3460 ax_ext (expr
, addr_size_bits
);
3461 ax_simple (expr
, aop_swap
);
3462 ax_ext (expr
, addr_size_bits
);
3463 /* No need for a second swap here. */
3464 ax_simple (expr
, aop_equal
);
3468 /* Sign extend the operands. */
3469 ax_ext (expr
, addr_size_bits
);
3470 ax_simple (expr
, aop_swap
);
3471 ax_ext (expr
, addr_size_bits
);
3472 ax_simple (expr
, aop_swap
);
3473 ax_simple (expr
, aop_less_signed
);
3477 /* Sign extend the operands. */
3478 ax_ext (expr
, addr_size_bits
);
3479 ax_simple (expr
, aop_swap
);
3480 ax_ext (expr
, addr_size_bits
);
3481 /* Note no swap here: A > B is B < A. */
3482 ax_simple (expr
, aop_less_signed
);
3486 /* Sign extend the operands. */
3487 ax_ext (expr
, addr_size_bits
);
3488 ax_simple (expr
, aop_swap
);
3489 ax_ext (expr
, addr_size_bits
);
3490 /* No need for a swap here. */
3491 ax_simple (expr
, aop_equal
);
3492 ax_simple (expr
, aop_log_not
);
3495 case DW_OP_call_frame_cfa
:
3498 CORE_ADDR text_offset
;
3500 const gdb_byte
*cfa_start
, *cfa_end
;
3502 if (dwarf2_fetch_cfa_info (arch
, expr
->scope
, per_cu
,
3504 &text_offset
, &cfa_start
, &cfa_end
))
3507 ax_reg (expr
, regnum
);
3510 ax_const_l (expr
, off
);
3511 ax_simple (expr
, aop_add
);
3516 /* Another expression. */
3517 ax_const_l (expr
, text_offset
);
3518 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3519 cfa_start
, cfa_end
, per_cu
);
3522 loc
->kind
= axs_lvalue_memory
;
3526 case DW_OP_GNU_push_tls_address
:
3527 case DW_OP_form_tls_address
:
3531 case DW_OP_push_object_address
:
3536 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3538 i
= ax_goto (expr
, aop_goto
);
3539 dw_labels
.push_back (op_ptr
+ offset
- base
);
3540 patches
.push_back (i
);
3544 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3546 /* Zero extend the operand. */
3547 ax_zero_ext (expr
, addr_size_bits
);
3548 i
= ax_goto (expr
, aop_if_goto
);
3549 dw_labels
.push_back (op_ptr
+ offset
- base
);
3550 patches
.push_back (i
);
3557 case DW_OP_bit_piece
:
3559 uint64_t size
, offset
;
3561 if (op_ptr
- 1 == previous_piece
)
3562 error (_("Cannot translate empty pieces to agent expressions"));
3563 previous_piece
= op_ptr
- 1;
3565 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3566 if (op
== DW_OP_piece
)
3572 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
3574 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3575 error (_("Expression pieces exceed word size"));
3577 /* Access the bits. */
3580 case axs_lvalue_register
:
3581 ax_reg (expr
, loc
->u
.reg
);
3584 case axs_lvalue_memory
:
3585 /* Offset the pointer, if needed. */
3588 ax_const_l (expr
, offset
/ 8);
3589 ax_simple (expr
, aop_add
);
3592 access_memory (arch
, expr
, size
);
3596 /* For a bits-big-endian target, shift up what we already
3597 have. For a bits-little-endian target, shift up the
3598 new data. Note that there is a potential bug here if
3599 the DWARF expression leaves multiple values on the
3601 if (bits_collected
> 0)
3603 if (bits_big_endian
)
3605 ax_simple (expr
, aop_swap
);
3606 ax_const_l (expr
, size
);
3607 ax_simple (expr
, aop_lsh
);
3608 /* We don't need a second swap here, because
3609 aop_bit_or is symmetric. */
3613 ax_const_l (expr
, size
);
3614 ax_simple (expr
, aop_lsh
);
3616 ax_simple (expr
, aop_bit_or
);
3619 bits_collected
+= size
;
3620 loc
->kind
= axs_rvalue
;
3624 case DW_OP_GNU_uninit
:
3630 struct dwarf2_locexpr_baton block
;
3631 int size
= (op
== DW_OP_call2
? 2 : 4);
3634 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3637 offset
.cu_off
= uoffset
;
3638 block
= dwarf2_fetch_die_loc_cu_off (offset
, per_cu
,
3641 /* DW_OP_call_ref is currently not supported. */
3642 gdb_assert (block
.per_cu
== per_cu
);
3644 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3645 block
.data
, block
.data
+ block
.size
,
3650 case DW_OP_call_ref
:
3658 /* Patch all the branches we emitted. */
3659 for (i
= 0; i
< patches
.size (); ++i
)
3661 int targ
= offsets
[dw_labels
[i
]];
3663 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3664 ax_label (expr
, patches
[i
], targ
);
3669 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3670 evaluator to calculate the location. */
3671 static struct value
*
3672 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3674 struct dwarf2_locexpr_baton
*dlbaton
3675 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3678 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3679 dlbaton
->size
, dlbaton
->per_cu
);
3684 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3685 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3688 static struct value
*
3689 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3691 struct dwarf2_locexpr_baton
*dlbaton
3692 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3694 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3698 /* Implementation of get_symbol_read_needs from
3699 symbol_computed_ops. */
3701 static enum symbol_needs_kind
3702 locexpr_get_symbol_read_needs (struct symbol
*symbol
)
3704 struct dwarf2_locexpr_baton
*dlbaton
3705 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3707 return dwarf2_loc_desc_get_symbol_read_needs (dlbaton
->data
, dlbaton
->size
,
3711 /* Return true if DATA points to the end of a piece. END is one past
3712 the last byte in the expression. */
3715 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3717 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3720 /* Helper for locexpr_describe_location_piece that finds the name of a
3724 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3728 /* This doesn't use dwarf_reg_to_regnum_or_error on purpose.
3729 We'd rather print *something* here than throw an error. */
3730 regnum
= dwarf_reg_to_regnum (gdbarch
, dwarf_regnum
);
3731 /* gdbarch_register_name may just return "", return something more
3732 descriptive for bad register numbers. */
3735 /* The text is output as "$bad_register_number".
3736 That is why we use the underscores. */
3737 return _("bad_register_number");
3739 return gdbarch_register_name (gdbarch
, regnum
);
3742 /* Nicely describe a single piece of a location, returning an updated
3743 position in the bytecode sequence. This function cannot recognize
3744 all locations; if a location is not recognized, it simply returns
3745 DATA. If there is an error during reading, e.g. we run off the end
3746 of the buffer, an error is thrown. */
3748 static const gdb_byte
*
3749 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3750 CORE_ADDR addr
, struct objfile
*objfile
,
3751 struct dwarf2_per_cu_data
*per_cu
,
3752 const gdb_byte
*data
, const gdb_byte
*end
,
3753 unsigned int addr_size
)
3755 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3758 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3760 fprintf_filtered (stream
, _("a variable in $%s"),
3761 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3764 else if (data
[0] == DW_OP_regx
)
3768 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3769 fprintf_filtered (stream
, _("a variable in $%s"),
3770 locexpr_regname (gdbarch
, reg
));
3772 else if (data
[0] == DW_OP_fbreg
)
3774 const struct block
*b
;
3775 struct symbol
*framefunc
;
3777 int64_t frame_offset
;
3778 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3780 int64_t base_offset
= 0;
3782 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3783 if (!piece_end_p (new_data
, end
))
3787 b
= block_for_pc (addr
);
3790 error (_("No block found for address for symbol \"%s\"."),
3791 SYMBOL_PRINT_NAME (symbol
));
3793 framefunc
= block_linkage_function (b
);
3796 error (_("No function found for block for symbol \"%s\"."),
3797 SYMBOL_PRINT_NAME (symbol
));
3799 func_get_frame_base_dwarf_block (framefunc
, addr
, &base_data
, &base_size
);
3801 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3803 const gdb_byte
*buf_end
;
3805 frame_reg
= base_data
[0] - DW_OP_breg0
;
3806 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3808 if (buf_end
!= base_data
+ base_size
)
3809 error (_("Unexpected opcode after "
3810 "DW_OP_breg%u for symbol \"%s\"."),
3811 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3813 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3815 /* The frame base is just the register, with no offset. */
3816 frame_reg
= base_data
[0] - DW_OP_reg0
;
3821 /* We don't know what to do with the frame base expression,
3822 so we can't trace this variable; give up. */
3826 fprintf_filtered (stream
,
3827 _("a variable at frame base reg $%s offset %s+%s"),
3828 locexpr_regname (gdbarch
, frame_reg
),
3829 plongest (base_offset
), plongest (frame_offset
));
3831 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3832 && piece_end_p (data
, end
))
3836 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3838 fprintf_filtered (stream
,
3839 _("a variable at offset %s from base reg $%s"),
3841 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3844 /* The location expression for a TLS variable looks like this (on a
3847 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3848 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3850 0x3 is the encoding for DW_OP_addr, which has an operand as long
3851 as the size of an address on the target machine (here is 8
3852 bytes). Note that more recent version of GCC emit DW_OP_const4u
3853 or DW_OP_const8u, depending on address size, rather than
3854 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3855 The operand represents the offset at which the variable is within
3856 the thread local storage. */
3858 else if (data
+ 1 + addr_size
< end
3859 && (data
[0] == DW_OP_addr
3860 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3861 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3862 && (data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3863 || data
[1 + addr_size
] == DW_OP_form_tls_address
)
3864 && piece_end_p (data
+ 2 + addr_size
, end
))
3867 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3868 gdbarch_byte_order (gdbarch
));
3870 fprintf_filtered (stream
,
3871 _("a thread-local variable at offset 0x%s "
3872 "in the thread-local storage for `%s'"),
3873 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3875 data
+= 1 + addr_size
+ 1;
3878 /* With -gsplit-dwarf a TLS variable can also look like this:
3879 DW_AT_location : 3 byte block: fc 4 e0
3880 (DW_OP_GNU_const_index: 4;
3881 DW_OP_GNU_push_tls_address) */
3882 else if (data
+ 3 <= end
3883 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3884 && data
[0] == DW_OP_GNU_const_index
3886 && (data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3887 || data
[1 + leb128_size
] == DW_OP_form_tls_address
)
3888 && piece_end_p (data
+ 2 + leb128_size
, end
))
3892 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3893 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3894 fprintf_filtered (stream
,
3895 _("a thread-local variable at offset 0x%s "
3896 "in the thread-local storage for `%s'"),
3897 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3901 else if (data
[0] >= DW_OP_lit0
3902 && data
[0] <= DW_OP_lit31
3904 && data
[1] == DW_OP_stack_value
)
3906 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3913 /* Disassemble an expression, stopping at the end of a piece or at the
3914 end of the expression. Returns a pointer to the next unread byte
3915 in the input expression. If ALL is nonzero, then this function
3916 will keep going until it reaches the end of the expression.
3917 If there is an error during reading, e.g. we run off the end
3918 of the buffer, an error is thrown. */
3920 static const gdb_byte
*
3921 disassemble_dwarf_expression (struct ui_file
*stream
,
3922 struct gdbarch
*arch
, unsigned int addr_size
,
3923 int offset_size
, const gdb_byte
*start
,
3924 const gdb_byte
*data
, const gdb_byte
*end
,
3925 int indent
, int all
,
3926 struct dwarf2_per_cu_data
*per_cu
)
3930 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3932 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *data
++;
3937 name
= get_DW_OP_name (op
);
3940 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3941 op
, (long) (data
- 1 - start
));
3942 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3943 (long) (data
- 1 - start
), name
);
3948 ul
= extract_unsigned_integer (data
, addr_size
,
3949 gdbarch_byte_order (arch
));
3951 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3955 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3957 fprintf_filtered (stream
, " %s", pulongest (ul
));
3960 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3962 fprintf_filtered (stream
, " %s", plongest (l
));
3965 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3967 fprintf_filtered (stream
, " %s", pulongest (ul
));
3970 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3972 fprintf_filtered (stream
, " %s", plongest (l
));
3975 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3977 fprintf_filtered (stream
, " %s", pulongest (ul
));
3980 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3982 fprintf_filtered (stream
, " %s", plongest (l
));
3985 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3987 fprintf_filtered (stream
, " %s", pulongest (ul
));
3990 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3992 fprintf_filtered (stream
, " %s", plongest (l
));
3995 data
= safe_read_uleb128 (data
, end
, &ul
);
3996 fprintf_filtered (stream
, " %s", pulongest (ul
));
3999 data
= safe_read_sleb128 (data
, end
, &l
);
4000 fprintf_filtered (stream
, " %s", plongest (l
));
4035 fprintf_filtered (stream
, " [$%s]",
4036 locexpr_regname (arch
, op
- DW_OP_reg0
));
4040 data
= safe_read_uleb128 (data
, end
, &ul
);
4041 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
4042 locexpr_regname (arch
, (int) ul
));
4045 case DW_OP_implicit_value
:
4046 data
= safe_read_uleb128 (data
, end
, &ul
);
4048 fprintf_filtered (stream
, " %s", pulongest (ul
));
4083 data
= safe_read_sleb128 (data
, end
, &l
);
4084 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
4085 locexpr_regname (arch
, op
- DW_OP_breg0
));
4089 data
= safe_read_uleb128 (data
, end
, &ul
);
4090 data
= safe_read_sleb128 (data
, end
, &l
);
4091 fprintf_filtered (stream
, " register %s [$%s] offset %s",
4093 locexpr_regname (arch
, (int) ul
),
4098 data
= safe_read_sleb128 (data
, end
, &l
);
4099 fprintf_filtered (stream
, " %s", plongest (l
));
4102 case DW_OP_xderef_size
:
4103 case DW_OP_deref_size
:
4105 fprintf_filtered (stream
, " %d", *data
);
4109 case DW_OP_plus_uconst
:
4110 data
= safe_read_uleb128 (data
, end
, &ul
);
4111 fprintf_filtered (stream
, " %s", pulongest (ul
));
4115 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4117 fprintf_filtered (stream
, " to %ld",
4118 (long) (data
+ l
- start
));
4122 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4124 fprintf_filtered (stream
, " %ld",
4125 (long) (data
+ l
- start
));
4129 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
4131 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
4135 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4137 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4140 case DW_OP_call_ref
:
4141 ul
= extract_unsigned_integer (data
, offset_size
,
4142 gdbarch_byte_order (arch
));
4143 data
+= offset_size
;
4144 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4148 data
= safe_read_uleb128 (data
, end
, &ul
);
4149 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
4152 case DW_OP_bit_piece
:
4156 data
= safe_read_uleb128 (data
, end
, &ul
);
4157 data
= safe_read_uleb128 (data
, end
, &offset
);
4158 fprintf_filtered (stream
, " size %s offset %s (bits)",
4159 pulongest (ul
), pulongest (offset
));
4163 case DW_OP_implicit_pointer
:
4164 case DW_OP_GNU_implicit_pointer
:
4166 ul
= extract_unsigned_integer (data
, offset_size
,
4167 gdbarch_byte_order (arch
));
4168 data
+= offset_size
;
4170 data
= safe_read_sleb128 (data
, end
, &l
);
4172 fprintf_filtered (stream
, " DIE %s offset %s",
4173 phex_nz (ul
, offset_size
),
4178 case DW_OP_deref_type
:
4179 case DW_OP_GNU_deref_type
:
4181 int addr_size
= *data
++;
4185 data
= safe_read_uleb128 (data
, end
, &ul
);
4187 type
= dwarf2_get_die_type (offset
, per_cu
);
4188 fprintf_filtered (stream
, "<");
4189 type_print (type
, "", stream
, -1);
4190 fprintf_filtered (stream
, " [0x%s]> %d", phex_nz (offset
.cu_off
, 0),
4195 case DW_OP_const_type
:
4196 case DW_OP_GNU_const_type
:
4201 data
= safe_read_uleb128 (data
, end
, &ul
);
4202 type_die
.cu_off
= ul
;
4203 type
= dwarf2_get_die_type (type_die
, per_cu
);
4204 fprintf_filtered (stream
, "<");
4205 type_print (type
, "", stream
, -1);
4206 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
4210 case DW_OP_regval_type
:
4211 case DW_OP_GNU_regval_type
:
4217 data
= safe_read_uleb128 (data
, end
, ®
);
4218 data
= safe_read_uleb128 (data
, end
, &ul
);
4219 type_die
.cu_off
= ul
;
4221 type
= dwarf2_get_die_type (type_die
, per_cu
);
4222 fprintf_filtered (stream
, "<");
4223 type_print (type
, "", stream
, -1);
4224 fprintf_filtered (stream
, " [0x%s]> [$%s]",
4225 phex_nz (type_die
.cu_off
, 0),
4226 locexpr_regname (arch
, reg
));
4231 case DW_OP_GNU_convert
:
4232 case DW_OP_reinterpret
:
4233 case DW_OP_GNU_reinterpret
:
4237 data
= safe_read_uleb128 (data
, end
, &ul
);
4238 type_die
.cu_off
= ul
;
4240 if (type_die
.cu_off
== 0)
4241 fprintf_filtered (stream
, "<0>");
4246 type
= dwarf2_get_die_type (type_die
, per_cu
);
4247 fprintf_filtered (stream
, "<");
4248 type_print (type
, "", stream
, -1);
4249 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
4254 case DW_OP_entry_value
:
4255 case DW_OP_GNU_entry_value
:
4256 data
= safe_read_uleb128 (data
, end
, &ul
);
4257 fputc_filtered ('\n', stream
);
4258 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
4259 start
, data
, data
+ ul
, indent
+ 2,
4264 case DW_OP_GNU_parameter_ref
:
4265 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4267 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4270 case DW_OP_GNU_addr_index
:
4271 data
= safe_read_uleb128 (data
, end
, &ul
);
4272 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4273 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
4275 case DW_OP_GNU_const_index
:
4276 data
= safe_read_uleb128 (data
, end
, &ul
);
4277 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4278 fprintf_filtered (stream
, " %s", pulongest (ul
));
4282 fprintf_filtered (stream
, "\n");
4288 /* Describe a single location, which may in turn consist of multiple
4292 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
4293 struct ui_file
*stream
,
4294 const gdb_byte
*data
, size_t size
,
4295 struct objfile
*objfile
, unsigned int addr_size
,
4296 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
4298 const gdb_byte
*end
= data
+ size
;
4299 int first_piece
= 1, bad
= 0;
4303 const gdb_byte
*here
= data
;
4304 int disassemble
= 1;
4309 fprintf_filtered (stream
, _(", and "));
4311 if (!dwarf_always_disassemble
)
4313 data
= locexpr_describe_location_piece (symbol
, stream
,
4314 addr
, objfile
, per_cu
,
4315 data
, end
, addr_size
);
4316 /* If we printed anything, or if we have an empty piece,
4317 then don't disassemble. */
4319 || data
[0] == DW_OP_piece
4320 || data
[0] == DW_OP_bit_piece
)
4325 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
4326 data
= disassemble_dwarf_expression (stream
,
4327 get_objfile_arch (objfile
),
4328 addr_size
, offset_size
, data
,
4330 dwarf_always_disassemble
,
4336 int empty
= data
== here
;
4339 fprintf_filtered (stream
, " ");
4340 if (data
[0] == DW_OP_piece
)
4344 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
4347 fprintf_filtered (stream
, _("an empty %s-byte piece"),
4350 fprintf_filtered (stream
, _(" [%s-byte piece]"),
4353 else if (data
[0] == DW_OP_bit_piece
)
4355 uint64_t bits
, offset
;
4357 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
4358 data
= safe_read_uleb128 (data
, end
, &offset
);
4361 fprintf_filtered (stream
,
4362 _("an empty %s-bit piece"),
4365 fprintf_filtered (stream
,
4366 _(" [%s-bit piece, offset %s bits]"),
4367 pulongest (bits
), pulongest (offset
));
4377 if (bad
|| data
> end
)
4378 error (_("Corrupted DWARF2 expression for \"%s\"."),
4379 SYMBOL_PRINT_NAME (symbol
));
4382 /* Print a natural-language description of SYMBOL to STREAM. This
4383 version is for a symbol with a single location. */
4386 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4387 struct ui_file
*stream
)
4389 struct dwarf2_locexpr_baton
*dlbaton
4390 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4391 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4392 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4393 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4395 locexpr_describe_location_1 (symbol
, addr
, stream
,
4396 dlbaton
->data
, dlbaton
->size
,
4397 objfile
, addr_size
, offset_size
,
4401 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4402 any necessary bytecode in AX. */
4405 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4406 struct agent_expr
*ax
, struct axs_value
*value
)
4408 struct dwarf2_locexpr_baton
*dlbaton
4409 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4410 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4412 if (dlbaton
->size
== 0)
4413 value
->optimized_out
= 1;
4415 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
4416 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4420 /* symbol_computed_ops 'generate_c_location' method. */
4423 locexpr_generate_c_location (struct symbol
*sym
, string_file
&stream
,
4424 struct gdbarch
*gdbarch
,
4425 unsigned char *registers_used
,
4426 CORE_ADDR pc
, const char *result_name
)
4428 struct dwarf2_locexpr_baton
*dlbaton
4429 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (sym
);
4430 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4432 if (dlbaton
->size
== 0)
4433 error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym
));
4435 compile_dwarf_expr_to_c (stream
, result_name
,
4436 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4437 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4441 /* The set of location functions used with the DWARF-2 expression
4443 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4444 locexpr_read_variable
,
4445 locexpr_read_variable_at_entry
,
4446 locexpr_get_symbol_read_needs
,
4447 locexpr_describe_location
,
4448 0, /* location_has_loclist */
4449 locexpr_tracepoint_var_ref
,
4450 locexpr_generate_c_location
4454 /* Wrapper functions for location lists. These generally find
4455 the appropriate location expression and call something above. */
4457 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4458 evaluator to calculate the location. */
4459 static struct value
*
4460 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4462 struct dwarf2_loclist_baton
*dlbaton
4463 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4465 const gdb_byte
*data
;
4467 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4469 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4470 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4476 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4477 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4480 Function always returns non-NULL value, it may be marked optimized out if
4481 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4482 if it cannot resolve the parameter for any reason. */
4484 static struct value
*
4485 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4487 struct dwarf2_loclist_baton
*dlbaton
4488 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4489 const gdb_byte
*data
;
4493 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4494 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4496 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4498 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4500 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4503 /* Implementation of get_symbol_read_needs from
4504 symbol_computed_ops. */
4506 static enum symbol_needs_kind
4507 loclist_symbol_needs (struct symbol
*symbol
)
4509 /* If there's a location list, then assume we need to have a frame
4510 to choose the appropriate location expression. With tracking of
4511 global variables this is not necessarily true, but such tracking
4512 is disabled in GCC at the moment until we figure out how to
4515 return SYMBOL_NEEDS_FRAME
;
4518 /* Print a natural-language description of SYMBOL to STREAM. This
4519 version applies when there is a list of different locations, each
4520 with a specified address range. */
4523 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4524 struct ui_file
*stream
)
4526 struct dwarf2_loclist_baton
*dlbaton
4527 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4528 const gdb_byte
*loc_ptr
, *buf_end
;
4529 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4530 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4531 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4532 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4533 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4534 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4535 /* Adjust base_address for relocatable objects. */
4536 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4537 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4540 loc_ptr
= dlbaton
->data
;
4541 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4543 fprintf_filtered (stream
, _("multi-location:\n"));
4545 /* Iterate through locations until we run out. */
4548 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4550 enum debug_loc_kind kind
;
4551 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4553 if (dlbaton
->from_dwo
)
4554 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4555 loc_ptr
, buf_end
, &new_ptr
,
4556 &low
, &high
, byte_order
);
4558 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4560 byte_order
, addr_size
,
4565 case DEBUG_LOC_END_OF_LIST
:
4568 case DEBUG_LOC_BASE_ADDRESS
:
4569 base_address
= high
+ base_offset
;
4570 fprintf_filtered (stream
, _(" Base address %s"),
4571 paddress (gdbarch
, base_address
));
4573 case DEBUG_LOC_START_END
:
4574 case DEBUG_LOC_START_LENGTH
:
4576 case DEBUG_LOC_BUFFER_OVERFLOW
:
4577 case DEBUG_LOC_INVALID_ENTRY
:
4578 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4579 SYMBOL_PRINT_NAME (symbol
));
4581 gdb_assert_not_reached ("bad debug_loc_kind");
4584 /* Otherwise, a location expression entry. */
4585 low
+= base_address
;
4586 high
+= base_address
;
4588 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
);
4589 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
);
4591 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4594 /* (It would improve readability to print only the minimum
4595 necessary digits of the second number of the range.) */
4596 fprintf_filtered (stream
, _(" Range %s-%s: "),
4597 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4599 /* Now describe this particular location. */
4600 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4601 objfile
, addr_size
, offset_size
,
4604 fprintf_filtered (stream
, "\n");
4610 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4611 any necessary bytecode in AX. */
4613 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4614 struct agent_expr
*ax
, struct axs_value
*value
)
4616 struct dwarf2_loclist_baton
*dlbaton
4617 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4618 const gdb_byte
*data
;
4620 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4622 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4624 value
->optimized_out
= 1;
4626 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
4630 /* symbol_computed_ops 'generate_c_location' method. */
4633 loclist_generate_c_location (struct symbol
*sym
, string_file
&stream
,
4634 struct gdbarch
*gdbarch
,
4635 unsigned char *registers_used
,
4636 CORE_ADDR pc
, const char *result_name
)
4638 struct dwarf2_loclist_baton
*dlbaton
4639 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (sym
);
4640 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4641 const gdb_byte
*data
;
4644 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4646 error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym
));
4648 compile_dwarf_expr_to_c (stream
, result_name
,
4649 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4654 /* The set of location functions used with the DWARF-2 expression
4655 evaluator and location lists. */
4656 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4657 loclist_read_variable
,
4658 loclist_read_variable_at_entry
,
4659 loclist_symbol_needs
,
4660 loclist_describe_location
,
4661 1, /* location_has_loclist */
4662 loclist_tracepoint_var_ref
,
4663 loclist_generate_c_location
4666 /* Provide a prototype to silence -Wmissing-prototypes. */
4667 extern initialize_file_ftype _initialize_dwarf2loc
;
4670 _initialize_dwarf2loc (void)
4672 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4673 &entry_values_debug
,
4674 _("Set entry values and tail call frames "
4676 _("Show entry values and tail call frames "
4678 _("When non-zero, the process of determining "
4679 "parameter values from function entry point "
4680 "and tail call frames will be printed."),
4682 show_entry_values_debug
,
4683 &setdebuglist
, &showdebuglist
);
4686 register_self_test (selftests::copy_bitwise_tests
);