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. */
257 high
+= base_address
;
259 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
262 if (low
== high
&& pc
== low
)
264 /* This is entry PC record present only at entry point
265 of a function. Verify it is really the function entry point. */
267 struct block
*pc_block
= block_for_pc (pc
);
268 struct symbol
*pc_func
= NULL
;
271 pc_func
= block_linkage_function (pc_block
);
273 if (pc_func
&& pc
== BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func
)))
275 *locexpr_length
= length
;
280 if (pc
>= low
&& pc
< high
)
282 *locexpr_length
= length
;
290 /* This is the baton used when performing dwarf2 expression
292 struct dwarf_expr_baton
294 struct frame_info
*frame
;
295 struct dwarf2_per_cu_data
*per_cu
;
298 /* Helper functions for dwarf2_evaluate_loc_desc. */
300 /* Using the frame specified in BATON, return the value of register
301 REGNUM, treated as a pointer. */
303 dwarf_expr_read_reg (void *baton
, int dwarf_regnum
)
305 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
306 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
310 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
311 result
= address_from_register (builtin_type (gdbarch
)->builtin_data_ptr
,
312 regnum
, debaton
->frame
);
316 /* Read memory at ADDR (length LEN) into BUF. */
319 dwarf_expr_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
321 read_memory (addr
, buf
, len
);
324 /* Using the frame specified in BATON, find the location expression
325 describing the frame base. Return a pointer to it in START and
326 its length in LENGTH. */
328 dwarf_expr_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
330 /* FIXME: cagney/2003-03-26: This code should be using
331 get_frame_base_address(), and then implement a dwarf2 specific
333 struct symbol
*framefunc
;
334 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
335 struct block
*bl
= get_frame_block (debaton
->frame
, NULL
);
338 error (_("frame address is not available."));
340 /* Use block_linkage_function, which returns a real (not inlined)
341 function, instead of get_frame_function, which may return an
343 framefunc
= block_linkage_function (bl
);
345 /* If we found a frame-relative symbol then it was certainly within
346 some function associated with a frame. If we can't find the frame,
347 something has gone wrong. */
348 gdb_assert (framefunc
!= NULL
);
350 dwarf_expr_frame_base_1 (framefunc
,
351 get_frame_address_in_block (debaton
->frame
),
356 dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
357 const gdb_byte
**start
, size_t *length
)
359 if (SYMBOL_LOCATION_BATON (framefunc
) == NULL
)
361 else if (SYMBOL_COMPUTED_OPS (framefunc
) == &dwarf2_loclist_funcs
)
363 struct dwarf2_loclist_baton
*symbaton
;
365 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
366 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
370 struct dwarf2_locexpr_baton
*symbaton
;
372 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
373 if (symbaton
!= NULL
)
375 *length
= symbaton
->size
;
376 *start
= symbaton
->data
;
383 error (_("Could not find the frame base for \"%s\"."),
384 SYMBOL_NATURAL_NAME (framefunc
));
387 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
388 the frame in BATON. */
391 dwarf_expr_frame_cfa (void *baton
)
393 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
395 return dwarf2_frame_cfa (debaton
->frame
);
398 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
399 the frame in BATON. */
402 dwarf_expr_frame_pc (void *baton
)
404 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
406 return get_frame_address_in_block (debaton
->frame
);
409 /* Using the objfile specified in BATON, find the address for the
410 current thread's thread-local storage with offset OFFSET. */
412 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
414 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
415 struct objfile
*objfile
= dwarf2_per_cu_objfile (debaton
->per_cu
);
417 return target_translate_tls_address (objfile
, offset
);
420 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
421 current CU (as is PER_CU). State of the CTX is not affected by the
425 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
426 struct dwarf2_per_cu_data
*per_cu
,
427 CORE_ADDR (*get_frame_pc
) (void *baton
),
430 struct dwarf2_locexpr_baton block
;
432 block
= dwarf2_fetch_die_loc_cu_off (die_offset
, per_cu
, get_frame_pc
, baton
);
434 /* DW_OP_call_ref is currently not supported. */
435 gdb_assert (block
.per_cu
== per_cu
);
437 dwarf_expr_eval (ctx
, block
.data
, block
.size
);
440 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
443 dwarf_expr_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
445 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
447 per_cu_dwarf_call (ctx
, die_offset
, debaton
->per_cu
,
448 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
451 /* Callback function for dwarf2_evaluate_loc_desc. */
454 dwarf_expr_get_base_type (struct dwarf_expr_context
*ctx
,
455 cu_offset die_offset
)
457 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
459 return dwarf2_get_die_type (die_offset
, debaton
->per_cu
);
462 /* See dwarf2loc.h. */
464 unsigned int entry_values_debug
= 0;
466 /* Helper to set entry_values_debug. */
469 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
470 struct cmd_list_element
*c
, const char *value
)
472 fprintf_filtered (file
,
473 _("Entry values and tail call frames debugging is %s.\n"),
477 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
478 CALLER_FRAME (for registers) can be NULL if it is not known. This function
479 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
482 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
483 struct call_site
*call_site
,
484 struct frame_info
*caller_frame
)
486 switch (FIELD_LOC_KIND (call_site
->target
))
488 case FIELD_LOC_KIND_DWARF_BLOCK
:
490 struct dwarf2_locexpr_baton
*dwarf_block
;
492 struct type
*caller_core_addr_type
;
493 struct gdbarch
*caller_arch
;
495 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
496 if (dwarf_block
== NULL
)
498 struct minimal_symbol
*msym
;
500 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
501 throw_error (NO_ENTRY_VALUE_ERROR
,
502 _("DW_AT_GNU_call_site_target is not specified "
504 paddress (call_site_gdbarch
, call_site
->pc
),
505 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
508 if (caller_frame
== NULL
)
510 struct minimal_symbol
*msym
;
512 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
513 throw_error (NO_ENTRY_VALUE_ERROR
,
514 _("DW_AT_GNU_call_site_target DWARF block resolving "
515 "requires known frame which is currently not "
516 "available at %s in %s"),
517 paddress (call_site_gdbarch
, call_site
->pc
),
518 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
521 caller_arch
= get_frame_arch (caller_frame
);
522 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
523 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
524 dwarf_block
->data
, dwarf_block
->size
,
525 dwarf_block
->per_cu
);
526 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
528 if (VALUE_LVAL (val
) == lval_memory
)
529 return value_address (val
);
531 return value_as_address (val
);
534 case FIELD_LOC_KIND_PHYSNAME
:
536 const char *physname
;
537 struct minimal_symbol
*msym
;
539 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
540 msym
= lookup_minimal_symbol_text (physname
, NULL
);
543 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
544 throw_error (NO_ENTRY_VALUE_ERROR
,
545 _("Cannot find function \"%s\" for a call site target "
547 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
548 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
551 return SYMBOL_VALUE_ADDRESS (msym
);
554 case FIELD_LOC_KIND_PHYSADDR
:
555 return FIELD_STATIC_PHYSADDR (call_site
->target
);
558 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
562 /* Convert function entry point exact address ADDR to the function which is
563 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
564 NO_ENTRY_VALUE_ERROR otherwise. */
566 static struct symbol
*
567 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
569 struct symbol
*sym
= find_pc_function (addr
);
572 if (sym
== NULL
|| BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
573 throw_error (NO_ENTRY_VALUE_ERROR
,
574 _("DW_TAG_GNU_call_site resolving failed to find function "
575 "name for address %s"),
576 paddress (gdbarch
, addr
));
578 type
= SYMBOL_TYPE (sym
);
579 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
580 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
585 /* Verify function with entry point exact address ADDR can never call itself
586 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
587 can call itself via tail calls.
589 If a funtion can tail call itself its entry value based parameters are
590 unreliable. There is no verification whether the value of some/all
591 parameters is unchanged through the self tail call, we expect if there is
592 a self tail call all the parameters can be modified. */
595 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
597 struct obstack addr_obstack
;
598 struct cleanup
*old_chain
;
601 /* Track here CORE_ADDRs which were already visited. */
604 /* The verification is completely unordered. Track here function addresses
605 which still need to be iterated. */
606 VEC (CORE_ADDR
) *todo
= NULL
;
608 obstack_init (&addr_obstack
);
609 old_chain
= make_cleanup_obstack_free (&addr_obstack
);
610 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
611 &addr_obstack
, hashtab_obstack_allocate
,
613 make_cleanup_htab_delete (addr_hash
);
615 make_cleanup (VEC_cleanup (CORE_ADDR
), &todo
);
617 VEC_safe_push (CORE_ADDR
, todo
, verify_addr
);
618 while (!VEC_empty (CORE_ADDR
, todo
))
620 struct symbol
*func_sym
;
621 struct call_site
*call_site
;
623 addr
= VEC_pop (CORE_ADDR
, todo
);
625 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
627 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
628 call_site
; call_site
= call_site
->tail_call_next
)
630 CORE_ADDR target_addr
;
633 /* CALLER_FRAME with registers is not available for tail-call jumped
635 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
637 if (target_addr
== verify_addr
)
639 struct minimal_symbol
*msym
;
641 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
642 throw_error (NO_ENTRY_VALUE_ERROR
,
643 _("DW_OP_GNU_entry_value resolving has found "
644 "function \"%s\" at %s can call itself via tail "
646 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
),
647 paddress (gdbarch
, verify_addr
));
650 slot
= htab_find_slot (addr_hash
, &target_addr
, INSERT
);
653 *slot
= obstack_copy (&addr_obstack
, &target_addr
,
654 sizeof (target_addr
));
655 VEC_safe_push (CORE_ADDR
, todo
, target_addr
);
660 do_cleanups (old_chain
);
663 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
664 ENTRY_VALUES_DEBUG. */
667 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
669 CORE_ADDR addr
= call_site
->pc
;
670 struct minimal_symbol
*msym
= lookup_minimal_symbol_by_pc (addr
- 1);
672 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
673 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
677 /* vec.h needs single word type name, typedef it. */
678 typedef struct call_site
*call_sitep
;
680 /* Define VEC (call_sitep) functions. */
681 DEF_VEC_P (call_sitep
);
683 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
684 only top callers and bottom callees which are present in both. GDBARCH is
685 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
686 no remaining possibilities to provide unambiguous non-trivial result.
687 RESULTP should point to NULL on the first (initialization) call. Caller is
688 responsible for xfree of any RESULTP data. */
691 chain_candidate (struct gdbarch
*gdbarch
, struct call_site_chain
**resultp
,
692 VEC (call_sitep
) *chain
)
694 struct call_site_chain
*result
= *resultp
;
695 long length
= VEC_length (call_sitep
, chain
);
696 int callers
, callees
, idx
;
700 /* Create the initial chain containing all the passed PCs. */
702 result
= xmalloc (sizeof (*result
) + sizeof (*result
->call_site
)
704 result
->length
= length
;
705 result
->callers
= result
->callees
= length
;
706 memcpy (result
->call_site
, VEC_address (call_sitep
, chain
),
707 sizeof (*result
->call_site
) * length
);
710 if (entry_values_debug
)
712 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
713 for (idx
= 0; idx
< length
; idx
++)
714 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
715 fputc_unfiltered ('\n', gdb_stdlog
);
721 if (entry_values_debug
)
723 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
724 for (idx
= 0; idx
< length
; idx
++)
725 tailcall_dump (gdbarch
, VEC_index (call_sitep
, chain
, idx
));
726 fputc_unfiltered ('\n', gdb_stdlog
);
729 /* Intersect callers. */
731 callers
= min (result
->callers
, length
);
732 for (idx
= 0; idx
< callers
; idx
++)
733 if (result
->call_site
[idx
] != VEC_index (call_sitep
, chain
, idx
))
735 result
->callers
= idx
;
739 /* Intersect callees. */
741 callees
= min (result
->callees
, length
);
742 for (idx
= 0; idx
< callees
; idx
++)
743 if (result
->call_site
[result
->length
- 1 - idx
]
744 != VEC_index (call_sitep
, chain
, length
- 1 - idx
))
746 result
->callees
= idx
;
750 if (entry_values_debug
)
752 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
753 for (idx
= 0; idx
< result
->callers
; idx
++)
754 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
755 fputs_unfiltered (" |", gdb_stdlog
);
756 for (idx
= 0; idx
< result
->callees
; idx
++)
757 tailcall_dump (gdbarch
, result
->call_site
[result
->length
758 - result
->callees
+ idx
]);
759 fputc_unfiltered ('\n', gdb_stdlog
);
762 if (result
->callers
== 0 && result
->callees
== 0)
764 /* There are no common callers or callees. It could be also a direct
765 call (which has length 0) with ambiguous possibility of an indirect
766 call - CALLERS == CALLEES == 0 is valid during the first allocation
767 but any subsequence processing of such entry means ambiguity. */
773 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
774 PC again. In such case there must be two different code paths to reach
775 it, therefore some of the former determined intermediate PCs must differ
776 and the unambiguous chain gets shortened. */
777 gdb_assert (result
->callers
+ result
->callees
< result
->length
);
780 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
781 assumed frames between them use GDBARCH. Use depth first search so we can
782 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
783 would have needless GDB stack overhead. Caller is responsible for xfree of
784 the returned result. Any unreliability results in thrown
785 NO_ENTRY_VALUE_ERROR. */
787 static struct call_site_chain
*
788 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
791 struct obstack addr_obstack
;
792 struct cleanup
*back_to_retval
, *back_to_workdata
;
793 struct call_site_chain
*retval
= NULL
;
794 struct call_site
*call_site
;
796 /* Mark CALL_SITEs so we do not visit the same ones twice. */
799 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
800 call_site nor any possible call_site at CALLEE_PC's function is there.
801 Any CALL_SITE in CHAIN will be iterated to its siblings - via
802 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
803 VEC (call_sitep
) *chain
= NULL
;
805 /* We are not interested in the specific PC inside the callee function. */
806 callee_pc
= get_pc_function_start (callee_pc
);
808 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
809 paddress (gdbarch
, callee_pc
));
811 back_to_retval
= make_cleanup (free_current_contents
, &retval
);
813 obstack_init (&addr_obstack
);
814 back_to_workdata
= make_cleanup_obstack_free (&addr_obstack
);
815 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
816 &addr_obstack
, hashtab_obstack_allocate
,
818 make_cleanup_htab_delete (addr_hash
);
820 make_cleanup (VEC_cleanup (call_sitep
), &chain
);
822 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
823 at the target's function. All the possible tail call sites in the
824 target's function will get iterated as already pushed into CHAIN via their
826 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
830 CORE_ADDR target_func_addr
;
831 struct call_site
*target_call_site
;
833 /* CALLER_FRAME with registers is not available for tail-call jumped
835 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
837 if (target_func_addr
== callee_pc
)
839 chain_candidate (gdbarch
, &retval
, chain
);
843 /* There is no way to reach CALLEE_PC again as we would prevent
844 entering it twice as being already marked in ADDR_HASH. */
845 target_call_site
= NULL
;
849 struct symbol
*target_func
;
851 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
852 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
857 /* Attempt to visit TARGET_CALL_SITE. */
859 if (target_call_site
)
863 slot
= htab_find_slot (addr_hash
, &target_call_site
->pc
, INSERT
);
866 /* Successfully entered TARGET_CALL_SITE. */
868 *slot
= &target_call_site
->pc
;
869 VEC_safe_push (call_sitep
, chain
, target_call_site
);
874 /* Backtrack (without revisiting the originating call_site). Try the
875 callers's sibling; if there isn't any try the callers's callers's
878 target_call_site
= NULL
;
879 while (!VEC_empty (call_sitep
, chain
))
881 call_site
= VEC_pop (call_sitep
, chain
);
883 gdb_assert (htab_find_slot (addr_hash
, &call_site
->pc
,
885 htab_remove_elt (addr_hash
, &call_site
->pc
);
887 target_call_site
= call_site
->tail_call_next
;
888 if (target_call_site
)
892 while (target_call_site
);
894 if (VEC_empty (call_sitep
, chain
))
897 call_site
= VEC_last (call_sitep
, chain
);
902 struct minimal_symbol
*msym_caller
, *msym_callee
;
904 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
905 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
906 throw_error (NO_ENTRY_VALUE_ERROR
,
907 _("There are no unambiguously determinable intermediate "
908 "callers or callees between caller function \"%s\" at %s "
909 "and callee function \"%s\" at %s"),
911 ? "???" : SYMBOL_PRINT_NAME (msym_caller
)),
912 paddress (gdbarch
, caller_pc
),
914 ? "???" : SYMBOL_PRINT_NAME (msym_callee
)),
915 paddress (gdbarch
, callee_pc
));
918 do_cleanups (back_to_workdata
);
919 discard_cleanups (back_to_retval
);
923 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
924 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
925 constructed return NULL. Caller is responsible for xfree of the returned
928 struct call_site_chain
*
929 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
932 volatile struct gdb_exception e
;
933 struct call_site_chain
*retval
= NULL
;
935 TRY_CATCH (e
, RETURN_MASK_ERROR
)
937 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
941 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
943 if (entry_values_debug
)
944 exception_print (gdb_stdout
, e
);
954 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
957 call_site_parameter_matches (struct call_site_parameter
*parameter
,
958 enum call_site_parameter_kind kind
,
959 union call_site_parameter_u kind_u
)
961 if (kind
== parameter
->kind
)
964 case CALL_SITE_PARAMETER_DWARF_REG
:
965 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
966 case CALL_SITE_PARAMETER_FB_OFFSET
:
967 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
968 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
969 return kind_u
.param_offset
.cu_off
== parameter
->u
.param_offset
.cu_off
;
974 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
977 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
980 static struct call_site_parameter
*
981 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
982 enum call_site_parameter_kind kind
,
983 union call_site_parameter_u kind_u
,
984 struct dwarf2_per_cu_data
**per_cu_return
)
986 CORE_ADDR func_addr
, caller_pc
;
987 struct gdbarch
*gdbarch
;
988 struct frame_info
*caller_frame
;
989 struct call_site
*call_site
;
991 /* Initialize it just to avoid a GCC false warning. */
992 struct call_site_parameter
*parameter
= NULL
;
993 CORE_ADDR target_addr
;
995 while (get_frame_type (frame
) == INLINE_FRAME
)
997 frame
= get_prev_frame (frame
);
998 gdb_assert (frame
!= NULL
);
1001 func_addr
= get_frame_func (frame
);
1002 gdbarch
= get_frame_arch (frame
);
1003 caller_frame
= get_prev_frame (frame
);
1004 if (gdbarch
!= frame_unwind_arch (frame
))
1006 struct minimal_symbol
*msym
= lookup_minimal_symbol_by_pc (func_addr
);
1007 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
1009 throw_error (NO_ENTRY_VALUE_ERROR
,
1010 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1011 "(of %s (%s)) does not match caller gdbarch %s"),
1012 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
1013 paddress (gdbarch
, func_addr
),
1014 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
),
1015 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
1018 if (caller_frame
== NULL
)
1020 struct minimal_symbol
*msym
= lookup_minimal_symbol_by_pc (func_addr
);
1022 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_GNU_entry_value resolving "
1023 "requires caller of %s (%s)"),
1024 paddress (gdbarch
, func_addr
),
1025 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
1027 caller_pc
= get_frame_pc (caller_frame
);
1028 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
1030 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1031 if (target_addr
!= func_addr
)
1033 struct minimal_symbol
*target_msym
, *func_msym
;
1035 target_msym
= lookup_minimal_symbol_by_pc (target_addr
);
1036 func_msym
= lookup_minimal_symbol_by_pc (func_addr
);
1037 throw_error (NO_ENTRY_VALUE_ERROR
,
1038 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1039 "but the called frame is for %s at %s"),
1040 (target_msym
== NULL
? "???"
1041 : SYMBOL_PRINT_NAME (target_msym
)),
1042 paddress (gdbarch
, target_addr
),
1043 func_msym
== NULL
? "???" : SYMBOL_PRINT_NAME (func_msym
),
1044 paddress (gdbarch
, func_addr
));
1047 /* No entry value based parameters would be reliable if this function can
1048 call itself via tail calls. */
1049 func_verify_no_selftailcall (gdbarch
, func_addr
);
1051 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1053 parameter
= &call_site
->parameter
[iparams
];
1054 if (call_site_parameter_matches (parameter
, kind
, kind_u
))
1057 if (iparams
== call_site
->parameter_count
)
1059 struct minimal_symbol
*msym
= lookup_minimal_symbol_by_pc (caller_pc
);
1061 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1062 determine its value. */
1063 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1064 "at DW_TAG_GNU_call_site %s at %s"),
1065 paddress (gdbarch
, caller_pc
),
1066 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
1069 *per_cu_return
= call_site
->per_cu
;
1073 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1074 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1075 DW_AT_GNU_call_site_data_value (dereferenced) block.
1077 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1080 Function always returns non-NULL, non-optimized out value. It throws
1081 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1083 static struct value
*
1084 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1085 CORE_ADDR deref_size
, struct type
*type
,
1086 struct frame_info
*caller_frame
,
1087 struct dwarf2_per_cu_data
*per_cu
)
1089 const gdb_byte
*data_src
;
1093 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1094 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1096 /* DEREF_SIZE size is not verified here. */
1097 if (data_src
== NULL
)
1098 throw_error (NO_ENTRY_VALUE_ERROR
,
1099 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1101 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1102 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1104 data
= alloca (size
+ 1);
1105 memcpy (data
, data_src
, size
);
1106 data
[size
] = DW_OP_stack_value
;
1108 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1111 /* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
1112 Choose DEREF_SIZE value of that parameter. Search caller of the CTX's
1113 frame. CTX must be of dwarf_expr_ctx_funcs kind.
1115 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1116 can be more simple as it does not support cross-CU DWARF executions. */
1119 dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
1120 enum call_site_parameter_kind kind
,
1121 union call_site_parameter_u kind_u
,
1124 struct dwarf_expr_baton
*debaton
;
1125 struct frame_info
*frame
, *caller_frame
;
1126 struct dwarf2_per_cu_data
*caller_per_cu
;
1127 struct dwarf_expr_baton baton_local
;
1128 struct dwarf_expr_context saved_ctx
;
1129 struct call_site_parameter
*parameter
;
1130 const gdb_byte
*data_src
;
1133 gdb_assert (ctx
->funcs
== &dwarf_expr_ctx_funcs
);
1134 debaton
= ctx
->baton
;
1135 frame
= debaton
->frame
;
1136 caller_frame
= get_prev_frame (frame
);
1138 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1140 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1141 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1143 /* DEREF_SIZE size is not verified here. */
1144 if (data_src
== NULL
)
1145 throw_error (NO_ENTRY_VALUE_ERROR
,
1146 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1148 baton_local
.frame
= caller_frame
;
1149 baton_local
.per_cu
= caller_per_cu
;
1151 saved_ctx
.gdbarch
= ctx
->gdbarch
;
1152 saved_ctx
.addr_size
= ctx
->addr_size
;
1153 saved_ctx
.offset
= ctx
->offset
;
1154 saved_ctx
.baton
= ctx
->baton
;
1155 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (baton_local
.per_cu
));
1156 ctx
->addr_size
= dwarf2_per_cu_addr_size (baton_local
.per_cu
);
1157 ctx
->offset
= dwarf2_per_cu_text_offset (baton_local
.per_cu
);
1158 ctx
->baton
= &baton_local
;
1160 dwarf_expr_eval (ctx
, data_src
, size
);
1162 ctx
->gdbarch
= saved_ctx
.gdbarch
;
1163 ctx
->addr_size
= saved_ctx
.addr_size
;
1164 ctx
->offset
= saved_ctx
.offset
;
1165 ctx
->baton
= saved_ctx
.baton
;
1168 /* Callback function for dwarf2_evaluate_loc_desc.
1169 Fetch the address indexed by DW_OP_GNU_addr_index. */
1172 dwarf_expr_get_addr_index (void *baton
, unsigned int index
)
1174 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
1176 return dwarf2_read_addr_index (debaton
->per_cu
, index
);
1179 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1180 the indirect method on it, that is use its stored target value, the sole
1181 purpose of entry_data_value_funcs.. */
1183 static struct value
*
1184 entry_data_value_coerce_ref (const struct value
*value
)
1186 struct type
*checked_type
= check_typedef (value_type (value
));
1187 struct value
*target_val
;
1189 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
)
1192 target_val
= value_computed_closure (value
);
1193 value_incref (target_val
);
1197 /* Implement copy_closure. */
1200 entry_data_value_copy_closure (const struct value
*v
)
1202 struct value
*target_val
= value_computed_closure (v
);
1204 value_incref (target_val
);
1208 /* Implement free_closure. */
1211 entry_data_value_free_closure (struct value
*v
)
1213 struct value
*target_val
= value_computed_closure (v
);
1215 value_free (target_val
);
1218 /* Vector for methods for an entry value reference where the referenced value
1219 is stored in the caller. On the first dereference use
1220 DW_AT_GNU_call_site_data_value in the caller. */
1222 static const struct lval_funcs entry_data_value_funcs
=
1226 NULL
, /* check_validity */
1227 NULL
, /* check_any_valid */
1228 NULL
, /* indirect */
1229 entry_data_value_coerce_ref
,
1230 NULL
, /* check_synthetic_pointer */
1231 entry_data_value_copy_closure
,
1232 entry_data_value_free_closure
1235 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1236 are used to match DW_AT_location at the caller's
1237 DW_TAG_GNU_call_site_parameter.
1239 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1240 cannot resolve the parameter for any reason. */
1242 static struct value
*
1243 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1244 enum call_site_parameter_kind kind
,
1245 union call_site_parameter_u kind_u
)
1247 struct type
*checked_type
= check_typedef (type
);
1248 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1249 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1250 struct value
*outer_val
, *target_val
, *val
;
1251 struct call_site_parameter
*parameter
;
1252 struct dwarf2_per_cu_data
*caller_per_cu
;
1255 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, kind
, kind_u
,
1258 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1262 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1263 used and it is not available do not fall back to OUTER_VAL - dereferencing
1264 TYPE_CODE_REF with non-entry data value would give current value - not the
1267 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
1268 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1271 target_val
= dwarf_entry_parameter_to_value (parameter
,
1272 TYPE_LENGTH (target_type
),
1273 target_type
, caller_frame
,
1276 /* value_as_address dereferences TYPE_CODE_REF. */
1277 addr
= extract_typed_address (value_contents (outer_val
), checked_type
);
1279 /* The target entry value has artificial address of the entry value
1281 VALUE_LVAL (target_val
) = lval_memory
;
1282 set_value_address (target_val
, addr
);
1284 release_value (target_val
);
1285 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1286 target_val
/* closure */);
1288 /* Copy the referencing pointer to the new computed value. */
1289 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1290 TYPE_LENGTH (checked_type
));
1291 set_value_lazy (val
, 0);
1296 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1297 SIZE are DWARF block used to match DW_AT_location at the caller's
1298 DW_TAG_GNU_call_site_parameter.
1300 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1301 cannot resolve the parameter for any reason. */
1303 static struct value
*
1304 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1305 const gdb_byte
*block
, size_t block_len
)
1307 union call_site_parameter_u kind_u
;
1309 kind_u
.dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1310 if (kind_u
.dwarf_reg
!= -1)
1311 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_DWARF_REG
,
1314 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &kind_u
.fb_offset
))
1315 return value_of_dwarf_reg_entry (type
, frame
, CALL_SITE_PARAMETER_FB_OFFSET
,
1318 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1319 suppressed during normal operation. The expression can be arbitrary if
1320 there is no caller-callee entry value binding expected. */
1321 throw_error (NO_ENTRY_VALUE_ERROR
,
1322 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1323 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1326 struct piece_closure
1328 /* Reference count. */
1331 /* The CU from which this closure's expression came. */
1332 struct dwarf2_per_cu_data
*per_cu
;
1334 /* The number of pieces used to describe this variable. */
1337 /* The target address size, used only for DWARF_VALUE_STACK. */
1340 /* The pieces themselves. */
1341 struct dwarf_expr_piece
*pieces
;
1344 /* Allocate a closure for a value formed from separately-described
1347 static struct piece_closure
*
1348 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1349 int n_pieces
, struct dwarf_expr_piece
*pieces
,
1352 struct piece_closure
*c
= XZALLOC (struct piece_closure
);
1357 c
->n_pieces
= n_pieces
;
1358 c
->addr_size
= addr_size
;
1359 c
->pieces
= XCALLOC (n_pieces
, struct dwarf_expr_piece
);
1361 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
1362 for (i
= 0; i
< n_pieces
; ++i
)
1363 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1364 value_incref (c
->pieces
[i
].v
.value
);
1369 /* The lowest-level function to extract bits from a byte buffer.
1370 SOURCE is the buffer. It is updated if we read to the end of a
1372 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1373 updated to reflect the number of bits actually read.
1374 NBITS is the number of bits we want to read. It is updated to
1375 reflect the number of bits actually read. This function may read
1377 BITS_BIG_ENDIAN is taken directly from gdbarch.
1378 This function returns the extracted bits. */
1381 extract_bits_primitive (const gdb_byte
**source
,
1382 unsigned int *source_offset_bits
,
1383 int *nbits
, int bits_big_endian
)
1385 unsigned int avail
, mask
, datum
;
1387 gdb_assert (*source_offset_bits
< 8);
1389 avail
= 8 - *source_offset_bits
;
1393 mask
= (1 << avail
) - 1;
1395 if (bits_big_endian
)
1396 datum
>>= 8 - (*source_offset_bits
+ *nbits
);
1398 datum
>>= *source_offset_bits
;
1402 *source_offset_bits
+= avail
;
1403 if (*source_offset_bits
>= 8)
1405 *source_offset_bits
-= 8;
1412 /* Extract some bits from a source buffer and move forward in the
1415 SOURCE is the source buffer. It is updated as bytes are read.
1416 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1418 NBITS is the number of bits to read.
1419 BITS_BIG_ENDIAN is taken directly from gdbarch.
1421 This function returns the bits that were read. */
1424 extract_bits (const gdb_byte
**source
, unsigned int *source_offset_bits
,
1425 int nbits
, int bits_big_endian
)
1429 gdb_assert (nbits
> 0 && nbits
<= 8);
1431 datum
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1437 more
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1439 if (bits_big_endian
)
1449 /* Write some bits into a buffer and move forward in the buffer.
1451 DATUM is the bits to write. The low-order bits of DATUM are used.
1452 DEST is the destination buffer. It is updated as bytes are
1454 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1456 NBITS is the number of valid bits in DATUM.
1457 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1460 insert_bits (unsigned int datum
,
1461 gdb_byte
*dest
, unsigned int dest_offset_bits
,
1462 int nbits
, int bits_big_endian
)
1466 gdb_assert (dest_offset_bits
+ nbits
<= 8);
1468 mask
= (1 << nbits
) - 1;
1469 if (bits_big_endian
)
1471 datum
<<= 8 - (dest_offset_bits
+ nbits
);
1472 mask
<<= 8 - (dest_offset_bits
+ nbits
);
1476 datum
<<= dest_offset_bits
;
1477 mask
<<= dest_offset_bits
;
1480 gdb_assert ((datum
& ~mask
) == 0);
1482 *dest
= (*dest
& ~mask
) | datum
;
1485 /* Copy bits from a source to a destination.
1487 DEST is where the bits should be written.
1488 DEST_OFFSET_BITS is the bit offset into DEST.
1489 SOURCE is the source of bits.
1490 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1491 BIT_COUNT is the number of bits to copy.
1492 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1495 copy_bitwise (gdb_byte
*dest
, unsigned int dest_offset_bits
,
1496 const gdb_byte
*source
, unsigned int source_offset_bits
,
1497 unsigned int bit_count
,
1498 int bits_big_endian
)
1500 unsigned int dest_avail
;
1503 /* Reduce everything to byte-size pieces. */
1504 dest
+= dest_offset_bits
/ 8;
1505 dest_offset_bits
%= 8;
1506 source
+= source_offset_bits
/ 8;
1507 source_offset_bits
%= 8;
1509 dest_avail
= 8 - dest_offset_bits
% 8;
1511 /* See if we can fill the first destination byte. */
1512 if (dest_avail
< bit_count
)
1514 datum
= extract_bits (&source
, &source_offset_bits
, dest_avail
,
1516 insert_bits (datum
, dest
, dest_offset_bits
, dest_avail
, bits_big_endian
);
1518 dest_offset_bits
= 0;
1519 bit_count
-= dest_avail
;
1522 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1523 than 8 bits remaining. */
1524 gdb_assert (dest_offset_bits
% 8 == 0 || bit_count
< 8);
1525 for (; bit_count
>= 8; bit_count
-= 8)
1527 datum
= extract_bits (&source
, &source_offset_bits
, 8, bits_big_endian
);
1528 *dest
++ = (gdb_byte
) datum
;
1531 /* Finally, we may have a few leftover bits. */
1532 gdb_assert (bit_count
<= 8 - dest_offset_bits
% 8);
1535 datum
= extract_bits (&source
, &source_offset_bits
, bit_count
,
1537 insert_bits (datum
, dest
, dest_offset_bits
, bit_count
, bits_big_endian
);
1542 read_pieced_value (struct value
*v
)
1546 ULONGEST bits_to_skip
;
1548 struct piece_closure
*c
1549 = (struct piece_closure
*) value_computed_closure (v
);
1550 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (v
));
1552 size_t buffer_size
= 0;
1553 char *buffer
= NULL
;
1554 struct cleanup
*cleanup
;
1556 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1558 if (value_type (v
) != value_enclosing_type (v
))
1559 internal_error (__FILE__
, __LINE__
,
1560 _("Should not be able to create a lazy value with "
1561 "an enclosing type"));
1563 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1565 contents
= value_contents_raw (v
);
1566 bits_to_skip
= 8 * value_offset (v
);
1567 if (value_bitsize (v
))
1569 bits_to_skip
+= value_bitpos (v
);
1570 type_len
= value_bitsize (v
);
1573 type_len
= 8 * TYPE_LENGTH (value_type (v
));
1575 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1577 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1578 size_t this_size
, this_size_bits
;
1579 long dest_offset_bits
, source_offset_bits
, source_offset
;
1580 const gdb_byte
*intermediate_buffer
;
1582 /* Compute size, source, and destination offsets for copying, in
1584 this_size_bits
= p
->size
;
1585 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1587 bits_to_skip
-= this_size_bits
;
1590 if (this_size_bits
> type_len
- offset
)
1591 this_size_bits
= type_len
- offset
;
1592 if (bits_to_skip
> 0)
1594 dest_offset_bits
= 0;
1595 source_offset_bits
= bits_to_skip
;
1596 this_size_bits
-= bits_to_skip
;
1601 dest_offset_bits
= offset
;
1602 source_offset_bits
= 0;
1605 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1606 source_offset
= source_offset_bits
/ 8;
1607 if (buffer_size
< this_size
)
1609 buffer_size
= this_size
;
1610 buffer
= xrealloc (buffer
, buffer_size
);
1612 intermediate_buffer
= buffer
;
1614 /* Copy from the source to DEST_BUFFER. */
1615 switch (p
->location
)
1617 case DWARF_VALUE_REGISTER
:
1619 struct gdbarch
*arch
= get_frame_arch (frame
);
1620 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1621 int reg_offset
= source_offset
;
1623 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1624 && this_size
< register_size (arch
, gdb_regnum
))
1626 /* Big-endian, and we want less than full size. */
1627 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1628 /* We want the lower-order THIS_SIZE_BITS of the bytes
1629 we extract from the register. */
1630 source_offset_bits
+= 8 * this_size
- this_size_bits
;
1633 if (gdb_regnum
!= -1)
1637 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1641 /* Just so garbage doesn't ever shine through. */
1642 memset (buffer
, 0, this_size
);
1645 set_value_optimized_out (v
, 1);
1647 mark_value_bytes_unavailable (v
, offset
, this_size
);
1652 error (_("Unable to access DWARF register number %s"),
1653 paddress (arch
, p
->v
.regno
));
1658 case DWARF_VALUE_MEMORY
:
1659 read_value_memory (v
, offset
,
1660 p
->v
.mem
.in_stack_memory
,
1661 p
->v
.mem
.addr
+ source_offset
,
1665 case DWARF_VALUE_STACK
:
1667 size_t n
= this_size
;
1669 if (n
> c
->addr_size
- source_offset
)
1670 n
= (c
->addr_size
>= source_offset
1671 ? c
->addr_size
- source_offset
1679 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
1681 intermediate_buffer
= val_bytes
+ source_offset
;
1686 case DWARF_VALUE_LITERAL
:
1688 size_t n
= this_size
;
1690 if (n
> p
->v
.literal
.length
- source_offset
)
1691 n
= (p
->v
.literal
.length
>= source_offset
1692 ? p
->v
.literal
.length
- source_offset
1695 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
1699 /* These bits show up as zeros -- but do not cause the value
1700 to be considered optimized-out. */
1701 case DWARF_VALUE_IMPLICIT_POINTER
:
1704 case DWARF_VALUE_OPTIMIZED_OUT
:
1705 set_value_optimized_out (v
, 1);
1709 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1712 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
1713 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1714 copy_bitwise (contents
, dest_offset_bits
,
1715 intermediate_buffer
, source_offset_bits
% 8,
1716 this_size_bits
, bits_big_endian
);
1718 offset
+= this_size_bits
;
1721 do_cleanups (cleanup
);
1725 write_pieced_value (struct value
*to
, struct value
*from
)
1729 ULONGEST bits_to_skip
;
1730 const gdb_byte
*contents
;
1731 struct piece_closure
*c
1732 = (struct piece_closure
*) value_computed_closure (to
);
1733 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
1735 size_t buffer_size
= 0;
1736 char *buffer
= NULL
;
1737 struct cleanup
*cleanup
;
1739 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
1743 set_value_optimized_out (to
, 1);
1747 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1749 contents
= value_contents (from
);
1750 bits_to_skip
= 8 * value_offset (to
);
1751 if (value_bitsize (to
))
1753 bits_to_skip
+= value_bitpos (to
);
1754 type_len
= value_bitsize (to
);
1757 type_len
= 8 * TYPE_LENGTH (value_type (to
));
1759 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1761 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1762 size_t this_size_bits
, this_size
;
1763 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
1765 const gdb_byte
*source_buffer
;
1767 this_size_bits
= p
->size
;
1768 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1770 bits_to_skip
-= this_size_bits
;
1773 if (this_size_bits
> type_len
- offset
)
1774 this_size_bits
= type_len
- offset
;
1775 if (bits_to_skip
> 0)
1777 dest_offset_bits
= bits_to_skip
;
1778 source_offset_bits
= 0;
1779 this_size_bits
-= bits_to_skip
;
1784 dest_offset_bits
= 0;
1785 source_offset_bits
= offset
;
1788 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1789 source_offset
= source_offset_bits
/ 8;
1790 dest_offset
= dest_offset_bits
/ 8;
1791 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
1793 source_buffer
= contents
+ source_offset
;
1798 if (buffer_size
< this_size
)
1800 buffer_size
= this_size
;
1801 buffer
= xrealloc (buffer
, buffer_size
);
1803 source_buffer
= buffer
;
1807 switch (p
->location
)
1809 case DWARF_VALUE_REGISTER
:
1811 struct gdbarch
*arch
= get_frame_arch (frame
);
1812 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1813 int reg_offset
= dest_offset
;
1815 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1816 && this_size
<= register_size (arch
, gdb_regnum
))
1817 /* Big-endian, and we want less than full size. */
1818 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1820 if (gdb_regnum
!= -1)
1826 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1831 error (_("Can't do read-modify-write to "
1832 "update bitfield; containing word has been "
1835 throw_error (NOT_AVAILABLE_ERROR
,
1836 _("Can't do read-modify-write to update "
1837 "bitfield; containing word "
1840 copy_bitwise (buffer
, dest_offset_bits
,
1841 contents
, source_offset_bits
,
1846 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1847 this_size
, source_buffer
);
1851 error (_("Unable to write to DWARF register number %s"),
1852 paddress (arch
, p
->v
.regno
));
1856 case DWARF_VALUE_MEMORY
:
1859 /* Only the first and last bytes can possibly have any
1861 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
, 1);
1862 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
1863 buffer
+ this_size
- 1, 1);
1864 copy_bitwise (buffer
, dest_offset_bits
,
1865 contents
, source_offset_bits
,
1870 write_memory (p
->v
.mem
.addr
+ dest_offset
,
1871 source_buffer
, this_size
);
1874 set_value_optimized_out (to
, 1);
1877 offset
+= this_size_bits
;
1880 do_cleanups (cleanup
);
1883 /* A helper function that checks bit validity in a pieced value.
1884 CHECK_FOR indicates the kind of validity checking.
1885 DWARF_VALUE_MEMORY means to check whether any bit is valid.
1886 DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
1888 DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
1889 implicit pointer. */
1892 check_pieced_value_bits (const struct value
*value
, int bit_offset
,
1894 enum dwarf_value_location check_for
)
1896 struct piece_closure
*c
1897 = (struct piece_closure
*) value_computed_closure (value
);
1899 int validity
= (check_for
== DWARF_VALUE_MEMORY
1900 || check_for
== DWARF_VALUE_IMPLICIT_POINTER
);
1902 bit_offset
+= 8 * value_offset (value
);
1903 if (value_bitsize (value
))
1904 bit_offset
+= value_bitpos (value
);
1906 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
1908 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1909 size_t this_size_bits
= p
->size
;
1913 if (bit_offset
>= this_size_bits
)
1915 bit_offset
-= this_size_bits
;
1919 bit_length
-= this_size_bits
- bit_offset
;
1923 bit_length
-= this_size_bits
;
1925 if (check_for
== DWARF_VALUE_IMPLICIT_POINTER
)
1927 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1930 else if (p
->location
== DWARF_VALUE_OPTIMIZED_OUT
1931 || p
->location
== DWARF_VALUE_IMPLICIT_POINTER
)
1947 check_pieced_value_validity (const struct value
*value
, int bit_offset
,
1950 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
1951 DWARF_VALUE_MEMORY
);
1955 check_pieced_value_invalid (const struct value
*value
)
1957 return check_pieced_value_bits (value
, 0,
1958 8 * TYPE_LENGTH (value_type (value
)),
1959 DWARF_VALUE_OPTIMIZED_OUT
);
1962 /* An implementation of an lval_funcs method to see whether a value is
1963 a synthetic pointer. */
1966 check_pieced_synthetic_pointer (const struct value
*value
, int bit_offset
,
1969 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
1970 DWARF_VALUE_IMPLICIT_POINTER
);
1973 /* A wrapper function for get_frame_address_in_block. */
1976 get_frame_address_in_block_wrapper (void *baton
)
1978 return get_frame_address_in_block (baton
);
1981 /* An implementation of an lval_funcs method to indirect through a
1982 pointer. This handles the synthetic pointer case when needed. */
1984 static struct value
*
1985 indirect_pieced_value (struct value
*value
)
1987 struct piece_closure
*c
1988 = (struct piece_closure
*) value_computed_closure (value
);
1990 struct frame_info
*frame
;
1991 struct dwarf2_locexpr_baton baton
;
1992 int i
, bit_offset
, bit_length
;
1993 struct dwarf_expr_piece
*piece
= NULL
;
1994 LONGEST byte_offset
;
1996 type
= check_typedef (value_type (value
));
1997 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
2000 bit_length
= 8 * TYPE_LENGTH (type
);
2001 bit_offset
= 8 * value_offset (value
);
2002 if (value_bitsize (value
))
2003 bit_offset
+= value_bitpos (value
);
2005 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
2007 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
2008 size_t this_size_bits
= p
->size
;
2012 if (bit_offset
>= this_size_bits
)
2014 bit_offset
-= this_size_bits
;
2018 bit_length
-= this_size_bits
- bit_offset
;
2022 bit_length
-= this_size_bits
;
2024 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2027 if (bit_length
!= 0)
2028 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2034 frame
= get_selected_frame (_("No frame selected."));
2036 /* This is an offset requested by GDB, such as value subcripts. */
2037 byte_offset
= value_as_address (value
);
2041 = dwarf2_fetch_die_loc_sect_off (piece
->v
.ptr
.die
, c
->per_cu
,
2042 get_frame_address_in_block_wrapper
,
2045 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
2046 baton
.data
, baton
.size
, baton
.per_cu
,
2047 piece
->v
.ptr
.offset
+ byte_offset
);
2051 copy_pieced_value_closure (const struct value
*v
)
2053 struct piece_closure
*c
2054 = (struct piece_closure
*) value_computed_closure (v
);
2061 free_pieced_value_closure (struct value
*v
)
2063 struct piece_closure
*c
2064 = (struct piece_closure
*) value_computed_closure (v
);
2071 for (i
= 0; i
< c
->n_pieces
; ++i
)
2072 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
2073 value_free (c
->pieces
[i
].v
.value
);
2080 /* Functions for accessing a variable described by DW_OP_piece. */
2081 static const struct lval_funcs pieced_value_funcs
= {
2084 check_pieced_value_validity
,
2085 check_pieced_value_invalid
,
2086 indirect_pieced_value
,
2087 NULL
, /* coerce_ref */
2088 check_pieced_synthetic_pointer
,
2089 copy_pieced_value_closure
,
2090 free_pieced_value_closure
2093 /* Helper function which throws an error if a synthetic pointer is
2097 invalid_synthetic_pointer (void)
2099 error (_("access outside bounds of object "
2100 "referenced via synthetic pointer"));
2103 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2105 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
=
2107 dwarf_expr_read_reg
,
2108 dwarf_expr_read_mem
,
2109 dwarf_expr_frame_base
,
2110 dwarf_expr_frame_cfa
,
2111 dwarf_expr_frame_pc
,
2112 dwarf_expr_tls_address
,
2113 dwarf_expr_dwarf_call
,
2114 dwarf_expr_get_base_type
,
2115 dwarf_expr_push_dwarf_reg_entry_value
,
2116 dwarf_expr_get_addr_index
2119 /* Evaluate a location description, starting at DATA and with length
2120 SIZE, to find the current location of variable of TYPE in the
2121 context of FRAME. BYTE_OFFSET is applied after the contents are
2124 static struct value
*
2125 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2126 const gdb_byte
*data
, size_t size
,
2127 struct dwarf2_per_cu_data
*per_cu
,
2128 LONGEST byte_offset
)
2130 struct value
*retval
;
2131 struct dwarf_expr_baton baton
;
2132 struct dwarf_expr_context
*ctx
;
2133 struct cleanup
*old_chain
, *value_chain
;
2134 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2135 volatile struct gdb_exception ex
;
2137 if (byte_offset
< 0)
2138 invalid_synthetic_pointer ();
2141 return allocate_optimized_out_value (type
);
2143 baton
.frame
= frame
;
2144 baton
.per_cu
= per_cu
;
2146 ctx
= new_dwarf_expr_context ();
2147 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2148 value_chain
= make_cleanup_value_free_to_mark (value_mark ());
2150 ctx
->gdbarch
= get_objfile_arch (objfile
);
2151 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2152 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2153 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2154 ctx
->baton
= &baton
;
2155 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2157 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2159 dwarf_expr_eval (ctx
, data
, size
);
2163 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2165 do_cleanups (old_chain
);
2166 retval
= allocate_value (type
);
2167 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
2170 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2172 if (entry_values_debug
)
2173 exception_print (gdb_stdout
, ex
);
2174 do_cleanups (old_chain
);
2175 return allocate_optimized_out_value (type
);
2178 throw_exception (ex
);
2181 if (ctx
->num_pieces
> 0)
2183 struct piece_closure
*c
;
2184 struct frame_id frame_id
= get_frame_id (frame
);
2185 ULONGEST bit_size
= 0;
2188 for (i
= 0; i
< ctx
->num_pieces
; ++i
)
2189 bit_size
+= ctx
->pieces
[i
].size
;
2190 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
2191 invalid_synthetic_pointer ();
2193 c
= allocate_piece_closure (per_cu
, ctx
->num_pieces
, ctx
->pieces
,
2195 /* We must clean up the value chain after creating the piece
2196 closure but before allocating the result. */
2197 do_cleanups (value_chain
);
2198 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
2199 VALUE_FRAME_ID (retval
) = frame_id
;
2200 set_value_offset (retval
, byte_offset
);
2204 switch (ctx
->location
)
2206 case DWARF_VALUE_REGISTER
:
2208 struct gdbarch
*arch
= get_frame_arch (frame
);
2209 ULONGEST dwarf_regnum
= value_as_long (dwarf_expr_fetch (ctx
, 0));
2210 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
2212 if (byte_offset
!= 0)
2213 error (_("cannot use offset on synthetic pointer to register"));
2214 do_cleanups (value_chain
);
2215 if (gdb_regnum
!= -1)
2216 retval
= value_from_register (type
, gdb_regnum
, frame
);
2218 error (_("Unable to access DWARF register number %s"),
2219 paddress (arch
, dwarf_regnum
));
2223 case DWARF_VALUE_MEMORY
:
2225 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
2226 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
2228 do_cleanups (value_chain
);
2229 retval
= allocate_value_lazy (type
);
2230 VALUE_LVAL (retval
) = lval_memory
;
2231 if (in_stack_memory
)
2232 set_value_stack (retval
, 1);
2233 set_value_address (retval
, address
+ byte_offset
);
2237 case DWARF_VALUE_STACK
:
2239 struct value
*value
= dwarf_expr_fetch (ctx
, 0);
2241 const gdb_byte
*val_bytes
;
2242 size_t n
= TYPE_LENGTH (value_type (value
));
2244 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2245 invalid_synthetic_pointer ();
2247 val_bytes
= value_contents_all (value
);
2248 val_bytes
+= byte_offset
;
2251 /* Preserve VALUE because we are going to free values back
2252 to the mark, but we still need the value contents
2254 value_incref (value
);
2255 do_cleanups (value_chain
);
2256 make_cleanup_value_free (value
);
2258 retval
= allocate_value (type
);
2259 contents
= value_contents_raw (retval
);
2260 if (n
> TYPE_LENGTH (type
))
2262 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2264 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2265 val_bytes
+= n
- TYPE_LENGTH (type
);
2266 n
= TYPE_LENGTH (type
);
2268 memcpy (contents
, val_bytes
, n
);
2272 case DWARF_VALUE_LITERAL
:
2275 const bfd_byte
*ldata
;
2276 size_t n
= ctx
->len
;
2278 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2279 invalid_synthetic_pointer ();
2281 do_cleanups (value_chain
);
2282 retval
= allocate_value (type
);
2283 contents
= value_contents_raw (retval
);
2285 ldata
= ctx
->data
+ byte_offset
;
2288 if (n
> TYPE_LENGTH (type
))
2290 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2292 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2293 ldata
+= n
- TYPE_LENGTH (type
);
2294 n
= TYPE_LENGTH (type
);
2296 memcpy (contents
, ldata
, n
);
2300 case DWARF_VALUE_OPTIMIZED_OUT
:
2301 do_cleanups (value_chain
);
2302 retval
= allocate_optimized_out_value (type
);
2305 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2306 operation by execute_stack_op. */
2307 case DWARF_VALUE_IMPLICIT_POINTER
:
2308 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2309 it can only be encountered when making a piece. */
2311 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2315 set_value_initialized (retval
, ctx
->initialized
);
2317 do_cleanups (old_chain
);
2322 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2323 passes 0 as the byte_offset. */
2326 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2327 const gdb_byte
*data
, size_t size
,
2328 struct dwarf2_per_cu_data
*per_cu
)
2330 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
2334 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2336 struct needs_frame_baton
2339 struct dwarf2_per_cu_data
*per_cu
;
2342 /* Reads from registers do require a frame. */
2344 needs_frame_read_reg (void *baton
, int regnum
)
2346 struct needs_frame_baton
*nf_baton
= baton
;
2348 nf_baton
->needs_frame
= 1;
2352 /* Reads from memory do not require a frame. */
2354 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
2356 memset (buf
, 0, len
);
2359 /* Frame-relative accesses do require a frame. */
2361 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
2363 static gdb_byte lit0
= DW_OP_lit0
;
2364 struct needs_frame_baton
*nf_baton
= baton
;
2369 nf_baton
->needs_frame
= 1;
2372 /* CFA accesses require a frame. */
2375 needs_frame_frame_cfa (void *baton
)
2377 struct needs_frame_baton
*nf_baton
= baton
;
2379 nf_baton
->needs_frame
= 1;
2383 /* Thread-local accesses do require a frame. */
2385 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
2387 struct needs_frame_baton
*nf_baton
= baton
;
2389 nf_baton
->needs_frame
= 1;
2393 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2396 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
2398 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2400 per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
,
2401 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
2404 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2407 needs_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
2408 enum call_site_parameter_kind kind
,
2409 union call_site_parameter_u kind_u
, int deref_size
)
2411 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2413 nf_baton
->needs_frame
= 1;
2415 /* The expression may require some stub values on DWARF stack. */
2416 dwarf_expr_push_address (ctx
, 0, 0);
2419 /* DW_OP_GNU_addr_index doesn't require a frame. */
2422 needs_get_addr_index (void *baton
, unsigned int index
)
2424 /* Nothing to do. */
2428 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2430 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs
=
2432 needs_frame_read_reg
,
2433 needs_frame_read_mem
,
2434 needs_frame_frame_base
,
2435 needs_frame_frame_cfa
,
2436 needs_frame_frame_cfa
, /* get_frame_pc */
2437 needs_frame_tls_address
,
2438 needs_frame_dwarf_call
,
2439 NULL
, /* get_base_type */
2440 needs_dwarf_reg_entry_value
,
2441 needs_get_addr_index
2444 /* Return non-zero iff the location expression at DATA (length SIZE)
2445 requires a frame to evaluate. */
2448 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, size_t size
,
2449 struct dwarf2_per_cu_data
*per_cu
)
2451 struct needs_frame_baton baton
;
2452 struct dwarf_expr_context
*ctx
;
2454 struct cleanup
*old_chain
;
2455 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2457 baton
.needs_frame
= 0;
2458 baton
.per_cu
= per_cu
;
2460 ctx
= new_dwarf_expr_context ();
2461 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2462 make_cleanup_value_free_to_mark (value_mark ());
2464 ctx
->gdbarch
= get_objfile_arch (objfile
);
2465 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2466 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2467 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2468 ctx
->baton
= &baton
;
2469 ctx
->funcs
= &needs_frame_ctx_funcs
;
2471 dwarf_expr_eval (ctx
, data
, size
);
2473 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
2475 if (ctx
->num_pieces
> 0)
2479 /* If the location has several pieces, and any of them are in
2480 registers, then we will need a frame to fetch them from. */
2481 for (i
= 0; i
< ctx
->num_pieces
; i
++)
2482 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2486 do_cleanups (old_chain
);
2488 return baton
.needs_frame
|| in_reg
;
2491 /* A helper function that throws an unimplemented error mentioning a
2492 given DWARF operator. */
2495 unimplemented (unsigned int op
)
2497 const char *name
= get_DW_OP_name (op
);
2500 error (_("DWARF operator %s cannot be translated to an agent expression"),
2503 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2504 "to an agent expression"),
2508 /* A helper function to convert a DWARF register to an arch register.
2509 ARCH is the architecture.
2510 DWARF_REG is the register.
2511 This will throw an exception if the DWARF register cannot be
2512 translated to an architecture register. */
2515 translate_register (struct gdbarch
*arch
, int dwarf_reg
)
2517 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2519 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
2523 /* A helper function that emits an access to memory. ARCH is the
2524 target architecture. EXPR is the expression which we are building.
2525 NBITS is the number of bits we want to read. This emits the
2526 opcodes needed to read the memory and then extract the desired
2530 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2532 ULONGEST nbytes
= (nbits
+ 7) / 8;
2534 gdb_assert (nbits
> 0 && nbits
<= sizeof (LONGEST
));
2537 ax_trace_quick (expr
, nbytes
);
2540 ax_simple (expr
, aop_ref8
);
2541 else if (nbits
<= 16)
2542 ax_simple (expr
, aop_ref16
);
2543 else if (nbits
<= 32)
2544 ax_simple (expr
, aop_ref32
);
2546 ax_simple (expr
, aop_ref64
);
2548 /* If we read exactly the number of bytes we wanted, we're done. */
2549 if (8 * nbytes
== nbits
)
2552 if (gdbarch_bits_big_endian (arch
))
2554 /* On a bits-big-endian machine, we want the high-order
2556 ax_const_l (expr
, 8 * nbytes
- nbits
);
2557 ax_simple (expr
, aop_rsh_unsigned
);
2561 /* On a bits-little-endian box, we want the low-order NBITS. */
2562 ax_zero_ext (expr
, nbits
);
2566 /* A helper function to return the frame's PC. */
2569 get_ax_pc (void *baton
)
2571 struct agent_expr
*expr
= baton
;
2576 /* Compile a DWARF location expression to an agent expression.
2578 EXPR is the agent expression we are building.
2579 LOC is the agent value we modify.
2580 ARCH is the architecture.
2581 ADDR_SIZE is the size of addresses, in bytes.
2582 OP_PTR is the start of the location expression.
2583 OP_END is one past the last byte of the location expression.
2585 This will throw an exception for various kinds of errors -- for
2586 example, if the expression cannot be compiled, or if the expression
2590 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2591 struct gdbarch
*arch
, unsigned int addr_size
,
2592 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
2593 struct dwarf2_per_cu_data
*per_cu
)
2595 struct cleanup
*cleanups
;
2597 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
2598 const gdb_byte
* const base
= op_ptr
;
2599 const gdb_byte
*previous_piece
= op_ptr
;
2600 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2601 ULONGEST bits_collected
= 0;
2602 unsigned int addr_size_bits
= 8 * addr_size
;
2603 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
2605 offsets
= xmalloc ((op_end
- op_ptr
) * sizeof (int));
2606 cleanups
= make_cleanup (xfree
, offsets
);
2608 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
2611 make_cleanup (VEC_cleanup (int), &dw_labels
);
2612 make_cleanup (VEC_cleanup (int), &patches
);
2614 /* By default we are making an address. */
2615 loc
->kind
= axs_lvalue_memory
;
2617 while (op_ptr
< op_end
)
2619 enum dwarf_location_atom op
= *op_ptr
;
2620 uint64_t uoffset
, reg
;
2624 offsets
[op_ptr
- base
] = expr
->len
;
2627 /* Our basic approach to code generation is to map DWARF
2628 operations directly to AX operations. However, there are
2631 First, DWARF works on address-sized units, but AX always uses
2632 LONGEST. For most operations we simply ignore this
2633 difference; instead we generate sign extensions as needed
2634 before division and comparison operations. It would be nice
2635 to omit the sign extensions, but there is no way to determine
2636 the size of the target's LONGEST. (This code uses the size
2637 of the host LONGEST in some cases -- that is a bug but it is
2640 Second, some DWARF operations cannot be translated to AX.
2641 For these we simply fail. See
2642 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2677 ax_const_l (expr
, op
- DW_OP_lit0
);
2681 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
2682 op_ptr
+= addr_size
;
2683 /* Some versions of GCC emit DW_OP_addr before
2684 DW_OP_GNU_push_tls_address. In this case the value is an
2685 index, not an address. We don't support things like
2686 branching between the address and the TLS op. */
2687 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
2688 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
2689 ax_const_l (expr
, uoffset
);
2693 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
2697 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
2701 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
2705 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
2709 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
2713 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
2717 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
2721 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
2725 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
2726 ax_const_l (expr
, uoffset
);
2729 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2730 ax_const_l (expr
, offset
);
2765 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2766 loc
->u
.reg
= translate_register (arch
, op
- DW_OP_reg0
);
2767 loc
->kind
= axs_lvalue_register
;
2771 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2772 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2773 loc
->u
.reg
= translate_register (arch
, reg
);
2774 loc
->kind
= axs_lvalue_register
;
2777 case DW_OP_implicit_value
:
2781 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
2782 if (op_ptr
+ len
> op_end
)
2783 error (_("DW_OP_implicit_value: too few bytes available."));
2784 if (len
> sizeof (ULONGEST
))
2785 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
2788 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
2791 dwarf_expr_require_composition (op_ptr
, op_end
,
2792 "DW_OP_implicit_value");
2794 loc
->kind
= axs_rvalue
;
2798 case DW_OP_stack_value
:
2799 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
2800 loc
->kind
= axs_rvalue
;
2835 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2836 i
= translate_register (arch
, op
- DW_OP_breg0
);
2840 ax_const_l (expr
, offset
);
2841 ax_simple (expr
, aop_add
);
2846 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2847 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2848 i
= translate_register (arch
, reg
);
2852 ax_const_l (expr
, offset
);
2853 ax_simple (expr
, aop_add
);
2859 const gdb_byte
*datastart
;
2862 struct symbol
*framefunc
;
2863 LONGEST base_offset
= 0;
2865 b
= block_for_pc (expr
->scope
);
2868 error (_("No block found for address"));
2870 framefunc
= block_linkage_function (b
);
2873 error (_("No function found for block"));
2875 dwarf_expr_frame_base_1 (framefunc
, expr
->scope
,
2876 &datastart
, &datalen
);
2878 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2879 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
2880 datastart
+ datalen
, per_cu
);
2884 ax_const_l (expr
, offset
);
2885 ax_simple (expr
, aop_add
);
2888 loc
->kind
= axs_lvalue_memory
;
2893 ax_simple (expr
, aop_dup
);
2897 ax_simple (expr
, aop_pop
);
2902 ax_pick (expr
, offset
);
2906 ax_simple (expr
, aop_swap
);
2914 ax_simple (expr
, aop_rot
);
2918 case DW_OP_deref_size
:
2922 if (op
== DW_OP_deref_size
)
2930 ax_simple (expr
, aop_ref8
);
2933 ax_simple (expr
, aop_ref16
);
2936 ax_simple (expr
, aop_ref32
);
2939 ax_simple (expr
, aop_ref64
);
2942 /* Note that get_DW_OP_name will never return
2944 error (_("Unsupported size %d in %s"),
2945 size
, get_DW_OP_name (op
));
2951 /* Sign extend the operand. */
2952 ax_ext (expr
, addr_size_bits
);
2953 ax_simple (expr
, aop_dup
);
2954 ax_const_l (expr
, 0);
2955 ax_simple (expr
, aop_less_signed
);
2956 ax_simple (expr
, aop_log_not
);
2957 i
= ax_goto (expr
, aop_if_goto
);
2958 /* We have to emit 0 - X. */
2959 ax_const_l (expr
, 0);
2960 ax_simple (expr
, aop_swap
);
2961 ax_simple (expr
, aop_sub
);
2962 ax_label (expr
, i
, expr
->len
);
2966 /* No need to sign extend here. */
2967 ax_const_l (expr
, 0);
2968 ax_simple (expr
, aop_swap
);
2969 ax_simple (expr
, aop_sub
);
2973 /* Sign extend the operand. */
2974 ax_ext (expr
, addr_size_bits
);
2975 ax_simple (expr
, aop_bit_not
);
2978 case DW_OP_plus_uconst
:
2979 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2980 /* It would be really weird to emit `DW_OP_plus_uconst 0',
2981 but we micro-optimize anyhow. */
2984 ax_const_l (expr
, reg
);
2985 ax_simple (expr
, aop_add
);
2990 ax_simple (expr
, aop_bit_and
);
2994 /* Sign extend the operands. */
2995 ax_ext (expr
, addr_size_bits
);
2996 ax_simple (expr
, aop_swap
);
2997 ax_ext (expr
, addr_size_bits
);
2998 ax_simple (expr
, aop_swap
);
2999 ax_simple (expr
, aop_div_signed
);
3003 ax_simple (expr
, aop_sub
);
3007 ax_simple (expr
, aop_rem_unsigned
);
3011 ax_simple (expr
, aop_mul
);
3015 ax_simple (expr
, aop_bit_or
);
3019 ax_simple (expr
, aop_add
);
3023 ax_simple (expr
, aop_lsh
);
3027 ax_simple (expr
, aop_rsh_unsigned
);
3031 ax_simple (expr
, aop_rsh_signed
);
3035 ax_simple (expr
, aop_bit_xor
);
3039 /* Sign extend the operands. */
3040 ax_ext (expr
, addr_size_bits
);
3041 ax_simple (expr
, aop_swap
);
3042 ax_ext (expr
, addr_size_bits
);
3043 /* Note no swap here: A <= B is !(B < A). */
3044 ax_simple (expr
, aop_less_signed
);
3045 ax_simple (expr
, aop_log_not
);
3049 /* Sign extend the operands. */
3050 ax_ext (expr
, addr_size_bits
);
3051 ax_simple (expr
, aop_swap
);
3052 ax_ext (expr
, addr_size_bits
);
3053 ax_simple (expr
, aop_swap
);
3054 /* A >= B is !(A < B). */
3055 ax_simple (expr
, aop_less_signed
);
3056 ax_simple (expr
, aop_log_not
);
3060 /* Sign extend the operands. */
3061 ax_ext (expr
, addr_size_bits
);
3062 ax_simple (expr
, aop_swap
);
3063 ax_ext (expr
, addr_size_bits
);
3064 /* No need for a second swap here. */
3065 ax_simple (expr
, aop_equal
);
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 ax_simple (expr
, aop_less_signed
);
3078 /* Sign extend the operands. */
3079 ax_ext (expr
, addr_size_bits
);
3080 ax_simple (expr
, aop_swap
);
3081 ax_ext (expr
, addr_size_bits
);
3082 /* Note no swap here: A > B is B < A. */
3083 ax_simple (expr
, aop_less_signed
);
3087 /* Sign extend the operands. */
3088 ax_ext (expr
, addr_size_bits
);
3089 ax_simple (expr
, aop_swap
);
3090 ax_ext (expr
, addr_size_bits
);
3091 /* No need for a swap here. */
3092 ax_simple (expr
, aop_equal
);
3093 ax_simple (expr
, aop_log_not
);
3096 case DW_OP_call_frame_cfa
:
3097 dwarf2_compile_cfa_to_ax (expr
, loc
, arch
, expr
->scope
, per_cu
);
3098 loc
->kind
= axs_lvalue_memory
;
3101 case DW_OP_GNU_push_tls_address
:
3106 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3108 i
= ax_goto (expr
, aop_goto
);
3109 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3110 VEC_safe_push (int, patches
, i
);
3114 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3116 /* Zero extend the operand. */
3117 ax_zero_ext (expr
, addr_size_bits
);
3118 i
= ax_goto (expr
, aop_if_goto
);
3119 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3120 VEC_safe_push (int, patches
, i
);
3127 case DW_OP_bit_piece
:
3129 uint64_t size
, offset
;
3131 if (op_ptr
- 1 == previous_piece
)
3132 error (_("Cannot translate empty pieces to agent expressions"));
3133 previous_piece
= op_ptr
- 1;
3135 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3136 if (op
== DW_OP_piece
)
3142 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
3144 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3145 error (_("Expression pieces exceed word size"));
3147 /* Access the bits. */
3150 case axs_lvalue_register
:
3151 ax_reg (expr
, loc
->u
.reg
);
3154 case axs_lvalue_memory
:
3155 /* Offset the pointer, if needed. */
3158 ax_const_l (expr
, offset
/ 8);
3159 ax_simple (expr
, aop_add
);
3162 access_memory (arch
, expr
, size
);
3166 /* For a bits-big-endian target, shift up what we already
3167 have. For a bits-little-endian target, shift up the
3168 new data. Note that there is a potential bug here if
3169 the DWARF expression leaves multiple values on the
3171 if (bits_collected
> 0)
3173 if (bits_big_endian
)
3175 ax_simple (expr
, aop_swap
);
3176 ax_const_l (expr
, size
);
3177 ax_simple (expr
, aop_lsh
);
3178 /* We don't need a second swap here, because
3179 aop_bit_or is symmetric. */
3183 ax_const_l (expr
, size
);
3184 ax_simple (expr
, aop_lsh
);
3186 ax_simple (expr
, aop_bit_or
);
3189 bits_collected
+= size
;
3190 loc
->kind
= axs_rvalue
;
3194 case DW_OP_GNU_uninit
:
3200 struct dwarf2_locexpr_baton block
;
3201 int size
= (op
== DW_OP_call2
? 2 : 4);
3204 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3207 offset
.cu_off
= uoffset
;
3208 block
= dwarf2_fetch_die_loc_cu_off (offset
, per_cu
,
3211 /* DW_OP_call_ref is currently not supported. */
3212 gdb_assert (block
.per_cu
== per_cu
);
3214 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3215 block
.data
, block
.data
+ block
.size
,
3220 case DW_OP_call_ref
:
3228 /* Patch all the branches we emitted. */
3229 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
3231 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
3233 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3234 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
3237 do_cleanups (cleanups
);
3241 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3242 evaluator to calculate the location. */
3243 static struct value
*
3244 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3246 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3249 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3250 dlbaton
->size
, dlbaton
->per_cu
);
3255 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3256 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3259 static struct value
*
3260 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3262 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3264 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3268 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3270 locexpr_read_needs_frame (struct symbol
*symbol
)
3272 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3274 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
3278 /* Return true if DATA points to the end of a piece. END is one past
3279 the last byte in the expression. */
3282 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3284 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3287 /* Helper for locexpr_describe_location_piece that finds the name of a
3291 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3295 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
3296 return gdbarch_register_name (gdbarch
, regnum
);
3299 /* Nicely describe a single piece of a location, returning an updated
3300 position in the bytecode sequence. This function cannot recognize
3301 all locations; if a location is not recognized, it simply returns
3302 DATA. If there is an error during reading, e.g. we run off the end
3303 of the buffer, an error is thrown. */
3305 static const gdb_byte
*
3306 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3307 CORE_ADDR addr
, struct objfile
*objfile
,
3308 struct dwarf2_per_cu_data
*per_cu
,
3309 const gdb_byte
*data
, const gdb_byte
*end
,
3310 unsigned int addr_size
)
3312 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3315 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3317 fprintf_filtered (stream
, _("a variable in $%s"),
3318 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3321 else if (data
[0] == DW_OP_regx
)
3325 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3326 fprintf_filtered (stream
, _("a variable in $%s"),
3327 locexpr_regname (gdbarch
, reg
));
3329 else if (data
[0] == DW_OP_fbreg
)
3332 struct symbol
*framefunc
;
3334 int64_t frame_offset
;
3335 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3337 int64_t base_offset
= 0;
3339 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3340 if (!piece_end_p (new_data
, end
))
3344 b
= block_for_pc (addr
);
3347 error (_("No block found for address for symbol \"%s\"."),
3348 SYMBOL_PRINT_NAME (symbol
));
3350 framefunc
= block_linkage_function (b
);
3353 error (_("No function found for block for symbol \"%s\"."),
3354 SYMBOL_PRINT_NAME (symbol
));
3356 dwarf_expr_frame_base_1 (framefunc
, addr
, &base_data
, &base_size
);
3358 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3360 const gdb_byte
*buf_end
;
3362 frame_reg
= base_data
[0] - DW_OP_breg0
;
3363 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3365 if (buf_end
!= base_data
+ base_size
)
3366 error (_("Unexpected opcode after "
3367 "DW_OP_breg%u for symbol \"%s\"."),
3368 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3370 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3372 /* The frame base is just the register, with no offset. */
3373 frame_reg
= base_data
[0] - DW_OP_reg0
;
3378 /* We don't know what to do with the frame base expression,
3379 so we can't trace this variable; give up. */
3383 fprintf_filtered (stream
,
3384 _("a variable at frame base reg $%s offset %s+%s"),
3385 locexpr_regname (gdbarch
, frame_reg
),
3386 plongest (base_offset
), plongest (frame_offset
));
3388 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3389 && piece_end_p (data
, end
))
3393 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3395 fprintf_filtered (stream
,
3396 _("a variable at offset %s from base reg $%s"),
3398 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3401 /* The location expression for a TLS variable looks like this (on a
3404 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3405 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3407 0x3 is the encoding for DW_OP_addr, which has an operand as long
3408 as the size of an address on the target machine (here is 8
3409 bytes). Note that more recent version of GCC emit DW_OP_const4u
3410 or DW_OP_const8u, depending on address size, rather than
3411 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3412 The operand represents the offset at which the variable is within
3413 the thread local storage. */
3415 else if (data
+ 1 + addr_size
< end
3416 && (data
[0] == DW_OP_addr
3417 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3418 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3419 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3420 && piece_end_p (data
+ 2 + addr_size
, end
))
3423 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3424 gdbarch_byte_order (gdbarch
));
3426 fprintf_filtered (stream
,
3427 _("a thread-local variable at offset 0x%s "
3428 "in the thread-local storage for `%s'"),
3429 phex_nz (offset
, addr_size
), objfile
->name
);
3431 data
+= 1 + addr_size
+ 1;
3434 /* With -gsplit-dwarf a TLS variable can also look like this:
3435 DW_AT_location : 3 byte block: fc 4 e0
3436 (DW_OP_GNU_const_index: 4;
3437 DW_OP_GNU_push_tls_address) */
3438 else if (data
+ 3 <= end
3439 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3440 && data
[0] == DW_OP_GNU_const_index
3442 && data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3443 && piece_end_p (data
+ 2 + leb128_size
, end
))
3447 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3448 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3449 fprintf_filtered (stream
,
3450 _("a thread-local variable at offset 0x%s "
3451 "in the thread-local storage for `%s'"),
3452 phex_nz (offset
, addr_size
), objfile
->name
);
3456 else if (data
[0] >= DW_OP_lit0
3457 && data
[0] <= DW_OP_lit31
3459 && data
[1] == DW_OP_stack_value
)
3461 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3468 /* Disassemble an expression, stopping at the end of a piece or at the
3469 end of the expression. Returns a pointer to the next unread byte
3470 in the input expression. If ALL is nonzero, then this function
3471 will keep going until it reaches the end of the expression.
3472 If there is an error during reading, e.g. we run off the end
3473 of the buffer, an error is thrown. */
3475 static const gdb_byte
*
3476 disassemble_dwarf_expression (struct ui_file
*stream
,
3477 struct gdbarch
*arch
, unsigned int addr_size
,
3478 int offset_size
, const gdb_byte
*start
,
3479 const gdb_byte
*data
, const gdb_byte
*end
,
3480 int indent
, int all
,
3481 struct dwarf2_per_cu_data
*per_cu
)
3485 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3487 enum dwarf_location_atom op
= *data
++;
3492 name
= get_DW_OP_name (op
);
3495 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3496 op
, (long) (data
- 1 - start
));
3497 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3498 (long) (data
- 1 - start
), name
);
3503 ul
= extract_unsigned_integer (data
, addr_size
,
3504 gdbarch_byte_order (arch
));
3506 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3510 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3512 fprintf_filtered (stream
, " %s", pulongest (ul
));
3515 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3517 fprintf_filtered (stream
, " %s", plongest (l
));
3520 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3522 fprintf_filtered (stream
, " %s", pulongest (ul
));
3525 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3527 fprintf_filtered (stream
, " %s", plongest (l
));
3530 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3532 fprintf_filtered (stream
, " %s", pulongest (ul
));
3535 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3537 fprintf_filtered (stream
, " %s", plongest (l
));
3540 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3542 fprintf_filtered (stream
, " %s", pulongest (ul
));
3545 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3547 fprintf_filtered (stream
, " %s", plongest (l
));
3550 data
= safe_read_uleb128 (data
, end
, &ul
);
3551 fprintf_filtered (stream
, " %s", pulongest (ul
));
3554 data
= safe_read_sleb128 (data
, end
, &l
);
3555 fprintf_filtered (stream
, " %s", plongest (l
));
3590 fprintf_filtered (stream
, " [$%s]",
3591 locexpr_regname (arch
, op
- DW_OP_reg0
));
3595 data
= safe_read_uleb128 (data
, end
, &ul
);
3596 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3597 locexpr_regname (arch
, (int) ul
));
3600 case DW_OP_implicit_value
:
3601 data
= safe_read_uleb128 (data
, end
, &ul
);
3603 fprintf_filtered (stream
, " %s", pulongest (ul
));
3638 data
= safe_read_sleb128 (data
, end
, &l
);
3639 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
3640 locexpr_regname (arch
, op
- DW_OP_breg0
));
3644 data
= safe_read_uleb128 (data
, end
, &ul
);
3645 data
= safe_read_sleb128 (data
, end
, &l
);
3646 fprintf_filtered (stream
, " register %s [$%s] offset %s",
3648 locexpr_regname (arch
, (int) ul
),
3653 data
= safe_read_sleb128 (data
, end
, &l
);
3654 fprintf_filtered (stream
, " %s", plongest (l
));
3657 case DW_OP_xderef_size
:
3658 case DW_OP_deref_size
:
3660 fprintf_filtered (stream
, " %d", *data
);
3664 case DW_OP_plus_uconst
:
3665 data
= safe_read_uleb128 (data
, end
, &ul
);
3666 fprintf_filtered (stream
, " %s", pulongest (ul
));
3670 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3672 fprintf_filtered (stream
, " to %ld",
3673 (long) (data
+ l
- start
));
3677 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3679 fprintf_filtered (stream
, " %ld",
3680 (long) (data
+ l
- start
));
3684 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3686 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
3690 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3692 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3695 case DW_OP_call_ref
:
3696 ul
= extract_unsigned_integer (data
, offset_size
,
3697 gdbarch_byte_order (arch
));
3698 data
+= offset_size
;
3699 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
3703 data
= safe_read_uleb128 (data
, end
, &ul
);
3704 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
3707 case DW_OP_bit_piece
:
3711 data
= safe_read_uleb128 (data
, end
, &ul
);
3712 data
= safe_read_uleb128 (data
, end
, &offset
);
3713 fprintf_filtered (stream
, " size %s offset %s (bits)",
3714 pulongest (ul
), pulongest (offset
));
3718 case DW_OP_GNU_implicit_pointer
:
3720 ul
= extract_unsigned_integer (data
, offset_size
,
3721 gdbarch_byte_order (arch
));
3722 data
+= offset_size
;
3724 data
= safe_read_sleb128 (data
, end
, &l
);
3726 fprintf_filtered (stream
, " DIE %s offset %s",
3727 phex_nz (ul
, offset_size
),
3732 case DW_OP_GNU_deref_type
:
3734 int addr_size
= *data
++;
3738 data
= safe_read_uleb128 (data
, end
, &ul
);
3740 type
= dwarf2_get_die_type (offset
, per_cu
);
3741 fprintf_filtered (stream
, "<");
3742 type_print (type
, "", stream
, -1);
3743 fprintf_filtered (stream
, " [0x%s]> %d", phex_nz (offset
.cu_off
, 0),
3748 case DW_OP_GNU_const_type
:
3753 data
= safe_read_uleb128 (data
, end
, &ul
);
3754 type_die
.cu_off
= ul
;
3755 type
= dwarf2_get_die_type (type_die
, per_cu
);
3756 fprintf_filtered (stream
, "<");
3757 type_print (type
, "", stream
, -1);
3758 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3762 case DW_OP_GNU_regval_type
:
3768 data
= safe_read_uleb128 (data
, end
, ®
);
3769 data
= safe_read_uleb128 (data
, end
, &ul
);
3770 type_die
.cu_off
= ul
;
3772 type
= dwarf2_get_die_type (type_die
, per_cu
);
3773 fprintf_filtered (stream
, "<");
3774 type_print (type
, "", stream
, -1);
3775 fprintf_filtered (stream
, " [0x%s]> [$%s]",
3776 phex_nz (type_die
.cu_off
, 0),
3777 locexpr_regname (arch
, reg
));
3781 case DW_OP_GNU_convert
:
3782 case DW_OP_GNU_reinterpret
:
3786 data
= safe_read_uleb128 (data
, end
, &ul
);
3787 type_die
.cu_off
= ul
;
3789 if (type_die
.cu_off
== 0)
3790 fprintf_filtered (stream
, "<0>");
3795 type
= dwarf2_get_die_type (type_die
, per_cu
);
3796 fprintf_filtered (stream
, "<");
3797 type_print (type
, "", stream
, -1);
3798 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3803 case DW_OP_GNU_entry_value
:
3804 data
= safe_read_uleb128 (data
, end
, &ul
);
3805 fputc_filtered ('\n', stream
);
3806 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
3807 start
, data
, data
+ ul
, indent
+ 2,
3812 case DW_OP_GNU_parameter_ref
:
3813 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3815 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3818 case DW_OP_GNU_addr_index
:
3819 data
= safe_read_uleb128 (data
, end
, &ul
);
3820 ul
= dwarf2_read_addr_index (per_cu
, ul
);
3821 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3823 case DW_OP_GNU_const_index
:
3824 data
= safe_read_uleb128 (data
, end
, &ul
);
3825 ul
= dwarf2_read_addr_index (per_cu
, ul
);
3826 fprintf_filtered (stream
, " %s", pulongest (ul
));
3830 fprintf_filtered (stream
, "\n");
3836 /* Describe a single location, which may in turn consist of multiple
3840 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
3841 struct ui_file
*stream
,
3842 const gdb_byte
*data
, size_t size
,
3843 struct objfile
*objfile
, unsigned int addr_size
,
3844 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
3846 const gdb_byte
*end
= data
+ size
;
3847 int first_piece
= 1, bad
= 0;
3851 const gdb_byte
*here
= data
;
3852 int disassemble
= 1;
3857 fprintf_filtered (stream
, _(", and "));
3859 if (!dwarf2_always_disassemble
)
3861 data
= locexpr_describe_location_piece (symbol
, stream
,
3862 addr
, objfile
, per_cu
,
3863 data
, end
, addr_size
);
3864 /* If we printed anything, or if we have an empty piece,
3865 then don't disassemble. */
3867 || data
[0] == DW_OP_piece
3868 || data
[0] == DW_OP_bit_piece
)
3873 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
3874 data
= disassemble_dwarf_expression (stream
,
3875 get_objfile_arch (objfile
),
3876 addr_size
, offset_size
, data
,
3878 dwarf2_always_disassemble
,
3884 int empty
= data
== here
;
3887 fprintf_filtered (stream
, " ");
3888 if (data
[0] == DW_OP_piece
)
3892 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
3895 fprintf_filtered (stream
, _("an empty %s-byte piece"),
3898 fprintf_filtered (stream
, _(" [%s-byte piece]"),
3901 else if (data
[0] == DW_OP_bit_piece
)
3903 uint64_t bits
, offset
;
3905 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
3906 data
= safe_read_uleb128 (data
, end
, &offset
);
3909 fprintf_filtered (stream
,
3910 _("an empty %s-bit piece"),
3913 fprintf_filtered (stream
,
3914 _(" [%s-bit piece, offset %s bits]"),
3915 pulongest (bits
), pulongest (offset
));
3925 if (bad
|| data
> end
)
3926 error (_("Corrupted DWARF2 expression for \"%s\"."),
3927 SYMBOL_PRINT_NAME (symbol
));
3930 /* Print a natural-language description of SYMBOL to STREAM. This
3931 version is for a symbol with a single location. */
3934 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
3935 struct ui_file
*stream
)
3937 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3938 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
3939 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
3940 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
3942 locexpr_describe_location_1 (symbol
, addr
, stream
,
3943 dlbaton
->data
, dlbaton
->size
,
3944 objfile
, addr_size
, offset_size
,
3948 /* Describe the location of SYMBOL as an agent value in VALUE, generating
3949 any necessary bytecode in AX. */
3952 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
3953 struct agent_expr
*ax
, struct axs_value
*value
)
3955 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3956 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
3958 if (dlbaton
->size
== 0)
3959 value
->optimized_out
= 1;
3961 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
3962 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
3966 /* The set of location functions used with the DWARF-2 expression
3968 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
3969 locexpr_read_variable
,
3970 locexpr_read_variable_at_entry
,
3971 locexpr_read_needs_frame
,
3972 locexpr_describe_location
,
3973 locexpr_tracepoint_var_ref
3977 /* Wrapper functions for location lists. These generally find
3978 the appropriate location expression and call something above. */
3980 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3981 evaluator to calculate the location. */
3982 static struct value
*
3983 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3985 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3987 const gdb_byte
*data
;
3989 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
3991 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
3992 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
3998 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
3999 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4002 Function always returns non-NULL value, it may be marked optimized out if
4003 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4004 if it cannot resolve the parameter for any reason. */
4006 static struct value
*
4007 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4009 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4010 const gdb_byte
*data
;
4014 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4015 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4017 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4019 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4021 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4024 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
4026 loclist_read_needs_frame (struct symbol
*symbol
)
4028 /* If there's a location list, then assume we need to have a frame
4029 to choose the appropriate location expression. With tracking of
4030 global variables this is not necessarily true, but such tracking
4031 is disabled in GCC at the moment until we figure out how to
4037 /* Print a natural-language description of SYMBOL to STREAM. This
4038 version applies when there is a list of different locations, each
4039 with a specified address range. */
4042 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4043 struct ui_file
*stream
)
4045 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4046 const gdb_byte
*loc_ptr
, *buf_end
;
4048 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4049 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4050 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4051 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4052 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4053 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4054 /* Adjust base_address for relocatable objects. */
4055 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4056 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4059 loc_ptr
= dlbaton
->data
;
4060 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4062 fprintf_filtered (stream
, _("multi-location:\n"));
4064 /* Iterate through locations until we run out. */
4067 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4069 enum debug_loc_kind kind
;
4070 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4072 if (dlbaton
->from_dwo
)
4073 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4074 loc_ptr
, buf_end
, &new_ptr
,
4075 &low
, &high
, byte_order
);
4077 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4079 byte_order
, addr_size
,
4084 case DEBUG_LOC_END_OF_LIST
:
4087 case DEBUG_LOC_BASE_ADDRESS
:
4088 base_address
= high
+ base_offset
;
4089 fprintf_filtered (stream
, _(" Base address %s"),
4090 paddress (gdbarch
, base_address
));
4092 case DEBUG_LOC_START_END
:
4093 case DEBUG_LOC_START_LENGTH
:
4095 case DEBUG_LOC_BUFFER_OVERFLOW
:
4096 case DEBUG_LOC_INVALID_ENTRY
:
4097 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4098 SYMBOL_PRINT_NAME (symbol
));
4100 gdb_assert_not_reached ("bad debug_loc_kind");
4103 /* Otherwise, a location expression entry. */
4104 low
+= base_address
;
4105 high
+= base_address
;
4107 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4110 /* (It would improve readability to print only the minimum
4111 necessary digits of the second number of the range.) */
4112 fprintf_filtered (stream
, _(" Range %s-%s: "),
4113 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4115 /* Now describe this particular location. */
4116 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4117 objfile
, addr_size
, offset_size
,
4120 fprintf_filtered (stream
, "\n");
4126 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4127 any necessary bytecode in AX. */
4129 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4130 struct agent_expr
*ax
, struct axs_value
*value
)
4132 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4133 const gdb_byte
*data
;
4135 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4137 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4139 value
->optimized_out
= 1;
4141 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
4145 /* The set of location functions used with the DWARF-2 expression
4146 evaluator and location lists. */
4147 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4148 loclist_read_variable
,
4149 loclist_read_variable_at_entry
,
4150 loclist_read_needs_frame
,
4151 loclist_describe_location
,
4152 loclist_tracepoint_var_ref
4155 /* Provide a prototype to silence -Wmissing-prototypes. */
4156 extern initialize_file_ftype _initialize_dwarf2loc
;
4159 _initialize_dwarf2loc (void)
4161 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4162 &entry_values_debug
,
4163 _("Set entry values and tail call frames "
4165 _("Show entry values and tail call frames "
4167 _("When non-zero, the process of determining "
4168 "parameter values from function entry point "
4169 "and tail call frames will be printed."),
4171 show_entry_values_debug
,
4172 &setdebuglist
, &showdebuglist
);