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 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 /* Fetch call_site_parameter from caller matching the parameters. FRAME is for
952 callee. See DWARF_REG and FB_OFFSET description at struct
953 dwarf_expr_context_funcs->push_dwarf_reg_entry_value.
955 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
958 static struct call_site_parameter
*
959 dwarf_expr_reg_to_entry_parameter (struct frame_info
*frame
, int dwarf_reg
,
961 struct dwarf2_per_cu_data
**per_cu_return
)
963 CORE_ADDR func_addr
= get_frame_func (frame
);
965 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
966 struct frame_info
*caller_frame
= get_prev_frame (frame
);
967 struct call_site
*call_site
;
969 /* Initialize it just to avoid a GCC false warning. */
970 struct call_site_parameter
*parameter
= NULL
;
971 CORE_ADDR target_addr
;
973 if (gdbarch
!= frame_unwind_arch (frame
))
975 struct minimal_symbol
*msym
= lookup_minimal_symbol_by_pc (func_addr
);
976 struct gdbarch
*caller_gdbarch
= frame_unwind_arch (frame
);
978 throw_error (NO_ENTRY_VALUE_ERROR
,
979 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
980 "(of %s (%s)) does not match caller gdbarch %s"),
981 gdbarch_bfd_arch_info (gdbarch
)->printable_name
,
982 paddress (gdbarch
, func_addr
),
983 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
),
984 gdbarch_bfd_arch_info (caller_gdbarch
)->printable_name
);
987 if (caller_frame
== NULL
)
989 struct minimal_symbol
*msym
= lookup_minimal_symbol_by_pc (func_addr
);
991 throw_error (NO_ENTRY_VALUE_ERROR
, _("DW_OP_GNU_entry_value resolving "
992 "requires caller of %s (%s)"),
993 paddress (gdbarch
, func_addr
),
994 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
996 caller_pc
= get_frame_pc (caller_frame
);
997 call_site
= call_site_for_pc (gdbarch
, caller_pc
);
999 target_addr
= call_site_to_target_addr (gdbarch
, call_site
, caller_frame
);
1000 if (target_addr
!= func_addr
)
1002 struct minimal_symbol
*target_msym
, *func_msym
;
1004 target_msym
= lookup_minimal_symbol_by_pc (target_addr
);
1005 func_msym
= lookup_minimal_symbol_by_pc (func_addr
);
1006 throw_error (NO_ENTRY_VALUE_ERROR
,
1007 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1008 "but the called frame is for %s at %s"),
1009 (target_msym
== NULL
? "???"
1010 : SYMBOL_PRINT_NAME (target_msym
)),
1011 paddress (gdbarch
, target_addr
),
1012 func_msym
== NULL
? "???" : SYMBOL_PRINT_NAME (func_msym
),
1013 paddress (gdbarch
, func_addr
));
1016 /* No entry value based parameters would be reliable if this function can
1017 call itself via tail calls. */
1018 func_verify_no_selftailcall (gdbarch
, func_addr
);
1020 for (iparams
= 0; iparams
< call_site
->parameter_count
; iparams
++)
1022 parameter
= &call_site
->parameter
[iparams
];
1023 if (parameter
->dwarf_reg
== -1 && dwarf_reg
== -1)
1025 if (parameter
->fb_offset
== fb_offset
)
1028 else if (parameter
->dwarf_reg
== dwarf_reg
)
1031 if (iparams
== call_site
->parameter_count
)
1033 struct minimal_symbol
*msym
= lookup_minimal_symbol_by_pc (caller_pc
);
1035 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1036 determine its value. */
1037 throw_error (NO_ENTRY_VALUE_ERROR
, _("Cannot find matching parameter "
1038 "at DW_TAG_GNU_call_site %s at %s"),
1039 paddress (gdbarch
, caller_pc
),
1040 msym
== NULL
? "???" : SYMBOL_PRINT_NAME (msym
));
1043 *per_cu_return
= call_site
->per_cu
;
1047 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1048 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1049 DW_AT_GNU_call_site_data_value (dereferenced) block.
1051 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1054 Function always returns non-NULL, non-optimized out value. It throws
1055 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1057 static struct value
*
1058 dwarf_entry_parameter_to_value (struct call_site_parameter
*parameter
,
1059 CORE_ADDR deref_size
, struct type
*type
,
1060 struct frame_info
*caller_frame
,
1061 struct dwarf2_per_cu_data
*per_cu
)
1063 const gdb_byte
*data_src
;
1067 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1068 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1070 /* DEREF_SIZE size is not verified here. */
1071 if (data_src
== NULL
)
1072 throw_error (NO_ENTRY_VALUE_ERROR
,
1073 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1075 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1076 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1078 data
= alloca (size
+ 1);
1079 memcpy (data
, data_src
, size
);
1080 data
[size
] = DW_OP_stack_value
;
1082 return dwarf2_evaluate_loc_desc (type
, caller_frame
, data
, size
+ 1, per_cu
);
1085 /* Execute call_site_parameter's DWARF block matching DEREF_SIZE for caller of
1086 the CTX's frame. CTX must be of dwarf_expr_ctx_funcs kind. See DWARF_REG
1087 and FB_OFFSET description at struct
1088 dwarf_expr_context_funcs->push_dwarf_reg_entry_value.
1090 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1091 can be more simple as it does not support cross-CU DWARF executions. */
1094 dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
1095 int dwarf_reg
, CORE_ADDR fb_offset
,
1098 struct dwarf_expr_baton
*debaton
;
1099 struct frame_info
*frame
, *caller_frame
;
1100 struct dwarf2_per_cu_data
*caller_per_cu
;
1101 struct dwarf_expr_baton baton_local
;
1102 struct dwarf_expr_context saved_ctx
;
1103 struct call_site_parameter
*parameter
;
1104 const gdb_byte
*data_src
;
1107 gdb_assert (ctx
->funcs
== &dwarf_expr_ctx_funcs
);
1108 debaton
= ctx
->baton
;
1109 frame
= debaton
->frame
;
1110 caller_frame
= get_prev_frame (frame
);
1112 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, dwarf_reg
, fb_offset
,
1114 data_src
= deref_size
== -1 ? parameter
->value
: parameter
->data_value
;
1115 size
= deref_size
== -1 ? parameter
->value_size
: parameter
->data_value_size
;
1117 /* DEREF_SIZE size is not verified here. */
1118 if (data_src
== NULL
)
1119 throw_error (NO_ENTRY_VALUE_ERROR
,
1120 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1122 baton_local
.frame
= caller_frame
;
1123 baton_local
.per_cu
= caller_per_cu
;
1125 saved_ctx
.gdbarch
= ctx
->gdbarch
;
1126 saved_ctx
.addr_size
= ctx
->addr_size
;
1127 saved_ctx
.offset
= ctx
->offset
;
1128 saved_ctx
.baton
= ctx
->baton
;
1129 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (baton_local
.per_cu
));
1130 ctx
->addr_size
= dwarf2_per_cu_addr_size (baton_local
.per_cu
);
1131 ctx
->offset
= dwarf2_per_cu_text_offset (baton_local
.per_cu
);
1132 ctx
->baton
= &baton_local
;
1134 dwarf_expr_eval (ctx
, data_src
, size
);
1136 ctx
->gdbarch
= saved_ctx
.gdbarch
;
1137 ctx
->addr_size
= saved_ctx
.addr_size
;
1138 ctx
->offset
= saved_ctx
.offset
;
1139 ctx
->baton
= saved_ctx
.baton
;
1142 /* Callback function for dwarf2_evaluate_loc_desc.
1143 Fetch the address indexed by DW_OP_GNU_addr_index. */
1146 dwarf_expr_get_addr_index (void *baton
, unsigned int index
)
1148 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
1150 return dwarf2_read_addr_index (debaton
->per_cu
, index
);
1153 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1154 the indirect method on it, that is use its stored target value, the sole
1155 purpose of entry_data_value_funcs.. */
1157 static struct value
*
1158 entry_data_value_coerce_ref (const struct value
*value
)
1160 struct type
*checked_type
= check_typedef (value_type (value
));
1161 struct value
*target_val
;
1163 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
)
1166 target_val
= value_computed_closure (value
);
1167 value_incref (target_val
);
1171 /* Implement copy_closure. */
1174 entry_data_value_copy_closure (const struct value
*v
)
1176 struct value
*target_val
= value_computed_closure (v
);
1178 value_incref (target_val
);
1182 /* Implement free_closure. */
1185 entry_data_value_free_closure (struct value
*v
)
1187 struct value
*target_val
= value_computed_closure (v
);
1189 value_free (target_val
);
1192 /* Vector for methods for an entry value reference where the referenced value
1193 is stored in the caller. On the first dereference use
1194 DW_AT_GNU_call_site_data_value in the caller. */
1196 static const struct lval_funcs entry_data_value_funcs
=
1200 NULL
, /* check_validity */
1201 NULL
, /* check_any_valid */
1202 NULL
, /* indirect */
1203 entry_data_value_coerce_ref
,
1204 NULL
, /* check_synthetic_pointer */
1205 entry_data_value_copy_closure
,
1206 entry_data_value_free_closure
1209 /* Read parameter of TYPE at (callee) FRAME's function entry. DWARF_REG and
1210 FB_OFFSET are used to match DW_AT_location at the caller's
1211 DW_TAG_GNU_call_site_parameter. See DWARF_REG and FB_OFFSET description at
1212 struct dwarf_expr_context_funcs->push_dwarf_reg_entry_value.
1214 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1215 cannot resolve the parameter for any reason. */
1217 static struct value
*
1218 value_of_dwarf_reg_entry (struct type
*type
, struct frame_info
*frame
,
1219 int dwarf_reg
, CORE_ADDR fb_offset
)
1221 struct type
*checked_type
= check_typedef (type
);
1222 struct type
*target_type
= TYPE_TARGET_TYPE (checked_type
);
1223 struct frame_info
*caller_frame
= get_prev_frame (frame
);
1224 struct value
*outer_val
, *target_val
, *val
;
1225 struct call_site_parameter
*parameter
;
1226 struct dwarf2_per_cu_data
*caller_per_cu
;
1229 parameter
= dwarf_expr_reg_to_entry_parameter (frame
, dwarf_reg
, fb_offset
,
1232 outer_val
= dwarf_entry_parameter_to_value (parameter
, -1 /* deref_size */,
1236 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1237 used and it is not available do not fall back to OUTER_VAL - dereferencing
1238 TYPE_CODE_REF with non-entry data value would give current value - not the
1241 if (TYPE_CODE (checked_type
) != TYPE_CODE_REF
1242 || TYPE_TARGET_TYPE (checked_type
) == NULL
)
1245 target_val
= dwarf_entry_parameter_to_value (parameter
,
1246 TYPE_LENGTH (target_type
),
1247 target_type
, caller_frame
,
1250 /* value_as_address dereferences TYPE_CODE_REF. */
1251 addr
= extract_typed_address (value_contents (outer_val
), checked_type
);
1253 /* The target entry value has artificial address of the entry value
1255 VALUE_LVAL (target_val
) = lval_memory
;
1256 set_value_address (target_val
, addr
);
1258 release_value (target_val
);
1259 val
= allocate_computed_value (type
, &entry_data_value_funcs
,
1260 target_val
/* closure */);
1262 /* Copy the referencing pointer to the new computed value. */
1263 memcpy (value_contents_raw (val
), value_contents_raw (outer_val
),
1264 TYPE_LENGTH (checked_type
));
1265 set_value_lazy (val
, 0);
1270 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1271 SIZE are DWARF block used to match DW_AT_location at the caller's
1272 DW_TAG_GNU_call_site_parameter.
1274 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1275 cannot resolve the parameter for any reason. */
1277 static struct value
*
1278 value_of_dwarf_block_entry (struct type
*type
, struct frame_info
*frame
,
1279 const gdb_byte
*block
, size_t block_len
)
1282 CORE_ADDR fb_offset
;
1284 dwarf_reg
= dwarf_block_to_dwarf_reg (block
, block
+ block_len
);
1285 if (dwarf_reg
!= -1)
1286 return value_of_dwarf_reg_entry (type
, frame
, dwarf_reg
, 0 /* unused */);
1288 if (dwarf_block_to_fb_offset (block
, block
+ block_len
, &fb_offset
))
1289 return value_of_dwarf_reg_entry (type
, frame
, -1, fb_offset
);
1291 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1292 suppressed during normal operation. The expression can be arbitrary if
1293 there is no caller-callee entry value binding expected. */
1294 throw_error (NO_ENTRY_VALUE_ERROR
,
1295 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1296 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1299 struct piece_closure
1301 /* Reference count. */
1304 /* The CU from which this closure's expression came. */
1305 struct dwarf2_per_cu_data
*per_cu
;
1307 /* The number of pieces used to describe this variable. */
1310 /* The target address size, used only for DWARF_VALUE_STACK. */
1313 /* The pieces themselves. */
1314 struct dwarf_expr_piece
*pieces
;
1317 /* Allocate a closure for a value formed from separately-described
1320 static struct piece_closure
*
1321 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
1322 int n_pieces
, struct dwarf_expr_piece
*pieces
,
1325 struct piece_closure
*c
= XZALLOC (struct piece_closure
);
1330 c
->n_pieces
= n_pieces
;
1331 c
->addr_size
= addr_size
;
1332 c
->pieces
= XCALLOC (n_pieces
, struct dwarf_expr_piece
);
1334 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
1335 for (i
= 0; i
< n_pieces
; ++i
)
1336 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1337 value_incref (c
->pieces
[i
].v
.value
);
1342 /* The lowest-level function to extract bits from a byte buffer.
1343 SOURCE is the buffer. It is updated if we read to the end of a
1345 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1346 updated to reflect the number of bits actually read.
1347 NBITS is the number of bits we want to read. It is updated to
1348 reflect the number of bits actually read. This function may read
1350 BITS_BIG_ENDIAN is taken directly from gdbarch.
1351 This function returns the extracted bits. */
1354 extract_bits_primitive (const gdb_byte
**source
,
1355 unsigned int *source_offset_bits
,
1356 int *nbits
, int bits_big_endian
)
1358 unsigned int avail
, mask
, datum
;
1360 gdb_assert (*source_offset_bits
< 8);
1362 avail
= 8 - *source_offset_bits
;
1366 mask
= (1 << avail
) - 1;
1368 if (bits_big_endian
)
1369 datum
>>= 8 - (*source_offset_bits
+ *nbits
);
1371 datum
>>= *source_offset_bits
;
1375 *source_offset_bits
+= avail
;
1376 if (*source_offset_bits
>= 8)
1378 *source_offset_bits
-= 8;
1385 /* Extract some bits from a source buffer and move forward in the
1388 SOURCE is the source buffer. It is updated as bytes are read.
1389 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1391 NBITS is the number of bits to read.
1392 BITS_BIG_ENDIAN is taken directly from gdbarch.
1394 This function returns the bits that were read. */
1397 extract_bits (const gdb_byte
**source
, unsigned int *source_offset_bits
,
1398 int nbits
, int bits_big_endian
)
1402 gdb_assert (nbits
> 0 && nbits
<= 8);
1404 datum
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1410 more
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
1412 if (bits_big_endian
)
1422 /* Write some bits into a buffer and move forward in the buffer.
1424 DATUM is the bits to write. The low-order bits of DATUM are used.
1425 DEST is the destination buffer. It is updated as bytes are
1427 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1429 NBITS is the number of valid bits in DATUM.
1430 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1433 insert_bits (unsigned int datum
,
1434 gdb_byte
*dest
, unsigned int dest_offset_bits
,
1435 int nbits
, int bits_big_endian
)
1439 gdb_assert (dest_offset_bits
+ nbits
<= 8);
1441 mask
= (1 << nbits
) - 1;
1442 if (bits_big_endian
)
1444 datum
<<= 8 - (dest_offset_bits
+ nbits
);
1445 mask
<<= 8 - (dest_offset_bits
+ nbits
);
1449 datum
<<= dest_offset_bits
;
1450 mask
<<= dest_offset_bits
;
1453 gdb_assert ((datum
& ~mask
) == 0);
1455 *dest
= (*dest
& ~mask
) | datum
;
1458 /* Copy bits from a source to a destination.
1460 DEST is where the bits should be written.
1461 DEST_OFFSET_BITS is the bit offset into DEST.
1462 SOURCE is the source of bits.
1463 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1464 BIT_COUNT is the number of bits to copy.
1465 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1468 copy_bitwise (gdb_byte
*dest
, unsigned int dest_offset_bits
,
1469 const gdb_byte
*source
, unsigned int source_offset_bits
,
1470 unsigned int bit_count
,
1471 int bits_big_endian
)
1473 unsigned int dest_avail
;
1476 /* Reduce everything to byte-size pieces. */
1477 dest
+= dest_offset_bits
/ 8;
1478 dest_offset_bits
%= 8;
1479 source
+= source_offset_bits
/ 8;
1480 source_offset_bits
%= 8;
1482 dest_avail
= 8 - dest_offset_bits
% 8;
1484 /* See if we can fill the first destination byte. */
1485 if (dest_avail
< bit_count
)
1487 datum
= extract_bits (&source
, &source_offset_bits
, dest_avail
,
1489 insert_bits (datum
, dest
, dest_offset_bits
, dest_avail
, bits_big_endian
);
1491 dest_offset_bits
= 0;
1492 bit_count
-= dest_avail
;
1495 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1496 than 8 bits remaining. */
1497 gdb_assert (dest_offset_bits
% 8 == 0 || bit_count
< 8);
1498 for (; bit_count
>= 8; bit_count
-= 8)
1500 datum
= extract_bits (&source
, &source_offset_bits
, 8, bits_big_endian
);
1501 *dest
++ = (gdb_byte
) datum
;
1504 /* Finally, we may have a few leftover bits. */
1505 gdb_assert (bit_count
<= 8 - dest_offset_bits
% 8);
1508 datum
= extract_bits (&source
, &source_offset_bits
, bit_count
,
1510 insert_bits (datum
, dest
, dest_offset_bits
, bit_count
, bits_big_endian
);
1515 read_pieced_value (struct value
*v
)
1519 ULONGEST bits_to_skip
;
1521 struct piece_closure
*c
1522 = (struct piece_closure
*) value_computed_closure (v
);
1523 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (v
));
1525 size_t buffer_size
= 0;
1526 char *buffer
= NULL
;
1527 struct cleanup
*cleanup
;
1529 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
1531 if (value_type (v
) != value_enclosing_type (v
))
1532 internal_error (__FILE__
, __LINE__
,
1533 _("Should not be able to create a lazy value with "
1534 "an enclosing type"));
1536 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1538 contents
= value_contents_raw (v
);
1539 bits_to_skip
= 8 * value_offset (v
);
1540 if (value_bitsize (v
))
1542 bits_to_skip
+= value_bitpos (v
);
1543 type_len
= value_bitsize (v
);
1546 type_len
= 8 * TYPE_LENGTH (value_type (v
));
1548 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1550 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1551 size_t this_size
, this_size_bits
;
1552 long dest_offset_bits
, source_offset_bits
, source_offset
;
1553 const gdb_byte
*intermediate_buffer
;
1555 /* Compute size, source, and destination offsets for copying, in
1557 this_size_bits
= p
->size
;
1558 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1560 bits_to_skip
-= this_size_bits
;
1563 if (this_size_bits
> type_len
- offset
)
1564 this_size_bits
= type_len
- offset
;
1565 if (bits_to_skip
> 0)
1567 dest_offset_bits
= 0;
1568 source_offset_bits
= bits_to_skip
;
1569 this_size_bits
-= bits_to_skip
;
1574 dest_offset_bits
= offset
;
1575 source_offset_bits
= 0;
1578 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1579 source_offset
= source_offset_bits
/ 8;
1580 if (buffer_size
< this_size
)
1582 buffer_size
= this_size
;
1583 buffer
= xrealloc (buffer
, buffer_size
);
1585 intermediate_buffer
= buffer
;
1587 /* Copy from the source to DEST_BUFFER. */
1588 switch (p
->location
)
1590 case DWARF_VALUE_REGISTER
:
1592 struct gdbarch
*arch
= get_frame_arch (frame
);
1593 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1594 int reg_offset
= source_offset
;
1596 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1597 && this_size
< register_size (arch
, gdb_regnum
))
1599 /* Big-endian, and we want less than full size. */
1600 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1601 /* We want the lower-order THIS_SIZE_BITS of the bytes
1602 we extract from the register. */
1603 source_offset_bits
+= 8 * this_size
- this_size_bits
;
1606 if (gdb_regnum
!= -1)
1610 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1614 /* Just so garbage doesn't ever shine through. */
1615 memset (buffer
, 0, this_size
);
1618 set_value_optimized_out (v
, 1);
1620 mark_value_bytes_unavailable (v
, offset
, this_size
);
1625 error (_("Unable to access DWARF register number %s"),
1626 paddress (arch
, p
->v
.regno
));
1631 case DWARF_VALUE_MEMORY
:
1632 read_value_memory (v
, offset
,
1633 p
->v
.mem
.in_stack_memory
,
1634 p
->v
.mem
.addr
+ source_offset
,
1638 case DWARF_VALUE_STACK
:
1640 size_t n
= this_size
;
1642 if (n
> c
->addr_size
- source_offset
)
1643 n
= (c
->addr_size
>= source_offset
1644 ? c
->addr_size
- source_offset
1652 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
1654 intermediate_buffer
= val_bytes
+ source_offset
;
1659 case DWARF_VALUE_LITERAL
:
1661 size_t n
= this_size
;
1663 if (n
> p
->v
.literal
.length
- source_offset
)
1664 n
= (p
->v
.literal
.length
>= source_offset
1665 ? p
->v
.literal
.length
- source_offset
1668 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
1672 /* These bits show up as zeros -- but do not cause the value
1673 to be considered optimized-out. */
1674 case DWARF_VALUE_IMPLICIT_POINTER
:
1677 case DWARF_VALUE_OPTIMIZED_OUT
:
1678 set_value_optimized_out (v
, 1);
1682 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1685 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
1686 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1687 copy_bitwise (contents
, dest_offset_bits
,
1688 intermediate_buffer
, source_offset_bits
% 8,
1689 this_size_bits
, bits_big_endian
);
1691 offset
+= this_size_bits
;
1694 do_cleanups (cleanup
);
1698 write_pieced_value (struct value
*to
, struct value
*from
)
1702 ULONGEST bits_to_skip
;
1703 const gdb_byte
*contents
;
1704 struct piece_closure
*c
1705 = (struct piece_closure
*) value_computed_closure (to
);
1706 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
1708 size_t buffer_size
= 0;
1709 char *buffer
= NULL
;
1710 struct cleanup
*cleanup
;
1712 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
1716 set_value_optimized_out (to
, 1);
1720 cleanup
= make_cleanup (free_current_contents
, &buffer
);
1722 contents
= value_contents (from
);
1723 bits_to_skip
= 8 * value_offset (to
);
1724 if (value_bitsize (to
))
1726 bits_to_skip
+= value_bitpos (to
);
1727 type_len
= value_bitsize (to
);
1730 type_len
= 8 * TYPE_LENGTH (value_type (to
));
1732 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
1734 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1735 size_t this_size_bits
, this_size
;
1736 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
1738 const gdb_byte
*source_buffer
;
1740 this_size_bits
= p
->size
;
1741 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
1743 bits_to_skip
-= this_size_bits
;
1746 if (this_size_bits
> type_len
- offset
)
1747 this_size_bits
= type_len
- offset
;
1748 if (bits_to_skip
> 0)
1750 dest_offset_bits
= bits_to_skip
;
1751 source_offset_bits
= 0;
1752 this_size_bits
-= bits_to_skip
;
1757 dest_offset_bits
= 0;
1758 source_offset_bits
= offset
;
1761 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
1762 source_offset
= source_offset_bits
/ 8;
1763 dest_offset
= dest_offset_bits
/ 8;
1764 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
1766 source_buffer
= contents
+ source_offset
;
1771 if (buffer_size
< this_size
)
1773 buffer_size
= this_size
;
1774 buffer
= xrealloc (buffer
, buffer_size
);
1776 source_buffer
= buffer
;
1780 switch (p
->location
)
1782 case DWARF_VALUE_REGISTER
:
1784 struct gdbarch
*arch
= get_frame_arch (frame
);
1785 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
1786 int reg_offset
= dest_offset
;
1788 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
1789 && this_size
<= register_size (arch
, gdb_regnum
))
1790 /* Big-endian, and we want less than full size. */
1791 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
1793 if (gdb_regnum
!= -1)
1799 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1804 error (_("Can't do read-modify-write to "
1805 "update bitfield; containing word has been "
1808 throw_error (NOT_AVAILABLE_ERROR
,
1809 _("Can't do read-modify-write to update "
1810 "bitfield; containing word "
1813 copy_bitwise (buffer
, dest_offset_bits
,
1814 contents
, source_offset_bits
,
1819 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
1820 this_size
, source_buffer
);
1824 error (_("Unable to write to DWARF register number %s"),
1825 paddress (arch
, p
->v
.regno
));
1829 case DWARF_VALUE_MEMORY
:
1832 /* Only the first and last bytes can possibly have any
1834 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
, 1);
1835 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
1836 buffer
+ this_size
- 1, 1);
1837 copy_bitwise (buffer
, dest_offset_bits
,
1838 contents
, source_offset_bits
,
1843 write_memory (p
->v
.mem
.addr
+ dest_offset
,
1844 source_buffer
, this_size
);
1847 set_value_optimized_out (to
, 1);
1850 offset
+= this_size_bits
;
1853 do_cleanups (cleanup
);
1856 /* A helper function that checks bit validity in a pieced value.
1857 CHECK_FOR indicates the kind of validity checking.
1858 DWARF_VALUE_MEMORY means to check whether any bit is valid.
1859 DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
1861 DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
1862 implicit pointer. */
1865 check_pieced_value_bits (const struct value
*value
, int bit_offset
,
1867 enum dwarf_value_location check_for
)
1869 struct piece_closure
*c
1870 = (struct piece_closure
*) value_computed_closure (value
);
1872 int validity
= (check_for
== DWARF_VALUE_MEMORY
1873 || check_for
== DWARF_VALUE_IMPLICIT_POINTER
);
1875 bit_offset
+= 8 * value_offset (value
);
1876 if (value_bitsize (value
))
1877 bit_offset
+= value_bitpos (value
);
1879 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
1881 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1882 size_t this_size_bits
= p
->size
;
1886 if (bit_offset
>= this_size_bits
)
1888 bit_offset
-= this_size_bits
;
1892 bit_length
-= this_size_bits
- bit_offset
;
1896 bit_length
-= this_size_bits
;
1898 if (check_for
== DWARF_VALUE_IMPLICIT_POINTER
)
1900 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1903 else if (p
->location
== DWARF_VALUE_OPTIMIZED_OUT
1904 || p
->location
== DWARF_VALUE_IMPLICIT_POINTER
)
1920 check_pieced_value_validity (const struct value
*value
, int bit_offset
,
1923 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
1924 DWARF_VALUE_MEMORY
);
1928 check_pieced_value_invalid (const struct value
*value
)
1930 return check_pieced_value_bits (value
, 0,
1931 8 * TYPE_LENGTH (value_type (value
)),
1932 DWARF_VALUE_OPTIMIZED_OUT
);
1935 /* An implementation of an lval_funcs method to see whether a value is
1936 a synthetic pointer. */
1939 check_pieced_synthetic_pointer (const struct value
*value
, int bit_offset
,
1942 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
1943 DWARF_VALUE_IMPLICIT_POINTER
);
1946 /* A wrapper function for get_frame_address_in_block. */
1949 get_frame_address_in_block_wrapper (void *baton
)
1951 return get_frame_address_in_block (baton
);
1954 /* An implementation of an lval_funcs method to indirect through a
1955 pointer. This handles the synthetic pointer case when needed. */
1957 static struct value
*
1958 indirect_pieced_value (struct value
*value
)
1960 struct piece_closure
*c
1961 = (struct piece_closure
*) value_computed_closure (value
);
1963 struct frame_info
*frame
;
1964 struct dwarf2_locexpr_baton baton
;
1965 int i
, bit_offset
, bit_length
;
1966 struct dwarf_expr_piece
*piece
= NULL
;
1967 LONGEST byte_offset
;
1969 type
= check_typedef (value_type (value
));
1970 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
1973 bit_length
= 8 * TYPE_LENGTH (type
);
1974 bit_offset
= 8 * value_offset (value
);
1975 if (value_bitsize (value
))
1976 bit_offset
+= value_bitpos (value
);
1978 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
1980 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
1981 size_t this_size_bits
= p
->size
;
1985 if (bit_offset
>= this_size_bits
)
1987 bit_offset
-= this_size_bits
;
1991 bit_length
-= this_size_bits
- bit_offset
;
1995 bit_length
-= this_size_bits
;
1997 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
2000 if (bit_length
!= 0)
2001 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2007 frame
= get_selected_frame (_("No frame selected."));
2009 /* This is an offset requested by GDB, such as value subcripts. */
2010 byte_offset
= value_as_address (value
);
2013 baton
= dwarf2_fetch_die_location_block (piece
->v
.ptr
.die
, c
->per_cu
,
2014 get_frame_address_in_block_wrapper
,
2017 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
2018 baton
.data
, baton
.size
, baton
.per_cu
,
2019 piece
->v
.ptr
.offset
+ byte_offset
);
2023 copy_pieced_value_closure (const struct value
*v
)
2025 struct piece_closure
*c
2026 = (struct piece_closure
*) value_computed_closure (v
);
2033 free_pieced_value_closure (struct value
*v
)
2035 struct piece_closure
*c
2036 = (struct piece_closure
*) value_computed_closure (v
);
2043 for (i
= 0; i
< c
->n_pieces
; ++i
)
2044 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
2045 value_free (c
->pieces
[i
].v
.value
);
2052 /* Functions for accessing a variable described by DW_OP_piece. */
2053 static const struct lval_funcs pieced_value_funcs
= {
2056 check_pieced_value_validity
,
2057 check_pieced_value_invalid
,
2058 indirect_pieced_value
,
2059 NULL
, /* coerce_ref */
2060 check_pieced_synthetic_pointer
,
2061 copy_pieced_value_closure
,
2062 free_pieced_value_closure
2065 /* Helper function which throws an error if a synthetic pointer is
2069 invalid_synthetic_pointer (void)
2071 error (_("access outside bounds of object "
2072 "referenced via synthetic pointer"));
2075 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2077 static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
=
2079 dwarf_expr_read_reg
,
2080 dwarf_expr_read_mem
,
2081 dwarf_expr_frame_base
,
2082 dwarf_expr_frame_cfa
,
2083 dwarf_expr_frame_pc
,
2084 dwarf_expr_tls_address
,
2085 dwarf_expr_dwarf_call
,
2086 dwarf_expr_get_base_type
,
2087 dwarf_expr_push_dwarf_reg_entry_value
,
2088 dwarf_expr_get_addr_index
2091 /* Evaluate a location description, starting at DATA and with length
2092 SIZE, to find the current location of variable of TYPE in the
2093 context of FRAME. BYTE_OFFSET is applied after the contents are
2096 static struct value
*
2097 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
2098 const gdb_byte
*data
, unsigned short size
,
2099 struct dwarf2_per_cu_data
*per_cu
,
2100 LONGEST byte_offset
)
2102 struct value
*retval
;
2103 struct dwarf_expr_baton baton
;
2104 struct dwarf_expr_context
*ctx
;
2105 struct cleanup
*old_chain
, *value_chain
;
2106 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2107 volatile struct gdb_exception ex
;
2109 if (byte_offset
< 0)
2110 invalid_synthetic_pointer ();
2113 return allocate_optimized_out_value (type
);
2115 baton
.frame
= frame
;
2116 baton
.per_cu
= per_cu
;
2118 ctx
= new_dwarf_expr_context ();
2119 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2120 value_chain
= make_cleanup_value_free_to_mark (value_mark ());
2122 ctx
->gdbarch
= get_objfile_arch (objfile
);
2123 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2124 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2125 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2126 ctx
->baton
= &baton
;
2127 ctx
->funcs
= &dwarf_expr_ctx_funcs
;
2129 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2131 dwarf_expr_eval (ctx
, data
, size
);
2135 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2137 do_cleanups (old_chain
);
2138 retval
= allocate_value (type
);
2139 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
2142 else if (ex
.error
== NO_ENTRY_VALUE_ERROR
)
2144 if (entry_values_debug
)
2145 exception_print (gdb_stdout
, ex
);
2146 do_cleanups (old_chain
);
2147 return allocate_optimized_out_value (type
);
2150 throw_exception (ex
);
2153 if (ctx
->num_pieces
> 0)
2155 struct piece_closure
*c
;
2156 struct frame_id frame_id
= get_frame_id (frame
);
2157 ULONGEST bit_size
= 0;
2160 for (i
= 0; i
< ctx
->num_pieces
; ++i
)
2161 bit_size
+= ctx
->pieces
[i
].size
;
2162 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
2163 invalid_synthetic_pointer ();
2165 c
= allocate_piece_closure (per_cu
, ctx
->num_pieces
, ctx
->pieces
,
2167 /* We must clean up the value chain after creating the piece
2168 closure but before allocating the result. */
2169 do_cleanups (value_chain
);
2170 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
2171 VALUE_FRAME_ID (retval
) = frame_id
;
2172 set_value_offset (retval
, byte_offset
);
2176 switch (ctx
->location
)
2178 case DWARF_VALUE_REGISTER
:
2180 struct gdbarch
*arch
= get_frame_arch (frame
);
2181 ULONGEST dwarf_regnum
= value_as_long (dwarf_expr_fetch (ctx
, 0));
2182 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
2184 if (byte_offset
!= 0)
2185 error (_("cannot use offset on synthetic pointer to register"));
2186 do_cleanups (value_chain
);
2187 if (gdb_regnum
!= -1)
2188 retval
= value_from_register (type
, gdb_regnum
, frame
);
2190 error (_("Unable to access DWARF register number %s"),
2191 paddress (arch
, dwarf_regnum
));
2195 case DWARF_VALUE_MEMORY
:
2197 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
2198 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
2200 do_cleanups (value_chain
);
2201 retval
= allocate_value_lazy (type
);
2202 VALUE_LVAL (retval
) = lval_memory
;
2203 if (in_stack_memory
)
2204 set_value_stack (retval
, 1);
2205 set_value_address (retval
, address
+ byte_offset
);
2209 case DWARF_VALUE_STACK
:
2211 struct value
*value
= dwarf_expr_fetch (ctx
, 0);
2213 const gdb_byte
*val_bytes
;
2214 size_t n
= TYPE_LENGTH (value_type (value
));
2216 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2217 invalid_synthetic_pointer ();
2219 val_bytes
= value_contents_all (value
);
2220 val_bytes
+= byte_offset
;
2223 /* Preserve VALUE because we are going to free values back
2224 to the mark, but we still need the value contents
2226 value_incref (value
);
2227 do_cleanups (value_chain
);
2228 make_cleanup_value_free (value
);
2230 retval
= allocate_value (type
);
2231 contents
= value_contents_raw (retval
);
2232 if (n
> TYPE_LENGTH (type
))
2234 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2236 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2237 val_bytes
+= n
- TYPE_LENGTH (type
);
2238 n
= TYPE_LENGTH (type
);
2240 memcpy (contents
, val_bytes
, n
);
2244 case DWARF_VALUE_LITERAL
:
2247 const bfd_byte
*ldata
;
2248 size_t n
= ctx
->len
;
2250 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
2251 invalid_synthetic_pointer ();
2253 do_cleanups (value_chain
);
2254 retval
= allocate_value (type
);
2255 contents
= value_contents_raw (retval
);
2257 ldata
= ctx
->data
+ byte_offset
;
2260 if (n
> TYPE_LENGTH (type
))
2262 struct gdbarch
*objfile_gdbarch
= get_objfile_arch (objfile
);
2264 if (gdbarch_byte_order (objfile_gdbarch
) == BFD_ENDIAN_BIG
)
2265 ldata
+= n
- TYPE_LENGTH (type
);
2266 n
= TYPE_LENGTH (type
);
2268 memcpy (contents
, ldata
, n
);
2272 case DWARF_VALUE_OPTIMIZED_OUT
:
2273 do_cleanups (value_chain
);
2274 retval
= allocate_optimized_out_value (type
);
2277 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2278 operation by execute_stack_op. */
2279 case DWARF_VALUE_IMPLICIT_POINTER
:
2280 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2281 it can only be encountered when making a piece. */
2283 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
2287 set_value_initialized (retval
, ctx
->initialized
);
2289 do_cleanups (old_chain
);
2294 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2295 passes 0 as the byte_offset. */
2298 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
2299 const gdb_byte
*data
, unsigned short size
,
2300 struct dwarf2_per_cu_data
*per_cu
)
2302 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
2306 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2308 struct needs_frame_baton
2311 struct dwarf2_per_cu_data
*per_cu
;
2314 /* Reads from registers do require a frame. */
2316 needs_frame_read_reg (void *baton
, int regnum
)
2318 struct needs_frame_baton
*nf_baton
= baton
;
2320 nf_baton
->needs_frame
= 1;
2324 /* Reads from memory do not require a frame. */
2326 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
2328 memset (buf
, 0, len
);
2331 /* Frame-relative accesses do require a frame. */
2333 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
2335 static gdb_byte lit0
= DW_OP_lit0
;
2336 struct needs_frame_baton
*nf_baton
= baton
;
2341 nf_baton
->needs_frame
= 1;
2344 /* CFA accesses require a frame. */
2347 needs_frame_frame_cfa (void *baton
)
2349 struct needs_frame_baton
*nf_baton
= baton
;
2351 nf_baton
->needs_frame
= 1;
2355 /* Thread-local accesses do require a frame. */
2357 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
2359 struct needs_frame_baton
*nf_baton
= baton
;
2361 nf_baton
->needs_frame
= 1;
2365 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2368 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, cu_offset die_offset
)
2370 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2372 per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
,
2373 ctx
->funcs
->get_frame_pc
, ctx
->baton
);
2376 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2379 needs_dwarf_reg_entry_value (struct dwarf_expr_context
*ctx
,
2380 int dwarf_reg
, CORE_ADDR fb_offset
, int deref_size
)
2382 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
2384 nf_baton
->needs_frame
= 1;
2387 /* DW_OP_GNU_addr_index doesn't require a frame. */
2390 needs_get_addr_index (void *baton
, unsigned int index
)
2392 /* Nothing to do. */
2396 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2398 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs
=
2400 needs_frame_read_reg
,
2401 needs_frame_read_mem
,
2402 needs_frame_frame_base
,
2403 needs_frame_frame_cfa
,
2404 needs_frame_frame_cfa
, /* get_frame_pc */
2405 needs_frame_tls_address
,
2406 needs_frame_dwarf_call
,
2407 NULL
, /* get_base_type */
2408 needs_dwarf_reg_entry_value
,
2409 needs_get_addr_index
2412 /* Return non-zero iff the location expression at DATA (length SIZE)
2413 requires a frame to evaluate. */
2416 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, unsigned short size
,
2417 struct dwarf2_per_cu_data
*per_cu
)
2419 struct needs_frame_baton baton
;
2420 struct dwarf_expr_context
*ctx
;
2422 struct cleanup
*old_chain
;
2423 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
2425 baton
.needs_frame
= 0;
2426 baton
.per_cu
= per_cu
;
2428 ctx
= new_dwarf_expr_context ();
2429 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
2430 make_cleanup_value_free_to_mark (value_mark ());
2432 ctx
->gdbarch
= get_objfile_arch (objfile
);
2433 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
2434 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (per_cu
);
2435 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
2436 ctx
->baton
= &baton
;
2437 ctx
->funcs
= &needs_frame_ctx_funcs
;
2439 dwarf_expr_eval (ctx
, data
, size
);
2441 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
2443 if (ctx
->num_pieces
> 0)
2447 /* If the location has several pieces, and any of them are in
2448 registers, then we will need a frame to fetch them from. */
2449 for (i
= 0; i
< ctx
->num_pieces
; i
++)
2450 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
2454 do_cleanups (old_chain
);
2456 return baton
.needs_frame
|| in_reg
;
2459 /* A helper function that throws an unimplemented error mentioning a
2460 given DWARF operator. */
2463 unimplemented (unsigned int op
)
2465 const char *name
= get_DW_OP_name (op
);
2468 error (_("DWARF operator %s cannot be translated to an agent expression"),
2471 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2472 "to an agent expression"),
2476 /* A helper function to convert a DWARF register to an arch register.
2477 ARCH is the architecture.
2478 DWARF_REG is the register.
2479 This will throw an exception if the DWARF register cannot be
2480 translated to an architecture register. */
2483 translate_register (struct gdbarch
*arch
, int dwarf_reg
)
2485 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
2487 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
2491 /* A helper function that emits an access to memory. ARCH is the
2492 target architecture. EXPR is the expression which we are building.
2493 NBITS is the number of bits we want to read. This emits the
2494 opcodes needed to read the memory and then extract the desired
2498 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
2500 ULONGEST nbytes
= (nbits
+ 7) / 8;
2502 gdb_assert (nbits
> 0 && nbits
<= sizeof (LONGEST
));
2505 ax_trace_quick (expr
, nbytes
);
2508 ax_simple (expr
, aop_ref8
);
2509 else if (nbits
<= 16)
2510 ax_simple (expr
, aop_ref16
);
2511 else if (nbits
<= 32)
2512 ax_simple (expr
, aop_ref32
);
2514 ax_simple (expr
, aop_ref64
);
2516 /* If we read exactly the number of bytes we wanted, we're done. */
2517 if (8 * nbytes
== nbits
)
2520 if (gdbarch_bits_big_endian (arch
))
2522 /* On a bits-big-endian machine, we want the high-order
2524 ax_const_l (expr
, 8 * nbytes
- nbits
);
2525 ax_simple (expr
, aop_rsh_unsigned
);
2529 /* On a bits-little-endian box, we want the low-order NBITS. */
2530 ax_zero_ext (expr
, nbits
);
2534 /* A helper function to return the frame's PC. */
2537 get_ax_pc (void *baton
)
2539 struct agent_expr
*expr
= baton
;
2544 /* Compile a DWARF location expression to an agent expression.
2546 EXPR is the agent expression we are building.
2547 LOC is the agent value we modify.
2548 ARCH is the architecture.
2549 ADDR_SIZE is the size of addresses, in bytes.
2550 OP_PTR is the start of the location expression.
2551 OP_END is one past the last byte of the location expression.
2553 This will throw an exception for various kinds of errors -- for
2554 example, if the expression cannot be compiled, or if the expression
2558 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
2559 struct gdbarch
*arch
, unsigned int addr_size
,
2560 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
2561 struct dwarf2_per_cu_data
*per_cu
)
2563 struct cleanup
*cleanups
;
2565 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
2566 const gdb_byte
* const base
= op_ptr
;
2567 const gdb_byte
*previous_piece
= op_ptr
;
2568 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2569 ULONGEST bits_collected
= 0;
2570 unsigned int addr_size_bits
= 8 * addr_size
;
2571 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
2573 offsets
= xmalloc ((op_end
- op_ptr
) * sizeof (int));
2574 cleanups
= make_cleanup (xfree
, offsets
);
2576 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
2579 make_cleanup (VEC_cleanup (int), &dw_labels
);
2580 make_cleanup (VEC_cleanup (int), &patches
);
2582 /* By default we are making an address. */
2583 loc
->kind
= axs_lvalue_memory
;
2585 while (op_ptr
< op_end
)
2587 enum dwarf_location_atom op
= *op_ptr
;
2588 uint64_t uoffset
, reg
;
2592 offsets
[op_ptr
- base
] = expr
->len
;
2595 /* Our basic approach to code generation is to map DWARF
2596 operations directly to AX operations. However, there are
2599 First, DWARF works on address-sized units, but AX always uses
2600 LONGEST. For most operations we simply ignore this
2601 difference; instead we generate sign extensions as needed
2602 before division and comparison operations. It would be nice
2603 to omit the sign extensions, but there is no way to determine
2604 the size of the target's LONGEST. (This code uses the size
2605 of the host LONGEST in some cases -- that is a bug but it is
2608 Second, some DWARF operations cannot be translated to AX.
2609 For these we simply fail. See
2610 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2645 ax_const_l (expr
, op
- DW_OP_lit0
);
2649 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
2650 op_ptr
+= addr_size
;
2651 /* Some versions of GCC emit DW_OP_addr before
2652 DW_OP_GNU_push_tls_address. In this case the value is an
2653 index, not an address. We don't support things like
2654 branching between the address and the TLS op. */
2655 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
2656 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
2657 ax_const_l (expr
, uoffset
);
2661 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
2665 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
2669 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
2673 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
2677 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
2681 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
2685 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
2689 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
2693 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
2694 ax_const_l (expr
, uoffset
);
2697 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2698 ax_const_l (expr
, offset
);
2733 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2734 loc
->u
.reg
= translate_register (arch
, op
- DW_OP_reg0
);
2735 loc
->kind
= axs_lvalue_register
;
2739 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2740 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
2741 loc
->u
.reg
= translate_register (arch
, reg
);
2742 loc
->kind
= axs_lvalue_register
;
2745 case DW_OP_implicit_value
:
2749 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &len
);
2750 if (op_ptr
+ len
> op_end
)
2751 error (_("DW_OP_implicit_value: too few bytes available."));
2752 if (len
> sizeof (ULONGEST
))
2753 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
2756 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
2759 dwarf_expr_require_composition (op_ptr
, op_end
,
2760 "DW_OP_implicit_value");
2762 loc
->kind
= axs_rvalue
;
2766 case DW_OP_stack_value
:
2767 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
2768 loc
->kind
= axs_rvalue
;
2803 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2804 i
= translate_register (arch
, op
- DW_OP_breg0
);
2808 ax_const_l (expr
, offset
);
2809 ax_simple (expr
, aop_add
);
2814 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2815 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2816 i
= translate_register (arch
, reg
);
2820 ax_const_l (expr
, offset
);
2821 ax_simple (expr
, aop_add
);
2827 const gdb_byte
*datastart
;
2830 struct symbol
*framefunc
;
2831 LONGEST base_offset
= 0;
2833 b
= block_for_pc (expr
->scope
);
2836 error (_("No block found for address"));
2838 framefunc
= block_linkage_function (b
);
2841 error (_("No function found for block"));
2843 dwarf_expr_frame_base_1 (framefunc
, expr
->scope
,
2844 &datastart
, &datalen
);
2846 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
2847 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
2848 datastart
+ datalen
, per_cu
);
2852 ax_const_l (expr
, offset
);
2853 ax_simple (expr
, aop_add
);
2856 loc
->kind
= axs_lvalue_memory
;
2861 ax_simple (expr
, aop_dup
);
2865 ax_simple (expr
, aop_pop
);
2870 ax_pick (expr
, offset
);
2874 ax_simple (expr
, aop_swap
);
2882 ax_simple (expr
, aop_rot
);
2886 case DW_OP_deref_size
:
2890 if (op
== DW_OP_deref_size
)
2898 ax_simple (expr
, aop_ref8
);
2901 ax_simple (expr
, aop_ref16
);
2904 ax_simple (expr
, aop_ref32
);
2907 ax_simple (expr
, aop_ref64
);
2910 /* Note that get_DW_OP_name will never return
2912 error (_("Unsupported size %d in %s"),
2913 size
, get_DW_OP_name (op
));
2919 /* Sign extend the operand. */
2920 ax_ext (expr
, addr_size_bits
);
2921 ax_simple (expr
, aop_dup
);
2922 ax_const_l (expr
, 0);
2923 ax_simple (expr
, aop_less_signed
);
2924 ax_simple (expr
, aop_log_not
);
2925 i
= ax_goto (expr
, aop_if_goto
);
2926 /* We have to emit 0 - X. */
2927 ax_const_l (expr
, 0);
2928 ax_simple (expr
, aop_swap
);
2929 ax_simple (expr
, aop_sub
);
2930 ax_label (expr
, i
, expr
->len
);
2934 /* No need to sign extend here. */
2935 ax_const_l (expr
, 0);
2936 ax_simple (expr
, aop_swap
);
2937 ax_simple (expr
, aop_sub
);
2941 /* Sign extend the operand. */
2942 ax_ext (expr
, addr_size_bits
);
2943 ax_simple (expr
, aop_bit_not
);
2946 case DW_OP_plus_uconst
:
2947 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
2948 /* It would be really weird to emit `DW_OP_plus_uconst 0',
2949 but we micro-optimize anyhow. */
2952 ax_const_l (expr
, reg
);
2953 ax_simple (expr
, aop_add
);
2958 ax_simple (expr
, aop_bit_and
);
2962 /* Sign extend the operands. */
2963 ax_ext (expr
, addr_size_bits
);
2964 ax_simple (expr
, aop_swap
);
2965 ax_ext (expr
, addr_size_bits
);
2966 ax_simple (expr
, aop_swap
);
2967 ax_simple (expr
, aop_div_signed
);
2971 ax_simple (expr
, aop_sub
);
2975 ax_simple (expr
, aop_rem_unsigned
);
2979 ax_simple (expr
, aop_mul
);
2983 ax_simple (expr
, aop_bit_or
);
2987 ax_simple (expr
, aop_add
);
2991 ax_simple (expr
, aop_lsh
);
2995 ax_simple (expr
, aop_rsh_unsigned
);
2999 ax_simple (expr
, aop_rsh_signed
);
3003 ax_simple (expr
, aop_bit_xor
);
3007 /* Sign extend the operands. */
3008 ax_ext (expr
, addr_size_bits
);
3009 ax_simple (expr
, aop_swap
);
3010 ax_ext (expr
, addr_size_bits
);
3011 /* Note no swap here: A <= B is !(B < A). */
3012 ax_simple (expr
, aop_less_signed
);
3013 ax_simple (expr
, aop_log_not
);
3017 /* Sign extend the operands. */
3018 ax_ext (expr
, addr_size_bits
);
3019 ax_simple (expr
, aop_swap
);
3020 ax_ext (expr
, addr_size_bits
);
3021 ax_simple (expr
, aop_swap
);
3022 /* A >= B is !(A < B). */
3023 ax_simple (expr
, aop_less_signed
);
3024 ax_simple (expr
, aop_log_not
);
3028 /* Sign extend the operands. */
3029 ax_ext (expr
, addr_size_bits
);
3030 ax_simple (expr
, aop_swap
);
3031 ax_ext (expr
, addr_size_bits
);
3032 /* No need for a second swap here. */
3033 ax_simple (expr
, aop_equal
);
3037 /* Sign extend the operands. */
3038 ax_ext (expr
, addr_size_bits
);
3039 ax_simple (expr
, aop_swap
);
3040 ax_ext (expr
, addr_size_bits
);
3041 ax_simple (expr
, aop_swap
);
3042 ax_simple (expr
, aop_less_signed
);
3046 /* Sign extend the operands. */
3047 ax_ext (expr
, addr_size_bits
);
3048 ax_simple (expr
, aop_swap
);
3049 ax_ext (expr
, addr_size_bits
);
3050 /* Note no swap here: A > B is B < A. */
3051 ax_simple (expr
, aop_less_signed
);
3055 /* Sign extend the operands. */
3056 ax_ext (expr
, addr_size_bits
);
3057 ax_simple (expr
, aop_swap
);
3058 ax_ext (expr
, addr_size_bits
);
3059 /* No need for a swap here. */
3060 ax_simple (expr
, aop_equal
);
3061 ax_simple (expr
, aop_log_not
);
3064 case DW_OP_call_frame_cfa
:
3065 dwarf2_compile_cfa_to_ax (expr
, loc
, arch
, expr
->scope
, per_cu
);
3066 loc
->kind
= axs_lvalue_memory
;
3069 case DW_OP_GNU_push_tls_address
:
3074 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3076 i
= ax_goto (expr
, aop_goto
);
3077 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3078 VEC_safe_push (int, patches
, i
);
3082 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
3084 /* Zero extend the operand. */
3085 ax_zero_ext (expr
, addr_size_bits
);
3086 i
= ax_goto (expr
, aop_if_goto
);
3087 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
3088 VEC_safe_push (int, patches
, i
);
3095 case DW_OP_bit_piece
:
3097 uint64_t size
, offset
;
3099 if (op_ptr
- 1 == previous_piece
)
3100 error (_("Cannot translate empty pieces to agent expressions"));
3101 previous_piece
= op_ptr
- 1;
3103 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &size
);
3104 if (op
== DW_OP_piece
)
3110 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &offset
);
3112 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
3113 error (_("Expression pieces exceed word size"));
3115 /* Access the bits. */
3118 case axs_lvalue_register
:
3119 ax_reg (expr
, loc
->u
.reg
);
3122 case axs_lvalue_memory
:
3123 /* Offset the pointer, if needed. */
3126 ax_const_l (expr
, offset
/ 8);
3127 ax_simple (expr
, aop_add
);
3130 access_memory (arch
, expr
, size
);
3134 /* For a bits-big-endian target, shift up what we already
3135 have. For a bits-little-endian target, shift up the
3136 new data. Note that there is a potential bug here if
3137 the DWARF expression leaves multiple values on the
3139 if (bits_collected
> 0)
3141 if (bits_big_endian
)
3143 ax_simple (expr
, aop_swap
);
3144 ax_const_l (expr
, size
);
3145 ax_simple (expr
, aop_lsh
);
3146 /* We don't need a second swap here, because
3147 aop_bit_or is symmetric. */
3151 ax_const_l (expr
, size
);
3152 ax_simple (expr
, aop_lsh
);
3154 ax_simple (expr
, aop_bit_or
);
3157 bits_collected
+= size
;
3158 loc
->kind
= axs_rvalue
;
3162 case DW_OP_GNU_uninit
:
3168 struct dwarf2_locexpr_baton block
;
3169 int size
= (op
== DW_OP_call2
? 2 : 4);
3172 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
3175 offset
.cu_off
= uoffset
;
3176 block
= dwarf2_fetch_die_location_block (offset
, per_cu
,
3179 /* DW_OP_call_ref is currently not supported. */
3180 gdb_assert (block
.per_cu
== per_cu
);
3182 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
3183 block
.data
, block
.data
+ block
.size
,
3188 case DW_OP_call_ref
:
3196 /* Patch all the branches we emitted. */
3197 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
3199 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
3201 internal_error (__FILE__
, __LINE__
, _("invalid label"));
3202 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
3205 do_cleanups (cleanups
);
3209 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3210 evaluator to calculate the location. */
3211 static struct value
*
3212 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3214 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3217 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3218 dlbaton
->size
, dlbaton
->per_cu
);
3223 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3224 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3227 static struct value
*
3228 locexpr_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3230 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3232 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
3236 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3238 locexpr_read_needs_frame (struct symbol
*symbol
)
3240 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3242 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
3246 /* Return true if DATA points to the end of a piece. END is one past
3247 the last byte in the expression. */
3250 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
3252 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
3255 /* Helper for locexpr_describe_location_piece that finds the name of a
3259 locexpr_regname (struct gdbarch
*gdbarch
, int dwarf_regnum
)
3263 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
3264 return gdbarch_register_name (gdbarch
, regnum
);
3267 /* Nicely describe a single piece of a location, returning an updated
3268 position in the bytecode sequence. This function cannot recognize
3269 all locations; if a location is not recognized, it simply returns
3270 DATA. If there is an error during reading, e.g. we run off the end
3271 of the buffer, an error is thrown. */
3273 static const gdb_byte
*
3274 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
3275 CORE_ADDR addr
, struct objfile
*objfile
,
3276 const gdb_byte
*data
, const gdb_byte
*end
,
3277 unsigned int addr_size
)
3279 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3281 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
3283 fprintf_filtered (stream
, _("a variable in $%s"),
3284 locexpr_regname (gdbarch
, data
[0] - DW_OP_reg0
));
3287 else if (data
[0] == DW_OP_regx
)
3291 data
= safe_read_uleb128 (data
+ 1, end
, ®
);
3292 fprintf_filtered (stream
, _("a variable in $%s"),
3293 locexpr_regname (gdbarch
, reg
));
3295 else if (data
[0] == DW_OP_fbreg
)
3298 struct symbol
*framefunc
;
3300 int64_t frame_offset
;
3301 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
3303 int64_t base_offset
= 0;
3305 new_data
= safe_read_sleb128 (data
+ 1, end
, &frame_offset
);
3306 if (!piece_end_p (new_data
, end
))
3310 b
= block_for_pc (addr
);
3313 error (_("No block found for address for symbol \"%s\"."),
3314 SYMBOL_PRINT_NAME (symbol
));
3316 framefunc
= block_linkage_function (b
);
3319 error (_("No function found for block for symbol \"%s\"."),
3320 SYMBOL_PRINT_NAME (symbol
));
3322 dwarf_expr_frame_base_1 (framefunc
, addr
, &base_data
, &base_size
);
3324 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
3326 const gdb_byte
*buf_end
;
3328 frame_reg
= base_data
[0] - DW_OP_breg0
;
3329 buf_end
= safe_read_sleb128 (base_data
+ 1, base_data
+ base_size
,
3331 if (buf_end
!= base_data
+ base_size
)
3332 error (_("Unexpected opcode after "
3333 "DW_OP_breg%u for symbol \"%s\"."),
3334 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
3336 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
3338 /* The frame base is just the register, with no offset. */
3339 frame_reg
= base_data
[0] - DW_OP_reg0
;
3344 /* We don't know what to do with the frame base expression,
3345 so we can't trace this variable; give up. */
3349 fprintf_filtered (stream
,
3350 _("a variable at frame base reg $%s offset %s+%s"),
3351 locexpr_regname (gdbarch
, frame_reg
),
3352 plongest (base_offset
), plongest (frame_offset
));
3354 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
3355 && piece_end_p (data
, end
))
3359 data
= safe_read_sleb128 (data
+ 1, end
, &offset
);
3361 fprintf_filtered (stream
,
3362 _("a variable at offset %s from base reg $%s"),
3364 locexpr_regname (gdbarch
, data
[0] - DW_OP_breg0
));
3367 /* The location expression for a TLS variable looks like this (on a
3370 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3371 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3373 0x3 is the encoding for DW_OP_addr, which has an operand as long
3374 as the size of an address on the target machine (here is 8
3375 bytes). Note that more recent version of GCC emit DW_OP_const4u
3376 or DW_OP_const8u, depending on address size, rather than
3377 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3378 The operand represents the offset at which the variable is within
3379 the thread local storage. */
3381 else if (data
+ 1 + addr_size
< end
3382 && (data
[0] == DW_OP_addr
3383 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
3384 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
3385 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
3386 && piece_end_p (data
+ 2 + addr_size
, end
))
3389 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
3390 gdbarch_byte_order (gdbarch
));
3392 fprintf_filtered (stream
,
3393 _("a thread-local variable at offset 0x%s "
3394 "in the thread-local storage for `%s'"),
3395 phex_nz (offset
, addr_size
), objfile
->name
);
3397 data
+= 1 + addr_size
+ 1;
3399 else if (data
[0] >= DW_OP_lit0
3400 && data
[0] <= DW_OP_lit31
3402 && data
[1] == DW_OP_stack_value
)
3404 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
3411 /* Disassemble an expression, stopping at the end of a piece or at the
3412 end of the expression. Returns a pointer to the next unread byte
3413 in the input expression. If ALL is nonzero, then this function
3414 will keep going until it reaches the end of the expression.
3415 If there is an error during reading, e.g. we run off the end
3416 of the buffer, an error is thrown. */
3418 static const gdb_byte
*
3419 disassemble_dwarf_expression (struct ui_file
*stream
,
3420 struct gdbarch
*arch
, unsigned int addr_size
,
3421 int offset_size
, const gdb_byte
*start
,
3422 const gdb_byte
*data
, const gdb_byte
*end
,
3423 int indent
, int all
,
3424 struct dwarf2_per_cu_data
*per_cu
)
3428 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
3430 enum dwarf_location_atom op
= *data
++;
3435 name
= get_DW_OP_name (op
);
3438 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3439 op
, (long) (data
- 1 - start
));
3440 fprintf_filtered (stream
, " %*ld: %s", indent
+ 4,
3441 (long) (data
- 1 - start
), name
);
3446 ul
= extract_unsigned_integer (data
, addr_size
,
3447 gdbarch_byte_order (arch
));
3449 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
3453 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
3455 fprintf_filtered (stream
, " %s", pulongest (ul
));
3458 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
3460 fprintf_filtered (stream
, " %s", plongest (l
));
3463 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3465 fprintf_filtered (stream
, " %s", pulongest (ul
));
3468 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3470 fprintf_filtered (stream
, " %s", plongest (l
));
3473 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3475 fprintf_filtered (stream
, " %s", pulongest (ul
));
3478 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
3480 fprintf_filtered (stream
, " %s", plongest (l
));
3483 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
3485 fprintf_filtered (stream
, " %s", pulongest (ul
));
3488 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
3490 fprintf_filtered (stream
, " %s", plongest (l
));
3493 data
= safe_read_uleb128 (data
, end
, &ul
);
3494 fprintf_filtered (stream
, " %s", pulongest (ul
));
3497 data
= safe_read_sleb128 (data
, end
, &l
);
3498 fprintf_filtered (stream
, " %s", plongest (l
));
3533 fprintf_filtered (stream
, " [$%s]",
3534 locexpr_regname (arch
, op
- DW_OP_reg0
));
3538 data
= safe_read_uleb128 (data
, end
, &ul
);
3539 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
3540 locexpr_regname (arch
, (int) ul
));
3543 case DW_OP_implicit_value
:
3544 data
= safe_read_uleb128 (data
, end
, &ul
);
3546 fprintf_filtered (stream
, " %s", pulongest (ul
));
3581 data
= safe_read_sleb128 (data
, end
, &l
);
3582 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
3583 locexpr_regname (arch
, op
- DW_OP_breg0
));
3587 data
= safe_read_uleb128 (data
, end
, &ul
);
3588 data
= safe_read_sleb128 (data
, end
, &l
);
3589 fprintf_filtered (stream
, " register %s [$%s] offset %s",
3591 locexpr_regname (arch
, (int) ul
),
3596 data
= safe_read_sleb128 (data
, end
, &l
);
3597 fprintf_filtered (stream
, " %s", plongest (l
));
3600 case DW_OP_xderef_size
:
3601 case DW_OP_deref_size
:
3603 fprintf_filtered (stream
, " %d", *data
);
3607 case DW_OP_plus_uconst
:
3608 data
= safe_read_uleb128 (data
, end
, &ul
);
3609 fprintf_filtered (stream
, " %s", pulongest (ul
));
3613 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3615 fprintf_filtered (stream
, " to %ld",
3616 (long) (data
+ l
- start
));
3620 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
3622 fprintf_filtered (stream
, " %ld",
3623 (long) (data
+ l
- start
));
3627 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
3629 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
3633 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
3635 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
3638 case DW_OP_call_ref
:
3639 ul
= extract_unsigned_integer (data
, offset_size
,
3640 gdbarch_byte_order (arch
));
3641 data
+= offset_size
;
3642 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
3646 data
= safe_read_uleb128 (data
, end
, &ul
);
3647 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
3650 case DW_OP_bit_piece
:
3654 data
= safe_read_uleb128 (data
, end
, &ul
);
3655 data
= safe_read_uleb128 (data
, end
, &offset
);
3656 fprintf_filtered (stream
, " size %s offset %s (bits)",
3657 pulongest (ul
), pulongest (offset
));
3661 case DW_OP_GNU_implicit_pointer
:
3663 ul
= extract_unsigned_integer (data
, offset_size
,
3664 gdbarch_byte_order (arch
));
3665 data
+= offset_size
;
3667 data
= safe_read_sleb128 (data
, end
, &l
);
3669 fprintf_filtered (stream
, " DIE %s offset %s",
3670 phex_nz (ul
, offset_size
),
3675 case DW_OP_GNU_deref_type
:
3677 int addr_size
= *data
++;
3681 data
= safe_read_uleb128 (data
, end
, &ul
);
3683 type
= dwarf2_get_die_type (offset
, per_cu
);
3684 fprintf_filtered (stream
, "<");
3685 type_print (type
, "", stream
, -1);
3686 fprintf_filtered (stream
, " [0x%s]> %d", phex_nz (offset
.cu_off
, 0),
3691 case DW_OP_GNU_const_type
:
3696 data
= safe_read_uleb128 (data
, end
, &ul
);
3697 type_die
.cu_off
= ul
;
3698 type
= dwarf2_get_die_type (type_die
, per_cu
);
3699 fprintf_filtered (stream
, "<");
3700 type_print (type
, "", stream
, -1);
3701 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3705 case DW_OP_GNU_regval_type
:
3711 data
= safe_read_uleb128 (data
, end
, ®
);
3712 data
= safe_read_uleb128 (data
, end
, &ul
);
3713 type_die
.cu_off
= ul
;
3715 type
= dwarf2_get_die_type (type_die
, per_cu
);
3716 fprintf_filtered (stream
, "<");
3717 type_print (type
, "", stream
, -1);
3718 fprintf_filtered (stream
, " [0x%s]> [$%s]",
3719 phex_nz (type_die
.cu_off
, 0),
3720 locexpr_regname (arch
, reg
));
3724 case DW_OP_GNU_convert
:
3725 case DW_OP_GNU_reinterpret
:
3729 data
= safe_read_uleb128 (data
, end
, &ul
);
3730 type_die
.cu_off
= ul
;
3732 if (type_die
.cu_off
== 0)
3733 fprintf_filtered (stream
, "<0>");
3738 type
= dwarf2_get_die_type (type_die
, per_cu
);
3739 fprintf_filtered (stream
, "<");
3740 type_print (type
, "", stream
, -1);
3741 fprintf_filtered (stream
, " [0x%s]>", phex_nz (type_die
.cu_off
, 0));
3746 case DW_OP_GNU_entry_value
:
3747 data
= safe_read_uleb128 (data
, end
, &ul
);
3748 fputc_filtered ('\n', stream
);
3749 disassemble_dwarf_expression (stream
, arch
, addr_size
, offset_size
,
3750 start
, data
, data
+ ul
, indent
+ 2,
3756 fprintf_filtered (stream
, "\n");
3762 /* Describe a single location, which may in turn consist of multiple
3766 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
3767 struct ui_file
*stream
,
3768 const gdb_byte
*data
, int size
,
3769 struct objfile
*objfile
, unsigned int addr_size
,
3770 int offset_size
, struct dwarf2_per_cu_data
*per_cu
)
3772 const gdb_byte
*end
= data
+ size
;
3773 int first_piece
= 1, bad
= 0;
3777 const gdb_byte
*here
= data
;
3778 int disassemble
= 1;
3783 fprintf_filtered (stream
, _(", and "));
3785 if (!dwarf2_always_disassemble
)
3787 data
= locexpr_describe_location_piece (symbol
, stream
,
3789 data
, end
, addr_size
);
3790 /* If we printed anything, or if we have an empty piece,
3791 then don't disassemble. */
3793 || data
[0] == DW_OP_piece
3794 || data
[0] == DW_OP_bit_piece
)
3799 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
3800 data
= disassemble_dwarf_expression (stream
,
3801 get_objfile_arch (objfile
),
3802 addr_size
, offset_size
, data
,
3804 dwarf2_always_disassemble
,
3810 int empty
= data
== here
;
3813 fprintf_filtered (stream
, " ");
3814 if (data
[0] == DW_OP_piece
)
3818 data
= safe_read_uleb128 (data
+ 1, end
, &bytes
);
3821 fprintf_filtered (stream
, _("an empty %s-byte piece"),
3824 fprintf_filtered (stream
, _(" [%s-byte piece]"),
3827 else if (data
[0] == DW_OP_bit_piece
)
3829 uint64_t bits
, offset
;
3831 data
= safe_read_uleb128 (data
+ 1, end
, &bits
);
3832 data
= safe_read_uleb128 (data
, end
, &offset
);
3835 fprintf_filtered (stream
,
3836 _("an empty %s-bit piece"),
3839 fprintf_filtered (stream
,
3840 _(" [%s-bit piece, offset %s bits]"),
3841 pulongest (bits
), pulongest (offset
));
3851 if (bad
|| data
> end
)
3852 error (_("Corrupted DWARF2 expression for \"%s\"."),
3853 SYMBOL_PRINT_NAME (symbol
));
3856 /* Print a natural-language description of SYMBOL to STREAM. This
3857 version is for a symbol with a single location. */
3860 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
3861 struct ui_file
*stream
)
3863 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3864 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
3865 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
3866 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
3868 locexpr_describe_location_1 (symbol
, addr
, stream
,
3869 dlbaton
->data
, dlbaton
->size
,
3870 objfile
, addr_size
, offset_size
,
3874 /* Describe the location of SYMBOL as an agent value in VALUE, generating
3875 any necessary bytecode in AX. */
3878 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
3879 struct agent_expr
*ax
, struct axs_value
*value
)
3881 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3882 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
3884 if (dlbaton
->size
== 0)
3885 value
->optimized_out
= 1;
3887 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
3888 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
3892 /* The set of location functions used with the DWARF-2 expression
3894 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
3895 locexpr_read_variable
,
3896 locexpr_read_variable_at_entry
,
3897 locexpr_read_needs_frame
,
3898 locexpr_describe_location
,
3899 locexpr_tracepoint_var_ref
3903 /* Wrapper functions for location lists. These generally find
3904 the appropriate location expression and call something above. */
3906 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3907 evaluator to calculate the location. */
3908 static struct value
*
3909 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
3911 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3913 const gdb_byte
*data
;
3915 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
3917 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
3918 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
3924 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
3925 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3928 Function always returns non-NULL value, it may be marked optimized out if
3929 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
3930 if it cannot resolve the parameter for any reason. */
3932 static struct value
*
3933 loclist_read_variable_at_entry (struct symbol
*symbol
, struct frame_info
*frame
)
3935 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3936 const gdb_byte
*data
;
3940 if (frame
== NULL
|| !get_frame_func_if_available (frame
, &pc
))
3941 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
3943 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
3945 return allocate_optimized_out_value (SYMBOL_TYPE (symbol
));
3947 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol
), frame
, data
, size
);
3950 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3952 loclist_read_needs_frame (struct symbol
*symbol
)
3954 /* If there's a location list, then assume we need to have a frame
3955 to choose the appropriate location expression. With tracking of
3956 global variables this is not necessarily true, but such tracking
3957 is disabled in GCC at the moment until we figure out how to
3963 /* Print a natural-language description of SYMBOL to STREAM. This
3964 version applies when there is a list of different locations, each
3965 with a specified address range. */
3968 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
3969 struct ui_file
*stream
)
3971 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
3972 const gdb_byte
*loc_ptr
, *buf_end
;
3974 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
3975 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3976 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3977 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
3978 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
3979 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
3980 /* Adjust base_address for relocatable objects. */
3981 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
3982 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
3985 loc_ptr
= dlbaton
->data
;
3986 buf_end
= dlbaton
->data
+ dlbaton
->size
;
3988 fprintf_filtered (stream
, _("multi-location:\n"));
3990 /* Iterate through locations until we run out. */
3993 CORE_ADDR low
= 0, high
= 0; /* init for gcc -Wall */
3995 enum debug_loc_kind kind
;
3996 const gdb_byte
*new_ptr
= NULL
; /* init for gcc -Wall */
3998 if (dlbaton
->from_dwo
)
3999 kind
= decode_debug_loc_dwo_addresses (dlbaton
->per_cu
,
4000 loc_ptr
, buf_end
, &new_ptr
,
4001 &low
, &high
, byte_order
);
4003 kind
= decode_debug_loc_addresses (loc_ptr
, buf_end
, &new_ptr
,
4005 byte_order
, addr_size
,
4010 case DEBUG_LOC_END_OF_LIST
:
4013 case DEBUG_LOC_BASE_ADDRESS
:
4014 base_address
= high
+ base_offset
;
4015 fprintf_filtered (stream
, _(" Base address %s"),
4016 paddress (gdbarch
, base_address
));
4018 case DEBUG_LOC_START_END
:
4019 case DEBUG_LOC_START_LENGTH
:
4021 case DEBUG_LOC_BUFFER_OVERFLOW
:
4022 case DEBUG_LOC_INVALID_ENTRY
:
4023 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4024 SYMBOL_PRINT_NAME (symbol
));
4026 gdb_assert_not_reached ("bad debug_loc_kind");
4029 /* Otherwise, a location expression entry. */
4030 low
+= base_address
;
4031 high
+= base_address
;
4033 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
4036 /* (It would improve readability to print only the minimum
4037 necessary digits of the second number of the range.) */
4038 fprintf_filtered (stream
, _(" Range %s-%s: "),
4039 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
4041 /* Now describe this particular location. */
4042 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
4043 objfile
, addr_size
, offset_size
,
4046 fprintf_filtered (stream
, "\n");
4052 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4053 any necessary bytecode in AX. */
4055 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
4056 struct agent_expr
*ax
, struct axs_value
*value
)
4058 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
4059 const gdb_byte
*data
;
4061 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
4063 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
4065 value
->optimized_out
= 1;
4067 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
4071 /* The set of location functions used with the DWARF-2 expression
4072 evaluator and location lists. */
4073 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
4074 loclist_read_variable
,
4075 loclist_read_variable_at_entry
,
4076 loclist_read_needs_frame
,
4077 loclist_describe_location
,
4078 loclist_tracepoint_var_ref
4081 /* Provide a prototype to silence -Wmissing-prototypes. */
4082 extern initialize_file_ftype _initialize_dwarf2loc
;
4085 _initialize_dwarf2loc (void)
4087 add_setshow_zinteger_cmd ("entry-values", class_maintenance
,
4088 &entry_values_debug
,
4089 _("Set entry values and tail call frames "
4091 _("Show entry values and tail call frames "
4093 _("When non-zero, the process of determining "
4094 "parameter values from function entry point "
4095 "and tail call frames will be printed."),
4097 show_entry_values_debug
,
4098 &setdebuglist
, &showdebuglist
);