1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003-2016 Free Software Foundation, Inc.
5 Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
35 #include "complaints.h"
37 #include "dwarf2expr.h"
38 #include "dwarf2loc.h"
39 #include "dwarf2-frame.h"
40 #include "compile/compile.h"
44 extern int dwarf_always_disassemble
;
46 extern const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
;
48 static struct value
*dwarf2_evaluate_loc_desc_full (struct type
*type
,
49 struct frame_info
*frame
,
52 struct dwarf2_per_cu_data
*per_cu
,
55 /* Until these have formal names, we define these here.
56 ref: http://gcc.gnu.org/wiki/DebugFission
57 Each entry in .debug_loc.dwo begins with a byte that describes the entry,
58 and is then followed by data specific to that entry. */
62 /* Indicates the end of the list of entries. */
63 DEBUG_LOC_END_OF_LIST
= 0,
65 /* This is followed by an unsigned LEB128 number that is an index into
66 .debug_addr and specifies the base address for all following entries. */
67 DEBUG_LOC_BASE_ADDRESS
= 1,
69 /* This is followed by two unsigned LEB128 numbers that are indices into
70 .debug_addr and specify the beginning and ending addresses, and then
71 a normal location expression as in .debug_loc. */
72 DEBUG_LOC_START_END
= 2,
74 /* This is followed by an unsigned LEB128 number that is an index into
75 .debug_addr and specifies the beginning address, and a 4 byte unsigned
76 number that specifies the length, and then a normal location expression
78 DEBUG_LOC_START_LENGTH
= 3,
80 /* An internal value indicating there is insufficient data. */
81 DEBUG_LOC_BUFFER_OVERFLOW
= -1,
83 /* An internal value indicating an invalid kind of entry was found. */
84 DEBUG_LOC_INVALID_ENTRY
= -2
87 /* Helper function which throws an error if a synthetic pointer is
91 invalid_synthetic_pointer (void)
93 error (_("access outside bounds of object "
94 "referenced via synthetic pointer"));
97 /* Decode the addresses in a non-dwo .debug_loc entry.
98 A pointer to the next byte to examine is returned in *NEW_PTR.
99 The encoded low,high addresses are return in *LOW,*HIGH.
100 The result indicates the kind of entry found. */
102 static enum debug_loc_kind
103 decode_debug_loc_addresses (const gdb_byte
*loc_ptr
, const gdb_byte
*buf_end
,
104 const gdb_byte
**new_ptr
,
105 CORE_ADDR
*low
, CORE_ADDR
*high
,
106 enum bfd_endian byte_order
,
107 unsigned int addr_size
,
110 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
112 if (buf_end
- loc_ptr
< 2 * addr_size
)
113 return DEBUG_LOC_BUFFER_OVERFLOW
;
116 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
118 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
119 loc_ptr
+= addr_size
;
122 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
124 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
125 loc_ptr
+= addr_size
;
129 /* A base-address-selection entry. */
130 if ((*low
& base_mask
) == base_mask
)
131 return DEBUG_LOC_BASE_ADDRESS
;
133 /* An end-of-list entry. */
134 if (*low
== 0 && *high
== 0)
135 return DEBUG_LOC_END_OF_LIST
;
137 return DEBUG_LOC_START_END
;
140 /* Decode the addresses in .debug_loc.dwo entry.
141 A pointer to the next byte to examine is returned in *NEW_PTR.
142 The encoded low,high addresses are return in *LOW,*HIGH.
143 The result indicates the kind of entry found. */
145 static enum debug_loc_kind
146 decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data
*per_cu
,
147 const gdb_byte
*loc_ptr
,
148 const gdb_byte
*buf_end
,
149 const gdb_byte
**new_ptr
,
150 CORE_ADDR
*low
, CORE_ADDR
*high
,
151 enum bfd_endian byte_order
)
153 uint64_t low_index
, high_index
;
155 if (loc_ptr
== buf_end
)
156 return DEBUG_LOC_BUFFER_OVERFLOW
;
160 case DEBUG_LOC_END_OF_LIST
:
162 return DEBUG_LOC_END_OF_LIST
;
163 case DEBUG_LOC_BASE_ADDRESS
:
165 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
167 return DEBUG_LOC_BUFFER_OVERFLOW
;
168 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
170 return DEBUG_LOC_BASE_ADDRESS
;
171 case DEBUG_LOC_START_END
:
172 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
174 return DEBUG_LOC_BUFFER_OVERFLOW
;
175 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
176 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
178 return DEBUG_LOC_BUFFER_OVERFLOW
;
179 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
181 return DEBUG_LOC_START_END
;
182 case DEBUG_LOC_START_LENGTH
:
183 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
185 return DEBUG_LOC_BUFFER_OVERFLOW
;
186 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
187 if (loc_ptr
+ 4 > buf_end
)
188 return DEBUG_LOC_BUFFER_OVERFLOW
;
190 *high
+= extract_unsigned_integer (loc_ptr
, 4, byte_order
);
191 *new_ptr
= loc_ptr
+ 4;
192 return DEBUG_LOC_START_LENGTH
;
194 return DEBUG_LOC_INVALID_ENTRY
;
198 /* A function for dealing with location lists. Given a
199 symbol baton (BATON) and a pc value (PC), find the appropriate
200 location expression, set *LOCEXPR_LENGTH, and return a pointer
201 to the beginning of the expression. Returns NULL on failure.
203 For now, only return the first matching location expression; there
204 can be more than one in the list. */
207 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
208 size_t *locexpr_length
, CORE_ADDR pc
)
210 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
211 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
212 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
213 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
214 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
215 /* Adjust base_address for relocatable objects. */
216 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (baton
->per_cu
);
217 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
218 const gdb_byte
*loc_ptr
, *buf_end
;
220 loc_ptr
= baton
->data
;
221 buf_end
= baton
->data
+ baton
->size
;
225 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
227 enum debug_loc_kind kind
;
228 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
231 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
232 loc_ptr
, buf_end
, &new_ptr
,
233 &low
, &high
, byte_order
);
235 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
237 byte_order
, addr_size
,
242 case DEBUG_LOC_END_OF_LIST
:
245 case DEBUG_LOC_BASE_ADDRESS
:
246 base_address
= high
+ base_offset
;
248 case DEBUG_LOC_START_END
:
249 case DEBUG_LOC_START_LENGTH
:
251 case DEBUG_LOC_BUFFER_OVERFLOW
:
252 case DEBUG_LOC_INVALID_ENTRY
:
253 error (_("dwarf2_find_location_expression: "
254 "Corrupted DWARF expression."));
256 gdb_assert_not_reached ("bad debug_loc_kind");
259 /* Otherwise, a location expression entry.
260 If the entry is from a DWO, don't add base address: the entry is from
261 .debug_addr which already has the DWARF "base address". We still add
262 base_offset in case we're debugging a PIE executable. */
271 high
+= base_address
;
274 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
277 if (low
== high
&& pc
== low
)
279 /* This is entry PC record present only at entry point
280 of a function. Verify it is really the function entry point. */
282 const struct block
*pc_block
= block_for_pc (pc
);
283 struct symbol
*pc_func
= NULL
;
286 pc_func
= block_linkage_function (pc_block
);
288 if (pc_func
&& pc
== BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func
)))
290 *locexpr_length
= length
;
295 if (pc
>= low
&& pc
< high
)
297 *locexpr_length
= length
;
305 /* This is the baton used when performing dwarf2 expression
307 struct dwarf_expr_baton
309 struct frame_info
*frame
;
310 struct dwarf2_per_cu_data
*per_cu
;
311 CORE_ADDR obj_address
;
314 /* Helper functions for dwarf2_evaluate_loc_desc. */
316 /* Using the frame specified in BATON, return the value of register
317 REGNUM, treated as a pointer. */
319 dwarf_expr_read_addr_from_reg (void *baton
, int dwarf_regnum
)
321 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
322 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
323 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
325 return address_from_register (regnum
, debaton
->frame
);
328 /* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback. */
330 static struct value
*
331 dwarf_expr_get_reg_value (void *baton
, struct type
*type
, int dwarf_regnum
)
333 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
334 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
335 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, dwarf_regnum
);
337 return value_from_register (type
, regnum
, debaton
->frame
);
340 /* Read memory at ADDR (length LEN) into BUF. */
343 dwarf_expr_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
345 read_memory (addr
, buf
, len
);
348 /* Using the frame specified in BATON, find the location expression
349 describing the frame base. Return a pointer to it in START and
350 its length in LENGTH. */
352 dwarf_expr_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
354 /* FIXME: cagney/2003-03-26: This code should be using
355 get_frame_base_address(), and then implement a dwarf2 specific
357 struct symbol
*framefunc
;
358 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
359 const struct block
*bl
= get_frame_block (debaton
->frame
, NULL
);
362 error (_("frame address is not available."));
364 /* Use block_linkage_function, which returns a real (not inlined)
365 function, instead of get_frame_function, which may return an
367 framefunc
= block_linkage_function (bl
);
369 /* If we found a frame-relative symbol then it was certainly within
370 some function associated with a frame. If we can't find the frame,
371 something has gone wrong. */
372 gdb_assert (framefunc
!= NULL
);
374 func_get_frame_base_dwarf_block (framefunc
,
375 get_frame_address_in_block (debaton
->frame
),
379 /* Implement find_frame_base_location method for LOC_BLOCK functions using
380 DWARF expression for its DW_AT_frame_base. */
383 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
384 const gdb_byte
**start
, size_t *length
)
386 struct dwarf2_locexpr_baton
*symbaton
387 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
389 *length
= symbaton
->size
;
390 *start
= symbaton
->data
;
393 /* Implement the struct symbol_block_ops::get_frame_base method for
394 LOC_BLOCK functions using a DWARF expression as its DW_AT_frame_base. */
397 locexpr_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
399 struct gdbarch
*gdbarch
;
401 struct dwarf2_locexpr_baton
*dlbaton
;
402 const gdb_byte
*start
;
404 struct value
*result
;
406 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
407 Thus, it's supposed to provide the find_frame_base_location method as
409 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
411 gdbarch
= get_frame_arch (frame
);
412 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
413 dlbaton
= (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
415 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
416 (framefunc
, get_frame_pc (frame
), &start
, &length
);
417 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
420 /* The DW_AT_frame_base attribute contains a location description which
421 computes the base address itself. However, the call to
422 dwarf2_evaluate_loc_desc returns a value representing a variable at
423 that address. The frame base address is thus this variable's
425 return value_address (result
);
428 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
429 function uses DWARF expression for its DW_AT_frame_base. */
431 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
433 locexpr_find_frame_base_location
,
434 locexpr_get_frame_base
437 /* Implement find_frame_base_location method for LOC_BLOCK functions using
438 DWARF location list for its DW_AT_frame_base. */
441 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
442 const gdb_byte
**start
, size_t *length
)
444 struct dwarf2_loclist_baton
*symbaton
445 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
447 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
450 /* Implement the struct symbol_block_ops::get_frame_base method for
451 LOC_BLOCK functions using a DWARF location list as its DW_AT_frame_base. */
454 loclist_get_frame_base (struct symbol
*framefunc
, struct frame_info
*frame
)
456 struct gdbarch
*gdbarch
;
458 struct dwarf2_loclist_baton
*dlbaton
;
459 const gdb_byte
*start
;
461 struct value
*result
;
463 /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
464 Thus, it's supposed to provide the find_frame_base_location method as
466 gdb_assert (SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
!= NULL
);
468 gdbarch
= get_frame_arch (frame
);
469 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
470 dlbaton
= (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (framefunc
);
472 SYMBOL_BLOCK_OPS (framefunc
)->find_frame_base_location
473 (framefunc
, get_frame_pc (frame
), &start
, &length
);
474 result
= dwarf2_evaluate_loc_desc (type
, frame
, start
, length
,
477 /* The DW_AT_frame_base attribute contains a location description which
478 computes the base address itself. However, the call to
479 dwarf2_evaluate_loc_desc returns a value representing a variable at
480 that address. The frame base address is thus this variable's
482 return value_address (result
);
485 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
486 function uses DWARF location list for its DW_AT_frame_base. */
488 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
490 loclist_find_frame_base_location
,
491 loclist_get_frame_base
494 /* See dwarf2loc.h. */
497 func_get_frame_base_dwarf_block (struct symbol
*framefunc
, CORE_ADDR pc
,
498 const gdb_byte
**start
, size_t *length
)
500 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
502 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
504 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
510 error (_("Could not find the frame base for \"%s\"."),
511 SYMBOL_NATURAL_NAME (framefunc
));
514 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
515 the frame in BATON. */
518 dwarf_expr_frame_cfa (void *baton
)
520 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
522 return dwarf2_frame_cfa (debaton
->frame
);
525 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
526 the frame in BATON. */
529 dwarf_expr_frame_pc (void *baton
)
531 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
533 return get_frame_address_in_block (debaton
->frame
);
536 /* Using the objfile specified in BATON, find the address for the
537 current thread's thread-local storage with offset OFFSET. */
539 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
541 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
542 struct objfile
*objfile
= dwarf2_per_cu_objfile (debaton
->per_cu
);
544 return target_translate_tls_address (objfile
, offset
);
547 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
548 current CU (as is PER_CU). State of the CTX is not affected by the
552 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
553 struct dwarf2_per_cu_data
*per_cu
,
554 CORE_ADDR (*get_frame_pc
) (void *baton
),
557 struct dwarf2_locexpr_baton block
;
559 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
, get_frame_pc
, baton
);
561 /* DW_OP_call_ref is currently not supported. */
562 gdb_assert (block
.per_cu
== per_cu
);
564 dwarf_expr_eval (ctx
, block
.data
, block
.size
);
567 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
570 dwarf_expr_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
572 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) ctx
->baton
;
574 per_cu_dwarf_call (ctx
, die_offset
, debaton
->per_cu
,
575 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
578 /* Callback function for dwarf2_evaluate_loc_desc. */
581 dwarf_expr_get_base_type (struct dwarf_expr_context
*ctx
,
582 cu_offset die_offset
)
584 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) ctx
->baton
;
586 return dwarf2_get_die_type (die_offset
, debaton
->per_cu
);
589 /* See dwarf2loc.h. */
591 unsigned int entry_values_debug
= 0;
593 /* Helper to set entry_values_debug. */
596 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
597 struct cmd_list_element
*c
, const char *value
)
599 fprintf_filtered (file
,
600 _("Entry values and tail call frames debugging is %s.\n"),
604 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
605 CALLER_FRAME (for registers) can be NULL if it is not known. This function
606 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
609 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
610 struct call_site
*call_site
,
611 struct frame_info
*caller_frame
)
613 switch (FIELD_LOC_KIND (call_site
->target
))
615 case FIELD_LOC_KIND_DWARF_BLOCK
:
617 struct dwarf2_locexpr_baton
*dwarf_block
;
619 struct type
*caller_core_addr_type
;
620 struct gdbarch
*caller_arch
;
622 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
623 if (dwarf_block
== NULL
)
625 struct bound_minimal_symbol msym
;
627 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
628 throw_error (NO_ENTRY_VALUE_ERROR
,
629 _("DW_AT_GNU_call_site_target is not specified "
631 paddress (call_site_gdbarch
, call_site
->pc
),
632 (msym
.minsym
== NULL
? "???"
633 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
636 if (caller_frame
== NULL
)
638 struct bound_minimal_symbol msym
;
640 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
641 throw_error (NO_ENTRY_VALUE_ERROR
,
642 _("DW_AT_GNU_call_site_target DWARF block resolving "
643 "requires known frame which is currently not "
644 "available at %s in %s"),
645 paddress (call_site_gdbarch
, call_site
->pc
),
646 (msym
.minsym
== NULL
? "???"
647 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
650 caller_arch
= get_frame_arch (caller_frame
);
651 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
652 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
653 dwarf_block
->data
, dwarf_block
->size
,
654 dwarf_block
->per_cu
);
655 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
657 if (VALUE_LVAL (val
) == lval_memory
)
658 return value_address (val
);
660 return value_as_address (val
);
663 case FIELD_LOC_KIND_PHYSNAME
:
665 const char *physname
;
666 struct bound_minimal_symbol msym
;
668 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
670 /* Handle both the mangled and demangled PHYSNAME. */
671 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
672 if (msym
.minsym
== NULL
)
674 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
675 throw_error (NO_ENTRY_VALUE_ERROR
,
676 _("Cannot find function \"%s\" for a call site target "
678 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
679 (msym
.minsym
== NULL
? "???"
680 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
683 return BMSYMBOL_VALUE_ADDRESS (msym
);
686 case FIELD_LOC_KIND_PHYSADDR
:
687 return FIELD_STATIC_PHYSADDR (call_site
->target
);
690 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
694 /* Convert function entry point exact address ADDR to the function which is
695 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
696 NO_ENTRY_VALUE_ERROR otherwise. */
698 static struct symbol
*
699 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
701 struct symbol
*sym
= find_pc_function (addr
);
704 if (sym
== NULL
|| BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
705 throw_error (NO_ENTRY_VALUE_ERROR
,
706 _("DW_TAG_GNU_call_site resolving failed to find function "
707 "name for address %s"),
708 paddress (gdbarch
, addr
));
710 type
= SYMBOL_TYPE (sym
);
711 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
712 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
717 /* Verify function with entry point exact address ADDR can never call itself
718 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
719 can call itself via tail calls.
721 If a funtion can tail call itself its entry value based parameters are
722 unreliable. There is no verification whether the value of some/all
723 parameters is unchanged through the self tail call, we expect if there is
724 a self tail call all the parameters can be modified. */
727 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
729 struct obstack addr_obstack
;
730 struct cleanup
*old_chain
;
733 /* Track here CORE_ADDRs which were already visited. */
736 /* The verification is completely unordered. Track here function addresses
737 which still need to be iterated. */
738 VEC (CORE_ADDR
) *todo
= NULL
;
740 obstack_init (&addr_obstack
);
741 old_chain
= make_cleanup_obstack_free (&addr_obstack
);
742 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
743 &addr_obstack
, hashtab_obstack_allocate
,
745 make_cleanup_htab_delete (addr_hash
);
747 make_cleanup (VEC_cleanup (CORE_ADDR
), &todo
);
749 VEC_safe_push (CORE_ADDR
, todo
, verify_addr
);
750 while (!VEC_empty (CORE_ADDR
, todo
))
752 struct symbol
*func_sym
;
753 struct call_site
*call_site
;
755 addr
= VEC_pop (CORE_ADDR
, todo
);
757 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
759 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
760 call_site
; call_site
= call_site
->tail_call_next
)
762 CORE_ADDR target_addr
;
765 /* CALLER_FRAME with registers is not available for tail-call jumped
767 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
769 if (target_addr
== verify_addr
)
771 struct bound_minimal_symbol msym
;
773 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
774 throw_error (NO_ENTRY_VALUE_ERROR
,
775 _("DW_OP_GNU_entry_value resolving has found "
776 "function \"%s\" at %s can call itself via tail "
778 (msym
.minsym
== NULL
? "???"
779 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
780 paddress (gdbarch
, verify_addr
));
783 slot
= htab_find_slot (addr_hash
, &target_addr
, INSERT
);
786 *slot
= obstack_copy (&addr_obstack
, &target_addr
,
787 sizeof (target_addr
));
788 VEC_safe_push (CORE_ADDR
, todo
, target_addr
);
793 do_cleanups (old_chain
);
796 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
797 ENTRY_VALUES_DEBUG. */
800 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
802 CORE_ADDR addr
= call_site
->pc
;
803 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
805 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
806 (msym
.minsym
== NULL
? "???"
807 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
811 /* vec.h needs single word type name, typedef it. */
812 typedef struct call_site
*call_sitep
;
814 /* Define VEC (call_sitep) functions. */
815 DEF_VEC_P (call_sitep
);
817 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
818 only top callers and bottom callees which are present in both. GDBARCH is
819 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
820 no remaining possibilities to provide unambiguous non-trivial result.
821 RESULTP should point to NULL on the first (initialization) call. Caller is
822 responsible for xfree of any RESULTP data. */
825 chain_candidate (struct gdbarch
*gdbarch
, struct call_site_chain
**resultp
,
826 VEC (call_sitep
) *chain
)
828 struct call_site_chain
*result
= *resultp
;
829 long length
= VEC_length (call_sitep
, chain
);
830 int callers
, callees
, idx
;
834 /* Create the initial chain containing all the passed PCs. */
836 result
= ((struct call_site_chain
*)
837 xmalloc (sizeof (*result
)
838 + sizeof (*result
->call_site
) * (length
- 1)));
839 result
->length
= length
;
840 result
->callers
= result
->callees
= length
;
841 if (!VEC_empty (call_sitep
, chain
))
842 memcpy (result
->call_site
, VEC_address (call_sitep
, chain
),
843 sizeof (*result
->call_site
) * length
);
846 if (entry_values_debug
)
848 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
849 for (idx
= 0; idx
< length
; idx
++)
850 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
851 fputc_unfiltered ('\n', gdb_stdlog
);
857 if (entry_values_debug
)
859 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
860 for (idx
= 0; idx
< length
; idx
++)
861 tailcall_dump (gdbarch
, VEC_index (call_sitep
, chain
, idx
));
862 fputc_unfiltered ('\n', gdb_stdlog
);
865 /* Intersect callers. */
867 callers
= std::min ((long) result
->callers
, length
);
868 for (idx
= 0; idx
< callers
; idx
++)
869 if (result
->call_site
[idx
] != VEC_index (call_sitep
, chain
, idx
))
871 result
->callers
= idx
;
875 /* Intersect callees. */
877 callees
= std::min ((long) result
->callees
, length
);
878 for (idx
= 0; idx
< callees
; idx
++)
879 if (result
->call_site
[result
->length
- 1 - idx
]
880 != VEC_index (call_sitep
, chain
, length
- 1 - idx
))
882 result
->callees
= idx
;
886 if (entry_values_debug
)
888 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
889 for (idx
= 0; idx
< result
->callers
; idx
++)
890 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
891 fputs_unfiltered (" |", gdb_stdlog
);
892 for (idx
= 0; idx
< result
->callees
; idx
++)
893 tailcall_dump (gdbarch
, result
->call_site
[result
->length
894 - result
->callees
+ idx
]);
895 fputc_unfiltered ('\n', gdb_stdlog
);
898 if (result
->callers
== 0 && result
->callees
== 0)
900 /* There are no common callers or callees. It could be also a direct
901 call (which has length 0) with ambiguous possibility of an indirect
902 call - CALLERS == CALLEES == 0 is valid during the first allocation
903 but any subsequence processing of such entry means ambiguity. */
909 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
910 PC again. In such case there must be two different code paths to reach
911 it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
912 gdb_assert (result
->callers
+ result
->callees
<= result
->length
);
915 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
916 assumed frames between them use GDBARCH. Use depth first search so we can
917 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
918 would have needless GDB stack overhead. Caller is responsible for xfree of
919 the returned result. Any unreliability results in thrown
920 NO_ENTRY_VALUE_ERROR. */
922 static struct call_site_chain
*
923 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
926 CORE_ADDR save_callee_pc
= callee_pc
;
927 struct obstack addr_obstack
;
928 struct cleanup
*back_to_retval
, *back_to_workdata
;
929 struct call_site_chain
*retval
= NULL
;
930 struct call_site
*call_site
;
932 /* Mark CALL_SITEs so we do not visit the same ones twice. */
935 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
936 call_site nor any possible call_site at CALLEE_PC's function is there.
937 Any CALL_SITE in CHAIN will be iterated to its siblings - via
938 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
939 VEC (call_sitep
) *chain
= NULL
;
941 /* We are not interested in the specific PC inside the callee function. */
942 callee_pc
= get_pc_function_start (callee_pc
);
944 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
945 paddress (gdbarch
, save_callee_pc
));
947 back_to_retval
= make_cleanup (free_current_contents
, &retval
);
949 obstack_init (&addr_obstack
);
950 back_to_workdata
= make_cleanup_obstack_free (&addr_obstack
);
951 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
952 &addr_obstack
, hashtab_obstack_allocate
,
954 make_cleanup_htab_delete (addr_hash
);
956 make_cleanup (VEC_cleanup (call_sitep
), &chain
);
958 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
959 at the target's function. All the possible tail call sites in the
960 target's function will get iterated as already pushed into CHAIN via their
962 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
966 CORE_ADDR target_func_addr
;
967 struct call_site
*target_call_site
;
969 /* CALLER_FRAME with registers is not available for tail-call jumped
971 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
973 if (target_func_addr
== callee_pc
)
975 chain_candidate (gdbarch
, &retval
, chain
);
979 /* There is no way to reach CALLEE_PC again as we would prevent
980 entering it twice as being already marked in ADDR_HASH. */
981 target_call_site
= NULL
;
985 struct symbol
*target_func
;
987 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
988 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
993 /* Attempt to visit TARGET_CALL_SITE. */
995 if (target_call_site
)
999 slot
= htab_find_slot (addr_hash
, &target_call_site
->pc
, INSERT
);
1002 /* Successfully entered TARGET_CALL_SITE. */
1004 *slot
= &target_call_site
->pc
;
1005 VEC_safe_push (call_sitep
, chain
, target_call_site
);
1010 /* Backtrack (without revisiting the originating call_site). Try the
1011 callers's sibling; if there isn't any try the callers's callers's
1014 target_call_site
= NULL
;
1015 while (!VEC_empty (call_sitep
, chain
))
1017 call_site
= VEC_pop (call_sitep
, chain
);
1019 gdb_assert (htab_find_slot (addr_hash
, &call_site
->pc
,
1020 NO_INSERT
) != NULL
);
1021 htab_remove_elt (addr_hash
, &call_site
->pc
);
1023 target_call_site
= call_site
->tail_call_next
;
1024 if (target_call_site
)
1028 while (target_call_site
);
1030 if (VEC_empty (call_sitep
, chain
))
1033 call_site
= VEC_last (call_sitep
, chain
);
1038 struct bound_minimal_symbol msym_caller
, msym_callee
;
1040 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
1041 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
1042 throw_error (NO_ENTRY_VALUE_ERROR
,
1043 _("There are no unambiguously determinable intermediate "
1044 "callers or callees between caller function \"%s\" at %s "
1045 "and callee function \"%s\" at %s"),
1046 (msym_caller
.minsym
== NULL
1047 ? "???" : MSYMBOL_PRINT_NAME (msym_caller
.minsym
)),
1048 paddress (gdbarch
, caller_pc
),
1049 (msym_callee
.minsym
== NULL
1050 ? "???" : MSYMBOL_PRINT_NAME (msym_callee
.minsym
)),
1051 paddress (gdbarch
, callee_pc
));
1054 do_cleanups (back_to_workdata
);
1055 discard_cleanups (back_to_retval
);
1059 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
1060 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
1061 constructed return NULL. Caller is responsible for xfree of the returned
1064 struct call_site_chain
*
1065 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
1066 CORE_ADDR callee_pc
)
1068 struct call_site_chain
*retval
= NULL
;
1072 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
1074 CATCH (e
, RETURN_MASK_ERROR
)
1076 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
1078 if (entry_values_debug
)
1079 exception_print (gdb_stdout
, e
);
1084 throw_exception (e
);
1091 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1094 call_site_parameter_matches (struct call_site_parameter
*parameter
,
1095 enum call_site_parameter_kind kind
,
1096 union call_site_parameter_u kind_u
)
1098 if (kind
== parameter
->kind
)
1101 case CALL_SITE_PARAMETER_DWARF_REG
:
1102 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1103 case CALL_SITE_PARAMETER_FB_OFFSET
:
1104 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1105 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1106 return kind_u
.param_offset
.cu_off
== parameter
->u
.param_offset
.cu_off
;
1111 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1112 FRAME is for callee.
1114 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1117 static struct call_site_parameter
*
1118 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1119 enum call_site_parameter_kind kind
,
1120 union call_site_parameter_u kind_u
,
1121 struct dwarf2_per_cu_data
**per_cu_return
)
1123 CORE_ADDR func_addr
, caller_pc
;
1124 struct gdbarch
*gdbarch
;
1125 struct frame_info
*caller_frame
;
1126 struct call_site
*call_site
;
1128 /* Initialize it just to avoid a GCC false warning. */
1129 struct call_site_parameter
*parameter
= NULL
;
1130 CORE_ADDR target_addr
;
1132 while (get_frame_type (frame
) == INLINE_FRAME
)
1134 frame
= get_prev_frame (frame
);
1135 gdb_assert (frame
!= NULL
);
1138 func_addr
= get_frame_func (frame
);
1139 gdbarch
= get_frame_arch (frame
);
1140 caller_frame
= get_prev_frame (frame
);
1141 if (gdbarch
!= frame_unwind_arch (frame
))
1143 struct bound_minimal_symbol msym
1144 = lookup_minimal_symbol_by_pc (func_addr
);
1145 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1147 throw_error (NO_ENTRY_VALUE_ERROR
,
1148 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1149 "(of %s (%s)) does not match caller gdbarch %s"),
1150 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1151 paddress (gdbarch
, func_addr
),
1152 (msym
.minsym
== NULL
? "???"
1153 : MSYMBOL_PRINT_NAME (msym
.minsym
)),
1154 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1157 if (caller_frame
== NULL
)
1159 struct bound_minimal_symbol msym
1160 = lookup_minimal_symbol_by_pc (func_addr
);
1162 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_GNU_entry_value resolving "
1163 "requires caller of %s (%s)"),
1164 paddress (gdbarch
, func_addr
),
1165 (msym
.minsym
== NULL
? "???"
1166 : MSYMBOL_PRINT_NAME (msym
.minsym
)));
1168 caller_pc
= get_frame_pc (caller_frame
);
1169 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1171 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1172 if (target_addr
!= func_addr
)
1174 struct minimal_symbol
*target_msym
, *func_msym
;
1176 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1177 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1178 throw_error (NO_ENTRY_VALUE_ERROR
,
1179 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1180 "but the called frame is for %s at %s"),
1181 (target_msym
== NULL
? "???"
1182 : MSYMBOL_PRINT_NAME (target_msym
)),
1183 paddress (gdbarch
, target_addr
),
1184 func_msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (func_msym
),
1185 paddress (gdbarch
, func_addr
));
1188 /* No entry value based parameters would be reliable if this function can
1189 call itself via tail calls. */
1190 func_verify_no_selftailcall (gdbarch
, func_addr
);
1192 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1194 parameter
= &call_site
->parameter
[iparams
];
1195 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1198 if (iparams
== call_site
->parameter_count
)
1200 struct minimal_symbol
*msym
1201 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1203 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1204 determine its value. */
1205 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1206 "at DW_TAG_GNU_call_site %s at %s"),
1207 paddress (gdbarch
, caller_pc
),
1208 msym
== NULL
? "???" : MSYMBOL_PRINT_NAME (msym
));
1211 *per_cu_return
= call_site
->per_cu
;
1215 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1216 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1217 DW_AT_GNU_call_site_data_value (dereferenced) block.
1219 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1222 Function always returns non-NULL, non-optimized out value. It throws
1223 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1225 static struct value
*
1226 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1227 CORE_ADDR deref_size
, struct type
*type
,
1228 struct frame_info
*caller_frame
,
1229 struct dwarf2_per_cu_data
*per_cu
)
1231 const gdb_byte
*data_src
;
1235 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1236 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1238 /* DEREF_SIZE size is not verified here. */
1239 if (data_src
== NULL
)
1240 throw_error (NO_ENTRY_VALUE_ERROR
,
1241 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1243 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1244 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1246 data
= (gdb_byte
*) alloca (size
+ 1);
1247 memcpy (data
, data_src
, size
);
1248 data
[size
] = DW_OP_stack_value
;
1250 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1253 /* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
1254 Choose DEREF_SIZE value of that parameter. Search caller of the CTX's
1255 frame. CTX must be of dwarf_expr_ctx_funcs kind.
1257 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1258 can be more simple as it does not support cross-CU DWARF executions. */
1261 dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
1262 enum call_site_parameter_kind kind
,
1263 union call_site_parameter_u kind_u
,
1266 struct dwarf_expr_baton
*debaton
;
1267 struct frame_info
*frame
, *caller_frame
;
1268 struct dwarf2_per_cu_data
*caller_per_cu
;
1269 struct dwarf_expr_baton baton_local
;
1270 struct dwarf_expr_context saved_ctx
;
1271 struct call_site_parameter
*parameter
;
1272 const gdb_byte
*data_src
;
1275 gdb_assert (ctx
->funcs
== &dwarf_expr_ctx_funcs
);
1276 debaton
= (struct dwarf_expr_baton
*) ctx
->baton
;
1277 frame
= debaton
->frame
;
1278 caller_frame
= get_prev_frame (frame
);
1280 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1282 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1283 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1285 /* DEREF_SIZE size is not verified here. */
1286 if (data_src
== NULL
)
1287 throw_error (NO_ENTRY_VALUE_ERROR
,
1288 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1290 baton_local
.frame
= caller_frame
;
1291 baton_local
.per_cu
= caller_per_cu
;
1292 baton_local
.obj_address
= 0;
1294 saved_ctx
.gdbarch
= ctx
->gdbarch
;
1295 saved_ctx
.addr_size
= ctx
->addr_size
;
1296 saved_ctx
.offset
= ctx
->offset
;
1297 saved_ctx
.baton
= ctx
->baton
;
1298 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (baton_local
.per_cu
));
1299 ctx
->addr_size
= dwarf2_per_cu_addr_size (baton_local
.per_cu
);
1300 ctx
->offset
= dwarf2_per_cu_text_offset (baton_local
.per_cu
);
1301 ctx
->baton
= &baton_local
;
1303 dwarf_expr_eval (ctx
, data_src
, size
);
1305 ctx
->gdbarch
= saved_ctx
.gdbarch
;
1306 ctx
->addr_size
= saved_ctx
.addr_size
;
1307 ctx
->offset
= saved_ctx
.offset
;
1308 ctx
->baton
= saved_ctx
.baton
;
1311 /* Callback function for dwarf2_evaluate_loc_desc.
1312 Fetch the address indexed by DW_OP_GNU_addr_index. */
1315 dwarf_expr_get_addr_index (void *baton
, unsigned int index
)
1317 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
1319 return dwarf2_read_addr_index (debaton
->per_cu
, index
);
1322 /* Callback function for get_object_address. Return the address of the VLA
1326 dwarf_expr_get_obj_addr (void *baton
)
1328 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
1330 gdb_assert (debaton
!= NULL
);
1332 if (debaton
->obj_address
== 0)
1333 error (_("Location address is not set."));
1335 return debaton
->obj_address
;
1338 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1339 the indirect method on it, that is use its stored target value, the sole
1340 purpose of entry_data_value_funcs.. */
1342 static struct value
*
1343 entry_data_value_coerce_ref (const struct value
*value
)
1345 struct type
*checked_type
= check_typedef (value_type (value
));
1346 struct value
*target_val
;
1348 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
)
1351 target_val
= (struct value
*) value_computed_closure (value
);
1352 value_incref (target_val
);
1356 /* Implement copy_closure. */
1359 entry_data_value_copy_closure (const struct value
*v
)
1361 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1363 value_incref (target_val
);
1367 /* Implement free_closure. */
1370 entry_data_value_free_closure (struct value
*v
)
1372 struct value
*target_val
= (struct value
*) value_computed_closure (v
);
1374 value_free (target_val
);
1377 /* Vector for methods for an entry value reference where the referenced value
1378 is stored in the caller. On the first dereference use
1379 DW_AT_GNU_call_site_data_value in the caller. */
1381 static const struct lval_funcs entry_data_value_funcs
=
1385 NULL
, /* indirect */
1386 entry_data_value_coerce_ref
,
1387 NULL
, /* check_synthetic_pointer */
1388 entry_data_value_copy_closure
,
1389 entry_data_value_free_closure
1392 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1393 are used to match DW_AT_location at the caller's
1394 DW_TAG_GNU_call_site_parameter.
1396 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1397 cannot resolve the parameter for any reason. */
1399 static struct value
*
1400 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1401 enum call_site_parameter_kind kind
,
1402 union call_site_parameter_u kind_u
)
1404 struct type
*checked_type
= check_typedef (type
);
1405 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1406 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1407 struct value
*outer_val
, *target_val
, *val
;
1408 struct call_site_parameter
*parameter
;
1409 struct dwarf2_per_cu_data
*caller_per_cu
;
1411 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1414 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1418 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1419 used and it is not available do not fall back to OUTER_VAL - dereferencing
1420 TYPE_CODE_REF with non-entry data value would give current value - not the
1423 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
1424 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1427 target_val
= dwarf_entry_parameter_to_value (parameter
,
1428 TYPE_LENGTH (target_type
),
1429 target_type
, caller_frame
,
1432 release_value (target_val
);
1433 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1434 target_val
/* closure */);
1436 /* Copy the referencing pointer to the new computed value. */
1437 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1438 TYPE_LENGTH (checked_type
));
1439 set_value_lazy (val
, 0);
1444 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1445 SIZE are DWARF block used to match DW_AT_location at the caller's
1446 DW_TAG_GNU_call_site_parameter.
1448 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1449 cannot resolve the parameter for any reason. */
1451 static struct value
*
1452 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1453 const gdb_byte
*block
, size_t block_len
)
1455 union call_site_parameter_u kind_u
;
1457 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1458 if (kind_u
.dwarf_reg
!= -1)
1459 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1462 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1463 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1466 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1467 suppressed during normal operation. The expression can be arbitrary if
1468 there is no caller-callee entry value binding expected. */
1469 throw_error (NO_ENTRY_VALUE_ERROR
,
1470 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1471 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1474 struct piece_closure
1476 /* Reference count. */
1479 /* The CU from which this closure's expression came. */
1480 struct dwarf2_per_cu_data
*per_cu
;
1482 /* The number of pieces used to describe this variable. */
1485 /* The target address size, used only for DWARF_VALUE_STACK. */
1488 /* The pieces themselves. */
1489 struct dwarf_expr_piece
*pieces
;
1492 /* Allocate a closure for a value formed from separately-described
1495 static struct piece_closure
*
1496 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1497 int n_pieces
, struct dwarf_expr_piece
*pieces
,
1500 struct piece_closure
*c
= XCNEW (struct piece_closure
);
1505 c
->n_pieces
= n_pieces
;
1506 c
->addr_size
= addr_size
;
1507 c
->pieces
= XCNEWVEC (struct dwarf_expr_piece
, n_pieces
);
1509 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
1510 for (i
= 0; i
< n_pieces
; ++i
)
1511 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1512 value_incref (c
->pieces
[i
].v
.value
);
1517 /* The lowest-level function to extract bits from a byte buffer.
1518 SOURCE is the buffer. It is updated if we read to the end of a
1520 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1521 updated to reflect the number of bits actually read.
1522 NBITS is the number of bits we want to read. It is updated to
1523 reflect the number of bits actually read. This function may read
1525 BITS_BIG_ENDIAN is taken directly from gdbarch.
1526 This function returns the extracted bits. */
1529 extract_bits_primitive (const gdb_byte
**source
,
1530 unsigned int *source_offset_bits
,
1531 int *nbits
, int bits_big_endian
)
1533 unsigned int avail
, mask
, datum
;
1535 gdb_assert (*source_offset_bits
< 8);
1537 avail
= 8 - *source_offset_bits
;
1541 mask
= (1 << avail
) - 1;
1543 if (bits_big_endian
)
1544 datum
>>= 8 - (*source_offset_bits
+ *nbits
);
1546 datum
>>= *source_offset_bits
;
1550 *source_offset_bits
+= avail
;
1551 if (*source_offset_bits
>= 8)
1553 *source_offset_bits
-= 8;
1560 /* Extract some bits from a source buffer and move forward in the
1563 SOURCE is the source buffer. It is updated as bytes are read.
1564 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1566 NBITS is the number of bits to read.
1567 BITS_BIG_ENDIAN is taken directly from gdbarch.
1569 This function returns the bits that were read. */
1572 extract_bits (const gdb_byte
**source
, unsigned int *source_offset_bits
,
1573 int nbits
, int bits_big_endian
)
1577 gdb_assert (nbits
> 0 && nbits
<= 8);
1579 datum
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1585 more
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1587 if (bits_big_endian
)
1597 /* Write some bits into a buffer and move forward in the buffer.
1599 DATUM is the bits to write. The low-order bits of DATUM are used.
1600 DEST is the destination buffer. It is updated as bytes are
1602 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1604 NBITS is the number of valid bits in DATUM.
1605 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1608 insert_bits (unsigned int datum
,
1609 gdb_byte
*dest
, unsigned int dest_offset_bits
,
1610 int nbits
, int bits_big_endian
)
1614 gdb_assert (dest_offset_bits
+ nbits
<= 8);
1616 mask
= (1 << nbits
) - 1;
1617 if (bits_big_endian
)
1619 datum
<<= 8 - (dest_offset_bits
+ nbits
);
1620 mask
<<= 8 - (dest_offset_bits
+ nbits
);
1624 datum
<<= dest_offset_bits
;
1625 mask
<<= dest_offset_bits
;
1628 gdb_assert ((datum
& ~mask
) == 0);
1630 *dest
= (*dest
& ~mask
) | datum
;
1633 /* Copy bits from a source to a destination.
1635 DEST is where the bits should be written.
1636 DEST_OFFSET_BITS is the bit offset into DEST.
1637 SOURCE is the source of bits.
1638 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1639 BIT_COUNT is the number of bits to copy.
1640 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1643 copy_bitwise (gdb_byte
*dest
, unsigned int dest_offset_bits
,
1644 const gdb_byte
*source
, unsigned int source_offset_bits
,
1645 unsigned int bit_count
,
1646 int bits_big_endian
)
1648 unsigned int dest_avail
;
1651 /* Reduce everything to byte-size pieces. */
1652 dest
+= dest_offset_bits
/ 8;
1653 dest_offset_bits
%= 8;
1654 source
+= source_offset_bits
/ 8;
1655 source_offset_bits
%= 8;
1657 dest_avail
= 8 - dest_offset_bits
% 8;
1659 /* See if we can fill the first destination byte. */
1660 if (dest_avail
< bit_count
)
1662 datum
= extract_bits (&source
, &source_offset_bits
, dest_avail
,
1664 insert_bits (datum
, dest
, dest_offset_bits
, dest_avail
, bits_big_endian
);
1666 dest_offset_bits
= 0;
1667 bit_count
-= dest_avail
;
1670 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1671 than 8 bits remaining. */
1672 gdb_assert (dest_offset_bits
% 8 == 0 || bit_count
< 8);
1673 for (; bit_count
>= 8; bit_count
-= 8)
1675 datum
= extract_bits (&source
, &source_offset_bits
, 8, bits_big_endian
);
1676 *dest
++ = (gdb_byte
) datum
;
1679 /* Finally, we may have a few leftover bits. */
1680 gdb_assert (bit_count
<= 8 - dest_offset_bits
% 8);
1683 datum
= extract_bits (&source
, &source_offset_bits
, bit_count
,
1685 insert_bits (datum
, dest
, dest_offset_bits
, bit_count
, bits_big_endian
);
1690 read_pieced_value (struct value
*v
)
1694 ULONGEST bits_to_skip
;
1696 struct piece_closure
*c
1697 = (struct piece_closure
*) value_computed_closure (v
);
1698 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (v
));
1700 size_t buffer_size
= 0;
1701 std::vector
<gdb_byte
> buffer
;
1703 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1705 if (value_type (v
) != value_enclosing_type (v
))
1706 internal_error (__FILE__
, __LINE__
,
1707 _("Should not be able to create a lazy value with "
1708 "an enclosing type"));
1710 contents
= value_contents_raw (v
);
1711 bits_to_skip
= 8 * value_offset (v
);
1712 if (value_bitsize (v
))
1714 bits_to_skip
+= value_bitpos (v
);
1715 type_len
= value_bitsize (v
);
1718 type_len
= 8 * TYPE_LENGTH (value_type (v
));
1720 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1722 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1723 size_t this_size
, this_size_bits
;
1724 long dest_offset_bits
, source_offset_bits
, source_offset
;
1725 const gdb_byte
*intermediate_buffer
;
1727 /* Compute size, source, and destination offsets for copying, in
1729 this_size_bits
= p
->size
;
1730 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1732 bits_to_skip
-= this_size_bits
;
1735 if (bits_to_skip
> 0)
1737 dest_offset_bits
= 0;
1738 source_offset_bits
= bits_to_skip
;
1739 this_size_bits
-= bits_to_skip
;
1744 dest_offset_bits
= offset
;
1745 source_offset_bits
= 0;
1747 if (this_size_bits
> type_len
- offset
)
1748 this_size_bits
= type_len
- offset
;
1750 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1751 source_offset
= source_offset_bits
/ 8;
1752 if (buffer_size
< this_size
)
1754 buffer_size
= this_size
;
1755 buffer
.reserve (buffer_size
);
1757 intermediate_buffer
= buffer
.data ();
1759 /* Copy from the source to DEST_BUFFER. */
1760 switch (p
->location
)
1762 case DWARF_VALUE_REGISTER
:
1764 struct gdbarch
*arch
= get_frame_arch (frame
);
1765 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, p
->v
.regno
);
1767 LONGEST reg_offset
= source_offset
;
1769 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1770 && this_size
< register_size (arch
, gdb_regnum
))
1772 /* Big-endian, and we want less than full size. */
1773 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1774 /* We want the lower-order THIS_SIZE_BITS of the bytes
1775 we extract from the register. */
1776 source_offset_bits
+= 8 * this_size
- this_size_bits
;
1779 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1780 this_size
, buffer
.data (),
1783 /* Just so garbage doesn't ever shine through. */
1784 memset (buffer
.data (), 0, this_size
);
1787 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1789 mark_value_bits_unavailable (v
, offset
, this_size_bits
);
1794 case DWARF_VALUE_MEMORY
:
1795 read_value_memory (v
, offset
,
1796 p
->v
.mem
.in_stack_memory
,
1797 p
->v
.mem
.addr
+ source_offset
,
1798 buffer
.data (), this_size
);
1801 case DWARF_VALUE_STACK
:
1803 size_t n
= this_size
;
1805 if (n
> c
->addr_size
- source_offset
)
1806 n
= (c
->addr_size
>= source_offset
1807 ? c
->addr_size
- source_offset
1815 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
1817 intermediate_buffer
= val_bytes
+ source_offset
;
1822 case DWARF_VALUE_LITERAL
:
1824 size_t n
= this_size
;
1826 if (n
> p
->v
.literal
.length
- source_offset
)
1827 n
= (p
->v
.literal
.length
>= source_offset
1828 ? p
->v
.literal
.length
- source_offset
1831 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
1835 /* These bits show up as zeros -- but do not cause the value
1836 to be considered optimized-out. */
1837 case DWARF_VALUE_IMPLICIT_POINTER
:
1840 case DWARF_VALUE_OPTIMIZED_OUT
:
1841 mark_value_bits_optimized_out (v
, offset
, this_size_bits
);
1845 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1848 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
1849 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1850 copy_bitwise (contents
, dest_offset_bits
,
1851 intermediate_buffer
, source_offset_bits
% 8,
1852 this_size_bits
, bits_big_endian
);
1854 offset
+= this_size_bits
;
1859 write_pieced_value (struct value
*to
, struct value
*from
)
1863 ULONGEST bits_to_skip
;
1864 const gdb_byte
*contents
;
1865 struct piece_closure
*c
1866 = (struct piece_closure
*) value_computed_closure (to
);
1867 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
1869 size_t buffer_size
= 0;
1870 std::vector
<gdb_byte
> buffer
;
1872 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
1876 mark_value_bytes_optimized_out (to
, 0, TYPE_LENGTH (value_type (to
)));
1880 contents
= value_contents (from
);
1881 bits_to_skip
= 8 * value_offset (to
);
1882 if (value_bitsize (to
))
1884 bits_to_skip
+= value_bitpos (to
);
1885 type_len
= value_bitsize (to
);
1888 type_len
= 8 * TYPE_LENGTH (value_type (to
));
1890 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1892 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1893 size_t this_size_bits
, this_size
;
1894 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
1896 const gdb_byte
*source_buffer
;
1898 this_size_bits
= p
->size
;
1899 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1901 bits_to_skip
-= this_size_bits
;
1904 if (this_size_bits
> type_len
- offset
)
1905 this_size_bits
= type_len
- offset
;
1906 if (bits_to_skip
> 0)
1908 dest_offset_bits
= bits_to_skip
;
1909 source_offset_bits
= 0;
1910 this_size_bits
-= bits_to_skip
;
1915 dest_offset_bits
= 0;
1916 source_offset_bits
= offset
;
1919 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1920 source_offset
= source_offset_bits
/ 8;
1921 dest_offset
= dest_offset_bits
/ 8;
1922 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
1924 source_buffer
= contents
+ source_offset
;
1929 if (buffer_size
< this_size
)
1931 buffer_size
= this_size
;
1932 buffer
.reserve (buffer_size
);
1934 source_buffer
= buffer
.data ();
1938 switch (p
->location
)
1940 case DWARF_VALUE_REGISTER
:
1942 struct gdbarch
*arch
= get_frame_arch (frame
);
1943 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, p
->v
.regno
);
1944 int reg_offset
= dest_offset
;
1946 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1947 && this_size
<= register_size (arch
, gdb_regnum
))
1949 /* Big-endian, and we want less than full size. */
1950 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1957 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1958 this_size
, buffer
.data (),
1962 throw_error (OPTIMIZED_OUT_ERROR
,
1963 _("Can't do read-modify-write to "
1964 "update bitfield; containing word "
1965 "has been optimized out"));
1967 throw_error (NOT_AVAILABLE_ERROR
,
1968 _("Can't do read-modify-write to update "
1969 "bitfield; containing word "
1972 copy_bitwise (buffer
.data (), dest_offset_bits
,
1973 contents
, source_offset_bits
,
1978 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1979 this_size
, source_buffer
);
1982 case DWARF_VALUE_MEMORY
:
1985 /* Only the first and last bytes can possibly have any
1987 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
.data (), 1);
1988 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
1989 &buffer
[this_size
- 1], 1);
1990 copy_bitwise (buffer
.data (), dest_offset_bits
,
1991 contents
, source_offset_bits
,
1996 write_memory (p
->v
.mem
.addr
+ dest_offset
,
1997 source_buffer
, this_size
);
2000 mark_value_bytes_optimized_out (to
, 0, TYPE_LENGTH (value_type (to
)));
2003 offset
+= this_size_bits
;
2007 /* An implementation of an lval_funcs method to see whether a value is
2008 a synthetic pointer. */
2011 check_pieced_synthetic_pointer (const struct value
*value
, LONGEST bit_offset
,
2014 struct piece_closure
*c
2015 = (struct piece_closure
*) value_computed_closure (value
);
2018 bit_offset
+= 8 * value_offset (value
);
2019 if (value_bitsize (value
))
2020 bit_offset
+= value_bitpos (value
);
2022 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2024 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2025 size_t this_size_bits
= p
->size
;
2029 if (bit_offset
>= this_size_bits
)
2031 bit_offset
-= this_size_bits
;
2035 bit_length
-= this_size_bits
- bit_offset
;
2039 bit_length
-= this_size_bits
;
2041 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2048 /* A wrapper function for get_frame_address_in_block. */
2051 get_frame_address_in_block_wrapper (void *baton
)
2053 return get_frame_address_in_block ((struct frame_info
*) baton
);
2056 /* Fetch a DW_AT_const_value through a synthetic pointer. */
2058 static struct value
*
2059 fetch_const_value_from_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
2060 struct dwarf2_per_cu_data
*per_cu
,
2063 struct value
*result
= NULL
;
2064 struct obstack temp_obstack
;
2065 struct cleanup
*cleanup
;
2066 const gdb_byte
*bytes
;
2069 obstack_init (&temp_obstack
);
2070 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2071 bytes
= dwarf2_fetch_constant_bytes (die
, per_cu
, &temp_obstack
, &len
);
2075 if (byte_offset
>= 0
2076 && byte_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) <= len
)
2078 bytes
+= byte_offset
;
2079 result
= value_from_contents (TYPE_TARGET_TYPE (type
), bytes
);
2082 invalid_synthetic_pointer ();
2085 result
= allocate_optimized_out_value (TYPE_TARGET_TYPE (type
));
2087 do_cleanups (cleanup
);
2092 /* Fetch the value pointed to by a synthetic pointer. */
2094 static struct value
*
2095 indirect_synthetic_pointer (sect_offset die
, LONGEST byte_offset
,
2096 struct dwarf2_per_cu_data
*per_cu
,
2097 struct frame_info
*frame
, struct type
*type
)
2099 /* Fetch the location expression of the DIE we're pointing to. */
2100 struct dwarf2_locexpr_baton baton
2101 = dwarf2_fetch_die_loc_sect_off (die
, per_cu
,
2102 get_frame_address_in_block_wrapper
, frame
);
2104 /* If pointed-to DIE has a DW_AT_location, evaluate it and return the
2105 resulting value. Otherwise, it may have a DW_AT_const_value instead,
2106 or it may've been optimized out. */
2107 if (baton
.data
!= NULL
)
2108 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
2109 baton
.data
, baton
.size
, baton
.per_cu
,
2112 return fetch_const_value_from_synthetic_pointer (die
, byte_offset
, per_cu
,
2116 /* An implementation of an lval_funcs method to indirect through a
2117 pointer. This handles the synthetic pointer case when needed. */
2119 static struct value
*
2120 indirect_pieced_value (struct value
*value
)
2122 struct piece_closure
*c
2123 = (struct piece_closure
*) value_computed_closure (value
);
2125 struct frame_info
*frame
;
2126 struct dwarf2_locexpr_baton baton
;
2129 struct dwarf_expr_piece
*piece
= NULL
;
2130 LONGEST byte_offset
;
2131 enum bfd_endian byte_order
;
2133 type
= check_typedef (value_type (value
));
2134 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
2137 bit_length
= 8 * TYPE_LENGTH (type
);
2138 bit_offset
= 8 * value_offset (value
);
2139 if (value_bitsize (value
))
2140 bit_offset
+= value_bitpos (value
);
2142 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2144 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2145 size_t this_size_bits
= p
->size
;
2149 if (bit_offset
>= this_size_bits
)
2151 bit_offset
-= this_size_bits
;
2155 bit_length
-= this_size_bits
- bit_offset
;
2159 bit_length
-= this_size_bits
;
2161 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2164 if (bit_length
!= 0)
2165 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2171 gdb_assert (piece
!= NULL
);
2172 frame
= get_selected_frame (_("No frame selected."));
2174 /* This is an offset requested by GDB, such as value subscripts.
2175 However, due to how synthetic pointers are implemented, this is
2176 always presented to us as a pointer type. This means we have to
2177 sign-extend it manually as appropriate. Use raw
2178 extract_signed_integer directly rather than value_as_address and
2179 sign extend afterwards on architectures that would need it
2180 (mostly everywhere except MIPS, which has signed addresses) as
2181 the later would go through gdbarch_pointer_to_address and thus
2182 return a CORE_ADDR with high bits set on architectures that
2183 encode address spaces and other things in CORE_ADDR. */
2184 byte_order
= gdbarch_byte_order (get_frame_arch (frame
));
2185 byte_offset
= extract_signed_integer (value_contents (value
),
2186 TYPE_LENGTH (type
), byte_order
);
2187 byte_offset
+= piece
->v
.ptr
.offset
;
2189 return indirect_synthetic_pointer (piece
->v
.ptr
.die
, byte_offset
, c
->per_cu
,
2193 /* Implementation of the coerce_ref method of lval_funcs for synthetic C++
2196 static struct value
*
2197 coerce_pieced_ref (const struct value
*value
)
2199 struct type
*type
= check_typedef (value_type (value
));
2201 if (value_bits_synthetic_pointer (value
, value_embedded_offset (value
),
2202 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
2204 const struct piece_closure
*closure
2205 = (struct piece_closure
*) value_computed_closure (value
);
2206 struct frame_info
*frame
2207 = get_selected_frame (_("No frame selected."));
2209 /* gdb represents synthetic pointers as pieced values with a single
2211 gdb_assert (closure
!= NULL
);
2212 gdb_assert (closure
->n_pieces
== 1);
2214 return indirect_synthetic_pointer (closure
->pieces
->v
.ptr
.die
,
2215 closure
->pieces
->v
.ptr
.offset
,
2216 closure
->per_cu
, frame
, type
);
2220 /* Else: not a synthetic reference; do nothing. */
2226 copy_pieced_value_closure (const struct value
*v
)
2228 struct piece_closure
*c
2229 = (struct piece_closure
*) value_computed_closure (v
);
2236 free_pieced_value_closure (struct value
*v
)
2238 struct piece_closure
*c
2239 = (struct piece_closure
*) value_computed_closure (v
);
2246 for (i
= 0; i
< c
->n_pieces
; ++i
)
2247 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
2248 value_free (c
->pieces
[i
].v
.value
);
2255 /* Functions for accessing a variable described by DW_OP_piece. */
2256 static const struct lval_funcs pieced_value_funcs
= {
2259 indirect_pieced_value
,
2261 check_pieced_synthetic_pointer
,
2262 copy_pieced_value_closure
,
2263 free_pieced_value_closure
2266 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2268 const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
=
2270 dwarf_expr_read_addr_from_reg
,
2271 dwarf_expr_get_reg_value
,
2272 dwarf_expr_read_mem
,
2273 dwarf_expr_frame_base
,
2274 dwarf_expr_frame_cfa
,
2275 dwarf_expr_frame_pc
,
2276 dwarf_expr_tls_address
,
2277 dwarf_expr_dwarf_call
,
2278 dwarf_expr_get_base_type
,
2279 dwarf_expr_push_dwarf_reg_entry_value
,
2280 dwarf_expr_get_addr_index
,
2281 dwarf_expr_get_obj_addr
2284 /* Evaluate a location description, starting at DATA and with length
2285 SIZE, to find the current location of variable of TYPE in the
2286 context of FRAME. BYTE_OFFSET is applied after the contents are
2289 static struct value
*
2290 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2291 const gdb_byte
*data
, size_t size
,
2292 struct dwarf2_per_cu_data
*per_cu
,
2293 LONGEST byte_offset
)
2295 struct value
*retval
;
2296 struct dwarf_expr_baton baton
;
2297 struct dwarf_expr_context
*ctx
;
2298 struct cleanup
*old_chain
, *value_chain
;
2299 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2301 if (byte_offset
< 0)
2302 invalid_synthetic_pointer ();
2305 return allocate_optimized_out_value (type
);
2307 baton
.frame
= frame
;
2308 baton
.per_cu
= per_cu
;
2309 baton
.obj_address
= 0;
2311 ctx
= new_dwarf_expr_context ();
2312 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2313 value_chain
= make_cleanup_value_free_to_mark (value_mark ());
2315 ctx
->gdbarch
= get_objfile_arch (objfile
);
2316 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2317 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2318 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2319 ctx
->baton
= &baton
;
2320 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2324 dwarf_expr_eval (ctx
, data
, size
);
2326 CATCH (ex
, RETURN_MASK_ERROR
)
2328 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2330 do_cleanups (old_chain
);
2331 retval
= allocate_value (type
);
2332 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
2335 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2337 if (entry_values_debug
)
2338 exception_print (gdb_stdout
, ex
);
2339 do_cleanups (old_chain
);
2340 return allocate_optimized_out_value (type
);
2343 throw_exception (ex
);
2347 if (ctx
->num_pieces
> 0)
2349 struct piece_closure
*c
;
2350 struct frame_id frame_id
= get_frame_id (frame
);
2351 ULONGEST bit_size
= 0;
2354 for (i
= 0; i
< ctx
->num_pieces
; ++i
)
2355 bit_size
+= ctx
->pieces
[i
].size
;
2356 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
2357 invalid_synthetic_pointer ();
2359 c
= allocate_piece_closure (per_cu
, ctx
->num_pieces
, ctx
->pieces
,
2361 /* We must clean up the value chain after creating the piece
2362 closure but before allocating the result. */
2363 do_cleanups (value_chain
);
2364 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
2365 VALUE_FRAME_ID (retval
) = frame_id
;
2366 set_value_offset (retval
, byte_offset
);
2370 switch (ctx
->location
)
2372 case DWARF_VALUE_REGISTER
:
2374 struct gdbarch
*arch
= get_frame_arch (frame
);
2376 = longest_to_int (value_as_long (dwarf_expr_fetch (ctx
, 0)));
2377 int gdb_regnum
= dwarf_reg_to_regnum_or_error (arch
, dwarf_regnum
);
2379 if (byte_offset
!= 0)
2380 error (_("cannot use offset on synthetic pointer to register"));
2381 do_cleanups (value_chain
);
2382 retval
= value_from_register (type
, gdb_regnum
, frame
);
2383 if (value_optimized_out (retval
))
2387 /* This means the register has undefined value / was
2388 not saved. As we're computing the location of some
2389 variable etc. in the program, not a value for
2390 inspecting a register ($pc, $sp, etc.), return a
2391 generic optimized out value instead, so that we show
2392 <optimized out> instead of <not saved>. */
2393 do_cleanups (value_chain
);
2394 tmp
= allocate_value (type
);
2395 value_contents_copy (tmp
, 0, retval
, 0, TYPE_LENGTH (type
));
2401 case DWARF_VALUE_MEMORY
:
2403 struct type
*ptr_type
;
2404 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
2405 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
2407 /* DW_OP_deref_size (and possibly other operations too) may
2408 create a pointer instead of an address. Ideally, the
2409 pointer to address conversion would be performed as part
2410 of those operations, but the type of the object to
2411 which the address refers is not known at the time of
2412 the operation. Therefore, we do the conversion here
2413 since the type is readily available. */
2415 switch (TYPE_CODE (type
))
2417 case TYPE_CODE_FUNC
:
2418 case TYPE_CODE_METHOD
:
2419 ptr_type
= builtin_type (ctx
->gdbarch
)->builtin_func_ptr
;
2422 ptr_type
= builtin_type (ctx
->gdbarch
)->builtin_data_ptr
;
2425 address
= value_as_address (value_from_pointer (ptr_type
, address
));
2427 do_cleanups (value_chain
);
2428 retval
= value_at_lazy (type
, address
+ byte_offset
);
2429 if (in_stack_memory
)
2430 set_value_stack (retval
, 1);
2434 case DWARF_VALUE_STACK
:
2436 struct value
*value
= dwarf_expr_fetch (ctx
, 0);
2438 const gdb_byte
*val_bytes
;
2439 size_t n
= TYPE_LENGTH (value_type (value
));
2441 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2442 invalid_synthetic_pointer ();
2444 val_bytes
= value_contents_all (value
);
2445 val_bytes
+= byte_offset
;
2448 /* Preserve VALUE because we are going to free values back
2449 to the mark, but we still need the value contents
2451 value_incref (value
);
2452 do_cleanups (value_chain
);
2453 make_cleanup_value_free (value
);
2455 retval
= allocate_value (type
);
2456 contents
= value_contents_raw (retval
);
2457 if (n
> TYPE_LENGTH (type
))
2459 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2461 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2462 val_bytes
+= n
- TYPE_LENGTH (type
);
2463 n
= TYPE_LENGTH (type
);
2465 memcpy (contents
, val_bytes
, n
);
2469 case DWARF_VALUE_LITERAL
:
2472 const bfd_byte
*ldata
;
2473 size_t n
= ctx
->len
;
2475 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2476 invalid_synthetic_pointer ();
2478 do_cleanups (value_chain
);
2479 retval
= allocate_value (type
);
2480 contents
= value_contents_raw (retval
);
2482 ldata
= ctx
->data
+ byte_offset
;
2485 if (n
> TYPE_LENGTH (type
))
2487 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2489 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2490 ldata
+= n
- TYPE_LENGTH (type
);
2491 n
= TYPE_LENGTH (type
);
2493 memcpy (contents
, ldata
, n
);
2497 case DWARF_VALUE_OPTIMIZED_OUT
:
2498 do_cleanups (value_chain
);
2499 retval
= allocate_optimized_out_value (type
);
2502 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2503 operation by execute_stack_op. */
2504 case DWARF_VALUE_IMPLICIT_POINTER
:
2505 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2506 it can only be encountered when making a piece. */
2508 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2512 set_value_initialized (retval
, ctx
->initialized
);
2514 do_cleanups (old_chain
);
2519 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2520 passes 0 as the byte_offset. */
2523 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2524 const gdb_byte
*data
, size_t size
,
2525 struct dwarf2_per_cu_data
*per_cu
)
2527 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
2530 /* Evaluates a dwarf expression and stores the result in VAL, expecting
2531 that the dwarf expression only produces a single CORE_ADDR. FRAME is the
2532 frame in which the expression is evaluated. ADDR is a context (location of
2533 a variable) and might be needed to evaluate the location expression.
2534 Returns 1 on success, 0 otherwise. */
2537 dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton
*dlbaton
,
2538 struct frame_info
*frame
,
2542 struct dwarf_expr_context
*ctx
;
2543 struct dwarf_expr_baton baton
;
2544 struct objfile
*objfile
;
2545 struct cleanup
*cleanup
;
2547 if (dlbaton
== NULL
|| dlbaton
->size
== 0)
2550 ctx
= new_dwarf_expr_context ();
2551 cleanup
= make_cleanup_free_dwarf_expr_context (ctx
);
2553 baton
.frame
= frame
;
2554 baton
.per_cu
= dlbaton
->per_cu
;
2555 baton
.obj_address
= addr
;
2557 objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2559 ctx
->gdbarch
= get_objfile_arch (objfile
);
2560 ctx
->addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2561 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (dlbaton
->per_cu
);
2562 ctx
->offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
2563 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2564 ctx
->baton
= &baton
;
2566 dwarf_expr_eval (ctx
, dlbaton
->data
, dlbaton
->size
);
2568 switch (ctx
->location
)
2570 case DWARF_VALUE_REGISTER
:
2571 case DWARF_VALUE_MEMORY
:
2572 case DWARF_VALUE_STACK
:
2573 *valp
= dwarf_expr_fetch_address (ctx
, 0);
2574 if (ctx
->location
== DWARF_VALUE_REGISTER
)
2575 *valp
= dwarf_expr_read_addr_from_reg (&baton
, *valp
);
2576 do_cleanups (cleanup
);
2578 case DWARF_VALUE_LITERAL
:
2579 *valp
= extract_signed_integer (ctx
->data
, ctx
->len
,
2580 gdbarch_byte_order (ctx
->gdbarch
));
2581 do_cleanups (cleanup
);
2583 /* Unsupported dwarf values. */
2584 case DWARF_VALUE_OPTIMIZED_OUT
:
2585 case DWARF_VALUE_IMPLICIT_POINTER
:
2589 do_cleanups (cleanup
);
2593 /* See dwarf2loc.h. */
2596 dwarf2_evaluate_property (const struct dynamic_prop
*prop
,
2597 struct frame_info
*frame
,
2598 struct property_addr_info
*addr_stack
,
2604 if (frame
== NULL
&& has_stack_frames ())
2605 frame
= get_selected_frame (NULL
);
2611 const struct dwarf2_property_baton
*baton
2612 = (const struct dwarf2_property_baton
*) prop
->data
.baton
;
2614 if (dwarf2_locexpr_baton_eval (&baton
->locexpr
, frame
,
2615 addr_stack
? addr_stack
->addr
: 0,
2618 if (baton
->referenced_type
)
2620 struct value
*val
= value_at (baton
->referenced_type
, *value
);
2622 *value
= value_as_address (val
);
2631 struct dwarf2_property_baton
*baton
2632 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2633 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2634 const gdb_byte
*data
;
2638 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2641 val
= dwarf2_evaluate_loc_desc (baton
->referenced_type
, frame
, data
,
2642 size
, baton
->loclist
.per_cu
);
2643 if (!value_optimized_out (val
))
2645 *value
= value_as_address (val
);
2653 *value
= prop
->data
.const_val
;
2656 case PROP_ADDR_OFFSET
:
2658 struct dwarf2_property_baton
*baton
2659 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2660 struct property_addr_info
*pinfo
;
2663 for (pinfo
= addr_stack
; pinfo
!= NULL
; pinfo
= pinfo
->next
)
2664 if (pinfo
->type
== baton
->referenced_type
)
2667 error (_("cannot find reference address for offset property"));
2668 if (pinfo
->valaddr
!= NULL
)
2669 val
= value_from_contents
2670 (baton
->offset_info
.type
,
2671 pinfo
->valaddr
+ baton
->offset_info
.offset
);
2673 val
= value_at (baton
->offset_info
.type
,
2674 pinfo
->addr
+ baton
->offset_info
.offset
);
2675 *value
= value_as_address (val
);
2683 /* See dwarf2loc.h. */
2686 dwarf2_compile_property_to_c (struct ui_file
*stream
,
2687 const char *result_name
,
2688 struct gdbarch
*gdbarch
,
2689 unsigned char *registers_used
,
2690 const struct dynamic_prop
*prop
,
2694 struct dwarf2_property_baton
*baton
2695 = (struct dwarf2_property_baton
*) prop
->data
.baton
;
2696 const gdb_byte
*data
;
2698 struct dwarf2_per_cu_data
*per_cu
;
2700 if (prop
->kind
== PROP_LOCEXPR
)
2702 data
= baton
->locexpr
.data
;
2703 size
= baton
->locexpr
.size
;
2704 per_cu
= baton
->locexpr
.per_cu
;
2708 gdb_assert (prop
->kind
== PROP_LOCLIST
);
2710 data
= dwarf2_find_location_expression (&baton
->loclist
, &size
, pc
);
2711 per_cu
= baton
->loclist
.per_cu
;
2714 compile_dwarf_bounds_to_c (stream
, result_name
, prop
, sym
, pc
,
2715 gdbarch
, registers_used
,
2716 dwarf2_per_cu_addr_size (per_cu
),
2717 data
, data
+ size
, per_cu
);
2721 /* Helper functions and baton for dwarf2_loc_desc_get_symbol_read_needs. */
2723 struct symbol_needs_baton
2725 enum symbol_needs_kind needs
;
2726 struct dwarf2_per_cu_data
*per_cu
;
2729 /* Reads from registers do require a frame. */
2731 symbol_needs_read_addr_from_reg (void *baton
, int regnum
)
2733 struct symbol_needs_baton
*nf_baton
= (struct symbol_needs_baton
*) baton
;
2735 nf_baton
->needs
= SYMBOL_NEEDS_FRAME
;
2739 /* struct dwarf_expr_context_funcs' "get_reg_value" callback:
2740 Reads from registers do require a frame. */
2742 static struct value
*
2743 symbol_needs_get_reg_value (void *baton
, struct type
*type
, int regnum
)
2745 struct symbol_needs_baton
*nf_baton
= (struct symbol_needs_baton
*) baton
;
2747 nf_baton
->needs
= SYMBOL_NEEDS_FRAME
;
2748 return value_zero (type
, not_lval
);
2751 /* Reads from memory do not require a frame. */
2753 symbol_needs_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
2755 memset (buf
, 0, len
);
2758 /* Frame-relative accesses do require a frame. */
2760 symbol_needs_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
2762 static gdb_byte lit0
= DW_OP_lit0
;
2763 struct symbol_needs_baton
*nf_baton
= (struct symbol_needs_baton
*) baton
;
2768 nf_baton
->needs
= SYMBOL_NEEDS_FRAME
;
2771 /* CFA accesses require a frame. */
2774 symbol_needs_frame_cfa (void *baton
)
2776 struct symbol_needs_baton
*nf_baton
= (struct symbol_needs_baton
*) baton
;
2778 nf_baton
->needs
= SYMBOL_NEEDS_FRAME
;
2782 /* Thread-local accesses require registers, but not a frame. */
2784 symbol_needs_tls_address (void *baton
, CORE_ADDR offset
)
2786 struct symbol_needs_baton
*nf_baton
= (struct symbol_needs_baton
*) baton
;
2788 if (nf_baton
->needs
<= SYMBOL_NEEDS_REGISTERS
)
2789 nf_baton
->needs
= SYMBOL_NEEDS_REGISTERS
;
2793 /* Helper interface of per_cu_dwarf_call for
2794 dwarf2_loc_desc_get_symbol_read_needs. */
2797 symbol_needs_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
2799 struct symbol_needs_baton
*nf_baton
=
2800 (struct symbol_needs_baton
*) ctx
->baton
;
2802 per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
,
2803 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
2806 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2809 needs_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
2810 enum call_site_parameter_kind kind
,
2811 union call_site_parameter_u kind_u
, int deref_size
)
2813 struct symbol_needs_baton
*nf_baton
=
2814 (struct symbol_needs_baton
*) ctx
->baton
;
2816 nf_baton
->needs
= SYMBOL_NEEDS_FRAME
;
2818 /* The expression may require some stub values on DWARF stack. */
2819 dwarf_expr_push_address (ctx
, 0, 0);
2822 /* DW_OP_GNU_addr_index doesn't require a frame. */
2825 needs_get_addr_index (void *baton
, unsigned int index
)
2827 /* Nothing to do. */
2831 /* DW_OP_push_object_address has a frame already passed through. */
2834 needs_get_obj_addr (void *baton
)
2836 /* Nothing to do. */
2840 /* Virtual method table for dwarf2_loc_desc_get_symbol_read_needs
2843 static const struct dwarf_expr_context_funcs symbol_needs_ctx_funcs
=
2845 symbol_needs_read_addr_from_reg
,
2846 symbol_needs_get_reg_value
,
2847 symbol_needs_read_mem
,
2848 symbol_needs_frame_base
,
2849 symbol_needs_frame_cfa
,
2850 symbol_needs_frame_cfa
, /* get_frame_pc */
2851 symbol_needs_tls_address
,
2852 symbol_needs_dwarf_call
,
2853 NULL
, /* get_base_type */
2854 needs_dwarf_reg_entry_value
,
2855 needs_get_addr_index
,
2859 /* Compute the correct symbol_needs_kind value for the location
2860 expression at DATA (length SIZE). */
2862 static enum symbol_needs_kind
2863 dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte
*data
, size_t size
,
2864 struct dwarf2_per_cu_data
*per_cu
)
2866 struct symbol_needs_baton baton
;
2867 struct dwarf_expr_context
*ctx
;
2869 struct cleanup
*old_chain
;
2870 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2872 baton
.needs
= SYMBOL_NEEDS_NONE
;
2873 baton
.per_cu
= per_cu
;
2875 ctx
= new_dwarf_expr_context ();
2876 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2877 make_cleanup_value_free_to_mark (value_mark ());
2879 ctx
->gdbarch
= get_objfile_arch (objfile
);
2880 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2881 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2882 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2883 ctx
->baton
= &baton
;
2884 ctx
->funcs
= &symbol_needs_ctx_funcs
;
2886 dwarf_expr_eval (ctx
, data
, size
);
2888 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
2890 if (ctx
->num_pieces
> 0)
2894 /* If the location has several pieces, and any of them are in
2895 registers, then we will need a frame to fetch them from. */
2896 for (i
= 0; i
< ctx
->num_pieces
; i
++)
2897 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2901 do_cleanups (old_chain
);
2904 baton
.needs
= SYMBOL_NEEDS_FRAME
;
2908 /* A helper function that throws an unimplemented error mentioning a
2909 given DWARF operator. */
2912 unimplemented (unsigned int op
)
2914 const char *name
= get_DW_OP_name (op
);
2917 error (_("DWARF operator %s cannot be translated to an agent expression"),
2920 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2921 "to an agent expression"),
2927 This is basically a wrapper on gdbarch_dwarf2_reg_to_regnum so that we
2928 can issue a complaint, which is better than having every target's
2929 implementation of dwarf2_reg_to_regnum do it. */
2932 dwarf_reg_to_regnum (struct gdbarch
*arch
, int dwarf_reg
)
2934 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2938 complaint (&symfile_complaints
,
2939 _("bad DWARF register number %d"), dwarf_reg
);
2944 /* Subroutine of dwarf_reg_to_regnum_or_error to simplify it.
2945 Throw an error because DWARF_REG is bad. */
2948 throw_bad_regnum_error (ULONGEST dwarf_reg
)
2950 /* Still want to print -1 as "-1".
2951 We *could* have int and ULONGEST versions of dwarf2_reg_to_regnum_or_error
2952 but that's overkill for now. */
2953 if ((int) dwarf_reg
== dwarf_reg
)
2954 error (_("Unable to access DWARF register number %d"), (int) dwarf_reg
);
2955 error (_("Unable to access DWARF register number %s"),
2956 pulongest (dwarf_reg
));
2959 /* See dwarf2loc.h. */
2962 dwarf_reg_to_regnum_or_error (struct gdbarch
*arch
, ULONGEST dwarf_reg
)
2966 if (dwarf_reg
> INT_MAX
)
2967 throw_bad_regnum_error (dwarf_reg
);
2968 /* Yes, we will end up issuing a complaint and an error if DWARF_REG is
2969 bad, but that's ok. */
2970 reg
= dwarf_reg_to_regnum (arch
, (int) dwarf_reg
);
2972 throw_bad_regnum_error (dwarf_reg
);
2976 /* A helper function that emits an access to memory. ARCH is the
2977 target architecture. EXPR is the expression which we are building.
2978 NBITS is the number of bits we want to read. This emits the
2979 opcodes needed to read the memory and then extract the desired
2983 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2985 ULONGEST nbytes
= (nbits
+ 7) / 8;
2987 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2990 ax_trace_quick (expr
, nbytes
);
2993 ax_simple (expr
, aop_ref8
);
2994 else if (nbits
<= 16)
2995 ax_simple (expr
, aop_ref16
);
2996 else if (nbits
<= 32)
2997 ax_simple (expr
, aop_ref32
);
2999 ax_simple (expr
, aop_ref64
);
3001 /* If we read exactly the number of bytes we wanted, we're done. */
3002 if (8 * nbytes
== nbits
)
3005 if (gdbarch_bits_big_endian (arch
))
3007 /* On a bits-big-endian machine, we want the high-order
3009 ax_const_l (expr
, 8 * nbytes
- nbits
);
3010 ax_simple (expr
, aop_rsh_unsigned
);
3014 /* On a bits-little-endian box, we want the low-order NBITS. */
3015 ax_zero_ext (expr
, nbits
);
3019 /* A helper function to return the frame's PC. */
3022 get_ax_pc (void *baton
)
3024 struct agent_expr
*expr
= (struct agent_expr
*) baton
;
3029 /* Compile a DWARF location expression to an agent expression.
3031 EXPR is the agent expression we are building.
3032 LOC is the agent value we modify.
3033 ARCH is the architecture.
3034 ADDR_SIZE is the size of addresses, in bytes.
3035 OP_PTR is the start of the location expression.
3036 OP_END is one past the last byte of the location expression.
3038 This will throw an exception for various kinds of errors -- for
3039 example, if the expression cannot be compiled, or if the expression
3043 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
3044 struct gdbarch
*arch
, unsigned int addr_size
,
3045 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
3046 struct dwarf2_per_cu_data
*per_cu
)
3049 std::vector
<int> dw_labels
, patches
;
3050 const gdb_byte
* const base
= op_ptr
;
3051 const gdb_byte
*previous_piece
= op_ptr
;
3052 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
3053 ULONGEST bits_collected
= 0;
3054 unsigned int addr_size_bits
= 8 * addr_size
;
3055 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
3057 std::vector
<int> offsets (op_end
- op_ptr
, -1);
3059 /* By default we are making an address. */
3060 loc
->kind
= axs_lvalue_memory
;
3062 while (op_ptr
< op_end
)
3064 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
3065 uint64_t uoffset
, reg
;
3069 offsets
[op_ptr
- base
] = expr
->len
;
3072 /* Our basic approach to code generation is to map DWARF
3073 operations directly to AX operations. However, there are
3076 First, DWARF works on address-sized units, but AX always uses
3077 LONGEST. For most operations we simply ignore this
3078 difference; instead we generate sign extensions as needed
3079 before division and comparison operations. It would be nice
3080 to omit the sign extensions, but there is no way to determine
3081 the size of the target's LONGEST. (This code uses the size
3082 of the host LONGEST in some cases -- that is a bug but it is
3085 Second, some DWARF operations cannot be translated to AX.
3086 For these we simply fail. See
3087 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
3122 ax_const_l (expr
, op
- DW_OP_lit0
);
3126 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
3127 op_ptr
+= addr_size
;
3128 /* Some versions of GCC emit DW_OP_addr before
3129 DW_OP_GNU_push_tls_address. In this case the value is an
3130 index, not an address. We don't support things like
3131 branching between the address and the TLS op. */
3132 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
3133 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
3134 ax_const_l (expr
, uoffset
);
3138 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
3142 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
3146 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
3150 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
3154 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
3158 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
3162 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
3166 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
3170 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
3171 ax_const_l (expr
, uoffset
);
3174 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3175 ax_const_l (expr
, offset
);
3210 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3211 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_reg0
);
3212 loc
->kind
= axs_lvalue_register
;
3216 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3217 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
3218 loc
->u
.reg
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3219 loc
->kind
= axs_lvalue_register
;
3222 case DW_OP_implicit_value
:
3226 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
3227 if (op_ptr
+ len
> op_end
)
3228 error (_("DW_OP_implicit_value: too few bytes available."));
3229 if (len
> sizeof (ULONGEST
))
3230 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
3233 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
3236 dwarf_expr_require_composition (op_ptr
, op_end
,
3237 "DW_OP_implicit_value");
3239 loc
->kind
= axs_rvalue
;
3243 case DW_OP_stack_value
:
3244 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
3245 loc
->kind
= axs_rvalue
;
3280 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3281 i
= dwarf_reg_to_regnum_or_error (arch
, op
- DW_OP_breg0
);
3285 ax_const_l (expr
, offset
);
3286 ax_simple (expr
, aop_add
);
3291 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3292 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3293 i
= dwarf_reg_to_regnum_or_error (arch
, reg
);
3297 ax_const_l (expr
, offset
);
3298 ax_simple (expr
, aop_add
);
3304 const gdb_byte
*datastart
;
3306 const struct block
*b
;
3307 struct symbol
*framefunc
;
3309 b
= block_for_pc (expr
->scope
);
3312 error (_("No block found for address"));
3314 framefunc
= block_linkage_function (b
);
3317 error (_("No function found for block"));
3319 func_get_frame_base_dwarf_block (framefunc
, expr
->scope
,
3320 &datastart
, &datalen
);
3322 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
3323 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
3324 datastart
+ datalen
, per_cu
);
3325 if (loc
->kind
== axs_lvalue_register
)
3326 require_rvalue (expr
, loc
);
3330 ax_const_l (expr
, offset
);
3331 ax_simple (expr
, aop_add
);
3334 loc
->kind
= axs_lvalue_memory
;
3339 ax_simple (expr
, aop_dup
);
3343 ax_simple (expr
, aop_pop
);
3348 ax_pick (expr
, offset
);
3352 ax_simple (expr
, aop_swap
);
3360 ax_simple (expr
, aop_rot
);
3364 case DW_OP_deref_size
:
3368 if (op
== DW_OP_deref_size
)
3373 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
3374 error (_("Unsupported size %d in %s"),
3375 size
, get_DW_OP_name (op
));
3376 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
3381 /* Sign extend the operand. */
3382 ax_ext (expr
, addr_size_bits
);
3383 ax_simple (expr
, aop_dup
);
3384 ax_const_l (expr
, 0);
3385 ax_simple (expr
, aop_less_signed
);
3386 ax_simple (expr
, aop_log_not
);
3387 i
= ax_goto (expr
, aop_if_goto
);
3388 /* We have to emit 0 - X. */
3389 ax_const_l (expr
, 0);
3390 ax_simple (expr
, aop_swap
);
3391 ax_simple (expr
, aop_sub
);
3392 ax_label (expr
, i
, expr
->len
);
3396 /* No need to sign extend here. */
3397 ax_const_l (expr
, 0);
3398 ax_simple (expr
, aop_swap
);
3399 ax_simple (expr
, aop_sub
);
3403 /* Sign extend the operand. */
3404 ax_ext (expr
, addr_size_bits
);
3405 ax_simple (expr
, aop_bit_not
);
3408 case DW_OP_plus_uconst
:
3409 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3410 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3411 but we micro-optimize anyhow. */
3414 ax_const_l (expr
, reg
);
3415 ax_simple (expr
, aop_add
);
3420 ax_simple (expr
, aop_bit_and
);
3424 /* Sign extend the operands. */
3425 ax_ext (expr
, addr_size_bits
);
3426 ax_simple (expr
, aop_swap
);
3427 ax_ext (expr
, addr_size_bits
);
3428 ax_simple (expr
, aop_swap
);
3429 ax_simple (expr
, aop_div_signed
);
3433 ax_simple (expr
, aop_sub
);
3437 ax_simple (expr
, aop_rem_unsigned
);
3441 ax_simple (expr
, aop_mul
);
3445 ax_simple (expr
, aop_bit_or
);
3449 ax_simple (expr
, aop_add
);
3453 ax_simple (expr
, aop_lsh
);
3457 ax_simple (expr
, aop_rsh_unsigned
);
3461 ax_simple (expr
, aop_rsh_signed
);
3465 ax_simple (expr
, aop_bit_xor
);
3469 /* Sign extend the operands. */
3470 ax_ext (expr
, addr_size_bits
);
3471 ax_simple (expr
, aop_swap
);
3472 ax_ext (expr
, addr_size_bits
);
3473 /* Note no swap here: A <= B is !(B < A). */
3474 ax_simple (expr
, aop_less_signed
);
3475 ax_simple (expr
, aop_log_not
);
3479 /* Sign extend the operands. */
3480 ax_ext (expr
, addr_size_bits
);
3481 ax_simple (expr
, aop_swap
);
3482 ax_ext (expr
, addr_size_bits
);
3483 ax_simple (expr
, aop_swap
);
3484 /* A >= B is !(A < B). */
3485 ax_simple (expr
, aop_less_signed
);
3486 ax_simple (expr
, aop_log_not
);
3490 /* Sign extend the operands. */
3491 ax_ext (expr
, addr_size_bits
);
3492 ax_simple (expr
, aop_swap
);
3493 ax_ext (expr
, addr_size_bits
);
3494 /* No need for a second swap here. */
3495 ax_simple (expr
, aop_equal
);
3499 /* Sign extend the operands. */
3500 ax_ext (expr
, addr_size_bits
);
3501 ax_simple (expr
, aop_swap
);
3502 ax_ext (expr
, addr_size_bits
);
3503 ax_simple (expr
, aop_swap
);
3504 ax_simple (expr
, aop_less_signed
);
3508 /* Sign extend the operands. */
3509 ax_ext (expr
, addr_size_bits
);
3510 ax_simple (expr
, aop_swap
);
3511 ax_ext (expr
, addr_size_bits
);
3512 /* Note no swap here: A > B is B < A. */
3513 ax_simple (expr
, aop_less_signed
);
3517 /* Sign extend the operands. */
3518 ax_ext (expr
, addr_size_bits
);
3519 ax_simple (expr
, aop_swap
);
3520 ax_ext (expr
, addr_size_bits
);
3521 /* No need for a swap here. */
3522 ax_simple (expr
, aop_equal
);
3523 ax_simple (expr
, aop_log_not
);
3526 case DW_OP_call_frame_cfa
:
3529 CORE_ADDR text_offset
;
3531 const gdb_byte
*cfa_start
, *cfa_end
;
3533 if (dwarf2_fetch_cfa_info (arch
, expr
->scope
, per_cu
,
3535 &text_offset
, &cfa_start
, &cfa_end
))
3538 ax_reg (expr
, regnum
);
3541 ax_const_l (expr
, off
);
3542 ax_simple (expr
, aop_add
);
3547 /* Another expression. */
3548 ax_const_l (expr
, text_offset
);
3549 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3550 cfa_start
, cfa_end
, per_cu
);
3553 loc
->kind
= axs_lvalue_memory
;
3557 case DW_OP_GNU_push_tls_address
:
3558 case DW_OP_form_tls_address
:
3562 case DW_OP_push_object_address
:
3567 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3569 i
= ax_goto (expr
, aop_goto
);
3570 dw_labels
.push_back (op_ptr
+ offset
- base
);
3571 patches
.push_back (i
);
3575 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3577 /* Zero extend the operand. */
3578 ax_zero_ext (expr
, addr_size_bits
);
3579 i
= ax_goto (expr
, aop_if_goto
);
3580 dw_labels
.push_back (op_ptr
+ offset
- base
);
3581 patches
.push_back (i
);
3588 case DW_OP_bit_piece
:
3590 uint64_t size
, offset
;
3592 if (op_ptr
- 1 == previous_piece
)
3593 error (_("Cannot translate empty pieces to agent expressions"));
3594 previous_piece
= op_ptr
- 1;
3596 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3597 if (op
== DW_OP_piece
)
3603 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
3605 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3606 error (_("Expression pieces exceed word size"));
3608 /* Access the bits. */
3611 case axs_lvalue_register
:
3612 ax_reg (expr
, loc
->u
.reg
);
3615 case axs_lvalue_memory
:
3616 /* Offset the pointer, if needed. */
3619 ax_const_l (expr
, offset
/ 8);
3620 ax_simple (expr
, aop_add
);
3623 access_memory (arch
, expr
, size
);
3627 /* For a bits-big-endian target, shift up what we already
3628 have. For a bits-little-endian target, shift up the
3629 new data. Note that there is a potential bug here if
3630 the DWARF expression leaves multiple values on the
3632 if (bits_collected
> 0)
3634 if (bits_big_endian
)
3636 ax_simple (expr
, aop_swap
);
3637 ax_const_l (expr
, size
);
3638 ax_simple (expr
, aop_lsh
);
3639 /* We don't need a second swap here, because
3640 aop_bit_or is symmetric. */
3644 ax_const_l (expr
, size
);
3645 ax_simple (expr
, aop_lsh
);
3647 ax_simple (expr
, aop_bit_or
);
3650 bits_collected
+= size
;
3651 loc
->kind
= axs_rvalue
;
3655 case DW_OP_GNU_uninit
:
3661 struct dwarf2_locexpr_baton block
;
3662 int size
= (op
== DW_OP_call2
? 2 : 4);
3665 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3668 offset
.cu_off
= uoffset
;
3669 block
= dwarf2_fetch_die_loc_cu_off (offset
, per_cu
,
3672 /* DW_OP_call_ref is currently not supported. */
3673 gdb_assert (block
.per_cu
== per_cu
);
3675 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3676 block
.data
, block
.data
+ block
.size
,
3681 case DW_OP_call_ref
:
3689 /* Patch all the branches we emitted. */
3690 for (i
= 0; i
< patches
.size (); ++i
)
3692 int targ
= offsets
[dw_labels
[i
]];
3694 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3695 ax_label (expr
, patches
[i
], targ
);
3700 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3701 evaluator to calculate the location. */
3702 static struct value
*
3703 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3705 struct dwarf2_locexpr_baton
*dlbaton
3706 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3709 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3710 dlbaton
->size
, dlbaton
->per_cu
);
3715 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3716 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3719 static struct value
*
3720 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3722 struct dwarf2_locexpr_baton
*dlbaton
3723 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3725 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3729 /* Implementation of get_symbol_read_needs from
3730 symbol_computed_ops. */
3732 static enum symbol_needs_kind
3733 locexpr_get_symbol_read_needs (struct symbol
*symbol
)
3735 struct dwarf2_locexpr_baton
*dlbaton
3736 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
3738 return dwarf2_loc_desc_get_symbol_read_needs (dlbaton
->data
, dlbaton
->size
,
3742 /* Return true if DATA points to the end of a piece. END is one past
3743 the last byte in the expression. */
3746 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3748 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3751 /* Helper for locexpr_describe_location_piece that finds the name of a
3755 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3759 /* This doesn't use dwarf_reg_to_regnum_or_error on purpose.
3760 We'd rather print *something* here than throw an error. */
3761 regnum
= dwarf_reg_to_regnum (gdbarch
, dwarf_regnum
);
3762 /* gdbarch_register_name may just return "", return something more
3763 descriptive for bad register numbers. */
3766 /* The text is output as "$bad_register_number".
3767 That is why we use the underscores. */
3768 return _("bad_register_number");
3770 return gdbarch_register_name (gdbarch
, regnum
);
3773 /* Nicely describe a single piece of a location, returning an updated
3774 position in the bytecode sequence. This function cannot recognize
3775 all locations; if a location is not recognized, it simply returns
3776 DATA. If there is an error during reading, e.g. we run off the end
3777 of the buffer, an error is thrown. */
3779 static const gdb_byte
*
3780 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3781 CORE_ADDR addr
, struct objfile
*objfile
,
3782 struct dwarf2_per_cu_data
*per_cu
,
3783 const gdb_byte
*data
, const gdb_byte
*end
,
3784 unsigned int addr_size
)
3786 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3789 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3791 fprintf_filtered (stream
, _("a variable in $%s"),
3792 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3795 else if (data
[0] == DW_OP_regx
)
3799 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3800 fprintf_filtered (stream
, _("a variable in $%s"),
3801 locexpr_regname (gdbarch
, reg
));
3803 else if (data
[0] == DW_OP_fbreg
)
3805 const struct block
*b
;
3806 struct symbol
*framefunc
;
3808 int64_t frame_offset
;
3809 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3811 int64_t base_offset
= 0;
3813 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3814 if (!piece_end_p (new_data
, end
))
3818 b
= block_for_pc (addr
);
3821 error (_("No block found for address for symbol \"%s\"."),
3822 SYMBOL_PRINT_NAME (symbol
));
3824 framefunc
= block_linkage_function (b
);
3827 error (_("No function found for block for symbol \"%s\"."),
3828 SYMBOL_PRINT_NAME (symbol
));
3830 func_get_frame_base_dwarf_block (framefunc
, addr
, &base_data
, &base_size
);
3832 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3834 const gdb_byte
*buf_end
;
3836 frame_reg
= base_data
[0] - DW_OP_breg0
;
3837 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3839 if (buf_end
!= base_data
+ base_size
)
3840 error (_("Unexpected opcode after "
3841 "DW_OP_breg%u for symbol \"%s\"."),
3842 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3844 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3846 /* The frame base is just the register, with no offset. */
3847 frame_reg
= base_data
[0] - DW_OP_reg0
;
3852 /* We don't know what to do with the frame base expression,
3853 so we can't trace this variable; give up. */
3857 fprintf_filtered (stream
,
3858 _("a variable at frame base reg $%s offset %s+%s"),
3859 locexpr_regname (gdbarch
, frame_reg
),
3860 plongest (base_offset
), plongest (frame_offset
));
3862 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3863 && piece_end_p (data
, end
))
3867 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3869 fprintf_filtered (stream
,
3870 _("a variable at offset %s from base reg $%s"),
3872 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3875 /* The location expression for a TLS variable looks like this (on a
3878 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3879 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3881 0x3 is the encoding for DW_OP_addr, which has an operand as long
3882 as the size of an address on the target machine (here is 8
3883 bytes). Note that more recent version of GCC emit DW_OP_const4u
3884 or DW_OP_const8u, depending on address size, rather than
3885 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3886 The operand represents the offset at which the variable is within
3887 the thread local storage. */
3889 else if (data
+ 1 + addr_size
< end
3890 && (data
[0] == DW_OP_addr
3891 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3892 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3893 && (data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3894 || data
[1 + addr_size
] == DW_OP_form_tls_address
)
3895 && piece_end_p (data
+ 2 + addr_size
, end
))
3898 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3899 gdbarch_byte_order (gdbarch
));
3901 fprintf_filtered (stream
,
3902 _("a thread-local variable at offset 0x%s "
3903 "in the thread-local storage for `%s'"),
3904 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3906 data
+= 1 + addr_size
+ 1;
3909 /* With -gsplit-dwarf a TLS variable can also look like this:
3910 DW_AT_location : 3 byte block: fc 4 e0
3911 (DW_OP_GNU_const_index: 4;
3912 DW_OP_GNU_push_tls_address) */
3913 else if (data
+ 3 <= end
3914 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3915 && data
[0] == DW_OP_GNU_const_index
3917 && (data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3918 || data
[1 + leb128_size
] == DW_OP_form_tls_address
)
3919 && piece_end_p (data
+ 2 + leb128_size
, end
))
3923 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3924 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3925 fprintf_filtered (stream
,
3926 _("a thread-local variable at offset 0x%s "
3927 "in the thread-local storage for `%s'"),
3928 phex_nz (offset
, addr_size
), objfile_name (objfile
));
3932 else if (data
[0] >= DW_OP_lit0
3933 && data
[0] <= DW_OP_lit31
3935 && data
[1] == DW_OP_stack_value
)
3937 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3944 /* Disassemble an expression, stopping at the end of a piece or at the
3945 end of the expression. Returns a pointer to the next unread byte
3946 in the input expression. If ALL is nonzero, then this function
3947 will keep going until it reaches the end of the expression.
3948 If there is an error during reading, e.g. we run off the end
3949 of the buffer, an error is thrown. */
3951 static const gdb_byte
*
3952 disassemble_dwarf_expression (struct ui_file
*stream
,
3953 struct gdbarch
*arch
, unsigned int addr_size
,
3954 int offset_size
, const gdb_byte
*start
,
3955 const gdb_byte
*data
, const gdb_byte
*end
,
3956 int indent
, int all
,
3957 struct dwarf2_per_cu_data
*per_cu
)
3961 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3963 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *data
++;
3968 name
= get_DW_OP_name (op
);
3971 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3972 op
, (long) (data
- 1 - start
));
3973 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3974 (long) (data
- 1 - start
), name
);
3979 ul
= extract_unsigned_integer (data
, addr_size
,
3980 gdbarch_byte_order (arch
));
3982 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3986 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3988 fprintf_filtered (stream
, " %s", pulongest (ul
));
3991 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3993 fprintf_filtered (stream
, " %s", plongest (l
));
3996 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3998 fprintf_filtered (stream
, " %s", pulongest (ul
));
4001 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4003 fprintf_filtered (stream
, " %s", plongest (l
));
4006 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4008 fprintf_filtered (stream
, " %s", pulongest (ul
));
4011 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
4013 fprintf_filtered (stream
, " %s", plongest (l
));
4016 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
4018 fprintf_filtered (stream
, " %s", pulongest (ul
));
4021 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
4023 fprintf_filtered (stream
, " %s", plongest (l
));
4026 data
= safe_read_uleb128 (data
, end
, &ul
);
4027 fprintf_filtered (stream
, " %s", pulongest (ul
));
4030 data
= safe_read_sleb128 (data
, end
, &l
);
4031 fprintf_filtered (stream
, " %s", plongest (l
));
4066 fprintf_filtered (stream
, " [$%s]",
4067 locexpr_regname (arch
, op
- DW_OP_reg0
));
4071 data
= safe_read_uleb128 (data
, end
, &ul
);
4072 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
4073 locexpr_regname (arch
, (int) ul
));
4076 case DW_OP_implicit_value
:
4077 data
= safe_read_uleb128 (data
, end
, &ul
);
4079 fprintf_filtered (stream
, " %s", pulongest (ul
));
4114 data
= safe_read_sleb128 (data
, end
, &l
);
4115 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
4116 locexpr_regname (arch
, op
- DW_OP_breg0
));
4120 data
= safe_read_uleb128 (data
, end
, &ul
);
4121 data
= safe_read_sleb128 (data
, end
, &l
);
4122 fprintf_filtered (stream
, " register %s [$%s] offset %s",
4124 locexpr_regname (arch
, (int) ul
),
4129 data
= safe_read_sleb128 (data
, end
, &l
);
4130 fprintf_filtered (stream
, " %s", plongest (l
));
4133 case DW_OP_xderef_size
:
4134 case DW_OP_deref_size
:
4136 fprintf_filtered (stream
, " %d", *data
);
4140 case DW_OP_plus_uconst
:
4141 data
= safe_read_uleb128 (data
, end
, &ul
);
4142 fprintf_filtered (stream
, " %s", pulongest (ul
));
4146 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4148 fprintf_filtered (stream
, " to %ld",
4149 (long) (data
+ l
- start
));
4153 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
4155 fprintf_filtered (stream
, " %ld",
4156 (long) (data
+ l
- start
));
4160 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
4162 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
4166 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4168 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4171 case DW_OP_call_ref
:
4172 ul
= extract_unsigned_integer (data
, offset_size
,
4173 gdbarch_byte_order (arch
));
4174 data
+= offset_size
;
4175 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
4179 data
= safe_read_uleb128 (data
, end
, &ul
);
4180 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
4183 case DW_OP_bit_piece
:
4187 data
= safe_read_uleb128 (data
, end
, &ul
);
4188 data
= safe_read_uleb128 (data
, end
, &offset
);
4189 fprintf_filtered (stream
, " size %s offset %s (bits)",
4190 pulongest (ul
), pulongest (offset
));
4194 case DW_OP_GNU_implicit_pointer
:
4196 ul
= extract_unsigned_integer (data
, offset_size
,
4197 gdbarch_byte_order (arch
));
4198 data
+= offset_size
;
4200 data
= safe_read_sleb128 (data
, end
, &l
);
4202 fprintf_filtered (stream
, " DIE %s offset %s",
4203 phex_nz (ul
, offset_size
),
4208 case DW_OP_GNU_deref_type
:
4210 int addr_size
= *data
++;
4214 data
= safe_read_uleb128 (data
, end
, &ul
);
4216 type
= dwarf2_get_die_type (offset
, per_cu
);
4217 fprintf_filtered (stream
, "<");
4218 type_print (type
, "", stream
, -1);
4219 fprintf_filtered (stream
, " [0x%s]> %d", phex_nz (offset
.cu_off
, 0),
4224 case DW_OP_GNU_const_type
:
4229 data
= safe_read_uleb128 (data
, end
, &ul
);
4230 type_die
.cu_off
= ul
;
4231 type
= dwarf2_get_die_type (type_die
, per_cu
);
4232 fprintf_filtered (stream
, "<");
4233 type_print (type
, "", stream
, -1);
4234 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
4238 case DW_OP_GNU_regval_type
:
4244 data
= safe_read_uleb128 (data
, end
, ®
);
4245 data
= safe_read_uleb128 (data
, end
, &ul
);
4246 type_die
.cu_off
= ul
;
4248 type
= dwarf2_get_die_type (type_die
, per_cu
);
4249 fprintf_filtered (stream
, "<");
4250 type_print (type
, "", stream
, -1);
4251 fprintf_filtered (stream
, " [0x%s]> [$%s]",
4252 phex_nz (type_die
.cu_off
, 0),
4253 locexpr_regname (arch
, reg
));
4257 case DW_OP_GNU_convert
:
4258 case DW_OP_GNU_reinterpret
:
4262 data
= safe_read_uleb128 (data
, end
, &ul
);
4263 type_die
.cu_off
= ul
;
4265 if (type_die
.cu_off
== 0)
4266 fprintf_filtered (stream
, "<0>");
4271 type
= dwarf2_get_die_type (type_die
, per_cu
);
4272 fprintf_filtered (stream
, "<");
4273 type_print (type
, "", stream
, -1);
4274 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
4279 case DW_OP_GNU_entry_value
:
4280 data
= safe_read_uleb128 (data
, end
, &ul
);
4281 fputc_filtered ('\n', stream
);
4282 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
4283 start
, data
, data
+ ul
, indent
+ 2,
4288 case DW_OP_GNU_parameter_ref
:
4289 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
4291 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
4294 case DW_OP_GNU_addr_index
:
4295 data
= safe_read_uleb128 (data
, end
, &ul
);
4296 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4297 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
4299 case DW_OP_GNU_const_index
:
4300 data
= safe_read_uleb128 (data
, end
, &ul
);
4301 ul
= dwarf2_read_addr_index (per_cu
, ul
);
4302 fprintf_filtered (stream
, " %s", pulongest (ul
));
4306 fprintf_filtered (stream
, "\n");
4312 /* Describe a single location, which may in turn consist of multiple
4316 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
4317 struct ui_file
*stream
,
4318 const gdb_byte
*data
, size_t size
,
4319 struct objfile
*objfile
, unsigned int addr_size
,
4320 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
4322 const gdb_byte
*end
= data
+ size
;
4323 int first_piece
= 1, bad
= 0;
4327 const gdb_byte
*here
= data
;
4328 int disassemble
= 1;
4333 fprintf_filtered (stream
, _(", and "));
4335 if (!dwarf_always_disassemble
)
4337 data
= locexpr_describe_location_piece (symbol
, stream
,
4338 addr
, objfile
, per_cu
,
4339 data
, end
, addr_size
);
4340 /* If we printed anything, or if we have an empty piece,
4341 then don't disassemble. */
4343 || data
[0] == DW_OP_piece
4344 || data
[0] == DW_OP_bit_piece
)
4349 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
4350 data
= disassemble_dwarf_expression (stream
,
4351 get_objfile_arch (objfile
),
4352 addr_size
, offset_size
, data
,
4354 dwarf_always_disassemble
,
4360 int empty
= data
== here
;
4363 fprintf_filtered (stream
, " ");
4364 if (data
[0] == DW_OP_piece
)
4368 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
4371 fprintf_filtered (stream
, _("an empty %s-byte piece"),
4374 fprintf_filtered (stream
, _(" [%s-byte piece]"),
4377 else if (data
[0] == DW_OP_bit_piece
)
4379 uint64_t bits
, offset
;
4381 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
4382 data
= safe_read_uleb128 (data
, end
, &offset
);
4385 fprintf_filtered (stream
,
4386 _("an empty %s-bit piece"),
4389 fprintf_filtered (stream
,
4390 _(" [%s-bit piece, offset %s bits]"),
4391 pulongest (bits
), pulongest (offset
));
4401 if (bad
|| data
> end
)
4402 error (_("Corrupted DWARF2 expression for \"%s\"."),
4403 SYMBOL_PRINT_NAME (symbol
));
4406 /* Print a natural-language description of SYMBOL to STREAM. This
4407 version is for a symbol with a single location. */
4410 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4411 struct ui_file
*stream
)
4413 struct dwarf2_locexpr_baton
*dlbaton
4414 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4415 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4416 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4417 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4419 locexpr_describe_location_1 (symbol
, addr
, stream
,
4420 dlbaton
->data
, dlbaton
->size
,
4421 objfile
, addr_size
, offset_size
,
4425 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4426 any necessary bytecode in AX. */
4429 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4430 struct agent_expr
*ax
, struct axs_value
*value
)
4432 struct dwarf2_locexpr_baton
*dlbaton
4433 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4434 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4436 if (dlbaton
->size
== 0)
4437 value
->optimized_out
= 1;
4439 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
4440 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4444 /* symbol_computed_ops 'generate_c_location' method. */
4447 locexpr_generate_c_location (struct symbol
*sym
, struct ui_file
*stream
,
4448 struct gdbarch
*gdbarch
,
4449 unsigned char *registers_used
,
4450 CORE_ADDR pc
, const char *result_name
)
4452 struct dwarf2_locexpr_baton
*dlbaton
4453 = (struct dwarf2_locexpr_baton
*) SYMBOL_LOCATION_BATON (sym
);
4454 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4456 if (dlbaton
->size
== 0)
4457 error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym
));
4459 compile_dwarf_expr_to_c (stream
, result_name
,
4460 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4461 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
4465 /* The set of location functions used with the DWARF-2 expression
4467 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
4468 locexpr_read_variable
,
4469 locexpr_read_variable_at_entry
,
4470 locexpr_get_symbol_read_needs
,
4471 locexpr_describe_location
,
4472 0, /* location_has_loclist */
4473 locexpr_tracepoint_var_ref
,
4474 locexpr_generate_c_location
4478 /* Wrapper functions for location lists. These generally find
4479 the appropriate location expression and call something above. */
4481 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4482 evaluator to calculate the location. */
4483 static struct value
*
4484 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4486 struct dwarf2_loclist_baton
*dlbaton
4487 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4489 const gdb_byte
*data
;
4491 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4493 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4494 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4500 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4501 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4504 Function always returns non-NULL value, it may be marked optimized out if
4505 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4506 if it cannot resolve the parameter for any reason. */
4508 static struct value
*
4509 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4511 struct dwarf2_loclist_baton
*dlbaton
4512 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4513 const gdb_byte
*data
;
4517 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4518 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4520 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4522 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4524 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4527 /* Implementation of get_symbol_read_needs from
4528 symbol_computed_ops. */
4530 static enum symbol_needs_kind
4531 loclist_symbol_needs (struct symbol
*symbol
)
4533 /* If there's a location list, then assume we need to have a frame
4534 to choose the appropriate location expression. With tracking of
4535 global variables this is not necessarily true, but such tracking
4536 is disabled in GCC at the moment until we figure out how to
4539 return SYMBOL_NEEDS_FRAME
;
4542 /* Print a natural-language description of SYMBOL to STREAM. This
4543 version applies when there is a list of different locations, each
4544 with a specified address range. */
4547 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4548 struct ui_file
*stream
)
4550 struct dwarf2_loclist_baton
*dlbaton
4551 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4552 const gdb_byte
*loc_ptr
, *buf_end
;
4553 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4554 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4555 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4556 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4557 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4558 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4559 /* Adjust base_address for relocatable objects. */
4560 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4561 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4564 loc_ptr
= dlbaton
->data
;
4565 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4567 fprintf_filtered (stream
, _("multi-location:\n"));
4569 /* Iterate through locations until we run out. */
4572 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4574 enum debug_loc_kind kind
;
4575 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4577 if (dlbaton
->from_dwo
)
4578 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4579 loc_ptr
, buf_end
, &new_ptr
,
4580 &low
, &high
, byte_order
);
4582 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4584 byte_order
, addr_size
,
4589 case DEBUG_LOC_END_OF_LIST
:
4592 case DEBUG_LOC_BASE_ADDRESS
:
4593 base_address
= high
+ base_offset
;
4594 fprintf_filtered (stream
, _(" Base address %s"),
4595 paddress (gdbarch
, base_address
));
4597 case DEBUG_LOC_START_END
:
4598 case DEBUG_LOC_START_LENGTH
:
4600 case DEBUG_LOC_BUFFER_OVERFLOW
:
4601 case DEBUG_LOC_INVALID_ENTRY
:
4602 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4603 SYMBOL_PRINT_NAME (symbol
));
4605 gdb_assert_not_reached ("bad debug_loc_kind");
4608 /* Otherwise, a location expression entry. */
4609 low
+= base_address
;
4610 high
+= base_address
;
4612 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
);
4613 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
);
4615 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4618 /* (It would improve readability to print only the minimum
4619 necessary digits of the second number of the range.) */
4620 fprintf_filtered (stream
, _(" Range %s-%s: "),
4621 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4623 /* Now describe this particular location. */
4624 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4625 objfile
, addr_size
, offset_size
,
4628 fprintf_filtered (stream
, "\n");
4634 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4635 any necessary bytecode in AX. */
4637 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4638 struct agent_expr
*ax
, struct axs_value
*value
)
4640 struct dwarf2_loclist_baton
*dlbaton
4641 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (symbol
);
4642 const gdb_byte
*data
;
4644 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4646 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4648 value
->optimized_out
= 1;
4650 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
4654 /* symbol_computed_ops 'generate_c_location' method. */
4657 loclist_generate_c_location (struct symbol
*sym
, struct ui_file
*stream
,
4658 struct gdbarch
*gdbarch
,
4659 unsigned char *registers_used
,
4660 CORE_ADDR pc
, const char *result_name
)
4662 struct dwarf2_loclist_baton
*dlbaton
4663 = (struct dwarf2_loclist_baton
*) SYMBOL_LOCATION_BATON (sym
);
4664 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4665 const gdb_byte
*data
;
4668 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4670 error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym
));
4672 compile_dwarf_expr_to_c (stream
, result_name
,
4673 sym
, pc
, gdbarch
, registers_used
, addr_size
,
4678 /* The set of location functions used with the DWARF-2 expression
4679 evaluator and location lists. */
4680 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4681 loclist_read_variable
,
4682 loclist_read_variable_at_entry
,
4683 loclist_symbol_needs
,
4684 loclist_describe_location
,
4685 1, /* location_has_loclist */
4686 loclist_tracepoint_var_ref
,
4687 loclist_generate_c_location
4690 /* Provide a prototype to silence -Wmissing-prototypes. */
4691 extern initialize_file_ftype _initialize_dwarf2loc
;
4694 _initialize_dwarf2loc (void)
4696 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4697 &entry_values_debug
,
4698 _("Set entry values and tail call frames "
4700 _("Show entry values and tail call frames "
4702 _("When non-zero, the process of determining "
4703 "parameter values from function entry point "
4704 "and tail call frames will be printed."),
4706 show_entry_values_debug
,
4707 &setdebuglist
, &showdebuglist
);