1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003-2013 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/>. */
33 #include "exceptions.h"
38 #include "dwarf2expr.h"
39 #include "dwarf2loc.h"
40 #include "dwarf2-frame.h"
42 #include "gdb_string.h"
43 #include "gdb_assert.h"
47 extern int dwarf2_always_disassemble
;
49 static void dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
50 const gdb_byte
**start
, size_t *length
);
52 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
;
54 static struct value
*dwarf2_evaluate_loc_desc_full (struct type
*type
,
55 struct frame_info
*frame
,
58 struct dwarf2_per_cu_data
*per_cu
,
61 /* Until these have formal names, we define these here.
62 ref: http://gcc.gnu.org/wiki/DebugFission
63 Each entry in .debug_loc.dwo begins with a byte that describes the entry,
64 and is then followed by data specific to that entry. */
68 /* Indicates the end of the list of entries. */
69 DEBUG_LOC_END_OF_LIST
= 0,
71 /* This is followed by an unsigned LEB128 number that is an index into
72 .debug_addr and specifies the base address for all following entries. */
73 DEBUG_LOC_BASE_ADDRESS
= 1,
75 /* This is followed by two unsigned LEB128 numbers that are indices into
76 .debug_addr and specify the beginning and ending addresses, and then
77 a normal location expression as in .debug_loc. */
78 DEBUG_LOC_START_END
= 2,
80 /* This is followed by an unsigned LEB128 number that is an index into
81 .debug_addr and specifies the beginning address, and a 4 byte unsigned
82 number that specifies the length, and then a normal location expression
84 DEBUG_LOC_START_LENGTH
= 3,
86 /* An internal value indicating there is insufficient data. */
87 DEBUG_LOC_BUFFER_OVERFLOW
= -1,
89 /* An internal value indicating an invalid kind of entry was found. */
90 DEBUG_LOC_INVALID_ENTRY
= -2
93 /* Decode the addresses in a non-dwo .debug_loc entry.
94 A pointer to the next byte to examine is returned in *NEW_PTR.
95 The encoded low,high addresses are return in *LOW,*HIGH.
96 The result indicates the kind of entry found. */
98 static enum debug_loc_kind
99 decode_debug_loc_addresses (const gdb_byte
*loc_ptr
, const gdb_byte
*buf_end
,
100 const gdb_byte
**new_ptr
,
101 CORE_ADDR
*low
, CORE_ADDR
*high
,
102 enum bfd_endian byte_order
,
103 unsigned int addr_size
,
106 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
108 if (buf_end
- loc_ptr
< 2 * addr_size
)
109 return DEBUG_LOC_BUFFER_OVERFLOW
;
112 *low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
114 *low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
115 loc_ptr
+= addr_size
;
118 *high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
120 *high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
121 loc_ptr
+= addr_size
;
125 /* A base-address-selection entry. */
126 if ((*low
& base_mask
) == base_mask
)
127 return DEBUG_LOC_BASE_ADDRESS
;
129 /* An end-of-list entry. */
130 if (*low
== 0 && *high
== 0)
131 return DEBUG_LOC_END_OF_LIST
;
133 return DEBUG_LOC_START_END
;
136 /* Decode the addresses in .debug_loc.dwo entry.
137 A pointer to the next byte to examine is returned in *NEW_PTR.
138 The encoded low,high addresses are return in *LOW,*HIGH.
139 The result indicates the kind of entry found. */
141 static enum debug_loc_kind
142 decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data
*per_cu
,
143 const gdb_byte
*loc_ptr
,
144 const gdb_byte
*buf_end
,
145 const gdb_byte
**new_ptr
,
146 CORE_ADDR
*low
, CORE_ADDR
*high
,
147 enum bfd_endian byte_order
)
149 uint64_t low_index
, high_index
;
151 if (loc_ptr
== buf_end
)
152 return DEBUG_LOC_BUFFER_OVERFLOW
;
156 case DEBUG_LOC_END_OF_LIST
:
158 return DEBUG_LOC_END_OF_LIST
;
159 case DEBUG_LOC_BASE_ADDRESS
:
161 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
163 return DEBUG_LOC_BUFFER_OVERFLOW
;
164 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
166 return DEBUG_LOC_BASE_ADDRESS
;
167 case DEBUG_LOC_START_END
:
168 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
170 return DEBUG_LOC_BUFFER_OVERFLOW
;
171 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
172 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &high_index
);
174 return DEBUG_LOC_BUFFER_OVERFLOW
;
175 *high
= dwarf2_read_addr_index (per_cu
, high_index
);
177 return DEBUG_LOC_START_END
;
178 case DEBUG_LOC_START_LENGTH
:
179 loc_ptr
= gdb_read_uleb128 (loc_ptr
, buf_end
, &low_index
);
181 return DEBUG_LOC_BUFFER_OVERFLOW
;
182 *low
= dwarf2_read_addr_index (per_cu
, low_index
);
183 if (loc_ptr
+ 4 > buf_end
)
184 return DEBUG_LOC_BUFFER_OVERFLOW
;
186 *high
+= extract_unsigned_integer (loc_ptr
, 4, byte_order
);
187 *new_ptr
= loc_ptr
+ 4;
188 return DEBUG_LOC_START_LENGTH
;
190 return DEBUG_LOC_INVALID_ENTRY
;
194 /* A function for dealing with location lists. Given a
195 symbol baton (BATON) and a pc value (PC), find the appropriate
196 location expression, set *LOCEXPR_LENGTH, and return a pointer
197 to the beginning of the expression. Returns NULL on failure.
199 For now, only return the first matching location expression; there
200 can be more than one in the list. */
203 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
204 size_t *locexpr_length
, CORE_ADDR pc
)
206 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
207 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
208 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
209 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
210 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
211 /* Adjust base_address for relocatable objects. */
212 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (baton
->per_cu
);
213 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
214 const gdb_byte
*loc_ptr
, *buf_end
;
216 loc_ptr
= baton
->data
;
217 buf_end
= baton
->data
+ baton
->size
;
221 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
223 enum debug_loc_kind kind
;
224 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
227 kind
= decode_debug_loc_dwo_addresses (baton
->per_cu
,
228 loc_ptr
, buf_end
, &new_ptr
,
229 &low
, &high
, byte_order
);
231 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
233 byte_order
, addr_size
,
238 case DEBUG_LOC_END_OF_LIST
:
241 case DEBUG_LOC_BASE_ADDRESS
:
242 base_address
= high
+ base_offset
;
244 case DEBUG_LOC_START_END
:
245 case DEBUG_LOC_START_LENGTH
:
247 case DEBUG_LOC_BUFFER_OVERFLOW
:
248 case DEBUG_LOC_INVALID_ENTRY
:
249 error (_("dwarf2_find_location_expression: "
250 "Corrupted DWARF expression."));
252 gdb_assert_not_reached ("bad debug_loc_kind");
255 /* Otherwise, a location expression entry.
256 If the entry is from a DWO, don't add base address: the entry is
257 from .debug_addr which has absolute addresses. */
258 if (! baton
->from_dwo
)
261 high
+= base_address
;
264 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
267 if (low
== high
&& pc
== low
)
269 /* This is entry PC record present only at entry point
270 of a function. Verify it is really the function entry point. */
272 struct block
*pc_block
= block_for_pc (pc
);
273 struct symbol
*pc_func
= NULL
;
276 pc_func
= block_linkage_function (pc_block
);
278 if (pc_func
&& pc
== BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func
)))
280 *locexpr_length
= length
;
285 if (pc
>= low
&& pc
< high
)
287 *locexpr_length
= length
;
295 /* This is the baton used when performing dwarf2 expression
297 struct dwarf_expr_baton
299 struct frame_info
*frame
;
300 struct dwarf2_per_cu_data
*per_cu
;
303 /* Helper functions for dwarf2_evaluate_loc_desc. */
305 /* Using the frame specified in BATON, return the value of register
306 REGNUM, treated as a pointer. */
308 dwarf_expr_read_reg (void *baton
, int dwarf_regnum
)
310 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
311 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
315 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
316 result
= address_from_register (builtin_type (gdbarch
)->builtin_data_ptr
,
317 regnum
, debaton
->frame
);
321 /* Read memory at ADDR (length LEN) into BUF. */
324 dwarf_expr_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
326 read_memory (addr
, buf
, len
);
329 /* Using the frame specified in BATON, find the location expression
330 describing the frame base. Return a pointer to it in START and
331 its length in LENGTH. */
333 dwarf_expr_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
335 /* FIXME: cagney/2003-03-26: This code should be using
336 get_frame_base_address(), and then implement a dwarf2 specific
338 struct symbol
*framefunc
;
339 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
340 struct block
*bl
= get_frame_block (debaton
->frame
, NULL
);
343 error (_("frame address is not available."));
345 /* Use block_linkage_function, which returns a real (not inlined)
346 function, instead of get_frame_function, which may return an
348 framefunc
= block_linkage_function (bl
);
350 /* If we found a frame-relative symbol then it was certainly within
351 some function associated with a frame. If we can't find the frame,
352 something has gone wrong. */
353 gdb_assert (framefunc
!= NULL
);
355 dwarf_expr_frame_base_1 (framefunc
,
356 get_frame_address_in_block (debaton
->frame
),
360 /* Implement find_frame_base_location method for LOC_BLOCK functions using
361 DWARF expression for its DW_AT_frame_base. */
364 locexpr_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
365 const gdb_byte
**start
, size_t *length
)
367 struct dwarf2_locexpr_baton
*symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
369 *length
= symbaton
->size
;
370 *start
= symbaton
->data
;
373 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
374 function uses DWARF expression for its DW_AT_frame_base. */
376 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
=
378 locexpr_find_frame_base_location
381 /* Implement find_frame_base_location method for LOC_BLOCK functions using
382 DWARF location list for its DW_AT_frame_base. */
385 loclist_find_frame_base_location (struct symbol
*framefunc
, CORE_ADDR pc
,
386 const gdb_byte
**start
, size_t *length
)
388 struct dwarf2_loclist_baton
*symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
390 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
393 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
394 function uses DWARF location list for its DW_AT_frame_base. */
396 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
=
398 loclist_find_frame_base_location
402 dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
403 const gdb_byte
**start
, size_t *length
)
405 if (SYMBOL_BLOCK_OPS (framefunc
) != NULL
)
407 const struct symbol_block_ops
*ops_block
= SYMBOL_BLOCK_OPS (framefunc
);
409 ops_block
->find_frame_base_location (framefunc
, pc
, start
, length
);
415 error (_("Could not find the frame base for \"%s\"."),
416 SYMBOL_NATURAL_NAME (framefunc
));
419 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
420 the frame in BATON. */
423 dwarf_expr_frame_cfa (void *baton
)
425 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
427 return dwarf2_frame_cfa (debaton
->frame
);
430 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
431 the frame in BATON. */
434 dwarf_expr_frame_pc (void *baton
)
436 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
438 return get_frame_address_in_block (debaton
->frame
);
441 /* Using the objfile specified in BATON, find the address for the
442 current thread's thread-local storage with offset OFFSET. */
444 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
446 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
447 struct objfile
*objfile
= dwarf2_per_cu_objfile (debaton
->per_cu
);
449 return target_translate_tls_address (objfile
, offset
);
452 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
453 current CU (as is PER_CU). State of the CTX is not affected by the
457 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
458 struct dwarf2_per_cu_data
*per_cu
,
459 CORE_ADDR (*get_frame_pc
) (void *baton
),
462 struct dwarf2_locexpr_baton block
;
464 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
, get_frame_pc
, baton
);
466 /* DW_OP_call_ref is currently not supported. */
467 gdb_assert (block
.per_cu
== per_cu
);
469 dwarf_expr_eval (ctx
, block
.data
, block
.size
);
472 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
475 dwarf_expr_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
477 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
479 per_cu_dwarf_call (ctx
, die_offset
, debaton
->per_cu
,
480 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
483 /* Callback function for dwarf2_evaluate_loc_desc. */
486 dwarf_expr_get_base_type (struct dwarf_expr_context
*ctx
,
487 cu_offset die_offset
)
489 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
491 return dwarf2_get_die_type (die_offset
, debaton
->per_cu
);
494 /* See dwarf2loc.h. */
496 unsigned int entry_values_debug
= 0;
498 /* Helper to set entry_values_debug. */
501 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
502 struct cmd_list_element
*c
, const char *value
)
504 fprintf_filtered (file
,
505 _("Entry values and tail call frames debugging is %s.\n"),
509 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
510 CALLER_FRAME (for registers) can be NULL if it is not known. This function
511 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
514 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
515 struct call_site
*call_site
,
516 struct frame_info
*caller_frame
)
518 switch (FIELD_LOC_KIND (call_site
->target
))
520 case FIELD_LOC_KIND_DWARF_BLOCK
:
522 struct dwarf2_locexpr_baton
*dwarf_block
;
524 struct type
*caller_core_addr_type
;
525 struct gdbarch
*caller_arch
;
527 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
528 if (dwarf_block
== NULL
)
530 struct bound_minimal_symbol msym
;
532 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
533 throw_error (NO_ENTRY_VALUE_ERROR
,
534 _("DW_AT_GNU_call_site_target is not specified "
536 paddress (call_site_gdbarch
, call_site
->pc
),
537 (msym
.minsym
== NULL
? "???"
538 : SYMBOL_PRINT_NAME (msym
.minsym
)));
541 if (caller_frame
== NULL
)
543 struct bound_minimal_symbol msym
;
545 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
546 throw_error (NO_ENTRY_VALUE_ERROR
,
547 _("DW_AT_GNU_call_site_target DWARF block resolving "
548 "requires known frame which is currently not "
549 "available at %s in %s"),
550 paddress (call_site_gdbarch
, call_site
->pc
),
551 (msym
.minsym
== NULL
? "???"
552 : SYMBOL_PRINT_NAME (msym
.minsym
)));
555 caller_arch
= get_frame_arch (caller_frame
);
556 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
557 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
558 dwarf_block
->data
, dwarf_block
->size
,
559 dwarf_block
->per_cu
);
560 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
562 if (VALUE_LVAL (val
) == lval_memory
)
563 return value_address (val
);
565 return value_as_address (val
);
568 case FIELD_LOC_KIND_PHYSNAME
:
570 const char *physname
;
571 struct minimal_symbol
*msym
;
573 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
575 /* Handle both the mangled and demangled PHYSNAME. */
576 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
579 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1).minsym
;
580 throw_error (NO_ENTRY_VALUE_ERROR
,
581 _("Cannot find function \"%s\" for a call site target "
583 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
584 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
587 return SYMBOL_VALUE_ADDRESS (msym
);
590 case FIELD_LOC_KIND_PHYSADDR
:
591 return FIELD_STATIC_PHYSADDR (call_site
->target
);
594 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
598 /* Convert function entry point exact address ADDR to the function which is
599 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
600 NO_ENTRY_VALUE_ERROR otherwise. */
602 static struct symbol
*
603 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
605 struct symbol
*sym
= find_pc_function (addr
);
608 if (sym
== NULL
|| BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
609 throw_error (NO_ENTRY_VALUE_ERROR
,
610 _("DW_TAG_GNU_call_site resolving failed to find function "
611 "name for address %s"),
612 paddress (gdbarch
, addr
));
614 type
= SYMBOL_TYPE (sym
);
615 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
616 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
621 /* Verify function with entry point exact address ADDR can never call itself
622 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
623 can call itself via tail calls.
625 If a funtion can tail call itself its entry value based parameters are
626 unreliable. There is no verification whether the value of some/all
627 parameters is unchanged through the self tail call, we expect if there is
628 a self tail call all the parameters can be modified. */
631 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
633 struct obstack addr_obstack
;
634 struct cleanup
*old_chain
;
637 /* Track here CORE_ADDRs which were already visited. */
640 /* The verification is completely unordered. Track here function addresses
641 which still need to be iterated. */
642 VEC (CORE_ADDR
) *todo
= NULL
;
644 obstack_init (&addr_obstack
);
645 old_chain
= make_cleanup_obstack_free (&addr_obstack
);
646 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
647 &addr_obstack
, hashtab_obstack_allocate
,
649 make_cleanup_htab_delete (addr_hash
);
651 make_cleanup (VEC_cleanup (CORE_ADDR
), &todo
);
653 VEC_safe_push (CORE_ADDR
, todo
, verify_addr
);
654 while (!VEC_empty (CORE_ADDR
, todo
))
656 struct symbol
*func_sym
;
657 struct call_site
*call_site
;
659 addr
= VEC_pop (CORE_ADDR
, todo
);
661 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
663 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
664 call_site
; call_site
= call_site
->tail_call_next
)
666 CORE_ADDR target_addr
;
669 /* CALLER_FRAME with registers is not available for tail-call jumped
671 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
673 if (target_addr
== verify_addr
)
675 struct bound_minimal_symbol msym
;
677 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
678 throw_error (NO_ENTRY_VALUE_ERROR
,
679 _("DW_OP_GNU_entry_value resolving has found "
680 "function \"%s\" at %s can call itself via tail "
682 (msym
.minsym
== NULL
? "???"
683 : SYMBOL_PRINT_NAME (msym
.minsym
)),
684 paddress (gdbarch
, verify_addr
));
687 slot
= htab_find_slot (addr_hash
, &target_addr
, INSERT
);
690 *slot
= obstack_copy (&addr_obstack
, &target_addr
,
691 sizeof (target_addr
));
692 VEC_safe_push (CORE_ADDR
, todo
, target_addr
);
697 do_cleanups (old_chain
);
700 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
701 ENTRY_VALUES_DEBUG. */
704 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
706 CORE_ADDR addr
= call_site
->pc
;
707 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (addr
- 1);
709 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
710 (msym
.minsym
== NULL
? "???"
711 : SYMBOL_PRINT_NAME (msym
.minsym
)));
715 /* vec.h needs single word type name, typedef it. */
716 typedef struct call_site
*call_sitep
;
718 /* Define VEC (call_sitep) functions. */
719 DEF_VEC_P (call_sitep
);
721 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
722 only top callers and bottom callees which are present in both. GDBARCH is
723 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
724 no remaining possibilities to provide unambiguous non-trivial result.
725 RESULTP should point to NULL on the first (initialization) call. Caller is
726 responsible for xfree of any RESULTP data. */
729 chain_candidate (struct gdbarch
*gdbarch
, struct call_site_chain
**resultp
,
730 VEC (call_sitep
) *chain
)
732 struct call_site_chain
*result
= *resultp
;
733 long length
= VEC_length (call_sitep
, chain
);
734 int callers
, callees
, idx
;
738 /* Create the initial chain containing all the passed PCs. */
740 result
= xmalloc (sizeof (*result
) + sizeof (*result
->call_site
)
742 result
->length
= length
;
743 result
->callers
= result
->callees
= length
;
744 memcpy (result
->call_site
, VEC_address (call_sitep
, chain
),
745 sizeof (*result
->call_site
) * length
);
748 if (entry_values_debug
)
750 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
751 for (idx
= 0; idx
< length
; idx
++)
752 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
753 fputc_unfiltered ('\n', gdb_stdlog
);
759 if (entry_values_debug
)
761 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
762 for (idx
= 0; idx
< length
; idx
++)
763 tailcall_dump (gdbarch
, VEC_index (call_sitep
, chain
, idx
));
764 fputc_unfiltered ('\n', gdb_stdlog
);
767 /* Intersect callers. */
769 callers
= min (result
->callers
, length
);
770 for (idx
= 0; idx
< callers
; idx
++)
771 if (result
->call_site
[idx
] != VEC_index (call_sitep
, chain
, idx
))
773 result
->callers
= idx
;
777 /* Intersect callees. */
779 callees
= min (result
->callees
, length
);
780 for (idx
= 0; idx
< callees
; idx
++)
781 if (result
->call_site
[result
->length
- 1 - idx
]
782 != VEC_index (call_sitep
, chain
, length
- 1 - idx
))
784 result
->callees
= idx
;
788 if (entry_values_debug
)
790 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
791 for (idx
= 0; idx
< result
->callers
; idx
++)
792 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
793 fputs_unfiltered (" |", gdb_stdlog
);
794 for (idx
= 0; idx
< result
->callees
; idx
++)
795 tailcall_dump (gdbarch
, result
->call_site
[result
->length
796 - result
->callees
+ idx
]);
797 fputc_unfiltered ('\n', gdb_stdlog
);
800 if (result
->callers
== 0 && result
->callees
== 0)
802 /* There are no common callers or callees. It could be also a direct
803 call (which has length 0) with ambiguous possibility of an indirect
804 call - CALLERS == CALLEES == 0 is valid during the first allocation
805 but any subsequence processing of such entry means ambiguity. */
811 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
812 PC again. In such case there must be two different code paths to reach
813 it, therefore some of the former determined intermediate PCs must differ
814 and the unambiguous chain gets shortened. */
815 gdb_assert (result
->callers
+ result
->callees
< result
->length
);
818 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
819 assumed frames between them use GDBARCH. Use depth first search so we can
820 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
821 would have needless GDB stack overhead. Caller is responsible for xfree of
822 the returned result. Any unreliability results in thrown
823 NO_ENTRY_VALUE_ERROR. */
825 static struct call_site_chain
*
826 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
829 CORE_ADDR save_callee_pc
= callee_pc
;
830 struct obstack addr_obstack
;
831 struct cleanup
*back_to_retval
, *back_to_workdata
;
832 struct call_site_chain
*retval
= NULL
;
833 struct call_site
*call_site
;
835 /* Mark CALL_SITEs so we do not visit the same ones twice. */
838 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
839 call_site nor any possible call_site at CALLEE_PC's function is there.
840 Any CALL_SITE in CHAIN will be iterated to its siblings - via
841 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
842 VEC (call_sitep
) *chain
= NULL
;
844 /* We are not interested in the specific PC inside the callee function. */
845 callee_pc
= get_pc_function_start (callee_pc
);
847 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
848 paddress (gdbarch
, save_callee_pc
));
850 back_to_retval
= make_cleanup (free_current_contents
, &retval
);
852 obstack_init (&addr_obstack
);
853 back_to_workdata
= make_cleanup_obstack_free (&addr_obstack
);
854 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
855 &addr_obstack
, hashtab_obstack_allocate
,
857 make_cleanup_htab_delete (addr_hash
);
859 make_cleanup (VEC_cleanup (call_sitep
), &chain
);
861 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
862 at the target's function. All the possible tail call sites in the
863 target's function will get iterated as already pushed into CHAIN via their
865 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
869 CORE_ADDR target_func_addr
;
870 struct call_site
*target_call_site
;
872 /* CALLER_FRAME with registers is not available for tail-call jumped
874 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
876 if (target_func_addr
== callee_pc
)
878 chain_candidate (gdbarch
, &retval
, chain
);
882 /* There is no way to reach CALLEE_PC again as we would prevent
883 entering it twice as being already marked in ADDR_HASH. */
884 target_call_site
= NULL
;
888 struct symbol
*target_func
;
890 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
891 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
896 /* Attempt to visit TARGET_CALL_SITE. */
898 if (target_call_site
)
902 slot
= htab_find_slot (addr_hash
, &target_call_site
->pc
, INSERT
);
905 /* Successfully entered TARGET_CALL_SITE. */
907 *slot
= &target_call_site
->pc
;
908 VEC_safe_push (call_sitep
, chain
, target_call_site
);
913 /* Backtrack (without revisiting the originating call_site). Try the
914 callers's sibling; if there isn't any try the callers's callers's
917 target_call_site
= NULL
;
918 while (!VEC_empty (call_sitep
, chain
))
920 call_site
= VEC_pop (call_sitep
, chain
);
922 gdb_assert (htab_find_slot (addr_hash
, &call_site
->pc
,
924 htab_remove_elt (addr_hash
, &call_site
->pc
);
926 target_call_site
= call_site
->tail_call_next
;
927 if (target_call_site
)
931 while (target_call_site
);
933 if (VEC_empty (call_sitep
, chain
))
936 call_site
= VEC_last (call_sitep
, chain
);
941 struct bound_minimal_symbol msym_caller
, msym_callee
;
943 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
944 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
945 throw_error (NO_ENTRY_VALUE_ERROR
,
946 _("There are no unambiguously determinable intermediate "
947 "callers or callees between caller function \"%s\" at %s "
948 "and callee function \"%s\" at %s"),
949 (msym_caller
.minsym
== NULL
950 ? "???" : SYMBOL_PRINT_NAME (msym_caller
.minsym
)),
951 paddress (gdbarch
, caller_pc
),
952 (msym_callee
.minsym
== NULL
953 ? "???" : SYMBOL_PRINT_NAME (msym_callee
.minsym
)),
954 paddress (gdbarch
, callee_pc
));
957 do_cleanups (back_to_workdata
);
958 discard_cleanups (back_to_retval
);
962 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
963 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
964 constructed return NULL. Caller is responsible for xfree of the returned
967 struct call_site_chain
*
968 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
971 volatile struct gdb_exception e
;
972 struct call_site_chain
*retval
= NULL
;
974 TRY_CATCH (e
, RETURN_MASK_ERROR
)
976 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
980 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
982 if (entry_values_debug
)
983 exception_print (gdb_stdout
, e
);
993 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
996 call_site_parameter_matches (struct call_site_parameter
*parameter
,
997 enum call_site_parameter_kind kind
,
998 union call_site_parameter_u kind_u
)
1000 if (kind
== parameter
->kind
)
1003 case CALL_SITE_PARAMETER_DWARF_REG
:
1004 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1005 case CALL_SITE_PARAMETER_FB_OFFSET
:
1006 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1007 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1008 return kind_u
.param_offset
.cu_off
== parameter
->u
.param_offset
.cu_off
;
1013 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1014 FRAME is for callee.
1016 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1019 static struct call_site_parameter
*
1020 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1021 enum call_site_parameter_kind kind
,
1022 union call_site_parameter_u kind_u
,
1023 struct dwarf2_per_cu_data
**per_cu_return
)
1025 CORE_ADDR func_addr
, caller_pc
;
1026 struct gdbarch
*gdbarch
;
1027 struct frame_info
*caller_frame
;
1028 struct call_site
*call_site
;
1030 /* Initialize it just to avoid a GCC false warning. */
1031 struct call_site_parameter
*parameter
= NULL
;
1032 CORE_ADDR target_addr
;
1034 while (get_frame_type (frame
) == INLINE_FRAME
)
1036 frame
= get_prev_frame (frame
);
1037 gdb_assert (frame
!= NULL
);
1040 func_addr
= get_frame_func (frame
);
1041 gdbarch
= get_frame_arch (frame
);
1042 caller_frame
= get_prev_frame (frame
);
1043 if (gdbarch
!= frame_unwind_arch (frame
))
1045 struct bound_minimal_symbol msym
1046 = lookup_minimal_symbol_by_pc (func_addr
);
1047 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1049 throw_error (NO_ENTRY_VALUE_ERROR
,
1050 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1051 "(of %s (%s)) does not match caller gdbarch %s"),
1052 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1053 paddress (gdbarch
, func_addr
),
1054 (msym
.minsym
== NULL
? "???"
1055 : SYMBOL_PRINT_NAME (msym
.minsym
)),
1056 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1059 if (caller_frame
== NULL
)
1061 struct bound_minimal_symbol msym
1062 = lookup_minimal_symbol_by_pc (func_addr
);
1064 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_GNU_entry_value resolving "
1065 "requires caller of %s (%s)"),
1066 paddress (gdbarch
, func_addr
),
1067 (msym
.minsym
== NULL
? "???"
1068 : SYMBOL_PRINT_NAME (msym
.minsym
)));
1070 caller_pc
= get_frame_pc (caller_frame
);
1071 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1073 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1074 if (target_addr
!= func_addr
)
1076 struct minimal_symbol
*target_msym
, *func_msym
;
1078 target_msym
= lookup_minimal_symbol_by_pc (target_addr
).minsym
;
1079 func_msym
= lookup_minimal_symbol_by_pc (func_addr
).minsym
;
1080 throw_error (NO_ENTRY_VALUE_ERROR
,
1081 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1082 "but the called frame is for %s at %s"),
1083 (target_msym
== NULL
? "???"
1084 : SYMBOL_PRINT_NAME (target_msym
)),
1085 paddress (gdbarch
, target_addr
),
1086 func_msym
== NULL
? "???" : SYMBOL_PRINT_NAME (func_msym
),
1087 paddress (gdbarch
, func_addr
));
1090 /* No entry value based parameters would be reliable if this function can
1091 call itself via tail calls. */
1092 func_verify_no_selftailcall (gdbarch
, func_addr
);
1094 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1096 parameter
= &call_site
->parameter
[iparams
];
1097 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1100 if (iparams
== call_site
->parameter_count
)
1102 struct minimal_symbol
*msym
1103 = lookup_minimal_symbol_by_pc (caller_pc
).minsym
;
1105 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1106 determine its value. */
1107 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1108 "at DW_TAG_GNU_call_site %s at %s"),
1109 paddress (gdbarch
, caller_pc
),
1110 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
1113 *per_cu_return
= call_site
->per_cu
;
1117 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1118 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1119 DW_AT_GNU_call_site_data_value (dereferenced) block.
1121 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1124 Function always returns non-NULL, non-optimized out value. It throws
1125 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1127 static struct value
*
1128 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1129 CORE_ADDR deref_size
, struct type
*type
,
1130 struct frame_info
*caller_frame
,
1131 struct dwarf2_per_cu_data
*per_cu
)
1133 const gdb_byte
*data_src
;
1137 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1138 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1140 /* DEREF_SIZE size is not verified here. */
1141 if (data_src
== NULL
)
1142 throw_error (NO_ENTRY_VALUE_ERROR
,
1143 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1145 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1146 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1148 data
= alloca (size
+ 1);
1149 memcpy (data
, data_src
, size
);
1150 data
[size
] = DW_OP_stack_value
;
1152 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1155 /* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
1156 Choose DEREF_SIZE value of that parameter. Search caller of the CTX's
1157 frame. CTX must be of dwarf_expr_ctx_funcs kind.
1159 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1160 can be more simple as it does not support cross-CU DWARF executions. */
1163 dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
1164 enum call_site_parameter_kind kind
,
1165 union call_site_parameter_u kind_u
,
1168 struct dwarf_expr_baton
*debaton
;
1169 struct frame_info
*frame
, *caller_frame
;
1170 struct dwarf2_per_cu_data
*caller_per_cu
;
1171 struct dwarf_expr_baton baton_local
;
1172 struct dwarf_expr_context saved_ctx
;
1173 struct call_site_parameter
*parameter
;
1174 const gdb_byte
*data_src
;
1177 gdb_assert (ctx
->funcs
== &dwarf_expr_ctx_funcs
);
1178 debaton
= ctx
->baton
;
1179 frame
= debaton
->frame
;
1180 caller_frame
= get_prev_frame (frame
);
1182 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1184 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1185 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1187 /* DEREF_SIZE size is not verified here. */
1188 if (data_src
== NULL
)
1189 throw_error (NO_ENTRY_VALUE_ERROR
,
1190 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1192 baton_local
.frame
= caller_frame
;
1193 baton_local
.per_cu
= caller_per_cu
;
1195 saved_ctx
.gdbarch
= ctx
->gdbarch
;
1196 saved_ctx
.addr_size
= ctx
->addr_size
;
1197 saved_ctx
.offset
= ctx
->offset
;
1198 saved_ctx
.baton
= ctx
->baton
;
1199 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (baton_local
.per_cu
));
1200 ctx
->addr_size
= dwarf2_per_cu_addr_size (baton_local
.per_cu
);
1201 ctx
->offset
= dwarf2_per_cu_text_offset (baton_local
.per_cu
);
1202 ctx
->baton
= &baton_local
;
1204 dwarf_expr_eval (ctx
, data_src
, size
);
1206 ctx
->gdbarch
= saved_ctx
.gdbarch
;
1207 ctx
->addr_size
= saved_ctx
.addr_size
;
1208 ctx
->offset
= saved_ctx
.offset
;
1209 ctx
->baton
= saved_ctx
.baton
;
1212 /* Callback function for dwarf2_evaluate_loc_desc.
1213 Fetch the address indexed by DW_OP_GNU_addr_index. */
1216 dwarf_expr_get_addr_index (void *baton
, unsigned int index
)
1218 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
1220 return dwarf2_read_addr_index (debaton
->per_cu
, index
);
1223 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1224 the indirect method on it, that is use its stored target value, the sole
1225 purpose of entry_data_value_funcs.. */
1227 static struct value
*
1228 entry_data_value_coerce_ref (const struct value
*value
)
1230 struct type
*checked_type
= check_typedef (value_type (value
));
1231 struct value
*target_val
;
1233 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
)
1236 target_val
= value_computed_closure (value
);
1237 value_incref (target_val
);
1241 /* Implement copy_closure. */
1244 entry_data_value_copy_closure (const struct value
*v
)
1246 struct value
*target_val
= value_computed_closure (v
);
1248 value_incref (target_val
);
1252 /* Implement free_closure. */
1255 entry_data_value_free_closure (struct value
*v
)
1257 struct value
*target_val
= value_computed_closure (v
);
1259 value_free (target_val
);
1262 /* Vector for methods for an entry value reference where the referenced value
1263 is stored in the caller. On the first dereference use
1264 DW_AT_GNU_call_site_data_value in the caller. */
1266 static const struct lval_funcs entry_data_value_funcs
=
1270 NULL
, /* check_validity */
1271 NULL
, /* check_any_valid */
1272 NULL
, /* indirect */
1273 entry_data_value_coerce_ref
,
1274 NULL
, /* check_synthetic_pointer */
1275 entry_data_value_copy_closure
,
1276 entry_data_value_free_closure
1279 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1280 are used to match DW_AT_location at the caller's
1281 DW_TAG_GNU_call_site_parameter.
1283 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1284 cannot resolve the parameter for any reason. */
1286 static struct value
*
1287 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1288 enum call_site_parameter_kind kind
,
1289 union call_site_parameter_u kind_u
)
1291 struct type
*checked_type
= check_typedef (type
);
1292 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1293 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1294 struct value
*outer_val
, *target_val
, *val
;
1295 struct call_site_parameter
*parameter
;
1296 struct dwarf2_per_cu_data
*caller_per_cu
;
1299 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1302 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1306 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1307 used and it is not available do not fall back to OUTER_VAL - dereferencing
1308 TYPE_CODE_REF with non-entry data value would give current value - not the
1311 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
1312 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1315 target_val
= dwarf_entry_parameter_to_value (parameter
,
1316 TYPE_LENGTH (target_type
),
1317 target_type
, caller_frame
,
1320 /* value_as_address dereferences TYPE_CODE_REF. */
1321 addr
= extract_typed_address (value_contents (outer_val
), checked_type
);
1323 /* The target entry value has artificial address of the entry value
1325 VALUE_LVAL (target_val
) = lval_memory
;
1326 set_value_address (target_val
, addr
);
1328 release_value (target_val
);
1329 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1330 target_val
/* closure */);
1332 /* Copy the referencing pointer to the new computed value. */
1333 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1334 TYPE_LENGTH (checked_type
));
1335 set_value_lazy (val
, 0);
1340 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1341 SIZE are DWARF block used to match DW_AT_location at the caller's
1342 DW_TAG_GNU_call_site_parameter.
1344 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1345 cannot resolve the parameter for any reason. */
1347 static struct value
*
1348 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1349 const gdb_byte
*block
, size_t block_len
)
1351 union call_site_parameter_u kind_u
;
1353 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1354 if (kind_u
.dwarf_reg
!= -1)
1355 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1358 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1359 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1362 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1363 suppressed during normal operation. The expression can be arbitrary if
1364 there is no caller-callee entry value binding expected. */
1365 throw_error (NO_ENTRY_VALUE_ERROR
,
1366 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1367 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1370 struct piece_closure
1372 /* Reference count. */
1375 /* The CU from which this closure's expression came. */
1376 struct dwarf2_per_cu_data
*per_cu
;
1378 /* The number of pieces used to describe this variable. */
1381 /* The target address size, used only for DWARF_VALUE_STACK. */
1384 /* The pieces themselves. */
1385 struct dwarf_expr_piece
*pieces
;
1388 /* Allocate a closure for a value formed from separately-described
1391 static struct piece_closure
*
1392 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1393 int n_pieces
, struct dwarf_expr_piece
*pieces
,
1396 struct piece_closure
*c
= XZALLOC (struct piece_closure
);
1401 c
->n_pieces
= n_pieces
;
1402 c
->addr_size
= addr_size
;
1403 c
->pieces
= XCALLOC (n_pieces
, struct dwarf_expr_piece
);
1405 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
1406 for (i
= 0; i
< n_pieces
; ++i
)
1407 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1408 value_incref (c
->pieces
[i
].v
.value
);
1413 /* The lowest-level function to extract bits from a byte buffer.
1414 SOURCE is the buffer. It is updated if we read to the end of a
1416 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1417 updated to reflect the number of bits actually read.
1418 NBITS is the number of bits we want to read. It is updated to
1419 reflect the number of bits actually read. This function may read
1421 BITS_BIG_ENDIAN is taken directly from gdbarch.
1422 This function returns the extracted bits. */
1425 extract_bits_primitive (const gdb_byte
**source
,
1426 unsigned int *source_offset_bits
,
1427 int *nbits
, int bits_big_endian
)
1429 unsigned int avail
, mask
, datum
;
1431 gdb_assert (*source_offset_bits
< 8);
1433 avail
= 8 - *source_offset_bits
;
1437 mask
= (1 << avail
) - 1;
1439 if (bits_big_endian
)
1440 datum
>>= 8 - (*source_offset_bits
+ *nbits
);
1442 datum
>>= *source_offset_bits
;
1446 *source_offset_bits
+= avail
;
1447 if (*source_offset_bits
>= 8)
1449 *source_offset_bits
-= 8;
1456 /* Extract some bits from a source buffer and move forward in the
1459 SOURCE is the source buffer. It is updated as bytes are read.
1460 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1462 NBITS is the number of bits to read.
1463 BITS_BIG_ENDIAN is taken directly from gdbarch.
1465 This function returns the bits that were read. */
1468 extract_bits (const gdb_byte
**source
, unsigned int *source_offset_bits
,
1469 int nbits
, int bits_big_endian
)
1473 gdb_assert (nbits
> 0 && nbits
<= 8);
1475 datum
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1481 more
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1483 if (bits_big_endian
)
1493 /* Write some bits into a buffer and move forward in the buffer.
1495 DATUM is the bits to write. The low-order bits of DATUM are used.
1496 DEST is the destination buffer. It is updated as bytes are
1498 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1500 NBITS is the number of valid bits in DATUM.
1501 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1504 insert_bits (unsigned int datum
,
1505 gdb_byte
*dest
, unsigned int dest_offset_bits
,
1506 int nbits
, int bits_big_endian
)
1510 gdb_assert (dest_offset_bits
+ nbits
<= 8);
1512 mask
= (1 << nbits
) - 1;
1513 if (bits_big_endian
)
1515 datum
<<= 8 - (dest_offset_bits
+ nbits
);
1516 mask
<<= 8 - (dest_offset_bits
+ nbits
);
1520 datum
<<= dest_offset_bits
;
1521 mask
<<= dest_offset_bits
;
1524 gdb_assert ((datum
& ~mask
) == 0);
1526 *dest
= (*dest
& ~mask
) | datum
;
1529 /* Copy bits from a source to a destination.
1531 DEST is where the bits should be written.
1532 DEST_OFFSET_BITS is the bit offset into DEST.
1533 SOURCE is the source of bits.
1534 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1535 BIT_COUNT is the number of bits to copy.
1536 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1539 copy_bitwise (gdb_byte
*dest
, unsigned int dest_offset_bits
,
1540 const gdb_byte
*source
, unsigned int source_offset_bits
,
1541 unsigned int bit_count
,
1542 int bits_big_endian
)
1544 unsigned int dest_avail
;
1547 /* Reduce everything to byte-size pieces. */
1548 dest
+= dest_offset_bits
/ 8;
1549 dest_offset_bits
%= 8;
1550 source
+= source_offset_bits
/ 8;
1551 source_offset_bits
%= 8;
1553 dest_avail
= 8 - dest_offset_bits
% 8;
1555 /* See if we can fill the first destination byte. */
1556 if (dest_avail
< bit_count
)
1558 datum
= extract_bits (&source
, &source_offset_bits
, dest_avail
,
1560 insert_bits (datum
, dest
, dest_offset_bits
, dest_avail
, bits_big_endian
);
1562 dest_offset_bits
= 0;
1563 bit_count
-= dest_avail
;
1566 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1567 than 8 bits remaining. */
1568 gdb_assert (dest_offset_bits
% 8 == 0 || bit_count
< 8);
1569 for (; bit_count
>= 8; bit_count
-= 8)
1571 datum
= extract_bits (&source
, &source_offset_bits
, 8, bits_big_endian
);
1572 *dest
++ = (gdb_byte
) datum
;
1575 /* Finally, we may have a few leftover bits. */
1576 gdb_assert (bit_count
<= 8 - dest_offset_bits
% 8);
1579 datum
= extract_bits (&source
, &source_offset_bits
, bit_count
,
1581 insert_bits (datum
, dest
, dest_offset_bits
, bit_count
, bits_big_endian
);
1586 read_pieced_value (struct value
*v
)
1590 ULONGEST bits_to_skip
;
1592 struct piece_closure
*c
1593 = (struct piece_closure
*) value_computed_closure (v
);
1594 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (v
));
1596 size_t buffer_size
= 0;
1597 char *buffer
= NULL
;
1598 struct cleanup
*cleanup
;
1600 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1602 if (value_type (v
) != value_enclosing_type (v
))
1603 internal_error (__FILE__
, __LINE__
,
1604 _("Should not be able to create a lazy value with "
1605 "an enclosing type"));
1607 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1609 contents
= value_contents_raw (v
);
1610 bits_to_skip
= 8 * value_offset (v
);
1611 if (value_bitsize (v
))
1613 bits_to_skip
+= value_bitpos (v
);
1614 type_len
= value_bitsize (v
);
1617 type_len
= 8 * TYPE_LENGTH (value_type (v
));
1619 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1621 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1622 size_t this_size
, this_size_bits
;
1623 long dest_offset_bits
, source_offset_bits
, source_offset
;
1624 const gdb_byte
*intermediate_buffer
;
1626 /* Compute size, source, and destination offsets for copying, in
1628 this_size_bits
= p
->size
;
1629 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1631 bits_to_skip
-= this_size_bits
;
1634 if (this_size_bits
> type_len
- offset
)
1635 this_size_bits
= type_len
- offset
;
1636 if (bits_to_skip
> 0)
1638 dest_offset_bits
= 0;
1639 source_offset_bits
= bits_to_skip
;
1640 this_size_bits
-= bits_to_skip
;
1645 dest_offset_bits
= offset
;
1646 source_offset_bits
= 0;
1649 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1650 source_offset
= source_offset_bits
/ 8;
1651 if (buffer_size
< this_size
)
1653 buffer_size
= this_size
;
1654 buffer
= xrealloc (buffer
, buffer_size
);
1656 intermediate_buffer
= buffer
;
1658 /* Copy from the source to DEST_BUFFER. */
1659 switch (p
->location
)
1661 case DWARF_VALUE_REGISTER
:
1663 struct gdbarch
*arch
= get_frame_arch (frame
);
1664 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1665 int reg_offset
= source_offset
;
1667 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1668 && this_size
< register_size (arch
, gdb_regnum
))
1670 /* Big-endian, and we want less than full size. */
1671 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1672 /* We want the lower-order THIS_SIZE_BITS of the bytes
1673 we extract from the register. */
1674 source_offset_bits
+= 8 * this_size
- this_size_bits
;
1677 if (gdb_regnum
!= -1)
1681 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1685 /* Just so garbage doesn't ever shine through. */
1686 memset (buffer
, 0, this_size
);
1689 set_value_optimized_out (v
, 1);
1691 mark_value_bytes_unavailable (v
, offset
, this_size
);
1696 error (_("Unable to access DWARF register number %s"),
1697 paddress (arch
, p
->v
.regno
));
1702 case DWARF_VALUE_MEMORY
:
1703 read_value_memory (v
, offset
,
1704 p
->v
.mem
.in_stack_memory
,
1705 p
->v
.mem
.addr
+ source_offset
,
1709 case DWARF_VALUE_STACK
:
1711 size_t n
= this_size
;
1713 if (n
> c
->addr_size
- source_offset
)
1714 n
= (c
->addr_size
>= source_offset
1715 ? c
->addr_size
- source_offset
1723 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
1725 intermediate_buffer
= val_bytes
+ source_offset
;
1730 case DWARF_VALUE_LITERAL
:
1732 size_t n
= this_size
;
1734 if (n
> p
->v
.literal
.length
- source_offset
)
1735 n
= (p
->v
.literal
.length
>= source_offset
1736 ? p
->v
.literal
.length
- source_offset
1739 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
1743 /* These bits show up as zeros -- but do not cause the value
1744 to be considered optimized-out. */
1745 case DWARF_VALUE_IMPLICIT_POINTER
:
1748 case DWARF_VALUE_OPTIMIZED_OUT
:
1749 set_value_optimized_out (v
, 1);
1753 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1756 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
1757 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1758 copy_bitwise (contents
, dest_offset_bits
,
1759 intermediate_buffer
, source_offset_bits
% 8,
1760 this_size_bits
, bits_big_endian
);
1762 offset
+= this_size_bits
;
1765 do_cleanups (cleanup
);
1769 write_pieced_value (struct value
*to
, struct value
*from
)
1773 ULONGEST bits_to_skip
;
1774 const gdb_byte
*contents
;
1775 struct piece_closure
*c
1776 = (struct piece_closure
*) value_computed_closure (to
);
1777 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
1779 size_t buffer_size
= 0;
1780 char *buffer
= NULL
;
1781 struct cleanup
*cleanup
;
1783 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
1787 set_value_optimized_out (to
, 1);
1791 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1793 contents
= value_contents (from
);
1794 bits_to_skip
= 8 * value_offset (to
);
1795 if (value_bitsize (to
))
1797 bits_to_skip
+= value_bitpos (to
);
1798 type_len
= value_bitsize (to
);
1801 type_len
= 8 * TYPE_LENGTH (value_type (to
));
1803 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1805 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1806 size_t this_size_bits
, this_size
;
1807 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
1809 const gdb_byte
*source_buffer
;
1811 this_size_bits
= p
->size
;
1812 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1814 bits_to_skip
-= this_size_bits
;
1817 if (this_size_bits
> type_len
- offset
)
1818 this_size_bits
= type_len
- offset
;
1819 if (bits_to_skip
> 0)
1821 dest_offset_bits
= bits_to_skip
;
1822 source_offset_bits
= 0;
1823 this_size_bits
-= bits_to_skip
;
1828 dest_offset_bits
= 0;
1829 source_offset_bits
= offset
;
1832 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1833 source_offset
= source_offset_bits
/ 8;
1834 dest_offset
= dest_offset_bits
/ 8;
1835 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
1837 source_buffer
= contents
+ source_offset
;
1842 if (buffer_size
< this_size
)
1844 buffer_size
= this_size
;
1845 buffer
= xrealloc (buffer
, buffer_size
);
1847 source_buffer
= buffer
;
1851 switch (p
->location
)
1853 case DWARF_VALUE_REGISTER
:
1855 struct gdbarch
*arch
= get_frame_arch (frame
);
1856 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1857 int reg_offset
= dest_offset
;
1859 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1860 && this_size
<= register_size (arch
, gdb_regnum
))
1861 /* Big-endian, and we want less than full size. */
1862 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1864 if (gdb_regnum
!= -1)
1870 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1875 error (_("Can't do read-modify-write to "
1876 "update bitfield; containing word has been "
1879 throw_error (NOT_AVAILABLE_ERROR
,
1880 _("Can't do read-modify-write to update "
1881 "bitfield; containing word "
1884 copy_bitwise (buffer
, dest_offset_bits
,
1885 contents
, source_offset_bits
,
1890 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1891 this_size
, source_buffer
);
1895 error (_("Unable to write to DWARF register number %s"),
1896 paddress (arch
, p
->v
.regno
));
1900 case DWARF_VALUE_MEMORY
:
1903 /* Only the first and last bytes can possibly have any
1905 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
, 1);
1906 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
1907 buffer
+ this_size
- 1, 1);
1908 copy_bitwise (buffer
, dest_offset_bits
,
1909 contents
, source_offset_bits
,
1914 write_memory (p
->v
.mem
.addr
+ dest_offset
,
1915 source_buffer
, this_size
);
1918 set_value_optimized_out (to
, 1);
1921 offset
+= this_size_bits
;
1924 do_cleanups (cleanup
);
1927 /* A helper function that checks bit validity in a pieced value.
1928 CHECK_FOR indicates the kind of validity checking.
1929 DWARF_VALUE_MEMORY means to check whether any bit is valid.
1930 DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
1932 DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
1933 implicit pointer. */
1936 check_pieced_value_bits (const struct value
*value
, int bit_offset
,
1938 enum dwarf_value_location check_for
)
1940 struct piece_closure
*c
1941 = (struct piece_closure
*) value_computed_closure (value
);
1943 int validity
= (check_for
== DWARF_VALUE_MEMORY
1944 || check_for
== DWARF_VALUE_IMPLICIT_POINTER
);
1946 bit_offset
+= 8 * value_offset (value
);
1947 if (value_bitsize (value
))
1948 bit_offset
+= value_bitpos (value
);
1950 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
1952 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1953 size_t this_size_bits
= p
->size
;
1957 if (bit_offset
>= this_size_bits
)
1959 bit_offset
-= this_size_bits
;
1963 bit_length
-= this_size_bits
- bit_offset
;
1967 bit_length
-= this_size_bits
;
1969 if (check_for
== DWARF_VALUE_IMPLICIT_POINTER
)
1971 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1974 else if (p
->location
== DWARF_VALUE_OPTIMIZED_OUT
1975 || p
->location
== DWARF_VALUE_IMPLICIT_POINTER
)
1991 check_pieced_value_validity (const struct value
*value
, int bit_offset
,
1994 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
1995 DWARF_VALUE_MEMORY
);
1999 check_pieced_value_invalid (const struct value
*value
)
2001 return check_pieced_value_bits (value
, 0,
2002 8 * TYPE_LENGTH (value_type (value
)),
2003 DWARF_VALUE_OPTIMIZED_OUT
);
2006 /* An implementation of an lval_funcs method to see whether a value is
2007 a synthetic pointer. */
2010 check_pieced_synthetic_pointer (const struct value
*value
, int bit_offset
,
2013 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
2014 DWARF_VALUE_IMPLICIT_POINTER
);
2017 /* A wrapper function for get_frame_address_in_block. */
2020 get_frame_address_in_block_wrapper (void *baton
)
2022 return get_frame_address_in_block (baton
);
2025 /* An implementation of an lval_funcs method to indirect through a
2026 pointer. This handles the synthetic pointer case when needed. */
2028 static struct value
*
2029 indirect_pieced_value (struct value
*value
)
2031 struct piece_closure
*c
2032 = (struct piece_closure
*) value_computed_closure (value
);
2034 struct frame_info
*frame
;
2035 struct dwarf2_locexpr_baton baton
;
2036 int i
, bit_offset
, bit_length
;
2037 struct dwarf_expr_piece
*piece
= NULL
;
2038 LONGEST byte_offset
;
2040 type
= check_typedef (value_type (value
));
2041 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
2044 bit_length
= 8 * TYPE_LENGTH (type
);
2045 bit_offset
= 8 * value_offset (value
);
2046 if (value_bitsize (value
))
2047 bit_offset
+= value_bitpos (value
);
2049 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2051 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2052 size_t this_size_bits
= p
->size
;
2056 if (bit_offset
>= this_size_bits
)
2058 bit_offset
-= this_size_bits
;
2062 bit_length
-= this_size_bits
- bit_offset
;
2066 bit_length
-= this_size_bits
;
2068 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2071 if (bit_length
!= 0)
2072 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2078 frame
= get_selected_frame (_("No frame selected."));
2080 /* This is an offset requested by GDB, such as value subcripts. */
2081 byte_offset
= value_as_address (value
);
2085 = dwarf2_fetch_die_loc_sect_off (piece
->v
.ptr
.die
, c
->per_cu
,
2086 get_frame_address_in_block_wrapper
,
2089 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
2090 baton
.data
, baton
.size
, baton
.per_cu
,
2091 piece
->v
.ptr
.offset
+ byte_offset
);
2095 copy_pieced_value_closure (const struct value
*v
)
2097 struct piece_closure
*c
2098 = (struct piece_closure
*) value_computed_closure (v
);
2105 free_pieced_value_closure (struct value
*v
)
2107 struct piece_closure
*c
2108 = (struct piece_closure
*) value_computed_closure (v
);
2115 for (i
= 0; i
< c
->n_pieces
; ++i
)
2116 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
2117 value_free (c
->pieces
[i
].v
.value
);
2124 /* Functions for accessing a variable described by DW_OP_piece. */
2125 static const struct lval_funcs pieced_value_funcs
= {
2128 check_pieced_value_validity
,
2129 check_pieced_value_invalid
,
2130 indirect_pieced_value
,
2131 NULL
, /* coerce_ref */
2132 check_pieced_synthetic_pointer
,
2133 copy_pieced_value_closure
,
2134 free_pieced_value_closure
2137 /* Helper function which throws an error if a synthetic pointer is
2141 invalid_synthetic_pointer (void)
2143 error (_("access outside bounds of object "
2144 "referenced via synthetic pointer"));
2147 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2149 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
=
2151 dwarf_expr_read_reg
,
2152 dwarf_expr_read_mem
,
2153 dwarf_expr_frame_base
,
2154 dwarf_expr_frame_cfa
,
2155 dwarf_expr_frame_pc
,
2156 dwarf_expr_tls_address
,
2157 dwarf_expr_dwarf_call
,
2158 dwarf_expr_get_base_type
,
2159 dwarf_expr_push_dwarf_reg_entry_value
,
2160 dwarf_expr_get_addr_index
2163 /* Evaluate a location description, starting at DATA and with length
2164 SIZE, to find the current location of variable of TYPE in the
2165 context of FRAME. BYTE_OFFSET is applied after the contents are
2168 static struct value
*
2169 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2170 const gdb_byte
*data
, size_t size
,
2171 struct dwarf2_per_cu_data
*per_cu
,
2172 LONGEST byte_offset
)
2174 struct value
*retval
;
2175 struct dwarf_expr_baton baton
;
2176 struct dwarf_expr_context
*ctx
;
2177 struct cleanup
*old_chain
, *value_chain
;
2178 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2179 volatile struct gdb_exception ex
;
2181 if (byte_offset
< 0)
2182 invalid_synthetic_pointer ();
2185 return allocate_optimized_out_value (type
);
2187 baton
.frame
= frame
;
2188 baton
.per_cu
= per_cu
;
2190 ctx
= new_dwarf_expr_context ();
2191 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2192 value_chain
= make_cleanup_value_free_to_mark (value_mark ());
2194 ctx
->gdbarch
= get_objfile_arch (objfile
);
2195 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2196 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2197 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2198 ctx
->baton
= &baton
;
2199 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2201 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2203 dwarf_expr_eval (ctx
, data
, size
);
2207 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2209 do_cleanups (old_chain
);
2210 retval
= allocate_value (type
);
2211 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
2214 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2216 if (entry_values_debug
)
2217 exception_print (gdb_stdout
, ex
);
2218 do_cleanups (old_chain
);
2219 return allocate_optimized_out_value (type
);
2222 throw_exception (ex
);
2225 if (ctx
->num_pieces
> 0)
2227 struct piece_closure
*c
;
2228 struct frame_id frame_id
= get_frame_id (frame
);
2229 ULONGEST bit_size
= 0;
2232 for (i
= 0; i
< ctx
->num_pieces
; ++i
)
2233 bit_size
+= ctx
->pieces
[i
].size
;
2234 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
2235 invalid_synthetic_pointer ();
2237 c
= allocate_piece_closure (per_cu
, ctx
->num_pieces
, ctx
->pieces
,
2239 /* We must clean up the value chain after creating the piece
2240 closure but before allocating the result. */
2241 do_cleanups (value_chain
);
2242 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
2243 VALUE_FRAME_ID (retval
) = frame_id
;
2244 set_value_offset (retval
, byte_offset
);
2248 switch (ctx
->location
)
2250 case DWARF_VALUE_REGISTER
:
2252 struct gdbarch
*arch
= get_frame_arch (frame
);
2253 ULONGEST dwarf_regnum
= value_as_long (dwarf_expr_fetch (ctx
, 0));
2254 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
2256 if (byte_offset
!= 0)
2257 error (_("cannot use offset on synthetic pointer to register"));
2258 do_cleanups (value_chain
);
2259 if (gdb_regnum
!= -1)
2260 retval
= value_from_register (type
, gdb_regnum
, frame
);
2262 error (_("Unable to access DWARF register number %s"),
2263 paddress (arch
, dwarf_regnum
));
2267 case DWARF_VALUE_MEMORY
:
2269 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
2270 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
2272 do_cleanups (value_chain
);
2273 retval
= allocate_value_lazy (type
);
2274 VALUE_LVAL (retval
) = lval_memory
;
2275 if (in_stack_memory
)
2276 set_value_stack (retval
, 1);
2277 set_value_address (retval
, address
+ byte_offset
);
2281 case DWARF_VALUE_STACK
:
2283 struct value
*value
= dwarf_expr_fetch (ctx
, 0);
2285 const gdb_byte
*val_bytes
;
2286 size_t n
= TYPE_LENGTH (value_type (value
));
2288 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2289 invalid_synthetic_pointer ();
2291 val_bytes
= value_contents_all (value
);
2292 val_bytes
+= byte_offset
;
2295 /* Preserve VALUE because we are going to free values back
2296 to the mark, but we still need the value contents
2298 value_incref (value
);
2299 do_cleanups (value_chain
);
2300 make_cleanup_value_free (value
);
2302 retval
= allocate_value (type
);
2303 contents
= value_contents_raw (retval
);
2304 if (n
> TYPE_LENGTH (type
))
2306 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2308 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2309 val_bytes
+= n
- TYPE_LENGTH (type
);
2310 n
= TYPE_LENGTH (type
);
2312 memcpy (contents
, val_bytes
, n
);
2316 case DWARF_VALUE_LITERAL
:
2319 const bfd_byte
*ldata
;
2320 size_t n
= ctx
->len
;
2322 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2323 invalid_synthetic_pointer ();
2325 do_cleanups (value_chain
);
2326 retval
= allocate_value (type
);
2327 contents
= value_contents_raw (retval
);
2329 ldata
= ctx
->data
+ byte_offset
;
2332 if (n
> TYPE_LENGTH (type
))
2334 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2336 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2337 ldata
+= n
- TYPE_LENGTH (type
);
2338 n
= TYPE_LENGTH (type
);
2340 memcpy (contents
, ldata
, n
);
2344 case DWARF_VALUE_OPTIMIZED_OUT
:
2345 do_cleanups (value_chain
);
2346 retval
= allocate_optimized_out_value (type
);
2349 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2350 operation by execute_stack_op. */
2351 case DWARF_VALUE_IMPLICIT_POINTER
:
2352 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2353 it can only be encountered when making a piece. */
2355 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2359 set_value_initialized (retval
, ctx
->initialized
);
2361 do_cleanups (old_chain
);
2366 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2367 passes 0 as the byte_offset. */
2370 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2371 const gdb_byte
*data
, size_t size
,
2372 struct dwarf2_per_cu_data
*per_cu
)
2374 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
2378 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2380 struct needs_frame_baton
2383 struct dwarf2_per_cu_data
*per_cu
;
2386 /* Reads from registers do require a frame. */
2388 needs_frame_read_reg (void *baton
, int regnum
)
2390 struct needs_frame_baton
*nf_baton
= baton
;
2392 nf_baton
->needs_frame
= 1;
2396 /* Reads from memory do not require a frame. */
2398 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
2400 memset (buf
, 0, len
);
2403 /* Frame-relative accesses do require a frame. */
2405 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
2407 static gdb_byte lit0
= DW_OP_lit0
;
2408 struct needs_frame_baton
*nf_baton
= baton
;
2413 nf_baton
->needs_frame
= 1;
2416 /* CFA accesses require a frame. */
2419 needs_frame_frame_cfa (void *baton
)
2421 struct needs_frame_baton
*nf_baton
= baton
;
2423 nf_baton
->needs_frame
= 1;
2427 /* Thread-local accesses do require a frame. */
2429 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
2431 struct needs_frame_baton
*nf_baton
= baton
;
2433 nf_baton
->needs_frame
= 1;
2437 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2440 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
2442 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2444 per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
,
2445 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
2448 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2451 needs_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
2452 enum call_site_parameter_kind kind
,
2453 union call_site_parameter_u kind_u
, int deref_size
)
2455 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2457 nf_baton
->needs_frame
= 1;
2459 /* The expression may require some stub values on DWARF stack. */
2460 dwarf_expr_push_address (ctx
, 0, 0);
2463 /* DW_OP_GNU_addr_index doesn't require a frame. */
2466 needs_get_addr_index (void *baton
, unsigned int index
)
2468 /* Nothing to do. */
2472 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2474 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs
=
2476 needs_frame_read_reg
,
2477 needs_frame_read_mem
,
2478 needs_frame_frame_base
,
2479 needs_frame_frame_cfa
,
2480 needs_frame_frame_cfa
, /* get_frame_pc */
2481 needs_frame_tls_address
,
2482 needs_frame_dwarf_call
,
2483 NULL
, /* get_base_type */
2484 needs_dwarf_reg_entry_value
,
2485 needs_get_addr_index
2488 /* Return non-zero iff the location expression at DATA (length SIZE)
2489 requires a frame to evaluate. */
2492 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, size_t size
,
2493 struct dwarf2_per_cu_data
*per_cu
)
2495 struct needs_frame_baton baton
;
2496 struct dwarf_expr_context
*ctx
;
2498 struct cleanup
*old_chain
;
2499 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2501 baton
.needs_frame
= 0;
2502 baton
.per_cu
= per_cu
;
2504 ctx
= new_dwarf_expr_context ();
2505 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2506 make_cleanup_value_free_to_mark (value_mark ());
2508 ctx
->gdbarch
= get_objfile_arch (objfile
);
2509 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2510 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2511 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2512 ctx
->baton
= &baton
;
2513 ctx
->funcs
= &needs_frame_ctx_funcs
;
2515 dwarf_expr_eval (ctx
, data
, size
);
2517 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
2519 if (ctx
->num_pieces
> 0)
2523 /* If the location has several pieces, and any of them are in
2524 registers, then we will need a frame to fetch them from. */
2525 for (i
= 0; i
< ctx
->num_pieces
; i
++)
2526 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2530 do_cleanups (old_chain
);
2532 return baton
.needs_frame
|| in_reg
;
2535 /* A helper function that throws an unimplemented error mentioning a
2536 given DWARF operator. */
2539 unimplemented (unsigned int op
)
2541 const char *name
= get_DW_OP_name (op
);
2544 error (_("DWARF operator %s cannot be translated to an agent expression"),
2547 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2548 "to an agent expression"),
2552 /* A helper function to convert a DWARF register to an arch register.
2553 ARCH is the architecture.
2554 DWARF_REG is the register.
2555 This will throw an exception if the DWARF register cannot be
2556 translated to an architecture register. */
2559 translate_register (struct gdbarch
*arch
, int dwarf_reg
)
2561 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2563 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
2567 /* A helper function that emits an access to memory. ARCH is the
2568 target architecture. EXPR is the expression which we are building.
2569 NBITS is the number of bits we want to read. This emits the
2570 opcodes needed to read the memory and then extract the desired
2574 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2576 ULONGEST nbytes
= (nbits
+ 7) / 8;
2578 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2581 ax_trace_quick (expr
, nbytes
);
2584 ax_simple (expr
, aop_ref8
);
2585 else if (nbits
<= 16)
2586 ax_simple (expr
, aop_ref16
);
2587 else if (nbits
<= 32)
2588 ax_simple (expr
, aop_ref32
);
2590 ax_simple (expr
, aop_ref64
);
2592 /* If we read exactly the number of bytes we wanted, we're done. */
2593 if (8 * nbytes
== nbits
)
2596 if (gdbarch_bits_big_endian (arch
))
2598 /* On a bits-big-endian machine, we want the high-order
2600 ax_const_l (expr
, 8 * nbytes
- nbits
);
2601 ax_simple (expr
, aop_rsh_unsigned
);
2605 /* On a bits-little-endian box, we want the low-order NBITS. */
2606 ax_zero_ext (expr
, nbits
);
2610 /* A helper function to return the frame's PC. */
2613 get_ax_pc (void *baton
)
2615 struct agent_expr
*expr
= baton
;
2620 /* Compile a DWARF location expression to an agent expression.
2622 EXPR is the agent expression we are building.
2623 LOC is the agent value we modify.
2624 ARCH is the architecture.
2625 ADDR_SIZE is the size of addresses, in bytes.
2626 OP_PTR is the start of the location expression.
2627 OP_END is one past the last byte of the location expression.
2629 This will throw an exception for various kinds of errors -- for
2630 example, if the expression cannot be compiled, or if the expression
2634 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2635 struct gdbarch
*arch
, unsigned int addr_size
,
2636 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
2637 struct dwarf2_per_cu_data
*per_cu
)
2639 struct cleanup
*cleanups
;
2641 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
2642 const gdb_byte
* const base
= op_ptr
;
2643 const gdb_byte
*previous_piece
= op_ptr
;
2644 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2645 ULONGEST bits_collected
= 0;
2646 unsigned int addr_size_bits
= 8 * addr_size
;
2647 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
2649 offsets
= xmalloc ((op_end
- op_ptr
) * sizeof (int));
2650 cleanups
= make_cleanup (xfree
, offsets
);
2652 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
2655 make_cleanup (VEC_cleanup (int), &dw_labels
);
2656 make_cleanup (VEC_cleanup (int), &patches
);
2658 /* By default we are making an address. */
2659 loc
->kind
= axs_lvalue_memory
;
2661 while (op_ptr
< op_end
)
2663 enum dwarf_location_atom op
= *op_ptr
;
2664 uint64_t uoffset
, reg
;
2668 offsets
[op_ptr
- base
] = expr
->len
;
2671 /* Our basic approach to code generation is to map DWARF
2672 operations directly to AX operations. However, there are
2675 First, DWARF works on address-sized units, but AX always uses
2676 LONGEST. For most operations we simply ignore this
2677 difference; instead we generate sign extensions as needed
2678 before division and comparison operations. It would be nice
2679 to omit the sign extensions, but there is no way to determine
2680 the size of the target's LONGEST. (This code uses the size
2681 of the host LONGEST in some cases -- that is a bug but it is
2684 Second, some DWARF operations cannot be translated to AX.
2685 For these we simply fail. See
2686 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2721 ax_const_l (expr
, op
- DW_OP_lit0
);
2725 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
2726 op_ptr
+= addr_size
;
2727 /* Some versions of GCC emit DW_OP_addr before
2728 DW_OP_GNU_push_tls_address. In this case the value is an
2729 index, not an address. We don't support things like
2730 branching between the address and the TLS op. */
2731 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
2732 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
2733 ax_const_l (expr
, uoffset
);
2737 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
2741 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
2745 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
2749 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
2753 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
2757 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
2761 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
2765 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
2769 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
2770 ax_const_l (expr
, uoffset
);
2773 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2774 ax_const_l (expr
, offset
);
2809 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2810 loc
->u
.reg
= translate_register (arch
, op
- DW_OP_reg0
);
2811 loc
->kind
= axs_lvalue_register
;
2815 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2816 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2817 loc
->u
.reg
= translate_register (arch
, reg
);
2818 loc
->kind
= axs_lvalue_register
;
2821 case DW_OP_implicit_value
:
2825 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
2826 if (op_ptr
+ len
> op_end
)
2827 error (_("DW_OP_implicit_value: too few bytes available."));
2828 if (len
> sizeof (ULONGEST
))
2829 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
2832 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
2835 dwarf_expr_require_composition (op_ptr
, op_end
,
2836 "DW_OP_implicit_value");
2838 loc
->kind
= axs_rvalue
;
2842 case DW_OP_stack_value
:
2843 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
2844 loc
->kind
= axs_rvalue
;
2879 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2880 i
= translate_register (arch
, op
- DW_OP_breg0
);
2884 ax_const_l (expr
, offset
);
2885 ax_simple (expr
, aop_add
);
2890 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2891 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2892 i
= translate_register (arch
, reg
);
2896 ax_const_l (expr
, offset
);
2897 ax_simple (expr
, aop_add
);
2903 const gdb_byte
*datastart
;
2906 struct symbol
*framefunc
;
2908 b
= block_for_pc (expr
->scope
);
2911 error (_("No block found for address"));
2913 framefunc
= block_linkage_function (b
);
2916 error (_("No function found for block"));
2918 dwarf_expr_frame_base_1 (framefunc
, expr
->scope
,
2919 &datastart
, &datalen
);
2921 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2922 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
2923 datastart
+ datalen
, per_cu
);
2924 if (loc
->kind
== axs_lvalue_register
)
2925 require_rvalue (expr
, loc
);
2929 ax_const_l (expr
, offset
);
2930 ax_simple (expr
, aop_add
);
2933 loc
->kind
= axs_lvalue_memory
;
2938 ax_simple (expr
, aop_dup
);
2942 ax_simple (expr
, aop_pop
);
2947 ax_pick (expr
, offset
);
2951 ax_simple (expr
, aop_swap
);
2959 ax_simple (expr
, aop_rot
);
2963 case DW_OP_deref_size
:
2967 if (op
== DW_OP_deref_size
)
2972 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
2973 error (_("Unsupported size %d in %s"),
2974 size
, get_DW_OP_name (op
));
2975 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
2980 /* Sign extend the operand. */
2981 ax_ext (expr
, addr_size_bits
);
2982 ax_simple (expr
, aop_dup
);
2983 ax_const_l (expr
, 0);
2984 ax_simple (expr
, aop_less_signed
);
2985 ax_simple (expr
, aop_log_not
);
2986 i
= ax_goto (expr
, aop_if_goto
);
2987 /* We have to emit 0 - X. */
2988 ax_const_l (expr
, 0);
2989 ax_simple (expr
, aop_swap
);
2990 ax_simple (expr
, aop_sub
);
2991 ax_label (expr
, i
, expr
->len
);
2995 /* No need to sign extend here. */
2996 ax_const_l (expr
, 0);
2997 ax_simple (expr
, aop_swap
);
2998 ax_simple (expr
, aop_sub
);
3002 /* Sign extend the operand. */
3003 ax_ext (expr
, addr_size_bits
);
3004 ax_simple (expr
, aop_bit_not
);
3007 case DW_OP_plus_uconst
:
3008 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3009 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3010 but we micro-optimize anyhow. */
3013 ax_const_l (expr
, reg
);
3014 ax_simple (expr
, aop_add
);
3019 ax_simple (expr
, aop_bit_and
);
3023 /* Sign extend the operands. */
3024 ax_ext (expr
, addr_size_bits
);
3025 ax_simple (expr
, aop_swap
);
3026 ax_ext (expr
, addr_size_bits
);
3027 ax_simple (expr
, aop_swap
);
3028 ax_simple (expr
, aop_div_signed
);
3032 ax_simple (expr
, aop_sub
);
3036 ax_simple (expr
, aop_rem_unsigned
);
3040 ax_simple (expr
, aop_mul
);
3044 ax_simple (expr
, aop_bit_or
);
3048 ax_simple (expr
, aop_add
);
3052 ax_simple (expr
, aop_lsh
);
3056 ax_simple (expr
, aop_rsh_unsigned
);
3060 ax_simple (expr
, aop_rsh_signed
);
3064 ax_simple (expr
, aop_bit_xor
);
3068 /* Sign extend the operands. */
3069 ax_ext (expr
, addr_size_bits
);
3070 ax_simple (expr
, aop_swap
);
3071 ax_ext (expr
, addr_size_bits
);
3072 /* Note no swap here: A <= B is !(B < A). */
3073 ax_simple (expr
, aop_less_signed
);
3074 ax_simple (expr
, aop_log_not
);
3078 /* Sign extend the operands. */
3079 ax_ext (expr
, addr_size_bits
);
3080 ax_simple (expr
, aop_swap
);
3081 ax_ext (expr
, addr_size_bits
);
3082 ax_simple (expr
, aop_swap
);
3083 /* A >= B is !(A < B). */
3084 ax_simple (expr
, aop_less_signed
);
3085 ax_simple (expr
, aop_log_not
);
3089 /* Sign extend the operands. */
3090 ax_ext (expr
, addr_size_bits
);
3091 ax_simple (expr
, aop_swap
);
3092 ax_ext (expr
, addr_size_bits
);
3093 /* No need for a second swap here. */
3094 ax_simple (expr
, aop_equal
);
3098 /* Sign extend the operands. */
3099 ax_ext (expr
, addr_size_bits
);
3100 ax_simple (expr
, aop_swap
);
3101 ax_ext (expr
, addr_size_bits
);
3102 ax_simple (expr
, aop_swap
);
3103 ax_simple (expr
, aop_less_signed
);
3107 /* Sign extend the operands. */
3108 ax_ext (expr
, addr_size_bits
);
3109 ax_simple (expr
, aop_swap
);
3110 ax_ext (expr
, addr_size_bits
);
3111 /* Note no swap here: A > B is B < A. */
3112 ax_simple (expr
, aop_less_signed
);
3116 /* Sign extend the operands. */
3117 ax_ext (expr
, addr_size_bits
);
3118 ax_simple (expr
, aop_swap
);
3119 ax_ext (expr
, addr_size_bits
);
3120 /* No need for a swap here. */
3121 ax_simple (expr
, aop_equal
);
3122 ax_simple (expr
, aop_log_not
);
3125 case DW_OP_call_frame_cfa
:
3126 dwarf2_compile_cfa_to_ax (expr
, loc
, arch
, expr
->scope
, per_cu
);
3127 loc
->kind
= axs_lvalue_memory
;
3130 case DW_OP_GNU_push_tls_address
:
3135 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3137 i
= ax_goto (expr
, aop_goto
);
3138 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3139 VEC_safe_push (int, patches
, i
);
3143 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3145 /* Zero extend the operand. */
3146 ax_zero_ext (expr
, addr_size_bits
);
3147 i
= ax_goto (expr
, aop_if_goto
);
3148 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3149 VEC_safe_push (int, patches
, i
);
3156 case DW_OP_bit_piece
:
3158 uint64_t size
, offset
;
3160 if (op_ptr
- 1 == previous_piece
)
3161 error (_("Cannot translate empty pieces to agent expressions"));
3162 previous_piece
= op_ptr
- 1;
3164 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3165 if (op
== DW_OP_piece
)
3171 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
3173 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3174 error (_("Expression pieces exceed word size"));
3176 /* Access the bits. */
3179 case axs_lvalue_register
:
3180 ax_reg (expr
, loc
->u
.reg
);
3183 case axs_lvalue_memory
:
3184 /* Offset the pointer, if needed. */
3187 ax_const_l (expr
, offset
/ 8);
3188 ax_simple (expr
, aop_add
);
3191 access_memory (arch
, expr
, size
);
3195 /* For a bits-big-endian target, shift up what we already
3196 have. For a bits-little-endian target, shift up the
3197 new data. Note that there is a potential bug here if
3198 the DWARF expression leaves multiple values on the
3200 if (bits_collected
> 0)
3202 if (bits_big_endian
)
3204 ax_simple (expr
, aop_swap
);
3205 ax_const_l (expr
, size
);
3206 ax_simple (expr
, aop_lsh
);
3207 /* We don't need a second swap here, because
3208 aop_bit_or is symmetric. */
3212 ax_const_l (expr
, size
);
3213 ax_simple (expr
, aop_lsh
);
3215 ax_simple (expr
, aop_bit_or
);
3218 bits_collected
+= size
;
3219 loc
->kind
= axs_rvalue
;
3223 case DW_OP_GNU_uninit
:
3229 struct dwarf2_locexpr_baton block
;
3230 int size
= (op
== DW_OP_call2
? 2 : 4);
3233 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3236 offset
.cu_off
= uoffset
;
3237 block
= dwarf2_fetch_die_loc_cu_off (offset
, per_cu
,
3240 /* DW_OP_call_ref is currently not supported. */
3241 gdb_assert (block
.per_cu
== per_cu
);
3243 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3244 block
.data
, block
.data
+ block
.size
,
3249 case DW_OP_call_ref
:
3257 /* Patch all the branches we emitted. */
3258 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
3260 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
3262 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3263 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
3266 do_cleanups (cleanups
);
3270 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3271 evaluator to calculate the location. */
3272 static struct value
*
3273 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3275 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3278 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3279 dlbaton
->size
, dlbaton
->per_cu
);
3284 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3285 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3288 static struct value
*
3289 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3291 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3293 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3297 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3299 locexpr_read_needs_frame (struct symbol
*symbol
)
3301 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3303 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
3307 /* Return true if DATA points to the end of a piece. END is one past
3308 the last byte in the expression. */
3311 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3313 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3316 /* Helper for locexpr_describe_location_piece that finds the name of a
3320 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3324 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
3325 return gdbarch_register_name (gdbarch
, regnum
);
3328 /* Nicely describe a single piece of a location, returning an updated
3329 position in the bytecode sequence. This function cannot recognize
3330 all locations; if a location is not recognized, it simply returns
3331 DATA. If there is an error during reading, e.g. we run off the end
3332 of the buffer, an error is thrown. */
3334 static const gdb_byte
*
3335 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3336 CORE_ADDR addr
, struct objfile
*objfile
,
3337 struct dwarf2_per_cu_data
*per_cu
,
3338 const gdb_byte
*data
, const gdb_byte
*end
,
3339 unsigned int addr_size
)
3341 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3344 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3346 fprintf_filtered (stream
, _("a variable in $%s"),
3347 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3350 else if (data
[0] == DW_OP_regx
)
3354 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3355 fprintf_filtered (stream
, _("a variable in $%s"),
3356 locexpr_regname (gdbarch
, reg
));
3358 else if (data
[0] == DW_OP_fbreg
)
3361 struct symbol
*framefunc
;
3363 int64_t frame_offset
;
3364 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3366 int64_t base_offset
= 0;
3368 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3369 if (!piece_end_p (new_data
, end
))
3373 b
= block_for_pc (addr
);
3376 error (_("No block found for address for symbol \"%s\"."),
3377 SYMBOL_PRINT_NAME (symbol
));
3379 framefunc
= block_linkage_function (b
);
3382 error (_("No function found for block for symbol \"%s\"."),
3383 SYMBOL_PRINT_NAME (symbol
));
3385 dwarf_expr_frame_base_1 (framefunc
, addr
, &base_data
, &base_size
);
3387 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3389 const gdb_byte
*buf_end
;
3391 frame_reg
= base_data
[0] - DW_OP_breg0
;
3392 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3394 if (buf_end
!= base_data
+ base_size
)
3395 error (_("Unexpected opcode after "
3396 "DW_OP_breg%u for symbol \"%s\"."),
3397 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3399 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3401 /* The frame base is just the register, with no offset. */
3402 frame_reg
= base_data
[0] - DW_OP_reg0
;
3407 /* We don't know what to do with the frame base expression,
3408 so we can't trace this variable; give up. */
3412 fprintf_filtered (stream
,
3413 _("a variable at frame base reg $%s offset %s+%s"),
3414 locexpr_regname (gdbarch
, frame_reg
),
3415 plongest (base_offset
), plongest (frame_offset
));
3417 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3418 && piece_end_p (data
, end
))
3422 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3424 fprintf_filtered (stream
,
3425 _("a variable at offset %s from base reg $%s"),
3427 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3430 /* The location expression for a TLS variable looks like this (on a
3433 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3434 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3436 0x3 is the encoding for DW_OP_addr, which has an operand as long
3437 as the size of an address on the target machine (here is 8
3438 bytes). Note that more recent version of GCC emit DW_OP_const4u
3439 or DW_OP_const8u, depending on address size, rather than
3440 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3441 The operand represents the offset at which the variable is within
3442 the thread local storage. */
3444 else if (data
+ 1 + addr_size
< end
3445 && (data
[0] == DW_OP_addr
3446 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3447 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3448 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3449 && piece_end_p (data
+ 2 + addr_size
, end
))
3452 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3453 gdbarch_byte_order (gdbarch
));
3455 fprintf_filtered (stream
,
3456 _("a thread-local variable at offset 0x%s "
3457 "in the thread-local storage for `%s'"),
3458 phex_nz (offset
, addr_size
), objfile
->name
);
3460 data
+= 1 + addr_size
+ 1;
3463 /* With -gsplit-dwarf a TLS variable can also look like this:
3464 DW_AT_location : 3 byte block: fc 4 e0
3465 (DW_OP_GNU_const_index: 4;
3466 DW_OP_GNU_push_tls_address) */
3467 else if (data
+ 3 <= end
3468 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3469 && data
[0] == DW_OP_GNU_const_index
3471 && data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3472 && piece_end_p (data
+ 2 + leb128_size
, end
))
3476 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3477 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3478 fprintf_filtered (stream
,
3479 _("a thread-local variable at offset 0x%s "
3480 "in the thread-local storage for `%s'"),
3481 phex_nz (offset
, addr_size
), objfile
->name
);
3485 else if (data
[0] >= DW_OP_lit0
3486 && data
[0] <= DW_OP_lit31
3488 && data
[1] == DW_OP_stack_value
)
3490 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3497 /* Disassemble an expression, stopping at the end of a piece or at the
3498 end of the expression. Returns a pointer to the next unread byte
3499 in the input expression. If ALL is nonzero, then this function
3500 will keep going until it reaches the end of the expression.
3501 If there is an error during reading, e.g. we run off the end
3502 of the buffer, an error is thrown. */
3504 static const gdb_byte
*
3505 disassemble_dwarf_expression (struct ui_file
*stream
,
3506 struct gdbarch
*arch
, unsigned int addr_size
,
3507 int offset_size
, const gdb_byte
*start
,
3508 const gdb_byte
*data
, const gdb_byte
*end
,
3509 int indent
, int all
,
3510 struct dwarf2_per_cu_data
*per_cu
)
3514 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3516 enum dwarf_location_atom op
= *data
++;
3521 name
= get_DW_OP_name (op
);
3524 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3525 op
, (long) (data
- 1 - start
));
3526 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3527 (long) (data
- 1 - start
), name
);
3532 ul
= extract_unsigned_integer (data
, addr_size
,
3533 gdbarch_byte_order (arch
));
3535 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3539 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3541 fprintf_filtered (stream
, " %s", pulongest (ul
));
3544 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3546 fprintf_filtered (stream
, " %s", plongest (l
));
3549 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3551 fprintf_filtered (stream
, " %s", pulongest (ul
));
3554 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3556 fprintf_filtered (stream
, " %s", plongest (l
));
3559 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3561 fprintf_filtered (stream
, " %s", pulongest (ul
));
3564 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3566 fprintf_filtered (stream
, " %s", plongest (l
));
3569 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3571 fprintf_filtered (stream
, " %s", pulongest (ul
));
3574 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3576 fprintf_filtered (stream
, " %s", plongest (l
));
3579 data
= safe_read_uleb128 (data
, end
, &ul
);
3580 fprintf_filtered (stream
, " %s", pulongest (ul
));
3583 data
= safe_read_sleb128 (data
, end
, &l
);
3584 fprintf_filtered (stream
, " %s", plongest (l
));
3619 fprintf_filtered (stream
, " [$%s]",
3620 locexpr_regname (arch
, op
- DW_OP_reg0
));
3624 data
= safe_read_uleb128 (data
, end
, &ul
);
3625 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3626 locexpr_regname (arch
, (int) ul
));
3629 case DW_OP_implicit_value
:
3630 data
= safe_read_uleb128 (data
, end
, &ul
);
3632 fprintf_filtered (stream
, " %s", pulongest (ul
));
3667 data
= safe_read_sleb128 (data
, end
, &l
);
3668 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
3669 locexpr_regname (arch
, op
- DW_OP_breg0
));
3673 data
= safe_read_uleb128 (data
, end
, &ul
);
3674 data
= safe_read_sleb128 (data
, end
, &l
);
3675 fprintf_filtered (stream
, " register %s [$%s] offset %s",
3677 locexpr_regname (arch
, (int) ul
),
3682 data
= safe_read_sleb128 (data
, end
, &l
);
3683 fprintf_filtered (stream
, " %s", plongest (l
));
3686 case DW_OP_xderef_size
:
3687 case DW_OP_deref_size
:
3689 fprintf_filtered (stream
, " %d", *data
);
3693 case DW_OP_plus_uconst
:
3694 data
= safe_read_uleb128 (data
, end
, &ul
);
3695 fprintf_filtered (stream
, " %s", pulongest (ul
));
3699 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3701 fprintf_filtered (stream
, " to %ld",
3702 (long) (data
+ l
- start
));
3706 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3708 fprintf_filtered (stream
, " %ld",
3709 (long) (data
+ l
- start
));
3713 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3715 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
3719 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3721 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3724 case DW_OP_call_ref
:
3725 ul
= extract_unsigned_integer (data
, offset_size
,
3726 gdbarch_byte_order (arch
));
3727 data
+= offset_size
;
3728 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
3732 data
= safe_read_uleb128 (data
, end
, &ul
);
3733 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
3736 case DW_OP_bit_piece
:
3740 data
= safe_read_uleb128 (data
, end
, &ul
);
3741 data
= safe_read_uleb128 (data
, end
, &offset
);
3742 fprintf_filtered (stream
, " size %s offset %s (bits)",
3743 pulongest (ul
), pulongest (offset
));
3747 case DW_OP_GNU_implicit_pointer
:
3749 ul
= extract_unsigned_integer (data
, offset_size
,
3750 gdbarch_byte_order (arch
));
3751 data
+= offset_size
;
3753 data
= safe_read_sleb128 (data
, end
, &l
);
3755 fprintf_filtered (stream
, " DIE %s offset %s",
3756 phex_nz (ul
, offset_size
),
3761 case DW_OP_GNU_deref_type
:
3763 int addr_size
= *data
++;
3767 data
= safe_read_uleb128 (data
, end
, &ul
);
3769 type
= dwarf2_get_die_type (offset
, per_cu
);
3770 fprintf_filtered (stream
, "<");
3771 type_print (type
, "", stream
, -1);
3772 fprintf_filtered (stream
, " [0x%s]> %d", phex_nz (offset
.cu_off
, 0),
3777 case DW_OP_GNU_const_type
:
3782 data
= safe_read_uleb128 (data
, end
, &ul
);
3783 type_die
.cu_off
= ul
;
3784 type
= dwarf2_get_die_type (type_die
, per_cu
);
3785 fprintf_filtered (stream
, "<");
3786 type_print (type
, "", stream
, -1);
3787 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3791 case DW_OP_GNU_regval_type
:
3797 data
= safe_read_uleb128 (data
, end
, ®
);
3798 data
= safe_read_uleb128 (data
, end
, &ul
);
3799 type_die
.cu_off
= ul
;
3801 type
= dwarf2_get_die_type (type_die
, per_cu
);
3802 fprintf_filtered (stream
, "<");
3803 type_print (type
, "", stream
, -1);
3804 fprintf_filtered (stream
, " [0x%s]> [$%s]",
3805 phex_nz (type_die
.cu_off
, 0),
3806 locexpr_regname (arch
, reg
));
3810 case DW_OP_GNU_convert
:
3811 case DW_OP_GNU_reinterpret
:
3815 data
= safe_read_uleb128 (data
, end
, &ul
);
3816 type_die
.cu_off
= ul
;
3818 if (type_die
.cu_off
== 0)
3819 fprintf_filtered (stream
, "<0>");
3824 type
= dwarf2_get_die_type (type_die
, per_cu
);
3825 fprintf_filtered (stream
, "<");
3826 type_print (type
, "", stream
, -1);
3827 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3832 case DW_OP_GNU_entry_value
:
3833 data
= safe_read_uleb128 (data
, end
, &ul
);
3834 fputc_filtered ('\n', stream
);
3835 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
3836 start
, data
, data
+ ul
, indent
+ 2,
3841 case DW_OP_GNU_parameter_ref
:
3842 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3844 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3847 case DW_OP_GNU_addr_index
:
3848 data
= safe_read_uleb128 (data
, end
, &ul
);
3849 ul
= dwarf2_read_addr_index (per_cu
, ul
);
3850 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3852 case DW_OP_GNU_const_index
:
3853 data
= safe_read_uleb128 (data
, end
, &ul
);
3854 ul
= dwarf2_read_addr_index (per_cu
, ul
);
3855 fprintf_filtered (stream
, " %s", pulongest (ul
));
3859 fprintf_filtered (stream
, "\n");
3865 /* Describe a single location, which may in turn consist of multiple
3869 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
3870 struct ui_file
*stream
,
3871 const gdb_byte
*data
, size_t size
,
3872 struct objfile
*objfile
, unsigned int addr_size
,
3873 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
3875 const gdb_byte
*end
= data
+ size
;
3876 int first_piece
= 1, bad
= 0;
3880 const gdb_byte
*here
= data
;
3881 int disassemble
= 1;
3886 fprintf_filtered (stream
, _(", and "));
3888 if (!dwarf2_always_disassemble
)
3890 data
= locexpr_describe_location_piece (symbol
, stream
,
3891 addr
, objfile
, per_cu
,
3892 data
, end
, addr_size
);
3893 /* If we printed anything, or if we have an empty piece,
3894 then don't disassemble. */
3896 || data
[0] == DW_OP_piece
3897 || data
[0] == DW_OP_bit_piece
)
3902 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
3903 data
= disassemble_dwarf_expression (stream
,
3904 get_objfile_arch (objfile
),
3905 addr_size
, offset_size
, data
,
3907 dwarf2_always_disassemble
,
3913 int empty
= data
== here
;
3916 fprintf_filtered (stream
, " ");
3917 if (data
[0] == DW_OP_piece
)
3921 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
3924 fprintf_filtered (stream
, _("an empty %s-byte piece"),
3927 fprintf_filtered (stream
, _(" [%s-byte piece]"),
3930 else if (data
[0] == DW_OP_bit_piece
)
3932 uint64_t bits
, offset
;
3934 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
3935 data
= safe_read_uleb128 (data
, end
, &offset
);
3938 fprintf_filtered (stream
,
3939 _("an empty %s-bit piece"),
3942 fprintf_filtered (stream
,
3943 _(" [%s-bit piece, offset %s bits]"),
3944 pulongest (bits
), pulongest (offset
));
3954 if (bad
|| data
> end
)
3955 error (_("Corrupted DWARF2 expression for \"%s\"."),
3956 SYMBOL_PRINT_NAME (symbol
));
3959 /* Print a natural-language description of SYMBOL to STREAM. This
3960 version is for a symbol with a single location. */
3963 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
3964 struct ui_file
*stream
)
3966 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3967 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
3968 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
3969 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
3971 locexpr_describe_location_1 (symbol
, addr
, stream
,
3972 dlbaton
->data
, dlbaton
->size
,
3973 objfile
, addr_size
, offset_size
,
3977 /* Describe the location of SYMBOL as an agent value in VALUE, generating
3978 any necessary bytecode in AX. */
3981 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
3982 struct agent_expr
*ax
, struct axs_value
*value
)
3984 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3985 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
3987 if (dlbaton
->size
== 0)
3988 value
->optimized_out
= 1;
3990 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
3991 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
3995 /* The set of location functions used with the DWARF-2 expression
3997 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
3998 locexpr_read_variable
,
3999 locexpr_read_variable_at_entry
,
4000 locexpr_read_needs_frame
,
4001 locexpr_describe_location
,
4002 0, /* location_has_loclist */
4003 locexpr_tracepoint_var_ref
4007 /* Wrapper functions for location lists. These generally find
4008 the appropriate location expression and call something above. */
4010 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4011 evaluator to calculate the location. */
4012 static struct value
*
4013 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4015 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4017 const gdb_byte
*data
;
4019 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4021 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4022 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4028 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4029 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4032 Function always returns non-NULL value, it may be marked optimized out if
4033 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4034 if it cannot resolve the parameter for any reason. */
4036 static struct value
*
4037 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4039 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4040 const gdb_byte
*data
;
4044 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4045 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4047 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4049 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4051 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4054 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
4056 loclist_read_needs_frame (struct symbol
*symbol
)
4058 /* If there's a location list, then assume we need to have a frame
4059 to choose the appropriate location expression. With tracking of
4060 global variables this is not necessarily true, but such tracking
4061 is disabled in GCC at the moment until we figure out how to
4067 /* Print a natural-language description of SYMBOL to STREAM. This
4068 version applies when there is a list of different locations, each
4069 with a specified address range. */
4072 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4073 struct ui_file
*stream
)
4075 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4076 const gdb_byte
*loc_ptr
, *buf_end
;
4077 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4078 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4079 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4080 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4081 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4082 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4083 /* Adjust base_address for relocatable objects. */
4084 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4085 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4088 loc_ptr
= dlbaton
->data
;
4089 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4091 fprintf_filtered (stream
, _("multi-location:\n"));
4093 /* Iterate through locations until we run out. */
4096 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4098 enum debug_loc_kind kind
;
4099 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4101 if (dlbaton
->from_dwo
)
4102 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4103 loc_ptr
, buf_end
, &new_ptr
,
4104 &low
, &high
, byte_order
);
4106 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4108 byte_order
, addr_size
,
4113 case DEBUG_LOC_END_OF_LIST
:
4116 case DEBUG_LOC_BASE_ADDRESS
:
4117 base_address
= high
+ base_offset
;
4118 fprintf_filtered (stream
, _(" Base address %s"),
4119 paddress (gdbarch
, base_address
));
4121 case DEBUG_LOC_START_END
:
4122 case DEBUG_LOC_START_LENGTH
:
4124 case DEBUG_LOC_BUFFER_OVERFLOW
:
4125 case DEBUG_LOC_INVALID_ENTRY
:
4126 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4127 SYMBOL_PRINT_NAME (symbol
));
4129 gdb_assert_not_reached ("bad debug_loc_kind");
4132 /* Otherwise, a location expression entry. */
4133 low
+= base_address
;
4134 high
+= base_address
;
4136 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4139 /* (It would improve readability to print only the minimum
4140 necessary digits of the second number of the range.) */
4141 fprintf_filtered (stream
, _(" Range %s-%s: "),
4142 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4144 /* Now describe this particular location. */
4145 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4146 objfile
, addr_size
, offset_size
,
4149 fprintf_filtered (stream
, "\n");
4155 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4156 any necessary bytecode in AX. */
4158 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4159 struct agent_expr
*ax
, struct axs_value
*value
)
4161 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4162 const gdb_byte
*data
;
4164 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4166 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4168 value
->optimized_out
= 1;
4170 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
4174 /* The set of location functions used with the DWARF-2 expression
4175 evaluator and location lists. */
4176 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4177 loclist_read_variable
,
4178 loclist_read_variable_at_entry
,
4179 loclist_read_needs_frame
,
4180 loclist_describe_location
,
4181 1, /* location_has_loclist */
4182 loclist_tracepoint_var_ref
4185 /* Provide a prototype to silence -Wmissing-prototypes. */
4186 extern initialize_file_ftype _initialize_dwarf2loc
;
4189 _initialize_dwarf2loc (void)
4191 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4192 &entry_values_debug
,
4193 _("Set entry values and tail call frames "
4195 _("Show entry values and tail call frames "
4197 _("When non-zero, the process of determining "
4198 "parameter values from function entry point "
4199 "and tail call frames will be printed."),
4201 show_entry_values_debug
,
4202 &setdebuglist
, &showdebuglist
);