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 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
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
540 if (caller_frame
== NULL
)
542 struct minimal_symbol
*msym
;
544 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
545 throw_error (NO_ENTRY_VALUE_ERROR
,
546 _("DW_AT_GNU_call_site_target DWARF block resolving "
547 "requires known frame which is currently not "
548 "available at %s in %s"),
549 paddress (call_site_gdbarch
, call_site
->pc
),
550 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
553 caller_arch
= get_frame_arch (caller_frame
);
554 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
555 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
556 dwarf_block
->data
, dwarf_block
->size
,
557 dwarf_block
->per_cu
);
558 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
560 if (VALUE_LVAL (val
) == lval_memory
)
561 return value_address (val
);
563 return value_as_address (val
);
566 case FIELD_LOC_KIND_PHYSNAME
:
568 const char *physname
;
569 struct minimal_symbol
*msym
;
571 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
573 /* Handle both the mangled and demangled PHYSNAME. */
574 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
577 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
578 throw_error (NO_ENTRY_VALUE_ERROR
,
579 _("Cannot find function \"%s\" for a call site target "
581 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
582 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
585 return SYMBOL_VALUE_ADDRESS (msym
);
588 case FIELD_LOC_KIND_PHYSADDR
:
589 return FIELD_STATIC_PHYSADDR (call_site
->target
);
592 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
596 /* Convert function entry point exact address ADDR to the function which is
597 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
598 NO_ENTRY_VALUE_ERROR otherwise. */
600 static struct symbol
*
601 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
603 struct symbol
*sym
= find_pc_function (addr
);
606 if (sym
== NULL
|| BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
607 throw_error (NO_ENTRY_VALUE_ERROR
,
608 _("DW_TAG_GNU_call_site resolving failed to find function "
609 "name for address %s"),
610 paddress (gdbarch
, addr
));
612 type
= SYMBOL_TYPE (sym
);
613 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
614 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
619 /* Verify function with entry point exact address ADDR can never call itself
620 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
621 can call itself via tail calls.
623 If a funtion can tail call itself its entry value based parameters are
624 unreliable. There is no verification whether the value of some/all
625 parameters is unchanged through the self tail call, we expect if there is
626 a self tail call all the parameters can be modified. */
629 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
631 struct obstack addr_obstack
;
632 struct cleanup
*old_chain
;
635 /* Track here CORE_ADDRs which were already visited. */
638 /* The verification is completely unordered. Track here function addresses
639 which still need to be iterated. */
640 VEC (CORE_ADDR
) *todo
= NULL
;
642 obstack_init (&addr_obstack
);
643 old_chain
= make_cleanup_obstack_free (&addr_obstack
);
644 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
645 &addr_obstack
, hashtab_obstack_allocate
,
647 make_cleanup_htab_delete (addr_hash
);
649 make_cleanup (VEC_cleanup (CORE_ADDR
), &todo
);
651 VEC_safe_push (CORE_ADDR
, todo
, verify_addr
);
652 while (!VEC_empty (CORE_ADDR
, todo
))
654 struct symbol
*func_sym
;
655 struct call_site
*call_site
;
657 addr
= VEC_pop (CORE_ADDR
, todo
);
659 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
661 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
662 call_site
; call_site
= call_site
->tail_call_next
)
664 CORE_ADDR target_addr
;
667 /* CALLER_FRAME with registers is not available for tail-call jumped
669 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
671 if (target_addr
== verify_addr
)
673 struct minimal_symbol
*msym
;
675 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
676 throw_error (NO_ENTRY_VALUE_ERROR
,
677 _("DW_OP_GNU_entry_value resolving has found "
678 "function \"%s\" at %s can call itself via tail "
680 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
),
681 paddress (gdbarch
, verify_addr
));
684 slot
= htab_find_slot (addr_hash
, &target_addr
, INSERT
);
687 *slot
= obstack_copy (&addr_obstack
, &target_addr
,
688 sizeof (target_addr
));
689 VEC_safe_push (CORE_ADDR
, todo
, target_addr
);
694 do_cleanups (old_chain
);
697 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
698 ENTRY_VALUES_DEBUG. */
701 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
703 CORE_ADDR addr
= call_site
->pc
;
704 struct minimal_symbol
*msym
= lookup_minimal_symbol_by_pc (addr
- 1);
706 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
707 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
711 /* vec.h needs single word type name, typedef it. */
712 typedef struct call_site
*call_sitep
;
714 /* Define VEC (call_sitep) functions. */
715 DEF_VEC_P (call_sitep
);
717 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
718 only top callers and bottom callees which are present in both. GDBARCH is
719 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
720 no remaining possibilities to provide unambiguous non-trivial result.
721 RESULTP should point to NULL on the first (initialization) call. Caller is
722 responsible for xfree of any RESULTP data. */
725 chain_candidate (struct gdbarch
*gdbarch
, struct call_site_chain
**resultp
,
726 VEC (call_sitep
) *chain
)
728 struct call_site_chain
*result
= *resultp
;
729 long length
= VEC_length (call_sitep
, chain
);
730 int callers
, callees
, idx
;
734 /* Create the initial chain containing all the passed PCs. */
736 result
= xmalloc (sizeof (*result
) + sizeof (*result
->call_site
)
738 result
->length
= length
;
739 result
->callers
= result
->callees
= length
;
740 memcpy (result
->call_site
, VEC_address (call_sitep
, chain
),
741 sizeof (*result
->call_site
) * length
);
744 if (entry_values_debug
)
746 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
747 for (idx
= 0; idx
< length
; idx
++)
748 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
749 fputc_unfiltered ('\n', gdb_stdlog
);
755 if (entry_values_debug
)
757 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
758 for (idx
= 0; idx
< length
; idx
++)
759 tailcall_dump (gdbarch
, VEC_index (call_sitep
, chain
, idx
));
760 fputc_unfiltered ('\n', gdb_stdlog
);
763 /* Intersect callers. */
765 callers
= min (result
->callers
, length
);
766 for (idx
= 0; idx
< callers
; idx
++)
767 if (result
->call_site
[idx
] != VEC_index (call_sitep
, chain
, idx
))
769 result
->callers
= idx
;
773 /* Intersect callees. */
775 callees
= min (result
->callees
, length
);
776 for (idx
= 0; idx
< callees
; idx
++)
777 if (result
->call_site
[result
->length
- 1 - idx
]
778 != VEC_index (call_sitep
, chain
, length
- 1 - idx
))
780 result
->callees
= idx
;
784 if (entry_values_debug
)
786 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
787 for (idx
= 0; idx
< result
->callers
; idx
++)
788 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
789 fputs_unfiltered (" |", gdb_stdlog
);
790 for (idx
= 0; idx
< result
->callees
; idx
++)
791 tailcall_dump (gdbarch
, result
->call_site
[result
->length
792 - result
->callees
+ idx
]);
793 fputc_unfiltered ('\n', gdb_stdlog
);
796 if (result
->callers
== 0 && result
->callees
== 0)
798 /* There are no common callers or callees. It could be also a direct
799 call (which has length 0) with ambiguous possibility of an indirect
800 call - CALLERS == CALLEES == 0 is valid during the first allocation
801 but any subsequence processing of such entry means ambiguity. */
807 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
808 PC again. In such case there must be two different code paths to reach
809 it, therefore some of the former determined intermediate PCs must differ
810 and the unambiguous chain gets shortened. */
811 gdb_assert (result
->callers
+ result
->callees
< result
->length
);
814 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
815 assumed frames between them use GDBARCH. Use depth first search so we can
816 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
817 would have needless GDB stack overhead. Caller is responsible for xfree of
818 the returned result. Any unreliability results in thrown
819 NO_ENTRY_VALUE_ERROR. */
821 static struct call_site_chain
*
822 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
825 CORE_ADDR save_callee_pc
= callee_pc
;
826 struct obstack addr_obstack
;
827 struct cleanup
*back_to_retval
, *back_to_workdata
;
828 struct call_site_chain
*retval
= NULL
;
829 struct call_site
*call_site
;
831 /* Mark CALL_SITEs so we do not visit the same ones twice. */
834 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
835 call_site nor any possible call_site at CALLEE_PC's function is there.
836 Any CALL_SITE in CHAIN will be iterated to its siblings - via
837 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
838 VEC (call_sitep
) *chain
= NULL
;
840 /* We are not interested in the specific PC inside the callee function. */
841 callee_pc
= get_pc_function_start (callee_pc
);
843 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
844 paddress (gdbarch
, save_callee_pc
));
846 back_to_retval
= make_cleanup (free_current_contents
, &retval
);
848 obstack_init (&addr_obstack
);
849 back_to_workdata
= make_cleanup_obstack_free (&addr_obstack
);
850 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
851 &addr_obstack
, hashtab_obstack_allocate
,
853 make_cleanup_htab_delete (addr_hash
);
855 make_cleanup (VEC_cleanup (call_sitep
), &chain
);
857 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
858 at the target's function. All the possible tail call sites in the
859 target's function will get iterated as already pushed into CHAIN via their
861 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
865 CORE_ADDR target_func_addr
;
866 struct call_site
*target_call_site
;
868 /* CALLER_FRAME with registers is not available for tail-call jumped
870 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
872 if (target_func_addr
== callee_pc
)
874 chain_candidate (gdbarch
, &retval
, chain
);
878 /* There is no way to reach CALLEE_PC again as we would prevent
879 entering it twice as being already marked in ADDR_HASH. */
880 target_call_site
= NULL
;
884 struct symbol
*target_func
;
886 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
887 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
892 /* Attempt to visit TARGET_CALL_SITE. */
894 if (target_call_site
)
898 slot
= htab_find_slot (addr_hash
, &target_call_site
->pc
, INSERT
);
901 /* Successfully entered TARGET_CALL_SITE. */
903 *slot
= &target_call_site
->pc
;
904 VEC_safe_push (call_sitep
, chain
, target_call_site
);
909 /* Backtrack (without revisiting the originating call_site). Try the
910 callers's sibling; if there isn't any try the callers's callers's
913 target_call_site
= NULL
;
914 while (!VEC_empty (call_sitep
, chain
))
916 call_site
= VEC_pop (call_sitep
, chain
);
918 gdb_assert (htab_find_slot (addr_hash
, &call_site
->pc
,
920 htab_remove_elt (addr_hash
, &call_site
->pc
);
922 target_call_site
= call_site
->tail_call_next
;
923 if (target_call_site
)
927 while (target_call_site
);
929 if (VEC_empty (call_sitep
, chain
))
932 call_site
= VEC_last (call_sitep
, chain
);
937 struct minimal_symbol
*msym_caller
, *msym_callee
;
939 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
940 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
941 throw_error (NO_ENTRY_VALUE_ERROR
,
942 _("There are no unambiguously determinable intermediate "
943 "callers or callees between caller function \"%s\" at %s "
944 "and callee function \"%s\" at %s"),
946 ? "???" : SYMBOL_PRINT_NAME (msym_caller
)),
947 paddress (gdbarch
, caller_pc
),
949 ? "???" : SYMBOL_PRINT_NAME (msym_callee
)),
950 paddress (gdbarch
, callee_pc
));
953 do_cleanups (back_to_workdata
);
954 discard_cleanups (back_to_retval
);
958 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
959 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
960 constructed return NULL. Caller is responsible for xfree of the returned
963 struct call_site_chain
*
964 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
967 volatile struct gdb_exception e
;
968 struct call_site_chain
*retval
= NULL
;
970 TRY_CATCH (e
, RETURN_MASK_ERROR
)
972 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
976 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
978 if (entry_values_debug
)
979 exception_print (gdb_stdout
, e
);
989 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
992 call_site_parameter_matches (struct call_site_parameter
*parameter
,
993 enum call_site_parameter_kind kind
,
994 union call_site_parameter_u kind_u
)
996 if (kind
== parameter
->kind
)
999 case CALL_SITE_PARAMETER_DWARF_REG
:
1000 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
1001 case CALL_SITE_PARAMETER_FB_OFFSET
:
1002 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
1003 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
1004 return kind_u
.param_offset
.cu_off
== parameter
->u
.param_offset
.cu_off
;
1009 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1010 FRAME is for callee.
1012 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1015 static struct call_site_parameter
*
1016 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
1017 enum call_site_parameter_kind kind
,
1018 union call_site_parameter_u kind_u
,
1019 struct dwarf2_per_cu_data
**per_cu_return
)
1021 CORE_ADDR func_addr
, caller_pc
;
1022 struct gdbarch
*gdbarch
;
1023 struct frame_info
*caller_frame
;
1024 struct call_site
*call_site
;
1026 /* Initialize it just to avoid a GCC false warning. */
1027 struct call_site_parameter
*parameter
= NULL
;
1028 CORE_ADDR target_addr
;
1030 while (get_frame_type (frame
) == INLINE_FRAME
)
1032 frame
= get_prev_frame (frame
);
1033 gdb_assert (frame
!= NULL
);
1036 func_addr
= get_frame_func (frame
);
1037 gdbarch
= get_frame_arch (frame
);
1038 caller_frame
= get_prev_frame (frame
);
1039 if (gdbarch
!= frame_unwind_arch (frame
))
1041 struct minimal_symbol
*msym
= lookup_minimal_symbol_by_pc (func_addr
);
1042 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1044 throw_error (NO_ENTRY_VALUE_ERROR
,
1045 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1046 "(of %s (%s)) does not match caller gdbarch %s"),
1047 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1048 paddress (gdbarch
, func_addr
),
1049 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
),
1050 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1053 if (caller_frame
== NULL
)
1055 struct minimal_symbol
*msym
= lookup_minimal_symbol_by_pc (func_addr
);
1057 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_GNU_entry_value resolving "
1058 "requires caller of %s (%s)"),
1059 paddress (gdbarch
, func_addr
),
1060 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
1062 caller_pc
= get_frame_pc (caller_frame
);
1063 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1065 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1066 if (target_addr
!= func_addr
)
1068 struct minimal_symbol
*target_msym
, *func_msym
;
1070 target_msym
= lookup_minimal_symbol_by_pc (target_addr
);
1071 func_msym
= lookup_minimal_symbol_by_pc (func_addr
);
1072 throw_error (NO_ENTRY_VALUE_ERROR
,
1073 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1074 "but the called frame is for %s at %s"),
1075 (target_msym
== NULL
? "???"
1076 : SYMBOL_PRINT_NAME (target_msym
)),
1077 paddress (gdbarch
, target_addr
),
1078 func_msym
== NULL
? "???" : SYMBOL_PRINT_NAME (func_msym
),
1079 paddress (gdbarch
, func_addr
));
1082 /* No entry value based parameters would be reliable if this function can
1083 call itself via tail calls. */
1084 func_verify_no_selftailcall (gdbarch
, func_addr
);
1086 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1088 parameter
= &call_site
->parameter
[iparams
];
1089 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1092 if (iparams
== call_site
->parameter_count
)
1094 struct minimal_symbol
*msym
= lookup_minimal_symbol_by_pc (caller_pc
);
1096 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1097 determine its value. */
1098 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1099 "at DW_TAG_GNU_call_site %s at %s"),
1100 paddress (gdbarch
, caller_pc
),
1101 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
1104 *per_cu_return
= call_site
->per_cu
;
1108 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1109 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1110 DW_AT_GNU_call_site_data_value (dereferenced) block.
1112 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1115 Function always returns non-NULL, non-optimized out value. It throws
1116 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1118 static struct value
*
1119 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1120 CORE_ADDR deref_size
, struct type
*type
,
1121 struct frame_info
*caller_frame
,
1122 struct dwarf2_per_cu_data
*per_cu
)
1124 const gdb_byte
*data_src
;
1128 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1129 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1131 /* DEREF_SIZE size is not verified here. */
1132 if (data_src
== NULL
)
1133 throw_error (NO_ENTRY_VALUE_ERROR
,
1134 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1136 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1137 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1139 data
= alloca (size
+ 1);
1140 memcpy (data
, data_src
, size
);
1141 data
[size
] = DW_OP_stack_value
;
1143 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1146 /* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
1147 Choose DEREF_SIZE value of that parameter. Search caller of the CTX's
1148 frame. CTX must be of dwarf_expr_ctx_funcs kind.
1150 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1151 can be more simple as it does not support cross-CU DWARF executions. */
1154 dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
1155 enum call_site_parameter_kind kind
,
1156 union call_site_parameter_u kind_u
,
1159 struct dwarf_expr_baton
*debaton
;
1160 struct frame_info
*frame
, *caller_frame
;
1161 struct dwarf2_per_cu_data
*caller_per_cu
;
1162 struct dwarf_expr_baton baton_local
;
1163 struct dwarf_expr_context saved_ctx
;
1164 struct call_site_parameter
*parameter
;
1165 const gdb_byte
*data_src
;
1168 gdb_assert (ctx
->funcs
== &dwarf_expr_ctx_funcs
);
1169 debaton
= ctx
->baton
;
1170 frame
= debaton
->frame
;
1171 caller_frame
= get_prev_frame (frame
);
1173 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1175 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1176 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1178 /* DEREF_SIZE size is not verified here. */
1179 if (data_src
== NULL
)
1180 throw_error (NO_ENTRY_VALUE_ERROR
,
1181 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1183 baton_local
.frame
= caller_frame
;
1184 baton_local
.per_cu
= caller_per_cu
;
1186 saved_ctx
.gdbarch
= ctx
->gdbarch
;
1187 saved_ctx
.addr_size
= ctx
->addr_size
;
1188 saved_ctx
.offset
= ctx
->offset
;
1189 saved_ctx
.baton
= ctx
->baton
;
1190 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (baton_local
.per_cu
));
1191 ctx
->addr_size
= dwarf2_per_cu_addr_size (baton_local
.per_cu
);
1192 ctx
->offset
= dwarf2_per_cu_text_offset (baton_local
.per_cu
);
1193 ctx
->baton
= &baton_local
;
1195 dwarf_expr_eval (ctx
, data_src
, size
);
1197 ctx
->gdbarch
= saved_ctx
.gdbarch
;
1198 ctx
->addr_size
= saved_ctx
.addr_size
;
1199 ctx
->offset
= saved_ctx
.offset
;
1200 ctx
->baton
= saved_ctx
.baton
;
1203 /* Callback function for dwarf2_evaluate_loc_desc.
1204 Fetch the address indexed by DW_OP_GNU_addr_index. */
1207 dwarf_expr_get_addr_index (void *baton
, unsigned int index
)
1209 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
1211 return dwarf2_read_addr_index (debaton
->per_cu
, index
);
1214 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1215 the indirect method on it, that is use its stored target value, the sole
1216 purpose of entry_data_value_funcs.. */
1218 static struct value
*
1219 entry_data_value_coerce_ref (const struct value
*value
)
1221 struct type
*checked_type
= check_typedef (value_type (value
));
1222 struct value
*target_val
;
1224 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
)
1227 target_val
= value_computed_closure (value
);
1228 value_incref (target_val
);
1232 /* Implement copy_closure. */
1235 entry_data_value_copy_closure (const struct value
*v
)
1237 struct value
*target_val
= value_computed_closure (v
);
1239 value_incref (target_val
);
1243 /* Implement free_closure. */
1246 entry_data_value_free_closure (struct value
*v
)
1248 struct value
*target_val
= value_computed_closure (v
);
1250 value_free (target_val
);
1253 /* Vector for methods for an entry value reference where the referenced value
1254 is stored in the caller. On the first dereference use
1255 DW_AT_GNU_call_site_data_value in the caller. */
1257 static const struct lval_funcs entry_data_value_funcs
=
1261 NULL
, /* check_validity */
1262 NULL
, /* check_any_valid */
1263 NULL
, /* indirect */
1264 entry_data_value_coerce_ref
,
1265 NULL
, /* check_synthetic_pointer */
1266 entry_data_value_copy_closure
,
1267 entry_data_value_free_closure
1270 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1271 are used to match DW_AT_location at the caller's
1272 DW_TAG_GNU_call_site_parameter.
1274 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1275 cannot resolve the parameter for any reason. */
1277 static struct value
*
1278 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1279 enum call_site_parameter_kind kind
,
1280 union call_site_parameter_u kind_u
)
1282 struct type
*checked_type
= check_typedef (type
);
1283 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1284 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1285 struct value
*outer_val
, *target_val
, *val
;
1286 struct call_site_parameter
*parameter
;
1287 struct dwarf2_per_cu_data
*caller_per_cu
;
1290 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1293 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1297 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1298 used and it is not available do not fall back to OUTER_VAL - dereferencing
1299 TYPE_CODE_REF with non-entry data value would give current value - not the
1302 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
1303 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1306 target_val
= dwarf_entry_parameter_to_value (parameter
,
1307 TYPE_LENGTH (target_type
),
1308 target_type
, caller_frame
,
1311 /* value_as_address dereferences TYPE_CODE_REF. */
1312 addr
= extract_typed_address (value_contents (outer_val
), checked_type
);
1314 /* The target entry value has artificial address of the entry value
1316 VALUE_LVAL (target_val
) = lval_memory
;
1317 set_value_address (target_val
, addr
);
1319 release_value (target_val
);
1320 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1321 target_val
/* closure */);
1323 /* Copy the referencing pointer to the new computed value. */
1324 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1325 TYPE_LENGTH (checked_type
));
1326 set_value_lazy (val
, 0);
1331 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1332 SIZE are DWARF block used to match DW_AT_location at the caller's
1333 DW_TAG_GNU_call_site_parameter.
1335 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1336 cannot resolve the parameter for any reason. */
1338 static struct value
*
1339 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1340 const gdb_byte
*block
, size_t block_len
)
1342 union call_site_parameter_u kind_u
;
1344 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1345 if (kind_u
.dwarf_reg
!= -1)
1346 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1349 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1350 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1353 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1354 suppressed during normal operation. The expression can be arbitrary if
1355 there is no caller-callee entry value binding expected. */
1356 throw_error (NO_ENTRY_VALUE_ERROR
,
1357 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1358 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1361 struct piece_closure
1363 /* Reference count. */
1366 /* The CU from which this closure's expression came. */
1367 struct dwarf2_per_cu_data
*per_cu
;
1369 /* The number of pieces used to describe this variable. */
1372 /* The target address size, used only for DWARF_VALUE_STACK. */
1375 /* The pieces themselves. */
1376 struct dwarf_expr_piece
*pieces
;
1379 /* Allocate a closure for a value formed from separately-described
1382 static struct piece_closure
*
1383 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1384 int n_pieces
, struct dwarf_expr_piece
*pieces
,
1387 struct piece_closure
*c
= XZALLOC (struct piece_closure
);
1392 c
->n_pieces
= n_pieces
;
1393 c
->addr_size
= addr_size
;
1394 c
->pieces
= XCALLOC (n_pieces
, struct dwarf_expr_piece
);
1396 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
1397 for (i
= 0; i
< n_pieces
; ++i
)
1398 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1399 value_incref (c
->pieces
[i
].v
.value
);
1404 /* The lowest-level function to extract bits from a byte buffer.
1405 SOURCE is the buffer. It is updated if we read to the end of a
1407 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1408 updated to reflect the number of bits actually read.
1409 NBITS is the number of bits we want to read. It is updated to
1410 reflect the number of bits actually read. This function may read
1412 BITS_BIG_ENDIAN is taken directly from gdbarch.
1413 This function returns the extracted bits. */
1416 extract_bits_primitive (const gdb_byte
**source
,
1417 unsigned int *source_offset_bits
,
1418 int *nbits
, int bits_big_endian
)
1420 unsigned int avail
, mask
, datum
;
1422 gdb_assert (*source_offset_bits
< 8);
1424 avail
= 8 - *source_offset_bits
;
1428 mask
= (1 << avail
) - 1;
1430 if (bits_big_endian
)
1431 datum
>>= 8 - (*source_offset_bits
+ *nbits
);
1433 datum
>>= *source_offset_bits
;
1437 *source_offset_bits
+= avail
;
1438 if (*source_offset_bits
>= 8)
1440 *source_offset_bits
-= 8;
1447 /* Extract some bits from a source buffer and move forward in the
1450 SOURCE is the source buffer. It is updated as bytes are read.
1451 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1453 NBITS is the number of bits to read.
1454 BITS_BIG_ENDIAN is taken directly from gdbarch.
1456 This function returns the bits that were read. */
1459 extract_bits (const gdb_byte
**source
, unsigned int *source_offset_bits
,
1460 int nbits
, int bits_big_endian
)
1464 gdb_assert (nbits
> 0 && nbits
<= 8);
1466 datum
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1472 more
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1474 if (bits_big_endian
)
1484 /* Write some bits into a buffer and move forward in the buffer.
1486 DATUM is the bits to write. The low-order bits of DATUM are used.
1487 DEST is the destination buffer. It is updated as bytes are
1489 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1491 NBITS is the number of valid bits in DATUM.
1492 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1495 insert_bits (unsigned int datum
,
1496 gdb_byte
*dest
, unsigned int dest_offset_bits
,
1497 int nbits
, int bits_big_endian
)
1501 gdb_assert (dest_offset_bits
+ nbits
<= 8);
1503 mask
= (1 << nbits
) - 1;
1504 if (bits_big_endian
)
1506 datum
<<= 8 - (dest_offset_bits
+ nbits
);
1507 mask
<<= 8 - (dest_offset_bits
+ nbits
);
1511 datum
<<= dest_offset_bits
;
1512 mask
<<= dest_offset_bits
;
1515 gdb_assert ((datum
& ~mask
) == 0);
1517 *dest
= (*dest
& ~mask
) | datum
;
1520 /* Copy bits from a source to a destination.
1522 DEST is where the bits should be written.
1523 DEST_OFFSET_BITS is the bit offset into DEST.
1524 SOURCE is the source of bits.
1525 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1526 BIT_COUNT is the number of bits to copy.
1527 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1530 copy_bitwise (gdb_byte
*dest
, unsigned int dest_offset_bits
,
1531 const gdb_byte
*source
, unsigned int source_offset_bits
,
1532 unsigned int bit_count
,
1533 int bits_big_endian
)
1535 unsigned int dest_avail
;
1538 /* Reduce everything to byte-size pieces. */
1539 dest
+= dest_offset_bits
/ 8;
1540 dest_offset_bits
%= 8;
1541 source
+= source_offset_bits
/ 8;
1542 source_offset_bits
%= 8;
1544 dest_avail
= 8 - dest_offset_bits
% 8;
1546 /* See if we can fill the first destination byte. */
1547 if (dest_avail
< bit_count
)
1549 datum
= extract_bits (&source
, &source_offset_bits
, dest_avail
,
1551 insert_bits (datum
, dest
, dest_offset_bits
, dest_avail
, bits_big_endian
);
1553 dest_offset_bits
= 0;
1554 bit_count
-= dest_avail
;
1557 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1558 than 8 bits remaining. */
1559 gdb_assert (dest_offset_bits
% 8 == 0 || bit_count
< 8);
1560 for (; bit_count
>= 8; bit_count
-= 8)
1562 datum
= extract_bits (&source
, &source_offset_bits
, 8, bits_big_endian
);
1563 *dest
++ = (gdb_byte
) datum
;
1566 /* Finally, we may have a few leftover bits. */
1567 gdb_assert (bit_count
<= 8 - dest_offset_bits
% 8);
1570 datum
= extract_bits (&source
, &source_offset_bits
, bit_count
,
1572 insert_bits (datum
, dest
, dest_offset_bits
, bit_count
, bits_big_endian
);
1577 read_pieced_value (struct value
*v
)
1581 ULONGEST bits_to_skip
;
1583 struct piece_closure
*c
1584 = (struct piece_closure
*) value_computed_closure (v
);
1585 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (v
));
1587 size_t buffer_size
= 0;
1588 char *buffer
= NULL
;
1589 struct cleanup
*cleanup
;
1591 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1593 if (value_type (v
) != value_enclosing_type (v
))
1594 internal_error (__FILE__
, __LINE__
,
1595 _("Should not be able to create a lazy value with "
1596 "an enclosing type"));
1598 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1600 contents
= value_contents_raw (v
);
1601 bits_to_skip
= 8 * value_offset (v
);
1602 if (value_bitsize (v
))
1604 bits_to_skip
+= value_bitpos (v
);
1605 type_len
= value_bitsize (v
);
1608 type_len
= 8 * TYPE_LENGTH (value_type (v
));
1610 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1612 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1613 size_t this_size
, this_size_bits
;
1614 long dest_offset_bits
, source_offset_bits
, source_offset
;
1615 const gdb_byte
*intermediate_buffer
;
1617 /* Compute size, source, and destination offsets for copying, in
1619 this_size_bits
= p
->size
;
1620 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1622 bits_to_skip
-= this_size_bits
;
1625 if (this_size_bits
> type_len
- offset
)
1626 this_size_bits
= type_len
- offset
;
1627 if (bits_to_skip
> 0)
1629 dest_offset_bits
= 0;
1630 source_offset_bits
= bits_to_skip
;
1631 this_size_bits
-= bits_to_skip
;
1636 dest_offset_bits
= offset
;
1637 source_offset_bits
= 0;
1640 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1641 source_offset
= source_offset_bits
/ 8;
1642 if (buffer_size
< this_size
)
1644 buffer_size
= this_size
;
1645 buffer
= xrealloc (buffer
, buffer_size
);
1647 intermediate_buffer
= buffer
;
1649 /* Copy from the source to DEST_BUFFER. */
1650 switch (p
->location
)
1652 case DWARF_VALUE_REGISTER
:
1654 struct gdbarch
*arch
= get_frame_arch (frame
);
1655 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1656 int reg_offset
= source_offset
;
1658 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1659 && this_size
< register_size (arch
, gdb_regnum
))
1661 /* Big-endian, and we want less than full size. */
1662 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1663 /* We want the lower-order THIS_SIZE_BITS of the bytes
1664 we extract from the register. */
1665 source_offset_bits
+= 8 * this_size
- this_size_bits
;
1668 if (gdb_regnum
!= -1)
1672 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1676 /* Just so garbage doesn't ever shine through. */
1677 memset (buffer
, 0, this_size
);
1680 set_value_optimized_out (v
, 1);
1682 mark_value_bytes_unavailable (v
, offset
, this_size
);
1687 error (_("Unable to access DWARF register number %s"),
1688 paddress (arch
, p
->v
.regno
));
1693 case DWARF_VALUE_MEMORY
:
1694 read_value_memory (v
, offset
,
1695 p
->v
.mem
.in_stack_memory
,
1696 p
->v
.mem
.addr
+ source_offset
,
1700 case DWARF_VALUE_STACK
:
1702 size_t n
= this_size
;
1704 if (n
> c
->addr_size
- source_offset
)
1705 n
= (c
->addr_size
>= source_offset
1706 ? c
->addr_size
- source_offset
1714 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
1716 intermediate_buffer
= val_bytes
+ source_offset
;
1721 case DWARF_VALUE_LITERAL
:
1723 size_t n
= this_size
;
1725 if (n
> p
->v
.literal
.length
- source_offset
)
1726 n
= (p
->v
.literal
.length
>= source_offset
1727 ? p
->v
.literal
.length
- source_offset
1730 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
1734 /* These bits show up as zeros -- but do not cause the value
1735 to be considered optimized-out. */
1736 case DWARF_VALUE_IMPLICIT_POINTER
:
1739 case DWARF_VALUE_OPTIMIZED_OUT
:
1740 set_value_optimized_out (v
, 1);
1744 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1747 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
1748 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1749 copy_bitwise (contents
, dest_offset_bits
,
1750 intermediate_buffer
, source_offset_bits
% 8,
1751 this_size_bits
, bits_big_endian
);
1753 offset
+= this_size_bits
;
1756 do_cleanups (cleanup
);
1760 write_pieced_value (struct value
*to
, struct value
*from
)
1764 ULONGEST bits_to_skip
;
1765 const gdb_byte
*contents
;
1766 struct piece_closure
*c
1767 = (struct piece_closure
*) value_computed_closure (to
);
1768 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
1770 size_t buffer_size
= 0;
1771 char *buffer
= NULL
;
1772 struct cleanup
*cleanup
;
1774 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
1778 set_value_optimized_out (to
, 1);
1782 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1784 contents
= value_contents (from
);
1785 bits_to_skip
= 8 * value_offset (to
);
1786 if (value_bitsize (to
))
1788 bits_to_skip
+= value_bitpos (to
);
1789 type_len
= value_bitsize (to
);
1792 type_len
= 8 * TYPE_LENGTH (value_type (to
));
1794 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1796 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1797 size_t this_size_bits
, this_size
;
1798 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
1800 const gdb_byte
*source_buffer
;
1802 this_size_bits
= p
->size
;
1803 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1805 bits_to_skip
-= this_size_bits
;
1808 if (this_size_bits
> type_len
- offset
)
1809 this_size_bits
= type_len
- offset
;
1810 if (bits_to_skip
> 0)
1812 dest_offset_bits
= bits_to_skip
;
1813 source_offset_bits
= 0;
1814 this_size_bits
-= bits_to_skip
;
1819 dest_offset_bits
= 0;
1820 source_offset_bits
= offset
;
1823 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1824 source_offset
= source_offset_bits
/ 8;
1825 dest_offset
= dest_offset_bits
/ 8;
1826 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
1828 source_buffer
= contents
+ source_offset
;
1833 if (buffer_size
< this_size
)
1835 buffer_size
= this_size
;
1836 buffer
= xrealloc (buffer
, buffer_size
);
1838 source_buffer
= buffer
;
1842 switch (p
->location
)
1844 case DWARF_VALUE_REGISTER
:
1846 struct gdbarch
*arch
= get_frame_arch (frame
);
1847 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1848 int reg_offset
= dest_offset
;
1850 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1851 && this_size
<= register_size (arch
, gdb_regnum
))
1852 /* Big-endian, and we want less than full size. */
1853 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1855 if (gdb_regnum
!= -1)
1861 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1866 error (_("Can't do read-modify-write to "
1867 "update bitfield; containing word has been "
1870 throw_error (NOT_AVAILABLE_ERROR
,
1871 _("Can't do read-modify-write to update "
1872 "bitfield; containing word "
1875 copy_bitwise (buffer
, dest_offset_bits
,
1876 contents
, source_offset_bits
,
1881 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1882 this_size
, source_buffer
);
1886 error (_("Unable to write to DWARF register number %s"),
1887 paddress (arch
, p
->v
.regno
));
1891 case DWARF_VALUE_MEMORY
:
1894 /* Only the first and last bytes can possibly have any
1896 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
, 1);
1897 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
1898 buffer
+ this_size
- 1, 1);
1899 copy_bitwise (buffer
, dest_offset_bits
,
1900 contents
, source_offset_bits
,
1905 write_memory (p
->v
.mem
.addr
+ dest_offset
,
1906 source_buffer
, this_size
);
1909 set_value_optimized_out (to
, 1);
1912 offset
+= this_size_bits
;
1915 do_cleanups (cleanup
);
1918 /* A helper function that checks bit validity in a pieced value.
1919 CHECK_FOR indicates the kind of validity checking.
1920 DWARF_VALUE_MEMORY means to check whether any bit is valid.
1921 DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
1923 DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
1924 implicit pointer. */
1927 check_pieced_value_bits (const struct value
*value
, int bit_offset
,
1929 enum dwarf_value_location check_for
)
1931 struct piece_closure
*c
1932 = (struct piece_closure
*) value_computed_closure (value
);
1934 int validity
= (check_for
== DWARF_VALUE_MEMORY
1935 || check_for
== DWARF_VALUE_IMPLICIT_POINTER
);
1937 bit_offset
+= 8 * value_offset (value
);
1938 if (value_bitsize (value
))
1939 bit_offset
+= value_bitpos (value
);
1941 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
1943 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1944 size_t this_size_bits
= p
->size
;
1948 if (bit_offset
>= this_size_bits
)
1950 bit_offset
-= this_size_bits
;
1954 bit_length
-= this_size_bits
- bit_offset
;
1958 bit_length
-= this_size_bits
;
1960 if (check_for
== DWARF_VALUE_IMPLICIT_POINTER
)
1962 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1965 else if (p
->location
== DWARF_VALUE_OPTIMIZED_OUT
1966 || p
->location
== DWARF_VALUE_IMPLICIT_POINTER
)
1982 check_pieced_value_validity (const struct value
*value
, int bit_offset
,
1985 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
1986 DWARF_VALUE_MEMORY
);
1990 check_pieced_value_invalid (const struct value
*value
)
1992 return check_pieced_value_bits (value
, 0,
1993 8 * TYPE_LENGTH (value_type (value
)),
1994 DWARF_VALUE_OPTIMIZED_OUT
);
1997 /* An implementation of an lval_funcs method to see whether a value is
1998 a synthetic pointer. */
2001 check_pieced_synthetic_pointer (const struct value
*value
, int bit_offset
,
2004 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
2005 DWARF_VALUE_IMPLICIT_POINTER
);
2008 /* A wrapper function for get_frame_address_in_block. */
2011 get_frame_address_in_block_wrapper (void *baton
)
2013 return get_frame_address_in_block (baton
);
2016 /* An implementation of an lval_funcs method to indirect through a
2017 pointer. This handles the synthetic pointer case when needed. */
2019 static struct value
*
2020 indirect_pieced_value (struct value
*value
)
2022 struct piece_closure
*c
2023 = (struct piece_closure
*) value_computed_closure (value
);
2025 struct frame_info
*frame
;
2026 struct dwarf2_locexpr_baton baton
;
2027 int i
, bit_offset
, bit_length
;
2028 struct dwarf_expr_piece
*piece
= NULL
;
2029 LONGEST byte_offset
;
2031 type
= check_typedef (value_type (value
));
2032 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
2035 bit_length
= 8 * TYPE_LENGTH (type
);
2036 bit_offset
= 8 * value_offset (value
);
2037 if (value_bitsize (value
))
2038 bit_offset
+= value_bitpos (value
);
2040 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2042 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2043 size_t this_size_bits
= p
->size
;
2047 if (bit_offset
>= this_size_bits
)
2049 bit_offset
-= this_size_bits
;
2053 bit_length
-= this_size_bits
- bit_offset
;
2057 bit_length
-= this_size_bits
;
2059 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2062 if (bit_length
!= 0)
2063 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2069 frame
= get_selected_frame (_("No frame selected."));
2071 /* This is an offset requested by GDB, such as value subcripts. */
2072 byte_offset
= value_as_address (value
);
2076 = dwarf2_fetch_die_loc_sect_off (piece
->v
.ptr
.die
, c
->per_cu
,
2077 get_frame_address_in_block_wrapper
,
2080 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
2081 baton
.data
, baton
.size
, baton
.per_cu
,
2082 piece
->v
.ptr
.offset
+ byte_offset
);
2086 copy_pieced_value_closure (const struct value
*v
)
2088 struct piece_closure
*c
2089 = (struct piece_closure
*) value_computed_closure (v
);
2096 free_pieced_value_closure (struct value
*v
)
2098 struct piece_closure
*c
2099 = (struct piece_closure
*) value_computed_closure (v
);
2106 for (i
= 0; i
< c
->n_pieces
; ++i
)
2107 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
2108 value_free (c
->pieces
[i
].v
.value
);
2115 /* Functions for accessing a variable described by DW_OP_piece. */
2116 static const struct lval_funcs pieced_value_funcs
= {
2119 check_pieced_value_validity
,
2120 check_pieced_value_invalid
,
2121 indirect_pieced_value
,
2122 NULL
, /* coerce_ref */
2123 check_pieced_synthetic_pointer
,
2124 copy_pieced_value_closure
,
2125 free_pieced_value_closure
2128 /* Helper function which throws an error if a synthetic pointer is
2132 invalid_synthetic_pointer (void)
2134 error (_("access outside bounds of object "
2135 "referenced via synthetic pointer"));
2138 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2140 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
=
2142 dwarf_expr_read_reg
,
2143 dwarf_expr_read_mem
,
2144 dwarf_expr_frame_base
,
2145 dwarf_expr_frame_cfa
,
2146 dwarf_expr_frame_pc
,
2147 dwarf_expr_tls_address
,
2148 dwarf_expr_dwarf_call
,
2149 dwarf_expr_get_base_type
,
2150 dwarf_expr_push_dwarf_reg_entry_value
,
2151 dwarf_expr_get_addr_index
2154 /* Evaluate a location description, starting at DATA and with length
2155 SIZE, to find the current location of variable of TYPE in the
2156 context of FRAME. BYTE_OFFSET is applied after the contents are
2159 static struct value
*
2160 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2161 const gdb_byte
*data
, size_t size
,
2162 struct dwarf2_per_cu_data
*per_cu
,
2163 LONGEST byte_offset
)
2165 struct value
*retval
;
2166 struct dwarf_expr_baton baton
;
2167 struct dwarf_expr_context
*ctx
;
2168 struct cleanup
*old_chain
, *value_chain
;
2169 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2170 volatile struct gdb_exception ex
;
2172 if (byte_offset
< 0)
2173 invalid_synthetic_pointer ();
2176 return allocate_optimized_out_value (type
);
2178 baton
.frame
= frame
;
2179 baton
.per_cu
= per_cu
;
2181 ctx
= new_dwarf_expr_context ();
2182 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2183 value_chain
= make_cleanup_value_free_to_mark (value_mark ());
2185 ctx
->gdbarch
= get_objfile_arch (objfile
);
2186 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2187 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2188 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2189 ctx
->baton
= &baton
;
2190 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2192 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2194 dwarf_expr_eval (ctx
, data
, size
);
2198 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2200 do_cleanups (old_chain
);
2201 retval
= allocate_value (type
);
2202 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
2205 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2207 if (entry_values_debug
)
2208 exception_print (gdb_stdout
, ex
);
2209 do_cleanups (old_chain
);
2210 return allocate_optimized_out_value (type
);
2213 throw_exception (ex
);
2216 if (ctx
->num_pieces
> 0)
2218 struct piece_closure
*c
;
2219 struct frame_id frame_id
= get_frame_id (frame
);
2220 ULONGEST bit_size
= 0;
2223 for (i
= 0; i
< ctx
->num_pieces
; ++i
)
2224 bit_size
+= ctx
->pieces
[i
].size
;
2225 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
2226 invalid_synthetic_pointer ();
2228 c
= allocate_piece_closure (per_cu
, ctx
->num_pieces
, ctx
->pieces
,
2230 /* We must clean up the value chain after creating the piece
2231 closure but before allocating the result. */
2232 do_cleanups (value_chain
);
2233 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
2234 VALUE_FRAME_ID (retval
) = frame_id
;
2235 set_value_offset (retval
, byte_offset
);
2239 switch (ctx
->location
)
2241 case DWARF_VALUE_REGISTER
:
2243 struct gdbarch
*arch
= get_frame_arch (frame
);
2244 ULONGEST dwarf_regnum
= value_as_long (dwarf_expr_fetch (ctx
, 0));
2245 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
2247 if (byte_offset
!= 0)
2248 error (_("cannot use offset on synthetic pointer to register"));
2249 do_cleanups (value_chain
);
2250 if (gdb_regnum
!= -1)
2251 retval
= value_from_register (type
, gdb_regnum
, frame
);
2253 error (_("Unable to access DWARF register number %s"),
2254 paddress (arch
, dwarf_regnum
));
2258 case DWARF_VALUE_MEMORY
:
2260 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
2261 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
2263 do_cleanups (value_chain
);
2264 retval
= allocate_value_lazy (type
);
2265 VALUE_LVAL (retval
) = lval_memory
;
2266 if (in_stack_memory
)
2267 set_value_stack (retval
, 1);
2268 set_value_address (retval
, address
+ byte_offset
);
2272 case DWARF_VALUE_STACK
:
2274 struct value
*value
= dwarf_expr_fetch (ctx
, 0);
2276 const gdb_byte
*val_bytes
;
2277 size_t n
= TYPE_LENGTH (value_type (value
));
2279 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2280 invalid_synthetic_pointer ();
2282 val_bytes
= value_contents_all (value
);
2283 val_bytes
+= byte_offset
;
2286 /* Preserve VALUE because we are going to free values back
2287 to the mark, but we still need the value contents
2289 value_incref (value
);
2290 do_cleanups (value_chain
);
2291 make_cleanup_value_free (value
);
2293 retval
= allocate_value (type
);
2294 contents
= value_contents_raw (retval
);
2295 if (n
> TYPE_LENGTH (type
))
2297 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2299 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2300 val_bytes
+= n
- TYPE_LENGTH (type
);
2301 n
= TYPE_LENGTH (type
);
2303 memcpy (contents
, val_bytes
, n
);
2307 case DWARF_VALUE_LITERAL
:
2310 const bfd_byte
*ldata
;
2311 size_t n
= ctx
->len
;
2313 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2314 invalid_synthetic_pointer ();
2316 do_cleanups (value_chain
);
2317 retval
= allocate_value (type
);
2318 contents
= value_contents_raw (retval
);
2320 ldata
= ctx
->data
+ byte_offset
;
2323 if (n
> TYPE_LENGTH (type
))
2325 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2327 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2328 ldata
+= n
- TYPE_LENGTH (type
);
2329 n
= TYPE_LENGTH (type
);
2331 memcpy (contents
, ldata
, n
);
2335 case DWARF_VALUE_OPTIMIZED_OUT
:
2336 do_cleanups (value_chain
);
2337 retval
= allocate_optimized_out_value (type
);
2340 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2341 operation by execute_stack_op. */
2342 case DWARF_VALUE_IMPLICIT_POINTER
:
2343 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2344 it can only be encountered when making a piece. */
2346 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2350 set_value_initialized (retval
, ctx
->initialized
);
2352 do_cleanups (old_chain
);
2357 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2358 passes 0 as the byte_offset. */
2361 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2362 const gdb_byte
*data
, size_t size
,
2363 struct dwarf2_per_cu_data
*per_cu
)
2365 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
2369 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2371 struct needs_frame_baton
2374 struct dwarf2_per_cu_data
*per_cu
;
2377 /* Reads from registers do require a frame. */
2379 needs_frame_read_reg (void *baton
, int regnum
)
2381 struct needs_frame_baton
*nf_baton
= baton
;
2383 nf_baton
->needs_frame
= 1;
2387 /* Reads from memory do not require a frame. */
2389 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
2391 memset (buf
, 0, len
);
2394 /* Frame-relative accesses do require a frame. */
2396 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
2398 static gdb_byte lit0
= DW_OP_lit0
;
2399 struct needs_frame_baton
*nf_baton
= baton
;
2404 nf_baton
->needs_frame
= 1;
2407 /* CFA accesses require a frame. */
2410 needs_frame_frame_cfa (void *baton
)
2412 struct needs_frame_baton
*nf_baton
= baton
;
2414 nf_baton
->needs_frame
= 1;
2418 /* Thread-local accesses do require a frame. */
2420 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
2422 struct needs_frame_baton
*nf_baton
= baton
;
2424 nf_baton
->needs_frame
= 1;
2428 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2431 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
2433 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2435 per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
,
2436 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
2439 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2442 needs_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
2443 enum call_site_parameter_kind kind
,
2444 union call_site_parameter_u kind_u
, int deref_size
)
2446 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2448 nf_baton
->needs_frame
= 1;
2450 /* The expression may require some stub values on DWARF stack. */
2451 dwarf_expr_push_address (ctx
, 0, 0);
2454 /* DW_OP_GNU_addr_index doesn't require a frame. */
2457 needs_get_addr_index (void *baton
, unsigned int index
)
2459 /* Nothing to do. */
2463 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2465 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs
=
2467 needs_frame_read_reg
,
2468 needs_frame_read_mem
,
2469 needs_frame_frame_base
,
2470 needs_frame_frame_cfa
,
2471 needs_frame_frame_cfa
, /* get_frame_pc */
2472 needs_frame_tls_address
,
2473 needs_frame_dwarf_call
,
2474 NULL
, /* get_base_type */
2475 needs_dwarf_reg_entry_value
,
2476 needs_get_addr_index
2479 /* Return non-zero iff the location expression at DATA (length SIZE)
2480 requires a frame to evaluate. */
2483 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, size_t size
,
2484 struct dwarf2_per_cu_data
*per_cu
)
2486 struct needs_frame_baton baton
;
2487 struct dwarf_expr_context
*ctx
;
2489 struct cleanup
*old_chain
;
2490 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2492 baton
.needs_frame
= 0;
2493 baton
.per_cu
= per_cu
;
2495 ctx
= new_dwarf_expr_context ();
2496 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2497 make_cleanup_value_free_to_mark (value_mark ());
2499 ctx
->gdbarch
= get_objfile_arch (objfile
);
2500 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2501 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2502 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2503 ctx
->baton
= &baton
;
2504 ctx
->funcs
= &needs_frame_ctx_funcs
;
2506 dwarf_expr_eval (ctx
, data
, size
);
2508 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
2510 if (ctx
->num_pieces
> 0)
2514 /* If the location has several pieces, and any of them are in
2515 registers, then we will need a frame to fetch them from. */
2516 for (i
= 0; i
< ctx
->num_pieces
; i
++)
2517 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2521 do_cleanups (old_chain
);
2523 return baton
.needs_frame
|| in_reg
;
2526 /* A helper function that throws an unimplemented error mentioning a
2527 given DWARF operator. */
2530 unimplemented (unsigned int op
)
2532 const char *name
= get_DW_OP_name (op
);
2535 error (_("DWARF operator %s cannot be translated to an agent expression"),
2538 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2539 "to an agent expression"),
2543 /* A helper function to convert a DWARF register to an arch register.
2544 ARCH is the architecture.
2545 DWARF_REG is the register.
2546 This will throw an exception if the DWARF register cannot be
2547 translated to an architecture register. */
2550 translate_register (struct gdbarch
*arch
, int dwarf_reg
)
2552 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2554 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
2558 /* A helper function that emits an access to memory. ARCH is the
2559 target architecture. EXPR is the expression which we are building.
2560 NBITS is the number of bits we want to read. This emits the
2561 opcodes needed to read the memory and then extract the desired
2565 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2567 ULONGEST nbytes
= (nbits
+ 7) / 8;
2569 gdb_assert (nbytes
> 0 && nbytes
<= sizeof (LONGEST
));
2572 ax_trace_quick (expr
, nbytes
);
2575 ax_simple (expr
, aop_ref8
);
2576 else if (nbits
<= 16)
2577 ax_simple (expr
, aop_ref16
);
2578 else if (nbits
<= 32)
2579 ax_simple (expr
, aop_ref32
);
2581 ax_simple (expr
, aop_ref64
);
2583 /* If we read exactly the number of bytes we wanted, we're done. */
2584 if (8 * nbytes
== nbits
)
2587 if (gdbarch_bits_big_endian (arch
))
2589 /* On a bits-big-endian machine, we want the high-order
2591 ax_const_l (expr
, 8 * nbytes
- nbits
);
2592 ax_simple (expr
, aop_rsh_unsigned
);
2596 /* On a bits-little-endian box, we want the low-order NBITS. */
2597 ax_zero_ext (expr
, nbits
);
2601 /* A helper function to return the frame's PC. */
2604 get_ax_pc (void *baton
)
2606 struct agent_expr
*expr
= baton
;
2611 /* Compile a DWARF location expression to an agent expression.
2613 EXPR is the agent expression we are building.
2614 LOC is the agent value we modify.
2615 ARCH is the architecture.
2616 ADDR_SIZE is the size of addresses, in bytes.
2617 OP_PTR is the start of the location expression.
2618 OP_END is one past the last byte of the location expression.
2620 This will throw an exception for various kinds of errors -- for
2621 example, if the expression cannot be compiled, or if the expression
2625 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2626 struct gdbarch
*arch
, unsigned int addr_size
,
2627 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
2628 struct dwarf2_per_cu_data
*per_cu
)
2630 struct cleanup
*cleanups
;
2632 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
2633 const gdb_byte
* const base
= op_ptr
;
2634 const gdb_byte
*previous_piece
= op_ptr
;
2635 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2636 ULONGEST bits_collected
= 0;
2637 unsigned int addr_size_bits
= 8 * addr_size
;
2638 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
2640 offsets
= xmalloc ((op_end
- op_ptr
) * sizeof (int));
2641 cleanups
= make_cleanup (xfree
, offsets
);
2643 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
2646 make_cleanup (VEC_cleanup (int), &dw_labels
);
2647 make_cleanup (VEC_cleanup (int), &patches
);
2649 /* By default we are making an address. */
2650 loc
->kind
= axs_lvalue_memory
;
2652 while (op_ptr
< op_end
)
2654 enum dwarf_location_atom op
= *op_ptr
;
2655 uint64_t uoffset
, reg
;
2659 offsets
[op_ptr
- base
] = expr
->len
;
2662 /* Our basic approach to code generation is to map DWARF
2663 operations directly to AX operations. However, there are
2666 First, DWARF works on address-sized units, but AX always uses
2667 LONGEST. For most operations we simply ignore this
2668 difference; instead we generate sign extensions as needed
2669 before division and comparison operations. It would be nice
2670 to omit the sign extensions, but there is no way to determine
2671 the size of the target's LONGEST. (This code uses the size
2672 of the host LONGEST in some cases -- that is a bug but it is
2675 Second, some DWARF operations cannot be translated to AX.
2676 For these we simply fail. See
2677 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2712 ax_const_l (expr
, op
- DW_OP_lit0
);
2716 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
2717 op_ptr
+= addr_size
;
2718 /* Some versions of GCC emit DW_OP_addr before
2719 DW_OP_GNU_push_tls_address. In this case the value is an
2720 index, not an address. We don't support things like
2721 branching between the address and the TLS op. */
2722 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
2723 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
2724 ax_const_l (expr
, uoffset
);
2728 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
2732 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
2736 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
2740 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
2744 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
2748 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
2752 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
2756 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
2760 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
2761 ax_const_l (expr
, uoffset
);
2764 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2765 ax_const_l (expr
, offset
);
2800 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2801 loc
->u
.reg
= translate_register (arch
, op
- DW_OP_reg0
);
2802 loc
->kind
= axs_lvalue_register
;
2806 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2807 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2808 loc
->u
.reg
= translate_register (arch
, reg
);
2809 loc
->kind
= axs_lvalue_register
;
2812 case DW_OP_implicit_value
:
2816 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
2817 if (op_ptr
+ len
> op_end
)
2818 error (_("DW_OP_implicit_value: too few bytes available."));
2819 if (len
> sizeof (ULONGEST
))
2820 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
2823 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
2826 dwarf_expr_require_composition (op_ptr
, op_end
,
2827 "DW_OP_implicit_value");
2829 loc
->kind
= axs_rvalue
;
2833 case DW_OP_stack_value
:
2834 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
2835 loc
->kind
= axs_rvalue
;
2870 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2871 i
= translate_register (arch
, op
- DW_OP_breg0
);
2875 ax_const_l (expr
, offset
);
2876 ax_simple (expr
, aop_add
);
2881 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2882 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2883 i
= translate_register (arch
, reg
);
2887 ax_const_l (expr
, offset
);
2888 ax_simple (expr
, aop_add
);
2894 const gdb_byte
*datastart
;
2897 struct symbol
*framefunc
;
2899 b
= block_for_pc (expr
->scope
);
2902 error (_("No block found for address"));
2904 framefunc
= block_linkage_function (b
);
2907 error (_("No function found for block"));
2909 dwarf_expr_frame_base_1 (framefunc
, expr
->scope
,
2910 &datastart
, &datalen
);
2912 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2913 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
2914 datastart
+ datalen
, per_cu
);
2915 if (loc
->kind
== axs_lvalue_register
)
2916 require_rvalue (expr
, loc
);
2920 ax_const_l (expr
, offset
);
2921 ax_simple (expr
, aop_add
);
2924 loc
->kind
= axs_lvalue_memory
;
2929 ax_simple (expr
, aop_dup
);
2933 ax_simple (expr
, aop_pop
);
2938 ax_pick (expr
, offset
);
2942 ax_simple (expr
, aop_swap
);
2950 ax_simple (expr
, aop_rot
);
2954 case DW_OP_deref_size
:
2958 if (op
== DW_OP_deref_size
)
2963 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8)
2964 error (_("Unsupported size %d in %s"),
2965 size
, get_DW_OP_name (op
));
2966 access_memory (arch
, expr
, size
* TARGET_CHAR_BIT
);
2971 /* Sign extend the operand. */
2972 ax_ext (expr
, addr_size_bits
);
2973 ax_simple (expr
, aop_dup
);
2974 ax_const_l (expr
, 0);
2975 ax_simple (expr
, aop_less_signed
);
2976 ax_simple (expr
, aop_log_not
);
2977 i
= ax_goto (expr
, aop_if_goto
);
2978 /* We have to emit 0 - X. */
2979 ax_const_l (expr
, 0);
2980 ax_simple (expr
, aop_swap
);
2981 ax_simple (expr
, aop_sub
);
2982 ax_label (expr
, i
, expr
->len
);
2986 /* No need to sign extend here. */
2987 ax_const_l (expr
, 0);
2988 ax_simple (expr
, aop_swap
);
2989 ax_simple (expr
, aop_sub
);
2993 /* Sign extend the operand. */
2994 ax_ext (expr
, addr_size_bits
);
2995 ax_simple (expr
, aop_bit_not
);
2998 case DW_OP_plus_uconst
:
2999 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
3000 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3001 but we micro-optimize anyhow. */
3004 ax_const_l (expr
, reg
);
3005 ax_simple (expr
, aop_add
);
3010 ax_simple (expr
, aop_bit_and
);
3014 /* Sign extend the operands. */
3015 ax_ext (expr
, addr_size_bits
);
3016 ax_simple (expr
, aop_swap
);
3017 ax_ext (expr
, addr_size_bits
);
3018 ax_simple (expr
, aop_swap
);
3019 ax_simple (expr
, aop_div_signed
);
3023 ax_simple (expr
, aop_sub
);
3027 ax_simple (expr
, aop_rem_unsigned
);
3031 ax_simple (expr
, aop_mul
);
3035 ax_simple (expr
, aop_bit_or
);
3039 ax_simple (expr
, aop_add
);
3043 ax_simple (expr
, aop_lsh
);
3047 ax_simple (expr
, aop_rsh_unsigned
);
3051 ax_simple (expr
, aop_rsh_signed
);
3055 ax_simple (expr
, aop_bit_xor
);
3059 /* Sign extend the operands. */
3060 ax_ext (expr
, addr_size_bits
);
3061 ax_simple (expr
, aop_swap
);
3062 ax_ext (expr
, addr_size_bits
);
3063 /* Note no swap here: A <= B is !(B < A). */
3064 ax_simple (expr
, aop_less_signed
);
3065 ax_simple (expr
, aop_log_not
);
3069 /* Sign extend the operands. */
3070 ax_ext (expr
, addr_size_bits
);
3071 ax_simple (expr
, aop_swap
);
3072 ax_ext (expr
, addr_size_bits
);
3073 ax_simple (expr
, aop_swap
);
3074 /* A >= B is !(A < B). */
3075 ax_simple (expr
, aop_less_signed
);
3076 ax_simple (expr
, aop_log_not
);
3080 /* Sign extend the operands. */
3081 ax_ext (expr
, addr_size_bits
);
3082 ax_simple (expr
, aop_swap
);
3083 ax_ext (expr
, addr_size_bits
);
3084 /* No need for a second swap here. */
3085 ax_simple (expr
, aop_equal
);
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 ax_simple (expr
, aop_swap
);
3094 ax_simple (expr
, aop_less_signed
);
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 /* Note no swap here: A > B is B < A. */
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 /* No need for a swap here. */
3112 ax_simple (expr
, aop_equal
);
3113 ax_simple (expr
, aop_log_not
);
3116 case DW_OP_call_frame_cfa
:
3117 dwarf2_compile_cfa_to_ax (expr
, loc
, arch
, expr
->scope
, per_cu
);
3118 loc
->kind
= axs_lvalue_memory
;
3121 case DW_OP_GNU_push_tls_address
:
3126 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3128 i
= ax_goto (expr
, aop_goto
);
3129 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3130 VEC_safe_push (int, patches
, i
);
3134 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3136 /* Zero extend the operand. */
3137 ax_zero_ext (expr
, addr_size_bits
);
3138 i
= ax_goto (expr
, aop_if_goto
);
3139 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3140 VEC_safe_push (int, patches
, i
);
3147 case DW_OP_bit_piece
:
3149 uint64_t size
, offset
;
3151 if (op_ptr
- 1 == previous_piece
)
3152 error (_("Cannot translate empty pieces to agent expressions"));
3153 previous_piece
= op_ptr
- 1;
3155 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3156 if (op
== DW_OP_piece
)
3162 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
3164 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3165 error (_("Expression pieces exceed word size"));
3167 /* Access the bits. */
3170 case axs_lvalue_register
:
3171 ax_reg (expr
, loc
->u
.reg
);
3174 case axs_lvalue_memory
:
3175 /* Offset the pointer, if needed. */
3178 ax_const_l (expr
, offset
/ 8);
3179 ax_simple (expr
, aop_add
);
3182 access_memory (arch
, expr
, size
);
3186 /* For a bits-big-endian target, shift up what we already
3187 have. For a bits-little-endian target, shift up the
3188 new data. Note that there is a potential bug here if
3189 the DWARF expression leaves multiple values on the
3191 if (bits_collected
> 0)
3193 if (bits_big_endian
)
3195 ax_simple (expr
, aop_swap
);
3196 ax_const_l (expr
, size
);
3197 ax_simple (expr
, aop_lsh
);
3198 /* We don't need a second swap here, because
3199 aop_bit_or is symmetric. */
3203 ax_const_l (expr
, size
);
3204 ax_simple (expr
, aop_lsh
);
3206 ax_simple (expr
, aop_bit_or
);
3209 bits_collected
+= size
;
3210 loc
->kind
= axs_rvalue
;
3214 case DW_OP_GNU_uninit
:
3220 struct dwarf2_locexpr_baton block
;
3221 int size
= (op
== DW_OP_call2
? 2 : 4);
3224 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3227 offset
.cu_off
= uoffset
;
3228 block
= dwarf2_fetch_die_loc_cu_off (offset
, per_cu
,
3231 /* DW_OP_call_ref is currently not supported. */
3232 gdb_assert (block
.per_cu
== per_cu
);
3234 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3235 block
.data
, block
.data
+ block
.size
,
3240 case DW_OP_call_ref
:
3248 /* Patch all the branches we emitted. */
3249 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
3251 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
3253 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3254 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
3257 do_cleanups (cleanups
);
3261 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3262 evaluator to calculate the location. */
3263 static struct value
*
3264 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3266 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3269 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3270 dlbaton
->size
, dlbaton
->per_cu
);
3275 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3276 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3279 static struct value
*
3280 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3282 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3284 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3288 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3290 locexpr_read_needs_frame (struct symbol
*symbol
)
3292 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3294 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
3298 /* Return true if DATA points to the end of a piece. END is one past
3299 the last byte in the expression. */
3302 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3304 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3307 /* Helper for locexpr_describe_location_piece that finds the name of a
3311 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3315 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
3316 return gdbarch_register_name (gdbarch
, regnum
);
3319 /* Nicely describe a single piece of a location, returning an updated
3320 position in the bytecode sequence. This function cannot recognize
3321 all locations; if a location is not recognized, it simply returns
3322 DATA. If there is an error during reading, e.g. we run off the end
3323 of the buffer, an error is thrown. */
3325 static const gdb_byte
*
3326 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3327 CORE_ADDR addr
, struct objfile
*objfile
,
3328 struct dwarf2_per_cu_data
*per_cu
,
3329 const gdb_byte
*data
, const gdb_byte
*end
,
3330 unsigned int addr_size
)
3332 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3335 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3337 fprintf_filtered (stream
, _("a variable in $%s"),
3338 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3341 else if (data
[0] == DW_OP_regx
)
3345 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3346 fprintf_filtered (stream
, _("a variable in $%s"),
3347 locexpr_regname (gdbarch
, reg
));
3349 else if (data
[0] == DW_OP_fbreg
)
3352 struct symbol
*framefunc
;
3354 int64_t frame_offset
;
3355 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3357 int64_t base_offset
= 0;
3359 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3360 if (!piece_end_p (new_data
, end
))
3364 b
= block_for_pc (addr
);
3367 error (_("No block found for address for symbol \"%s\"."),
3368 SYMBOL_PRINT_NAME (symbol
));
3370 framefunc
= block_linkage_function (b
);
3373 error (_("No function found for block for symbol \"%s\"."),
3374 SYMBOL_PRINT_NAME (symbol
));
3376 dwarf_expr_frame_base_1 (framefunc
, addr
, &base_data
, &base_size
);
3378 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3380 const gdb_byte
*buf_end
;
3382 frame_reg
= base_data
[0] - DW_OP_breg0
;
3383 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3385 if (buf_end
!= base_data
+ base_size
)
3386 error (_("Unexpected opcode after "
3387 "DW_OP_breg%u for symbol \"%s\"."),
3388 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3390 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3392 /* The frame base is just the register, with no offset. */
3393 frame_reg
= base_data
[0] - DW_OP_reg0
;
3398 /* We don't know what to do with the frame base expression,
3399 so we can't trace this variable; give up. */
3403 fprintf_filtered (stream
,
3404 _("a variable at frame base reg $%s offset %s+%s"),
3405 locexpr_regname (gdbarch
, frame_reg
),
3406 plongest (base_offset
), plongest (frame_offset
));
3408 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3409 && piece_end_p (data
, end
))
3413 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3415 fprintf_filtered (stream
,
3416 _("a variable at offset %s from base reg $%s"),
3418 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3421 /* The location expression for a TLS variable looks like this (on a
3424 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3425 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3427 0x3 is the encoding for DW_OP_addr, which has an operand as long
3428 as the size of an address on the target machine (here is 8
3429 bytes). Note that more recent version of GCC emit DW_OP_const4u
3430 or DW_OP_const8u, depending on address size, rather than
3431 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3432 The operand represents the offset at which the variable is within
3433 the thread local storage. */
3435 else if (data
+ 1 + addr_size
< end
3436 && (data
[0] == DW_OP_addr
3437 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3438 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3439 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3440 && piece_end_p (data
+ 2 + addr_size
, end
))
3443 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3444 gdbarch_byte_order (gdbarch
));
3446 fprintf_filtered (stream
,
3447 _("a thread-local variable at offset 0x%s "
3448 "in the thread-local storage for `%s'"),
3449 phex_nz (offset
, addr_size
), objfile
->name
);
3451 data
+= 1 + addr_size
+ 1;
3454 /* With -gsplit-dwarf a TLS variable can also look like this:
3455 DW_AT_location : 3 byte block: fc 4 e0
3456 (DW_OP_GNU_const_index: 4;
3457 DW_OP_GNU_push_tls_address) */
3458 else if (data
+ 3 <= end
3459 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3460 && data
[0] == DW_OP_GNU_const_index
3462 && data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3463 && piece_end_p (data
+ 2 + leb128_size
, end
))
3467 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3468 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3469 fprintf_filtered (stream
,
3470 _("a thread-local variable at offset 0x%s "
3471 "in the thread-local storage for `%s'"),
3472 phex_nz (offset
, addr_size
), objfile
->name
);
3476 else if (data
[0] >= DW_OP_lit0
3477 && data
[0] <= DW_OP_lit31
3479 && data
[1] == DW_OP_stack_value
)
3481 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3488 /* Disassemble an expression, stopping at the end of a piece or at the
3489 end of the expression. Returns a pointer to the next unread byte
3490 in the input expression. If ALL is nonzero, then this function
3491 will keep going until it reaches the end of the expression.
3492 If there is an error during reading, e.g. we run off the end
3493 of the buffer, an error is thrown. */
3495 static const gdb_byte
*
3496 disassemble_dwarf_expression (struct ui_file
*stream
,
3497 struct gdbarch
*arch
, unsigned int addr_size
,
3498 int offset_size
, const gdb_byte
*start
,
3499 const gdb_byte
*data
, const gdb_byte
*end
,
3500 int indent
, int all
,
3501 struct dwarf2_per_cu_data
*per_cu
)
3505 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3507 enum dwarf_location_atom op
= *data
++;
3512 name
= get_DW_OP_name (op
);
3515 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3516 op
, (long) (data
- 1 - start
));
3517 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3518 (long) (data
- 1 - start
), name
);
3523 ul
= extract_unsigned_integer (data
, addr_size
,
3524 gdbarch_byte_order (arch
));
3526 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3530 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3532 fprintf_filtered (stream
, " %s", pulongest (ul
));
3535 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3537 fprintf_filtered (stream
, " %s", plongest (l
));
3540 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3542 fprintf_filtered (stream
, " %s", pulongest (ul
));
3545 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3547 fprintf_filtered (stream
, " %s", plongest (l
));
3550 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3552 fprintf_filtered (stream
, " %s", pulongest (ul
));
3555 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3557 fprintf_filtered (stream
, " %s", plongest (l
));
3560 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3562 fprintf_filtered (stream
, " %s", pulongest (ul
));
3565 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3567 fprintf_filtered (stream
, " %s", plongest (l
));
3570 data
= safe_read_uleb128 (data
, end
, &ul
);
3571 fprintf_filtered (stream
, " %s", pulongest (ul
));
3574 data
= safe_read_sleb128 (data
, end
, &l
);
3575 fprintf_filtered (stream
, " %s", plongest (l
));
3610 fprintf_filtered (stream
, " [$%s]",
3611 locexpr_regname (arch
, op
- DW_OP_reg0
));
3615 data
= safe_read_uleb128 (data
, end
, &ul
);
3616 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3617 locexpr_regname (arch
, (int) ul
));
3620 case DW_OP_implicit_value
:
3621 data
= safe_read_uleb128 (data
, end
, &ul
);
3623 fprintf_filtered (stream
, " %s", pulongest (ul
));
3658 data
= safe_read_sleb128 (data
, end
, &l
);
3659 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
3660 locexpr_regname (arch
, op
- DW_OP_breg0
));
3664 data
= safe_read_uleb128 (data
, end
, &ul
);
3665 data
= safe_read_sleb128 (data
, end
, &l
);
3666 fprintf_filtered (stream
, " register %s [$%s] offset %s",
3668 locexpr_regname (arch
, (int) ul
),
3673 data
= safe_read_sleb128 (data
, end
, &l
);
3674 fprintf_filtered (stream
, " %s", plongest (l
));
3677 case DW_OP_xderef_size
:
3678 case DW_OP_deref_size
:
3680 fprintf_filtered (stream
, " %d", *data
);
3684 case DW_OP_plus_uconst
:
3685 data
= safe_read_uleb128 (data
, end
, &ul
);
3686 fprintf_filtered (stream
, " %s", pulongest (ul
));
3690 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3692 fprintf_filtered (stream
, " to %ld",
3693 (long) (data
+ l
- start
));
3697 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3699 fprintf_filtered (stream
, " %ld",
3700 (long) (data
+ l
- start
));
3704 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3706 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
3710 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3712 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3715 case DW_OP_call_ref
:
3716 ul
= extract_unsigned_integer (data
, offset_size
,
3717 gdbarch_byte_order (arch
));
3718 data
+= offset_size
;
3719 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
3723 data
= safe_read_uleb128 (data
, end
, &ul
);
3724 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
3727 case DW_OP_bit_piece
:
3731 data
= safe_read_uleb128 (data
, end
, &ul
);
3732 data
= safe_read_uleb128 (data
, end
, &offset
);
3733 fprintf_filtered (stream
, " size %s offset %s (bits)",
3734 pulongest (ul
), pulongest (offset
));
3738 case DW_OP_GNU_implicit_pointer
:
3740 ul
= extract_unsigned_integer (data
, offset_size
,
3741 gdbarch_byte_order (arch
));
3742 data
+= offset_size
;
3744 data
= safe_read_sleb128 (data
, end
, &l
);
3746 fprintf_filtered (stream
, " DIE %s offset %s",
3747 phex_nz (ul
, offset_size
),
3752 case DW_OP_GNU_deref_type
:
3754 int addr_size
= *data
++;
3758 data
= safe_read_uleb128 (data
, end
, &ul
);
3760 type
= dwarf2_get_die_type (offset
, per_cu
);
3761 fprintf_filtered (stream
, "<");
3762 type_print (type
, "", stream
, -1);
3763 fprintf_filtered (stream
, " [0x%s]> %d", phex_nz (offset
.cu_off
, 0),
3768 case DW_OP_GNU_const_type
:
3773 data
= safe_read_uleb128 (data
, end
, &ul
);
3774 type_die
.cu_off
= ul
;
3775 type
= dwarf2_get_die_type (type_die
, per_cu
);
3776 fprintf_filtered (stream
, "<");
3777 type_print (type
, "", stream
, -1);
3778 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3782 case DW_OP_GNU_regval_type
:
3788 data
= safe_read_uleb128 (data
, end
, ®
);
3789 data
= safe_read_uleb128 (data
, end
, &ul
);
3790 type_die
.cu_off
= ul
;
3792 type
= dwarf2_get_die_type (type_die
, per_cu
);
3793 fprintf_filtered (stream
, "<");
3794 type_print (type
, "", stream
, -1);
3795 fprintf_filtered (stream
, " [0x%s]> [$%s]",
3796 phex_nz (type_die
.cu_off
, 0),
3797 locexpr_regname (arch
, reg
));
3801 case DW_OP_GNU_convert
:
3802 case DW_OP_GNU_reinterpret
:
3806 data
= safe_read_uleb128 (data
, end
, &ul
);
3807 type_die
.cu_off
= ul
;
3809 if (type_die
.cu_off
== 0)
3810 fprintf_filtered (stream
, "<0>");
3815 type
= dwarf2_get_die_type (type_die
, per_cu
);
3816 fprintf_filtered (stream
, "<");
3817 type_print (type
, "", stream
, -1);
3818 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3823 case DW_OP_GNU_entry_value
:
3824 data
= safe_read_uleb128 (data
, end
, &ul
);
3825 fputc_filtered ('\n', stream
);
3826 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
3827 start
, data
, data
+ ul
, indent
+ 2,
3832 case DW_OP_GNU_parameter_ref
:
3833 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3835 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3838 case DW_OP_GNU_addr_index
:
3839 data
= safe_read_uleb128 (data
, end
, &ul
);
3840 ul
= dwarf2_read_addr_index (per_cu
, ul
);
3841 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3843 case DW_OP_GNU_const_index
:
3844 data
= safe_read_uleb128 (data
, end
, &ul
);
3845 ul
= dwarf2_read_addr_index (per_cu
, ul
);
3846 fprintf_filtered (stream
, " %s", pulongest (ul
));
3850 fprintf_filtered (stream
, "\n");
3856 /* Describe a single location, which may in turn consist of multiple
3860 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
3861 struct ui_file
*stream
,
3862 const gdb_byte
*data
, size_t size
,
3863 struct objfile
*objfile
, unsigned int addr_size
,
3864 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
3866 const gdb_byte
*end
= data
+ size
;
3867 int first_piece
= 1, bad
= 0;
3871 const gdb_byte
*here
= data
;
3872 int disassemble
= 1;
3877 fprintf_filtered (stream
, _(", and "));
3879 if (!dwarf2_always_disassemble
)
3881 data
= locexpr_describe_location_piece (symbol
, stream
,
3882 addr
, objfile
, per_cu
,
3883 data
, end
, addr_size
);
3884 /* If we printed anything, or if we have an empty piece,
3885 then don't disassemble. */
3887 || data
[0] == DW_OP_piece
3888 || data
[0] == DW_OP_bit_piece
)
3893 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
3894 data
= disassemble_dwarf_expression (stream
,
3895 get_objfile_arch (objfile
),
3896 addr_size
, offset_size
, data
,
3898 dwarf2_always_disassemble
,
3904 int empty
= data
== here
;
3907 fprintf_filtered (stream
, " ");
3908 if (data
[0] == DW_OP_piece
)
3912 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
3915 fprintf_filtered (stream
, _("an empty %s-byte piece"),
3918 fprintf_filtered (stream
, _(" [%s-byte piece]"),
3921 else if (data
[0] == DW_OP_bit_piece
)
3923 uint64_t bits
, offset
;
3925 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
3926 data
= safe_read_uleb128 (data
, end
, &offset
);
3929 fprintf_filtered (stream
,
3930 _("an empty %s-bit piece"),
3933 fprintf_filtered (stream
,
3934 _(" [%s-bit piece, offset %s bits]"),
3935 pulongest (bits
), pulongest (offset
));
3945 if (bad
|| data
> end
)
3946 error (_("Corrupted DWARF2 expression for \"%s\"."),
3947 SYMBOL_PRINT_NAME (symbol
));
3950 /* Print a natural-language description of SYMBOL to STREAM. This
3951 version is for a symbol with a single location. */
3954 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
3955 struct ui_file
*stream
)
3957 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3958 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
3959 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
3960 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
3962 locexpr_describe_location_1 (symbol
, addr
, stream
,
3963 dlbaton
->data
, dlbaton
->size
,
3964 objfile
, addr_size
, offset_size
,
3968 /* Describe the location of SYMBOL as an agent value in VALUE, generating
3969 any necessary bytecode in AX. */
3972 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
3973 struct agent_expr
*ax
, struct axs_value
*value
)
3975 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3976 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
3978 if (dlbaton
->size
== 0)
3979 value
->optimized_out
= 1;
3981 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
3982 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
3986 /* The set of location functions used with the DWARF-2 expression
3988 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
3989 locexpr_read_variable
,
3990 locexpr_read_variable_at_entry
,
3991 locexpr_read_needs_frame
,
3992 locexpr_describe_location
,
3993 0, /* location_has_loclist */
3994 locexpr_tracepoint_var_ref
3998 /* Wrapper functions for location lists. These generally find
3999 the appropriate location expression and call something above. */
4001 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4002 evaluator to calculate the location. */
4003 static struct value
*
4004 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
4006 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4008 const gdb_byte
*data
;
4010 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
4012 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4013 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
4019 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4020 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4023 Function always returns non-NULL value, it may be marked optimized out if
4024 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4025 if it cannot resolve the parameter for any reason. */
4027 static struct value
*
4028 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4030 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4031 const gdb_byte
*data
;
4035 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4036 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4038 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4040 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4042 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4045 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
4047 loclist_read_needs_frame (struct symbol
*symbol
)
4049 /* If there's a location list, then assume we need to have a frame
4050 to choose the appropriate location expression. With tracking of
4051 global variables this is not necessarily true, but such tracking
4052 is disabled in GCC at the moment until we figure out how to
4058 /* Print a natural-language description of SYMBOL to STREAM. This
4059 version applies when there is a list of different locations, each
4060 with a specified address range. */
4063 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4064 struct ui_file
*stream
)
4066 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4067 const gdb_byte
*loc_ptr
, *buf_end
;
4068 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4069 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4070 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4071 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4072 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4073 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4074 /* Adjust base_address for relocatable objects. */
4075 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4076 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4079 loc_ptr
= dlbaton
->data
;
4080 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4082 fprintf_filtered (stream
, _("multi-location:\n"));
4084 /* Iterate through locations until we run out. */
4087 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4089 enum debug_loc_kind kind
;
4090 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4092 if (dlbaton
->from_dwo
)
4093 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4094 loc_ptr
, buf_end
, &new_ptr
,
4095 &low
, &high
, byte_order
);
4097 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4099 byte_order
, addr_size
,
4104 case DEBUG_LOC_END_OF_LIST
:
4107 case DEBUG_LOC_BASE_ADDRESS
:
4108 base_address
= high
+ base_offset
;
4109 fprintf_filtered (stream
, _(" Base address %s"),
4110 paddress (gdbarch
, base_address
));
4112 case DEBUG_LOC_START_END
:
4113 case DEBUG_LOC_START_LENGTH
:
4115 case DEBUG_LOC_BUFFER_OVERFLOW
:
4116 case DEBUG_LOC_INVALID_ENTRY
:
4117 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4118 SYMBOL_PRINT_NAME (symbol
));
4120 gdb_assert_not_reached ("bad debug_loc_kind");
4123 /* Otherwise, a location expression entry. */
4124 low
+= base_address
;
4125 high
+= base_address
;
4127 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4130 /* (It would improve readability to print only the minimum
4131 necessary digits of the second number of the range.) */
4132 fprintf_filtered (stream
, _(" Range %s-%s: "),
4133 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4135 /* Now describe this particular location. */
4136 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4137 objfile
, addr_size
, offset_size
,
4140 fprintf_filtered (stream
, "\n");
4146 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4147 any necessary bytecode in AX. */
4149 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4150 struct agent_expr
*ax
, struct axs_value
*value
)
4152 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4153 const gdb_byte
*data
;
4155 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4157 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4159 value
->optimized_out
= 1;
4161 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
4165 /* The set of location functions used with the DWARF-2 expression
4166 evaluator and location lists. */
4167 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4168 loclist_read_variable
,
4169 loclist_read_variable_at_entry
,
4170 loclist_read_needs_frame
,
4171 loclist_describe_location
,
4172 1, /* location_has_loclist */
4173 loclist_tracepoint_var_ref
4176 /* Provide a prototype to silence -Wmissing-prototypes. */
4177 extern initialize_file_ftype _initialize_dwarf2loc
;
4180 _initialize_dwarf2loc (void)
4182 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4183 &entry_values_debug
,
4184 _("Set entry values and tail call frames "
4186 _("Show entry values and tail call frames "
4188 _("When non-zero, the process of determining "
4189 "parameter values from function entry point "
4190 "and tail call frames will be printed."),
4192 show_entry_values_debug
,
4193 &setdebuglist
, &showdebuglist
);