1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003, 2005, 2007-2012 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
;
336 /* Use block_linkage_function, which returns a real (not inlined)
337 function, instead of get_frame_function, which may return an
339 framefunc
= block_linkage_function (get_frame_block (debaton
->frame
, NULL
));
341 /* If we found a frame-relative symbol then it was certainly within
342 some function associated with a frame. If we can't find the frame,
343 something has gone wrong. */
344 gdb_assert (framefunc
!= NULL
);
346 dwarf_expr_frame_base_1 (framefunc
,
347 get_frame_address_in_block (debaton
->frame
),
352 dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
353 const gdb_byte
**start
, size_t *length
)
355 if (SYMBOL_LOCATION_BATON (framefunc
) == NULL
)
357 else if (SYMBOL_COMPUTED_OPS (framefunc
) == &dwarf2_loclist_funcs
)
359 struct dwarf2_loclist_baton
*symbaton
;
361 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
362 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
366 struct dwarf2_locexpr_baton
*symbaton
;
368 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
369 if (symbaton
!= NULL
)
371 *length
= symbaton
->size
;
372 *start
= symbaton
->data
;
379 error (_("Could not find the frame base for \"%s\"."),
380 SYMBOL_NATURAL_NAME (framefunc
));
383 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
384 the frame in BATON. */
387 dwarf_expr_frame_cfa (void *baton
)
389 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
391 return dwarf2_frame_cfa (debaton
->frame
);
394 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
395 the frame in BATON. */
398 dwarf_expr_frame_pc (void *baton
)
400 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
402 return get_frame_address_in_block (debaton
->frame
);
405 /* Using the objfile specified in BATON, find the address for the
406 current thread's thread-local storage with offset OFFSET. */
408 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
410 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
411 struct objfile
*objfile
= dwarf2_per_cu_objfile (debaton
->per_cu
);
413 return target_translate_tls_address (objfile
, offset
);
416 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
417 current CU (as is PER_CU). State of the CTX is not affected by the
421 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
,
422 struct dwarf2_per_cu_data
*per_cu
,
423 CORE_ADDR (*get_frame_pc
) (void *baton
),
426 struct dwarf2_locexpr_baton block
;
428 block
= dwarf2_fetch_die_location_block (die_offset
, per_cu
,
429 get_frame_pc
, baton
);
431 /* DW_OP_call_ref is currently not supported. */
432 gdb_assert (block
.per_cu
== per_cu
);
434 dwarf_expr_eval (ctx
, block
.data
, block
.size
);
437 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
440 dwarf_expr_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
442 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
444 per_cu_dwarf_call (ctx
, die_offset
, debaton
->per_cu
,
445 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
448 /* Callback function for dwarf2_evaluate_loc_desc. */
451 dwarf_expr_get_base_type (struct dwarf_expr_context
*ctx
,
452 cu_offset die_offset
)
454 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
456 return dwarf2_get_die_type (die_offset
, debaton
->per_cu
);
459 /* See dwarf2loc.h. */
461 unsigned int entry_values_debug
= 0;
463 /* Helper to set entry_values_debug. */
466 show_entry_values_debug (struct ui_file
*file
, int from_tty
,
467 struct cmd_list_element
*c
, const char *value
)
469 fprintf_filtered (file
,
470 _("Entry values and tail call frames debugging is %s.\n"),
474 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
475 CALLER_FRAME (for registers) can be NULL if it is not known. This function
476 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
479 call_site_to_target_addr (struct gdbarch
*call_site_gdbarch
,
480 struct call_site
*call_site
,
481 struct frame_info
*caller_frame
)
483 switch (FIELD_LOC_KIND (call_site
->target
))
485 case FIELD_LOC_KIND_DWARF_BLOCK
:
487 struct dwarf2_locexpr_baton
*dwarf_block
;
489 struct type
*caller_core_addr_type
;
490 struct gdbarch
*caller_arch
;
492 dwarf_block
= FIELD_DWARF_BLOCK (call_site
->target
);
493 if (dwarf_block
== NULL
)
495 struct minimal_symbol
*msym
;
497 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
498 throw_error (NO_ENTRY_VALUE_ERROR
,
499 _("DW_AT_GNU_call_site_target is not specified "
501 paddress (call_site_gdbarch
, call_site
->pc
),
502 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
505 if (caller_frame
== NULL
)
507 struct minimal_symbol
*msym
;
509 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
510 throw_error (NO_ENTRY_VALUE_ERROR
,
511 _("DW_AT_GNU_call_site_target DWARF block resolving "
512 "requires known frame which is currently not "
513 "available at %s in %s"),
514 paddress (call_site_gdbarch
, call_site
->pc
),
515 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
518 caller_arch
= get_frame_arch (caller_frame
);
519 caller_core_addr_type
= builtin_type (caller_arch
)->builtin_func_ptr
;
520 val
= dwarf2_evaluate_loc_desc (caller_core_addr_type
, caller_frame
,
521 dwarf_block
->data
, dwarf_block
->size
,
522 dwarf_block
->per_cu
);
523 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
525 if (VALUE_LVAL (val
) == lval_memory
)
526 return value_address (val
);
528 return value_as_address (val
);
531 case FIELD_LOC_KIND_PHYSNAME
:
533 const char *physname
;
534 struct minimal_symbol
*msym
;
536 physname
= FIELD_STATIC_PHYSNAME (call_site
->target
);
537 msym
= lookup_minimal_symbol_text (physname
, NULL
);
540 msym
= lookup_minimal_symbol_by_pc (call_site
->pc
- 1);
541 throw_error (NO_ENTRY_VALUE_ERROR
,
542 _("Cannot find function \"%s\" for a call site target "
544 physname
, paddress (call_site_gdbarch
, call_site
->pc
),
545 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
548 return SYMBOL_VALUE_ADDRESS (msym
);
551 case FIELD_LOC_KIND_PHYSADDR
:
552 return FIELD_STATIC_PHYSADDR (call_site
->target
);
555 internal_error (__FILE__
, __LINE__
, _("invalid call site target kind"));
559 /* Convert function entry point exact address ADDR to the function which is
560 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
561 NO_ENTRY_VALUE_ERROR otherwise. */
563 static struct symbol
*
564 func_addr_to_tail_call_list (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
566 struct symbol
*sym
= find_pc_function (addr
);
569 if (sym
== NULL
|| BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) != addr
)
570 throw_error (NO_ENTRY_VALUE_ERROR
,
571 _("DW_TAG_GNU_call_site resolving failed to find function "
572 "name for address %s"),
573 paddress (gdbarch
, addr
));
575 type
= SYMBOL_TYPE (sym
);
576 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FUNC
);
577 gdb_assert (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_FUNC
);
582 /* Verify function with entry point exact address ADDR can never call itself
583 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
584 can call itself via tail calls.
586 If a funtion can tail call itself its entry value based parameters are
587 unreliable. There is no verification whether the value of some/all
588 parameters is unchanged through the self tail call, we expect if there is
589 a self tail call all the parameters can be modified. */
592 func_verify_no_selftailcall (struct gdbarch
*gdbarch
, CORE_ADDR verify_addr
)
594 struct obstack addr_obstack
;
595 struct cleanup
*old_chain
;
598 /* Track here CORE_ADDRs which were already visited. */
601 /* The verification is completely unordered. Track here function addresses
602 which still need to be iterated. */
603 VEC (CORE_ADDR
) *todo
= NULL
;
605 obstack_init (&addr_obstack
);
606 old_chain
= make_cleanup_obstack_free (&addr_obstack
);
607 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
608 &addr_obstack
, hashtab_obstack_allocate
,
610 make_cleanup_htab_delete (addr_hash
);
612 make_cleanup (VEC_cleanup (CORE_ADDR
), &todo
);
614 VEC_safe_push (CORE_ADDR
, todo
, verify_addr
);
615 while (!VEC_empty (CORE_ADDR
, todo
))
617 struct symbol
*func_sym
;
618 struct call_site
*call_site
;
620 addr
= VEC_pop (CORE_ADDR
, todo
);
622 func_sym
= func_addr_to_tail_call_list (gdbarch
, addr
);
624 for (call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym
));
625 call_site
; call_site
= call_site
->tail_call_next
)
627 CORE_ADDR target_addr
;
630 /* CALLER_FRAME with registers is not available for tail-call jumped
632 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
634 if (target_addr
== verify_addr
)
636 struct minimal_symbol
*msym
;
638 msym
= lookup_minimal_symbol_by_pc (verify_addr
);
639 throw_error (NO_ENTRY_VALUE_ERROR
,
640 _("DW_OP_GNU_entry_value resolving has found "
641 "function \"%s\" at %s can call itself via tail "
643 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
),
644 paddress (gdbarch
, verify_addr
));
647 slot
= htab_find_slot (addr_hash
, &target_addr
, INSERT
);
650 *slot
= obstack_copy (&addr_obstack
, &target_addr
,
651 sizeof (target_addr
));
652 VEC_safe_push (CORE_ADDR
, todo
, target_addr
);
657 do_cleanups (old_chain
);
660 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
661 ENTRY_VALUES_DEBUG. */
664 tailcall_dump (struct gdbarch
*gdbarch
, const struct call_site
*call_site
)
666 CORE_ADDR addr
= call_site
->pc
;
667 struct minimal_symbol
*msym
= lookup_minimal_symbol_by_pc (addr
- 1);
669 fprintf_unfiltered (gdb_stdlog
, " %s(%s)", paddress (gdbarch
, addr
),
670 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
674 /* vec.h needs single word type name, typedef it. */
675 typedef struct call_site
*call_sitep
;
677 /* Define VEC (call_sitep) functions. */
678 DEF_VEC_P (call_sitep
);
680 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
681 only top callers and bottom callees which are present in both. GDBARCH is
682 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
683 no remaining possibilities to provide unambiguous non-trivial result.
684 RESULTP should point to NULL on the first (initialization) call. Caller is
685 responsible for xfree of any RESULTP data. */
688 chain_candidate (struct gdbarch
*gdbarch
, struct call_site_chain
**resultp
,
689 VEC (call_sitep
) *chain
)
691 struct call_site_chain
*result
= *resultp
;
692 long length
= VEC_length (call_sitep
, chain
);
693 int callers
, callees
, idx
;
697 /* Create the initial chain containing all the passed PCs. */
699 result
= xmalloc (sizeof (*result
) + sizeof (*result
->call_site
)
701 result
->length
= length
;
702 result
->callers
= result
->callees
= length
;
703 memcpy (result
->call_site
, VEC_address (call_sitep
, chain
),
704 sizeof (*result
->call_site
) * length
);
707 if (entry_values_debug
)
709 fprintf_unfiltered (gdb_stdlog
, "tailcall: initial:");
710 for (idx
= 0; idx
< length
; idx
++)
711 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
712 fputc_unfiltered ('\n', gdb_stdlog
);
718 if (entry_values_debug
)
720 fprintf_unfiltered (gdb_stdlog
, "tailcall: compare:");
721 for (idx
= 0; idx
< length
; idx
++)
722 tailcall_dump (gdbarch
, VEC_index (call_sitep
, chain
, idx
));
723 fputc_unfiltered ('\n', gdb_stdlog
);
726 /* Intersect callers. */
728 callers
= min (result
->callers
, length
);
729 for (idx
= 0; idx
< callers
; idx
++)
730 if (result
->call_site
[idx
] != VEC_index (call_sitep
, chain
, idx
))
732 result
->callers
= idx
;
736 /* Intersect callees. */
738 callees
= min (result
->callees
, length
);
739 for (idx
= 0; idx
< callees
; idx
++)
740 if (result
->call_site
[result
->length
- 1 - idx
]
741 != VEC_index (call_sitep
, chain
, length
- 1 - idx
))
743 result
->callees
= idx
;
747 if (entry_values_debug
)
749 fprintf_unfiltered (gdb_stdlog
, "tailcall: reduced:");
750 for (idx
= 0; idx
< result
->callers
; idx
++)
751 tailcall_dump (gdbarch
, result
->call_site
[idx
]);
752 fputs_unfiltered (" |", gdb_stdlog
);
753 for (idx
= 0; idx
< result
->callees
; idx
++)
754 tailcall_dump (gdbarch
, result
->call_site
[result
->length
755 - result
->callees
+ idx
]);
756 fputc_unfiltered ('\n', gdb_stdlog
);
759 if (result
->callers
== 0 && result
->callees
== 0)
761 /* There are no common callers or callees. It could be also a direct
762 call (which has length 0) with ambiguous possibility of an indirect
763 call - CALLERS == CALLEES == 0 is valid during the first allocation
764 but any subsequence processing of such entry means ambiguity. */
770 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
771 PC again. In such case there must be two different code paths to reach
772 it, therefore some of the former determined intermediate PCs must differ
773 and the unambiguous chain gets shortened. */
774 gdb_assert (result
->callers
+ result
->callees
< result
->length
);
777 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
778 assumed frames between them use GDBARCH. Use depth first search so we can
779 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
780 would have needless GDB stack overhead. Caller is responsible for xfree of
781 the returned result. Any unreliability results in thrown
782 NO_ENTRY_VALUE_ERROR. */
784 static struct call_site_chain
*
785 call_site_find_chain_1 (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
788 struct obstack addr_obstack
;
789 struct cleanup
*back_to_retval
, *back_to_workdata
;
790 struct call_site_chain
*retval
= NULL
;
791 struct call_site
*call_site
;
793 /* Mark CALL_SITEs so we do not visit the same ones twice. */
796 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
797 call_site nor any possible call_site at CALLEE_PC's function is there.
798 Any CALL_SITE in CHAIN will be iterated to its siblings - via
799 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
800 VEC (call_sitep
) *chain
= NULL
;
802 /* We are not interested in the specific PC inside the callee function. */
803 callee_pc
= get_pc_function_start (callee_pc
);
805 throw_error (NO_ENTRY_VALUE_ERROR
, _("Unable to find function for PC %s"),
806 paddress (gdbarch
, callee_pc
));
808 back_to_retval
= make_cleanup (free_current_contents
, &retval
);
810 obstack_init (&addr_obstack
);
811 back_to_workdata
= make_cleanup_obstack_free (&addr_obstack
);
812 addr_hash
= htab_create_alloc_ex (64, core_addr_hash
, core_addr_eq
, NULL
,
813 &addr_obstack
, hashtab_obstack_allocate
,
815 make_cleanup_htab_delete (addr_hash
);
817 make_cleanup (VEC_cleanup (call_sitep
), &chain
);
819 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
820 at the target's function. All the possible tail call sites in the
821 target's function will get iterated as already pushed into CHAIN via their
823 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
827 CORE_ADDR target_func_addr
;
828 struct call_site
*target_call_site
;
830 /* CALLER_FRAME with registers is not available for tail-call jumped
832 target_func_addr
= call_site_to_target_addr (gdbarch
, call_site
, NULL
);
834 if (target_func_addr
== callee_pc
)
836 chain_candidate (gdbarch
, &retval
, chain
);
840 /* There is no way to reach CALLEE_PC again as we would prevent
841 entering it twice as being already marked in ADDR_HASH. */
842 target_call_site
= NULL
;
846 struct symbol
*target_func
;
848 target_func
= func_addr_to_tail_call_list (gdbarch
, target_func_addr
);
849 target_call_site
= TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func
));
854 /* Attempt to visit TARGET_CALL_SITE. */
856 if (target_call_site
)
860 slot
= htab_find_slot (addr_hash
, &target_call_site
->pc
, INSERT
);
863 /* Successfully entered TARGET_CALL_SITE. */
865 *slot
= &target_call_site
->pc
;
866 VEC_safe_push (call_sitep
, chain
, target_call_site
);
871 /* Backtrack (without revisiting the originating call_site). Try the
872 callers's sibling; if there isn't any try the callers's callers's
875 target_call_site
= NULL
;
876 while (!VEC_empty (call_sitep
, chain
))
878 call_site
= VEC_pop (call_sitep
, chain
);
880 gdb_assert (htab_find_slot (addr_hash
, &call_site
->pc
,
882 htab_remove_elt (addr_hash
, &call_site
->pc
);
884 target_call_site
= call_site
->tail_call_next
;
885 if (target_call_site
)
889 while (target_call_site
);
891 if (VEC_empty (call_sitep
, chain
))
894 call_site
= VEC_last (call_sitep
, chain
);
899 struct minimal_symbol
*msym_caller
, *msym_callee
;
901 msym_caller
= lookup_minimal_symbol_by_pc (caller_pc
);
902 msym_callee
= lookup_minimal_symbol_by_pc (callee_pc
);
903 throw_error (NO_ENTRY_VALUE_ERROR
,
904 _("There are no unambiguously determinable intermediate "
905 "callers or callees between caller function \"%s\" at %s "
906 "and callee function \"%s\" at %s"),
908 ? "???" : SYMBOL_PRINT_NAME (msym_caller
)),
909 paddress (gdbarch
, caller_pc
),
911 ? "???" : SYMBOL_PRINT_NAME (msym_callee
)),
912 paddress (gdbarch
, callee_pc
));
915 do_cleanups (back_to_workdata
);
916 discard_cleanups (back_to_retval
);
920 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
921 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
922 constructed return NULL. Caller is responsible for xfree of the returned
925 struct call_site_chain
*
926 call_site_find_chain (struct gdbarch
*gdbarch
, CORE_ADDR caller_pc
,
929 volatile struct gdb_exception e
;
930 struct call_site_chain
*retval
= NULL
;
932 TRY_CATCH (e
, RETURN_MASK_ERROR
)
934 retval
= call_site_find_chain_1 (gdbarch
, caller_pc
, callee_pc
);
938 if (e
.error
== NO_ENTRY_VALUE_ERROR
)
940 if (entry_values_debug
)
941 exception_print (gdb_stdout
, e
);
951 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
954 call_site_parameter_matches (struct call_site_parameter
*parameter
,
955 enum call_site_parameter_kind kind
,
956 union call_site_parameter_u kind_u
)
958 if (kind
== parameter
->kind
)
961 case CALL_SITE_PARAMETER_DWARF_REG
:
962 return kind_u
.dwarf_reg
== parameter
->u
.dwarf_reg
;
963 case CALL_SITE_PARAMETER_FB_OFFSET
:
964 return kind_u
.fb_offset
== parameter
->u
.fb_offset
;
965 case CALL_SITE_PARAMETER_PARAM_OFFSET
:
966 return kind_u
.param_offset
.cu_off
== parameter
->u
.param_offset
.cu_off
;
971 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
974 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
977 static struct call_site_parameter
*
978 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
,
979 enum call_site_parameter_kind kind
,
980 union call_site_parameter_u kind_u
,
981 struct dwarf2_per_cu_data
**per_cu_return
)
983 CORE_ADDR func_addr
, caller_pc
;
984 struct gdbarch
*gdbarch
;
985 struct frame_info
*caller_frame
;
986 struct call_site
*call_site
;
988 /* Initialize it just to avoid a GCC false warning. */
989 struct call_site_parameter
*parameter
= NULL
;
990 CORE_ADDR target_addr
;
992 /* Skip any inlined frames, entry value call sites work between real
993 functions. They do not make sense between inline functions as even PC
994 does not change there. */
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
);
2040 baton
= dwarf2_fetch_die_location_block (piece
->v
.ptr
.die
, c
->per_cu
,
2041 get_frame_address_in_block_wrapper
,
2044 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
2045 baton
.data
, baton
.size
, baton
.per_cu
,
2046 piece
->v
.ptr
.offset
+ byte_offset
);
2050 copy_pieced_value_closure (const struct value
*v
)
2052 struct piece_closure
*c
2053 = (struct piece_closure
*) value_computed_closure (v
);
2060 free_pieced_value_closure (struct value
*v
)
2062 struct piece_closure
*c
2063 = (struct piece_closure
*) value_computed_closure (v
);
2070 for (i
= 0; i
< c
->n_pieces
; ++i
)
2071 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
2072 value_free (c
->pieces
[i
].v
.value
);
2079 /* Functions for accessing a variable described by DW_OP_piece. */
2080 static const struct lval_funcs pieced_value_funcs
= {
2083 check_pieced_value_validity
,
2084 check_pieced_value_invalid
,
2085 indirect_pieced_value
,
2086 NULL
, /* coerce_ref */
2087 check_pieced_synthetic_pointer
,
2088 copy_pieced_value_closure
,
2089 free_pieced_value_closure
2092 /* Helper function which throws an error if a synthetic pointer is
2096 invalid_synthetic_pointer (void)
2098 error (_("access outside bounds of object "
2099 "referenced via synthetic pointer"));
2102 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2104 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
=
2106 dwarf_expr_read_reg
,
2107 dwarf_expr_read_mem
,
2108 dwarf_expr_frame_base
,
2109 dwarf_expr_frame_cfa
,
2110 dwarf_expr_frame_pc
,
2111 dwarf_expr_tls_address
,
2112 dwarf_expr_dwarf_call
,
2113 dwarf_expr_get_base_type
,
2114 dwarf_expr_push_dwarf_reg_entry_value
,
2115 dwarf_expr_get_addr_index
2118 /* Evaluate a location description, starting at DATA and with length
2119 SIZE, to find the current location of variable of TYPE in the
2120 context of FRAME. BYTE_OFFSET is applied after the contents are
2123 static struct value
*
2124 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2125 const gdb_byte
*data
, size_t size
,
2126 struct dwarf2_per_cu_data
*per_cu
,
2127 LONGEST byte_offset
)
2129 struct value
*retval
;
2130 struct dwarf_expr_baton baton
;
2131 struct dwarf_expr_context
*ctx
;
2132 struct cleanup
*old_chain
, *value_chain
;
2133 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2134 volatile struct gdb_exception ex
;
2136 if (byte_offset
< 0)
2137 invalid_synthetic_pointer ();
2140 return allocate_optimized_out_value (type
);
2142 baton
.frame
= frame
;
2143 baton
.per_cu
= per_cu
;
2145 ctx
= new_dwarf_expr_context ();
2146 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2147 value_chain
= make_cleanup_value_free_to_mark (value_mark ());
2149 ctx
->gdbarch
= get_objfile_arch (objfile
);
2150 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2151 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2152 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2153 ctx
->baton
= &baton
;
2154 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2156 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2158 dwarf_expr_eval (ctx
, data
, size
);
2162 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2164 do_cleanups (old_chain
);
2165 retval
= allocate_value (type
);
2166 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
2169 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2171 if (entry_values_debug
)
2172 exception_print (gdb_stdout
, ex
);
2173 do_cleanups (old_chain
);
2174 return allocate_optimized_out_value (type
);
2177 throw_exception (ex
);
2180 if (ctx
->num_pieces
> 0)
2182 struct piece_closure
*c
;
2183 struct frame_id frame_id
= get_frame_id (frame
);
2184 ULONGEST bit_size
= 0;
2187 for (i
= 0; i
< ctx
->num_pieces
; ++i
)
2188 bit_size
+= ctx
->pieces
[i
].size
;
2189 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
2190 invalid_synthetic_pointer ();
2192 c
= allocate_piece_closure (per_cu
, ctx
->num_pieces
, ctx
->pieces
,
2194 /* We must clean up the value chain after creating the piece
2195 closure but before allocating the result. */
2196 do_cleanups (value_chain
);
2197 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
2198 VALUE_FRAME_ID (retval
) = frame_id
;
2199 set_value_offset (retval
, byte_offset
);
2203 switch (ctx
->location
)
2205 case DWARF_VALUE_REGISTER
:
2207 struct gdbarch
*arch
= get_frame_arch (frame
);
2208 ULONGEST dwarf_regnum
= value_as_long (dwarf_expr_fetch (ctx
, 0));
2209 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
2211 if (byte_offset
!= 0)
2212 error (_("cannot use offset on synthetic pointer to register"));
2213 do_cleanups (value_chain
);
2214 if (gdb_regnum
!= -1)
2215 retval
= value_from_register (type
, gdb_regnum
, frame
);
2217 error (_("Unable to access DWARF register number %s"),
2218 paddress (arch
, dwarf_regnum
));
2222 case DWARF_VALUE_MEMORY
:
2224 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
2225 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
2227 do_cleanups (value_chain
);
2228 retval
= allocate_value_lazy (type
);
2229 VALUE_LVAL (retval
) = lval_memory
;
2230 if (in_stack_memory
)
2231 set_value_stack (retval
, 1);
2232 set_value_address (retval
, address
+ byte_offset
);
2236 case DWARF_VALUE_STACK
:
2238 struct value
*value
= dwarf_expr_fetch (ctx
, 0);
2240 const gdb_byte
*val_bytes
;
2241 size_t n
= TYPE_LENGTH (value_type (value
));
2243 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2244 invalid_synthetic_pointer ();
2246 val_bytes
= value_contents_all (value
);
2247 val_bytes
+= byte_offset
;
2250 /* Preserve VALUE because we are going to free values back
2251 to the mark, but we still need the value contents
2253 value_incref (value
);
2254 do_cleanups (value_chain
);
2255 make_cleanup_value_free (value
);
2257 retval
= allocate_value (type
);
2258 contents
= value_contents_raw (retval
);
2259 if (n
> TYPE_LENGTH (type
))
2261 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2263 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2264 val_bytes
+= n
- TYPE_LENGTH (type
);
2265 n
= TYPE_LENGTH (type
);
2267 memcpy (contents
, val_bytes
, n
);
2271 case DWARF_VALUE_LITERAL
:
2274 const bfd_byte
*ldata
;
2275 size_t n
= ctx
->len
;
2277 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2278 invalid_synthetic_pointer ();
2280 do_cleanups (value_chain
);
2281 retval
= allocate_value (type
);
2282 contents
= value_contents_raw (retval
);
2284 ldata
= ctx
->data
+ byte_offset
;
2287 if (n
> TYPE_LENGTH (type
))
2289 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2291 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2292 ldata
+= n
- TYPE_LENGTH (type
);
2293 n
= TYPE_LENGTH (type
);
2295 memcpy (contents
, ldata
, n
);
2299 case DWARF_VALUE_OPTIMIZED_OUT
:
2300 do_cleanups (value_chain
);
2301 retval
= allocate_optimized_out_value (type
);
2304 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2305 operation by execute_stack_op. */
2306 case DWARF_VALUE_IMPLICIT_POINTER
:
2307 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2308 it can only be encountered when making a piece. */
2310 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2314 set_value_initialized (retval
, ctx
->initialized
);
2316 do_cleanups (old_chain
);
2321 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2322 passes 0 as the byte_offset. */
2325 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2326 const gdb_byte
*data
, size_t size
,
2327 struct dwarf2_per_cu_data
*per_cu
)
2329 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
2333 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2335 struct needs_frame_baton
2338 struct dwarf2_per_cu_data
*per_cu
;
2341 /* Reads from registers do require a frame. */
2343 needs_frame_read_reg (void *baton
, int regnum
)
2345 struct needs_frame_baton
*nf_baton
= baton
;
2347 nf_baton
->needs_frame
= 1;
2351 /* Reads from memory do not require a frame. */
2353 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
2355 memset (buf
, 0, len
);
2358 /* Frame-relative accesses do require a frame. */
2360 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
2362 static gdb_byte lit0
= DW_OP_lit0
;
2363 struct needs_frame_baton
*nf_baton
= baton
;
2368 nf_baton
->needs_frame
= 1;
2371 /* CFA accesses require a frame. */
2374 needs_frame_frame_cfa (void *baton
)
2376 struct needs_frame_baton
*nf_baton
= baton
;
2378 nf_baton
->needs_frame
= 1;
2382 /* Thread-local accesses do require a frame. */
2384 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
2386 struct needs_frame_baton
*nf_baton
= baton
;
2388 nf_baton
->needs_frame
= 1;
2392 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2395 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
2397 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2399 per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
,
2400 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
2403 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2406 needs_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
2407 enum call_site_parameter_kind kind
,
2408 union call_site_parameter_u kind_u
, int deref_size
)
2410 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2412 nf_baton
->needs_frame
= 1;
2414 /* The expression may require some stub values on DWARF stack. */
2415 dwarf_expr_push_address (ctx
, 0, 0);
2418 /* DW_OP_GNU_addr_index doesn't require a frame. */
2421 needs_get_addr_index (void *baton
, unsigned int index
)
2423 /* Nothing to do. */
2427 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2429 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs
=
2431 needs_frame_read_reg
,
2432 needs_frame_read_mem
,
2433 needs_frame_frame_base
,
2434 needs_frame_frame_cfa
,
2435 needs_frame_frame_cfa
, /* get_frame_pc */
2436 needs_frame_tls_address
,
2437 needs_frame_dwarf_call
,
2438 NULL
, /* get_base_type */
2439 needs_dwarf_reg_entry_value
,
2440 needs_get_addr_index
2443 /* Return non-zero iff the location expression at DATA (length SIZE)
2444 requires a frame to evaluate. */
2447 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, size_t size
,
2448 struct dwarf2_per_cu_data
*per_cu
)
2450 struct needs_frame_baton baton
;
2451 struct dwarf_expr_context
*ctx
;
2453 struct cleanup
*old_chain
;
2454 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2456 baton
.needs_frame
= 0;
2457 baton
.per_cu
= per_cu
;
2459 ctx
= new_dwarf_expr_context ();
2460 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2461 make_cleanup_value_free_to_mark (value_mark ());
2463 ctx
->gdbarch
= get_objfile_arch (objfile
);
2464 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2465 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2466 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2467 ctx
->baton
= &baton
;
2468 ctx
->funcs
= &needs_frame_ctx_funcs
;
2470 dwarf_expr_eval (ctx
, data
, size
);
2472 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
2474 if (ctx
->num_pieces
> 0)
2478 /* If the location has several pieces, and any of them are in
2479 registers, then we will need a frame to fetch them from. */
2480 for (i
= 0; i
< ctx
->num_pieces
; i
++)
2481 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2485 do_cleanups (old_chain
);
2487 return baton
.needs_frame
|| in_reg
;
2490 /* A helper function that throws an unimplemented error mentioning a
2491 given DWARF operator. */
2494 unimplemented (unsigned int op
)
2496 const char *name
= get_DW_OP_name (op
);
2499 error (_("DWARF operator %s cannot be translated to an agent expression"),
2502 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2503 "to an agent expression"),
2507 /* A helper function to convert a DWARF register to an arch register.
2508 ARCH is the architecture.
2509 DWARF_REG is the register.
2510 This will throw an exception if the DWARF register cannot be
2511 translated to an architecture register. */
2514 translate_register (struct gdbarch
*arch
, int dwarf_reg
)
2516 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2518 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
2522 /* A helper function that emits an access to memory. ARCH is the
2523 target architecture. EXPR is the expression which we are building.
2524 NBITS is the number of bits we want to read. This emits the
2525 opcodes needed to read the memory and then extract the desired
2529 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2531 ULONGEST nbytes
= (nbits
+ 7) / 8;
2533 gdb_assert (nbits
> 0 && nbits
<= sizeof (LONGEST
));
2536 ax_trace_quick (expr
, nbytes
);
2539 ax_simple (expr
, aop_ref8
);
2540 else if (nbits
<= 16)
2541 ax_simple (expr
, aop_ref16
);
2542 else if (nbits
<= 32)
2543 ax_simple (expr
, aop_ref32
);
2545 ax_simple (expr
, aop_ref64
);
2547 /* If we read exactly the number of bytes we wanted, we're done. */
2548 if (8 * nbytes
== nbits
)
2551 if (gdbarch_bits_big_endian (arch
))
2553 /* On a bits-big-endian machine, we want the high-order
2555 ax_const_l (expr
, 8 * nbytes
- nbits
);
2556 ax_simple (expr
, aop_rsh_unsigned
);
2560 /* On a bits-little-endian box, we want the low-order NBITS. */
2561 ax_zero_ext (expr
, nbits
);
2565 /* A helper function to return the frame's PC. */
2568 get_ax_pc (void *baton
)
2570 struct agent_expr
*expr
= baton
;
2575 /* Compile a DWARF location expression to an agent expression.
2577 EXPR is the agent expression we are building.
2578 LOC is the agent value we modify.
2579 ARCH is the architecture.
2580 ADDR_SIZE is the size of addresses, in bytes.
2581 OP_PTR is the start of the location expression.
2582 OP_END is one past the last byte of the location expression.
2584 This will throw an exception for various kinds of errors -- for
2585 example, if the expression cannot be compiled, or if the expression
2589 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2590 struct gdbarch
*arch
, unsigned int addr_size
,
2591 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
2592 struct dwarf2_per_cu_data
*per_cu
)
2594 struct cleanup
*cleanups
;
2596 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
2597 const gdb_byte
* const base
= op_ptr
;
2598 const gdb_byte
*previous_piece
= op_ptr
;
2599 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2600 ULONGEST bits_collected
= 0;
2601 unsigned int addr_size_bits
= 8 * addr_size
;
2602 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
2604 offsets
= xmalloc ((op_end
- op_ptr
) * sizeof (int));
2605 cleanups
= make_cleanup (xfree
, offsets
);
2607 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
2610 make_cleanup (VEC_cleanup (int), &dw_labels
);
2611 make_cleanup (VEC_cleanup (int), &patches
);
2613 /* By default we are making an address. */
2614 loc
->kind
= axs_lvalue_memory
;
2616 while (op_ptr
< op_end
)
2618 enum dwarf_location_atom op
= *op_ptr
;
2619 uint64_t uoffset
, reg
;
2623 offsets
[op_ptr
- base
] = expr
->len
;
2626 /* Our basic approach to code generation is to map DWARF
2627 operations directly to AX operations. However, there are
2630 First, DWARF works on address-sized units, but AX always uses
2631 LONGEST. For most operations we simply ignore this
2632 difference; instead we generate sign extensions as needed
2633 before division and comparison operations. It would be nice
2634 to omit the sign extensions, but there is no way to determine
2635 the size of the target's LONGEST. (This code uses the size
2636 of the host LONGEST in some cases -- that is a bug but it is
2639 Second, some DWARF operations cannot be translated to AX.
2640 For these we simply fail. See
2641 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2676 ax_const_l (expr
, op
- DW_OP_lit0
);
2680 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
2681 op_ptr
+= addr_size
;
2682 /* Some versions of GCC emit DW_OP_addr before
2683 DW_OP_GNU_push_tls_address. In this case the value is an
2684 index, not an address. We don't support things like
2685 branching between the address and the TLS op. */
2686 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
2687 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
2688 ax_const_l (expr
, uoffset
);
2692 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
2696 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
2700 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
2704 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
2708 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
2712 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
2716 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
2720 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
2724 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
2725 ax_const_l (expr
, uoffset
);
2728 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2729 ax_const_l (expr
, offset
);
2764 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2765 loc
->u
.reg
= translate_register (arch
, op
- DW_OP_reg0
);
2766 loc
->kind
= axs_lvalue_register
;
2770 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2771 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2772 loc
->u
.reg
= translate_register (arch
, reg
);
2773 loc
->kind
= axs_lvalue_register
;
2776 case DW_OP_implicit_value
:
2780 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
2781 if (op_ptr
+ len
> op_end
)
2782 error (_("DW_OP_implicit_value: too few bytes available."));
2783 if (len
> sizeof (ULONGEST
))
2784 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
2787 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
2790 dwarf_expr_require_composition (op_ptr
, op_end
,
2791 "DW_OP_implicit_value");
2793 loc
->kind
= axs_rvalue
;
2797 case DW_OP_stack_value
:
2798 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
2799 loc
->kind
= axs_rvalue
;
2834 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2835 i
= translate_register (arch
, op
- DW_OP_breg0
);
2839 ax_const_l (expr
, offset
);
2840 ax_simple (expr
, aop_add
);
2845 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2846 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2847 i
= translate_register (arch
, reg
);
2851 ax_const_l (expr
, offset
);
2852 ax_simple (expr
, aop_add
);
2858 const gdb_byte
*datastart
;
2861 struct symbol
*framefunc
;
2862 LONGEST base_offset
= 0;
2864 b
= block_for_pc (expr
->scope
);
2867 error (_("No block found for address"));
2869 framefunc
= block_linkage_function (b
);
2872 error (_("No function found for block"));
2874 dwarf_expr_frame_base_1 (framefunc
, expr
->scope
,
2875 &datastart
, &datalen
);
2877 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2878 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
2879 datastart
+ datalen
, per_cu
);
2883 ax_const_l (expr
, offset
);
2884 ax_simple (expr
, aop_add
);
2887 loc
->kind
= axs_lvalue_memory
;
2892 ax_simple (expr
, aop_dup
);
2896 ax_simple (expr
, aop_pop
);
2901 ax_pick (expr
, offset
);
2905 ax_simple (expr
, aop_swap
);
2913 ax_simple (expr
, aop_rot
);
2917 case DW_OP_deref_size
:
2921 if (op
== DW_OP_deref_size
)
2929 ax_simple (expr
, aop_ref8
);
2932 ax_simple (expr
, aop_ref16
);
2935 ax_simple (expr
, aop_ref32
);
2938 ax_simple (expr
, aop_ref64
);
2941 /* Note that get_DW_OP_name will never return
2943 error (_("Unsupported size %d in %s"),
2944 size
, get_DW_OP_name (op
));
2950 /* Sign extend the operand. */
2951 ax_ext (expr
, addr_size_bits
);
2952 ax_simple (expr
, aop_dup
);
2953 ax_const_l (expr
, 0);
2954 ax_simple (expr
, aop_less_signed
);
2955 ax_simple (expr
, aop_log_not
);
2956 i
= ax_goto (expr
, aop_if_goto
);
2957 /* We have to emit 0 - X. */
2958 ax_const_l (expr
, 0);
2959 ax_simple (expr
, aop_swap
);
2960 ax_simple (expr
, aop_sub
);
2961 ax_label (expr
, i
, expr
->len
);
2965 /* No need to sign extend here. */
2966 ax_const_l (expr
, 0);
2967 ax_simple (expr
, aop_swap
);
2968 ax_simple (expr
, aop_sub
);
2972 /* Sign extend the operand. */
2973 ax_ext (expr
, addr_size_bits
);
2974 ax_simple (expr
, aop_bit_not
);
2977 case DW_OP_plus_uconst
:
2978 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2979 /* It would be really weird to emit `DW_OP_plus_uconst 0',
2980 but we micro-optimize anyhow. */
2983 ax_const_l (expr
, reg
);
2984 ax_simple (expr
, aop_add
);
2989 ax_simple (expr
, aop_bit_and
);
2993 /* Sign extend the operands. */
2994 ax_ext (expr
, addr_size_bits
);
2995 ax_simple (expr
, aop_swap
);
2996 ax_ext (expr
, addr_size_bits
);
2997 ax_simple (expr
, aop_swap
);
2998 ax_simple (expr
, aop_div_signed
);
3002 ax_simple (expr
, aop_sub
);
3006 ax_simple (expr
, aop_rem_unsigned
);
3010 ax_simple (expr
, aop_mul
);
3014 ax_simple (expr
, aop_bit_or
);
3018 ax_simple (expr
, aop_add
);
3022 ax_simple (expr
, aop_lsh
);
3026 ax_simple (expr
, aop_rsh_unsigned
);
3030 ax_simple (expr
, aop_rsh_signed
);
3034 ax_simple (expr
, aop_bit_xor
);
3038 /* Sign extend the operands. */
3039 ax_ext (expr
, addr_size_bits
);
3040 ax_simple (expr
, aop_swap
);
3041 ax_ext (expr
, addr_size_bits
);
3042 /* Note no swap here: A <= B is !(B < A). */
3043 ax_simple (expr
, aop_less_signed
);
3044 ax_simple (expr
, aop_log_not
);
3048 /* Sign extend the operands. */
3049 ax_ext (expr
, addr_size_bits
);
3050 ax_simple (expr
, aop_swap
);
3051 ax_ext (expr
, addr_size_bits
);
3052 ax_simple (expr
, aop_swap
);
3053 /* A >= B is !(A < B). */
3054 ax_simple (expr
, aop_less_signed
);
3055 ax_simple (expr
, aop_log_not
);
3059 /* Sign extend the operands. */
3060 ax_ext (expr
, addr_size_bits
);
3061 ax_simple (expr
, aop_swap
);
3062 ax_ext (expr
, addr_size_bits
);
3063 /* No need for a second swap here. */
3064 ax_simple (expr
, aop_equal
);
3068 /* Sign extend the operands. */
3069 ax_ext (expr
, addr_size_bits
);
3070 ax_simple (expr
, aop_swap
);
3071 ax_ext (expr
, addr_size_bits
);
3072 ax_simple (expr
, aop_swap
);
3073 ax_simple (expr
, aop_less_signed
);
3077 /* Sign extend the operands. */
3078 ax_ext (expr
, addr_size_bits
);
3079 ax_simple (expr
, aop_swap
);
3080 ax_ext (expr
, addr_size_bits
);
3081 /* Note no swap here: A > B is B < A. */
3082 ax_simple (expr
, aop_less_signed
);
3086 /* Sign extend the operands. */
3087 ax_ext (expr
, addr_size_bits
);
3088 ax_simple (expr
, aop_swap
);
3089 ax_ext (expr
, addr_size_bits
);
3090 /* No need for a swap here. */
3091 ax_simple (expr
, aop_equal
);
3092 ax_simple (expr
, aop_log_not
);
3095 case DW_OP_call_frame_cfa
:
3096 dwarf2_compile_cfa_to_ax (expr
, loc
, arch
, expr
->scope
, per_cu
);
3097 loc
->kind
= axs_lvalue_memory
;
3100 case DW_OP_GNU_push_tls_address
:
3105 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3107 i
= ax_goto (expr
, aop_goto
);
3108 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3109 VEC_safe_push (int, patches
, i
);
3113 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3115 /* Zero extend the operand. */
3116 ax_zero_ext (expr
, addr_size_bits
);
3117 i
= ax_goto (expr
, aop_if_goto
);
3118 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3119 VEC_safe_push (int, patches
, i
);
3126 case DW_OP_bit_piece
:
3128 uint64_t size
, offset
;
3130 if (op_ptr
- 1 == previous_piece
)
3131 error (_("Cannot translate empty pieces to agent expressions"));
3132 previous_piece
= op_ptr
- 1;
3134 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3135 if (op
== DW_OP_piece
)
3141 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
3143 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3144 error (_("Expression pieces exceed word size"));
3146 /* Access the bits. */
3149 case axs_lvalue_register
:
3150 ax_reg (expr
, loc
->u
.reg
);
3153 case axs_lvalue_memory
:
3154 /* Offset the pointer, if needed. */
3157 ax_const_l (expr
, offset
/ 8);
3158 ax_simple (expr
, aop_add
);
3161 access_memory (arch
, expr
, size
);
3165 /* For a bits-big-endian target, shift up what we already
3166 have. For a bits-little-endian target, shift up the
3167 new data. Note that there is a potential bug here if
3168 the DWARF expression leaves multiple values on the
3170 if (bits_collected
> 0)
3172 if (bits_big_endian
)
3174 ax_simple (expr
, aop_swap
);
3175 ax_const_l (expr
, size
);
3176 ax_simple (expr
, aop_lsh
);
3177 /* We don't need a second swap here, because
3178 aop_bit_or is symmetric. */
3182 ax_const_l (expr
, size
);
3183 ax_simple (expr
, aop_lsh
);
3185 ax_simple (expr
, aop_bit_or
);
3188 bits_collected
+= size
;
3189 loc
->kind
= axs_rvalue
;
3193 case DW_OP_GNU_uninit
:
3199 struct dwarf2_locexpr_baton block
;
3200 int size
= (op
== DW_OP_call2
? 2 : 4);
3203 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3206 offset
.cu_off
= uoffset
;
3207 block
= dwarf2_fetch_die_location_block (offset
, per_cu
,
3210 /* DW_OP_call_ref is currently not supported. */
3211 gdb_assert (block
.per_cu
== per_cu
);
3213 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3214 block
.data
, block
.data
+ block
.size
,
3219 case DW_OP_call_ref
:
3227 /* Patch all the branches we emitted. */
3228 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
3230 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
3232 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3233 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
3236 do_cleanups (cleanups
);
3240 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3241 evaluator to calculate the location. */
3242 static struct value
*
3243 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3245 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3248 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3249 dlbaton
->size
, dlbaton
->per_cu
);
3254 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3255 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3258 static struct value
*
3259 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3261 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3263 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3267 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3269 locexpr_read_needs_frame (struct symbol
*symbol
)
3271 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3273 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
3277 /* Return true if DATA points to the end of a piece. END is one past
3278 the last byte in the expression. */
3281 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3283 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3286 /* Helper for locexpr_describe_location_piece that finds the name of a
3290 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3294 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
3295 return gdbarch_register_name (gdbarch
, regnum
);
3298 /* Nicely describe a single piece of a location, returning an updated
3299 position in the bytecode sequence. This function cannot recognize
3300 all locations; if a location is not recognized, it simply returns
3301 DATA. If there is an error during reading, e.g. we run off the end
3302 of the buffer, an error is thrown. */
3304 static const gdb_byte
*
3305 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3306 CORE_ADDR addr
, struct objfile
*objfile
,
3307 struct dwarf2_per_cu_data
*per_cu
,
3308 const gdb_byte
*data
, const gdb_byte
*end
,
3309 unsigned int addr_size
)
3311 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3314 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3316 fprintf_filtered (stream
, _("a variable in $%s"),
3317 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3320 else if (data
[0] == DW_OP_regx
)
3324 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3325 fprintf_filtered (stream
, _("a variable in $%s"),
3326 locexpr_regname (gdbarch
, reg
));
3328 else if (data
[0] == DW_OP_fbreg
)
3331 struct symbol
*framefunc
;
3333 int64_t frame_offset
;
3334 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3336 int64_t base_offset
= 0;
3338 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3339 if (!piece_end_p (new_data
, end
))
3343 b
= block_for_pc (addr
);
3346 error (_("No block found for address for symbol \"%s\"."),
3347 SYMBOL_PRINT_NAME (symbol
));
3349 framefunc
= block_linkage_function (b
);
3352 error (_("No function found for block for symbol \"%s\"."),
3353 SYMBOL_PRINT_NAME (symbol
));
3355 dwarf_expr_frame_base_1 (framefunc
, addr
, &base_data
, &base_size
);
3357 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3359 const gdb_byte
*buf_end
;
3361 frame_reg
= base_data
[0] - DW_OP_breg0
;
3362 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3364 if (buf_end
!= base_data
+ base_size
)
3365 error (_("Unexpected opcode after "
3366 "DW_OP_breg%u for symbol \"%s\"."),
3367 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3369 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3371 /* The frame base is just the register, with no offset. */
3372 frame_reg
= base_data
[0] - DW_OP_reg0
;
3377 /* We don't know what to do with the frame base expression,
3378 so we can't trace this variable; give up. */
3382 fprintf_filtered (stream
,
3383 _("a variable at frame base reg $%s offset %s+%s"),
3384 locexpr_regname (gdbarch
, frame_reg
),
3385 plongest (base_offset
), plongest (frame_offset
));
3387 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3388 && piece_end_p (data
, end
))
3392 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3394 fprintf_filtered (stream
,
3395 _("a variable at offset %s from base reg $%s"),
3397 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3400 /* The location expression for a TLS variable looks like this (on a
3403 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3404 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3406 0x3 is the encoding for DW_OP_addr, which has an operand as long
3407 as the size of an address on the target machine (here is 8
3408 bytes). Note that more recent version of GCC emit DW_OP_const4u
3409 or DW_OP_const8u, depending on address size, rather than
3410 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3411 The operand represents the offset at which the variable is within
3412 the thread local storage. */
3414 else if (data
+ 1 + addr_size
< end
3415 && (data
[0] == DW_OP_addr
3416 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3417 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3418 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3419 && piece_end_p (data
+ 2 + addr_size
, end
))
3422 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3423 gdbarch_byte_order (gdbarch
));
3425 fprintf_filtered (stream
,
3426 _("a thread-local variable at offset 0x%s "
3427 "in the thread-local storage for `%s'"),
3428 phex_nz (offset
, addr_size
), objfile
->name
);
3430 data
+= 1 + addr_size
+ 1;
3433 /* With -gsplit-dwarf a TLS variable can also look like this:
3434 DW_AT_location : 3 byte block: fc 4 e0
3435 (DW_OP_GNU_const_index: 4;
3436 DW_OP_GNU_push_tls_address) */
3437 else if (data
+ 3 <= end
3438 && data
+ 1 + (leb128_size
= skip_leb128 (data
+ 1, end
)) < end
3439 && data
[0] == DW_OP_GNU_const_index
3441 && data
[1 + leb128_size
] == DW_OP_GNU_push_tls_address
3442 && piece_end_p (data
+ 2 + leb128_size
, end
))
3446 data
= safe_read_uleb128 (data
+ 1, end
, &offset
);
3447 offset
= dwarf2_read_addr_index (per_cu
, offset
);
3448 fprintf_filtered (stream
,
3449 _("a thread-local variable at offset 0x%s "
3450 "in the thread-local storage for `%s'"),
3451 phex_nz (offset
, addr_size
), objfile
->name
);
3455 else if (data
[0] >= DW_OP_lit0
3456 && data
[0] <= DW_OP_lit31
3458 && data
[1] == DW_OP_stack_value
)
3460 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3467 /* Disassemble an expression, stopping at the end of a piece or at the
3468 end of the expression. Returns a pointer to the next unread byte
3469 in the input expression. If ALL is nonzero, then this function
3470 will keep going until it reaches the end of the expression.
3471 If there is an error during reading, e.g. we run off the end
3472 of the buffer, an error is thrown. */
3474 static const gdb_byte
*
3475 disassemble_dwarf_expression (struct ui_file
*stream
,
3476 struct gdbarch
*arch
, unsigned int addr_size
,
3477 int offset_size
, const gdb_byte
*start
,
3478 const gdb_byte
*data
, const gdb_byte
*end
,
3479 int indent
, int all
,
3480 struct dwarf2_per_cu_data
*per_cu
)
3484 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3486 enum dwarf_location_atom op
= *data
++;
3491 name
= get_DW_OP_name (op
);
3494 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3495 op
, (long) (data
- 1 - start
));
3496 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3497 (long) (data
- 1 - start
), name
);
3502 ul
= extract_unsigned_integer (data
, addr_size
,
3503 gdbarch_byte_order (arch
));
3505 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3509 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3511 fprintf_filtered (stream
, " %s", pulongest (ul
));
3514 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3516 fprintf_filtered (stream
, " %s", plongest (l
));
3519 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3521 fprintf_filtered (stream
, " %s", pulongest (ul
));
3524 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3526 fprintf_filtered (stream
, " %s", plongest (l
));
3529 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3531 fprintf_filtered (stream
, " %s", pulongest (ul
));
3534 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3536 fprintf_filtered (stream
, " %s", plongest (l
));
3539 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3541 fprintf_filtered (stream
, " %s", pulongest (ul
));
3544 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3546 fprintf_filtered (stream
, " %s", plongest (l
));
3549 data
= safe_read_uleb128 (data
, end
, &ul
);
3550 fprintf_filtered (stream
, " %s", pulongest (ul
));
3553 data
= safe_read_sleb128 (data
, end
, &l
);
3554 fprintf_filtered (stream
, " %s", plongest (l
));
3589 fprintf_filtered (stream
, " [$%s]",
3590 locexpr_regname (arch
, op
- DW_OP_reg0
));
3594 data
= safe_read_uleb128 (data
, end
, &ul
);
3595 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3596 locexpr_regname (arch
, (int) ul
));
3599 case DW_OP_implicit_value
:
3600 data
= safe_read_uleb128 (data
, end
, &ul
);
3602 fprintf_filtered (stream
, " %s", pulongest (ul
));
3637 data
= safe_read_sleb128 (data
, end
, &l
);
3638 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
3639 locexpr_regname (arch
, op
- DW_OP_breg0
));
3643 data
= safe_read_uleb128 (data
, end
, &ul
);
3644 data
= safe_read_sleb128 (data
, end
, &l
);
3645 fprintf_filtered (stream
, " register %s [$%s] offset %s",
3647 locexpr_regname (arch
, (int) ul
),
3652 data
= safe_read_sleb128 (data
, end
, &l
);
3653 fprintf_filtered (stream
, " %s", plongest (l
));
3656 case DW_OP_xderef_size
:
3657 case DW_OP_deref_size
:
3659 fprintf_filtered (stream
, " %d", *data
);
3663 case DW_OP_plus_uconst
:
3664 data
= safe_read_uleb128 (data
, end
, &ul
);
3665 fprintf_filtered (stream
, " %s", pulongest (ul
));
3669 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3671 fprintf_filtered (stream
, " to %ld",
3672 (long) (data
+ l
- start
));
3676 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3678 fprintf_filtered (stream
, " %ld",
3679 (long) (data
+ l
- start
));
3683 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3685 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
3689 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3691 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3694 case DW_OP_call_ref
:
3695 ul
= extract_unsigned_integer (data
, offset_size
,
3696 gdbarch_byte_order (arch
));
3697 data
+= offset_size
;
3698 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
3702 data
= safe_read_uleb128 (data
, end
, &ul
);
3703 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
3706 case DW_OP_bit_piece
:
3710 data
= safe_read_uleb128 (data
, end
, &ul
);
3711 data
= safe_read_uleb128 (data
, end
, &offset
);
3712 fprintf_filtered (stream
, " size %s offset %s (bits)",
3713 pulongest (ul
), pulongest (offset
));
3717 case DW_OP_GNU_implicit_pointer
:
3719 ul
= extract_unsigned_integer (data
, offset_size
,
3720 gdbarch_byte_order (arch
));
3721 data
+= offset_size
;
3723 data
= safe_read_sleb128 (data
, end
, &l
);
3725 fprintf_filtered (stream
, " DIE %s offset %s",
3726 phex_nz (ul
, offset_size
),
3731 case DW_OP_GNU_deref_type
:
3733 int addr_size
= *data
++;
3737 data
= safe_read_uleb128 (data
, end
, &ul
);
3739 type
= dwarf2_get_die_type (offset
, per_cu
);
3740 fprintf_filtered (stream
, "<");
3741 type_print (type
, "", stream
, -1);
3742 fprintf_filtered (stream
, " [0x%s]> %d", phex_nz (offset
.cu_off
, 0),
3747 case DW_OP_GNU_const_type
:
3752 data
= safe_read_uleb128 (data
, end
, &ul
);
3753 type_die
.cu_off
= ul
;
3754 type
= dwarf2_get_die_type (type_die
, per_cu
);
3755 fprintf_filtered (stream
, "<");
3756 type_print (type
, "", stream
, -1);
3757 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3761 case DW_OP_GNU_regval_type
:
3767 data
= safe_read_uleb128 (data
, end
, ®
);
3768 data
= safe_read_uleb128 (data
, end
, &ul
);
3769 type_die
.cu_off
= ul
;
3771 type
= dwarf2_get_die_type (type_die
, per_cu
);
3772 fprintf_filtered (stream
, "<");
3773 type_print (type
, "", stream
, -1);
3774 fprintf_filtered (stream
, " [0x%s]> [$%s]",
3775 phex_nz (type_die
.cu_off
, 0),
3776 locexpr_regname (arch
, reg
));
3780 case DW_OP_GNU_convert
:
3781 case DW_OP_GNU_reinterpret
:
3785 data
= safe_read_uleb128 (data
, end
, &ul
);
3786 type_die
.cu_off
= ul
;
3788 if (type_die
.cu_off
== 0)
3789 fprintf_filtered (stream
, "<0>");
3794 type
= dwarf2_get_die_type (type_die
, per_cu
);
3795 fprintf_filtered (stream
, "<");
3796 type_print (type
, "", stream
, -1);
3797 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3802 case DW_OP_GNU_entry_value
:
3803 data
= safe_read_uleb128 (data
, end
, &ul
);
3804 fputc_filtered ('\n', stream
);
3805 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
3806 start
, data
, data
+ ul
, indent
+ 2,
3811 case DW_OP_GNU_parameter_ref
:
3812 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3814 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3817 case DW_OP_GNU_addr_index
:
3818 data
= safe_read_uleb128 (data
, end
, &ul
);
3819 ul
= dwarf2_read_addr_index (per_cu
, ul
);
3820 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3822 case DW_OP_GNU_const_index
:
3823 data
= safe_read_uleb128 (data
, end
, &ul
);
3824 ul
= dwarf2_read_addr_index (per_cu
, ul
);
3825 fprintf_filtered (stream
, " %s", pulongest (ul
));
3829 fprintf_filtered (stream
, "\n");
3835 /* Describe a single location, which may in turn consist of multiple
3839 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
3840 struct ui_file
*stream
,
3841 const gdb_byte
*data
, size_t size
,
3842 struct objfile
*objfile
, unsigned int addr_size
,
3843 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
3845 const gdb_byte
*end
= data
+ size
;
3846 int first_piece
= 1, bad
= 0;
3850 const gdb_byte
*here
= data
;
3851 int disassemble
= 1;
3856 fprintf_filtered (stream
, _(", and "));
3858 if (!dwarf2_always_disassemble
)
3860 data
= locexpr_describe_location_piece (symbol
, stream
,
3861 addr
, objfile
, per_cu
,
3862 data
, end
, addr_size
);
3863 /* If we printed anything, or if we have an empty piece,
3864 then don't disassemble. */
3866 || data
[0] == DW_OP_piece
3867 || data
[0] == DW_OP_bit_piece
)
3872 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
3873 data
= disassemble_dwarf_expression (stream
,
3874 get_objfile_arch (objfile
),
3875 addr_size
, offset_size
, data
,
3877 dwarf2_always_disassemble
,
3883 int empty
= data
== here
;
3886 fprintf_filtered (stream
, " ");
3887 if (data
[0] == DW_OP_piece
)
3891 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
3894 fprintf_filtered (stream
, _("an empty %s-byte piece"),
3897 fprintf_filtered (stream
, _(" [%s-byte piece]"),
3900 else if (data
[0] == DW_OP_bit_piece
)
3902 uint64_t bits
, offset
;
3904 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
3905 data
= safe_read_uleb128 (data
, end
, &offset
);
3908 fprintf_filtered (stream
,
3909 _("an empty %s-bit piece"),
3912 fprintf_filtered (stream
,
3913 _(" [%s-bit piece, offset %s bits]"),
3914 pulongest (bits
), pulongest (offset
));
3924 if (bad
|| data
> end
)
3925 error (_("Corrupted DWARF2 expression for \"%s\"."),
3926 SYMBOL_PRINT_NAME (symbol
));
3929 /* Print a natural-language description of SYMBOL to STREAM. This
3930 version is for a symbol with a single location. */
3933 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
3934 struct ui_file
*stream
)
3936 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3937 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
3938 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
3939 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
3941 locexpr_describe_location_1 (symbol
, addr
, stream
,
3942 dlbaton
->data
, dlbaton
->size
,
3943 objfile
, addr_size
, offset_size
,
3947 /* Describe the location of SYMBOL as an agent value in VALUE, generating
3948 any necessary bytecode in AX. */
3951 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
3952 struct agent_expr
*ax
, struct axs_value
*value
)
3954 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3955 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
3957 if (dlbaton
->size
== 0)
3958 value
->optimized_out
= 1;
3960 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
3961 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
3965 /* The set of location functions used with the DWARF-2 expression
3967 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
3968 locexpr_read_variable
,
3969 locexpr_read_variable_at_entry
,
3970 locexpr_read_needs_frame
,
3971 locexpr_describe_location
,
3972 locexpr_tracepoint_var_ref
3976 /* Wrapper functions for location lists. These generally find
3977 the appropriate location expression and call something above. */
3979 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3980 evaluator to calculate the location. */
3981 static struct value
*
3982 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3984 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3986 const gdb_byte
*data
;
3988 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
3990 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
3991 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
3997 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
3998 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4001 Function always returns non-NULL value, it may be marked optimized out if
4002 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4003 if it cannot resolve the parameter for any reason. */
4005 static struct value
*
4006 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
4008 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4009 const gdb_byte
*data
;
4013 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
4014 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4016 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
4018 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
4020 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
4023 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
4025 loclist_read_needs_frame (struct symbol
*symbol
)
4027 /* If there's a location list, then assume we need to have a frame
4028 to choose the appropriate location expression. With tracking of
4029 global variables this is not necessarily true, but such tracking
4030 is disabled in GCC at the moment until we figure out how to
4036 /* Print a natural-language description of SYMBOL to STREAM. This
4037 version applies when there is a list of different locations, each
4038 with a specified address range. */
4041 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
4042 struct ui_file
*stream
)
4044 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4045 const gdb_byte
*loc_ptr
, *buf_end
;
4047 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
4048 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
4049 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
4050 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4051 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
4052 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
4053 /* Adjust base_address for relocatable objects. */
4054 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
4055 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
4058 loc_ptr
= dlbaton
->data
;
4059 buf_end
= dlbaton
->data
+ dlbaton
->size
;
4061 fprintf_filtered (stream
, _("multi-location:\n"));
4063 /* Iterate through locations until we run out. */
4066 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
4068 enum debug_loc_kind kind
;
4069 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
4071 if (dlbaton
->from_dwo
)
4072 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4073 loc_ptr
, buf_end
, &new_ptr
,
4074 &low
, &high
, byte_order
);
4076 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4078 byte_order
, addr_size
,
4083 case DEBUG_LOC_END_OF_LIST
:
4086 case DEBUG_LOC_BASE_ADDRESS
:
4087 base_address
= high
+ base_offset
;
4088 fprintf_filtered (stream
, _(" Base address %s"),
4089 paddress (gdbarch
, base_address
));
4091 case DEBUG_LOC_START_END
:
4092 case DEBUG_LOC_START_LENGTH
:
4094 case DEBUG_LOC_BUFFER_OVERFLOW
:
4095 case DEBUG_LOC_INVALID_ENTRY
:
4096 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4097 SYMBOL_PRINT_NAME (symbol
));
4099 gdb_assert_not_reached ("bad debug_loc_kind");
4102 /* Otherwise, a location expression entry. */
4103 low
+= base_address
;
4104 high
+= base_address
;
4106 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4109 /* (It would improve readability to print only the minimum
4110 necessary digits of the second number of the range.) */
4111 fprintf_filtered (stream
, _(" Range %s-%s: "),
4112 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4114 /* Now describe this particular location. */
4115 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4116 objfile
, addr_size
, offset_size
,
4119 fprintf_filtered (stream
, "\n");
4125 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4126 any necessary bytecode in AX. */
4128 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4129 struct agent_expr
*ax
, struct axs_value
*value
)
4131 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4132 const gdb_byte
*data
;
4134 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4136 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4138 value
->optimized_out
= 1;
4140 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
4144 /* The set of location functions used with the DWARF-2 expression
4145 evaluator and location lists. */
4146 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4147 loclist_read_variable
,
4148 loclist_read_variable_at_entry
,
4149 loclist_read_needs_frame
,
4150 loclist_describe_location
,
4151 loclist_tracepoint_var_ref
4154 /* Provide a prototype to silence -Wmissing-prototypes. */
4155 extern initialize_file_ftype _initialize_dwarf2loc
;
4158 _initialize_dwarf2loc (void)
4160 add_setshow_zuinteger_cmd ("entry-values", class_maintenance
,
4161 &entry_values_debug
,
4162 _("Set entry values and tail call frames "
4164 _("Show entry values and tail call frames "
4166 _("When non-zero, the process of determining "
4167 "parameter values from function entry point "
4168 "and tail call frames will be printed."),
4170 show_entry_values_debug
,
4171 &setdebuglist
, &showdebuglist
);