1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003-2015 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/>. */
37 #include "dwarf2expr.h"
38 #include "dwarf2loc.h"
39 #include "dwarf2-frame.h"
40 #include "compile/compile.h"
42 extern int dwarf_always_disassemble
;
44 extern const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
;
46 static struct value
*dwarf2_evaluate_loc_desc_full (struct type
*type
,
47 struct frame_info
*frame
,
50 struct dwarf2_per_cu_data
*per_cu
,
53 /* Until these have formal names, we define these here.
54 ref: http://gcc.gnu.org/wiki/DebugFission
55 Each entry in .debug_loc.dwo begins with a byte that describes the entry,
56 and is then followed by data specific to that entry. */
60 /* Indicates the end of the list of entries. */
61 DEBUG_LOC_END_OF_LIST
= 0,
63 /* This is followed by an unsigned LEB128 number that is an index into
64 .debug_addr and specifies the base address for all following entries. */
65 DEBUG_LOC_BASE_ADDRESS
= 1,
67 /* This is followed by two unsigned LEB128 numbers that are indices into
68 .debug_addr and specify the beginning and ending addresses, and then
69 a normal location expression as in .debug_loc. */
70 DEBUG_LOC_START_END
= 2,
72 /* This is followed by an unsigned LEB128 number that is an index into
73 .debug_addr and specifies the beginning address, and a 4 byte unsigned
74 number that specifies the length, and then a normal location expression
76 DEBUG_LOC_START_LENGTH
= 3,
78 /* An internal value indicating there is insufficient data. */
79 DEBUG_LOC_BUFFER_OVERFLOW
= -1,
81 /* An internal value indicating an invalid kind of entry was found. */
82 DEBUG_LOC_INVALID_ENTRY
= -2
85 /* Helper function which throws an error if a synthetic pointer is
89 invalid_synthetic_pointer (void)
91 error (_("access outside bounds of object "
92 "referenced via synthetic pointer"));
95 /* Decode the addresses in a non-dwo .debug_loc entry.
96 A pointer to the next byte to examine is returned in *NEW_PTR.
97 The encoded low,high addresses are return in *LOW,*HIGH.
98 The result indicates the kind of entry found. */
100 static enum debug_loc_kind
101 decode_debug_loc_addresses (const gdb_byte
*loc_ptr
, const gdb_byte
*buf_end
,
102 const gdb_byte
**new_ptr
,
103 CORE_ADDR
*low
, CORE_ADDR
*high
,
104 enum bfd_endian byte_order
,
105 unsigned int addr_size
,
108 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
110 if (buf_end
- loc_ptr
< 2 * addr_size
)
111 return DEBUG_LOC_BUFFER_OVERFLOW
;
114 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
116 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
117 loc_ptr
+= addr_size
;
120 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
122 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
123 loc_ptr
+= addr_size
;
127 /* A base-address-selection entry. */
128 if ((*low
& base_mask
) == base_mask
)
129 return DEBUG_LOC_BASE_ADDRESS
;
131 /* An end-of-list entry. */
132 if (*low
== 0 && *high
== 0)
133 return DEBUG_LOC_END_OF_LIST
;
135 return DEBUG_LOC_START_END
;
138 /* Decode the addresses in .debug_loc.dwo entry.
139 A pointer to the next byte to examine is returned in *NEW_PTR.
140 The encoded low,high addresses are return in *LOW,*HIGH.
141 The result indicates the kind of entry found. */
143 static enum debug_loc_kind
144 decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data
*per_cu
,
145 const gdb_byte
*loc_ptr
,
146 const gdb_byte
*buf_end
,
147 const gdb_byte
**new_ptr
,
148 CORE_ADDR
*low
, CORE_ADDR
*high
,
149 enum bfd_endian byte_order
)
151 uint64_t low_index
, high_index
;
153 if (loc_ptr
== buf_end
)
154 return DEBUG_LOC_BUFFER_OVERFLOW
;
158 case DEBUG_LOC_END_OF_LIST
:
160 return DEBUG_LOC_END_OF_LIST
;
161 case DEBUG_LOC_BASE_ADDRESS
:
163 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
165 return DEBUG_LOC_BUFFER_OVERFLOW
;
166 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
168 return DEBUG_LOC_BASE_ADDRESS
;
169 case DEBUG_LOC_START_END
:
170 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
172 return DEBUG_LOC_BUFFER_OVERFLOW
;
173 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
174 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
176 return DEBUG_LOC_BUFFER_OVERFLOW
;
177 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
179 return DEBUG_LOC_START_END
;
180 case DEBUG_LOC_START_LENGTH
:
181 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
183 return DEBUG_LOC_BUFFER_OVERFLOW
;
184 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
185 if (loc_ptr
+ 4 > buf_end
)
186 return DEBUG_LOC_BUFFER_OVERFLOW
;
188 *high
+= extract_unsigned_integer (loc_ptr
, 4, byte_order
);
189 *new_ptr
= loc_ptr
+ 4;
190 return DEBUG_LOC_START_LENGTH
;
192 return DEBUG_LOC_INVALID_ENTRY
;
196 /* A function for dealing with location lists. Given a
197 symbol baton (BATON) and a pc value (PC), find the appropriate
198 location expression, set *LOCEXPR_LENGTH, and return a pointer
199 to the beginning of the expression. Returns NULL on failure.
201 For now, only return the first matching location expression; there
202 can be more than one in the list. */
205 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
206 size_t *locexpr_length
, CORE_ADDR pc
)
208 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
209 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
210 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
211 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
212 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
213 /* Adjust base_address for relocatable objects. */
214 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (baton
->per_cu
);
215 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
216 const gdb_byte
*loc_ptr
, *buf_end
;
218 loc_ptr
= baton
->data
;
219 buf_end
= baton
->data
+ baton
->size
;
223 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
225 enum debug_loc_kind kind
;
226 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
229 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
230 loc_ptr
, buf_end
, &new_ptr
,
231 &low
, &high
, byte_order
);
233 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
235 byte_order
, addr_size
,
240 case DEBUG_LOC_END_OF_LIST
:
243 case DEBUG_LOC_BASE_ADDRESS
:
244 base_address
= high
+ base_offset
;
246 case DEBUG_LOC_START_END
:
247 case DEBUG_LOC_START_LENGTH
:
249 case DEBUG_LOC_BUFFER_OVERFLOW
:
250 case DEBUG_LOC_INVALID_ENTRY
:
251 error (_("dwarf2_find_location_expression: "
252 "Corrupted DWARF expression."));
254 gdb_assert_not_reached ("bad debug_loc_kind");
257 /* Otherwise, a location expression entry.
258 If the entry is from a DWO, don't add base address: the entry is
259 from .debug_addr which has absolute addresses. */
260 if (! baton
->from_dwo
)
263 high
+= base_address
;
266 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
269 if (low
== high
&& pc
== low
)
271 /* This is entry PC record present only at entry point
272 of a function. Verify it is really the function entry point. */
274 const struct block
*pc_block
= block_for_pc (pc
);
275 struct symbol
*pc_func
= NULL
;
278 pc_func
= block_linkage_function (pc_block
);
280 if (pc_func
&& pc
== BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func
)))
282 *locexpr_length
= length
;
287 if (pc
>= low
&& pc
< high
)
289 *locexpr_length
= length
;
297 /* This is the baton used when performing dwarf2 expression
299 struct dwarf_expr_baton
301 struct frame_info
*frame
;
302 struct dwarf2_per_cu_data
*per_cu
;
303 CORE_ADDR obj_address
;
306 /* Helper functions for dwarf2_evaluate_loc_desc. */
308 /* Using the frame specified in BATON, return the value of register
309 REGNUM, treated as a pointer. */
311 dwarf_expr_read_addr_from_reg (void *baton
, int dwarf_regnum
)
313 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
314 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
315 int regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
317 return address_from_register (regnum
, debaton
->frame
);
320 /* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback. */
322 static struct value
*
323 dwarf_expr_get_reg_value (void *baton
, struct type
*type
, int dwarf_regnum
)
325 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
326 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
327 int regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
329 return value_from_register (type
, regnum
, debaton
->frame
);
332 /* Read memory at ADDR (length LEN) into BUF. */
335 dwarf_expr_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
337 read_memory (addr
, buf
, len
);
340 /* Using the frame specified in BATON, find the location expression
341 describing the frame base. Return a pointer to it in START and
342 its length in LENGTH. */
344 dwarf_expr_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
346 /* FIXME: cagney/2003-03-26: This code should be using
347 get_frame_base_address(), and then implement a dwarf2 specific
349 struct symbol
*framefunc
;
350 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
351 const struct block
*bl
= get_frame_block (debaton
->frame
, NULL
);
354 error (_("frame address is not available."));
356 /* Use block_linkage_function, which returns a real (not inlined)
357 function, instead of get_frame_function, which may return an
359 framefunc
= block_linkage_function (bl
);
361 /* If we found a frame-relative symbol then it was certainly within
362 some function associated with a frame. If we can't find the frame,
363 something has gone wrong. */
364 gdb_assert (framefunc
!= NULL
);
366 func_get_frame_base_dwarf_block (framefunc
,
367 get_frame_address_in_block (debaton
->frame
),
371 /* Implement find_frame_base_location method for LOC_BLOCK functions using
372 DWARF expression for its DW_AT_frame_base. */
375 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
376 const gdb_byte
**start
, size_t *length
)
378 struct dwarf2_locexpr_baton
*symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
380 *length
= symbaton
->size
;
381 *start
= symbaton
->data
;
384 /* Implement the struct symbol_block_ops::get_frame_base method for
385 LOC_BLOCK functions using a DWARF expression as its DW_AT_frame_base. */
388 locexpr_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
390 struct gdbarch
*gdbarch
;
392 struct dwarf2_locexpr_baton
*dlbaton
;
393 const gdb_byte
*start
;
395 struct value
*result
;
397 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
398 Thus, it's supposed to provide the find_frame_base_location method as
400 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
402 gdbarch
= get_frame_arch (frame
);
403 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
404 dlbaton
= SYMBOL_LOCATION_BATON (framefunc
);
406 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
407 (framefunc
, get_frame_pc (frame
), &start
, &length
);
408 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
411 /* The DW_AT_frame_base attribute contains a location description which
412 computes the base address itself. However, the call to
413 dwarf2_evaluate_loc_desc returns a value representing a variable at
414 that address. The frame base address is thus this variable's
416 return value_address (result
);
419 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
420 function uses DWARF expression for its DW_AT_frame_base. */
422 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
424 locexpr_find_frame_base_location
,
425 locexpr_get_frame_base
428 /* Implement find_frame_base_location method for LOC_BLOCK functions using
429 DWARF location list for its DW_AT_frame_base. */
432 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
433 const gdb_byte
**start
, size_t *length
)
435 struct dwarf2_loclist_baton
*symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
437 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
440 /* Implement the struct symbol_block_ops::get_frame_base method for
441 LOC_BLOCK functions using a DWARF location list as its DW_AT_frame_base. */
444 loclist_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
446 struct gdbarch
*gdbarch
;
448 struct dwarf2_loclist_baton
*dlbaton
;
449 const gdb_byte
*start
;
451 struct value
*result
;
453 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
454 Thus, it's supposed to provide the find_frame_base_location method as
456 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
458 gdbarch
= get_frame_arch (frame
);
459 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
460 dlbaton
= SYMBOL_LOCATION_BATON (framefunc
);
462 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
463 (framefunc
, get_frame_pc (frame
), &start
, &length
);
464 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
467 /* The DW_AT_frame_base attribute contains a location description which
468 computes the base address itself. However, the call to
469 dwarf2_evaluate_loc_desc returns a value representing a variable at
470 that address. The frame base address is thus this variable's
472 return value_address (result
);
475 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
476 function uses DWARF location list for its DW_AT_frame_base. */
478 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
480 loclist_find_frame_base_location
,
481 loclist_get_frame_base
484 /* See dwarf2loc.h. */
487 func_get_frame_base_dwarf_block (struct symbol
*framefunc
, CORE_ADDR pc
,
488 const gdb_byte
**start
, size_t *length
)
490 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
492 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
494 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
500 error (_("Could not find the frame base for \"%s\"."),
501 SYMBOL_NATURAL_NAME (framefunc
));
504 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
505 the frame in BATON. */
508 dwarf_expr_frame_cfa (void *baton
)
510 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
512 return dwarf2_frame_cfa (debaton
->frame
);
515 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
516 the frame in BATON. */
519 dwarf_expr_frame_pc (void *baton
)
521 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
523 return get_frame_address_in_block (debaton
->frame
);
526 /* Using the objfile specified in BATON, find the address for the
527 current thread's thread-local storage with offset OFFSET. */
529 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
531 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
532 struct objfile
*objfile
= dwarf2_per_cu_objfile (debaton
->per_cu
);
534 return target_translate_tls_address (objfile
, offset
);
537 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
538 current CU (as is PER_CU). State of the CTX is not affected by the
542 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
543 struct dwarf2_per_cu_data
*per_cu
,
544 CORE_ADDR (*get_frame_pc
) (void *baton
),
547 struct dwarf2_locexpr_baton block
;
549 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
, get_frame_pc
, baton
);
551 /* DW_OP_call_ref is currently not supported. */
552 gdb_assert (block
.per_cu
== per_cu
);
554 dwarf_expr_eval (ctx
, block
.data
, block
.size
);
557 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
560 dwarf_expr_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
562 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
564 per_cu_dwarf_call (ctx
, die_offset
, debaton
->per_cu
,
565 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
568 /* Callback function for dwarf2_evaluate_loc_desc. */
571 dwarf_expr_get_base_type (struct dwarf_expr_context
*ctx
,
572 cu_offset die_offset
)
574 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
576 return dwarf2_get_die_type (die_offset
, debaton
->per_cu
);
579 /* See dwarf2loc.h. */
581 unsigned int entry_values_debug
= 0;
583 /* Helper to set entry_values_debug. */
586 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
587 struct cmd_list_element
*c
, const char *value
)
589 fprintf_filtered (file
,
590 _("Entry values and tail call frames debugging is %s.\n"),
594 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
595 CALLER_FRAME (for registers) can be NULL if it is not known. This function
596 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
599 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
600 struct call_site
*call_site
,
601 struct frame_info
*caller_frame
)
603 switch (FIELD_LOC_KIND (call_site
->target
))
605 case FIELD_LOC_KIND_DWARF_BLOCK
:
607 struct dwarf2_locexpr_baton
*dwarf_block
;
609 struct type
*caller_core_addr_type
;
610 struct gdbarch
*caller_arch
;
612 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
613 if (dwarf_block
== NULL
)
615 struct bound_minimal_symbol msym
;
617 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
618 throw_error (NO_ENTRY_VALUE_ERROR
,
619 _("DW_AT_GNU_call_site_target is not specified "
621 paddress (call_site_gdbarch
, call_site
->pc
),
622 (msym
.minsym
== NULL
? "???"
623 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
626 if (caller_frame
== NULL
)
628 struct bound_minimal_symbol msym
;
630 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
631 throw_error (NO_ENTRY_VALUE_ERROR
,
632 _("DW_AT_GNU_call_site_target DWARF block resolving "
633 "requires known frame which is currently not "
634 "available at %s in %s"),
635 paddress (call_site_gdbarch
, call_site
->pc
),
636 (msym
.minsym
== NULL
? "???"
637 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
640 caller_arch
= get_frame_arch (caller_frame
);
641 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
642 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
643 dwarf_block
->data
, dwarf_block
->size
,
644 dwarf_block
->per_cu
);
645 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
647 if (VALUE_LVAL (val
) == lval_memory
)
648 return value_address (val
);
650 return value_as_address (val
);
653 case FIELD_LOC_KIND_PHYSNAME
:
655 const char *physname
;
656 struct bound_minimal_symbol msym
;
658 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
660 /* Handle both the mangled and demangled PHYSNAME. */
661 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
662 if (msym
.minsym
== NULL
)
664 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
665 throw_error (NO_ENTRY_VALUE_ERROR
,
666 _("Cannot find function \"%s\" for a call site target "
668 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
669 (msym
.minsym
== NULL
? "???"
670 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
673 return BMSYMBOL_VALUE_ADDRESS (msym
);
676 case FIELD_LOC_KIND_PHYSADDR
:
677 return FIELD_STATIC_PHYSADDR (call_site
->target
);
680 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
684 /* Convert function entry point exact address ADDR to the function which is
685 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
686 NO_ENTRY_VALUE_ERROR otherwise. */
688 static struct symbol
*
689 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
691 struct symbol
*sym
= find_pc_function (addr
);
694 if (sym
== NULL
|| BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
695 throw_error (NO_ENTRY_VALUE_ERROR
,
696 _("DW_TAG_GNU_call_site resolving failed to find function "
697 "name for address %s"),
698 paddress (gdbarch
, addr
));
700 type
= SYMBOL_TYPE (sym
);
701 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
702 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
707 /* Verify function with entry point exact address ADDR can never call itself
708 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
709 can call itself via tail calls.
711 If a funtion can tail call itself its entry value based parameters are
712 unreliable. There is no verification whether the value of some/all
713 parameters is unchanged through the self tail call, we expect if there is
714 a self tail call all the parameters can be modified. */
717 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
719 struct obstack addr_obstack
;
720 struct cleanup
*old_chain
;
723 /* Track here CORE_ADDRs which were already visited. */
726 /* The verification is completely unordered. Track here function addresses
727 which still need to be iterated. */
728 VEC (CORE_ADDR
) *todo
= NULL
;
730 obstack_init (&addr_obstack
);
731 old_chain
= make_cleanup_obstack_free (&addr_obstack
);
732 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
733 &addr_obstack
, hashtab_obstack_allocate
,
735 make_cleanup_htab_delete (addr_hash
);
737 make_cleanup (VEC_cleanup (CORE_ADDR
), &todo
);
739 VEC_safe_push (CORE_ADDR
, todo
, verify_addr
);
740 while (!VEC_empty (CORE_ADDR
, todo
))
742 struct symbol
*func_sym
;
743 struct call_site
*call_site
;
745 addr
= VEC_pop (CORE_ADDR
, todo
);
747 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
749 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
750 call_site
; call_site
= call_site
->tail_call_next
)
752 CORE_ADDR target_addr
;
755 /* CALLER_FRAME with registers is not available for tail-call jumped
757 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
759 if (target_addr
== verify_addr
)
761 struct bound_minimal_symbol msym
;
763 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
764 throw_error (NO_ENTRY_VALUE_ERROR
,
765 _("DW_OP_GNU_entry_value resolving has found "
766 "function \"%s\" at %s can call itself via tail "
768 (msym
.minsym
== NULL
? "???"
769 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
770 paddress (gdbarch
, verify_addr
));
773 slot
= htab_find_slot (addr_hash
, &target_addr
, INSERT
);
776 *slot
= obstack_copy (&addr_obstack
, &target_addr
,
777 sizeof (target_addr
));
778 VEC_safe_push (CORE_ADDR
, todo
, target_addr
);
783 do_cleanups (old_chain
);
786 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
787 ENTRY_VALUES_DEBUG. */
790 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
792 CORE_ADDR addr
= call_site
->pc
;
793 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
795 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
796 (msym
.minsym
== NULL
? "???"
797 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
801 /* vec.h needs single word type name, typedef it. */
802 typedef struct call_site
*call_sitep
;
804 /* Define VEC (call_sitep) functions. */
805 DEF_VEC_P (call_sitep
);
807 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
808 only top callers and bottom callees which are present in both. GDBARCH is
809 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
810 no remaining possibilities to provide unambiguous non-trivial result.
811 RESULTP should point to NULL on the first (initialization) call. Caller is
812 responsible for xfree of any RESULTP data. */
815 chain_candidate (struct gdbarch
*gdbarch
, struct call_site_chain
**resultp
,
816 VEC (call_sitep
) *chain
)
818 struct call_site_chain
*result
= *resultp
;
819 long length
= VEC_length (call_sitep
, chain
);
820 int callers
, callees
, idx
;
824 /* Create the initial chain containing all the passed PCs. */
826 result
= xmalloc (sizeof (*result
) + sizeof (*result
->call_site
)
828 result
->length
= length
;
829 result
->callers
= result
->callees
= length
;
830 if (!VEC_empty (call_sitep
, chain
))
831 memcpy (result
->call_site
, VEC_address (call_sitep
, chain
),
832 sizeof (*result
->call_site
) * length
);
835 if (entry_values_debug
)
837 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
838 for (idx
= 0; idx
< length
; idx
++)
839 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
840 fputc_unfiltered ('\n', gdb_stdlog
);
846 if (entry_values_debug
)
848 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
849 for (idx
= 0; idx
< length
; idx
++)
850 tailcall_dump (gdbarch
, VEC_index (call_sitep
, chain
, idx
));
851 fputc_unfiltered ('\n', gdb_stdlog
);
854 /* Intersect callers. */
856 callers
= min (result
->callers
, length
);
857 for (idx
= 0; idx
< callers
; idx
++)
858 if (result
->call_site
[idx
] != VEC_index (call_sitep
, chain
, idx
))
860 result
->callers
= idx
;
864 /* Intersect callees. */
866 callees
= min (result
->callees
, length
);
867 for (idx
= 0; idx
< callees
; idx
++)
868 if (result
->call_site
[result
->length
- 1 - idx
]
869 != VEC_index (call_sitep
, chain
, length
- 1 - idx
))
871 result
->callees
= idx
;
875 if (entry_values_debug
)
877 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
878 for (idx
= 0; idx
< result
->callers
; idx
++)
879 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
880 fputs_unfiltered (" |", gdb_stdlog
);
881 for (idx
= 0; idx
< result
->callees
; idx
++)
882 tailcall_dump (gdbarch
, result
->call_site
[result
->length
883 - result
->callees
+ idx
]);
884 fputc_unfiltered ('\n', gdb_stdlog
);
887 if (result
->callers
== 0 && result
->callees
== 0)
889 /* There are no common callers or callees. It could be also a direct
890 call (which has length 0) with ambiguous possibility of an indirect
891 call - CALLERS == CALLEES == 0 is valid during the first allocation
892 but any subsequence processing of such entry means ambiguity. */
898 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
899 PC again. In such case there must be two different code paths to reach
900 it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
901 gdb_assert (result
->callers
+ result
->callees
<= result
->length
);
904 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
905 assumed frames between them use GDBARCH. Use depth first search so we can
906 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
907 would have needless GDB stack overhead. Caller is responsible for xfree of
908 the returned result. Any unreliability results in thrown
909 NO_ENTRY_VALUE_ERROR. */
911 static struct call_site_chain
*
912 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
915 CORE_ADDR save_callee_pc
= callee_pc
;
916 struct obstack addr_obstack
;
917 struct cleanup
*back_to_retval
, *back_to_workdata
;
918 struct call_site_chain
*retval
= NULL
;
919 struct call_site
*call_site
;
921 /* Mark CALL_SITEs so we do not visit the same ones twice. */
924 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
925 call_site nor any possible call_site at CALLEE_PC's function is there.
926 Any CALL_SITE in CHAIN will be iterated to its siblings - via
927 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
928 VEC (call_sitep
) *chain
= NULL
;
930 /* We are not interested in the specific PC inside the callee function. */
931 callee_pc
= get_pc_function_start (callee_pc
);
933 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
934 paddress (gdbarch
, save_callee_pc
));
936 back_to_retval
= make_cleanup (free_current_contents
, &retval
);
938 obstack_init (&addr_obstack
);
939 back_to_workdata
= make_cleanup_obstack_free (&addr_obstack
);
940 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
941 &addr_obstack
, hashtab_obstack_allocate
,
943 make_cleanup_htab_delete (addr_hash
);
945 make_cleanup (VEC_cleanup (call_sitep
), &chain
);
947 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
948 at the target's function. All the possible tail call sites in the
949 target's function will get iterated as already pushed into CHAIN via their
951 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
955 CORE_ADDR target_func_addr
;
956 struct call_site
*target_call_site
;
958 /* CALLER_FRAME with registers is not available for tail-call jumped
960 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
962 if (target_func_addr
== callee_pc
)
964 chain_candidate (gdbarch
, &retval
, chain
);
968 /* There is no way to reach CALLEE_PC again as we would prevent
969 entering it twice as being already marked in ADDR_HASH. */
970 target_call_site
= NULL
;
974 struct symbol
*target_func
;
976 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
977 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
982 /* Attempt to visit TARGET_CALL_SITE. */
984 if (target_call_site
)
988 slot
= htab_find_slot (addr_hash
, &target_call_site
->pc
, INSERT
);
991 /* Successfully entered TARGET_CALL_SITE. */
993 *slot
= &target_call_site
->pc
;
994 VEC_safe_push (call_sitep
, chain
, target_call_site
);
999 /* Backtrack (without revisiting the originating call_site). Try the
1000 callers's sibling; if there isn't any try the callers's callers's
1003 target_call_site
= NULL
;
1004 while (!VEC_empty (call_sitep
, chain
))
1006 call_site
= VEC_pop (call_sitep
, chain
);
1008 gdb_assert (htab_find_slot (addr_hash
, &call_site
->pc
,
1009 NO_INSERT
) != NULL
);
1010 htab_remove_elt (addr_hash
, &call_site
->pc
);
1012 target_call_site
= call_site
->tail_call_next
;
1013 if (target_call_site
)
1017 while (target_call_site
);
1019 if (VEC_empty (call_sitep
, chain
))
1022 call_site
= VEC_last (call_sitep
, chain
);
1027 struct bound_minimal_symbol msym_caller
, msym_callee
;
1029 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
1030 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
1031 throw_error (NO_ENTRY_VALUE_ERROR
,
1032 _("There are no unambiguously determinable intermediate "
1033 "callers or callees between caller function \"%s\" at %s "
1034 "and callee function \"%s\" at %s"),
1035 (msym_caller
.minsym
== NULL
1036 ? "???" : MSYMBOL_PRINT_NAME (msym_caller
.minsym
)),
1037 paddress (gdbarch
, caller_pc
),
1038 (msym_callee
.minsym
== NULL
1039 ? "???" : MSYMBOL_PRINT_NAME (msym_callee
.minsym
)),
1040 paddress (gdbarch
, callee_pc
));
1043 do_cleanups (back_to_workdata
);
1044 discard_cleanups (back_to_retval
);
1048 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1049 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
1050 constructed return NULL. Caller is responsible for xfree of the returned
1053 struct call_site_chain
*
1054 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1055 CORE_ADDR callee_pc
)
1057 struct call_site_chain
*retval
= NULL
;
1061 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
1063 CATCH (e
, RETURN_MASK_ERROR
)
1065 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
1067 if (entry_values_debug
)
1068 exception_print (gdb_stdout
, e
);
1073 throw_exception (e
);
1080 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1083 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1084 enum call_site_parameter_kind kind
,
1085 union call_site_parameter_u kind_u
)
1087 if (kind
== parameter
->kind
)
1090 case CALL_SITE_PARAMETER_DWARF_REG
:
1091 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1092 case CALL_SITE_PARAMETER_FB_OFFSET
:
1093 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1094 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1095 return kind_u
.param_offset
.cu_off
== parameter
->u
.param_offset
.cu_off
;
1100 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1101 FRAME is for callee.
1103 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1106 static struct call_site_parameter
*
1107 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1108 enum call_site_parameter_kind kind
,
1109 union call_site_parameter_u kind_u
,
1110 struct dwarf2_per_cu_data
**per_cu_return
)
1112 CORE_ADDR func_addr
, caller_pc
;
1113 struct gdbarch
*gdbarch
;
1114 struct frame_info
*caller_frame
;
1115 struct call_site
*call_site
;
1117 /* Initialize it just to avoid a GCC false warning. */
1118 struct call_site_parameter
*parameter
= NULL
;
1119 CORE_ADDR target_addr
;
1121 while (get_frame_type (frame
) == INLINE_FRAME
)
1123 frame
= get_prev_frame (frame
);
1124 gdb_assert (frame
!= NULL
);
1127 func_addr
= get_frame_func (frame
);
1128 gdbarch
= get_frame_arch (frame
);
1129 caller_frame
= get_prev_frame (frame
);
1130 if (gdbarch
!= frame_unwind_arch (frame
))
1132 struct bound_minimal_symbol msym
1133 = lookup_minimal_symbol_by_pc (func_addr
);
1134 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1136 throw_error (NO_ENTRY_VALUE_ERROR
,
1137 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1138 "(of %s (%s)) does not match caller gdbarch %s"),
1139 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1140 paddress (gdbarch
, func_addr
),
1141 (msym
.minsym
== NULL
? "???"
1142 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
1143 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1146 if (caller_frame
== NULL
)
1148 struct bound_minimal_symbol msym
1149 = lookup_minimal_symbol_by_pc (func_addr
);
1151 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_GNU_entry_value resolving "
1152 "requires caller of %s (%s)"),
1153 paddress (gdbarch
, func_addr
),
1154 (msym
.minsym
== NULL
? "???"
1155 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
1157 caller_pc
= get_frame_pc (caller_frame
);
1158 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1160 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1161 if (target_addr
!= func_addr
)
1163 struct minimal_symbol
*target_msym
, *func_msym
;
1165 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1166 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1167 throw_error (NO_ENTRY_VALUE_ERROR
,
1168 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1169 "but the called frame is for %s at %s"),
1170 (target_msym
== NULL
? "???"
1171 : MSYMBOL_PRINT_NAME (target_msym
)),
1172 paddress (gdbarch
, target_addr
),
1173 func_msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (func_msym
),
1174 paddress (gdbarch
, func_addr
));
1177 /* No entry value based parameters would be reliable if this function can
1178 call itself via tail calls. */
1179 func_verify_no_selftailcall (gdbarch
, func_addr
);
1181 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1183 parameter
= &call_site
->parameter
[iparams
];
1184 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1187 if (iparams
== call_site
->parameter_count
)
1189 struct minimal_symbol
*msym
1190 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1192 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1193 determine its value. */
1194 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1195 "at DW_TAG_GNU_call_site %s at %s"),
1196 paddress (gdbarch
, caller_pc
),
1197 msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (msym
));
1200 *per_cu_return
= call_site
->per_cu
;
1204 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1205 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1206 DW_AT_GNU_call_site_data_value (dereferenced) block.
1208 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1211 Function always returns non-NULL, non-optimized out value. It throws
1212 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1214 static struct value
*
1215 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1216 CORE_ADDR deref_size
, struct type
*type
,
1217 struct frame_info
*caller_frame
,
1218 struct dwarf2_per_cu_data
*per_cu
)
1220 const gdb_byte
*data_src
;
1224 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1225 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1227 /* DEREF_SIZE size is not verified here. */
1228 if (data_src
== NULL
)
1229 throw_error (NO_ENTRY_VALUE_ERROR
,
1230 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1232 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1233 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1235 data
= alloca (size
+ 1);
1236 memcpy (data
, data_src
, size
);
1237 data
[size
] = DW_OP_stack_value
;
1239 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1242 /* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
1243 Choose DEREF_SIZE value of that parameter. Search caller of the CTX's
1244 frame. CTX must be of dwarf_expr_ctx_funcs kind.
1246 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1247 can be more simple as it does not support cross-CU DWARF executions. */
1250 dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
1251 enum call_site_parameter_kind kind
,
1252 union call_site_parameter_u kind_u
,
1255 struct dwarf_expr_baton
*debaton
;
1256 struct frame_info
*frame
, *caller_frame
;
1257 struct dwarf2_per_cu_data
*caller_per_cu
;
1258 struct dwarf_expr_baton baton_local
;
1259 struct dwarf_expr_context saved_ctx
;
1260 struct call_site_parameter
*parameter
;
1261 const gdb_byte
*data_src
;
1264 gdb_assert (ctx
->funcs
== &dwarf_expr_ctx_funcs
);
1265 debaton
= ctx
->baton
;
1266 frame
= debaton
->frame
;
1267 caller_frame
= get_prev_frame (frame
);
1269 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1271 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1272 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1274 /* DEREF_SIZE size is not verified here. */
1275 if (data_src
== NULL
)
1276 throw_error (NO_ENTRY_VALUE_ERROR
,
1277 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1279 baton_local
.frame
= caller_frame
;
1280 baton_local
.per_cu
= caller_per_cu
;
1281 baton_local
.obj_address
= 0;
1283 saved_ctx
.gdbarch
= ctx
->gdbarch
;
1284 saved_ctx
.addr_size
= ctx
->addr_size
;
1285 saved_ctx
.offset
= ctx
->offset
;
1286 saved_ctx
.baton
= ctx
->baton
;
1287 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (baton_local
.per_cu
));
1288 ctx
->addr_size
= dwarf2_per_cu_addr_size (baton_local
.per_cu
);
1289 ctx
->offset
= dwarf2_per_cu_text_offset (baton_local
.per_cu
);
1290 ctx
->baton
= &baton_local
;
1292 dwarf_expr_eval (ctx
, data_src
, size
);
1294 ctx
->gdbarch
= saved_ctx
.gdbarch
;
1295 ctx
->addr_size
= saved_ctx
.addr_size
;
1296 ctx
->offset
= saved_ctx
.offset
;
1297 ctx
->baton
= saved_ctx
.baton
;
1300 /* Callback function for dwarf2_evaluate_loc_desc.
1301 Fetch the address indexed by DW_OP_GNU_addr_index. */
1304 dwarf_expr_get_addr_index (void *baton
, unsigned int index
)
1306 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
1308 return dwarf2_read_addr_index (debaton
->per_cu
, index
);
1311 /* Callback function for get_object_address. Return the address of the VLA
1315 dwarf_expr_get_obj_addr (void *baton
)
1317 struct dwarf_expr_baton
*debaton
= baton
;
1319 gdb_assert (debaton
!= NULL
);
1321 if (debaton
->obj_address
== 0)
1322 error (_("Location address is not set."));
1324 return debaton
->obj_address
;
1327 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1328 the indirect method on it, that is use its stored target value, the sole
1329 purpose of entry_data_value_funcs.. */
1331 static struct value
*
1332 entry_data_value_coerce_ref (const struct value
*value
)
1334 struct type
*checked_type
= check_typedef (value_type (value
));
1335 struct value
*target_val
;
1337 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
)
1340 target_val
= value_computed_closure (value
);
1341 value_incref (target_val
);
1345 /* Implement copy_closure. */
1348 entry_data_value_copy_closure (const struct value
*v
)
1350 struct value
*target_val
= value_computed_closure (v
);
1352 value_incref (target_val
);
1356 /* Implement free_closure. */
1359 entry_data_value_free_closure (struct value
*v
)
1361 struct value
*target_val
= value_computed_closure (v
);
1363 value_free (target_val
);
1366 /* Vector for methods for an entry value reference where the referenced value
1367 is stored in the caller. On the first dereference use
1368 DW_AT_GNU_call_site_data_value in the caller. */
1370 static const struct lval_funcs entry_data_value_funcs
=
1374 NULL
, /* indirect */
1375 entry_data_value_coerce_ref
,
1376 NULL
, /* check_synthetic_pointer */
1377 entry_data_value_copy_closure
,
1378 entry_data_value_free_closure
1381 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1382 are 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_reg_entry (struct type
*type
, struct frame_info
*frame
,
1390 enum call_site_parameter_kind kind
,
1391 union call_site_parameter_u kind_u
)
1393 struct type
*checked_type
= check_typedef (type
);
1394 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1395 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1396 struct value
*outer_val
, *target_val
, *val
;
1397 struct call_site_parameter
*parameter
;
1398 struct dwarf2_per_cu_data
*caller_per_cu
;
1400 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1403 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1407 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1408 used and it is not available do not fall back to OUTER_VAL - dereferencing
1409 TYPE_CODE_REF with non-entry data value would give current value - not the
1412 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
1413 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1416 target_val
= dwarf_entry_parameter_to_value (parameter
,
1417 TYPE_LENGTH (target_type
),
1418 target_type
, caller_frame
,
1421 release_value (target_val
);
1422 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1423 target_val
/* closure */);
1425 /* Copy the referencing pointer to the new computed value. */
1426 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1427 TYPE_LENGTH (checked_type
));
1428 set_value_lazy (val
, 0);
1433 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1434 SIZE are DWARF block used to match DW_AT_location at the caller's
1435 DW_TAG_GNU_call_site_parameter.
1437 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1438 cannot resolve the parameter for any reason. */
1440 static struct value
*
1441 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1442 const gdb_byte
*block
, size_t block_len
)
1444 union call_site_parameter_u kind_u
;
1446 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1447 if (kind_u
.dwarf_reg
!= -1)
1448 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1451 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1452 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1455 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1456 suppressed during normal operation. The expression can be arbitrary if
1457 there is no caller-callee entry value binding expected. */
1458 throw_error (NO_ENTRY_VALUE_ERROR
,
1459 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1460 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1463 struct piece_closure
1465 /* Reference count. */
1468 /* The CU from which this closure's expression came. */
1469 struct dwarf2_per_cu_data
*per_cu
;
1471 /* The number of pieces used to describe this variable. */
1474 /* The target address size, used only for DWARF_VALUE_STACK. */
1477 /* The pieces themselves. */
1478 struct dwarf_expr_piece
*pieces
;
1481 /* Allocate a closure for a value formed from separately-described
1484 static struct piece_closure
*
1485 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1486 int n_pieces
, struct dwarf_expr_piece
*pieces
,
1489 struct piece_closure
*c
= XCNEW (struct piece_closure
);
1494 c
->n_pieces
= n_pieces
;
1495 c
->addr_size
= addr_size
;
1496 c
->pieces
= XCNEWVEC (struct dwarf_expr_piece
, n_pieces
);
1498 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
1499 for (i
= 0; i
< n_pieces
; ++i
)
1500 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1501 value_incref (c
->pieces
[i
].v
.value
);
1506 /* The lowest-level function to extract bits from a byte buffer.
1507 SOURCE is the buffer. It is updated if we read to the end of a
1509 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1510 updated to reflect the number of bits actually read.
1511 NBITS is the number of bits we want to read. It is updated to
1512 reflect the number of bits actually read. This function may read
1514 BITS_BIG_ENDIAN is taken directly from gdbarch.
1515 This function returns the extracted bits. */
1518 extract_bits_primitive (const gdb_byte
**source
,
1519 unsigned int *source_offset_bits
,
1520 int *nbits
, int bits_big_endian
)
1522 unsigned int avail
, mask
, datum
;
1524 gdb_assert (*source_offset_bits
< 8);
1526 avail
= 8 - *source_offset_bits
;
1530 mask
= (1 << avail
) - 1;
1532 if (bits_big_endian
)
1533 datum
>>= 8 - (*source_offset_bits
+ *nbits
);
1535 datum
>>= *source_offset_bits
;
1539 *source_offset_bits
+= avail
;
1540 if (*source_offset_bits
>= 8)
1542 *source_offset_bits
-= 8;
1549 /* Extract some bits from a source buffer and move forward in the
1552 SOURCE is the source buffer. It is updated as bytes are read.
1553 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1555 NBITS is the number of bits to read.
1556 BITS_BIG_ENDIAN is taken directly from gdbarch.
1558 This function returns the bits that were read. */
1561 extract_bits (const gdb_byte
**source
, unsigned int *source_offset_bits
,
1562 int nbits
, int bits_big_endian
)
1566 gdb_assert (nbits
> 0 && nbits
<= 8);
1568 datum
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1574 more
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1576 if (bits_big_endian
)
1586 /* Write some bits into a buffer and move forward in the buffer.
1588 DATUM is the bits to write. The low-order bits of DATUM are used.
1589 DEST is the destination buffer. It is updated as bytes are
1591 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1593 NBITS is the number of valid bits in DATUM.
1594 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1597 insert_bits (unsigned int datum
,
1598 gdb_byte
*dest
, unsigned int dest_offset_bits
,
1599 int nbits
, int bits_big_endian
)
1603 gdb_assert (dest_offset_bits
+ nbits
<= 8);
1605 mask
= (1 << nbits
) - 1;
1606 if (bits_big_endian
)
1608 datum
<<= 8 - (dest_offset_bits
+ nbits
);
1609 mask
<<= 8 - (dest_offset_bits
+ nbits
);
1613 datum
<<= dest_offset_bits
;
1614 mask
<<= dest_offset_bits
;
1617 gdb_assert ((datum
& ~mask
) == 0);
1619 *dest
= (*dest
& ~mask
) | datum
;
1622 /* Copy bits from a source to a destination.
1624 DEST is where the bits should be written.
1625 DEST_OFFSET_BITS is the bit offset into DEST.
1626 SOURCE is the source of bits.
1627 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1628 BIT_COUNT is the number of bits to copy.
1629 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1632 copy_bitwise (gdb_byte
*dest
, unsigned int dest_offset_bits
,
1633 const gdb_byte
*source
, unsigned int source_offset_bits
,
1634 unsigned int bit_count
,
1635 int bits_big_endian
)
1637 unsigned int dest_avail
;
1640 /* Reduce everything to byte-size pieces. */
1641 dest
+= dest_offset_bits
/ 8;
1642 dest_offset_bits
%= 8;
1643 source
+= source_offset_bits
/ 8;
1644 source_offset_bits
%= 8;
1646 dest_avail
= 8 - dest_offset_bits
% 8;
1648 /* See if we can fill the first destination byte. */
1649 if (dest_avail
< bit_count
)
1651 datum
= extract_bits (&source
, &source_offset_bits
, dest_avail
,
1653 insert_bits (datum
, dest
, dest_offset_bits
, dest_avail
, bits_big_endian
);
1655 dest_offset_bits
= 0;
1656 bit_count
-= dest_avail
;
1659 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1660 than 8 bits remaining. */
1661 gdb_assert (dest_offset_bits
% 8 == 0 || bit_count
< 8);
1662 for (; bit_count
>= 8; bit_count
-= 8)
1664 datum
= extract_bits (&source
, &source_offset_bits
, 8, bits_big_endian
);
1665 *dest
++ = (gdb_byte
) datum
;
1668 /* Finally, we may have a few leftover bits. */
1669 gdb_assert (bit_count
<= 8 - dest_offset_bits
% 8);
1672 datum
= extract_bits (&source
, &source_offset_bits
, bit_count
,
1674 insert_bits (datum
, dest
, dest_offset_bits
, bit_count
, bits_big_endian
);
1679 read_pieced_value (struct value
*v
)
1683 ULONGEST bits_to_skip
;
1685 struct piece_closure
*c
1686 = (struct piece_closure
*) value_computed_closure (v
);
1687 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (v
));
1689 size_t buffer_size
= 0;
1690 gdb_byte
*buffer
= NULL
;
1691 struct cleanup
*cleanup
;
1693 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1695 if (value_type (v
) != value_enclosing_type (v
))
1696 internal_error (__FILE__
, __LINE__
,
1697 _("Should not be able to create a lazy value with "
1698 "an enclosing type"));
1700 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1702 contents
= value_contents_raw (v
);
1703 bits_to_skip
= 8 * value_offset (v
);
1704 if (value_bitsize (v
))
1706 bits_to_skip
+= value_bitpos (v
);
1707 type_len
= value_bitsize (v
);
1710 type_len
= 8 * TYPE_LENGTH (value_type (v
));
1712 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1714 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1715 size_t this_size
, this_size_bits
;
1716 long dest_offset_bits
, source_offset_bits
, source_offset
;
1717 const gdb_byte
*intermediate_buffer
;
1719 /* Compute size, source, and destination offsets for copying, in
1721 this_size_bits
= p
->size
;
1722 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1724 bits_to_skip
-= this_size_bits
;
1727 if (bits_to_skip
> 0)
1729 dest_offset_bits
= 0;
1730 source_offset_bits
= bits_to_skip
;
1731 this_size_bits
-= bits_to_skip
;
1736 dest_offset_bits
= offset
;
1737 source_offset_bits
= 0;
1739 if (this_size_bits
> type_len
- offset
)
1740 this_size_bits
= type_len
- offset
;
1742 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1743 source_offset
= source_offset_bits
/ 8;
1744 if (buffer_size
< this_size
)
1746 buffer_size
= this_size
;
1747 buffer
= xrealloc (buffer
, buffer_size
);
1749 intermediate_buffer
= buffer
;
1751 /* Copy from the source to DEST_BUFFER. */
1752 switch (p
->location
)
1754 case DWARF_VALUE_REGISTER
:
1756 struct gdbarch
*arch
= get_frame_arch (frame
);
1757 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1759 if (gdb_regnum
!= -1)
1762 int reg_offset
= source_offset
;
1764 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1765 && this_size
< register_size (arch
, gdb_regnum
))
1767 /* Big-endian, and we want less than full size. */
1768 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1769 /* We want the lower-order THIS_SIZE_BITS of the bytes
1770 we extract from the register. */
1771 source_offset_bits
+= 8 * this_size
- this_size_bits
;
1774 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1778 /* Just so garbage doesn't ever shine through. */
1779 memset (buffer
, 0, this_size
);
1782 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1784 mark_value_bits_unavailable (v
, offset
, this_size_bits
);
1789 error (_("Unable to access DWARF register number %s"),
1790 paddress (arch
, p
->v
.regno
));
1795 case DWARF_VALUE_MEMORY
:
1796 read_value_memory (v
, offset
,
1797 p
->v
.mem
.in_stack_memory
,
1798 p
->v
.mem
.addr
+ source_offset
,
1802 case DWARF_VALUE_STACK
:
1804 size_t n
= this_size
;
1806 if (n
> c
->addr_size
- source_offset
)
1807 n
= (c
->addr_size
>= source_offset
1808 ? c
->addr_size
- source_offset
1816 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
1818 intermediate_buffer
= val_bytes
+ source_offset
;
1823 case DWARF_VALUE_LITERAL
:
1825 size_t n
= this_size
;
1827 if (n
> p
->v
.literal
.length
- source_offset
)
1828 n
= (p
->v
.literal
.length
>= source_offset
1829 ? p
->v
.literal
.length
- source_offset
1832 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
1836 /* These bits show up as zeros -- but do not cause the value
1837 to be considered optimized-out. */
1838 case DWARF_VALUE_IMPLICIT_POINTER
:
1841 case DWARF_VALUE_OPTIMIZED_OUT
:
1842 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1846 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1849 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
1850 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1851 copy_bitwise (contents
, dest_offset_bits
,
1852 intermediate_buffer
, source_offset_bits
% 8,
1853 this_size_bits
, bits_big_endian
);
1855 offset
+= this_size_bits
;
1858 do_cleanups (cleanup
);
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
);
1870 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
1872 size_t buffer_size
= 0;
1873 gdb_byte
*buffer
= NULL
;
1874 struct cleanup
*cleanup
;
1876 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
1880 mark_value_bytes_optimized_out (to
, 0, TYPE_LENGTH (value_type (to
)));
1884 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1886 contents
= value_contents (from
);
1887 bits_to_skip
= 8 * value_offset (to
);
1888 if (value_bitsize (to
))
1890 bits_to_skip
+= value_bitpos (to
);
1891 type_len
= value_bitsize (to
);
1894 type_len
= 8 * TYPE_LENGTH (value_type (to
));
1896 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1898 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1899 size_t this_size_bits
, this_size
;
1900 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
1902 const gdb_byte
*source_buffer
;
1904 this_size_bits
= p
->size
;
1905 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1907 bits_to_skip
-= this_size_bits
;
1910 if (this_size_bits
> type_len
- offset
)
1911 this_size_bits
= type_len
- offset
;
1912 if (bits_to_skip
> 0)
1914 dest_offset_bits
= bits_to_skip
;
1915 source_offset_bits
= 0;
1916 this_size_bits
-= bits_to_skip
;
1921 dest_offset_bits
= 0;
1922 source_offset_bits
= offset
;
1925 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1926 source_offset
= source_offset_bits
/ 8;
1927 dest_offset
= dest_offset_bits
/ 8;
1928 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
1930 source_buffer
= contents
+ source_offset
;
1935 if (buffer_size
< this_size
)
1937 buffer_size
= this_size
;
1938 buffer
= xrealloc (buffer
, buffer_size
);
1940 source_buffer
= buffer
;
1944 switch (p
->location
)
1946 case DWARF_VALUE_REGISTER
:
1948 struct gdbarch
*arch
= get_frame_arch (frame
);
1949 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1951 if (gdb_regnum
!= -1)
1953 int reg_offset
= dest_offset
;
1955 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1956 && this_size
<= register_size (arch
, gdb_regnum
))
1958 /* Big-endian, and we want less than full size. */
1959 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1966 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1971 throw_error (OPTIMIZED_OUT_ERROR
,
1972 _("Can't do read-modify-write to "
1973 "update bitfield; containing word "
1974 "has been optimized out"));
1976 throw_error (NOT_AVAILABLE_ERROR
,
1977 _("Can't do read-modify-write to update "
1978 "bitfield; containing word "
1981 copy_bitwise (buffer
, dest_offset_bits
,
1982 contents
, source_offset_bits
,
1987 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1988 this_size
, source_buffer
);
1992 error (_("Unable to write to DWARF register number %s"),
1993 paddress (arch
, p
->v
.regno
));
1997 case DWARF_VALUE_MEMORY
:
2000 /* Only the first and last bytes can possibly have any
2002 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
, 1);
2003 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
2004 buffer
+ this_size
- 1, 1);
2005 copy_bitwise (buffer
, dest_offset_bits
,
2006 contents
, source_offset_bits
,
2011 write_memory (p
->v
.mem
.addr
+ dest_offset
,
2012 source_buffer
, this_size
);
2015 mark_value_bytes_optimized_out (to
, 0, TYPE_LENGTH (value_type (to
)));
2018 offset
+= this_size_bits
;
2021 do_cleanups (cleanup
);
2024 /* An implementation of an lval_funcs method to see whether a value is
2025 a synthetic pointer. */
2028 check_pieced_synthetic_pointer (const struct value
*value
, int bit_offset
,
2031 struct piece_closure
*c
2032 = (struct piece_closure
*) value_computed_closure (value
);
2035 bit_offset
+= 8 * value_offset (value
);
2036 if (value_bitsize (value
))
2037 bit_offset
+= value_bitpos (value
);
2039 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2041 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2042 size_t this_size_bits
= p
->size
;
2046 if (bit_offset
>= this_size_bits
)
2048 bit_offset
-= this_size_bits
;
2052 bit_length
-= this_size_bits
- bit_offset
;
2056 bit_length
-= this_size_bits
;
2058 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2065 /* A wrapper function for get_frame_address_in_block. */
2068 get_frame_address_in_block_wrapper (void *baton
)
2070 return get_frame_address_in_block (baton
);
2073 /* An implementation of an lval_funcs method to indirect through a
2074 pointer. This handles the synthetic pointer case when needed. */
2076 static struct value
*
2077 indirect_pieced_value (struct value
*value
)
2079 struct piece_closure
*c
2080 = (struct piece_closure
*) value_computed_closure (value
);
2082 struct frame_info
*frame
;
2083 struct dwarf2_locexpr_baton baton
;
2084 int i
, bit_offset
, bit_length
;
2085 struct dwarf_expr_piece
*piece
= NULL
;
2086 LONGEST byte_offset
;
2087 enum bfd_endian byte_order
;
2089 type
= check_typedef (value_type (value
));
2090 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
2093 bit_length
= 8 * TYPE_LENGTH (type
);
2094 bit_offset
= 8 * value_offset (value
);
2095 if (value_bitsize (value
))
2096 bit_offset
+= value_bitpos (value
);
2098 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2100 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2101 size_t this_size_bits
= p
->size
;
2105 if (bit_offset
>= this_size_bits
)
2107 bit_offset
-= this_size_bits
;
2111 bit_length
-= this_size_bits
- bit_offset
;
2115 bit_length
-= this_size_bits
;
2117 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2120 if (bit_length
!= 0)
2121 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2127 frame
= get_selected_frame (_("No frame selected."));
2129 /* This is an offset requested by GDB, such as value subscripts.
2130 However, due to how synthetic pointers are implemented, this is
2131 always presented to us as a pointer type. This means we have to
2132 sign-extend it manually as appropriate. Use raw
2133 extract_signed_integer directly rather than value_as_address and
2134 sign extend afterwards on architectures that would need it
2135 (mostly everywhere except MIPS, which has signed addresses) as
2136 the later would go through gdbarch_pointer_to_address and thus
2137 return a CORE_ADDR with high bits set on architectures that
2138 encode address spaces and other things in CORE_ADDR. */
2139 byte_order
= gdbarch_byte_order (get_frame_arch (frame
));
2140 byte_offset
= extract_signed_integer (value_contents (value
),
2141 TYPE_LENGTH (type
), byte_order
);
2142 byte_offset
+= piece
->v
.ptr
.offset
;
2146 = dwarf2_fetch_die_loc_sect_off (piece
->v
.ptr
.die
, c
->per_cu
,
2147 get_frame_address_in_block_wrapper
,
2150 if (baton
.data
!= NULL
)
2151 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
2152 baton
.data
, baton
.size
, baton
.per_cu
,
2156 struct obstack temp_obstack
;
2157 struct cleanup
*cleanup
;
2158 const gdb_byte
*bytes
;
2160 struct value
*result
;
2162 obstack_init (&temp_obstack
);
2163 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2165 bytes
= dwarf2_fetch_constant_bytes (piece
->v
.ptr
.die
, c
->per_cu
,
2166 &temp_obstack
, &len
);
2168 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
2172 || byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > len
)
2173 invalid_synthetic_pointer ();
2174 bytes
+= byte_offset
;
2175 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
2178 do_cleanups (cleanup
);
2184 copy_pieced_value_closure (const struct value
*v
)
2186 struct piece_closure
*c
2187 = (struct piece_closure
*) value_computed_closure (v
);
2194 free_pieced_value_closure (struct value
*v
)
2196 struct piece_closure
*c
2197 = (struct piece_closure
*) value_computed_closure (v
);
2204 for (i
= 0; i
< c
->n_pieces
; ++i
)
2205 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
2206 value_free (c
->pieces
[i
].v
.value
);
2213 /* Functions for accessing a variable described by DW_OP_piece. */
2214 static const struct lval_funcs pieced_value_funcs
= {
2217 indirect_pieced_value
,
2218 NULL
, /* coerce_ref */
2219 check_pieced_synthetic_pointer
,
2220 copy_pieced_value_closure
,
2221 free_pieced_value_closure
2224 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2226 const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
=
2228 dwarf_expr_read_addr_from_reg
,
2229 dwarf_expr_get_reg_value
,
2230 dwarf_expr_read_mem
,
2231 dwarf_expr_frame_base
,
2232 dwarf_expr_frame_cfa
,
2233 dwarf_expr_frame_pc
,
2234 dwarf_expr_tls_address
,
2235 dwarf_expr_dwarf_call
,
2236 dwarf_expr_get_base_type
,
2237 dwarf_expr_push_dwarf_reg_entry_value
,
2238 dwarf_expr_get_addr_index
,
2239 dwarf_expr_get_obj_addr
2242 /* Evaluate a location description, starting at DATA and with length
2243 SIZE, to find the current location of variable of TYPE in the
2244 context of FRAME. BYTE_OFFSET is applied after the contents are
2247 static struct value
*
2248 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2249 const gdb_byte
*data
, size_t size
,
2250 struct dwarf2_per_cu_data
*per_cu
,
2251 LONGEST byte_offset
)
2253 struct value
*retval
;
2254 struct dwarf_expr_baton baton
;
2255 struct dwarf_expr_context
*ctx
;
2256 struct cleanup
*old_chain
, *value_chain
;
2257 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2259 if (byte_offset
< 0)
2260 invalid_synthetic_pointer ();
2263 return allocate_optimized_out_value (type
);
2265 baton
.frame
= frame
;
2266 baton
.per_cu
= per_cu
;
2267 baton
.obj_address
= 0;
2269 ctx
= new_dwarf_expr_context ();
2270 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2271 value_chain
= make_cleanup_value_free_to_mark (value_mark ());
2273 ctx
->gdbarch
= get_objfile_arch (objfile
);
2274 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2275 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2276 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2277 ctx
->baton
= &baton
;
2278 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2282 dwarf_expr_eval (ctx
, data
, size
);
2284 CATCH (ex
, RETURN_MASK_ERROR
)
2286 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2288 do_cleanups (old_chain
);
2289 retval
= allocate_value (type
);
2290 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
2293 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2295 if (entry_values_debug
)
2296 exception_print (gdb_stdout
, ex
);
2297 do_cleanups (old_chain
);
2298 return allocate_optimized_out_value (type
);
2301 throw_exception (ex
);
2305 if (ctx
->num_pieces
> 0)
2307 struct piece_closure
*c
;
2308 struct frame_id frame_id
= get_frame_id (frame
);
2309 ULONGEST bit_size
= 0;
2312 for (i
= 0; i
< ctx
->num_pieces
; ++i
)
2313 bit_size
+= ctx
->pieces
[i
].size
;
2314 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
2315 invalid_synthetic_pointer ();
2317 c
= allocate_piece_closure (per_cu
, ctx
->num_pieces
, ctx
->pieces
,
2319 /* We must clean up the value chain after creating the piece
2320 closure but before allocating the result. */
2321 do_cleanups (value_chain
);
2322 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
2323 VALUE_FRAME_ID (retval
) = frame_id
;
2324 set_value_offset (retval
, byte_offset
);
2328 switch (ctx
->location
)
2330 case DWARF_VALUE_REGISTER
:
2332 struct gdbarch
*arch
= get_frame_arch (frame
);
2334 = longest_to_int (value_as_long (dwarf_expr_fetch (ctx
, 0)));
2335 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
2337 if (byte_offset
!= 0)
2338 error (_("cannot use offset on synthetic pointer to register"));
2339 do_cleanups (value_chain
);
2340 if (gdb_regnum
== -1)
2341 error (_("Unable to access DWARF register number %d"),
2343 retval
= value_from_register (type
, gdb_regnum
, frame
);
2344 if (value_optimized_out (retval
))
2348 /* This means the register has undefined value / was
2349 not saved. As we're computing the location of some
2350 variable etc. in the program, not a value for
2351 inspecting a register ($pc, $sp, etc.), return a
2352 generic optimized out value instead, so that we show
2353 <optimized out> instead of <not saved>. */
2354 do_cleanups (value_chain
);
2355 tmp
= allocate_value (type
);
2356 value_contents_copy (tmp
, 0, retval
, 0, TYPE_LENGTH (type
));
2362 case DWARF_VALUE_MEMORY
:
2364 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
2365 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
2367 do_cleanups (value_chain
);
2368 retval
= value_at_lazy (type
, address
+ byte_offset
);
2369 if (in_stack_memory
)
2370 set_value_stack (retval
, 1);
2374 case DWARF_VALUE_STACK
:
2376 struct value
*value
= dwarf_expr_fetch (ctx
, 0);
2378 const gdb_byte
*val_bytes
;
2379 size_t n
= TYPE_LENGTH (value_type (value
));
2381 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2382 invalid_synthetic_pointer ();
2384 val_bytes
= value_contents_all (value
);
2385 val_bytes
+= byte_offset
;
2388 /* Preserve VALUE because we are going to free values back
2389 to the mark, but we still need the value contents
2391 value_incref (value
);
2392 do_cleanups (value_chain
);
2393 make_cleanup_value_free (value
);
2395 retval
= allocate_value (type
);
2396 contents
= value_contents_raw (retval
);
2397 if (n
> TYPE_LENGTH (type
))
2399 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2401 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2402 val_bytes
+= n
- TYPE_LENGTH (type
);
2403 n
= TYPE_LENGTH (type
);
2405 memcpy (contents
, val_bytes
, n
);
2409 case DWARF_VALUE_LITERAL
:
2412 const bfd_byte
*ldata
;
2413 size_t n
= ctx
->len
;
2415 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2416 invalid_synthetic_pointer ();
2418 do_cleanups (value_chain
);
2419 retval
= allocate_value (type
);
2420 contents
= value_contents_raw (retval
);
2422 ldata
= ctx
->data
+ byte_offset
;
2425 if (n
> TYPE_LENGTH (type
))
2427 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2429 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2430 ldata
+= n
- TYPE_LENGTH (type
);
2431 n
= TYPE_LENGTH (type
);
2433 memcpy (contents
, ldata
, n
);
2437 case DWARF_VALUE_OPTIMIZED_OUT
:
2438 do_cleanups (value_chain
);
2439 retval
= allocate_optimized_out_value (type
);
2442 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2443 operation by execute_stack_op. */
2444 case DWARF_VALUE_IMPLICIT_POINTER
:
2445 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2446 it can only be encountered when making a piece. */
2448 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2452 set_value_initialized (retval
, ctx
->initialized
);
2454 do_cleanups (old_chain
);
2459 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2460 passes 0 as the byte_offset. */
2463 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2464 const gdb_byte
*data
, size_t size
,
2465 struct dwarf2_per_cu_data
*per_cu
)
2467 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
2470 /* Evaluates a dwarf expression and stores the result in VAL, expecting
2471 that the dwarf expression only produces a single CORE_ADDR. FRAME is the
2472 frame in which the expression is evaluated. ADDR is a context (location of
2473 a variable) and might be needed to evaluate the location expression.
2474 Returns 1 on success, 0 otherwise. */
2477 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton
*dlbaton
,
2478 struct frame_info
*frame
,
2482 struct dwarf_expr_context
*ctx
;
2483 struct dwarf_expr_baton baton
;
2484 struct objfile
*objfile
;
2485 struct cleanup
*cleanup
;
2487 if (dlbaton
== NULL
|| dlbaton
->size
== 0)
2490 ctx
= new_dwarf_expr_context ();
2491 cleanup
= make_cleanup_free_dwarf_expr_context (ctx
);
2493 baton
.frame
= frame
;
2494 baton
.per_cu
= dlbaton
->per_cu
;
2495 baton
.obj_address
= addr
;
2497 objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2499 ctx
->gdbarch
= get_objfile_arch (objfile
);
2500 ctx
->addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2501 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (dlbaton
->per_cu
);
2502 ctx
->offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
2503 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2504 ctx
->baton
= &baton
;
2506 dwarf_expr_eval (ctx
, dlbaton
->data
, dlbaton
->size
);
2508 switch (ctx
->location
)
2510 case DWARF_VALUE_REGISTER
:
2511 case DWARF_VALUE_MEMORY
:
2512 case DWARF_VALUE_STACK
:
2513 *valp
= dwarf_expr_fetch_address (ctx
, 0);
2514 if (ctx
->location
== DWARF_VALUE_REGISTER
)
2515 *valp
= dwarf_expr_read_addr_from_reg (&baton
, *valp
);
2516 do_cleanups (cleanup
);
2518 case DWARF_VALUE_LITERAL
:
2519 *valp
= extract_signed_integer (ctx
->data
, ctx
->len
,
2520 gdbarch_byte_order (ctx
->gdbarch
));
2521 do_cleanups (cleanup
);
2523 /* Unsupported dwarf values. */
2524 case DWARF_VALUE_OPTIMIZED_OUT
:
2525 case DWARF_VALUE_IMPLICIT_POINTER
:
2529 do_cleanups (cleanup
);
2533 /* See dwarf2loc.h. */
2536 dwarf2_evaluate_property (const struct dynamic_prop
*prop
,
2537 struct frame_info
*frame
,
2538 struct property_addr_info
*addr_stack
,
2544 if (frame
== NULL
&& has_stack_frames ())
2545 frame
= get_selected_frame (NULL
);
2551 const struct dwarf2_property_baton
*baton
= prop
->data
.baton
;
2553 if (dwarf2_locexpr_baton_eval (&baton
->locexpr
, frame
,
2554 addr_stack
? addr_stack
->addr
: 0,
2557 if (baton
->referenced_type
)
2559 struct value
*val
= value_at (baton
->referenced_type
, *value
);
2561 *value
= value_as_address (val
);
2570 struct dwarf2_property_baton
*baton
= prop
->data
.baton
;
2571 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2572 const gdb_byte
*data
;
2576 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2579 val
= dwarf2_evaluate_loc_desc (baton
->referenced_type
, frame
, data
,
2580 size
, baton
->loclist
.per_cu
);
2581 if (!value_optimized_out (val
))
2583 *value
= value_as_address (val
);
2591 *value
= prop
->data
.const_val
;
2594 case PROP_ADDR_OFFSET
:
2596 struct dwarf2_property_baton
*baton
= prop
->data
.baton
;
2597 struct property_addr_info
*pinfo
;
2600 for (pinfo
= addr_stack
; pinfo
!= NULL
; pinfo
= pinfo
->next
)
2601 if (pinfo
->type
== baton
->referenced_type
)
2604 error (_("cannot find reference address for offset property"));
2605 if (pinfo
->valaddr
!= NULL
)
2606 val
= value_from_contents
2607 (baton
->offset_info
.type
,
2608 pinfo
->valaddr
+ baton
->offset_info
.offset
);
2610 val
= value_at (baton
->offset_info
.type
,
2611 pinfo
->addr
+ baton
->offset_info
.offset
);
2612 *value
= value_as_address (val
);
2620 /* See dwarf2loc.h. */
2623 dwarf2_compile_property_to_c (struct ui_file
*stream
,
2624 const char *result_name
,
2625 struct gdbarch
*gdbarch
,
2626 unsigned char *registers_used
,
2627 const struct dynamic_prop
*prop
,
2631 struct dwarf2_property_baton
*baton
= prop
->data
.baton
;
2632 const gdb_byte
*data
;
2634 struct dwarf2_per_cu_data
*per_cu
;
2636 if (prop
->kind
== PROP_LOCEXPR
)
2638 data
= baton
->locexpr
.data
;
2639 size
= baton
->locexpr
.size
;
2640 per_cu
= baton
->locexpr
.per_cu
;
2644 gdb_assert (prop
->kind
== PROP_LOCLIST
);
2646 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2647 per_cu
= baton
->loclist
.per_cu
;
2650 compile_dwarf_bounds_to_c (stream
, result_name
, prop
, sym
, pc
,
2651 gdbarch
, registers_used
,
2652 dwarf2_per_cu_addr_size (per_cu
),
2653 data
, data
+ size
, per_cu
);
2657 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2659 struct needs_frame_baton
2662 struct dwarf2_per_cu_data
*per_cu
;
2665 /* Reads from registers do require a frame. */
2667 needs_frame_read_addr_from_reg (void *baton
, int regnum
)
2669 struct needs_frame_baton
*nf_baton
= baton
;
2671 nf_baton
->needs_frame
= 1;
2675 /* struct dwarf_expr_context_funcs' "get_reg_value" callback:
2676 Reads from registers do require a frame. */
2678 static struct value
*
2679 needs_frame_get_reg_value (void *baton
, struct type
*type
, int regnum
)
2681 struct needs_frame_baton
*nf_baton
= baton
;
2683 nf_baton
->needs_frame
= 1;
2684 return value_zero (type
, not_lval
);
2687 /* Reads from memory do not require a frame. */
2689 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
2691 memset (buf
, 0, len
);
2694 /* Frame-relative accesses do require a frame. */
2696 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
2698 static gdb_byte lit0
= DW_OP_lit0
;
2699 struct needs_frame_baton
*nf_baton
= baton
;
2704 nf_baton
->needs_frame
= 1;
2707 /* CFA accesses require a frame. */
2710 needs_frame_frame_cfa (void *baton
)
2712 struct needs_frame_baton
*nf_baton
= baton
;
2714 nf_baton
->needs_frame
= 1;
2718 /* Thread-local accesses do require a frame. */
2720 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
2722 struct needs_frame_baton
*nf_baton
= baton
;
2724 nf_baton
->needs_frame
= 1;
2728 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2731 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
2733 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2735 per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
,
2736 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
2739 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2742 needs_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
2743 enum call_site_parameter_kind kind
,
2744 union call_site_parameter_u kind_u
, int deref_size
)
2746 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2748 nf_baton
->needs_frame
= 1;
2750 /* The expression may require some stub values on DWARF stack. */
2751 dwarf_expr_push_address (ctx
, 0, 0);
2754 /* DW_OP_GNU_addr_index doesn't require a frame. */
2757 needs_get_addr_index (void *baton
, unsigned int index
)
2759 /* Nothing to do. */
2763 /* DW_OP_push_object_address has a frame already passed through. */
2766 needs_get_obj_addr (void *baton
)
2768 /* Nothing to do. */
2772 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2774 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs
=
2776 needs_frame_read_addr_from_reg
,
2777 needs_frame_get_reg_value
,
2778 needs_frame_read_mem
,
2779 needs_frame_frame_base
,
2780 needs_frame_frame_cfa
,
2781 needs_frame_frame_cfa
, /* get_frame_pc */
2782 needs_frame_tls_address
,
2783 needs_frame_dwarf_call
,
2784 NULL
, /* get_base_type */
2785 needs_dwarf_reg_entry_value
,
2786 needs_get_addr_index
,
2790 /* Return non-zero iff the location expression at DATA (length SIZE)
2791 requires a frame to evaluate. */
2794 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, size_t size
,
2795 struct dwarf2_per_cu_data
*per_cu
)
2797 struct needs_frame_baton baton
;
2798 struct dwarf_expr_context
*ctx
;
2800 struct cleanup
*old_chain
;
2801 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2803 baton
.needs_frame
= 0;
2804 baton
.per_cu
= per_cu
;
2806 ctx
= new_dwarf_expr_context ();
2807 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2808 make_cleanup_value_free_to_mark (value_mark ());
2810 ctx
->gdbarch
= get_objfile_arch (objfile
);
2811 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2812 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2813 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2814 ctx
->baton
= &baton
;
2815 ctx
->funcs
= &needs_frame_ctx_funcs
;
2817 dwarf_expr_eval (ctx
, data
, size
);
2819 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
2821 if (ctx
->num_pieces
> 0)
2825 /* If the location has several pieces, and any of them are in
2826 registers, then we will need a frame to fetch them from. */
2827 for (i
= 0; i
< ctx
->num_pieces
; i
++)
2828 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2832 do_cleanups (old_chain
);
2834 return baton
.needs_frame
|| in_reg
;
2837 /* A helper function that throws an unimplemented error mentioning a
2838 given DWARF operator. */
2841 unimplemented (unsigned int op
)
2843 const char *name
= get_DW_OP_name (op
);
2846 error (_("DWARF operator %s cannot be translated to an agent expression"),
2849 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2850 "to an agent expression"),
2854 /* See dwarf2loc.h. */
2857 dwarf2_reg_to_regnum_or_error (struct gdbarch
*arch
, int dwarf_reg
)
2859 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2861 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
2865 /* A helper function that emits an access to memory. ARCH is the
2866 target architecture. EXPR is the expression which we are building.
2867 NBITS is the number of bits we want to read. This emits the
2868 opcodes needed to read the memory and then extract the desired
2872 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2874 ULONGEST nbytes
= (nbits
+ 7) / 8;
2876 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2879 ax_trace_quick (expr
, nbytes
);
2882 ax_simple (expr
, aop_ref8
);
2883 else if (nbits
<= 16)
2884 ax_simple (expr
, aop_ref16
);
2885 else if (nbits
<= 32)
2886 ax_simple (expr
, aop_ref32
);
2888 ax_simple (expr
, aop_ref64
);
2890 /* If we read exactly the number of bytes we wanted, we're done. */
2891 if (8 * nbytes
== nbits
)
2894 if (gdbarch_bits_big_endian (arch
))
2896 /* On a bits-big-endian machine, we want the high-order
2898 ax_const_l (expr
, 8 * nbytes
- nbits
);
2899 ax_simple (expr
, aop_rsh_unsigned
);
2903 /* On a bits-little-endian box, we want the low-order NBITS. */
2904 ax_zero_ext (expr
, nbits
);
2908 /* A helper function to return the frame's PC. */
2911 get_ax_pc (void *baton
)
2913 struct agent_expr
*expr
= baton
;
2918 /* Compile a DWARF location expression to an agent expression.
2920 EXPR is the agent expression we are building.
2921 LOC is the agent value we modify.
2922 ARCH is the architecture.
2923 ADDR_SIZE is the size of addresses, in bytes.
2924 OP_PTR is the start of the location expression.
2925 OP_END is one past the last byte of the location expression.
2927 This will throw an exception for various kinds of errors -- for
2928 example, if the expression cannot be compiled, or if the expression
2932 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2933 struct gdbarch
*arch
, unsigned int addr_size
,
2934 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
2935 struct dwarf2_per_cu_data
*per_cu
)
2937 struct cleanup
*cleanups
;
2939 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
2940 const gdb_byte
* const base
= op_ptr
;
2941 const gdb_byte
*previous_piece
= op_ptr
;
2942 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2943 ULONGEST bits_collected
= 0;
2944 unsigned int addr_size_bits
= 8 * addr_size
;
2945 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
2947 offsets
= XNEWVEC (int, op_end
- op_ptr
);
2948 cleanups
= make_cleanup (xfree
, offsets
);
2950 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
2953 make_cleanup (VEC_cleanup (int), &dw_labels
);
2954 make_cleanup (VEC_cleanup (int), &patches
);
2956 /* By default we are making an address. */
2957 loc
->kind
= axs_lvalue_memory
;
2959 while (op_ptr
< op_end
)
2961 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
2962 uint64_t uoffset
, reg
;
2966 offsets
[op_ptr
- base
] = expr
->len
;
2969 /* Our basic approach to code generation is to map DWARF
2970 operations directly to AX operations. However, there are
2973 First, DWARF works on address-sized units, but AX always uses
2974 LONGEST. For most operations we simply ignore this
2975 difference; instead we generate sign extensions as needed
2976 before division and comparison operations. It would be nice
2977 to omit the sign extensions, but there is no way to determine
2978 the size of the target's LONGEST. (This code uses the size
2979 of the host LONGEST in some cases -- that is a bug but it is
2982 Second, some DWARF operations cannot be translated to AX.
2983 For these we simply fail. See
2984 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
3019 ax_const_l (expr
, op
- DW_OP_lit0
);
3023 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
3024 op_ptr
+= addr_size
;
3025 /* Some versions of GCC emit DW_OP_addr before
3026 DW_OP_GNU_push_tls_address. In this case the value is an
3027 index, not an address. We don't support things like
3028 branching between the address and the TLS op. */
3029 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
3030 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
3031 ax_const_l (expr
, uoffset
);
3035 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
3039 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
3043 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
3047 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
3051 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
3055 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
3059 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
3063 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
3067 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3068 ax_const_l (expr
, uoffset
);
3071 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3072 ax_const_l (expr
, offset
);
3107 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3108 loc
->u
.reg
= dwarf2_reg_to_regnum_or_error (arch
, op
- DW_OP_reg0
);
3109 loc
->kind
= axs_lvalue_register
;
3113 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3114 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3115 loc
->u
.reg
= dwarf2_reg_to_regnum_or_error (arch
, reg
);
3116 loc
->kind
= axs_lvalue_register
;
3119 case DW_OP_implicit_value
:
3123 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
3124 if (op_ptr
+ len
> op_end
)
3125 error (_("DW_OP_implicit_value: too few bytes available."));
3126 if (len
> sizeof (ULONGEST
))
3127 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
3130 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
3133 dwarf_expr_require_composition (op_ptr
, op_end
,
3134 "DW_OP_implicit_value");
3136 loc
->kind
= axs_rvalue
;
3140 case DW_OP_stack_value
:
3141 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
3142 loc
->kind
= axs_rvalue
;
3177 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3178 i
= dwarf2_reg_to_regnum_or_error (arch
, op
- DW_OP_breg0
);
3182 ax_const_l (expr
, offset
);
3183 ax_simple (expr
, aop_add
);
3188 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3189 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3190 i
= dwarf2_reg_to_regnum_or_error (arch
, reg
);
3194 ax_const_l (expr
, offset
);
3195 ax_simple (expr
, aop_add
);
3201 const gdb_byte
*datastart
;
3203 const struct block
*b
;
3204 struct symbol
*framefunc
;
3206 b
= block_for_pc (expr
->scope
);
3209 error (_("No block found for address"));
3211 framefunc
= block_linkage_function (b
);
3214 error (_("No function found for block"));
3216 func_get_frame_base_dwarf_block (framefunc
, expr
->scope
,
3217 &datastart
, &datalen
);
3219 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3220 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
3221 datastart
+ datalen
, per_cu
);
3222 if (loc
->kind
== axs_lvalue_register
)
3223 require_rvalue (expr
, loc
);
3227 ax_const_l (expr
, offset
);
3228 ax_simple (expr
, aop_add
);
3231 loc
->kind
= axs_lvalue_memory
;
3236 ax_simple (expr
, aop_dup
);
3240 ax_simple (expr
, aop_pop
);
3245 ax_pick (expr
, offset
);
3249 ax_simple (expr
, aop_swap
);
3257 ax_simple (expr
, aop_rot
);
3261 case DW_OP_deref_size
:
3265 if (op
== DW_OP_deref_size
)
3270 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3271 error (_("Unsupported size %d in %s"),
3272 size
, get_DW_OP_name (op
));
3273 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3278 /* Sign extend the operand. */
3279 ax_ext (expr
, addr_size_bits
);
3280 ax_simple (expr
, aop_dup
);
3281 ax_const_l (expr
, 0);
3282 ax_simple (expr
, aop_less_signed
);
3283 ax_simple (expr
, aop_log_not
);
3284 i
= ax_goto (expr
, aop_if_goto
);
3285 /* We have to emit 0 - X. */
3286 ax_const_l (expr
, 0);
3287 ax_simple (expr
, aop_swap
);
3288 ax_simple (expr
, aop_sub
);
3289 ax_label (expr
, i
, expr
->len
);
3293 /* No need to sign extend here. */
3294 ax_const_l (expr
, 0);
3295 ax_simple (expr
, aop_swap
);
3296 ax_simple (expr
, aop_sub
);
3300 /* Sign extend the operand. */
3301 ax_ext (expr
, addr_size_bits
);
3302 ax_simple (expr
, aop_bit_not
);
3305 case DW_OP_plus_uconst
:
3306 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3307 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3308 but we micro-optimize anyhow. */
3311 ax_const_l (expr
, reg
);
3312 ax_simple (expr
, aop_add
);
3317 ax_simple (expr
, aop_bit_and
);
3321 /* Sign extend the operands. */
3322 ax_ext (expr
, addr_size_bits
);
3323 ax_simple (expr
, aop_swap
);
3324 ax_ext (expr
, addr_size_bits
);
3325 ax_simple (expr
, aop_swap
);
3326 ax_simple (expr
, aop_div_signed
);
3330 ax_simple (expr
, aop_sub
);
3334 ax_simple (expr
, aop_rem_unsigned
);
3338 ax_simple (expr
, aop_mul
);
3342 ax_simple (expr
, aop_bit_or
);
3346 ax_simple (expr
, aop_add
);
3350 ax_simple (expr
, aop_lsh
);
3354 ax_simple (expr
, aop_rsh_unsigned
);
3358 ax_simple (expr
, aop_rsh_signed
);
3362 ax_simple (expr
, aop_bit_xor
);
3366 /* Sign extend the operands. */
3367 ax_ext (expr
, addr_size_bits
);
3368 ax_simple (expr
, aop_swap
);
3369 ax_ext (expr
, addr_size_bits
);
3370 /* Note no swap here: A <= B is !(B < A). */
3371 ax_simple (expr
, aop_less_signed
);
3372 ax_simple (expr
, aop_log_not
);
3376 /* Sign extend the operands. */
3377 ax_ext (expr
, addr_size_bits
);
3378 ax_simple (expr
, aop_swap
);
3379 ax_ext (expr
, addr_size_bits
);
3380 ax_simple (expr
, aop_swap
);
3381 /* A >= B is !(A < B). */
3382 ax_simple (expr
, aop_less_signed
);
3383 ax_simple (expr
, aop_log_not
);
3387 /* Sign extend the operands. */
3388 ax_ext (expr
, addr_size_bits
);
3389 ax_simple (expr
, aop_swap
);
3390 ax_ext (expr
, addr_size_bits
);
3391 /* No need for a second swap here. */
3392 ax_simple (expr
, aop_equal
);
3396 /* Sign extend the operands. */
3397 ax_ext (expr
, addr_size_bits
);
3398 ax_simple (expr
, aop_swap
);
3399 ax_ext (expr
, addr_size_bits
);
3400 ax_simple (expr
, aop_swap
);
3401 ax_simple (expr
, aop_less_signed
);
3405 /* Sign extend the operands. */
3406 ax_ext (expr
, addr_size_bits
);
3407 ax_simple (expr
, aop_swap
);
3408 ax_ext (expr
, addr_size_bits
);
3409 /* Note no swap here: A > B is B < A. */
3410 ax_simple (expr
, aop_less_signed
);
3414 /* Sign extend the operands. */
3415 ax_ext (expr
, addr_size_bits
);
3416 ax_simple (expr
, aop_swap
);
3417 ax_ext (expr
, addr_size_bits
);
3418 /* No need for a swap here. */
3419 ax_simple (expr
, aop_equal
);
3420 ax_simple (expr
, aop_log_not
);
3423 case DW_OP_call_frame_cfa
:
3426 CORE_ADDR text_offset
;
3428 const gdb_byte
*cfa_start
, *cfa_end
;
3430 if (dwarf2_fetch_cfa_info (arch
, expr
->scope
, per_cu
,
3432 &text_offset
, &cfa_start
, &cfa_end
))
3435 ax_reg (expr
, regnum
);
3438 ax_const_l (expr
, off
);
3439 ax_simple (expr
, aop_add
);
3444 /* Another expression. */
3445 ax_const_l (expr
, text_offset
);
3446 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3447 cfa_start
, cfa_end
, per_cu
);
3450 loc
->kind
= axs_lvalue_memory
;
3454 case DW_OP_GNU_push_tls_address
:
3458 case DW_OP_push_object_address
:
3463 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3465 i
= ax_goto (expr
, aop_goto
);
3466 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3467 VEC_safe_push (int, patches
, i
);
3471 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3473 /* Zero extend the operand. */
3474 ax_zero_ext (expr
, addr_size_bits
);
3475 i
= ax_goto (expr
, aop_if_goto
);
3476 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3477 VEC_safe_push (int, patches
, i
);
3484 case DW_OP_bit_piece
:
3486 uint64_t size
, offset
;
3488 if (op_ptr
- 1 == previous_piece
)
3489 error (_("Cannot translate empty pieces to agent expressions"));
3490 previous_piece
= op_ptr
- 1;
3492 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3493 if (op
== DW_OP_piece
)
3499 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
3501 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3502 error (_("Expression pieces exceed word size"));
3504 /* Access the bits. */
3507 case axs_lvalue_register
:
3508 ax_reg (expr
, loc
->u
.reg
);
3511 case axs_lvalue_memory
:
3512 /* Offset the pointer, if needed. */
3515 ax_const_l (expr
, offset
/ 8);
3516 ax_simple (expr
, aop_add
);
3519 access_memory (arch
, expr
, size
);
3523 /* For a bits-big-endian target, shift up what we already
3524 have. For a bits-little-endian target, shift up the
3525 new data. Note that there is a potential bug here if
3526 the DWARF expression leaves multiple values on the
3528 if (bits_collected
> 0)
3530 if (bits_big_endian
)
3532 ax_simple (expr
, aop_swap
);
3533 ax_const_l (expr
, size
);
3534 ax_simple (expr
, aop_lsh
);
3535 /* We don't need a second swap here, because
3536 aop_bit_or is symmetric. */
3540 ax_const_l (expr
, size
);
3541 ax_simple (expr
, aop_lsh
);
3543 ax_simple (expr
, aop_bit_or
);
3546 bits_collected
+= size
;
3547 loc
->kind
= axs_rvalue
;
3551 case DW_OP_GNU_uninit
:
3557 struct dwarf2_locexpr_baton block
;
3558 int size
= (op
== DW_OP_call2
? 2 : 4);
3561 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3564 offset
.cu_off
= uoffset
;
3565 block
= dwarf2_fetch_die_loc_cu_off (offset
, per_cu
,
3568 /* DW_OP_call_ref is currently not supported. */
3569 gdb_assert (block
.per_cu
== per_cu
);
3571 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3572 block
.data
, block
.data
+ block
.size
,
3577 case DW_OP_call_ref
:
3585 /* Patch all the branches we emitted. */
3586 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
3588 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
3590 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3591 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
3594 do_cleanups (cleanups
);
3598 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3599 evaluator to calculate the location. */
3600 static struct value
*
3601 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3603 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3606 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3607 dlbaton
->size
, dlbaton
->per_cu
);
3612 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3613 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3616 static struct value
*
3617 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3619 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3621 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3625 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3627 locexpr_read_needs_frame (struct symbol
*symbol
)
3629 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3631 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
3635 /* Return true if DATA points to the end of a piece. END is one past
3636 the last byte in the expression. */
3639 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3641 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3644 /* Helper for locexpr_describe_location_piece that finds the name of a
3648 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3652 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
3653 return gdbarch_register_name (gdbarch
, regnum
);
3656 /* Nicely describe a single piece of a location, returning an updated
3657 position in the bytecode sequence. This function cannot recognize
3658 all locations; if a location is not recognized, it simply returns
3659 DATA. If there is an error during reading, e.g. we run off the end
3660 of the buffer, an error is thrown. */
3662 static const gdb_byte
*
3663 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3664 CORE_ADDR addr
, struct objfile
*objfile
,
3665 struct dwarf2_per_cu_data
*per_cu
,
3666 const gdb_byte
*data
, const gdb_byte
*end
,
3667 unsigned int addr_size
)
3669 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3672 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3674 fprintf_filtered (stream
, _("a variable in $%s"),
3675 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3678 else if (data
[0] == DW_OP_regx
)
3682 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3683 fprintf_filtered (stream
, _("a variable in $%s"),
3684 locexpr_regname (gdbarch
, reg
));
3686 else if (data
[0] == DW_OP_fbreg
)
3688 const struct block
*b
;
3689 struct symbol
*framefunc
;
3691 int64_t frame_offset
;
3692 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3694 int64_t base_offset
= 0;
3696 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3697 if (!piece_end_p (new_data
, end
))
3701 b
= block_for_pc (addr
);
3704 error (_("No block found for address for symbol \"%s\"."),
3705 SYMBOL_PRINT_NAME (symbol
));
3707 framefunc
= block_linkage_function (b
);
3710 error (_("No function found for block for symbol \"%s\"."),
3711 SYMBOL_PRINT_NAME (symbol
));
3713 func_get_frame_base_dwarf_block (framefunc
, addr
, &base_data
, &base_size
);
3715 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3717 const gdb_byte
*buf_end
;
3719 frame_reg
= base_data
[0] - DW_OP_breg0
;
3720 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3722 if (buf_end
!= base_data
+ base_size
)
3723 error (_("Unexpected opcode after "
3724 "DW_OP_breg%u for symbol \"%s\"."),
3725 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3727 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3729 /* The frame base is just the register, with no offset. */
3730 frame_reg
= base_data
[0] - DW_OP_reg0
;
3735 /* We don't know what to do with the frame base expression,
3736 so we can't trace this variable; give up. */
3740 fprintf_filtered (stream
,
3741 _("a variable at frame base reg $%s offset %s+%s"),
3742 locexpr_regname (gdbarch
, frame_reg
),
3743 plongest (base_offset
), plongest (frame_offset
));
3745 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3746 && piece_end_p (data
, end
))
3750 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3752 fprintf_filtered (stream
,
3753 _("a variable at offset %s from base reg $%s"),
3755 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3758 /* The location expression for a TLS variable looks like this (on a
3761 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3762 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3764 0x3 is the encoding for DW_OP_addr, which has an operand as long
3765 as the size of an address on the target machine (here is 8
3766 bytes). Note that more recent version of GCC emit DW_OP_const4u
3767 or DW_OP_const8u, depending on address size, rather than
3768 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3769 The operand represents the offset at which the variable is within
3770 the thread local storage. */
3772 else if (data
+ 1 + addr_size
< end
3773 && (data
[0] == DW_OP_addr
3774 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3775 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3776 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3777 && piece_end_p (data
+ 2 + addr_size
, end
))
3780 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3781 gdbarch_byte_order (gdbarch
));
3783 fprintf_filtered (stream
,
3784 _("a thread-local variable at offset 0x%s "
3785 "in the thread-local storage for `%s'"),
3786 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3788 data
+= 1 + addr_size
+ 1;
3791 /* With -gsplit-dwarf a TLS variable can also look like this:
3792 DW_AT_location : 3 byte block: fc 4 e0
3793 (DW_OP_GNU_const_index: 4;
3794 DW_OP_GNU_push_tls_address) */
3795 else if (data
+ 3 <= end
3796 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3797 && data
[0] == DW_OP_GNU_const_index
3799 && data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3800 && piece_end_p (data
+ 2 + leb128_size
, end
))
3804 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3805 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3806 fprintf_filtered (stream
,
3807 _("a thread-local variable at offset 0x%s "
3808 "in the thread-local storage for `%s'"),
3809 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3813 else if (data
[0] >= DW_OP_lit0
3814 && data
[0] <= DW_OP_lit31
3816 && data
[1] == DW_OP_stack_value
)
3818 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3825 /* Disassemble an expression, stopping at the end of a piece or at the
3826 end of the expression. Returns a pointer to the next unread byte
3827 in the input expression. If ALL is nonzero, then this function
3828 will keep going until it reaches the end of the expression.
3829 If there is an error during reading, e.g. we run off the end
3830 of the buffer, an error is thrown. */
3832 static const gdb_byte
*
3833 disassemble_dwarf_expression (struct ui_file
*stream
,
3834 struct gdbarch
*arch
, unsigned int addr_size
,
3835 int offset_size
, const gdb_byte
*start
,
3836 const gdb_byte
*data
, const gdb_byte
*end
,
3837 int indent
, int all
,
3838 struct dwarf2_per_cu_data
*per_cu
)
3842 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3844 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *data
++;
3849 name
= get_DW_OP_name (op
);
3852 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3853 op
, (long) (data
- 1 - start
));
3854 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3855 (long) (data
- 1 - start
), name
);
3860 ul
= extract_unsigned_integer (data
, addr_size
,
3861 gdbarch_byte_order (arch
));
3863 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3867 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3869 fprintf_filtered (stream
, " %s", pulongest (ul
));
3872 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3874 fprintf_filtered (stream
, " %s", plongest (l
));
3877 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3879 fprintf_filtered (stream
, " %s", pulongest (ul
));
3882 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3884 fprintf_filtered (stream
, " %s", plongest (l
));
3887 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3889 fprintf_filtered (stream
, " %s", pulongest (ul
));
3892 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3894 fprintf_filtered (stream
, " %s", plongest (l
));
3897 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3899 fprintf_filtered (stream
, " %s", pulongest (ul
));
3902 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3904 fprintf_filtered (stream
, " %s", plongest (l
));
3907 data
= safe_read_uleb128 (data
, end
, &ul
);
3908 fprintf_filtered (stream
, " %s", pulongest (ul
));
3911 data
= safe_read_sleb128 (data
, end
, &l
);
3912 fprintf_filtered (stream
, " %s", plongest (l
));
3947 fprintf_filtered (stream
, " [$%s]",
3948 locexpr_regname (arch
, op
- DW_OP_reg0
));
3952 data
= safe_read_uleb128 (data
, end
, &ul
);
3953 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3954 locexpr_regname (arch
, (int) ul
));
3957 case DW_OP_implicit_value
:
3958 data
= safe_read_uleb128 (data
, end
, &ul
);
3960 fprintf_filtered (stream
, " %s", pulongest (ul
));
3995 data
= safe_read_sleb128 (data
, end
, &l
);
3996 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
3997 locexpr_regname (arch
, op
- DW_OP_breg0
));
4001 data
= safe_read_uleb128 (data
, end
, &ul
);
4002 data
= safe_read_sleb128 (data
, end
, &l
);
4003 fprintf_filtered (stream
, " register %s [$%s] offset %s",
4005 locexpr_regname (arch
, (int) ul
),
4010 data
= safe_read_sleb128 (data
, end
, &l
);
4011 fprintf_filtered (stream
, " %s", plongest (l
));
4014 case DW_OP_xderef_size
:
4015 case DW_OP_deref_size
:
4017 fprintf_filtered (stream
, " %d", *data
);
4021 case DW_OP_plus_uconst
:
4022 data
= safe_read_uleb128 (data
, end
, &ul
);
4023 fprintf_filtered (stream
, " %s", pulongest (ul
));
4027 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4029 fprintf_filtered (stream
, " to %ld",
4030 (long) (data
+ l
- start
));
4034 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4036 fprintf_filtered (stream
, " %ld",
4037 (long) (data
+ l
- start
));
4041 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
4043 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
4047 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4049 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4052 case DW_OP_call_ref
:
4053 ul
= extract_unsigned_integer (data
, offset_size
,
4054 gdbarch_byte_order (arch
));
4055 data
+= offset_size
;
4056 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4060 data
= safe_read_uleb128 (data
, end
, &ul
);
4061 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
4064 case DW_OP_bit_piece
:
4068 data
= safe_read_uleb128 (data
, end
, &ul
);
4069 data
= safe_read_uleb128 (data
, end
, &offset
);
4070 fprintf_filtered (stream
, " size %s offset %s (bits)",
4071 pulongest (ul
), pulongest (offset
));
4075 case DW_OP_GNU_implicit_pointer
:
4077 ul
= extract_unsigned_integer (data
, offset_size
,
4078 gdbarch_byte_order (arch
));
4079 data
+= offset_size
;
4081 data
= safe_read_sleb128 (data
, end
, &l
);
4083 fprintf_filtered (stream
, " DIE %s offset %s",
4084 phex_nz (ul
, offset_size
),
4089 case DW_OP_GNU_deref_type
:
4091 int addr_size
= *data
++;
4095 data
= safe_read_uleb128 (data
, end
, &ul
);
4097 type
= dwarf2_get_die_type (offset
, per_cu
);
4098 fprintf_filtered (stream
, "<");
4099 type_print (type
, "", stream
, -1);
4100 fprintf_filtered (stream
, " [0x%s]> %d", phex_nz (offset
.cu_off
, 0),
4105 case DW_OP_GNU_const_type
:
4110 data
= safe_read_uleb128 (data
, end
, &ul
);
4111 type_die
.cu_off
= ul
;
4112 type
= dwarf2_get_die_type (type_die
, per_cu
);
4113 fprintf_filtered (stream
, "<");
4114 type_print (type
, "", stream
, -1);
4115 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
4119 case DW_OP_GNU_regval_type
:
4125 data
= safe_read_uleb128 (data
, end
, ®
);
4126 data
= safe_read_uleb128 (data
, end
, &ul
);
4127 type_die
.cu_off
= ul
;
4129 type
= dwarf2_get_die_type (type_die
, per_cu
);
4130 fprintf_filtered (stream
, "<");
4131 type_print (type
, "", stream
, -1);
4132 fprintf_filtered (stream
, " [0x%s]> [$%s]",
4133 phex_nz (type_die
.cu_off
, 0),
4134 locexpr_regname (arch
, reg
));
4138 case DW_OP_GNU_convert
:
4139 case DW_OP_GNU_reinterpret
:
4143 data
= safe_read_uleb128 (data
, end
, &ul
);
4144 type_die
.cu_off
= ul
;
4146 if (type_die
.cu_off
== 0)
4147 fprintf_filtered (stream
, "<0>");
4152 type
= dwarf2_get_die_type (type_die
, per_cu
);
4153 fprintf_filtered (stream
, "<");
4154 type_print (type
, "", stream
, -1);
4155 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
4160 case DW_OP_GNU_entry_value
:
4161 data
= safe_read_uleb128 (data
, end
, &ul
);
4162 fputc_filtered ('\n', stream
);
4163 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
4164 start
, data
, data
+ ul
, indent
+ 2,
4169 case DW_OP_GNU_parameter_ref
:
4170 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4172 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4175 case DW_OP_GNU_addr_index
:
4176 data
= safe_read_uleb128 (data
, end
, &ul
);
4177 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4178 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
4180 case DW_OP_GNU_const_index
:
4181 data
= safe_read_uleb128 (data
, end
, &ul
);
4182 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4183 fprintf_filtered (stream
, " %s", pulongest (ul
));
4187 fprintf_filtered (stream
, "\n");
4193 /* Describe a single location, which may in turn consist of multiple
4197 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
4198 struct ui_file
*stream
,
4199 const gdb_byte
*data
, size_t size
,
4200 struct objfile
*objfile
, unsigned int addr_size
,
4201 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
4203 const gdb_byte
*end
= data
+ size
;
4204 int first_piece
= 1, bad
= 0;
4208 const gdb_byte
*here
= data
;
4209 int disassemble
= 1;
4214 fprintf_filtered (stream
, _(", and "));
4216 if (!dwarf_always_disassemble
)
4218 data
= locexpr_describe_location_piece (symbol
, stream
,
4219 addr
, objfile
, per_cu
,
4220 data
, end
, addr_size
);
4221 /* If we printed anything, or if we have an empty piece,
4222 then don't disassemble. */
4224 || data
[0] == DW_OP_piece
4225 || data
[0] == DW_OP_bit_piece
)
4230 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
4231 data
= disassemble_dwarf_expression (stream
,
4232 get_objfile_arch (objfile
),
4233 addr_size
, offset_size
, data
,
4235 dwarf_always_disassemble
,
4241 int empty
= data
== here
;
4244 fprintf_filtered (stream
, " ");
4245 if (data
[0] == DW_OP_piece
)
4249 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
4252 fprintf_filtered (stream
, _("an empty %s-byte piece"),
4255 fprintf_filtered (stream
, _(" [%s-byte piece]"),
4258 else if (data
[0] == DW_OP_bit_piece
)
4260 uint64_t bits
, offset
;
4262 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
4263 data
= safe_read_uleb128 (data
, end
, &offset
);
4266 fprintf_filtered (stream
,
4267 _("an empty %s-bit piece"),
4270 fprintf_filtered (stream
,
4271 _(" [%s-bit piece, offset %s bits]"),
4272 pulongest (bits
), pulongest (offset
));
4282 if (bad
|| data
> end
)
4283 error (_("Corrupted DWARF2 expression for \"%s\"."),
4284 SYMBOL_PRINT_NAME (symbol
));
4287 /* Print a natural-language description of SYMBOL to STREAM. This
4288 version is for a symbol with a single location. */
4291 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4292 struct ui_file
*stream
)
4294 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4295 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4296 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4297 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4299 locexpr_describe_location_1 (symbol
, addr
, stream
,
4300 dlbaton
->data
, dlbaton
->size
,
4301 objfile
, addr_size
, offset_size
,
4305 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4306 any necessary bytecode in AX. */
4309 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4310 struct agent_expr
*ax
, struct axs_value
*value
)
4312 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4313 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4315 if (dlbaton
->size
== 0)
4316 value
->optimized_out
= 1;
4318 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
4319 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4323 /* symbol_computed_ops 'generate_c_location' method. */
4326 locexpr_generate_c_location (struct symbol
*sym
, struct ui_file
*stream
,
4327 struct gdbarch
*gdbarch
,
4328 unsigned char *registers_used
,
4329 CORE_ADDR pc
, const char *result_name
)
4331 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (sym
);
4332 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4334 if (dlbaton
->size
== 0)
4335 error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym
));
4337 compile_dwarf_expr_to_c (stream
, result_name
,
4338 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4339 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4343 /* The set of location functions used with the DWARF-2 expression
4345 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4346 locexpr_read_variable
,
4347 locexpr_read_variable_at_entry
,
4348 locexpr_read_needs_frame
,
4349 locexpr_describe_location
,
4350 0, /* location_has_loclist */
4351 locexpr_tracepoint_var_ref
,
4352 locexpr_generate_c_location
4356 /* Wrapper functions for location lists. These generally find
4357 the appropriate location expression and call something above. */
4359 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4360 evaluator to calculate the location. */
4361 static struct value
*
4362 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4364 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4366 const gdb_byte
*data
;
4368 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4370 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4371 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4377 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4378 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4381 Function always returns non-NULL value, it may be marked optimized out if
4382 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4383 if it cannot resolve the parameter for any reason. */
4385 static struct value
*
4386 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4388 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4389 const gdb_byte
*data
;
4393 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4394 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4396 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4398 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4400 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4403 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
4405 loclist_read_needs_frame (struct symbol
*symbol
)
4407 /* If there's a location list, then assume we need to have a frame
4408 to choose the appropriate location expression. With tracking of
4409 global variables this is not necessarily true, but such tracking
4410 is disabled in GCC at the moment until we figure out how to
4416 /* Print a natural-language description of SYMBOL to STREAM. This
4417 version applies when there is a list of different locations, each
4418 with a specified address range. */
4421 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4422 struct ui_file
*stream
)
4424 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4425 const gdb_byte
*loc_ptr
, *buf_end
;
4426 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4427 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4428 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4429 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4430 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4431 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4432 /* Adjust base_address for relocatable objects. */
4433 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4434 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4437 loc_ptr
= dlbaton
->data
;
4438 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4440 fprintf_filtered (stream
, _("multi-location:\n"));
4442 /* Iterate through locations until we run out. */
4445 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4447 enum debug_loc_kind kind
;
4448 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4450 if (dlbaton
->from_dwo
)
4451 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4452 loc_ptr
, buf_end
, &new_ptr
,
4453 &low
, &high
, byte_order
);
4455 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4457 byte_order
, addr_size
,
4462 case DEBUG_LOC_END_OF_LIST
:
4465 case DEBUG_LOC_BASE_ADDRESS
:
4466 base_address
= high
+ base_offset
;
4467 fprintf_filtered (stream
, _(" Base address %s"),
4468 paddress (gdbarch
, base_address
));
4470 case DEBUG_LOC_START_END
:
4471 case DEBUG_LOC_START_LENGTH
:
4473 case DEBUG_LOC_BUFFER_OVERFLOW
:
4474 case DEBUG_LOC_INVALID_ENTRY
:
4475 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4476 SYMBOL_PRINT_NAME (symbol
));
4478 gdb_assert_not_reached ("bad debug_loc_kind");
4481 /* Otherwise, a location expression entry. */
4482 low
+= base_address
;
4483 high
+= base_address
;
4485 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
);
4486 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
);
4488 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4491 /* (It would improve readability to print only the minimum
4492 necessary digits of the second number of the range.) */
4493 fprintf_filtered (stream
, _(" Range %s-%s: "),
4494 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4496 /* Now describe this particular location. */
4497 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4498 objfile
, addr_size
, offset_size
,
4501 fprintf_filtered (stream
, "\n");
4507 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4508 any necessary bytecode in AX. */
4510 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4511 struct agent_expr
*ax
, struct axs_value
*value
)
4513 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4514 const gdb_byte
*data
;
4516 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4518 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4520 value
->optimized_out
= 1;
4522 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
4526 /* symbol_computed_ops 'generate_c_location' method. */
4529 loclist_generate_c_location (struct symbol
*sym
, struct ui_file
*stream
,
4530 struct gdbarch
*gdbarch
,
4531 unsigned char *registers_used
,
4532 CORE_ADDR pc
, const char *result_name
)
4534 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (sym
);
4535 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4536 const gdb_byte
*data
;
4539 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4541 error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym
));
4543 compile_dwarf_expr_to_c (stream
, result_name
,
4544 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4549 /* The set of location functions used with the DWARF-2 expression
4550 evaluator and location lists. */
4551 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4552 loclist_read_variable
,
4553 loclist_read_variable_at_entry
,
4554 loclist_read_needs_frame
,
4555 loclist_describe_location
,
4556 1, /* location_has_loclist */
4557 loclist_tracepoint_var_ref
,
4558 loclist_generate_c_location
4561 /* Provide a prototype to silence -Wmissing-prototypes. */
4562 extern initialize_file_ftype _initialize_dwarf2loc
;
4565 _initialize_dwarf2loc (void)
4567 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4568 &entry_values_debug
,
4569 _("Set entry values and tail call frames "
4571 _("Show entry values and tail call frames "
4573 _("When non-zero, the process of determining "
4574 "parameter values from function entry point "
4575 "and tail call frames will be printed."),
4577 show_entry_values_debug
,
4578 &setdebuglist
, &showdebuglist
);