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_loc.dwo 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_loc_dwo_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
)
159 uint64_t low_index
, high_index
;
161 if (loc_ptr
== buf_end
)
162 return DEBUG_LOC_BUFFER_OVERFLOW
;
166 case DEBUG_LOC_END_OF_LIST
:
168 return DEBUG_LOC_END_OF_LIST
;
169 case DEBUG_LOC_BASE_ADDRESS
:
171 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
173 return DEBUG_LOC_BUFFER_OVERFLOW
;
174 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
176 return DEBUG_LOC_BASE_ADDRESS
;
177 case DEBUG_LOC_START_END
:
178 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
180 return DEBUG_LOC_BUFFER_OVERFLOW
;
181 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
182 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
184 return DEBUG_LOC_BUFFER_OVERFLOW
;
185 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
187 return DEBUG_LOC_START_END
;
188 case DEBUG_LOC_START_LENGTH
:
189 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
191 return DEBUG_LOC_BUFFER_OVERFLOW
;
192 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
193 if (loc_ptr
+ 4 > buf_end
)
194 return DEBUG_LOC_BUFFER_OVERFLOW
;
196 *high
+= extract_unsigned_integer (loc_ptr
, 4, byte_order
);
197 *new_ptr
= loc_ptr
+ 4;
198 return DEBUG_LOC_START_LENGTH
;
200 return DEBUG_LOC_INVALID_ENTRY
;
204 /* A function for dealing with location lists. Given a
205 symbol baton (BATON) and a pc value (PC), find the appropriate
206 location expression, set *LOCEXPR_LENGTH, and return a pointer
207 to the beginning of the expression. Returns NULL on failure.
209 For now, only return the first matching location expression; there
210 can be more than one in the list. */
213 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
214 size_t *locexpr_length
, CORE_ADDR pc
)
216 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
217 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
218 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
219 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
220 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
221 /* Adjust base_address for relocatable objects. */
222 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (baton
->per_cu
);
223 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
224 const gdb_byte
*loc_ptr
, *buf_end
;
226 loc_ptr
= baton
->data
;
227 buf_end
= baton
->data
+ baton
->size
;
231 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
233 enum debug_loc_kind kind
;
234 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
237 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
238 loc_ptr
, buf_end
, &new_ptr
,
239 &low
, &high
, byte_order
);
241 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
243 byte_order
, addr_size
,
248 case DEBUG_LOC_END_OF_LIST
:
251 case DEBUG_LOC_BASE_ADDRESS
:
252 base_address
= high
+ base_offset
;
254 case DEBUG_LOC_START_END
:
255 case DEBUG_LOC_START_LENGTH
:
257 case DEBUG_LOC_BUFFER_OVERFLOW
:
258 case DEBUG_LOC_INVALID_ENTRY
:
259 error (_("dwarf2_find_location_expression: "
260 "Corrupted DWARF expression."));
262 gdb_assert_not_reached ("bad debug_loc_kind");
265 /* Otherwise, a location expression entry.
266 If the entry is from a DWO, don't add base address: the entry is from
267 .debug_addr which already has the DWARF "base address". We still add
268 base_offset in case we're debugging a PIE executable. */
277 high
+= base_address
;
280 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
283 if (low
== high
&& pc
== low
)
285 /* This is entry PC record present only at entry point
286 of a function. Verify it is really the function entry point. */
288 const struct block
*pc_block
= block_for_pc (pc
);
289 struct symbol
*pc_func
= NULL
;
292 pc_func
= block_linkage_function (pc_block
);
294 if (pc_func
&& pc
== BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func
)))
296 *locexpr_length
= length
;
301 if (pc
>= low
&& pc
< high
)
303 *locexpr_length
= length
;
311 /* This is the baton used when performing dwarf2 expression
313 struct dwarf_expr_baton
315 struct frame_info
*frame
;
316 struct dwarf2_per_cu_data
*per_cu
;
317 CORE_ADDR obj_address
;
320 /* Implement find_frame_base_location method for LOC_BLOCK functions using
321 DWARF expression for its DW_AT_frame_base. */
324 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
325 const gdb_byte
**start
, size_t *length
)
327 struct dwarf2_locexpr_baton
*symbaton
328 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
330 *length
= symbaton
->size
;
331 *start
= symbaton
->data
;
334 /* Implement the struct symbol_block_ops::get_frame_base method for
335 LOC_BLOCK functions using a DWARF expression as its DW_AT_frame_base. */
338 locexpr_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
340 struct gdbarch
*gdbarch
;
342 struct dwarf2_locexpr_baton
*dlbaton
;
343 const gdb_byte
*start
;
345 struct value
*result
;
347 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
348 Thus, it's supposed to provide the find_frame_base_location method as
350 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
352 gdbarch
= get_frame_arch (frame
);
353 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
354 dlbaton
= (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
356 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
357 (framefunc
, get_frame_pc (frame
), &start
, &length
);
358 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
361 /* The DW_AT_frame_base attribute contains a location description which
362 computes the base address itself. However, the call to
363 dwarf2_evaluate_loc_desc returns a value representing a variable at
364 that address. The frame base address is thus this variable's
366 return value_address (result
);
369 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
370 function uses DWARF expression for its DW_AT_frame_base. */
372 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
374 locexpr_find_frame_base_location
,
375 locexpr_get_frame_base
378 /* Implement find_frame_base_location method for LOC_BLOCK functions using
379 DWARF location list for its DW_AT_frame_base. */
382 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
383 const gdb_byte
**start
, size_t *length
)
385 struct dwarf2_loclist_baton
*symbaton
386 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
388 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
391 /* Implement the struct symbol_block_ops::get_frame_base method for
392 LOC_BLOCK functions using a DWARF location list as its DW_AT_frame_base. */
395 loclist_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
397 struct gdbarch
*gdbarch
;
399 struct dwarf2_loclist_baton
*dlbaton
;
400 const gdb_byte
*start
;
402 struct value
*result
;
404 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
405 Thus, it's supposed to provide the find_frame_base_location method as
407 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
409 gdbarch
= get_frame_arch (frame
);
410 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
411 dlbaton
= (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
413 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
414 (framefunc
, get_frame_pc (frame
), &start
, &length
);
415 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
418 /* The DW_AT_frame_base attribute contains a location description which
419 computes the base address itself. However, the call to
420 dwarf2_evaluate_loc_desc returns a value representing a variable at
421 that address. The frame base address is thus this variable's
423 return value_address (result
);
426 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
427 function uses DWARF location list for its DW_AT_frame_base. */
429 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
431 loclist_find_frame_base_location
,
432 loclist_get_frame_base
435 /* See dwarf2loc.h. */
438 func_get_frame_base_dwarf_block (struct symbol
*framefunc
, CORE_ADDR pc
,
439 const gdb_byte
**start
, size_t *length
)
441 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
443 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
445 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
451 error (_("Could not find the frame base for \"%s\"."),
452 SYMBOL_NATURAL_NAME (framefunc
));
456 get_frame_pc_for_per_cu_dwarf_call (void *baton
)
458 dwarf_expr_context
*ctx
= (dwarf_expr_context
*) baton
;
460 return ctx
->get_frame_pc ();
464 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
465 struct dwarf2_per_cu_data
*per_cu
)
467 struct dwarf2_locexpr_baton block
;
469 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
,
470 get_frame_pc_for_per_cu_dwarf_call
,
473 /* DW_OP_call_ref is currently not supported. */
474 gdb_assert (block
.per_cu
== per_cu
);
476 ctx
->eval (block
.data
, block
.size
);
479 class dwarf_evaluate_loc_desc
: public dwarf_expr_context
483 struct frame_info
*frame
;
484 struct dwarf2_per_cu_data
*per_cu
;
485 CORE_ADDR obj_address
;
487 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
488 the frame in BATON. */
490 CORE_ADDR
get_frame_cfa () OVERRIDE
492 return dwarf2_frame_cfa (frame
);
495 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
496 the frame in BATON. */
498 CORE_ADDR
get_frame_pc () OVERRIDE
500 return get_frame_address_in_block (frame
);
503 /* Using the objfile specified in BATON, find the address for the
504 current thread's thread-local storage with offset OFFSET. */
505 CORE_ADDR
get_tls_address (CORE_ADDR offset
) OVERRIDE
507 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
509 return target_translate_tls_address (objfile
, offset
);
512 /* Helper interface of per_cu_dwarf_call for
513 dwarf2_evaluate_loc_desc. */
515 void dwarf_call (cu_offset die_offset
) OVERRIDE
517 per_cu_dwarf_call (this, die_offset
, per_cu
);
520 struct type
*get_base_type (cu_offset die_offset
, int size
) OVERRIDE
522 struct type
*result
= dwarf2_get_die_type (die_offset
, per_cu
);
524 error (_("Could not find type for DW_OP_GNU_const_type"));
525 if (size
!= 0 && TYPE_LENGTH (result
) != size
)
526 error (_("DW_OP_GNU_const_type has different sizes for type and data"));
530 /* Callback function for dwarf2_evaluate_loc_desc.
531 Fetch the address indexed by DW_OP_GNU_addr_index. */
533 CORE_ADDR
get_addr_index (unsigned int index
) OVERRIDE
535 return dwarf2_read_addr_index (per_cu
, index
);
538 /* Callback function for get_object_address. Return the address of the VLA
541 CORE_ADDR
get_object_address () OVERRIDE
543 if (obj_address
== 0)
544 error (_("Location address is not set."));
548 /* Execute DWARF block of call_site_parameter which matches KIND and
549 KIND_U. Choose DEREF_SIZE value of that parameter. Search
550 caller of this objects's frame.
552 The caller can be from a different CU - per_cu_dwarf_call
553 implementation can be more simple as it does not support cross-CU
556 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
557 union call_site_parameter_u kind_u
,
558 int deref_size
) OVERRIDE
560 struct frame_info
*caller_frame
;
561 struct dwarf2_per_cu_data
*caller_per_cu
;
562 struct call_site_parameter
*parameter
;
563 const gdb_byte
*data_src
;
566 caller_frame
= get_prev_frame (frame
);
568 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
570 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
571 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
573 /* DEREF_SIZE size is not verified here. */
574 if (data_src
== NULL
)
575 throw_error (NO_ENTRY_VALUE_ERROR
,
576 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
578 scoped_restore save_frame
= make_scoped_restore (&this->frame
,
580 scoped_restore save_per_cu
= make_scoped_restore (&this->per_cu
,
582 scoped_restore save_obj_addr
= make_scoped_restore (&this->obj_address
,
585 scoped_restore save_arch
= make_scoped_restore (&this->gdbarch
);
587 = get_objfile_arch (dwarf2_per_cu_objfile (per_cu
));
588 scoped_restore save_addr_size
= make_scoped_restore (&this->addr_size
);
589 this->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
590 scoped_restore save_offset
= make_scoped_restore (&this->offset
);
591 this->offset
= dwarf2_per_cu_text_offset (per_cu
);
593 this->eval (data_src
, size
);
596 /* Using the frame specified in BATON, find the location expression
597 describing the frame base. Return a pointer to it in START and
598 its length in LENGTH. */
599 void get_frame_base (const gdb_byte
**start
, size_t * length
) OVERRIDE
601 /* FIXME: cagney/2003-03-26: This code should be using
602 get_frame_base_address(), and then implement a dwarf2 specific
604 struct symbol
*framefunc
;
605 const struct block
*bl
= get_frame_block (frame
, NULL
);
608 error (_("frame address is not available."));
610 /* Use block_linkage_function, which returns a real (not inlined)
611 function, instead of get_frame_function, which may return an
613 framefunc
= block_linkage_function (bl
);
615 /* If we found a frame-relative symbol then it was certainly within
616 some function associated with a frame. If we can't find the frame,
617 something has gone wrong. */
618 gdb_assert (framefunc
!= NULL
);
620 func_get_frame_base_dwarf_block (framefunc
,
621 get_frame_address_in_block (frame
),
625 /* Read memory at ADDR (length LEN) into BUF. */
627 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) OVERRIDE
629 read_memory (addr
, buf
, len
);
632 /* Using the frame specified in BATON, return the value of register
633 REGNUM, treated as a pointer. */
634 CORE_ADDR
read_addr_from_reg (int dwarf_regnum
) OVERRIDE
636 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
637 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
639 return address_from_register (regnum
, frame
);
642 /* Implement "get_reg_value" callback. */
644 struct value
*get_reg_value (struct type
*type
, int dwarf_regnum
) OVERRIDE
646 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
647 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
649 return value_from_register (type
, regnum
, frame
);
653 /* See dwarf2loc.h. */
655 unsigned int entry_values_debug
= 0;
657 /* Helper to set entry_values_debug. */
660 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
661 struct cmd_list_element
*c
, const char *value
)
663 fprintf_filtered (file
,
664 _("Entry values and tail call frames debugging is %s.\n"),
668 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
669 CALLER_FRAME (for registers) can be NULL if it is not known. This function
670 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
673 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
674 struct call_site
*call_site
,
675 struct frame_info
*caller_frame
)
677 switch (FIELD_LOC_KIND (call_site
->target
))
679 case FIELD_LOC_KIND_DWARF_BLOCK
:
681 struct dwarf2_locexpr_baton
*dwarf_block
;
683 struct type
*caller_core_addr_type
;
684 struct gdbarch
*caller_arch
;
686 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
687 if (dwarf_block
== NULL
)
689 struct bound_minimal_symbol msym
;
691 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
692 throw_error (NO_ENTRY_VALUE_ERROR
,
693 _("DW_AT_GNU_call_site_target is not specified "
695 paddress (call_site_gdbarch
, call_site
->pc
),
696 (msym
.minsym
== NULL
? "???"
697 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
700 if (caller_frame
== NULL
)
702 struct bound_minimal_symbol msym
;
704 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
705 throw_error (NO_ENTRY_VALUE_ERROR
,
706 _("DW_AT_GNU_call_site_target DWARF block resolving "
707 "requires known frame which is currently not "
708 "available at %s in %s"),
709 paddress (call_site_gdbarch
, call_site
->pc
),
710 (msym
.minsym
== NULL
? "???"
711 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
714 caller_arch
= get_frame_arch (caller_frame
);
715 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
716 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
717 dwarf_block
->data
, dwarf_block
->size
,
718 dwarf_block
->per_cu
);
719 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
721 if (VALUE_LVAL (val
) == lval_memory
)
722 return value_address (val
);
724 return value_as_address (val
);
727 case FIELD_LOC_KIND_PHYSNAME
:
729 const char *physname
;
730 struct bound_minimal_symbol msym
;
732 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
734 /* Handle both the mangled and demangled PHYSNAME. */
735 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
736 if (msym
.minsym
== NULL
)
738 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
739 throw_error (NO_ENTRY_VALUE_ERROR
,
740 _("Cannot find function \"%s\" for a call site target "
742 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
743 (msym
.minsym
== NULL
? "???"
744 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
747 return BMSYMBOL_VALUE_ADDRESS (msym
);
750 case FIELD_LOC_KIND_PHYSADDR
:
751 return FIELD_STATIC_PHYSADDR (call_site
->target
);
754 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
758 /* Convert function entry point exact address ADDR to the function which is
759 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
760 NO_ENTRY_VALUE_ERROR otherwise. */
762 static struct symbol
*
763 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
765 struct symbol
*sym
= find_pc_function (addr
);
768 if (sym
== NULL
|| BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
769 throw_error (NO_ENTRY_VALUE_ERROR
,
770 _("DW_TAG_GNU_call_site resolving failed to find function "
771 "name for address %s"),
772 paddress (gdbarch
, addr
));
774 type
= SYMBOL_TYPE (sym
);
775 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
776 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
781 /* Verify function with entry point exact address ADDR can never call itself
782 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
783 can call itself via tail calls.
785 If a funtion can tail call itself its entry value based parameters are
786 unreliable. There is no verification whether the value of some/all
787 parameters is unchanged through the self tail call, we expect if there is
788 a self tail call all the parameters can be modified. */
791 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
795 /* The verification is completely unordered. Track here function addresses
796 which still need to be iterated. */
797 std::vector
<CORE_ADDR
> todo
;
799 /* Track here CORE_ADDRs which were already visited. */
800 std::unordered_set
<CORE_ADDR
> addr_hash
;
802 todo
.push_back (verify_addr
);
803 while (!todo
.empty ())
805 struct symbol
*func_sym
;
806 struct call_site
*call_site
;
811 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
813 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
814 call_site
; call_site
= call_site
->tail_call_next
)
816 CORE_ADDR target_addr
;
818 /* CALLER_FRAME with registers is not available for tail-call jumped
820 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
822 if (target_addr
== verify_addr
)
824 struct bound_minimal_symbol msym
;
826 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
827 throw_error (NO_ENTRY_VALUE_ERROR
,
828 _("DW_OP_GNU_entry_value resolving has found "
829 "function \"%s\" at %s can call itself via tail "
831 (msym
.minsym
== NULL
? "???"
832 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
833 paddress (gdbarch
, verify_addr
));
836 if (addr_hash
.insert (target_addr
).second
)
837 todo
.push_back (target_addr
);
842 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
843 ENTRY_VALUES_DEBUG. */
846 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
848 CORE_ADDR addr
= call_site
->pc
;
849 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
851 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
852 (msym
.minsym
== NULL
? "???"
853 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
857 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
858 only top callers and bottom callees which are present in both. GDBARCH is
859 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
860 no remaining possibilities to provide unambiguous non-trivial result.
861 RESULTP should point to NULL on the first (initialization) call. Caller is
862 responsible for xfree of any RESULTP data. */
865 chain_candidate (struct gdbarch
*gdbarch
,
866 gdb::unique_xmalloc_ptr
<struct call_site_chain
> *resultp
,
867 std::vector
<struct call_site
*> *chain
)
869 long length
= chain
->size ();
870 int callers
, callees
, idx
;
872 if (*resultp
== NULL
)
874 /* Create the initial chain containing all the passed PCs. */
876 struct call_site_chain
*result
877 = ((struct call_site_chain
*)
878 xmalloc (sizeof (*result
)
879 + sizeof (*result
->call_site
) * (length
- 1)));
880 result
->length
= length
;
881 result
->callers
= result
->callees
= length
;
882 if (!chain
->empty ())
883 memcpy (result
->call_site
, chain
->data (),
884 sizeof (*result
->call_site
) * length
);
885 resultp
->reset (result
);
887 if (entry_values_debug
)
889 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
890 for (idx
= 0; idx
< length
; idx
++)
891 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
892 fputc_unfiltered ('\n', gdb_stdlog
);
898 if (entry_values_debug
)
900 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
901 for (idx
= 0; idx
< length
; idx
++)
902 tailcall_dump (gdbarch
, chain
->at (idx
));
903 fputc_unfiltered ('\n', gdb_stdlog
);
906 /* Intersect callers. */
908 callers
= std::min ((long) (*resultp
)->callers
, length
);
909 for (idx
= 0; idx
< callers
; idx
++)
910 if ((*resultp
)->call_site
[idx
] != chain
->at (idx
))
912 (*resultp
)->callers
= idx
;
916 /* Intersect callees. */
918 callees
= std::min ((long) (*resultp
)->callees
, length
);
919 for (idx
= 0; idx
< callees
; idx
++)
920 if ((*resultp
)->call_site
[(*resultp
)->length
- 1 - idx
]
921 != chain
->at (length
- 1 - idx
))
923 (*resultp
)->callees
= idx
;
927 if (entry_values_debug
)
929 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
930 for (idx
= 0; idx
< (*resultp
)->callers
; idx
++)
931 tailcall_dump (gdbarch
, (*resultp
)->call_site
[idx
]);
932 fputs_unfiltered (" |", gdb_stdlog
);
933 for (idx
= 0; idx
< (*resultp
)->callees
; idx
++)
934 tailcall_dump (gdbarch
,
935 (*resultp
)->call_site
[(*resultp
)->length
936 - (*resultp
)->callees
+ idx
]);
937 fputc_unfiltered ('\n', gdb_stdlog
);
940 if ((*resultp
)->callers
== 0 && (*resultp
)->callees
== 0)
942 /* There are no common callers or callees. It could be also a direct
943 call (which has length 0) with ambiguous possibility of an indirect
944 call - CALLERS == CALLEES == 0 is valid during the first allocation
945 but any subsequence processing of such entry means ambiguity. */
946 resultp
->reset (NULL
);
950 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
951 PC again. In such case there must be two different code paths to reach
952 it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
953 gdb_assert ((*resultp
)->callers
+ (*resultp
)->callees
<= (*resultp
)->length
);
956 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
957 assumed frames between them use GDBARCH. Use depth first search so we can
958 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
959 would have needless GDB stack overhead. Caller is responsible for xfree of
960 the returned result. Any unreliability results in thrown
961 NO_ENTRY_VALUE_ERROR. */
963 static struct call_site_chain
*
964 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
967 CORE_ADDR save_callee_pc
= callee_pc
;
968 gdb::unique_xmalloc_ptr
<struct call_site_chain
> retval
;
969 struct call_site
*call_site
;
971 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
972 call_site nor any possible call_site at CALLEE_PC's function is there.
973 Any CALL_SITE in CHAIN will be iterated to its siblings - via
974 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
975 std::vector
<struct call_site
*> chain
;
977 /* We are not interested in the specific PC inside the callee function. */
978 callee_pc
= get_pc_function_start (callee_pc
);
980 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
981 paddress (gdbarch
, save_callee_pc
));
983 /* Mark CALL_SITEs so we do not visit the same ones twice. */
984 std::unordered_set
<CORE_ADDR
> addr_hash
;
986 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
987 at the target's function. All the possible tail call sites in the
988 target's function will get iterated as already pushed into CHAIN via their
990 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
994 CORE_ADDR target_func_addr
;
995 struct call_site
*target_call_site
;
997 /* CALLER_FRAME with registers is not available for tail-call jumped
999 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
1001 if (target_func_addr
== callee_pc
)
1003 chain_candidate (gdbarch
, &retval
, &chain
);
1007 /* There is no way to reach CALLEE_PC again as we would prevent
1008 entering it twice as being already marked in ADDR_HASH. */
1009 target_call_site
= NULL
;
1013 struct symbol
*target_func
;
1015 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
1016 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
1021 /* Attempt to visit TARGET_CALL_SITE. */
1023 if (target_call_site
)
1025 if (addr_hash
.insert (target_call_site
->pc
).second
)
1027 /* Successfully entered TARGET_CALL_SITE. */
1029 chain
.push_back (target_call_site
);
1034 /* Backtrack (without revisiting the originating call_site). Try the
1035 callers's sibling; if there isn't any try the callers's callers's
1038 target_call_site
= NULL
;
1039 while (!chain
.empty ())
1041 call_site
= chain
.back ();
1044 size_t removed
= addr_hash
.erase (call_site
->pc
);
1045 gdb_assert (removed
== 1);
1047 target_call_site
= call_site
->tail_call_next
;
1048 if (target_call_site
)
1052 while (target_call_site
);
1057 call_site
= chain
.back ();
1062 struct bound_minimal_symbol msym_caller
, msym_callee
;
1064 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
1065 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
1066 throw_error (NO_ENTRY_VALUE_ERROR
,
1067 _("There are no unambiguously determinable intermediate "
1068 "callers or callees between caller function \"%s\" at %s "
1069 "and callee function \"%s\" at %s"),
1070 (msym_caller
.minsym
== NULL
1071 ? "???" : MSYMBOL_PRINT_NAME (msym_caller
.minsym
)),
1072 paddress (gdbarch
, caller_pc
),
1073 (msym_callee
.minsym
== NULL
1074 ? "???" : MSYMBOL_PRINT_NAME (msym_callee
.minsym
)),
1075 paddress (gdbarch
, callee_pc
));
1078 return retval
.release ();
1081 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1082 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
1083 constructed return NULL. Caller is responsible for xfree of the returned
1086 struct call_site_chain
*
1087 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1088 CORE_ADDR callee_pc
)
1090 struct call_site_chain
*retval
= NULL
;
1094 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
1096 CATCH (e
, RETURN_MASK_ERROR
)
1098 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
1100 if (entry_values_debug
)
1101 exception_print (gdb_stdout
, e
);
1106 throw_exception (e
);
1113 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1116 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1117 enum call_site_parameter_kind kind
,
1118 union call_site_parameter_u kind_u
)
1120 if (kind
== parameter
->kind
)
1123 case CALL_SITE_PARAMETER_DWARF_REG
:
1124 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1125 case CALL_SITE_PARAMETER_FB_OFFSET
:
1126 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1127 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1128 return kind_u
.param_offset
.cu_off
== parameter
->u
.param_offset
.cu_off
;
1133 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1134 FRAME is for callee.
1136 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1139 static struct call_site_parameter
*
1140 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1141 enum call_site_parameter_kind kind
,
1142 union call_site_parameter_u kind_u
,
1143 struct dwarf2_per_cu_data
**per_cu_return
)
1145 CORE_ADDR func_addr
, caller_pc
;
1146 struct gdbarch
*gdbarch
;
1147 struct frame_info
*caller_frame
;
1148 struct call_site
*call_site
;
1150 /* Initialize it just to avoid a GCC false warning. */
1151 struct call_site_parameter
*parameter
= NULL
;
1152 CORE_ADDR target_addr
;
1154 while (get_frame_type (frame
) == INLINE_FRAME
)
1156 frame
= get_prev_frame (frame
);
1157 gdb_assert (frame
!= NULL
);
1160 func_addr
= get_frame_func (frame
);
1161 gdbarch
= get_frame_arch (frame
);
1162 caller_frame
= get_prev_frame (frame
);
1163 if (gdbarch
!= frame_unwind_arch (frame
))
1165 struct bound_minimal_symbol msym
1166 = lookup_minimal_symbol_by_pc (func_addr
);
1167 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1169 throw_error (NO_ENTRY_VALUE_ERROR
,
1170 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1171 "(of %s (%s)) does not match caller gdbarch %s"),
1172 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1173 paddress (gdbarch
, func_addr
),
1174 (msym
.minsym
== NULL
? "???"
1175 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
1176 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1179 if (caller_frame
== NULL
)
1181 struct bound_minimal_symbol msym
1182 = lookup_minimal_symbol_by_pc (func_addr
);
1184 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_GNU_entry_value resolving "
1185 "requires caller of %s (%s)"),
1186 paddress (gdbarch
, func_addr
),
1187 (msym
.minsym
== NULL
? "???"
1188 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
1190 caller_pc
= get_frame_pc (caller_frame
);
1191 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1193 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1194 if (target_addr
!= func_addr
)
1196 struct minimal_symbol
*target_msym
, *func_msym
;
1198 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1199 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1200 throw_error (NO_ENTRY_VALUE_ERROR
,
1201 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1202 "but the called frame is for %s at %s"),
1203 (target_msym
== NULL
? "???"
1204 : MSYMBOL_PRINT_NAME (target_msym
)),
1205 paddress (gdbarch
, target_addr
),
1206 func_msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (func_msym
),
1207 paddress (gdbarch
, func_addr
));
1210 /* No entry value based parameters would be reliable if this function can
1211 call itself via tail calls. */
1212 func_verify_no_selftailcall (gdbarch
, func_addr
);
1214 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1216 parameter
= &call_site
->parameter
[iparams
];
1217 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1220 if (iparams
== call_site
->parameter_count
)
1222 struct minimal_symbol
*msym
1223 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1225 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1226 determine its value. */
1227 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1228 "at DW_TAG_GNU_call_site %s at %s"),
1229 paddress (gdbarch
, caller_pc
),
1230 msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (msym
));
1233 *per_cu_return
= call_site
->per_cu
;
1237 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1238 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1239 DW_AT_GNU_call_site_data_value (dereferenced) block.
1241 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1244 Function always returns non-NULL, non-optimized out value. It throws
1245 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1247 static struct value
*
1248 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1249 CORE_ADDR deref_size
, struct type
*type
,
1250 struct frame_info
*caller_frame
,
1251 struct dwarf2_per_cu_data
*per_cu
)
1253 const gdb_byte
*data_src
;
1257 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1258 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1260 /* DEREF_SIZE size is not verified here. */
1261 if (data_src
== NULL
)
1262 throw_error (NO_ENTRY_VALUE_ERROR
,
1263 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1265 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1266 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1268 data
= (gdb_byte
*) alloca (size
+ 1);
1269 memcpy (data
, data_src
, size
);
1270 data
[size
] = DW_OP_stack_value
;
1272 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1275 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1276 the indirect method on it, that is use its stored target value, the sole
1277 purpose of entry_data_value_funcs.. */
1279 static struct value
*
1280 entry_data_value_coerce_ref (const struct value
*value
)
1282 struct type
*checked_type
= check_typedef (value_type (value
));
1283 struct value
*target_val
;
1285 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
)
1288 target_val
= (struct value
*) value_computed_closure (value
);
1289 value_incref (target_val
);
1293 /* Implement copy_closure. */
1296 entry_data_value_copy_closure (const struct value
*v
)
1298 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1300 value_incref (target_val
);
1304 /* Implement free_closure. */
1307 entry_data_value_free_closure (struct value
*v
)
1309 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1311 value_free (target_val
);
1314 /* Vector for methods for an entry value reference where the referenced value
1315 is stored in the caller. On the first dereference use
1316 DW_AT_GNU_call_site_data_value in the caller. */
1318 static const struct lval_funcs entry_data_value_funcs
=
1322 NULL
, /* indirect */
1323 entry_data_value_coerce_ref
,
1324 NULL
, /* check_synthetic_pointer */
1325 entry_data_value_copy_closure
,
1326 entry_data_value_free_closure
1329 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1330 are used to match DW_AT_location at the caller's
1331 DW_TAG_GNU_call_site_parameter.
1333 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1334 cannot resolve the parameter for any reason. */
1336 static struct value
*
1337 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1338 enum call_site_parameter_kind kind
,
1339 union call_site_parameter_u kind_u
)
1341 struct type
*checked_type
= check_typedef (type
);
1342 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1343 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1344 struct value
*outer_val
, *target_val
, *val
;
1345 struct call_site_parameter
*parameter
;
1346 struct dwarf2_per_cu_data
*caller_per_cu
;
1348 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1351 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1355 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1356 used and it is not available do not fall back to OUTER_VAL - dereferencing
1357 TYPE_CODE_REF with non-entry data value would give current value - not the
1360 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
1361 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1364 target_val
= dwarf_entry_parameter_to_value (parameter
,
1365 TYPE_LENGTH (target_type
),
1366 target_type
, caller_frame
,
1369 release_value (target_val
);
1370 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1371 target_val
/* closure */);
1373 /* Copy the referencing pointer to the new computed value. */
1374 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1375 TYPE_LENGTH (checked_type
));
1376 set_value_lazy (val
, 0);
1381 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1382 SIZE are DWARF block used to match DW_AT_location at the caller's
1383 DW_TAG_GNU_call_site_parameter.
1385 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1386 cannot resolve the parameter for any reason. */
1388 static struct value
*
1389 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1390 const gdb_byte
*block
, size_t block_len
)
1392 union call_site_parameter_u kind_u
;
1394 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1395 if (kind_u
.dwarf_reg
!= -1)
1396 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1399 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1400 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1403 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1404 suppressed during normal operation. The expression can be arbitrary if
1405 there is no caller-callee entry value binding expected. */
1406 throw_error (NO_ENTRY_VALUE_ERROR
,
1407 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1408 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1411 struct piece_closure
1413 /* Reference count. */
1416 /* The CU from which this closure's expression came. */
1417 struct dwarf2_per_cu_data
*per_cu
;
1419 /* The number of pieces used to describe this variable. */
1422 /* The target address size, used only for DWARF_VALUE_STACK. */
1425 /* The pieces themselves. */
1426 struct dwarf_expr_piece
*pieces
;
1428 /* Frame ID of frame to which a register value is relative, used
1429 only by DWARF_VALUE_REGISTER. */
1430 struct frame_id frame_id
;
1433 /* Allocate a closure for a value formed from separately-described
1436 static struct piece_closure
*
1437 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1438 int n_pieces
, struct dwarf_expr_piece
*pieces
,
1439 int addr_size
, struct frame_info
*frame
)
1441 struct piece_closure
*c
= XCNEW (struct piece_closure
);
1446 c
->n_pieces
= n_pieces
;
1447 c
->addr_size
= addr_size
;
1448 c
->pieces
= XCNEWVEC (struct dwarf_expr_piece
, n_pieces
);
1450 c
->frame_id
= null_frame_id
;
1452 c
->frame_id
= get_frame_id (frame
);
1454 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
1455 for (i
= 0; i
< n_pieces
; ++i
)
1456 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1457 value_incref (c
->pieces
[i
].v
.value
);
1462 /* Copy NBITS bits from SOURCE to DEST starting at the given bit
1463 offsets. Use the bit order as specified by BITS_BIG_ENDIAN.
1464 Source and destination buffers must not overlap. */
1467 copy_bitwise (gdb_byte
*dest
, ULONGEST dest_offset
,
1468 const gdb_byte
*source
, ULONGEST source_offset
,
1469 ULONGEST nbits
, int bits_big_endian
)
1471 unsigned int buf
, avail
;
1476 if (bits_big_endian
)
1478 /* Start from the end, then work backwards. */
1479 dest_offset
+= nbits
- 1;
1480 dest
+= dest_offset
/ 8;
1481 dest_offset
= 7 - dest_offset
% 8;
1482 source_offset
+= nbits
- 1;
1483 source
+= source_offset
/ 8;
1484 source_offset
= 7 - source_offset
% 8;
1488 dest
+= dest_offset
/ 8;
1490 source
+= source_offset
/ 8;
1494 /* Fill BUF with DEST_OFFSET bits from the destination and 8 -
1495 SOURCE_OFFSET bits from the source. */
1496 buf
= *(bits_big_endian
? source
-- : source
++) >> source_offset
;
1497 buf
<<= dest_offset
;
1498 buf
|= *dest
& ((1 << dest_offset
) - 1);
1500 /* NBITS: bits yet to be written; AVAIL: BUF's fill level. */
1501 nbits
+= dest_offset
;
1502 avail
= dest_offset
+ 8 - source_offset
;
1504 /* Flush 8 bits from BUF, if appropriate. */
1505 if (nbits
>= 8 && avail
>= 8)
1507 *(bits_big_endian
? dest
-- : dest
++) = buf
;
1513 /* Copy the middle part. */
1516 size_t len
= nbits
/ 8;
1518 /* Use a faster method for byte-aligned copies. */
1521 if (bits_big_endian
)
1525 memcpy (dest
+ 1, source
+ 1, len
);
1529 memcpy (dest
, source
, len
);
1538 buf
|= *(bits_big_endian
? source
-- : source
++) << avail
;
1539 *(bits_big_endian
? dest
-- : dest
++) = buf
;
1546 /* Write the last byte. */
1550 buf
|= *source
<< avail
;
1552 buf
&= (1 << nbits
) - 1;
1553 *dest
= (*dest
& (~0 << nbits
)) | buf
;
1559 namespace selftests
{
1561 /* Helper function for the unit test of copy_bitwise. Convert NBITS bits
1562 out of BITS, starting at OFFS, to the respective '0'/'1'-string. MSB0
1563 specifies whether to assume big endian bit numbering. Store the
1564 resulting (not null-terminated) string at STR. */
1567 bits_to_str (char *str
, const gdb_byte
*bits
, ULONGEST offs
,
1568 ULONGEST nbits
, int msb0
)
1573 for (i
= offs
/ 8, j
= offs
% 8; nbits
; i
++, j
= 0)
1575 unsigned int ch
= bits
[i
];
1576 for (; j
< 8 && nbits
; j
++, nbits
--)
1577 *str
++ = (ch
& (msb0
? (1 << (7 - j
)) : (1 << j
))) ? '1' : '0';
1581 /* Check one invocation of copy_bitwise with the given parameters. */
1584 check_copy_bitwise (const gdb_byte
*dest
, unsigned int dest_offset
,
1585 const gdb_byte
*source
, unsigned int source_offset
,
1586 unsigned int nbits
, int msb0
)
1588 size_t len
= align_up (dest_offset
+ nbits
, 8);
1589 char *expected
= (char *) alloca (len
+ 1);
1590 char *actual
= (char *) alloca (len
+ 1);
1591 gdb_byte
*buf
= (gdb_byte
*) alloca (len
/ 8);
1593 /* Compose a '0'/'1'-string that represents the expected result of
1595 Bits from [0, DEST_OFFSET) are filled from DEST.
1596 Bits from [DEST_OFFSET, DEST_OFFSET + NBITS) are filled from SOURCE.
1597 Bits from [DEST_OFFSET + NBITS, LEN) are filled from DEST.
1606 We should end up with:
1608 DDDDSSDD (D=dest, S=source)
1610 bits_to_str (expected
, dest
, 0, len
, msb0
);
1611 bits_to_str (expected
+ dest_offset
, source
, source_offset
, nbits
, msb0
);
1613 /* Fill BUF with data from DEST, apply copy_bitwise, and convert the
1614 result to a '0'/'1'-string. */
1615 memcpy (buf
, dest
, len
/ 8);
1616 copy_bitwise (buf
, dest_offset
, source
, source_offset
, nbits
, msb0
);
1617 bits_to_str (actual
, buf
, 0, len
, msb0
);
1619 /* Compare the resulting strings. */
1620 expected
[len
] = actual
[len
] = '\0';
1621 if (strcmp (expected
, actual
) != 0)
1622 error (_("copy_bitwise %s != %s (%u+%u -> %u)"),
1623 expected
, actual
, source_offset
, nbits
, dest_offset
);
1626 /* Unit test for copy_bitwise. */
1629 copy_bitwise_tests (void)
1631 /* Data to be used as both source and destination buffers. The two
1632 arrays below represent the lsb0- and msb0- encoded versions of the
1633 following bit string, respectively:
1634 00000000 00011111 11111111 01001000 10100101 11110010
1635 This pattern is chosen such that it contains:
1636 - constant 0- and 1- chunks of more than a full byte;
1637 - 0/1- and 1/0 transitions on all bit positions within a byte;
1638 - several sufficiently asymmetric bytes.
1640 static const gdb_byte data_lsb0
[] = {
1641 0x00, 0xf8, 0xff, 0x12, 0xa5, 0x4f
1643 static const gdb_byte data_msb0
[] = {
1644 0x00, 0x1f, 0xff, 0x48, 0xa5, 0xf2
1647 constexpr size_t data_nbits
= 8 * sizeof (data_lsb0
);
1648 constexpr unsigned max_nbits
= 24;
1650 /* Try all combinations of:
1651 lsb0/msb0 bit order (using the respective data array)
1652 X [0, MAX_NBITS] copy bit width
1653 X feasible source offsets for the given copy bit width
1654 X feasible destination offsets
1656 for (int msb0
= 0; msb0
< 2; msb0
++)
1658 const gdb_byte
*data
= msb0
? data_msb0
: data_lsb0
;
1660 for (unsigned int nbits
= 1; nbits
<= max_nbits
; nbits
++)
1662 const unsigned int max_offset
= data_nbits
- nbits
;
1664 for (unsigned source_offset
= 0;
1665 source_offset
<= max_offset
;
1668 for (unsigned dest_offset
= 0;
1669 dest_offset
<= max_offset
;
1672 check_copy_bitwise (data
+ dest_offset
/ 8,
1674 data
+ source_offset
/ 8,
1681 /* Special cases: copy all, copy nothing. */
1682 check_copy_bitwise (data_lsb0
, 0, data_msb0
, 0, data_nbits
, msb0
);
1683 check_copy_bitwise (data_msb0
, 0, data_lsb0
, 0, data_nbits
, msb0
);
1684 check_copy_bitwise (data
, data_nbits
- 7, data
, 9, 0, msb0
);
1688 } /* namespace selftests */
1690 #endif /* GDB_SELF_TEST */
1693 read_pieced_value (struct value
*v
)
1697 ULONGEST bits_to_skip
;
1699 struct piece_closure
*c
1700 = (struct piece_closure
*) value_computed_closure (v
);
1702 size_t buffer_size
= 0;
1703 std::vector
<gdb_byte
> buffer
;
1705 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1707 if (value_type (v
) != value_enclosing_type (v
))
1708 internal_error (__FILE__
, __LINE__
,
1709 _("Should not be able to create a lazy value with "
1710 "an enclosing type"));
1712 contents
= value_contents_raw (v
);
1713 bits_to_skip
= 8 * value_offset (v
);
1714 if (value_bitsize (v
))
1716 bits_to_skip
+= value_bitpos (v
);
1717 type_len
= value_bitsize (v
);
1720 type_len
= 8 * TYPE_LENGTH (value_type (v
));
1722 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1724 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1725 size_t this_size
, this_size_bits
;
1726 long dest_offset_bits
, source_offset_bits
, source_offset
;
1727 const gdb_byte
*intermediate_buffer
;
1729 /* Compute size, source, and destination offsets for copying, in
1731 this_size_bits
= p
->size
;
1732 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1734 bits_to_skip
-= this_size_bits
;
1737 if (bits_to_skip
> 0)
1739 dest_offset_bits
= 0;
1740 source_offset_bits
= bits_to_skip
;
1741 this_size_bits
-= bits_to_skip
;
1746 dest_offset_bits
= offset
;
1747 source_offset_bits
= 0;
1749 if (this_size_bits
> type_len
- offset
)
1750 this_size_bits
= type_len
- offset
;
1752 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1753 source_offset
= source_offset_bits
/ 8;
1754 if (buffer_size
< this_size
)
1756 buffer_size
= this_size
;
1757 buffer
.reserve (buffer_size
);
1759 intermediate_buffer
= buffer
.data ();
1761 /* Copy from the source to DEST_BUFFER. */
1762 switch (p
->location
)
1764 case DWARF_VALUE_REGISTER
:
1766 struct frame_info
*frame
= frame_find_by_id (c
->frame_id
);
1767 struct gdbarch
*arch
= get_frame_arch (frame
);
1768 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, p
->v
.regno
);
1770 LONGEST reg_offset
= source_offset
;
1772 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1773 && this_size
< register_size (arch
, gdb_regnum
))
1775 /* Big-endian, and we want less than full size. */
1776 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1777 /* We want the lower-order THIS_SIZE_BITS of the bytes
1778 we extract from the register. */
1779 source_offset_bits
+= 8 * this_size
- this_size_bits
;
1782 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1783 this_size
, buffer
.data (),
1786 /* Just so garbage doesn't ever shine through. */
1787 memset (buffer
.data (), 0, this_size
);
1790 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1792 mark_value_bits_unavailable (v
, offset
, this_size_bits
);
1797 case DWARF_VALUE_MEMORY
:
1798 read_value_memory (v
, offset
,
1799 p
->v
.mem
.in_stack_memory
,
1800 p
->v
.mem
.addr
+ source_offset
,
1801 buffer
.data (), this_size
);
1804 case DWARF_VALUE_STACK
:
1806 size_t n
= this_size
;
1808 if (n
> c
->addr_size
- source_offset
)
1809 n
= (c
->addr_size
>= source_offset
1810 ? c
->addr_size
- source_offset
1818 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
1820 intermediate_buffer
= val_bytes
+ source_offset
;
1825 case DWARF_VALUE_LITERAL
:
1827 size_t n
= this_size
;
1829 if (n
> p
->v
.literal
.length
- source_offset
)
1830 n
= (p
->v
.literal
.length
>= source_offset
1831 ? p
->v
.literal
.length
- source_offset
1834 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
1838 /* These bits show up as zeros -- but do not cause the value
1839 to be considered optimized-out. */
1840 case DWARF_VALUE_IMPLICIT_POINTER
:
1843 case DWARF_VALUE_OPTIMIZED_OUT
:
1844 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1848 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1851 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
1852 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1853 copy_bitwise (contents
, dest_offset_bits
,
1854 intermediate_buffer
, source_offset_bits
% 8,
1855 this_size_bits
, bits_big_endian
);
1857 offset
+= this_size_bits
;
1862 write_pieced_value (struct value
*to
, struct value
*from
)
1866 ULONGEST bits_to_skip
;
1867 const gdb_byte
*contents
;
1868 struct piece_closure
*c
1869 = (struct piece_closure
*) value_computed_closure (to
);
1871 size_t buffer_size
= 0;
1872 std::vector
<gdb_byte
> buffer
;
1874 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
1876 contents
= value_contents (from
);
1877 bits_to_skip
= 8 * value_offset (to
);
1878 if (value_bitsize (to
))
1880 bits_to_skip
+= value_bitpos (to
);
1881 type_len
= value_bitsize (to
);
1884 type_len
= 8 * TYPE_LENGTH (value_type (to
));
1886 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1888 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1889 size_t this_size_bits
, this_size
;
1890 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
1892 const gdb_byte
*source_buffer
;
1894 this_size_bits
= p
->size
;
1895 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1897 bits_to_skip
-= this_size_bits
;
1900 if (this_size_bits
> type_len
- offset
)
1901 this_size_bits
= type_len
- offset
;
1902 if (bits_to_skip
> 0)
1904 dest_offset_bits
= bits_to_skip
;
1905 source_offset_bits
= 0;
1906 this_size_bits
-= bits_to_skip
;
1911 dest_offset_bits
= 0;
1912 source_offset_bits
= offset
;
1915 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1916 source_offset
= source_offset_bits
/ 8;
1917 dest_offset
= dest_offset_bits
/ 8;
1918 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
1920 source_buffer
= contents
+ source_offset
;
1925 if (buffer_size
< this_size
)
1927 buffer_size
= this_size
;
1928 buffer
.reserve (buffer_size
);
1930 source_buffer
= buffer
.data ();
1934 switch (p
->location
)
1936 case DWARF_VALUE_REGISTER
:
1938 struct frame_info
*frame
= frame_find_by_id (c
->frame_id
);
1939 struct gdbarch
*arch
= get_frame_arch (frame
);
1940 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, p
->v
.regno
);
1941 int reg_offset
= dest_offset
;
1943 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1944 && this_size
<= register_size (arch
, gdb_regnum
))
1946 /* Big-endian, and we want less than full size. */
1947 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1954 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1955 this_size
, buffer
.data (),
1959 throw_error (OPTIMIZED_OUT_ERROR
,
1960 _("Can't do read-modify-write to "
1961 "update bitfield; containing word "
1962 "has been optimized out"));
1964 throw_error (NOT_AVAILABLE_ERROR
,
1965 _("Can't do read-modify-write to update "
1966 "bitfield; containing word "
1969 copy_bitwise (buffer
.data (), dest_offset_bits
,
1970 contents
, source_offset_bits
,
1975 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1976 this_size
, source_buffer
);
1979 case DWARF_VALUE_MEMORY
:
1982 /* Only the first and last bytes can possibly have any
1984 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
.data (), 1);
1985 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
1986 &buffer
[this_size
- 1], 1);
1987 copy_bitwise (buffer
.data (), dest_offset_bits
,
1988 contents
, source_offset_bits
,
1993 write_memory (p
->v
.mem
.addr
+ dest_offset
,
1994 source_buffer
, this_size
);
1997 mark_value_bytes_optimized_out (to
, 0, TYPE_LENGTH (value_type (to
)));
2000 offset
+= this_size_bits
;
2004 /* An implementation of an lval_funcs method to see whether a value is
2005 a synthetic pointer. */
2008 check_pieced_synthetic_pointer (const struct value
*value
, LONGEST bit_offset
,
2011 struct piece_closure
*c
2012 = (struct piece_closure
*) value_computed_closure (value
);
2015 bit_offset
+= 8 * value_offset (value
);
2016 if (value_bitsize (value
))
2017 bit_offset
+= value_bitpos (value
);
2019 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2021 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2022 size_t this_size_bits
= p
->size
;
2026 if (bit_offset
>= this_size_bits
)
2028 bit_offset
-= this_size_bits
;
2032 bit_length
-= this_size_bits
- bit_offset
;
2036 bit_length
-= this_size_bits
;
2038 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2045 /* A wrapper function for get_frame_address_in_block. */
2048 get_frame_address_in_block_wrapper (void *baton
)
2050 return get_frame_address_in_block ((struct frame_info
*) baton
);
2053 /* Fetch a DW_AT_const_value through a synthetic pointer. */
2055 static struct value
*
2056 fetch_const_value_from_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
2057 struct dwarf2_per_cu_data
*per_cu
,
2060 struct value
*result
= NULL
;
2061 struct obstack temp_obstack
;
2062 struct cleanup
*cleanup
;
2063 const gdb_byte
*bytes
;
2066 obstack_init (&temp_obstack
);
2067 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2068 bytes
= dwarf2_fetch_constant_bytes (die
, per_cu
, &temp_obstack
, &len
);
2072 if (byte_offset
>= 0
2073 && byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) <= len
)
2075 bytes
+= byte_offset
;
2076 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
2079 invalid_synthetic_pointer ();
2082 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
2084 do_cleanups (cleanup
);
2089 /* Fetch the value pointed to by a synthetic pointer. */
2091 static struct value
*
2092 indirect_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
2093 struct dwarf2_per_cu_data
*per_cu
,
2094 struct frame_info
*frame
, struct type
*type
)
2096 /* Fetch the location expression of the DIE we're pointing to. */
2097 struct dwarf2_locexpr_baton baton
2098 = dwarf2_fetch_die_loc_sect_off (die
, per_cu
,
2099 get_frame_address_in_block_wrapper
, frame
);
2101 /* If pointed-to DIE has a DW_AT_location, evaluate it and return the
2102 resulting value. Otherwise, it may have a DW_AT_const_value instead,
2103 or it may've been optimized out. */
2104 if (baton
.data
!= NULL
)
2105 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
2106 baton
.data
, baton
.size
, baton
.per_cu
,
2109 return fetch_const_value_from_synthetic_pointer (die
, byte_offset
, per_cu
,
2113 /* An implementation of an lval_funcs method to indirect through a
2114 pointer. This handles the synthetic pointer case when needed. */
2116 static struct value
*
2117 indirect_pieced_value (struct value
*value
)
2119 struct piece_closure
*c
2120 = (struct piece_closure
*) value_computed_closure (value
);
2122 struct frame_info
*frame
;
2123 struct dwarf2_locexpr_baton baton
;
2126 struct dwarf_expr_piece
*piece
= NULL
;
2127 LONGEST byte_offset
;
2128 enum bfd_endian byte_order
;
2130 type
= check_typedef (value_type (value
));
2131 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
2134 bit_length
= 8 * TYPE_LENGTH (type
);
2135 bit_offset
= 8 * value_offset (value
);
2136 if (value_bitsize (value
))
2137 bit_offset
+= value_bitpos (value
);
2139 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2141 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2142 size_t this_size_bits
= p
->size
;
2146 if (bit_offset
>= this_size_bits
)
2148 bit_offset
-= this_size_bits
;
2152 bit_length
-= this_size_bits
- bit_offset
;
2156 bit_length
-= this_size_bits
;
2158 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2161 if (bit_length
!= 0)
2162 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2168 gdb_assert (piece
!= NULL
);
2169 frame
= get_selected_frame (_("No frame selected."));
2171 /* This is an offset requested by GDB, such as value subscripts.
2172 However, due to how synthetic pointers are implemented, this is
2173 always presented to us as a pointer type. This means we have to
2174 sign-extend it manually as appropriate. Use raw
2175 extract_signed_integer directly rather than value_as_address and
2176 sign extend afterwards on architectures that would need it
2177 (mostly everywhere except MIPS, which has signed addresses) as
2178 the later would go through gdbarch_pointer_to_address and thus
2179 return a CORE_ADDR with high bits set on architectures that
2180 encode address spaces and other things in CORE_ADDR. */
2181 byte_order
= gdbarch_byte_order (get_frame_arch (frame
));
2182 byte_offset
= extract_signed_integer (value_contents (value
),
2183 TYPE_LENGTH (type
), byte_order
);
2184 byte_offset
+= piece
->v
.ptr
.offset
;
2186 return indirect_synthetic_pointer (piece
->v
.ptr
.die
, byte_offset
, c
->per_cu
,
2190 /* Implementation of the coerce_ref method of lval_funcs for synthetic C++
2193 static struct value
*
2194 coerce_pieced_ref (const struct value
*value
)
2196 struct type
*type
= check_typedef (value_type (value
));
2198 if (value_bits_synthetic_pointer (value
, value_embedded_offset (value
),
2199 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
2201 const struct piece_closure
*closure
2202 = (struct piece_closure
*) value_computed_closure (value
);
2203 struct frame_info
*frame
2204 = get_selected_frame (_("No frame selected."));
2206 /* gdb represents synthetic pointers as pieced values with a single
2208 gdb_assert (closure
!= NULL
);
2209 gdb_assert (closure
->n_pieces
== 1);
2211 return indirect_synthetic_pointer (closure
->pieces
->v
.ptr
.die
,
2212 closure
->pieces
->v
.ptr
.offset
,
2213 closure
->per_cu
, frame
, type
);
2217 /* Else: not a synthetic reference; do nothing. */
2223 copy_pieced_value_closure (const struct value
*v
)
2225 struct piece_closure
*c
2226 = (struct piece_closure
*) value_computed_closure (v
);
2233 free_pieced_value_closure (struct value
*v
)
2235 struct piece_closure
*c
2236 = (struct piece_closure
*) value_computed_closure (v
);
2243 for (i
= 0; i
< c
->n_pieces
; ++i
)
2244 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
2245 value_free (c
->pieces
[i
].v
.value
);
2252 /* Functions for accessing a variable described by DW_OP_piece. */
2253 static const struct lval_funcs pieced_value_funcs
= {
2256 indirect_pieced_value
,
2258 check_pieced_synthetic_pointer
,
2259 copy_pieced_value_closure
,
2260 free_pieced_value_closure
2263 /* Evaluate a location description, starting at DATA and with length
2264 SIZE, to find the current location of variable of TYPE in the
2265 context of FRAME. BYTE_OFFSET is applied after the contents are
2268 static struct value
*
2269 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2270 const gdb_byte
*data
, size_t size
,
2271 struct dwarf2_per_cu_data
*per_cu
,
2272 LONGEST byte_offset
)
2274 struct value
*retval
;
2275 struct cleanup
*value_chain
;
2276 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2278 if (byte_offset
< 0)
2279 invalid_synthetic_pointer ();
2282 return allocate_optimized_out_value (type
);
2284 dwarf_evaluate_loc_desc ctx
;
2286 ctx
.per_cu
= per_cu
;
2287 ctx
.obj_address
= 0;
2289 value_chain
= make_cleanup_value_free_to_mark (value_mark ());
2291 ctx
.gdbarch
= get_objfile_arch (objfile
);
2292 ctx
.addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2293 ctx
.ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2294 ctx
.offset
= dwarf2_per_cu_text_offset (per_cu
);
2298 ctx
.eval (data
, size
);
2300 CATCH (ex
, RETURN_MASK_ERROR
)
2302 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2304 do_cleanups (value_chain
);
2305 retval
= allocate_value (type
);
2306 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
2309 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2311 if (entry_values_debug
)
2312 exception_print (gdb_stdout
, ex
);
2313 do_cleanups (value_chain
);
2314 return allocate_optimized_out_value (type
);
2317 throw_exception (ex
);
2321 if (ctx
.num_pieces
> 0)
2323 struct piece_closure
*c
;
2324 ULONGEST bit_size
= 0;
2327 for (i
= 0; i
< ctx
.num_pieces
; ++i
)
2328 bit_size
+= ctx
.pieces
[i
].size
;
2329 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
2330 invalid_synthetic_pointer ();
2332 c
= allocate_piece_closure (per_cu
, ctx
.num_pieces
, ctx
.pieces
,
2333 ctx
.addr_size
, frame
);
2334 /* We must clean up the value chain after creating the piece
2335 closure but before allocating the result. */
2336 do_cleanups (value_chain
);
2337 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
2338 set_value_offset (retval
, byte_offset
);
2342 switch (ctx
.location
)
2344 case DWARF_VALUE_REGISTER
:
2346 struct gdbarch
*arch
= get_frame_arch (frame
);
2348 = longest_to_int (value_as_long (ctx
.fetch (0)));
2349 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, dwarf_regnum
);
2351 if (byte_offset
!= 0)
2352 error (_("cannot use offset on synthetic pointer to register"));
2353 do_cleanups (value_chain
);
2354 retval
= value_from_register (type
, gdb_regnum
, frame
);
2355 if (value_optimized_out (retval
))
2359 /* This means the register has undefined value / was
2360 not saved. As we're computing the location of some
2361 variable etc. in the program, not a value for
2362 inspecting a register ($pc, $sp, etc.), return a
2363 generic optimized out value instead, so that we show
2364 <optimized out> instead of <not saved>. */
2365 do_cleanups (value_chain
);
2366 tmp
= allocate_value (type
);
2367 value_contents_copy (tmp
, 0, retval
, 0, TYPE_LENGTH (type
));
2373 case DWARF_VALUE_MEMORY
:
2375 struct type
*ptr_type
;
2376 CORE_ADDR address
= ctx
.fetch_address (0);
2377 int in_stack_memory
= ctx
.fetch_in_stack_memory (0);
2379 /* DW_OP_deref_size (and possibly other operations too) may
2380 create a pointer instead of an address. Ideally, the
2381 pointer to address conversion would be performed as part
2382 of those operations, but the type of the object to
2383 which the address refers is not known at the time of
2384 the operation. Therefore, we do the conversion here
2385 since the type is readily available. */
2387 switch (TYPE_CODE (type
))
2389 case TYPE_CODE_FUNC
:
2390 case TYPE_CODE_METHOD
:
2391 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_func_ptr
;
2394 ptr_type
= builtin_type (ctx
.gdbarch
)->builtin_data_ptr
;
2397 address
= value_as_address (value_from_pointer (ptr_type
, address
));
2399 do_cleanups (value_chain
);
2400 retval
= value_at_lazy (type
, address
+ byte_offset
);
2401 if (in_stack_memory
)
2402 set_value_stack (retval
, 1);
2406 case DWARF_VALUE_STACK
:
2408 struct value
*value
= ctx
.fetch (0);
2410 const gdb_byte
*val_bytes
;
2411 size_t n
= TYPE_LENGTH (value_type (value
));
2413 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2414 invalid_synthetic_pointer ();
2416 val_bytes
= value_contents_all (value
);
2417 val_bytes
+= byte_offset
;
2420 /* Preserve VALUE because we are going to free values back
2421 to the mark, but we still need the value contents
2423 value_incref (value
);
2424 do_cleanups (value_chain
);
2425 make_cleanup_value_free (value
);
2427 retval
= allocate_value (type
);
2428 contents
= value_contents_raw (retval
);
2429 if (n
> TYPE_LENGTH (type
))
2431 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2433 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2434 val_bytes
+= n
- TYPE_LENGTH (type
);
2435 n
= TYPE_LENGTH (type
);
2437 memcpy (contents
, val_bytes
, n
);
2441 case DWARF_VALUE_LITERAL
:
2444 const bfd_byte
*ldata
;
2447 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2448 invalid_synthetic_pointer ();
2450 do_cleanups (value_chain
);
2451 retval
= allocate_value (type
);
2452 contents
= value_contents_raw (retval
);
2454 ldata
= ctx
.data
+ byte_offset
;
2457 if (n
> TYPE_LENGTH (type
))
2459 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2461 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2462 ldata
+= n
- TYPE_LENGTH (type
);
2463 n
= TYPE_LENGTH (type
);
2465 memcpy (contents
, ldata
, n
);
2469 case DWARF_VALUE_OPTIMIZED_OUT
:
2470 do_cleanups (value_chain
);
2471 retval
= allocate_optimized_out_value (type
);
2474 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2475 operation by execute_stack_op. */
2476 case DWARF_VALUE_IMPLICIT_POINTER
:
2477 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2478 it can only be encountered when making a piece. */
2480 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2484 set_value_initialized (retval
, ctx
.initialized
);
2486 do_cleanups (value_chain
);
2491 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2492 passes 0 as the byte_offset. */
2495 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2496 const gdb_byte
*data
, size_t size
,
2497 struct dwarf2_per_cu_data
*per_cu
)
2499 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
2502 /* Evaluates a dwarf expression and stores the result in VAL, expecting
2503 that the dwarf expression only produces a single CORE_ADDR. FRAME is the
2504 frame in which the expression is evaluated. ADDR is a context (location of
2505 a variable) and might be needed to evaluate the location expression.
2506 Returns 1 on success, 0 otherwise. */
2509 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton
*dlbaton
,
2510 struct frame_info
*frame
,
2514 struct objfile
*objfile
;
2516 if (dlbaton
== NULL
|| dlbaton
->size
== 0)
2519 dwarf_evaluate_loc_desc ctx
;
2522 ctx
.per_cu
= dlbaton
->per_cu
;
2523 ctx
.obj_address
= addr
;
2525 objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2527 ctx
.gdbarch
= get_objfile_arch (objfile
);
2528 ctx
.addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2529 ctx
.ref_addr_size
= dwarf2_per_cu_ref_addr_size (dlbaton
->per_cu
);
2530 ctx
.offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
2532 ctx
.eval (dlbaton
->data
, dlbaton
->size
);
2534 switch (ctx
.location
)
2536 case DWARF_VALUE_REGISTER
:
2537 case DWARF_VALUE_MEMORY
:
2538 case DWARF_VALUE_STACK
:
2539 *valp
= ctx
.fetch_address (0);
2540 if (ctx
.location
== DWARF_VALUE_REGISTER
)
2541 *valp
= ctx
.read_addr_from_reg (*valp
);
2543 case DWARF_VALUE_LITERAL
:
2544 *valp
= extract_signed_integer (ctx
.data
, ctx
.len
,
2545 gdbarch_byte_order (ctx
.gdbarch
));
2547 /* Unsupported dwarf values. */
2548 case DWARF_VALUE_OPTIMIZED_OUT
:
2549 case DWARF_VALUE_IMPLICIT_POINTER
:
2556 /* See dwarf2loc.h. */
2559 dwarf2_evaluate_property (const struct dynamic_prop
*prop
,
2560 struct frame_info
*frame
,
2561 struct property_addr_info
*addr_stack
,
2567 if (frame
== NULL
&& has_stack_frames ())
2568 frame
= get_selected_frame (NULL
);
2574 const struct dwarf2_property_baton
*baton
2575 = (const struct dwarf2_property_baton
*) prop
->data
.baton
;
2577 if (dwarf2_locexpr_baton_eval (&baton
->locexpr
, frame
,
2578 addr_stack
? addr_stack
->addr
: 0,
2581 if (baton
->referenced_type
)
2583 struct value
*val
= value_at (baton
->referenced_type
, *value
);
2585 *value
= value_as_address (val
);
2594 struct dwarf2_property_baton
*baton
2595 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2596 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2597 const gdb_byte
*data
;
2601 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2604 val
= dwarf2_evaluate_loc_desc (baton
->referenced_type
, frame
, data
,
2605 size
, baton
->loclist
.per_cu
);
2606 if (!value_optimized_out (val
))
2608 *value
= value_as_address (val
);
2616 *value
= prop
->data
.const_val
;
2619 case PROP_ADDR_OFFSET
:
2621 struct dwarf2_property_baton
*baton
2622 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2623 struct property_addr_info
*pinfo
;
2626 for (pinfo
= addr_stack
; pinfo
!= NULL
; pinfo
= pinfo
->next
)
2627 if (pinfo
->type
== baton
->referenced_type
)
2630 error (_("cannot find reference address for offset property"));
2631 if (pinfo
->valaddr
!= NULL
)
2632 val
= value_from_contents
2633 (baton
->offset_info
.type
,
2634 pinfo
->valaddr
+ baton
->offset_info
.offset
);
2636 val
= value_at (baton
->offset_info
.type
,
2637 pinfo
->addr
+ baton
->offset_info
.offset
);
2638 *value
= value_as_address (val
);
2646 /* See dwarf2loc.h. */
2649 dwarf2_compile_property_to_c (struct ui_file
*stream
,
2650 const char *result_name
,
2651 struct gdbarch
*gdbarch
,
2652 unsigned char *registers_used
,
2653 const struct dynamic_prop
*prop
,
2657 struct dwarf2_property_baton
*baton
2658 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2659 const gdb_byte
*data
;
2661 struct dwarf2_per_cu_data
*per_cu
;
2663 if (prop
->kind
== PROP_LOCEXPR
)
2665 data
= baton
->locexpr
.data
;
2666 size
= baton
->locexpr
.size
;
2667 per_cu
= baton
->locexpr
.per_cu
;
2671 gdb_assert (prop
->kind
== PROP_LOCLIST
);
2673 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2674 per_cu
= baton
->loclist
.per_cu
;
2677 compile_dwarf_bounds_to_c (stream
, result_name
, prop
, sym
, pc
,
2678 gdbarch
, registers_used
,
2679 dwarf2_per_cu_addr_size (per_cu
),
2680 data
, data
+ size
, per_cu
);
2684 /* Helper functions and baton for dwarf2_loc_desc_get_symbol_read_needs. */
2686 class symbol_needs_eval_context
: public dwarf_expr_context
2690 enum symbol_needs_kind needs
;
2691 struct dwarf2_per_cu_data
*per_cu
;
2693 /* Reads from registers do require a frame. */
2694 CORE_ADDR
read_addr_from_reg (int regnum
) OVERRIDE
2696 needs
= SYMBOL_NEEDS_FRAME
;
2700 /* "get_reg_value" callback: Reads from registers do require a
2703 struct value
*get_reg_value (struct type
*type
, int regnum
) OVERRIDE
2705 needs
= SYMBOL_NEEDS_FRAME
;
2706 return value_zero (type
, not_lval
);
2709 /* Reads from memory do not require a frame. */
2710 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) OVERRIDE
2712 memset (buf
, 0, len
);
2715 /* Frame-relative accesses do require a frame. */
2716 void get_frame_base (const gdb_byte
**start
, size_t *length
) OVERRIDE
2718 static gdb_byte lit0
= DW_OP_lit0
;
2723 needs
= SYMBOL_NEEDS_FRAME
;
2726 /* CFA accesses require a frame. */
2727 CORE_ADDR
get_frame_cfa () OVERRIDE
2729 needs
= SYMBOL_NEEDS_FRAME
;
2733 CORE_ADDR
get_frame_pc () OVERRIDE
2735 needs
= SYMBOL_NEEDS_FRAME
;
2739 /* Thread-local accesses require registers, but not a frame. */
2740 CORE_ADDR
get_tls_address (CORE_ADDR offset
) OVERRIDE
2742 if (needs
<= SYMBOL_NEEDS_REGISTERS
)
2743 needs
= SYMBOL_NEEDS_REGISTERS
;
2747 /* Helper interface of per_cu_dwarf_call for
2748 dwarf2_loc_desc_get_symbol_read_needs. */
2750 void dwarf_call (cu_offset die_offset
) OVERRIDE
2752 per_cu_dwarf_call (this, die_offset
, per_cu
);
2755 /* DW_OP_GNU_entry_value accesses require a caller, therefore a
2758 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
2759 union call_site_parameter_u kind_u
,
2760 int deref_size
) OVERRIDE
2762 needs
= SYMBOL_NEEDS_FRAME
;
2764 /* The expression may require some stub values on DWARF stack. */
2765 push_address (0, 0);
2768 /* DW_OP_GNU_addr_index doesn't require a frame. */
2770 CORE_ADDR
get_addr_index (unsigned int index
) OVERRIDE
2772 /* Nothing to do. */
2776 /* DW_OP_push_object_address has a frame already passed through. */
2778 CORE_ADDR
get_object_address () OVERRIDE
2780 /* Nothing to do. */
2785 /* Compute the correct symbol_needs_kind value for the location
2786 expression at DATA (length SIZE). */
2788 static enum symbol_needs_kind
2789 dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte
*data
, size_t size
,
2790 struct dwarf2_per_cu_data
*per_cu
)
2793 struct cleanup
*old_chain
;
2794 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2796 symbol_needs_eval_context ctx
;
2798 ctx
.needs
= SYMBOL_NEEDS_NONE
;
2799 ctx
.per_cu
= per_cu
;
2801 old_chain
= make_cleanup_value_free_to_mark (value_mark ());
2803 ctx
.gdbarch
= get_objfile_arch (objfile
);
2804 ctx
.addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2805 ctx
.ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2806 ctx
.offset
= dwarf2_per_cu_text_offset (per_cu
);
2808 ctx
.eval (data
, size
);
2810 in_reg
= ctx
.location
== DWARF_VALUE_REGISTER
;
2812 if (ctx
.num_pieces
> 0)
2816 /* If the location has several pieces, and any of them are in
2817 registers, then we will need a frame to fetch them from. */
2818 for (i
= 0; i
< ctx
.num_pieces
; i
++)
2819 if (ctx
.pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2823 do_cleanups (old_chain
);
2826 ctx
.needs
= SYMBOL_NEEDS_FRAME
;
2830 /* A helper function that throws an unimplemented error mentioning a
2831 given DWARF operator. */
2834 unimplemented (unsigned int op
)
2836 const char *name
= get_DW_OP_name (op
);
2839 error (_("DWARF operator %s cannot be translated to an agent expression"),
2842 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2843 "to an agent expression"),
2849 This is basically a wrapper on gdbarch_dwarf2_reg_to_regnum so that we
2850 can issue a complaint, which is better than having every target's
2851 implementation of dwarf2_reg_to_regnum do it. */
2854 dwarf_reg_to_regnum (struct gdbarch
*arch
, int dwarf_reg
)
2856 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2860 complaint (&symfile_complaints
,
2861 _("bad DWARF register number %d"), dwarf_reg
);
2866 /* Subroutine of dwarf_reg_to_regnum_or_error to simplify it.
2867 Throw an error because DWARF_REG is bad. */
2870 throw_bad_regnum_error (ULONGEST dwarf_reg
)
2872 /* Still want to print -1 as "-1".
2873 We *could* have int and ULONGEST versions of dwarf2_reg_to_regnum_or_error
2874 but that's overkill for now. */
2875 if ((int) dwarf_reg
== dwarf_reg
)
2876 error (_("Unable to access DWARF register number %d"), (int) dwarf_reg
);
2877 error (_("Unable to access DWARF register number %s"),
2878 pulongest (dwarf_reg
));
2881 /* See dwarf2loc.h. */
2884 dwarf_reg_to_regnum_or_error (struct gdbarch
*arch
, ULONGEST dwarf_reg
)
2888 if (dwarf_reg
> INT_MAX
)
2889 throw_bad_regnum_error (dwarf_reg
);
2890 /* Yes, we will end up issuing a complaint and an error if DWARF_REG is
2891 bad, but that's ok. */
2892 reg
= dwarf_reg_to_regnum (arch
, (int) dwarf_reg
);
2894 throw_bad_regnum_error (dwarf_reg
);
2898 /* A helper function that emits an access to memory. ARCH is the
2899 target architecture. EXPR is the expression which we are building.
2900 NBITS is the number of bits we want to read. This emits the
2901 opcodes needed to read the memory and then extract the desired
2905 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2907 ULONGEST nbytes
= (nbits
+ 7) / 8;
2909 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2912 ax_trace_quick (expr
, nbytes
);
2915 ax_simple (expr
, aop_ref8
);
2916 else if (nbits
<= 16)
2917 ax_simple (expr
, aop_ref16
);
2918 else if (nbits
<= 32)
2919 ax_simple (expr
, aop_ref32
);
2921 ax_simple (expr
, aop_ref64
);
2923 /* If we read exactly the number of bytes we wanted, we're done. */
2924 if (8 * nbytes
== nbits
)
2927 if (gdbarch_bits_big_endian (arch
))
2929 /* On a bits-big-endian machine, we want the high-order
2931 ax_const_l (expr
, 8 * nbytes
- nbits
);
2932 ax_simple (expr
, aop_rsh_unsigned
);
2936 /* On a bits-little-endian box, we want the low-order NBITS. */
2937 ax_zero_ext (expr
, nbits
);
2941 /* A helper function to return the frame's PC. */
2944 get_ax_pc (void *baton
)
2946 struct agent_expr
*expr
= (struct agent_expr
*) baton
;
2951 /* Compile a DWARF location expression to an agent expression.
2953 EXPR is the agent expression we are building.
2954 LOC is the agent value we modify.
2955 ARCH is the architecture.
2956 ADDR_SIZE is the size of addresses, in bytes.
2957 OP_PTR is the start of the location expression.
2958 OP_END is one past the last byte of the location expression.
2960 This will throw an exception for various kinds of errors -- for
2961 example, if the expression cannot be compiled, or if the expression
2965 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2966 struct gdbarch
*arch
, unsigned int addr_size
,
2967 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
2968 struct dwarf2_per_cu_data
*per_cu
)
2971 std::vector
<int> dw_labels
, patches
;
2972 const gdb_byte
* const base
= op_ptr
;
2973 const gdb_byte
*previous_piece
= op_ptr
;
2974 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2975 ULONGEST bits_collected
= 0;
2976 unsigned int addr_size_bits
= 8 * addr_size
;
2977 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
2979 std::vector
<int> offsets (op_end
- op_ptr
, -1);
2981 /* By default we are making an address. */
2982 loc
->kind
= axs_lvalue_memory
;
2984 while (op_ptr
< op_end
)
2986 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
2987 uint64_t uoffset
, reg
;
2991 offsets
[op_ptr
- base
] = expr
->len
;
2994 /* Our basic approach to code generation is to map DWARF
2995 operations directly to AX operations. However, there are
2998 First, DWARF works on address-sized units, but AX always uses
2999 LONGEST. For most operations we simply ignore this
3000 difference; instead we generate sign extensions as needed
3001 before division and comparison operations. It would be nice
3002 to omit the sign extensions, but there is no way to determine
3003 the size of the target's LONGEST. (This code uses the size
3004 of the host LONGEST in some cases -- that is a bug but it is
3007 Second, some DWARF operations cannot be translated to AX.
3008 For these we simply fail. See
3009 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
3044 ax_const_l (expr
, op
- DW_OP_lit0
);
3048 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
3049 op_ptr
+= addr_size
;
3050 /* Some versions of GCC emit DW_OP_addr before
3051 DW_OP_GNU_push_tls_address. In this case the value is an
3052 index, not an address. We don't support things like
3053 branching between the address and the TLS op. */
3054 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
3055 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
3056 ax_const_l (expr
, uoffset
);
3060 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
3064 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
3068 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
3072 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
3076 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
3080 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
3084 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
3088 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
3092 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3093 ax_const_l (expr
, uoffset
);
3096 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3097 ax_const_l (expr
, offset
);
3132 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3133 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_reg0
);
3134 loc
->kind
= axs_lvalue_register
;
3138 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3139 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3140 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3141 loc
->kind
= axs_lvalue_register
;
3144 case DW_OP_implicit_value
:
3148 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
3149 if (op_ptr
+ len
> op_end
)
3150 error (_("DW_OP_implicit_value: too few bytes available."));
3151 if (len
> sizeof (ULONGEST
))
3152 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
3155 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
3158 dwarf_expr_require_composition (op_ptr
, op_end
,
3159 "DW_OP_implicit_value");
3161 loc
->kind
= axs_rvalue
;
3165 case DW_OP_stack_value
:
3166 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
3167 loc
->kind
= axs_rvalue
;
3202 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3203 i
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_breg0
);
3207 ax_const_l (expr
, offset
);
3208 ax_simple (expr
, aop_add
);
3213 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3214 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3215 i
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3219 ax_const_l (expr
, offset
);
3220 ax_simple (expr
, aop_add
);
3226 const gdb_byte
*datastart
;
3228 const struct block
*b
;
3229 struct symbol
*framefunc
;
3231 b
= block_for_pc (expr
->scope
);
3234 error (_("No block found for address"));
3236 framefunc
= block_linkage_function (b
);
3239 error (_("No function found for block"));
3241 func_get_frame_base_dwarf_block (framefunc
, expr
->scope
,
3242 &datastart
, &datalen
);
3244 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3245 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
3246 datastart
+ datalen
, per_cu
);
3247 if (loc
->kind
== axs_lvalue_register
)
3248 require_rvalue (expr
, loc
);
3252 ax_const_l (expr
, offset
);
3253 ax_simple (expr
, aop_add
);
3256 loc
->kind
= axs_lvalue_memory
;
3261 ax_simple (expr
, aop_dup
);
3265 ax_simple (expr
, aop_pop
);
3270 ax_pick (expr
, offset
);
3274 ax_simple (expr
, aop_swap
);
3282 ax_simple (expr
, aop_rot
);
3286 case DW_OP_deref_size
:
3290 if (op
== DW_OP_deref_size
)
3295 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3296 error (_("Unsupported size %d in %s"),
3297 size
, get_DW_OP_name (op
));
3298 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3303 /* Sign extend the operand. */
3304 ax_ext (expr
, addr_size_bits
);
3305 ax_simple (expr
, aop_dup
);
3306 ax_const_l (expr
, 0);
3307 ax_simple (expr
, aop_less_signed
);
3308 ax_simple (expr
, aop_log_not
);
3309 i
= ax_goto (expr
, aop_if_goto
);
3310 /* We have to emit 0 - X. */
3311 ax_const_l (expr
, 0);
3312 ax_simple (expr
, aop_swap
);
3313 ax_simple (expr
, aop_sub
);
3314 ax_label (expr
, i
, expr
->len
);
3318 /* No need to sign extend here. */
3319 ax_const_l (expr
, 0);
3320 ax_simple (expr
, aop_swap
);
3321 ax_simple (expr
, aop_sub
);
3325 /* Sign extend the operand. */
3326 ax_ext (expr
, addr_size_bits
);
3327 ax_simple (expr
, aop_bit_not
);
3330 case DW_OP_plus_uconst
:
3331 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3332 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3333 but we micro-optimize anyhow. */
3336 ax_const_l (expr
, reg
);
3337 ax_simple (expr
, aop_add
);
3342 ax_simple (expr
, aop_bit_and
);
3346 /* Sign extend the operands. */
3347 ax_ext (expr
, addr_size_bits
);
3348 ax_simple (expr
, aop_swap
);
3349 ax_ext (expr
, addr_size_bits
);
3350 ax_simple (expr
, aop_swap
);
3351 ax_simple (expr
, aop_div_signed
);
3355 ax_simple (expr
, aop_sub
);
3359 ax_simple (expr
, aop_rem_unsigned
);
3363 ax_simple (expr
, aop_mul
);
3367 ax_simple (expr
, aop_bit_or
);
3371 ax_simple (expr
, aop_add
);
3375 ax_simple (expr
, aop_lsh
);
3379 ax_simple (expr
, aop_rsh_unsigned
);
3383 ax_simple (expr
, aop_rsh_signed
);
3387 ax_simple (expr
, aop_bit_xor
);
3391 /* Sign extend the operands. */
3392 ax_ext (expr
, addr_size_bits
);
3393 ax_simple (expr
, aop_swap
);
3394 ax_ext (expr
, addr_size_bits
);
3395 /* Note no swap here: A <= B is !(B < A). */
3396 ax_simple (expr
, aop_less_signed
);
3397 ax_simple (expr
, aop_log_not
);
3401 /* Sign extend the operands. */
3402 ax_ext (expr
, addr_size_bits
);
3403 ax_simple (expr
, aop_swap
);
3404 ax_ext (expr
, addr_size_bits
);
3405 ax_simple (expr
, aop_swap
);
3406 /* A >= B is !(A < B). */
3407 ax_simple (expr
, aop_less_signed
);
3408 ax_simple (expr
, aop_log_not
);
3412 /* Sign extend the operands. */
3413 ax_ext (expr
, addr_size_bits
);
3414 ax_simple (expr
, aop_swap
);
3415 ax_ext (expr
, addr_size_bits
);
3416 /* No need for a second swap here. */
3417 ax_simple (expr
, aop_equal
);
3421 /* Sign extend the operands. */
3422 ax_ext (expr
, addr_size_bits
);
3423 ax_simple (expr
, aop_swap
);
3424 ax_ext (expr
, addr_size_bits
);
3425 ax_simple (expr
, aop_swap
);
3426 ax_simple (expr
, aop_less_signed
);
3430 /* Sign extend the operands. */
3431 ax_ext (expr
, addr_size_bits
);
3432 ax_simple (expr
, aop_swap
);
3433 ax_ext (expr
, addr_size_bits
);
3434 /* Note no swap here: A > B is B < A. */
3435 ax_simple (expr
, aop_less_signed
);
3439 /* Sign extend the operands. */
3440 ax_ext (expr
, addr_size_bits
);
3441 ax_simple (expr
, aop_swap
);
3442 ax_ext (expr
, addr_size_bits
);
3443 /* No need for a swap here. */
3444 ax_simple (expr
, aop_equal
);
3445 ax_simple (expr
, aop_log_not
);
3448 case DW_OP_call_frame_cfa
:
3451 CORE_ADDR text_offset
;
3453 const gdb_byte
*cfa_start
, *cfa_end
;
3455 if (dwarf2_fetch_cfa_info (arch
, expr
->scope
, per_cu
,
3457 &text_offset
, &cfa_start
, &cfa_end
))
3460 ax_reg (expr
, regnum
);
3463 ax_const_l (expr
, off
);
3464 ax_simple (expr
, aop_add
);
3469 /* Another expression. */
3470 ax_const_l (expr
, text_offset
);
3471 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3472 cfa_start
, cfa_end
, per_cu
);
3475 loc
->kind
= axs_lvalue_memory
;
3479 case DW_OP_GNU_push_tls_address
:
3480 case DW_OP_form_tls_address
:
3484 case DW_OP_push_object_address
:
3489 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3491 i
= ax_goto (expr
, aop_goto
);
3492 dw_labels
.push_back (op_ptr
+ offset
- base
);
3493 patches
.push_back (i
);
3497 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3499 /* Zero extend the operand. */
3500 ax_zero_ext (expr
, addr_size_bits
);
3501 i
= ax_goto (expr
, aop_if_goto
);
3502 dw_labels
.push_back (op_ptr
+ offset
- base
);
3503 patches
.push_back (i
);
3510 case DW_OP_bit_piece
:
3512 uint64_t size
, offset
;
3514 if (op_ptr
- 1 == previous_piece
)
3515 error (_("Cannot translate empty pieces to agent expressions"));
3516 previous_piece
= op_ptr
- 1;
3518 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3519 if (op
== DW_OP_piece
)
3525 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
3527 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3528 error (_("Expression pieces exceed word size"));
3530 /* Access the bits. */
3533 case axs_lvalue_register
:
3534 ax_reg (expr
, loc
->u
.reg
);
3537 case axs_lvalue_memory
:
3538 /* Offset the pointer, if needed. */
3541 ax_const_l (expr
, offset
/ 8);
3542 ax_simple (expr
, aop_add
);
3545 access_memory (arch
, expr
, size
);
3549 /* For a bits-big-endian target, shift up what we already
3550 have. For a bits-little-endian target, shift up the
3551 new data. Note that there is a potential bug here if
3552 the DWARF expression leaves multiple values on the
3554 if (bits_collected
> 0)
3556 if (bits_big_endian
)
3558 ax_simple (expr
, aop_swap
);
3559 ax_const_l (expr
, size
);
3560 ax_simple (expr
, aop_lsh
);
3561 /* We don't need a second swap here, because
3562 aop_bit_or is symmetric. */
3566 ax_const_l (expr
, size
);
3567 ax_simple (expr
, aop_lsh
);
3569 ax_simple (expr
, aop_bit_or
);
3572 bits_collected
+= size
;
3573 loc
->kind
= axs_rvalue
;
3577 case DW_OP_GNU_uninit
:
3583 struct dwarf2_locexpr_baton block
;
3584 int size
= (op
== DW_OP_call2
? 2 : 4);
3587 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3590 offset
.cu_off
= uoffset
;
3591 block
= dwarf2_fetch_die_loc_cu_off (offset
, per_cu
,
3594 /* DW_OP_call_ref is currently not supported. */
3595 gdb_assert (block
.per_cu
== per_cu
);
3597 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3598 block
.data
, block
.data
+ block
.size
,
3603 case DW_OP_call_ref
:
3611 /* Patch all the branches we emitted. */
3612 for (i
= 0; i
< patches
.size (); ++i
)
3614 int targ
= offsets
[dw_labels
[i
]];
3616 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3617 ax_label (expr
, patches
[i
], targ
);
3622 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3623 evaluator to calculate the location. */
3624 static struct value
*
3625 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3627 struct dwarf2_locexpr_baton
*dlbaton
3628 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3631 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3632 dlbaton
->size
, dlbaton
->per_cu
);
3637 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3638 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3641 static struct value
*
3642 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3644 struct dwarf2_locexpr_baton
*dlbaton
3645 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3647 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3651 /* Implementation of get_symbol_read_needs from
3652 symbol_computed_ops. */
3654 static enum symbol_needs_kind
3655 locexpr_get_symbol_read_needs (struct symbol
*symbol
)
3657 struct dwarf2_locexpr_baton
*dlbaton
3658 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3660 return dwarf2_loc_desc_get_symbol_read_needs (dlbaton
->data
, dlbaton
->size
,
3664 /* Return true if DATA points to the end of a piece. END is one past
3665 the last byte in the expression. */
3668 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3670 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3673 /* Helper for locexpr_describe_location_piece that finds the name of a
3677 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3681 /* This doesn't use dwarf_reg_to_regnum_or_error on purpose.
3682 We'd rather print *something* here than throw an error. */
3683 regnum
= dwarf_reg_to_regnum (gdbarch
, dwarf_regnum
);
3684 /* gdbarch_register_name may just return "", return something more
3685 descriptive for bad register numbers. */
3688 /* The text is output as "$bad_register_number".
3689 That is why we use the underscores. */
3690 return _("bad_register_number");
3692 return gdbarch_register_name (gdbarch
, regnum
);
3695 /* Nicely describe a single piece of a location, returning an updated
3696 position in the bytecode sequence. This function cannot recognize
3697 all locations; if a location is not recognized, it simply returns
3698 DATA. If there is an error during reading, e.g. we run off the end
3699 of the buffer, an error is thrown. */
3701 static const gdb_byte
*
3702 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3703 CORE_ADDR addr
, struct objfile
*objfile
,
3704 struct dwarf2_per_cu_data
*per_cu
,
3705 const gdb_byte
*data
, const gdb_byte
*end
,
3706 unsigned int addr_size
)
3708 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3711 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3713 fprintf_filtered (stream
, _("a variable in $%s"),
3714 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3717 else if (data
[0] == DW_OP_regx
)
3721 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3722 fprintf_filtered (stream
, _("a variable in $%s"),
3723 locexpr_regname (gdbarch
, reg
));
3725 else if (data
[0] == DW_OP_fbreg
)
3727 const struct block
*b
;
3728 struct symbol
*framefunc
;
3730 int64_t frame_offset
;
3731 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3733 int64_t base_offset
= 0;
3735 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3736 if (!piece_end_p (new_data
, end
))
3740 b
= block_for_pc (addr
);
3743 error (_("No block found for address for symbol \"%s\"."),
3744 SYMBOL_PRINT_NAME (symbol
));
3746 framefunc
= block_linkage_function (b
);
3749 error (_("No function found for block for symbol \"%s\"."),
3750 SYMBOL_PRINT_NAME (symbol
));
3752 func_get_frame_base_dwarf_block (framefunc
, addr
, &base_data
, &base_size
);
3754 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3756 const gdb_byte
*buf_end
;
3758 frame_reg
= base_data
[0] - DW_OP_breg0
;
3759 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3761 if (buf_end
!= base_data
+ base_size
)
3762 error (_("Unexpected opcode after "
3763 "DW_OP_breg%u for symbol \"%s\"."),
3764 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3766 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3768 /* The frame base is just the register, with no offset. */
3769 frame_reg
= base_data
[0] - DW_OP_reg0
;
3774 /* We don't know what to do with the frame base expression,
3775 so we can't trace this variable; give up. */
3779 fprintf_filtered (stream
,
3780 _("a variable at frame base reg $%s offset %s+%s"),
3781 locexpr_regname (gdbarch
, frame_reg
),
3782 plongest (base_offset
), plongest (frame_offset
));
3784 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3785 && piece_end_p (data
, end
))
3789 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3791 fprintf_filtered (stream
,
3792 _("a variable at offset %s from base reg $%s"),
3794 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3797 /* The location expression for a TLS variable looks like this (on a
3800 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3801 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3803 0x3 is the encoding for DW_OP_addr, which has an operand as long
3804 as the size of an address on the target machine (here is 8
3805 bytes). Note that more recent version of GCC emit DW_OP_const4u
3806 or DW_OP_const8u, depending on address size, rather than
3807 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3808 The operand represents the offset at which the variable is within
3809 the thread local storage. */
3811 else if (data
+ 1 + addr_size
< end
3812 && (data
[0] == DW_OP_addr
3813 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3814 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3815 && (data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3816 || data
[1 + addr_size
] == DW_OP_form_tls_address
)
3817 && piece_end_p (data
+ 2 + addr_size
, end
))
3820 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3821 gdbarch_byte_order (gdbarch
));
3823 fprintf_filtered (stream
,
3824 _("a thread-local variable at offset 0x%s "
3825 "in the thread-local storage for `%s'"),
3826 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3828 data
+= 1 + addr_size
+ 1;
3831 /* With -gsplit-dwarf a TLS variable can also look like this:
3832 DW_AT_location : 3 byte block: fc 4 e0
3833 (DW_OP_GNU_const_index: 4;
3834 DW_OP_GNU_push_tls_address) */
3835 else if (data
+ 3 <= end
3836 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3837 && data
[0] == DW_OP_GNU_const_index
3839 && (data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3840 || data
[1 + leb128_size
] == DW_OP_form_tls_address
)
3841 && piece_end_p (data
+ 2 + leb128_size
, end
))
3845 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3846 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3847 fprintf_filtered (stream
,
3848 _("a thread-local variable at offset 0x%s "
3849 "in the thread-local storage for `%s'"),
3850 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3854 else if (data
[0] >= DW_OP_lit0
3855 && data
[0] <= DW_OP_lit31
3857 && data
[1] == DW_OP_stack_value
)
3859 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3866 /* Disassemble an expression, stopping at the end of a piece or at the
3867 end of the expression. Returns a pointer to the next unread byte
3868 in the input expression. If ALL is nonzero, then this function
3869 will keep going until it reaches the end of the expression.
3870 If there is an error during reading, e.g. we run off the end
3871 of the buffer, an error is thrown. */
3873 static const gdb_byte
*
3874 disassemble_dwarf_expression (struct ui_file
*stream
,
3875 struct gdbarch
*arch
, unsigned int addr_size
,
3876 int offset_size
, const gdb_byte
*start
,
3877 const gdb_byte
*data
, const gdb_byte
*end
,
3878 int indent
, int all
,
3879 struct dwarf2_per_cu_data
*per_cu
)
3883 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3885 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *data
++;
3890 name
= get_DW_OP_name (op
);
3893 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3894 op
, (long) (data
- 1 - start
));
3895 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3896 (long) (data
- 1 - start
), name
);
3901 ul
= extract_unsigned_integer (data
, addr_size
,
3902 gdbarch_byte_order (arch
));
3904 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3908 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3910 fprintf_filtered (stream
, " %s", pulongest (ul
));
3913 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3915 fprintf_filtered (stream
, " %s", plongest (l
));
3918 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3920 fprintf_filtered (stream
, " %s", pulongest (ul
));
3923 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3925 fprintf_filtered (stream
, " %s", plongest (l
));
3928 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3930 fprintf_filtered (stream
, " %s", pulongest (ul
));
3933 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3935 fprintf_filtered (stream
, " %s", plongest (l
));
3938 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3940 fprintf_filtered (stream
, " %s", pulongest (ul
));
3943 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3945 fprintf_filtered (stream
, " %s", plongest (l
));
3948 data
= safe_read_uleb128 (data
, end
, &ul
);
3949 fprintf_filtered (stream
, " %s", pulongest (ul
));
3952 data
= safe_read_sleb128 (data
, end
, &l
);
3953 fprintf_filtered (stream
, " %s", plongest (l
));
3988 fprintf_filtered (stream
, " [$%s]",
3989 locexpr_regname (arch
, op
- DW_OP_reg0
));
3993 data
= safe_read_uleb128 (data
, end
, &ul
);
3994 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3995 locexpr_regname (arch
, (int) ul
));
3998 case DW_OP_implicit_value
:
3999 data
= safe_read_uleb128 (data
, end
, &ul
);
4001 fprintf_filtered (stream
, " %s", pulongest (ul
));
4036 data
= safe_read_sleb128 (data
, end
, &l
);
4037 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
4038 locexpr_regname (arch
, op
- DW_OP_breg0
));
4042 data
= safe_read_uleb128 (data
, end
, &ul
);
4043 data
= safe_read_sleb128 (data
, end
, &l
);
4044 fprintf_filtered (stream
, " register %s [$%s] offset %s",
4046 locexpr_regname (arch
, (int) ul
),
4051 data
= safe_read_sleb128 (data
, end
, &l
);
4052 fprintf_filtered (stream
, " %s", plongest (l
));
4055 case DW_OP_xderef_size
:
4056 case DW_OP_deref_size
:
4058 fprintf_filtered (stream
, " %d", *data
);
4062 case DW_OP_plus_uconst
:
4063 data
= safe_read_uleb128 (data
, end
, &ul
);
4064 fprintf_filtered (stream
, " %s", pulongest (ul
));
4068 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4070 fprintf_filtered (stream
, " to %ld",
4071 (long) (data
+ l
- start
));
4075 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4077 fprintf_filtered (stream
, " %ld",
4078 (long) (data
+ l
- start
));
4082 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
4084 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
4088 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4090 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4093 case DW_OP_call_ref
:
4094 ul
= extract_unsigned_integer (data
, offset_size
,
4095 gdbarch_byte_order (arch
));
4096 data
+= offset_size
;
4097 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4101 data
= safe_read_uleb128 (data
, end
, &ul
);
4102 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
4105 case DW_OP_bit_piece
:
4109 data
= safe_read_uleb128 (data
, end
, &ul
);
4110 data
= safe_read_uleb128 (data
, end
, &offset
);
4111 fprintf_filtered (stream
, " size %s offset %s (bits)",
4112 pulongest (ul
), pulongest (offset
));
4116 case DW_OP_GNU_implicit_pointer
:
4118 ul
= extract_unsigned_integer (data
, offset_size
,
4119 gdbarch_byte_order (arch
));
4120 data
+= offset_size
;
4122 data
= safe_read_sleb128 (data
, end
, &l
);
4124 fprintf_filtered (stream
, " DIE %s offset %s",
4125 phex_nz (ul
, offset_size
),
4130 case DW_OP_GNU_deref_type
:
4132 int addr_size
= *data
++;
4136 data
= safe_read_uleb128 (data
, end
, &ul
);
4138 type
= dwarf2_get_die_type (offset
, per_cu
);
4139 fprintf_filtered (stream
, "<");
4140 type_print (type
, "", stream
, -1);
4141 fprintf_filtered (stream
, " [0x%s]> %d", phex_nz (offset
.cu_off
, 0),
4146 case DW_OP_GNU_const_type
:
4151 data
= safe_read_uleb128 (data
, end
, &ul
);
4152 type_die
.cu_off
= ul
;
4153 type
= dwarf2_get_die_type (type_die
, per_cu
);
4154 fprintf_filtered (stream
, "<");
4155 type_print (type
, "", stream
, -1);
4156 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
4160 case DW_OP_GNU_regval_type
:
4166 data
= safe_read_uleb128 (data
, end
, ®
);
4167 data
= safe_read_uleb128 (data
, end
, &ul
);
4168 type_die
.cu_off
= ul
;
4170 type
= dwarf2_get_die_type (type_die
, per_cu
);
4171 fprintf_filtered (stream
, "<");
4172 type_print (type
, "", stream
, -1);
4173 fprintf_filtered (stream
, " [0x%s]> [$%s]",
4174 phex_nz (type_die
.cu_off
, 0),
4175 locexpr_regname (arch
, reg
));
4179 case DW_OP_GNU_convert
:
4180 case DW_OP_GNU_reinterpret
:
4184 data
= safe_read_uleb128 (data
, end
, &ul
);
4185 type_die
.cu_off
= ul
;
4187 if (type_die
.cu_off
== 0)
4188 fprintf_filtered (stream
, "<0>");
4193 type
= dwarf2_get_die_type (type_die
, per_cu
);
4194 fprintf_filtered (stream
, "<");
4195 type_print (type
, "", stream
, -1);
4196 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
4201 case DW_OP_GNU_entry_value
:
4202 data
= safe_read_uleb128 (data
, end
, &ul
);
4203 fputc_filtered ('\n', stream
);
4204 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
4205 start
, data
, data
+ ul
, indent
+ 2,
4210 case DW_OP_GNU_parameter_ref
:
4211 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4213 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4216 case DW_OP_GNU_addr_index
:
4217 data
= safe_read_uleb128 (data
, end
, &ul
);
4218 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4219 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
4221 case DW_OP_GNU_const_index
:
4222 data
= safe_read_uleb128 (data
, end
, &ul
);
4223 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4224 fprintf_filtered (stream
, " %s", pulongest (ul
));
4228 fprintf_filtered (stream
, "\n");
4234 /* Describe a single location, which may in turn consist of multiple
4238 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
4239 struct ui_file
*stream
,
4240 const gdb_byte
*data
, size_t size
,
4241 struct objfile
*objfile
, unsigned int addr_size
,
4242 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
4244 const gdb_byte
*end
= data
+ size
;
4245 int first_piece
= 1, bad
= 0;
4249 const gdb_byte
*here
= data
;
4250 int disassemble
= 1;
4255 fprintf_filtered (stream
, _(", and "));
4257 if (!dwarf_always_disassemble
)
4259 data
= locexpr_describe_location_piece (symbol
, stream
,
4260 addr
, objfile
, per_cu
,
4261 data
, end
, addr_size
);
4262 /* If we printed anything, or if we have an empty piece,
4263 then don't disassemble. */
4265 || data
[0] == DW_OP_piece
4266 || data
[0] == DW_OP_bit_piece
)
4271 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
4272 data
= disassemble_dwarf_expression (stream
,
4273 get_objfile_arch (objfile
),
4274 addr_size
, offset_size
, data
,
4276 dwarf_always_disassemble
,
4282 int empty
= data
== here
;
4285 fprintf_filtered (stream
, " ");
4286 if (data
[0] == DW_OP_piece
)
4290 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
4293 fprintf_filtered (stream
, _("an empty %s-byte piece"),
4296 fprintf_filtered (stream
, _(" [%s-byte piece]"),
4299 else if (data
[0] == DW_OP_bit_piece
)
4301 uint64_t bits
, offset
;
4303 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
4304 data
= safe_read_uleb128 (data
, end
, &offset
);
4307 fprintf_filtered (stream
,
4308 _("an empty %s-bit piece"),
4311 fprintf_filtered (stream
,
4312 _(" [%s-bit piece, offset %s bits]"),
4313 pulongest (bits
), pulongest (offset
));
4323 if (bad
|| data
> end
)
4324 error (_("Corrupted DWARF2 expression for \"%s\"."),
4325 SYMBOL_PRINT_NAME (symbol
));
4328 /* Print a natural-language description of SYMBOL to STREAM. This
4329 version is for a symbol with a single location. */
4332 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4333 struct ui_file
*stream
)
4335 struct dwarf2_locexpr_baton
*dlbaton
4336 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4337 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4338 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4339 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4341 locexpr_describe_location_1 (symbol
, addr
, stream
,
4342 dlbaton
->data
, dlbaton
->size
,
4343 objfile
, addr_size
, offset_size
,
4347 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4348 any necessary bytecode in AX. */
4351 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4352 struct agent_expr
*ax
, struct axs_value
*value
)
4354 struct dwarf2_locexpr_baton
*dlbaton
4355 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4356 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4358 if (dlbaton
->size
== 0)
4359 value
->optimized_out
= 1;
4361 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
4362 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4366 /* symbol_computed_ops 'generate_c_location' method. */
4369 locexpr_generate_c_location (struct symbol
*sym
, struct ui_file
*stream
,
4370 struct gdbarch
*gdbarch
,
4371 unsigned char *registers_used
,
4372 CORE_ADDR pc
, const char *result_name
)
4374 struct dwarf2_locexpr_baton
*dlbaton
4375 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (sym
);
4376 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4378 if (dlbaton
->size
== 0)
4379 error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym
));
4381 compile_dwarf_expr_to_c (stream
, result_name
,
4382 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4383 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4387 /* The set of location functions used with the DWARF-2 expression
4389 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4390 locexpr_read_variable
,
4391 locexpr_read_variable_at_entry
,
4392 locexpr_get_symbol_read_needs
,
4393 locexpr_describe_location
,
4394 0, /* location_has_loclist */
4395 locexpr_tracepoint_var_ref
,
4396 locexpr_generate_c_location
4400 /* Wrapper functions for location lists. These generally find
4401 the appropriate location expression and call something above. */
4403 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4404 evaluator to calculate the location. */
4405 static struct value
*
4406 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4408 struct dwarf2_loclist_baton
*dlbaton
4409 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4411 const gdb_byte
*data
;
4413 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4415 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4416 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4422 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4423 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4426 Function always returns non-NULL value, it may be marked optimized out if
4427 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4428 if it cannot resolve the parameter for any reason. */
4430 static struct value
*
4431 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4433 struct dwarf2_loclist_baton
*dlbaton
4434 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4435 const gdb_byte
*data
;
4439 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4440 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4442 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4444 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4446 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4449 /* Implementation of get_symbol_read_needs from
4450 symbol_computed_ops. */
4452 static enum symbol_needs_kind
4453 loclist_symbol_needs (struct symbol
*symbol
)
4455 /* If there's a location list, then assume we need to have a frame
4456 to choose the appropriate location expression. With tracking of
4457 global variables this is not necessarily true, but such tracking
4458 is disabled in GCC at the moment until we figure out how to
4461 return SYMBOL_NEEDS_FRAME
;
4464 /* Print a natural-language description of SYMBOL to STREAM. This
4465 version applies when there is a list of different locations, each
4466 with a specified address range. */
4469 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4470 struct ui_file
*stream
)
4472 struct dwarf2_loclist_baton
*dlbaton
4473 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4474 const gdb_byte
*loc_ptr
, *buf_end
;
4475 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4476 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4477 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4478 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4479 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4480 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4481 /* Adjust base_address for relocatable objects. */
4482 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4483 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4486 loc_ptr
= dlbaton
->data
;
4487 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4489 fprintf_filtered (stream
, _("multi-location:\n"));
4491 /* Iterate through locations until we run out. */
4494 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4496 enum debug_loc_kind kind
;
4497 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4499 if (dlbaton
->from_dwo
)
4500 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4501 loc_ptr
, buf_end
, &new_ptr
,
4502 &low
, &high
, byte_order
);
4504 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4506 byte_order
, addr_size
,
4511 case DEBUG_LOC_END_OF_LIST
:
4514 case DEBUG_LOC_BASE_ADDRESS
:
4515 base_address
= high
+ base_offset
;
4516 fprintf_filtered (stream
, _(" Base address %s"),
4517 paddress (gdbarch
, base_address
));
4519 case DEBUG_LOC_START_END
:
4520 case DEBUG_LOC_START_LENGTH
:
4522 case DEBUG_LOC_BUFFER_OVERFLOW
:
4523 case DEBUG_LOC_INVALID_ENTRY
:
4524 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4525 SYMBOL_PRINT_NAME (symbol
));
4527 gdb_assert_not_reached ("bad debug_loc_kind");
4530 /* Otherwise, a location expression entry. */
4531 low
+= base_address
;
4532 high
+= base_address
;
4534 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
);
4535 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
);
4537 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4540 /* (It would improve readability to print only the minimum
4541 necessary digits of the second number of the range.) */
4542 fprintf_filtered (stream
, _(" Range %s-%s: "),
4543 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4545 /* Now describe this particular location. */
4546 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4547 objfile
, addr_size
, offset_size
,
4550 fprintf_filtered (stream
, "\n");
4556 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4557 any necessary bytecode in AX. */
4559 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4560 struct agent_expr
*ax
, struct axs_value
*value
)
4562 struct dwarf2_loclist_baton
*dlbaton
4563 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4564 const gdb_byte
*data
;
4566 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4568 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4570 value
->optimized_out
= 1;
4572 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
4576 /* symbol_computed_ops 'generate_c_location' method. */
4579 loclist_generate_c_location (struct symbol
*sym
, struct ui_file
*stream
,
4580 struct gdbarch
*gdbarch
,
4581 unsigned char *registers_used
,
4582 CORE_ADDR pc
, const char *result_name
)
4584 struct dwarf2_loclist_baton
*dlbaton
4585 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (sym
);
4586 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4587 const gdb_byte
*data
;
4590 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4592 error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym
));
4594 compile_dwarf_expr_to_c (stream
, result_name
,
4595 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4600 /* The set of location functions used with the DWARF-2 expression
4601 evaluator and location lists. */
4602 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4603 loclist_read_variable
,
4604 loclist_read_variable_at_entry
,
4605 loclist_symbol_needs
,
4606 loclist_describe_location
,
4607 1, /* location_has_loclist */
4608 loclist_tracepoint_var_ref
,
4609 loclist_generate_c_location
4612 /* Provide a prototype to silence -Wmissing-prototypes. */
4613 extern initialize_file_ftype _initialize_dwarf2loc
;
4616 _initialize_dwarf2loc (void)
4618 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4619 &entry_values_debug
,
4620 _("Set entry values and tail call frames "
4622 _("Show entry values and tail call frames "
4624 _("When non-zero, the process of determining "
4625 "parameter values from function entry point "
4626 "and tail call frames will be printed."),
4628 show_entry_values_debug
,
4629 &setdebuglist
, &showdebuglist
);
4632 register_self_test (selftests::copy_bitwise_tests
);