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_GNU_const_type"));
592 if (size
!= 0 && TYPE_LENGTH (result
) != size
)
593 error (_("DW_OP_GNU_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_GNU_call_site_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_GNU_call_site's DW_AT_GNU_call_site_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_GNU_call_site_target is not specified "
762 paddress (call_site_gdbarch
, call_site
->pc
),
763 (msym
.minsym
== NULL
? "???"
764 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
767 if (caller_frame
== NULL
)
769 struct bound_minimal_symbol msym
;
771 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
772 throw_error (NO_ENTRY_VALUE_ERROR
,
773 _("DW_AT_GNU_call_site_target DWARF block resolving "
774 "requires known frame which is currently not "
775 "available at %s in %s"),
776 paddress (call_site_gdbarch
, call_site
->pc
),
777 (msym
.minsym
== NULL
? "???"
778 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
781 caller_arch
= get_frame_arch (caller_frame
);
782 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
783 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
784 dwarf_block
->data
, dwarf_block
->size
,
785 dwarf_block
->per_cu
);
786 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
788 if (VALUE_LVAL (val
) == lval_memory
)
789 return value_address (val
);
791 return value_as_address (val
);
794 case FIELD_LOC_KIND_PHYSNAME
:
796 const char *physname
;
797 struct bound_minimal_symbol msym
;
799 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
801 /* Handle both the mangled and demangled PHYSNAME. */
802 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
803 if (msym
.minsym
== NULL
)
805 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
806 throw_error (NO_ENTRY_VALUE_ERROR
,
807 _("Cannot find function \"%s\" for a call site target "
809 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
810 (msym
.minsym
== NULL
? "???"
811 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
814 return BMSYMBOL_VALUE_ADDRESS (msym
);
817 case FIELD_LOC_KIND_PHYSADDR
:
818 return FIELD_STATIC_PHYSADDR (call_site
->target
);
821 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
825 /* Convert function entry point exact address ADDR to the function which is
826 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
827 NO_ENTRY_VALUE_ERROR otherwise. */
829 static struct symbol
*
830 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
832 struct symbol
*sym
= find_pc_function (addr
);
835 if (sym
== NULL
|| BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
836 throw_error (NO_ENTRY_VALUE_ERROR
,
837 _("DW_TAG_GNU_call_site resolving failed to find function "
838 "name for address %s"),
839 paddress (gdbarch
, addr
));
841 type
= SYMBOL_TYPE (sym
);
842 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
843 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
848 /* Verify function with entry point exact address ADDR can never call itself
849 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
850 can call itself via tail calls.
852 If a funtion can tail call itself its entry value based parameters are
853 unreliable. There is no verification whether the value of some/all
854 parameters is unchanged through the self tail call, we expect if there is
855 a self tail call all the parameters can be modified. */
858 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
862 /* The verification is completely unordered. Track here function addresses
863 which still need to be iterated. */
864 std::vector
<CORE_ADDR
> todo
;
866 /* Track here CORE_ADDRs which were already visited. */
867 std::unordered_set
<CORE_ADDR
> addr_hash
;
869 todo
.push_back (verify_addr
);
870 while (!todo
.empty ())
872 struct symbol
*func_sym
;
873 struct call_site
*call_site
;
878 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
880 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
881 call_site
; call_site
= call_site
->tail_call_next
)
883 CORE_ADDR target_addr
;
885 /* CALLER_FRAME with registers is not available for tail-call jumped
887 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
889 if (target_addr
== verify_addr
)
891 struct bound_minimal_symbol msym
;
893 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
894 throw_error (NO_ENTRY_VALUE_ERROR
,
895 _("DW_OP_GNU_entry_value resolving has found "
896 "function \"%s\" at %s can call itself via tail "
898 (msym
.minsym
== NULL
? "???"
899 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
900 paddress (gdbarch
, verify_addr
));
903 if (addr_hash
.insert (target_addr
).second
)
904 todo
.push_back (target_addr
);
909 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
910 ENTRY_VALUES_DEBUG. */
913 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
915 CORE_ADDR addr
= call_site
->pc
;
916 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
918 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
919 (msym
.minsym
== NULL
? "???"
920 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
924 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
925 only top callers and bottom callees which are present in both. GDBARCH is
926 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
927 no remaining possibilities to provide unambiguous non-trivial result.
928 RESULTP should point to NULL on the first (initialization) call. Caller is
929 responsible for xfree of any RESULTP data. */
932 chain_candidate (struct gdbarch
*gdbarch
,
933 gdb::unique_xmalloc_ptr
<struct call_site_chain
> *resultp
,
934 std::vector
<struct call_site
*> *chain
)
936 long length
= chain
->size ();
937 int callers
, callees
, idx
;
939 if (*resultp
== NULL
)
941 /* Create the initial chain containing all the passed PCs. */
943 struct call_site_chain
*result
944 = ((struct call_site_chain
*)
945 xmalloc (sizeof (*result
)
946 + sizeof (*result
->call_site
) * (length
- 1)));
947 result
->length
= length
;
948 result
->callers
= result
->callees
= length
;
949 if (!chain
->empty ())
950 memcpy (result
->call_site
, chain
->data (),
951 sizeof (*result
->call_site
) * length
);
952 resultp
->reset (result
);
954 if (entry_values_debug
)
956 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
957 for (idx
= 0; idx
< length
; idx
++)
958 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
959 fputc_unfiltered ('\n', gdb_stdlog
);
965 if (entry_values_debug
)
967 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
968 for (idx
= 0; idx
< length
; idx
++)
969 tailcall_dump (gdbarch
, chain
->at (idx
));
970 fputc_unfiltered ('\n', gdb_stdlog
);
973 /* Intersect callers. */
975 callers
= std::min ((long) (*resultp
)->callers
, length
);
976 for (idx
= 0; idx
< callers
; idx
++)
977 if ((*resultp
)->call_site
[idx
] != chain
->at (idx
))
979 (*resultp
)->callers
= idx
;
983 /* Intersect callees. */
985 callees
= std::min ((long) (*resultp
)->callees
, length
);
986 for (idx
= 0; idx
< callees
; idx
++)
987 if ((*resultp
)->call_site
[(*resultp
)->length
- 1 - idx
]
988 != chain
->at (length
- 1 - idx
))
990 (*resultp
)->callees
= idx
;
994 if (entry_values_debug
)
996 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
997 for (idx
= 0; idx
< (*resultp
)->callers
; idx
++)
998 tailcall_dump (gdbarch
, (*resultp
)->call_site
[idx
]);
999 fputs_unfiltered (" |", gdb_stdlog
);
1000 for (idx
= 0; idx
< (*resultp
)->callees
; idx
++)
1001 tailcall_dump (gdbarch
,
1002 (*resultp
)->call_site
[(*resultp
)->length
1003 - (*resultp
)->callees
+ idx
]);
1004 fputc_unfiltered ('\n', gdb_stdlog
);
1007 if ((*resultp
)->callers
== 0 && (*resultp
)->callees
== 0)
1009 /* There are no common callers or callees. It could be also a direct
1010 call (which has length 0) with ambiguous possibility of an indirect
1011 call - CALLERS == CALLEES == 0 is valid during the first allocation
1012 but any subsequence processing of such entry means ambiguity. */
1013 resultp
->reset (NULL
);
1017 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
1018 PC again. In such case there must be two different code paths to reach
1019 it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
1020 gdb_assert ((*resultp
)->callers
+ (*resultp
)->callees
<= (*resultp
)->length
);
1023 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1024 assumed frames between them use GDBARCH. Use depth first search so we can
1025 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
1026 would have needless GDB stack overhead. Caller is responsible for xfree of
1027 the returned result. Any unreliability results in thrown
1028 NO_ENTRY_VALUE_ERROR. */
1030 static struct call_site_chain
*
1031 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1032 CORE_ADDR callee_pc
)
1034 CORE_ADDR save_callee_pc
= callee_pc
;
1035 gdb::unique_xmalloc_ptr
<struct call_site_chain
> retval
;
1036 struct call_site
*call_site
;
1038 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
1039 call_site nor any possible call_site at CALLEE_PC's function is there.
1040 Any CALL_SITE in CHAIN will be iterated to its siblings - via
1041 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
1042 std::vector
<struct call_site
*> chain
;
1044 /* We are not interested in the specific PC inside the callee function. */
1045 callee_pc
= get_pc_function_start (callee_pc
);
1047 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
1048 paddress (gdbarch
, save_callee_pc
));
1050 /* Mark CALL_SITEs so we do not visit the same ones twice. */
1051 std::unordered_set
<CORE_ADDR
> addr_hash
;
1053 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
1054 at the target's function. All the possible tail call sites in the
1055 target's function will get iterated as already pushed into CHAIN via their
1057 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1061 CORE_ADDR target_func_addr
;
1062 struct call_site
*target_call_site
;
1064 /* CALLER_FRAME with registers is not available for tail-call jumped
1066 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
1068 if (target_func_addr
== callee_pc
)
1070 chain_candidate (gdbarch
, &retval
, &chain
);
1074 /* There is no way to reach CALLEE_PC again as we would prevent
1075 entering it twice as being already marked in ADDR_HASH. */
1076 target_call_site
= NULL
;
1080 struct symbol
*target_func
;
1082 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
1083 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
1088 /* Attempt to visit TARGET_CALL_SITE. */
1090 if (target_call_site
)
1092 if (addr_hash
.insert (target_call_site
->pc
).second
)
1094 /* Successfully entered TARGET_CALL_SITE. */
1096 chain
.push_back (target_call_site
);
1101 /* Backtrack (without revisiting the originating call_site). Try the
1102 callers's sibling; if there isn't any try the callers's callers's
1105 target_call_site
= NULL
;
1106 while (!chain
.empty ())
1108 call_site
= chain
.back ();
1111 size_t removed
= addr_hash
.erase (call_site
->pc
);
1112 gdb_assert (removed
== 1);
1114 target_call_site
= call_site
->tail_call_next
;
1115 if (target_call_site
)
1119 while (target_call_site
);
1124 call_site
= chain
.back ();
1129 struct bound_minimal_symbol msym_caller
, msym_callee
;
1131 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
1132 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
1133 throw_error (NO_ENTRY_VALUE_ERROR
,
1134 _("There are no unambiguously determinable intermediate "
1135 "callers or callees between caller function \"%s\" at %s "
1136 "and callee function \"%s\" at %s"),
1137 (msym_caller
.minsym
== NULL
1138 ? "???" : MSYMBOL_PRINT_NAME (msym_caller
.minsym
)),
1139 paddress (gdbarch
, caller_pc
),
1140 (msym_callee
.minsym
== NULL
1141 ? "???" : MSYMBOL_PRINT_NAME (msym_callee
.minsym
)),
1142 paddress (gdbarch
, callee_pc
));
1145 return retval
.release ();
1148 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1149 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
1150 constructed return NULL. Caller is responsible for xfree of the returned
1153 struct call_site_chain
*
1154 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1155 CORE_ADDR callee_pc
)
1157 struct call_site_chain
*retval
= NULL
;
1161 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
1163 CATCH (e
, RETURN_MASK_ERROR
)
1165 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
1167 if (entry_values_debug
)
1168 exception_print (gdb_stdout
, e
);
1173 throw_exception (e
);
1180 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1183 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1184 enum call_site_parameter_kind kind
,
1185 union call_site_parameter_u kind_u
)
1187 if (kind
== parameter
->kind
)
1190 case CALL_SITE_PARAMETER_DWARF_REG
:
1191 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1192 case CALL_SITE_PARAMETER_FB_OFFSET
:
1193 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1194 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1195 return kind_u
.param_offset
.cu_off
== parameter
->u
.param_offset
.cu_off
;
1200 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1201 FRAME is for callee.
1203 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1206 static struct call_site_parameter
*
1207 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1208 enum call_site_parameter_kind kind
,
1209 union call_site_parameter_u kind_u
,
1210 struct dwarf2_per_cu_data
**per_cu_return
)
1212 CORE_ADDR func_addr
, caller_pc
;
1213 struct gdbarch
*gdbarch
;
1214 struct frame_info
*caller_frame
;
1215 struct call_site
*call_site
;
1217 /* Initialize it just to avoid a GCC false warning. */
1218 struct call_site_parameter
*parameter
= NULL
;
1219 CORE_ADDR target_addr
;
1221 while (get_frame_type (frame
) == INLINE_FRAME
)
1223 frame
= get_prev_frame (frame
);
1224 gdb_assert (frame
!= NULL
);
1227 func_addr
= get_frame_func (frame
);
1228 gdbarch
= get_frame_arch (frame
);
1229 caller_frame
= get_prev_frame (frame
);
1230 if (gdbarch
!= frame_unwind_arch (frame
))
1232 struct bound_minimal_symbol msym
1233 = lookup_minimal_symbol_by_pc (func_addr
);
1234 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1236 throw_error (NO_ENTRY_VALUE_ERROR
,
1237 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1238 "(of %s (%s)) does not match caller gdbarch %s"),
1239 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1240 paddress (gdbarch
, func_addr
),
1241 (msym
.minsym
== NULL
? "???"
1242 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
1243 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1246 if (caller_frame
== NULL
)
1248 struct bound_minimal_symbol msym
1249 = lookup_minimal_symbol_by_pc (func_addr
);
1251 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_GNU_entry_value resolving "
1252 "requires caller of %s (%s)"),
1253 paddress (gdbarch
, func_addr
),
1254 (msym
.minsym
== NULL
? "???"
1255 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
1257 caller_pc
= get_frame_pc (caller_frame
);
1258 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1260 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1261 if (target_addr
!= func_addr
)
1263 struct minimal_symbol
*target_msym
, *func_msym
;
1265 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1266 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1267 throw_error (NO_ENTRY_VALUE_ERROR
,
1268 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1269 "but the called frame is for %s at %s"),
1270 (target_msym
== NULL
? "???"
1271 : MSYMBOL_PRINT_NAME (target_msym
)),
1272 paddress (gdbarch
, target_addr
),
1273 func_msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (func_msym
),
1274 paddress (gdbarch
, func_addr
));
1277 /* No entry value based parameters would be reliable if this function can
1278 call itself via tail calls. */
1279 func_verify_no_selftailcall (gdbarch
, func_addr
);
1281 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1283 parameter
= &call_site
->parameter
[iparams
];
1284 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1287 if (iparams
== call_site
->parameter_count
)
1289 struct minimal_symbol
*msym
1290 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1292 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1293 determine its value. */
1294 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1295 "at DW_TAG_GNU_call_site %s at %s"),
1296 paddress (gdbarch
, caller_pc
),
1297 msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (msym
));
1300 *per_cu_return
= call_site
->per_cu
;
1304 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1305 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1306 DW_AT_GNU_call_site_data_value (dereferenced) block.
1308 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1311 Function always returns non-NULL, non-optimized out value. It throws
1312 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1314 static struct value
*
1315 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1316 CORE_ADDR deref_size
, struct type
*type
,
1317 struct frame_info
*caller_frame
,
1318 struct dwarf2_per_cu_data
*per_cu
)
1320 const gdb_byte
*data_src
;
1324 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1325 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1327 /* DEREF_SIZE size is not verified here. */
1328 if (data_src
== NULL
)
1329 throw_error (NO_ENTRY_VALUE_ERROR
,
1330 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1332 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1333 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1335 data
= (gdb_byte
*) alloca (size
+ 1);
1336 memcpy (data
, data_src
, size
);
1337 data
[size
] = DW_OP_stack_value
;
1339 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1342 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1343 the indirect method on it, that is use its stored target value, the sole
1344 purpose of entry_data_value_funcs.. */
1346 static struct value
*
1347 entry_data_value_coerce_ref (const struct value
*value
)
1349 struct type
*checked_type
= check_typedef (value_type (value
));
1350 struct value
*target_val
;
1352 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
)
1355 target_val
= (struct value
*) value_computed_closure (value
);
1356 value_incref (target_val
);
1360 /* Implement copy_closure. */
1363 entry_data_value_copy_closure (const struct value
*v
)
1365 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1367 value_incref (target_val
);
1371 /* Implement free_closure. */
1374 entry_data_value_free_closure (struct value
*v
)
1376 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1378 value_free (target_val
);
1381 /* Vector for methods for an entry value reference where the referenced value
1382 is stored in the caller. On the first dereference use
1383 DW_AT_GNU_call_site_data_value in the caller. */
1385 static const struct lval_funcs entry_data_value_funcs
=
1389 NULL
, /* indirect */
1390 entry_data_value_coerce_ref
,
1391 NULL
, /* check_synthetic_pointer */
1392 entry_data_value_copy_closure
,
1393 entry_data_value_free_closure
1396 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1397 are used to match DW_AT_location at the caller's
1398 DW_TAG_GNU_call_site_parameter.
1400 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1401 cannot resolve the parameter for any reason. */
1403 static struct value
*
1404 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1405 enum call_site_parameter_kind kind
,
1406 union call_site_parameter_u kind_u
)
1408 struct type
*checked_type
= check_typedef (type
);
1409 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1410 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1411 struct value
*outer_val
, *target_val
, *val
;
1412 struct call_site_parameter
*parameter
;
1413 struct dwarf2_per_cu_data
*caller_per_cu
;
1415 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1418 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1422 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1423 used and it is not available do not fall back to OUTER_VAL - dereferencing
1424 TYPE_CODE_REF with non-entry data value would give current value - not the
1427 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
1428 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1431 target_val
= dwarf_entry_parameter_to_value (parameter
,
1432 TYPE_LENGTH (target_type
),
1433 target_type
, caller_frame
,
1436 release_value (target_val
);
1437 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1438 target_val
/* closure */);
1440 /* Copy the referencing pointer to the new computed value. */
1441 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1442 TYPE_LENGTH (checked_type
));
1443 set_value_lazy (val
, 0);
1448 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1449 SIZE are DWARF block used to match DW_AT_location at the caller's
1450 DW_TAG_GNU_call_site_parameter.
1452 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1453 cannot resolve the parameter for any reason. */
1455 static struct value
*
1456 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1457 const gdb_byte
*block
, size_t block_len
)
1459 union call_site_parameter_u kind_u
;
1461 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1462 if (kind_u
.dwarf_reg
!= -1)
1463 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1466 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1467 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1470 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1471 suppressed during normal operation. The expression can be arbitrary if
1472 there is no caller-callee entry value binding expected. */
1473 throw_error (NO_ENTRY_VALUE_ERROR
,
1474 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1475 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1478 struct piece_closure
1480 /* Reference count. */
1483 /* The CU from which this closure's expression came. */
1484 struct dwarf2_per_cu_data
*per_cu
;
1486 /* The number of pieces used to describe this variable. */
1489 /* The target address size, used only for DWARF_VALUE_STACK. */
1492 /* The pieces themselves. */
1493 struct dwarf_expr_piece
*pieces
;
1495 /* Frame ID of frame to which a register value is relative, used
1496 only by DWARF_VALUE_REGISTER. */
1497 struct frame_id frame_id
;
1500 /* Allocate a closure for a value formed from separately-described
1503 static struct piece_closure
*
1504 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1505 int n_pieces
, struct dwarf_expr_piece
*pieces
,
1506 int addr_size
, struct frame_info
*frame
)
1508 struct piece_closure
*c
= XCNEW (struct piece_closure
);
1513 c
->n_pieces
= n_pieces
;
1514 c
->addr_size
= addr_size
;
1515 c
->pieces
= XCNEWVEC (struct dwarf_expr_piece
, n_pieces
);
1517 c
->frame_id
= null_frame_id
;
1519 c
->frame_id
= get_frame_id (frame
);
1521 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
1522 for (i
= 0; i
< n_pieces
; ++i
)
1523 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1524 value_incref (c
->pieces
[i
].v
.value
);
1529 /* Copy NBITS bits from SOURCE to DEST starting at the given bit
1530 offsets. Use the bit order as specified by BITS_BIG_ENDIAN.
1531 Source and destination buffers must not overlap. */
1534 copy_bitwise (gdb_byte
*dest
, ULONGEST dest_offset
,
1535 const gdb_byte
*source
, ULONGEST source_offset
,
1536 ULONGEST nbits
, int bits_big_endian
)
1538 unsigned int buf
, avail
;
1543 if (bits_big_endian
)
1545 /* Start from the end, then work backwards. */
1546 dest_offset
+= nbits
- 1;
1547 dest
+= dest_offset
/ 8;
1548 dest_offset
= 7 - dest_offset
% 8;
1549 source_offset
+= nbits
- 1;
1550 source
+= source_offset
/ 8;
1551 source_offset
= 7 - source_offset
% 8;
1555 dest
+= dest_offset
/ 8;
1557 source
+= source_offset
/ 8;
1561 /* Fill BUF with DEST_OFFSET bits from the destination and 8 -
1562 SOURCE_OFFSET bits from the source. */
1563 buf
= *(bits_big_endian
? source
-- : source
++) >> source_offset
;
1564 buf
<<= dest_offset
;
1565 buf
|= *dest
& ((1 << dest_offset
) - 1);
1567 /* NBITS: bits yet to be written; AVAIL: BUF's fill level. */
1568 nbits
+= dest_offset
;
1569 avail
= dest_offset
+ 8 - source_offset
;
1571 /* Flush 8 bits from BUF, if appropriate. */
1572 if (nbits
>= 8 && avail
>= 8)
1574 *(bits_big_endian
? dest
-- : dest
++) = buf
;
1580 /* Copy the middle part. */
1583 size_t len
= nbits
/ 8;
1585 /* Use a faster method for byte-aligned copies. */
1588 if (bits_big_endian
)
1592 memcpy (dest
+ 1, source
+ 1, len
);
1596 memcpy (dest
, source
, len
);
1605 buf
|= *(bits_big_endian
? source
-- : source
++) << avail
;
1606 *(bits_big_endian
? dest
-- : dest
++) = buf
;
1613 /* Write the last byte. */
1617 buf
|= *source
<< avail
;
1619 buf
&= (1 << nbits
) - 1;
1620 *dest
= (*dest
& (~0 << nbits
)) | buf
;
1626 namespace selftests
{
1628 /* Helper function for the unit test of copy_bitwise. Convert NBITS bits
1629 out of BITS, starting at OFFS, to the respective '0'/'1'-string. MSB0
1630 specifies whether to assume big endian bit numbering. Store the
1631 resulting (not null-terminated) string at STR. */
1634 bits_to_str (char *str
, const gdb_byte
*bits
, ULONGEST offs
,
1635 ULONGEST nbits
, int msb0
)
1640 for (i
= offs
/ 8, j
= offs
% 8; nbits
; i
++, j
= 0)
1642 unsigned int ch
= bits
[i
];
1643 for (; j
< 8 && nbits
; j
++, nbits
--)
1644 *str
++ = (ch
& (msb0
? (1 << (7 - j
)) : (1 << j
))) ? '1' : '0';
1648 /* Check one invocation of copy_bitwise with the given parameters. */
1651 check_copy_bitwise (const gdb_byte
*dest
, unsigned int dest_offset
,
1652 const gdb_byte
*source
, unsigned int source_offset
,
1653 unsigned int nbits
, int msb0
)
1655 size_t len
= align_up (dest_offset
+ nbits
, 8);
1656 char *expected
= (char *) alloca (len
+ 1);
1657 char *actual
= (char *) alloca (len
+ 1);
1658 gdb_byte
*buf
= (gdb_byte
*) alloca (len
/ 8);
1660 /* Compose a '0'/'1'-string that represents the expected result of
1662 Bits from [0, DEST_OFFSET) are filled from DEST.
1663 Bits from [DEST_OFFSET, DEST_OFFSET + NBITS) are filled from SOURCE.
1664 Bits from [DEST_OFFSET + NBITS, LEN) are filled from DEST.
1673 We should end up with:
1675 DDDDSSDD (D=dest, S=source)
1677 bits_to_str (expected
, dest
, 0, len
, msb0
);
1678 bits_to_str (expected
+ dest_offset
, source
, source_offset
, nbits
, msb0
);
1680 /* Fill BUF with data from DEST, apply copy_bitwise, and convert the
1681 result to a '0'/'1'-string. */
1682 memcpy (buf
, dest
, len
/ 8);
1683 copy_bitwise (buf
, dest_offset
, source
, source_offset
, nbits
, msb0
);
1684 bits_to_str (actual
, buf
, 0, len
, msb0
);
1686 /* Compare the resulting strings. */
1687 expected
[len
] = actual
[len
] = '\0';
1688 if (strcmp (expected
, actual
) != 0)
1689 error (_("copy_bitwise %s != %s (%u+%u -> %u)"),
1690 expected
, actual
, source_offset
, nbits
, dest_offset
);
1693 /* Unit test for copy_bitwise. */
1696 copy_bitwise_tests (void)
1698 /* Data to be used as both source and destination buffers. The two
1699 arrays below represent the lsb0- and msb0- encoded versions of the
1700 following bit string, respectively:
1701 00000000 00011111 11111111 01001000 10100101 11110010
1702 This pattern is chosen such that it contains:
1703 - constant 0- and 1- chunks of more than a full byte;
1704 - 0/1- and 1/0 transitions on all bit positions within a byte;
1705 - several sufficiently asymmetric bytes.
1707 static const gdb_byte data_lsb0
[] = {
1708 0x00, 0xf8, 0xff, 0x12, 0xa5, 0x4f
1710 static const gdb_byte data_msb0
[] = {
1711 0x00, 0x1f, 0xff, 0x48, 0xa5, 0xf2
1714 constexpr size_t data_nbits
= 8 * sizeof (data_lsb0
);
1715 constexpr unsigned max_nbits
= 24;
1717 /* Try all combinations of:
1718 lsb0/msb0 bit order (using the respective data array)
1719 X [0, MAX_NBITS] copy bit width
1720 X feasible source offsets for the given copy bit width
1721 X feasible destination offsets
1723 for (int msb0
= 0; msb0
< 2; msb0
++)
1725 const gdb_byte
*data
= msb0
? data_msb0
: data_lsb0
;
1727 for (unsigned int nbits
= 1; nbits
<= max_nbits
; nbits
++)
1729 const unsigned int max_offset
= data_nbits
- nbits
;
1731 for (unsigned source_offset
= 0;
1732 source_offset
<= max_offset
;
1735 for (unsigned dest_offset
= 0;
1736 dest_offset
<= max_offset
;
1739 check_copy_bitwise (data
+ dest_offset
/ 8,
1741 data
+ source_offset
/ 8,
1748 /* Special cases: copy all, copy nothing. */
1749 check_copy_bitwise (data_lsb0
, 0, data_msb0
, 0, data_nbits
, msb0
);
1750 check_copy_bitwise (data_msb0
, 0, data_lsb0
, 0, data_nbits
, msb0
);
1751 check_copy_bitwise (data
, data_nbits
- 7, data
, 9, 0, msb0
);
1755 } /* namespace selftests */
1757 #endif /* GDB_SELF_TEST */
1760 read_pieced_value (struct value
*v
)
1764 ULONGEST bits_to_skip
;
1766 struct piece_closure
*c
1767 = (struct piece_closure
*) value_computed_closure (v
);
1769 size_t buffer_size
= 0;
1770 std::vector
<gdb_byte
> buffer
;
1772 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1774 if (value_type (v
) != value_enclosing_type (v
))
1775 internal_error (__FILE__
, __LINE__
,
1776 _("Should not be able to create a lazy value with "
1777 "an enclosing type"));
1779 contents
= value_contents_raw (v
);
1780 bits_to_skip
= 8 * value_offset (v
);
1781 if (value_bitsize (v
))
1783 bits_to_skip
+= value_bitpos (v
);
1784 type_len
= value_bitsize (v
);
1787 type_len
= 8 * TYPE_LENGTH (value_type (v
));
1789 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1791 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1792 size_t this_size
, this_size_bits
;
1793 long dest_offset_bits
, source_offset_bits
, source_offset
;
1794 const gdb_byte
*intermediate_buffer
;
1796 /* Compute size, source, and destination offsets for copying, in
1798 this_size_bits
= p
->size
;
1799 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1801 bits_to_skip
-= this_size_bits
;
1804 if (bits_to_skip
> 0)
1806 dest_offset_bits
= 0;
1807 source_offset_bits
= bits_to_skip
;
1808 this_size_bits
-= bits_to_skip
;
1813 dest_offset_bits
= offset
;
1814 source_offset_bits
= 0;
1816 if (this_size_bits
> type_len
- offset
)
1817 this_size_bits
= type_len
- offset
;
1819 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1820 source_offset
= source_offset_bits
/ 8;
1821 if (buffer_size
< this_size
)
1823 buffer_size
= this_size
;
1824 buffer
.reserve (buffer_size
);
1826 intermediate_buffer
= buffer
.data ();
1828 /* Copy from the source to DEST_BUFFER. */
1829 switch (p
->location
)
1831 case DWARF_VALUE_REGISTER
:
1833 struct frame_info
*frame
= frame_find_by_id (c
->frame_id
);
1834 struct gdbarch
*arch
= get_frame_arch (frame
);
1835 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, p
->v
.regno
);
1837 LONGEST reg_offset
= source_offset
;
1839 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1840 && this_size
< register_size (arch
, gdb_regnum
))
1842 /* Big-endian, and we want less than full size. */
1843 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1844 /* We want the lower-order THIS_SIZE_BITS of the bytes
1845 we extract from the register. */
1846 source_offset_bits
+= 8 * this_size
- this_size_bits
;
1849 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1850 this_size
, buffer
.data (),
1853 /* Just so garbage doesn't ever shine through. */
1854 memset (buffer
.data (), 0, this_size
);
1857 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1859 mark_value_bits_unavailable (v
, offset
, this_size_bits
);
1864 case DWARF_VALUE_MEMORY
:
1865 read_value_memory (v
, offset
,
1866 p
->v
.mem
.in_stack_memory
,
1867 p
->v
.mem
.addr
+ source_offset
,
1868 buffer
.data (), this_size
);
1871 case DWARF_VALUE_STACK
:
1873 size_t n
= this_size
;
1875 if (n
> c
->addr_size
- source_offset
)
1876 n
= (c
->addr_size
>= source_offset
1877 ? c
->addr_size
- source_offset
1885 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
1887 intermediate_buffer
= val_bytes
+ source_offset
;
1892 case DWARF_VALUE_LITERAL
:
1894 size_t n
= this_size
;
1896 if (n
> p
->v
.literal
.length
- source_offset
)
1897 n
= (p
->v
.literal
.length
>= source_offset
1898 ? p
->v
.literal
.length
- source_offset
1901 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
1905 /* These bits show up as zeros -- but do not cause the value
1906 to be considered optimized-out. */
1907 case DWARF_VALUE_IMPLICIT_POINTER
:
1910 case DWARF_VALUE_OPTIMIZED_OUT
:
1911 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1915 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1918 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
1919 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1920 copy_bitwise (contents
, dest_offset_bits
,
1921 intermediate_buffer
, source_offset_bits
% 8,
1922 this_size_bits
, bits_big_endian
);
1924 offset
+= this_size_bits
;
1929 write_pieced_value (struct value
*to
, struct value
*from
)
1933 ULONGEST bits_to_skip
;
1934 const gdb_byte
*contents
;
1935 struct piece_closure
*c
1936 = (struct piece_closure
*) value_computed_closure (to
);
1938 size_t buffer_size
= 0;
1939 std::vector
<gdb_byte
> buffer
;
1941 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
1943 contents
= value_contents (from
);
1944 bits_to_skip
= 8 * value_offset (to
);
1945 if (value_bitsize (to
))
1947 bits_to_skip
+= value_bitpos (to
);
1948 type_len
= value_bitsize (to
);
1951 type_len
= 8 * TYPE_LENGTH (value_type (to
));
1953 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1955 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1956 size_t this_size_bits
, this_size
;
1957 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
1959 const gdb_byte
*source_buffer
;
1961 this_size_bits
= p
->size
;
1962 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1964 bits_to_skip
-= this_size_bits
;
1967 if (this_size_bits
> type_len
- offset
)
1968 this_size_bits
= type_len
- offset
;
1969 if (bits_to_skip
> 0)
1971 dest_offset_bits
= bits_to_skip
;
1972 source_offset_bits
= 0;
1973 this_size_bits
-= bits_to_skip
;
1978 dest_offset_bits
= 0;
1979 source_offset_bits
= offset
;
1982 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1983 source_offset
= source_offset_bits
/ 8;
1984 dest_offset
= dest_offset_bits
/ 8;
1985 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
1987 source_buffer
= contents
+ source_offset
;
1992 if (buffer_size
< this_size
)
1994 buffer_size
= this_size
;
1995 buffer
.reserve (buffer_size
);
1997 source_buffer
= buffer
.data ();
2001 switch (p
->location
)
2003 case DWARF_VALUE_REGISTER
:
2005 struct frame_info
*frame
= frame_find_by_id (c
->frame_id
);
2006 struct gdbarch
*arch
= get_frame_arch (frame
);
2007 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, p
->v
.regno
);
2008 int reg_offset
= dest_offset
;
2010 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
2011 && this_size
<= register_size (arch
, gdb_regnum
))
2013 /* Big-endian, and we want less than full size. */
2014 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
2021 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
2022 this_size
, buffer
.data (),
2026 throw_error (OPTIMIZED_OUT_ERROR
,
2027 _("Can't do read-modify-write to "
2028 "update bitfield; containing word "
2029 "has been optimized out"));
2031 throw_error (NOT_AVAILABLE_ERROR
,
2032 _("Can't do read-modify-write to update "
2033 "bitfield; containing word "
2036 copy_bitwise (buffer
.data (), dest_offset_bits
,
2037 contents
, source_offset_bits
,
2042 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
2043 this_size
, source_buffer
);
2046 case DWARF_VALUE_MEMORY
:
2049 /* Only the first and last bytes can possibly have any
2051 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
.data (), 1);
2052 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
2053 &buffer
[this_size
- 1], 1);
2054 copy_bitwise (buffer
.data (), dest_offset_bits
,
2055 contents
, source_offset_bits
,
2060 write_memory (p
->v
.mem
.addr
+ dest_offset
,
2061 source_buffer
, this_size
);
2064 mark_value_bytes_optimized_out (to
, 0, TYPE_LENGTH (value_type (to
)));
2067 offset
+= this_size_bits
;
2071 /* An implementation of an lval_funcs method to see whether a value is
2072 a synthetic pointer. */
2075 check_pieced_synthetic_pointer (const struct value
*value
, LONGEST bit_offset
,
2078 struct piece_closure
*c
2079 = (struct piece_closure
*) value_computed_closure (value
);
2082 bit_offset
+= 8 * value_offset (value
);
2083 if (value_bitsize (value
))
2084 bit_offset
+= value_bitpos (value
);
2086 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2088 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2089 size_t this_size_bits
= p
->size
;
2093 if (bit_offset
>= this_size_bits
)
2095 bit_offset
-= this_size_bits
;
2099 bit_length
-= this_size_bits
- bit_offset
;
2103 bit_length
-= this_size_bits
;
2105 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2112 /* A wrapper function for get_frame_address_in_block. */
2115 get_frame_address_in_block_wrapper (void *baton
)
2117 return get_frame_address_in_block ((struct frame_info
*) baton
);
2120 /* Fetch a DW_AT_const_value through a synthetic pointer. */
2122 static struct value
*
2123 fetch_const_value_from_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
2124 struct dwarf2_per_cu_data
*per_cu
,
2127 struct value
*result
= NULL
;
2128 struct obstack temp_obstack
;
2129 struct cleanup
*cleanup
;
2130 const gdb_byte
*bytes
;
2133 obstack_init (&temp_obstack
);
2134 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2135 bytes
= dwarf2_fetch_constant_bytes (die
, per_cu
, &temp_obstack
, &len
);
2139 if (byte_offset
>= 0
2140 && byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) <= len
)
2142 bytes
+= byte_offset
;
2143 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
2146 invalid_synthetic_pointer ();
2149 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
2151 do_cleanups (cleanup
);
2156 /* Fetch the value pointed to by a synthetic pointer. */
2158 static struct value
*
2159 indirect_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
2160 struct dwarf2_per_cu_data
*per_cu
,
2161 struct frame_info
*frame
, struct type
*type
)
2163 /* Fetch the location expression of the DIE we're pointing to. */
2164 struct dwarf2_locexpr_baton baton
2165 = dwarf2_fetch_die_loc_sect_off (die
, per_cu
,
2166 get_frame_address_in_block_wrapper
, frame
);
2168 /* If pointed-to DIE has a DW_AT_location, evaluate it and return the
2169 resulting value. Otherwise, it may have a DW_AT_const_value instead,
2170 or it may've been optimized out. */
2171 if (baton
.data
!= NULL
)
2172 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
2173 baton
.data
, baton
.size
, baton
.per_cu
,
2176 return fetch_const_value_from_synthetic_pointer (die
, byte_offset
, per_cu
,
2180 /* An implementation of an lval_funcs method to indirect through a
2181 pointer. This handles the synthetic pointer case when needed. */
2183 static struct value
*
2184 indirect_pieced_value (struct value
*value
)
2186 struct piece_closure
*c
2187 = (struct piece_closure
*) value_computed_closure (value
);
2189 struct frame_info
*frame
;
2190 struct dwarf2_locexpr_baton baton
;
2193 struct dwarf_expr_piece
*piece
= NULL
;
2194 LONGEST byte_offset
;
2195 enum bfd_endian byte_order
;
2197 type
= check_typedef (value_type (value
));
2198 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
2201 bit_length
= 8 * TYPE_LENGTH (type
);
2202 bit_offset
= 8 * value_offset (value
);
2203 if (value_bitsize (value
))
2204 bit_offset
+= value_bitpos (value
);
2206 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2208 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2209 size_t this_size_bits
= p
->size
;
2213 if (bit_offset
>= this_size_bits
)
2215 bit_offset
-= this_size_bits
;
2219 bit_length
-= this_size_bits
- bit_offset
;
2223 bit_length
-= this_size_bits
;
2225 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2228 if (bit_length
!= 0)
2229 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2235 gdb_assert (piece
!= NULL
);
2236 frame
= get_selected_frame (_("No frame selected."));
2238 /* This is an offset requested by GDB, such as value subscripts.
2239 However, due to how synthetic pointers are implemented, this is
2240 always presented to us as a pointer type. This means we have to
2241 sign-extend it manually as appropriate. Use raw
2242 extract_signed_integer directly rather than value_as_address and
2243 sign extend afterwards on architectures that would need it
2244 (mostly everywhere except MIPS, which has signed addresses) as
2245 the later would go through gdbarch_pointer_to_address and thus
2246 return a CORE_ADDR with high bits set on architectures that
2247 encode address spaces and other things in CORE_ADDR. */
2248 byte_order
= gdbarch_byte_order (get_frame_arch (frame
));
2249 byte_offset
= extract_signed_integer (value_contents (value
),
2250 TYPE_LENGTH (type
), byte_order
);
2251 byte_offset
+= piece
->v
.ptr
.offset
;
2253 return indirect_synthetic_pointer (piece
->v
.ptr
.die
, byte_offset
, c
->per_cu
,
2257 /* Implementation of the coerce_ref method of lval_funcs for synthetic C++
2260 static struct value
*
2261 coerce_pieced_ref (const struct value
*value
)
2263 struct type
*type
= check_typedef (value_type (value
));
2265 if (value_bits_synthetic_pointer (value
, value_embedded_offset (value
),
2266 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
2268 const struct piece_closure
*closure
2269 = (struct piece_closure
*) value_computed_closure (value
);
2270 struct frame_info
*frame
2271 = get_selected_frame (_("No frame selected."));
2273 /* gdb represents synthetic pointers as pieced values with a single
2275 gdb_assert (closure
!= NULL
);
2276 gdb_assert (closure
->n_pieces
== 1);
2278 return indirect_synthetic_pointer (closure
->pieces
->v
.ptr
.die
,
2279 closure
->pieces
->v
.ptr
.offset
,
2280 closure
->per_cu
, frame
, type
);
2284 /* Else: not a synthetic reference; do nothing. */
2290 copy_pieced_value_closure (const struct value
*v
)
2292 struct piece_closure
*c
2293 = (struct piece_closure
*) value_computed_closure (v
);
2300 free_pieced_value_closure (struct value
*v
)
2302 struct piece_closure
*c
2303 = (struct piece_closure
*) value_computed_closure (v
);
2310 for (i
= 0; i
< c
->n_pieces
; ++i
)
2311 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
2312 value_free (c
->pieces
[i
].v
.value
);
2319 /* Functions for accessing a variable described by DW_OP_piece. */
2320 static const struct lval_funcs pieced_value_funcs
= {
2323 indirect_pieced_value
,
2325 check_pieced_synthetic_pointer
,
2326 copy_pieced_value_closure
,
2327 free_pieced_value_closure
2330 /* Evaluate a location description, starting at DATA and with length
2331 SIZE, to find the current location of variable of TYPE in the
2332 context of FRAME. BYTE_OFFSET is applied after the contents are
2335 static struct value
*
2336 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2337 const gdb_byte
*data
, size_t size
,
2338 struct dwarf2_per_cu_data
*per_cu
,
2339 LONGEST byte_offset
)
2341 struct value
*retval
;
2342 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2344 if (byte_offset
< 0)
2345 invalid_synthetic_pointer ();
2348 return allocate_optimized_out_value (type
);
2350 dwarf_evaluate_loc_desc ctx
;
2352 ctx
.per_cu
= per_cu
;
2353 ctx
.obj_address
= 0;
2355 scoped_value_mark free_values
;
2357 ctx
.gdbarch
= get_objfile_arch (objfile
);
2358 ctx
.addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2359 ctx
.ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2360 ctx
.offset
= dwarf2_per_cu_text_offset (per_cu
);
2364 ctx
.eval (data
, size
);
2366 CATCH (ex
, RETURN_MASK_ERROR
)
2368 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2370 free_values
.free_to_mark ();
2371 retval
= allocate_value (type
);
2372 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
2375 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2377 if (entry_values_debug
)
2378 exception_print (gdb_stdout
, ex
);
2379 free_values
.free_to_mark ();
2380 return allocate_optimized_out_value (type
);
2383 throw_exception (ex
);
2387 if (ctx
.num_pieces
> 0)
2389 struct piece_closure
*c
;
2390 ULONGEST bit_size
= 0;
2393 for (i
= 0; i
< ctx
.num_pieces
; ++i
)
2394 bit_size
+= ctx
.pieces
[i
].size
;
2395 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
2396 invalid_synthetic_pointer ();
2398 c
= allocate_piece_closure (per_cu
, ctx
.num_pieces
, ctx
.pieces
,
2399 ctx
.addr_size
, frame
);
2400 /* We must clean up the value chain after creating the piece
2401 closure but before allocating the result. */
2402 free_values
.free_to_mark ();
2403 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
2404 set_value_offset (retval
, byte_offset
);
2408 switch (ctx
.location
)
2410 case DWARF_VALUE_REGISTER
:
2412 struct gdbarch
*arch
= get_frame_arch (frame
);
2414 = longest_to_int (value_as_long (ctx
.fetch (0)));
2415 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, dwarf_regnum
);
2417 if (byte_offset
!= 0)
2418 error (_("cannot use offset on synthetic pointer to register"));
2419 free_values
.free_to_mark ();
2420 retval
= value_from_register (type
, gdb_regnum
, frame
);
2421 if (value_optimized_out (retval
))
2425 /* This means the register has undefined value / was
2426 not saved. As we're computing the location of some
2427 variable etc. in the program, not a value for
2428 inspecting a register ($pc, $sp, etc.), return a
2429 generic optimized out value instead, so that we show
2430 <optimized out> instead of <not saved>. */
2431 tmp
= allocate_value (type
);
2432 value_contents_copy (tmp
, 0, retval
, 0, TYPE_LENGTH (type
));
2438 case DWARF_VALUE_MEMORY
:
2440 struct type
*ptr_type
;
2441 CORE_ADDR address
= ctx
.fetch_address (0);
2442 int in_stack_memory
= ctx
.fetch_in_stack_memory (0);
2444 /* DW_OP_deref_size (and possibly other operations too) may
2445 create a pointer instead of an address. Ideally, the
2446 pointer to address conversion would be performed as part
2447 of those operations, but the type of the object to
2448 which the address refers is not known at the time of
2449 the operation. Therefore, we do the conversion here
2450 since the type is readily available. */
2452 switch (TYPE_CODE (type
))
2454 case TYPE_CODE_FUNC
:
2455 case TYPE_CODE_METHOD
:
2456 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_func_ptr
;
2459 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_data_ptr
;
2462 address
= value_as_address (value_from_pointer (ptr_type
, address
));
2464 free_values
.free_to_mark ();
2465 retval
= value_at_lazy (type
, address
+ byte_offset
);
2466 if (in_stack_memory
)
2467 set_value_stack (retval
, 1);
2471 case DWARF_VALUE_STACK
:
2473 struct value
*value
= ctx
.fetch (0);
2475 const gdb_byte
*val_bytes
;
2476 size_t n
= TYPE_LENGTH (value_type (value
));
2477 struct cleanup
*cleanup
;
2479 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2480 invalid_synthetic_pointer ();
2482 val_bytes
= value_contents_all (value
);
2483 val_bytes
+= byte_offset
;
2486 /* Preserve VALUE because we are going to free values back
2487 to the mark, but we still need the value contents
2489 value_incref (value
);
2490 free_values
.free_to_mark ();
2491 cleanup
= make_cleanup_value_free (value
);
2493 retval
= allocate_value (type
);
2494 contents
= value_contents_raw (retval
);
2495 if (n
> TYPE_LENGTH (type
))
2497 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2499 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2500 val_bytes
+= n
- TYPE_LENGTH (type
);
2501 n
= TYPE_LENGTH (type
);
2503 memcpy (contents
, val_bytes
, n
);
2505 do_cleanups (cleanup
);
2509 case DWARF_VALUE_LITERAL
:
2512 size_t n
= TYPE_LENGTH (type
);
2514 if (byte_offset
+ n
> ctx
.len
)
2515 invalid_synthetic_pointer ();
2517 free_values
.free_to_mark ();
2518 retval
= allocate_value (type
);
2519 contents
= value_contents_raw (retval
);
2520 memcpy (contents
, ctx
.data
+ byte_offset
, n
);
2524 case DWARF_VALUE_OPTIMIZED_OUT
:
2525 free_values
.free_to_mark ();
2526 retval
= allocate_optimized_out_value (type
);
2529 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2530 operation by execute_stack_op. */
2531 case DWARF_VALUE_IMPLICIT_POINTER
:
2532 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2533 it can only be encountered when making a piece. */
2535 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2539 set_value_initialized (retval
, ctx
.initialized
);
2544 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2545 passes 0 as the byte_offset. */
2548 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2549 const gdb_byte
*data
, size_t size
,
2550 struct dwarf2_per_cu_data
*per_cu
)
2552 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
2555 /* Evaluates a dwarf expression and stores the result in VAL, expecting
2556 that the dwarf expression only produces a single CORE_ADDR. FRAME is the
2557 frame in which the expression is evaluated. ADDR is a context (location of
2558 a variable) and might be needed to evaluate the location expression.
2559 Returns 1 on success, 0 otherwise. */
2562 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton
*dlbaton
,
2563 struct frame_info
*frame
,
2567 struct objfile
*objfile
;
2569 if (dlbaton
== NULL
|| dlbaton
->size
== 0)
2572 dwarf_evaluate_loc_desc ctx
;
2575 ctx
.per_cu
= dlbaton
->per_cu
;
2576 ctx
.obj_address
= addr
;
2578 objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2580 ctx
.gdbarch
= get_objfile_arch (objfile
);
2581 ctx
.addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2582 ctx
.ref_addr_size
= dwarf2_per_cu_ref_addr_size (dlbaton
->per_cu
);
2583 ctx
.offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
2585 ctx
.eval (dlbaton
->data
, dlbaton
->size
);
2587 switch (ctx
.location
)
2589 case DWARF_VALUE_REGISTER
:
2590 case DWARF_VALUE_MEMORY
:
2591 case DWARF_VALUE_STACK
:
2592 *valp
= ctx
.fetch_address (0);
2593 if (ctx
.location
== DWARF_VALUE_REGISTER
)
2594 *valp
= ctx
.read_addr_from_reg (*valp
);
2596 case DWARF_VALUE_LITERAL
:
2597 *valp
= extract_signed_integer (ctx
.data
, ctx
.len
,
2598 gdbarch_byte_order (ctx
.gdbarch
));
2600 /* Unsupported dwarf values. */
2601 case DWARF_VALUE_OPTIMIZED_OUT
:
2602 case DWARF_VALUE_IMPLICIT_POINTER
:
2609 /* See dwarf2loc.h. */
2612 dwarf2_evaluate_property (const struct dynamic_prop
*prop
,
2613 struct frame_info
*frame
,
2614 struct property_addr_info
*addr_stack
,
2620 if (frame
== NULL
&& has_stack_frames ())
2621 frame
= get_selected_frame (NULL
);
2627 const struct dwarf2_property_baton
*baton
2628 = (const struct dwarf2_property_baton
*) prop
->data
.baton
;
2630 if (dwarf2_locexpr_baton_eval (&baton
->locexpr
, frame
,
2631 addr_stack
? addr_stack
->addr
: 0,
2634 if (baton
->referenced_type
)
2636 struct value
*val
= value_at (baton
->referenced_type
, *value
);
2638 *value
= value_as_address (val
);
2647 struct dwarf2_property_baton
*baton
2648 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2649 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2650 const gdb_byte
*data
;
2654 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2657 val
= dwarf2_evaluate_loc_desc (baton
->referenced_type
, frame
, data
,
2658 size
, baton
->loclist
.per_cu
);
2659 if (!value_optimized_out (val
))
2661 *value
= value_as_address (val
);
2669 *value
= prop
->data
.const_val
;
2672 case PROP_ADDR_OFFSET
:
2674 struct dwarf2_property_baton
*baton
2675 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2676 struct property_addr_info
*pinfo
;
2679 for (pinfo
= addr_stack
; pinfo
!= NULL
; pinfo
= pinfo
->next
)
2680 if (pinfo
->type
== baton
->referenced_type
)
2683 error (_("cannot find reference address for offset property"));
2684 if (pinfo
->valaddr
!= NULL
)
2685 val
= value_from_contents
2686 (baton
->offset_info
.type
,
2687 pinfo
->valaddr
+ baton
->offset_info
.offset
);
2689 val
= value_at (baton
->offset_info
.type
,
2690 pinfo
->addr
+ baton
->offset_info
.offset
);
2691 *value
= value_as_address (val
);
2699 /* See dwarf2loc.h. */
2702 dwarf2_compile_property_to_c (string_file
&stream
,
2703 const char *result_name
,
2704 struct gdbarch
*gdbarch
,
2705 unsigned char *registers_used
,
2706 const struct dynamic_prop
*prop
,
2710 struct dwarf2_property_baton
*baton
2711 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2712 const gdb_byte
*data
;
2714 struct dwarf2_per_cu_data
*per_cu
;
2716 if (prop
->kind
== PROP_LOCEXPR
)
2718 data
= baton
->locexpr
.data
;
2719 size
= baton
->locexpr
.size
;
2720 per_cu
= baton
->locexpr
.per_cu
;
2724 gdb_assert (prop
->kind
== PROP_LOCLIST
);
2726 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2727 per_cu
= baton
->loclist
.per_cu
;
2730 compile_dwarf_bounds_to_c (stream
, result_name
, prop
, sym
, pc
,
2731 gdbarch
, registers_used
,
2732 dwarf2_per_cu_addr_size (per_cu
),
2733 data
, data
+ size
, per_cu
);
2737 /* Helper functions and baton for dwarf2_loc_desc_get_symbol_read_needs. */
2739 class symbol_needs_eval_context
: public dwarf_expr_context
2743 enum symbol_needs_kind needs
;
2744 struct dwarf2_per_cu_data
*per_cu
;
2746 /* Reads from registers do require a frame. */
2747 CORE_ADDR
read_addr_from_reg (int regnum
) OVERRIDE
2749 needs
= SYMBOL_NEEDS_FRAME
;
2753 /* "get_reg_value" callback: Reads from registers do require a
2756 struct value
*get_reg_value (struct type
*type
, int regnum
) OVERRIDE
2758 needs
= SYMBOL_NEEDS_FRAME
;
2759 return value_zero (type
, not_lval
);
2762 /* Reads from memory do not require a frame. */
2763 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) OVERRIDE
2765 memset (buf
, 0, len
);
2768 /* Frame-relative accesses do require a frame. */
2769 void get_frame_base (const gdb_byte
**start
, size_t *length
) OVERRIDE
2771 static gdb_byte lit0
= DW_OP_lit0
;
2776 needs
= SYMBOL_NEEDS_FRAME
;
2779 /* CFA accesses require a frame. */
2780 CORE_ADDR
get_frame_cfa () OVERRIDE
2782 needs
= SYMBOL_NEEDS_FRAME
;
2786 CORE_ADDR
get_frame_pc () OVERRIDE
2788 needs
= SYMBOL_NEEDS_FRAME
;
2792 /* Thread-local accesses require registers, but not a frame. */
2793 CORE_ADDR
get_tls_address (CORE_ADDR offset
) OVERRIDE
2795 if (needs
<= SYMBOL_NEEDS_REGISTERS
)
2796 needs
= SYMBOL_NEEDS_REGISTERS
;
2800 /* Helper interface of per_cu_dwarf_call for
2801 dwarf2_loc_desc_get_symbol_read_needs. */
2803 void dwarf_call (cu_offset die_offset
) OVERRIDE
2805 per_cu_dwarf_call (this, die_offset
, per_cu
);
2808 /* DW_OP_GNU_entry_value accesses require a caller, therefore a
2811 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
2812 union call_site_parameter_u kind_u
,
2813 int deref_size
) OVERRIDE
2815 needs
= SYMBOL_NEEDS_FRAME
;
2817 /* The expression may require some stub values on DWARF stack. */
2818 push_address (0, 0);
2821 /* DW_OP_GNU_addr_index doesn't require a frame. */
2823 CORE_ADDR
get_addr_index (unsigned int index
) OVERRIDE
2825 /* Nothing to do. */
2829 /* DW_OP_push_object_address has a frame already passed through. */
2831 CORE_ADDR
get_object_address () OVERRIDE
2833 /* Nothing to do. */
2838 /* Compute the correct symbol_needs_kind value for the location
2839 expression at DATA (length SIZE). */
2841 static enum symbol_needs_kind
2842 dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte
*data
, size_t size
,
2843 struct dwarf2_per_cu_data
*per_cu
)
2846 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2848 scoped_value_mark free_values
;
2850 symbol_needs_eval_context ctx
;
2852 ctx
.needs
= SYMBOL_NEEDS_NONE
;
2853 ctx
.per_cu
= per_cu
;
2854 ctx
.gdbarch
= get_objfile_arch (objfile
);
2855 ctx
.addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2856 ctx
.ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2857 ctx
.offset
= dwarf2_per_cu_text_offset (per_cu
);
2859 ctx
.eval (data
, size
);
2861 in_reg
= ctx
.location
== DWARF_VALUE_REGISTER
;
2863 if (ctx
.num_pieces
> 0)
2867 /* If the location has several pieces, and any of them are in
2868 registers, then we will need a frame to fetch them from. */
2869 for (i
= 0; i
< ctx
.num_pieces
; i
++)
2870 if (ctx
.pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2875 ctx
.needs
= SYMBOL_NEEDS_FRAME
;
2879 /* A helper function that throws an unimplemented error mentioning a
2880 given DWARF operator. */
2883 unimplemented (unsigned int op
)
2885 const char *name
= get_DW_OP_name (op
);
2888 error (_("DWARF operator %s cannot be translated to an agent expression"),
2891 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2892 "to an agent expression"),
2898 This is basically a wrapper on gdbarch_dwarf2_reg_to_regnum so that we
2899 can issue a complaint, which is better than having every target's
2900 implementation of dwarf2_reg_to_regnum do it. */
2903 dwarf_reg_to_regnum (struct gdbarch
*arch
, int dwarf_reg
)
2905 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2909 complaint (&symfile_complaints
,
2910 _("bad DWARF register number %d"), dwarf_reg
);
2915 /* Subroutine of dwarf_reg_to_regnum_or_error to simplify it.
2916 Throw an error because DWARF_REG is bad. */
2919 throw_bad_regnum_error (ULONGEST dwarf_reg
)
2921 /* Still want to print -1 as "-1".
2922 We *could* have int and ULONGEST versions of dwarf2_reg_to_regnum_or_error
2923 but that's overkill for now. */
2924 if ((int) dwarf_reg
== dwarf_reg
)
2925 error (_("Unable to access DWARF register number %d"), (int) dwarf_reg
);
2926 error (_("Unable to access DWARF register number %s"),
2927 pulongest (dwarf_reg
));
2930 /* See dwarf2loc.h. */
2933 dwarf_reg_to_regnum_or_error (struct gdbarch
*arch
, ULONGEST dwarf_reg
)
2937 if (dwarf_reg
> INT_MAX
)
2938 throw_bad_regnum_error (dwarf_reg
);
2939 /* Yes, we will end up issuing a complaint and an error if DWARF_REG is
2940 bad, but that's ok. */
2941 reg
= dwarf_reg_to_regnum (arch
, (int) dwarf_reg
);
2943 throw_bad_regnum_error (dwarf_reg
);
2947 /* A helper function that emits an access to memory. ARCH is the
2948 target architecture. EXPR is the expression which we are building.
2949 NBITS is the number of bits we want to read. This emits the
2950 opcodes needed to read the memory and then extract the desired
2954 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2956 ULONGEST nbytes
= (nbits
+ 7) / 8;
2958 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2961 ax_trace_quick (expr
, nbytes
);
2964 ax_simple (expr
, aop_ref8
);
2965 else if (nbits
<= 16)
2966 ax_simple (expr
, aop_ref16
);
2967 else if (nbits
<= 32)
2968 ax_simple (expr
, aop_ref32
);
2970 ax_simple (expr
, aop_ref64
);
2972 /* If we read exactly the number of bytes we wanted, we're done. */
2973 if (8 * nbytes
== nbits
)
2976 if (gdbarch_bits_big_endian (arch
))
2978 /* On a bits-big-endian machine, we want the high-order
2980 ax_const_l (expr
, 8 * nbytes
- nbits
);
2981 ax_simple (expr
, aop_rsh_unsigned
);
2985 /* On a bits-little-endian box, we want the low-order NBITS. */
2986 ax_zero_ext (expr
, nbits
);
2990 /* A helper function to return the frame's PC. */
2993 get_ax_pc (void *baton
)
2995 struct agent_expr
*expr
= (struct agent_expr
*) baton
;
3000 /* Compile a DWARF location expression to an agent expression.
3002 EXPR is the agent expression we are building.
3003 LOC is the agent value we modify.
3004 ARCH is the architecture.
3005 ADDR_SIZE is the size of addresses, in bytes.
3006 OP_PTR is the start of the location expression.
3007 OP_END is one past the last byte of the location expression.
3009 This will throw an exception for various kinds of errors -- for
3010 example, if the expression cannot be compiled, or if the expression
3014 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
3015 struct gdbarch
*arch
, unsigned int addr_size
,
3016 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
3017 struct dwarf2_per_cu_data
*per_cu
)
3020 std::vector
<int> dw_labels
, patches
;
3021 const gdb_byte
* const base
= op_ptr
;
3022 const gdb_byte
*previous_piece
= op_ptr
;
3023 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
3024 ULONGEST bits_collected
= 0;
3025 unsigned int addr_size_bits
= 8 * addr_size
;
3026 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
3028 std::vector
<int> offsets (op_end
- op_ptr
, -1);
3030 /* By default we are making an address. */
3031 loc
->kind
= axs_lvalue_memory
;
3033 while (op_ptr
< op_end
)
3035 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
3036 uint64_t uoffset
, reg
;
3040 offsets
[op_ptr
- base
] = expr
->len
;
3043 /* Our basic approach to code generation is to map DWARF
3044 operations directly to AX operations. However, there are
3047 First, DWARF works on address-sized units, but AX always uses
3048 LONGEST. For most operations we simply ignore this
3049 difference; instead we generate sign extensions as needed
3050 before division and comparison operations. It would be nice
3051 to omit the sign extensions, but there is no way to determine
3052 the size of the target's LONGEST. (This code uses the size
3053 of the host LONGEST in some cases -- that is a bug but it is
3056 Second, some DWARF operations cannot be translated to AX.
3057 For these we simply fail. See
3058 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
3093 ax_const_l (expr
, op
- DW_OP_lit0
);
3097 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
3098 op_ptr
+= addr_size
;
3099 /* Some versions of GCC emit DW_OP_addr before
3100 DW_OP_GNU_push_tls_address. In this case the value is an
3101 index, not an address. We don't support things like
3102 branching between the address and the TLS op. */
3103 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
3104 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
3105 ax_const_l (expr
, uoffset
);
3109 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
3113 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
3117 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
3121 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
3125 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
3129 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
3133 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
3137 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
3141 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3142 ax_const_l (expr
, uoffset
);
3145 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3146 ax_const_l (expr
, offset
);
3181 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3182 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_reg0
);
3183 loc
->kind
= axs_lvalue_register
;
3187 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3188 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3189 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3190 loc
->kind
= axs_lvalue_register
;
3193 case DW_OP_implicit_value
:
3197 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
3198 if (op_ptr
+ len
> op_end
)
3199 error (_("DW_OP_implicit_value: too few bytes available."));
3200 if (len
> sizeof (ULONGEST
))
3201 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
3204 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
3207 dwarf_expr_require_composition (op_ptr
, op_end
,
3208 "DW_OP_implicit_value");
3210 loc
->kind
= axs_rvalue
;
3214 case DW_OP_stack_value
:
3215 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
3216 loc
->kind
= axs_rvalue
;
3251 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3252 i
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_breg0
);
3256 ax_const_l (expr
, offset
);
3257 ax_simple (expr
, aop_add
);
3262 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3263 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3264 i
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3268 ax_const_l (expr
, offset
);
3269 ax_simple (expr
, aop_add
);
3275 const gdb_byte
*datastart
;
3277 const struct block
*b
;
3278 struct symbol
*framefunc
;
3280 b
= block_for_pc (expr
->scope
);
3283 error (_("No block found for address"));
3285 framefunc
= block_linkage_function (b
);
3288 error (_("No function found for block"));
3290 func_get_frame_base_dwarf_block (framefunc
, expr
->scope
,
3291 &datastart
, &datalen
);
3293 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3294 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
3295 datastart
+ datalen
, per_cu
);
3296 if (loc
->kind
== axs_lvalue_register
)
3297 require_rvalue (expr
, loc
);
3301 ax_const_l (expr
, offset
);
3302 ax_simple (expr
, aop_add
);
3305 loc
->kind
= axs_lvalue_memory
;
3310 ax_simple (expr
, aop_dup
);
3314 ax_simple (expr
, aop_pop
);
3319 ax_pick (expr
, offset
);
3323 ax_simple (expr
, aop_swap
);
3331 ax_simple (expr
, aop_rot
);
3335 case DW_OP_deref_size
:
3339 if (op
== DW_OP_deref_size
)
3344 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3345 error (_("Unsupported size %d in %s"),
3346 size
, get_DW_OP_name (op
));
3347 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3352 /* Sign extend the operand. */
3353 ax_ext (expr
, addr_size_bits
);
3354 ax_simple (expr
, aop_dup
);
3355 ax_const_l (expr
, 0);
3356 ax_simple (expr
, aop_less_signed
);
3357 ax_simple (expr
, aop_log_not
);
3358 i
= ax_goto (expr
, aop_if_goto
);
3359 /* We have to emit 0 - X. */
3360 ax_const_l (expr
, 0);
3361 ax_simple (expr
, aop_swap
);
3362 ax_simple (expr
, aop_sub
);
3363 ax_label (expr
, i
, expr
->len
);
3367 /* No need to sign extend here. */
3368 ax_const_l (expr
, 0);
3369 ax_simple (expr
, aop_swap
);
3370 ax_simple (expr
, aop_sub
);
3374 /* Sign extend the operand. */
3375 ax_ext (expr
, addr_size_bits
);
3376 ax_simple (expr
, aop_bit_not
);
3379 case DW_OP_plus_uconst
:
3380 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3381 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3382 but we micro-optimize anyhow. */
3385 ax_const_l (expr
, reg
);
3386 ax_simple (expr
, aop_add
);
3391 ax_simple (expr
, aop_bit_and
);
3395 /* Sign extend the operands. */
3396 ax_ext (expr
, addr_size_bits
);
3397 ax_simple (expr
, aop_swap
);
3398 ax_ext (expr
, addr_size_bits
);
3399 ax_simple (expr
, aop_swap
);
3400 ax_simple (expr
, aop_div_signed
);
3404 ax_simple (expr
, aop_sub
);
3408 ax_simple (expr
, aop_rem_unsigned
);
3412 ax_simple (expr
, aop_mul
);
3416 ax_simple (expr
, aop_bit_or
);
3420 ax_simple (expr
, aop_add
);
3424 ax_simple (expr
, aop_lsh
);
3428 ax_simple (expr
, aop_rsh_unsigned
);
3432 ax_simple (expr
, aop_rsh_signed
);
3436 ax_simple (expr
, aop_bit_xor
);
3440 /* Sign extend the operands. */
3441 ax_ext (expr
, addr_size_bits
);
3442 ax_simple (expr
, aop_swap
);
3443 ax_ext (expr
, addr_size_bits
);
3444 /* Note no swap here: A <= B is !(B < A). */
3445 ax_simple (expr
, aop_less_signed
);
3446 ax_simple (expr
, aop_log_not
);
3450 /* Sign extend the operands. */
3451 ax_ext (expr
, addr_size_bits
);
3452 ax_simple (expr
, aop_swap
);
3453 ax_ext (expr
, addr_size_bits
);
3454 ax_simple (expr
, aop_swap
);
3455 /* A >= B is !(A < B). */
3456 ax_simple (expr
, aop_less_signed
);
3457 ax_simple (expr
, aop_log_not
);
3461 /* Sign extend the operands. */
3462 ax_ext (expr
, addr_size_bits
);
3463 ax_simple (expr
, aop_swap
);
3464 ax_ext (expr
, addr_size_bits
);
3465 /* No need for a second swap here. */
3466 ax_simple (expr
, aop_equal
);
3470 /* Sign extend the operands. */
3471 ax_ext (expr
, addr_size_bits
);
3472 ax_simple (expr
, aop_swap
);
3473 ax_ext (expr
, addr_size_bits
);
3474 ax_simple (expr
, aop_swap
);
3475 ax_simple (expr
, aop_less_signed
);
3479 /* Sign extend the operands. */
3480 ax_ext (expr
, addr_size_bits
);
3481 ax_simple (expr
, aop_swap
);
3482 ax_ext (expr
, addr_size_bits
);
3483 /* Note no swap here: A > B is B < A. */
3484 ax_simple (expr
, aop_less_signed
);
3488 /* Sign extend the operands. */
3489 ax_ext (expr
, addr_size_bits
);
3490 ax_simple (expr
, aop_swap
);
3491 ax_ext (expr
, addr_size_bits
);
3492 /* No need for a swap here. */
3493 ax_simple (expr
, aop_equal
);
3494 ax_simple (expr
, aop_log_not
);
3497 case DW_OP_call_frame_cfa
:
3500 CORE_ADDR text_offset
;
3502 const gdb_byte
*cfa_start
, *cfa_end
;
3504 if (dwarf2_fetch_cfa_info (arch
, expr
->scope
, per_cu
,
3506 &text_offset
, &cfa_start
, &cfa_end
))
3509 ax_reg (expr
, regnum
);
3512 ax_const_l (expr
, off
);
3513 ax_simple (expr
, aop_add
);
3518 /* Another expression. */
3519 ax_const_l (expr
, text_offset
);
3520 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3521 cfa_start
, cfa_end
, per_cu
);
3524 loc
->kind
= axs_lvalue_memory
;
3528 case DW_OP_GNU_push_tls_address
:
3529 case DW_OP_form_tls_address
:
3533 case DW_OP_push_object_address
:
3538 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3540 i
= ax_goto (expr
, aop_goto
);
3541 dw_labels
.push_back (op_ptr
+ offset
- base
);
3542 patches
.push_back (i
);
3546 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3548 /* Zero extend the operand. */
3549 ax_zero_ext (expr
, addr_size_bits
);
3550 i
= ax_goto (expr
, aop_if_goto
);
3551 dw_labels
.push_back (op_ptr
+ offset
- base
);
3552 patches
.push_back (i
);
3559 case DW_OP_bit_piece
:
3561 uint64_t size
, offset
;
3563 if (op_ptr
- 1 == previous_piece
)
3564 error (_("Cannot translate empty pieces to agent expressions"));
3565 previous_piece
= op_ptr
- 1;
3567 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3568 if (op
== DW_OP_piece
)
3574 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
3576 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3577 error (_("Expression pieces exceed word size"));
3579 /* Access the bits. */
3582 case axs_lvalue_register
:
3583 ax_reg (expr
, loc
->u
.reg
);
3586 case axs_lvalue_memory
:
3587 /* Offset the pointer, if needed. */
3590 ax_const_l (expr
, offset
/ 8);
3591 ax_simple (expr
, aop_add
);
3594 access_memory (arch
, expr
, size
);
3598 /* For a bits-big-endian target, shift up what we already
3599 have. For a bits-little-endian target, shift up the
3600 new data. Note that there is a potential bug here if
3601 the DWARF expression leaves multiple values on the
3603 if (bits_collected
> 0)
3605 if (bits_big_endian
)
3607 ax_simple (expr
, aop_swap
);
3608 ax_const_l (expr
, size
);
3609 ax_simple (expr
, aop_lsh
);
3610 /* We don't need a second swap here, because
3611 aop_bit_or is symmetric. */
3615 ax_const_l (expr
, size
);
3616 ax_simple (expr
, aop_lsh
);
3618 ax_simple (expr
, aop_bit_or
);
3621 bits_collected
+= size
;
3622 loc
->kind
= axs_rvalue
;
3626 case DW_OP_GNU_uninit
:
3632 struct dwarf2_locexpr_baton block
;
3633 int size
= (op
== DW_OP_call2
? 2 : 4);
3636 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3639 offset
.cu_off
= uoffset
;
3640 block
= dwarf2_fetch_die_loc_cu_off (offset
, per_cu
,
3643 /* DW_OP_call_ref is currently not supported. */
3644 gdb_assert (block
.per_cu
== per_cu
);
3646 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3647 block
.data
, block
.data
+ block
.size
,
3652 case DW_OP_call_ref
:
3660 /* Patch all the branches we emitted. */
3661 for (i
= 0; i
< patches
.size (); ++i
)
3663 int targ
= offsets
[dw_labels
[i
]];
3665 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3666 ax_label (expr
, patches
[i
], targ
);
3671 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3672 evaluator to calculate the location. */
3673 static struct value
*
3674 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3676 struct dwarf2_locexpr_baton
*dlbaton
3677 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3680 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3681 dlbaton
->size
, dlbaton
->per_cu
);
3686 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3687 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3690 static struct value
*
3691 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3693 struct dwarf2_locexpr_baton
*dlbaton
3694 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3696 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3700 /* Implementation of get_symbol_read_needs from
3701 symbol_computed_ops. */
3703 static enum symbol_needs_kind
3704 locexpr_get_symbol_read_needs (struct symbol
*symbol
)
3706 struct dwarf2_locexpr_baton
*dlbaton
3707 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3709 return dwarf2_loc_desc_get_symbol_read_needs (dlbaton
->data
, dlbaton
->size
,
3713 /* Return true if DATA points to the end of a piece. END is one past
3714 the last byte in the expression. */
3717 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3719 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3722 /* Helper for locexpr_describe_location_piece that finds the name of a
3726 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3730 /* This doesn't use dwarf_reg_to_regnum_or_error on purpose.
3731 We'd rather print *something* here than throw an error. */
3732 regnum
= dwarf_reg_to_regnum (gdbarch
, dwarf_regnum
);
3733 /* gdbarch_register_name may just return "", return something more
3734 descriptive for bad register numbers. */
3737 /* The text is output as "$bad_register_number".
3738 That is why we use the underscores. */
3739 return _("bad_register_number");
3741 return gdbarch_register_name (gdbarch
, regnum
);
3744 /* Nicely describe a single piece of a location, returning an updated
3745 position in the bytecode sequence. This function cannot recognize
3746 all locations; if a location is not recognized, it simply returns
3747 DATA. If there is an error during reading, e.g. we run off the end
3748 of the buffer, an error is thrown. */
3750 static const gdb_byte
*
3751 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3752 CORE_ADDR addr
, struct objfile
*objfile
,
3753 struct dwarf2_per_cu_data
*per_cu
,
3754 const gdb_byte
*data
, const gdb_byte
*end
,
3755 unsigned int addr_size
)
3757 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3760 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3762 fprintf_filtered (stream
, _("a variable in $%s"),
3763 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3766 else if (data
[0] == DW_OP_regx
)
3770 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3771 fprintf_filtered (stream
, _("a variable in $%s"),
3772 locexpr_regname (gdbarch
, reg
));
3774 else if (data
[0] == DW_OP_fbreg
)
3776 const struct block
*b
;
3777 struct symbol
*framefunc
;
3779 int64_t frame_offset
;
3780 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3782 int64_t base_offset
= 0;
3784 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3785 if (!piece_end_p (new_data
, end
))
3789 b
= block_for_pc (addr
);
3792 error (_("No block found for address for symbol \"%s\"."),
3793 SYMBOL_PRINT_NAME (symbol
));
3795 framefunc
= block_linkage_function (b
);
3798 error (_("No function found for block for symbol \"%s\"."),
3799 SYMBOL_PRINT_NAME (symbol
));
3801 func_get_frame_base_dwarf_block (framefunc
, addr
, &base_data
, &base_size
);
3803 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3805 const gdb_byte
*buf_end
;
3807 frame_reg
= base_data
[0] - DW_OP_breg0
;
3808 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3810 if (buf_end
!= base_data
+ base_size
)
3811 error (_("Unexpected opcode after "
3812 "DW_OP_breg%u for symbol \"%s\"."),
3813 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3815 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3817 /* The frame base is just the register, with no offset. */
3818 frame_reg
= base_data
[0] - DW_OP_reg0
;
3823 /* We don't know what to do with the frame base expression,
3824 so we can't trace this variable; give up. */
3828 fprintf_filtered (stream
,
3829 _("a variable at frame base reg $%s offset %s+%s"),
3830 locexpr_regname (gdbarch
, frame_reg
),
3831 plongest (base_offset
), plongest (frame_offset
));
3833 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3834 && piece_end_p (data
, end
))
3838 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3840 fprintf_filtered (stream
,
3841 _("a variable at offset %s from base reg $%s"),
3843 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3846 /* The location expression for a TLS variable looks like this (on a
3849 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3850 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3852 0x3 is the encoding for DW_OP_addr, which has an operand as long
3853 as the size of an address on the target machine (here is 8
3854 bytes). Note that more recent version of GCC emit DW_OP_const4u
3855 or DW_OP_const8u, depending on address size, rather than
3856 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3857 The operand represents the offset at which the variable is within
3858 the thread local storage. */
3860 else if (data
+ 1 + addr_size
< end
3861 && (data
[0] == DW_OP_addr
3862 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3863 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3864 && (data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3865 || data
[1 + addr_size
] == DW_OP_form_tls_address
)
3866 && piece_end_p (data
+ 2 + addr_size
, end
))
3869 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3870 gdbarch_byte_order (gdbarch
));
3872 fprintf_filtered (stream
,
3873 _("a thread-local variable at offset 0x%s "
3874 "in the thread-local storage for `%s'"),
3875 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3877 data
+= 1 + addr_size
+ 1;
3880 /* With -gsplit-dwarf a TLS variable can also look like this:
3881 DW_AT_location : 3 byte block: fc 4 e0
3882 (DW_OP_GNU_const_index: 4;
3883 DW_OP_GNU_push_tls_address) */
3884 else if (data
+ 3 <= end
3885 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3886 && data
[0] == DW_OP_GNU_const_index
3888 && (data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3889 || data
[1 + leb128_size
] == DW_OP_form_tls_address
)
3890 && piece_end_p (data
+ 2 + leb128_size
, end
))
3894 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3895 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3896 fprintf_filtered (stream
,
3897 _("a thread-local variable at offset 0x%s "
3898 "in the thread-local storage for `%s'"),
3899 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3903 else if (data
[0] >= DW_OP_lit0
3904 && data
[0] <= DW_OP_lit31
3906 && data
[1] == DW_OP_stack_value
)
3908 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3915 /* Disassemble an expression, stopping at the end of a piece or at the
3916 end of the expression. Returns a pointer to the next unread byte
3917 in the input expression. If ALL is nonzero, then this function
3918 will keep going until it reaches the end of the expression.
3919 If there is an error during reading, e.g. we run off the end
3920 of the buffer, an error is thrown. */
3922 static const gdb_byte
*
3923 disassemble_dwarf_expression (struct ui_file
*stream
,
3924 struct gdbarch
*arch
, unsigned int addr_size
,
3925 int offset_size
, const gdb_byte
*start
,
3926 const gdb_byte
*data
, const gdb_byte
*end
,
3927 int indent
, int all
,
3928 struct dwarf2_per_cu_data
*per_cu
)
3932 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3934 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *data
++;
3939 name
= get_DW_OP_name (op
);
3942 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3943 op
, (long) (data
- 1 - start
));
3944 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3945 (long) (data
- 1 - start
), name
);
3950 ul
= extract_unsigned_integer (data
, addr_size
,
3951 gdbarch_byte_order (arch
));
3953 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3957 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3959 fprintf_filtered (stream
, " %s", pulongest (ul
));
3962 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3964 fprintf_filtered (stream
, " %s", plongest (l
));
3967 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3969 fprintf_filtered (stream
, " %s", pulongest (ul
));
3972 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3974 fprintf_filtered (stream
, " %s", plongest (l
));
3977 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3979 fprintf_filtered (stream
, " %s", pulongest (ul
));
3982 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3984 fprintf_filtered (stream
, " %s", plongest (l
));
3987 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3989 fprintf_filtered (stream
, " %s", pulongest (ul
));
3992 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3994 fprintf_filtered (stream
, " %s", plongest (l
));
3997 data
= safe_read_uleb128 (data
, end
, &ul
);
3998 fprintf_filtered (stream
, " %s", pulongest (ul
));
4001 data
= safe_read_sleb128 (data
, end
, &l
);
4002 fprintf_filtered (stream
, " %s", plongest (l
));
4037 fprintf_filtered (stream
, " [$%s]",
4038 locexpr_regname (arch
, op
- DW_OP_reg0
));
4042 data
= safe_read_uleb128 (data
, end
, &ul
);
4043 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
4044 locexpr_regname (arch
, (int) ul
));
4047 case DW_OP_implicit_value
:
4048 data
= safe_read_uleb128 (data
, end
, &ul
);
4050 fprintf_filtered (stream
, " %s", pulongest (ul
));
4085 data
= safe_read_sleb128 (data
, end
, &l
);
4086 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
4087 locexpr_regname (arch
, op
- DW_OP_breg0
));
4091 data
= safe_read_uleb128 (data
, end
, &ul
);
4092 data
= safe_read_sleb128 (data
, end
, &l
);
4093 fprintf_filtered (stream
, " register %s [$%s] offset %s",
4095 locexpr_regname (arch
, (int) ul
),
4100 data
= safe_read_sleb128 (data
, end
, &l
);
4101 fprintf_filtered (stream
, " %s", plongest (l
));
4104 case DW_OP_xderef_size
:
4105 case DW_OP_deref_size
:
4107 fprintf_filtered (stream
, " %d", *data
);
4111 case DW_OP_plus_uconst
:
4112 data
= safe_read_uleb128 (data
, end
, &ul
);
4113 fprintf_filtered (stream
, " %s", pulongest (ul
));
4117 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4119 fprintf_filtered (stream
, " to %ld",
4120 (long) (data
+ l
- start
));
4124 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4126 fprintf_filtered (stream
, " %ld",
4127 (long) (data
+ l
- start
));
4131 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
4133 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
4137 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4139 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4142 case DW_OP_call_ref
:
4143 ul
= extract_unsigned_integer (data
, offset_size
,
4144 gdbarch_byte_order (arch
));
4145 data
+= offset_size
;
4146 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4150 data
= safe_read_uleb128 (data
, end
, &ul
);
4151 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
4154 case DW_OP_bit_piece
:
4158 data
= safe_read_uleb128 (data
, end
, &ul
);
4159 data
= safe_read_uleb128 (data
, end
, &offset
);
4160 fprintf_filtered (stream
, " size %s offset %s (bits)",
4161 pulongest (ul
), pulongest (offset
));
4165 case DW_OP_GNU_implicit_pointer
:
4167 ul
= extract_unsigned_integer (data
, offset_size
,
4168 gdbarch_byte_order (arch
));
4169 data
+= offset_size
;
4171 data
= safe_read_sleb128 (data
, end
, &l
);
4173 fprintf_filtered (stream
, " DIE %s offset %s",
4174 phex_nz (ul
, offset_size
),
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_GNU_const_type
:
4200 data
= safe_read_uleb128 (data
, end
, &ul
);
4201 type_die
.cu_off
= ul
;
4202 type
= dwarf2_get_die_type (type_die
, per_cu
);
4203 fprintf_filtered (stream
, "<");
4204 type_print (type
, "", stream
, -1);
4205 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
4209 case DW_OP_GNU_regval_type
:
4215 data
= safe_read_uleb128 (data
, end
, ®
);
4216 data
= safe_read_uleb128 (data
, end
, &ul
);
4217 type_die
.cu_off
= ul
;
4219 type
= dwarf2_get_die_type (type_die
, per_cu
);
4220 fprintf_filtered (stream
, "<");
4221 type_print (type
, "", stream
, -1);
4222 fprintf_filtered (stream
, " [0x%s]> [$%s]",
4223 phex_nz (type_die
.cu_off
, 0),
4224 locexpr_regname (arch
, reg
));
4228 case DW_OP_GNU_convert
:
4229 case DW_OP_GNU_reinterpret
:
4233 data
= safe_read_uleb128 (data
, end
, &ul
);
4234 type_die
.cu_off
= ul
;
4236 if (type_die
.cu_off
== 0)
4237 fprintf_filtered (stream
, "<0>");
4242 type
= dwarf2_get_die_type (type_die
, per_cu
);
4243 fprintf_filtered (stream
, "<");
4244 type_print (type
, "", stream
, -1);
4245 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
4250 case DW_OP_GNU_entry_value
:
4251 data
= safe_read_uleb128 (data
, end
, &ul
);
4252 fputc_filtered ('\n', stream
);
4253 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
4254 start
, data
, data
+ ul
, indent
+ 2,
4259 case DW_OP_GNU_parameter_ref
:
4260 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4262 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4265 case DW_OP_GNU_addr_index
:
4266 data
= safe_read_uleb128 (data
, end
, &ul
);
4267 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4268 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
4270 case DW_OP_GNU_const_index
:
4271 data
= safe_read_uleb128 (data
, end
, &ul
);
4272 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4273 fprintf_filtered (stream
, " %s", pulongest (ul
));
4277 fprintf_filtered (stream
, "\n");
4283 /* Describe a single location, which may in turn consist of multiple
4287 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
4288 struct ui_file
*stream
,
4289 const gdb_byte
*data
, size_t size
,
4290 struct objfile
*objfile
, unsigned int addr_size
,
4291 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
4293 const gdb_byte
*end
= data
+ size
;
4294 int first_piece
= 1, bad
= 0;
4298 const gdb_byte
*here
= data
;
4299 int disassemble
= 1;
4304 fprintf_filtered (stream
, _(", and "));
4306 if (!dwarf_always_disassemble
)
4308 data
= locexpr_describe_location_piece (symbol
, stream
,
4309 addr
, objfile
, per_cu
,
4310 data
, end
, addr_size
);
4311 /* If we printed anything, or if we have an empty piece,
4312 then don't disassemble. */
4314 || data
[0] == DW_OP_piece
4315 || data
[0] == DW_OP_bit_piece
)
4320 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
4321 data
= disassemble_dwarf_expression (stream
,
4322 get_objfile_arch (objfile
),
4323 addr_size
, offset_size
, data
,
4325 dwarf_always_disassemble
,
4331 int empty
= data
== here
;
4334 fprintf_filtered (stream
, " ");
4335 if (data
[0] == DW_OP_piece
)
4339 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
4342 fprintf_filtered (stream
, _("an empty %s-byte piece"),
4345 fprintf_filtered (stream
, _(" [%s-byte piece]"),
4348 else if (data
[0] == DW_OP_bit_piece
)
4350 uint64_t bits
, offset
;
4352 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
4353 data
= safe_read_uleb128 (data
, end
, &offset
);
4356 fprintf_filtered (stream
,
4357 _("an empty %s-bit piece"),
4360 fprintf_filtered (stream
,
4361 _(" [%s-bit piece, offset %s bits]"),
4362 pulongest (bits
), pulongest (offset
));
4372 if (bad
|| data
> end
)
4373 error (_("Corrupted DWARF2 expression for \"%s\"."),
4374 SYMBOL_PRINT_NAME (symbol
));
4377 /* Print a natural-language description of SYMBOL to STREAM. This
4378 version is for a symbol with a single location. */
4381 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4382 struct ui_file
*stream
)
4384 struct dwarf2_locexpr_baton
*dlbaton
4385 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4386 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4387 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4388 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4390 locexpr_describe_location_1 (symbol
, addr
, stream
,
4391 dlbaton
->data
, dlbaton
->size
,
4392 objfile
, addr_size
, offset_size
,
4396 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4397 any necessary bytecode in AX. */
4400 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4401 struct agent_expr
*ax
, struct axs_value
*value
)
4403 struct dwarf2_locexpr_baton
*dlbaton
4404 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4405 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4407 if (dlbaton
->size
== 0)
4408 value
->optimized_out
= 1;
4410 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
4411 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4415 /* symbol_computed_ops 'generate_c_location' method. */
4418 locexpr_generate_c_location (struct symbol
*sym
, string_file
&stream
,
4419 struct gdbarch
*gdbarch
,
4420 unsigned char *registers_used
,
4421 CORE_ADDR pc
, const char *result_name
)
4423 struct dwarf2_locexpr_baton
*dlbaton
4424 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (sym
);
4425 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4427 if (dlbaton
->size
== 0)
4428 error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym
));
4430 compile_dwarf_expr_to_c (stream
, result_name
,
4431 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4432 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4436 /* The set of location functions used with the DWARF-2 expression
4438 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4439 locexpr_read_variable
,
4440 locexpr_read_variable_at_entry
,
4441 locexpr_get_symbol_read_needs
,
4442 locexpr_describe_location
,
4443 0, /* location_has_loclist */
4444 locexpr_tracepoint_var_ref
,
4445 locexpr_generate_c_location
4449 /* Wrapper functions for location lists. These generally find
4450 the appropriate location expression and call something above. */
4452 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4453 evaluator to calculate the location. */
4454 static struct value
*
4455 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4457 struct dwarf2_loclist_baton
*dlbaton
4458 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4460 const gdb_byte
*data
;
4462 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4464 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4465 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4471 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4472 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4475 Function always returns non-NULL value, it may be marked optimized out if
4476 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4477 if it cannot resolve the parameter for any reason. */
4479 static struct value
*
4480 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4482 struct dwarf2_loclist_baton
*dlbaton
4483 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4484 const gdb_byte
*data
;
4488 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4489 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4491 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4493 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4495 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4498 /* Implementation of get_symbol_read_needs from
4499 symbol_computed_ops. */
4501 static enum symbol_needs_kind
4502 loclist_symbol_needs (struct symbol
*symbol
)
4504 /* If there's a location list, then assume we need to have a frame
4505 to choose the appropriate location expression. With tracking of
4506 global variables this is not necessarily true, but such tracking
4507 is disabled in GCC at the moment until we figure out how to
4510 return SYMBOL_NEEDS_FRAME
;
4513 /* Print a natural-language description of SYMBOL to STREAM. This
4514 version applies when there is a list of different locations, each
4515 with a specified address range. */
4518 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4519 struct ui_file
*stream
)
4521 struct dwarf2_loclist_baton
*dlbaton
4522 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4523 const gdb_byte
*loc_ptr
, *buf_end
;
4524 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4525 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4526 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4527 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4528 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4529 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4530 /* Adjust base_address for relocatable objects. */
4531 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4532 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4535 loc_ptr
= dlbaton
->data
;
4536 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4538 fprintf_filtered (stream
, _("multi-location:\n"));
4540 /* Iterate through locations until we run out. */
4543 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4545 enum debug_loc_kind kind
;
4546 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4548 if (dlbaton
->from_dwo
)
4549 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4550 loc_ptr
, buf_end
, &new_ptr
,
4551 &low
, &high
, byte_order
);
4553 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4555 byte_order
, addr_size
,
4560 case DEBUG_LOC_END_OF_LIST
:
4563 case DEBUG_LOC_BASE_ADDRESS
:
4564 base_address
= high
+ base_offset
;
4565 fprintf_filtered (stream
, _(" Base address %s"),
4566 paddress (gdbarch
, base_address
));
4568 case DEBUG_LOC_START_END
:
4569 case DEBUG_LOC_START_LENGTH
:
4571 case DEBUG_LOC_BUFFER_OVERFLOW
:
4572 case DEBUG_LOC_INVALID_ENTRY
:
4573 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4574 SYMBOL_PRINT_NAME (symbol
));
4576 gdb_assert_not_reached ("bad debug_loc_kind");
4579 /* Otherwise, a location expression entry. */
4580 low
+= base_address
;
4581 high
+= base_address
;
4583 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
);
4584 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
);
4586 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4589 /* (It would improve readability to print only the minimum
4590 necessary digits of the second number of the range.) */
4591 fprintf_filtered (stream
, _(" Range %s-%s: "),
4592 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4594 /* Now describe this particular location. */
4595 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4596 objfile
, addr_size
, offset_size
,
4599 fprintf_filtered (stream
, "\n");
4605 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4606 any necessary bytecode in AX. */
4608 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4609 struct agent_expr
*ax
, struct axs_value
*value
)
4611 struct dwarf2_loclist_baton
*dlbaton
4612 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4613 const gdb_byte
*data
;
4615 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4617 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4619 value
->optimized_out
= 1;
4621 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
4625 /* symbol_computed_ops 'generate_c_location' method. */
4628 loclist_generate_c_location (struct symbol
*sym
, string_file
&stream
,
4629 struct gdbarch
*gdbarch
,
4630 unsigned char *registers_used
,
4631 CORE_ADDR pc
, const char *result_name
)
4633 struct dwarf2_loclist_baton
*dlbaton
4634 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (sym
);
4635 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4636 const gdb_byte
*data
;
4639 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4641 error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym
));
4643 compile_dwarf_expr_to_c (stream
, result_name
,
4644 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4649 /* The set of location functions used with the DWARF-2 expression
4650 evaluator and location lists. */
4651 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4652 loclist_read_variable
,
4653 loclist_read_variable_at_entry
,
4654 loclist_symbol_needs
,
4655 loclist_describe_location
,
4656 1, /* location_has_loclist */
4657 loclist_tracepoint_var_ref
,
4658 loclist_generate_c_location
4661 /* Provide a prototype to silence -Wmissing-prototypes. */
4662 extern initialize_file_ftype _initialize_dwarf2loc
;
4665 _initialize_dwarf2loc (void)
4667 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4668 &entry_values_debug
,
4669 _("Set entry values and tail call frames "
4671 _("Show entry values and tail call frames "
4673 _("When non-zero, the process of determining "
4674 "parameter values from function entry point "
4675 "and tail call frames will be printed."),
4677 show_entry_values_debug
,
4678 &setdebuglist
, &showdebuglist
);
4681 register_self_test (selftests::copy_bitwise_tests
);