1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003, 2005, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
34 #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"
45 extern int dwarf2_always_disassemble
;
48 dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
49 const gdb_byte
**start
, size_t *length
);
52 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
53 const gdb_byte
*data
, unsigned short size
,
54 struct dwarf2_per_cu_data
*per_cu
,
57 /* A function for dealing with location lists. Given a
58 symbol baton (BATON) and a pc value (PC), find the appropriate
59 location expression, set *LOCEXPR_LENGTH, and return a pointer
60 to the beginning of the expression. Returns NULL on failure.
62 For now, only return the first matching location expression; there
63 can be more than one in the list. */
66 dwarf2_find_location_expression (struct dwarf2_loclist_baton
*baton
,
67 size_t *locexpr_length
, CORE_ADDR pc
)
70 const gdb_byte
*loc_ptr
, *buf_end
;
72 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
73 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
74 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
75 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
76 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
77 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
78 /* Adjust base_address for relocatable objects. */
79 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (baton
->per_cu
);
80 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
82 loc_ptr
= baton
->data
;
83 buf_end
= baton
->data
+ baton
->size
;
87 if (buf_end
- loc_ptr
< 2 * addr_size
)
88 error (_("dwarf2_find_location_expression: "
89 "Corrupted DWARF expression."));
92 low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
94 low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
98 high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
100 high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
101 loc_ptr
+= addr_size
;
103 /* A base-address-selection entry. */
104 if ((low
& base_mask
) == base_mask
)
106 base_address
= high
+ base_offset
;
110 /* An end-of-list entry. */
111 if (low
== 0 && high
== 0)
114 /* Otherwise, a location expression entry. */
116 high
+= base_address
;
118 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
121 if (pc
>= low
&& pc
< high
)
123 *locexpr_length
= length
;
131 /* This is the baton used when performing dwarf2 expression
133 struct dwarf_expr_baton
135 struct frame_info
*frame
;
136 struct dwarf2_per_cu_data
*per_cu
;
139 /* Helper functions for dwarf2_evaluate_loc_desc. */
141 /* Using the frame specified in BATON, return the value of register
142 REGNUM, treated as a pointer. */
144 dwarf_expr_read_reg (void *baton
, int dwarf_regnum
)
146 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
147 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
151 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
152 result
= address_from_register (builtin_type (gdbarch
)->builtin_data_ptr
,
153 regnum
, debaton
->frame
);
157 /* Read memory at ADDR (length LEN) into BUF. */
160 dwarf_expr_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
162 read_memory (addr
, buf
, len
);
165 /* Using the frame specified in BATON, find the location expression
166 describing the frame base. Return a pointer to it in START and
167 its length in LENGTH. */
169 dwarf_expr_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
171 /* FIXME: cagney/2003-03-26: This code should be using
172 get_frame_base_address(), and then implement a dwarf2 specific
174 struct symbol
*framefunc
;
175 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
177 /* Use block_linkage_function, which returns a real (not inlined)
178 function, instead of get_frame_function, which may return an
180 framefunc
= block_linkage_function (get_frame_block (debaton
->frame
, NULL
));
182 /* If we found a frame-relative symbol then it was certainly within
183 some function associated with a frame. If we can't find the frame,
184 something has gone wrong. */
185 gdb_assert (framefunc
!= NULL
);
187 dwarf_expr_frame_base_1 (framefunc
,
188 get_frame_address_in_block (debaton
->frame
),
193 dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
194 const gdb_byte
**start
, size_t *length
)
196 if (SYMBOL_LOCATION_BATON (framefunc
) == NULL
)
198 else if (SYMBOL_COMPUTED_OPS (framefunc
) == &dwarf2_loclist_funcs
)
200 struct dwarf2_loclist_baton
*symbaton
;
202 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
203 *start
= dwarf2_find_location_expression (symbaton
, length
, pc
);
207 struct dwarf2_locexpr_baton
*symbaton
;
209 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
210 if (symbaton
!= NULL
)
212 *length
= symbaton
->size
;
213 *start
= symbaton
->data
;
220 error (_("Could not find the frame base for \"%s\"."),
221 SYMBOL_NATURAL_NAME (framefunc
));
224 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
225 the frame in BATON. */
228 dwarf_expr_frame_cfa (void *baton
)
230 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
232 return dwarf2_frame_cfa (debaton
->frame
);
235 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
236 the frame in BATON. */
239 dwarf_expr_frame_pc (void *baton
)
241 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
243 return get_frame_address_in_block (debaton
->frame
);
246 /* Using the objfile specified in BATON, find the address for the
247 current thread's thread-local storage with offset OFFSET. */
249 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
251 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
252 struct objfile
*objfile
= dwarf2_per_cu_objfile (debaton
->per_cu
);
254 return target_translate_tls_address (objfile
, offset
);
257 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
258 current CU (as is PER_CU). State of the CTX is not affected by the
262 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, size_t die_offset
,
263 struct dwarf2_per_cu_data
*per_cu
,
264 CORE_ADDR (*get_frame_pc
) (void *baton
),
267 struct dwarf2_locexpr_baton block
;
269 block
= dwarf2_fetch_die_location_block (die_offset
, per_cu
,
270 get_frame_pc
, baton
);
272 /* DW_OP_call_ref is currently not supported. */
273 gdb_assert (block
.per_cu
== per_cu
);
275 dwarf_expr_eval (ctx
, block
.data
, block
.size
);
278 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
281 dwarf_expr_dwarf_call (struct dwarf_expr_context
*ctx
, size_t die_offset
)
283 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
285 per_cu_dwarf_call (ctx
, die_offset
, debaton
->per_cu
,
286 ctx
->get_frame_pc
, ctx
->baton
);
291 /* Reference count. */
294 /* The CU from which this closure's expression came. */
295 struct dwarf2_per_cu_data
*per_cu
;
297 /* The number of pieces used to describe this variable. */
300 /* The target address size, used only for DWARF_VALUE_STACK. */
303 /* The pieces themselves. */
304 struct dwarf_expr_piece
*pieces
;
307 /* Allocate a closure for a value formed from separately-described
310 static struct piece_closure
*
311 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
312 int n_pieces
, struct dwarf_expr_piece
*pieces
,
315 struct piece_closure
*c
= XZALLOC (struct piece_closure
);
319 c
->n_pieces
= n_pieces
;
320 c
->addr_size
= addr_size
;
321 c
->pieces
= XCALLOC (n_pieces
, struct dwarf_expr_piece
);
323 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
328 /* The lowest-level function to extract bits from a byte buffer.
329 SOURCE is the buffer. It is updated if we read to the end of a
331 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
332 updated to reflect the number of bits actually read.
333 NBITS is the number of bits we want to read. It is updated to
334 reflect the number of bits actually read. This function may read
336 BITS_BIG_ENDIAN is taken directly from gdbarch.
337 This function returns the extracted bits. */
340 extract_bits_primitive (const gdb_byte
**source
,
341 unsigned int *source_offset_bits
,
342 int *nbits
, int bits_big_endian
)
344 unsigned int avail
, mask
, datum
;
346 gdb_assert (*source_offset_bits
< 8);
348 avail
= 8 - *source_offset_bits
;
352 mask
= (1 << avail
) - 1;
355 datum
>>= 8 - (*source_offset_bits
+ *nbits
);
357 datum
>>= *source_offset_bits
;
361 *source_offset_bits
+= avail
;
362 if (*source_offset_bits
>= 8)
364 *source_offset_bits
-= 8;
371 /* Extract some bits from a source buffer and move forward in the
374 SOURCE is the source buffer. It is updated as bytes are read.
375 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
377 NBITS is the number of bits to read.
378 BITS_BIG_ENDIAN is taken directly from gdbarch.
380 This function returns the bits that were read. */
383 extract_bits (const gdb_byte
**source
, unsigned int *source_offset_bits
,
384 int nbits
, int bits_big_endian
)
388 gdb_assert (nbits
> 0 && nbits
<= 8);
390 datum
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
396 more
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
408 /* Write some bits into a buffer and move forward in the buffer.
410 DATUM is the bits to write. The low-order bits of DATUM are used.
411 DEST is the destination buffer. It is updated as bytes are
413 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
415 NBITS is the number of valid bits in DATUM.
416 BITS_BIG_ENDIAN is taken directly from gdbarch. */
419 insert_bits (unsigned int datum
,
420 gdb_byte
*dest
, unsigned int dest_offset_bits
,
421 int nbits
, int bits_big_endian
)
425 gdb_assert (dest_offset_bits
+ nbits
<= 8);
427 mask
= (1 << nbits
) - 1;
430 datum
<<= 8 - (dest_offset_bits
+ nbits
);
431 mask
<<= 8 - (dest_offset_bits
+ nbits
);
435 datum
<<= dest_offset_bits
;
436 mask
<<= dest_offset_bits
;
439 gdb_assert ((datum
& ~mask
) == 0);
441 *dest
= (*dest
& ~mask
) | datum
;
444 /* Copy bits from a source to a destination.
446 DEST is where the bits should be written.
447 DEST_OFFSET_BITS is the bit offset into DEST.
448 SOURCE is the source of bits.
449 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
450 BIT_COUNT is the number of bits to copy.
451 BITS_BIG_ENDIAN is taken directly from gdbarch. */
454 copy_bitwise (gdb_byte
*dest
, unsigned int dest_offset_bits
,
455 const gdb_byte
*source
, unsigned int source_offset_bits
,
456 unsigned int bit_count
,
459 unsigned int dest_avail
;
462 /* Reduce everything to byte-size pieces. */
463 dest
+= dest_offset_bits
/ 8;
464 dest_offset_bits
%= 8;
465 source
+= source_offset_bits
/ 8;
466 source_offset_bits
%= 8;
468 dest_avail
= 8 - dest_offset_bits
% 8;
470 /* See if we can fill the first destination byte. */
471 if (dest_avail
< bit_count
)
473 datum
= extract_bits (&source
, &source_offset_bits
, dest_avail
,
475 insert_bits (datum
, dest
, dest_offset_bits
, dest_avail
, bits_big_endian
);
477 dest_offset_bits
= 0;
478 bit_count
-= dest_avail
;
481 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
482 than 8 bits remaining. */
483 gdb_assert (dest_offset_bits
% 8 == 0 || bit_count
< 8);
484 for (; bit_count
>= 8; bit_count
-= 8)
486 datum
= extract_bits (&source
, &source_offset_bits
, 8, bits_big_endian
);
487 *dest
++ = (gdb_byte
) datum
;
490 /* Finally, we may have a few leftover bits. */
491 gdb_assert (bit_count
<= 8 - dest_offset_bits
% 8);
494 datum
= extract_bits (&source
, &source_offset_bits
, bit_count
,
496 insert_bits (datum
, dest
, dest_offset_bits
, bit_count
, bits_big_endian
);
501 read_pieced_value (struct value
*v
)
505 ULONGEST bits_to_skip
;
507 struct piece_closure
*c
508 = (struct piece_closure
*) value_computed_closure (v
);
509 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (v
));
511 size_t buffer_size
= 0;
513 struct cleanup
*cleanup
;
515 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
517 if (value_type (v
) != value_enclosing_type (v
))
518 internal_error (__FILE__
, __LINE__
,
519 _("Should not be able to create a lazy value with "
520 "an enclosing type"));
522 cleanup
= make_cleanup (free_current_contents
, &buffer
);
524 contents
= value_contents_raw (v
);
525 bits_to_skip
= 8 * value_offset (v
);
526 if (value_bitsize (v
))
528 bits_to_skip
+= value_bitpos (v
);
529 type_len
= value_bitsize (v
);
532 type_len
= 8 * TYPE_LENGTH (value_type (v
));
534 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
536 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
537 size_t this_size
, this_size_bits
;
538 long dest_offset_bits
, source_offset_bits
, source_offset
;
539 const gdb_byte
*intermediate_buffer
;
541 /* Compute size, source, and destination offsets for copying, in
543 this_size_bits
= p
->size
;
544 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
546 bits_to_skip
-= this_size_bits
;
549 if (this_size_bits
> type_len
- offset
)
550 this_size_bits
= type_len
- offset
;
551 if (bits_to_skip
> 0)
553 dest_offset_bits
= 0;
554 source_offset_bits
= bits_to_skip
;
555 this_size_bits
-= bits_to_skip
;
560 dest_offset_bits
= offset
;
561 source_offset_bits
= 0;
564 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
565 source_offset
= source_offset_bits
/ 8;
566 if (buffer_size
< this_size
)
568 buffer_size
= this_size
;
569 buffer
= xrealloc (buffer
, buffer_size
);
571 intermediate_buffer
= buffer
;
573 /* Copy from the source to DEST_BUFFER. */
576 case DWARF_VALUE_REGISTER
:
578 struct gdbarch
*arch
= get_frame_arch (frame
);
579 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.value
);
580 int reg_offset
= source_offset
;
582 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
583 && this_size
< register_size (arch
, gdb_regnum
))
585 /* Big-endian, and we want less than full size. */
586 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
587 /* We want the lower-order THIS_SIZE_BITS of the bytes
588 we extract from the register. */
589 source_offset_bits
+= 8 * this_size
- this_size_bits
;
592 if (gdb_regnum
!= -1)
596 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
600 /* Just so garbage doesn't ever shine through. */
601 memset (buffer
, 0, this_size
);
604 set_value_optimized_out (v
, 1);
606 mark_value_bytes_unavailable (v
, offset
, this_size
);
611 error (_("Unable to access DWARF register number %s"),
612 paddress (arch
, p
->v
.value
));
617 case DWARF_VALUE_MEMORY
:
618 read_value_memory (v
, offset
,
619 p
->v
.mem
.in_stack_memory
,
620 p
->v
.mem
.addr
+ source_offset
,
624 case DWARF_VALUE_STACK
:
626 struct gdbarch
*gdbarch
= get_type_arch (value_type (v
));
627 size_t n
= this_size
;
629 if (n
> c
->addr_size
- source_offset
)
630 n
= (c
->addr_size
>= source_offset
631 ? c
->addr_size
- source_offset
637 else if (source_offset
== 0)
638 store_unsigned_integer (buffer
, n
,
639 gdbarch_byte_order (gdbarch
),
643 gdb_byte bytes
[sizeof (ULONGEST
)];
645 store_unsigned_integer (bytes
, n
+ source_offset
,
646 gdbarch_byte_order (gdbarch
),
648 memcpy (buffer
, bytes
+ source_offset
, n
);
653 case DWARF_VALUE_LITERAL
:
655 size_t n
= this_size
;
657 if (n
> p
->v
.literal
.length
- source_offset
)
658 n
= (p
->v
.literal
.length
>= source_offset
659 ? p
->v
.literal
.length
- source_offset
662 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
666 /* These bits show up as zeros -- but do not cause the value
667 to be considered optimized-out. */
668 case DWARF_VALUE_IMPLICIT_POINTER
:
671 case DWARF_VALUE_OPTIMIZED_OUT
:
672 set_value_optimized_out (v
, 1);
676 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
679 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
680 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
681 copy_bitwise (contents
, dest_offset_bits
,
682 intermediate_buffer
, source_offset_bits
% 8,
683 this_size_bits
, bits_big_endian
);
685 offset
+= this_size_bits
;
688 do_cleanups (cleanup
);
692 write_pieced_value (struct value
*to
, struct value
*from
)
696 ULONGEST bits_to_skip
;
697 const gdb_byte
*contents
;
698 struct piece_closure
*c
699 = (struct piece_closure
*) value_computed_closure (to
);
700 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
702 size_t buffer_size
= 0;
704 struct cleanup
*cleanup
;
706 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
710 set_value_optimized_out (to
, 1);
714 cleanup
= make_cleanup (free_current_contents
, &buffer
);
716 contents
= value_contents (from
);
717 bits_to_skip
= 8 * value_offset (to
);
718 if (value_bitsize (to
))
720 bits_to_skip
+= value_bitpos (to
);
721 type_len
= value_bitsize (to
);
724 type_len
= 8 * TYPE_LENGTH (value_type (to
));
726 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
728 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
729 size_t this_size_bits
, this_size
;
730 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
732 const gdb_byte
*source_buffer
;
734 this_size_bits
= p
->size
;
735 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
737 bits_to_skip
-= this_size_bits
;
740 if (this_size_bits
> type_len
- offset
)
741 this_size_bits
= type_len
- offset
;
742 if (bits_to_skip
> 0)
744 dest_offset_bits
= bits_to_skip
;
745 source_offset_bits
= 0;
746 this_size_bits
-= bits_to_skip
;
751 dest_offset_bits
= 0;
752 source_offset_bits
= offset
;
755 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
756 source_offset
= source_offset_bits
/ 8;
757 dest_offset
= dest_offset_bits
/ 8;
758 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
760 source_buffer
= contents
+ source_offset
;
765 if (buffer_size
< this_size
)
767 buffer_size
= this_size
;
768 buffer
= xrealloc (buffer
, buffer_size
);
770 source_buffer
= buffer
;
776 case DWARF_VALUE_REGISTER
:
778 struct gdbarch
*arch
= get_frame_arch (frame
);
779 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.value
);
780 int reg_offset
= dest_offset
;
782 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
783 && this_size
<= register_size (arch
, gdb_regnum
))
784 /* Big-endian, and we want less than full size. */
785 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
787 if (gdb_regnum
!= -1)
793 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
798 error (_("Can't do read-modify-write to "
799 "update bitfield; containing word has been "
802 throw_error (NOT_AVAILABLE_ERROR
,
803 _("Can't do read-modify-write to update "
804 "bitfield; containing word "
807 copy_bitwise (buffer
, dest_offset_bits
,
808 contents
, source_offset_bits
,
813 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
814 this_size
, source_buffer
);
818 error (_("Unable to write to DWARF register number %s"),
819 paddress (arch
, p
->v
.value
));
823 case DWARF_VALUE_MEMORY
:
826 /* Only the first and last bytes can possibly have any
828 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
, 1);
829 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
830 buffer
+ this_size
- 1, 1);
831 copy_bitwise (buffer
, dest_offset_bits
,
832 contents
, source_offset_bits
,
837 write_memory (p
->v
.mem
.addr
+ dest_offset
,
838 source_buffer
, this_size
);
841 set_value_optimized_out (to
, 1);
844 offset
+= this_size_bits
;
847 do_cleanups (cleanup
);
850 /* A helper function that checks bit validity in a pieced value.
851 CHECK_FOR indicates the kind of validity checking.
852 DWARF_VALUE_MEMORY means to check whether any bit is valid.
853 DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
855 DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
859 check_pieced_value_bits (const struct value
*value
, int bit_offset
,
861 enum dwarf_value_location check_for
)
863 struct piece_closure
*c
864 = (struct piece_closure
*) value_computed_closure (value
);
866 int validity
= (check_for
== DWARF_VALUE_MEMORY
867 || check_for
== DWARF_VALUE_IMPLICIT_POINTER
);
869 bit_offset
+= 8 * value_offset (value
);
870 if (value_bitsize (value
))
871 bit_offset
+= value_bitpos (value
);
873 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
875 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
876 size_t this_size_bits
= p
->size
;
880 if (bit_offset
>= this_size_bits
)
882 bit_offset
-= this_size_bits
;
886 bit_length
-= this_size_bits
- bit_offset
;
890 bit_length
-= this_size_bits
;
892 if (check_for
== DWARF_VALUE_IMPLICIT_POINTER
)
894 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
897 else if (p
->location
== DWARF_VALUE_OPTIMIZED_OUT
898 || p
->location
== DWARF_VALUE_IMPLICIT_POINTER
)
914 check_pieced_value_validity (const struct value
*value
, int bit_offset
,
917 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
922 check_pieced_value_invalid (const struct value
*value
)
924 return check_pieced_value_bits (value
, 0,
925 8 * TYPE_LENGTH (value_type (value
)),
926 DWARF_VALUE_OPTIMIZED_OUT
);
929 /* An implementation of an lval_funcs method to see whether a value is
930 a synthetic pointer. */
933 check_pieced_synthetic_pointer (const struct value
*value
, int bit_offset
,
936 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
937 DWARF_VALUE_IMPLICIT_POINTER
);
940 /* A wrapper function for get_frame_address_in_block. */
943 get_frame_address_in_block_wrapper (void *baton
)
945 return get_frame_address_in_block (baton
);
948 /* An implementation of an lval_funcs method to indirect through a
949 pointer. This handles the synthetic pointer case when needed. */
951 static struct value
*
952 indirect_pieced_value (struct value
*value
)
954 struct piece_closure
*c
955 = (struct piece_closure
*) value_computed_closure (value
);
957 struct frame_info
*frame
;
958 struct dwarf2_locexpr_baton baton
;
959 int i
, bit_offset
, bit_length
;
960 struct dwarf_expr_piece
*piece
= NULL
;
961 struct value
*result
;
964 type
= value_type (value
);
965 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
968 bit_length
= 8 * TYPE_LENGTH (type
);
969 bit_offset
= 8 * value_offset (value
);
970 if (value_bitsize (value
))
971 bit_offset
+= value_bitpos (value
);
973 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
975 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
976 size_t this_size_bits
= p
->size
;
980 if (bit_offset
>= this_size_bits
)
982 bit_offset
-= this_size_bits
;
986 bit_length
-= this_size_bits
- bit_offset
;
990 bit_length
-= this_size_bits
;
992 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
996 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
1002 frame
= get_selected_frame (_("No frame selected."));
1003 byte_offset
= value_as_address (value
);
1006 baton
= dwarf2_fetch_die_location_block (piece
->v
.ptr
.die
, c
->per_cu
,
1007 get_frame_address_in_block_wrapper
,
1010 result
= dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
1011 baton
.data
, baton
.size
, baton
.per_cu
,
1018 copy_pieced_value_closure (const struct value
*v
)
1020 struct piece_closure
*c
1021 = (struct piece_closure
*) value_computed_closure (v
);
1028 free_pieced_value_closure (struct value
*v
)
1030 struct piece_closure
*c
1031 = (struct piece_closure
*) value_computed_closure (v
);
1041 /* Functions for accessing a variable described by DW_OP_piece. */
1042 static struct lval_funcs pieced_value_funcs
= {
1045 check_pieced_value_validity
,
1046 check_pieced_value_invalid
,
1047 indirect_pieced_value
,
1048 check_pieced_synthetic_pointer
,
1049 copy_pieced_value_closure
,
1050 free_pieced_value_closure
1053 /* Helper function which throws an error if a synthetic pointer is
1057 invalid_synthetic_pointer (void)
1059 error (_("access outside bounds of object "
1060 "referenced via synthetic pointer"));
1063 /* Evaluate a location description, starting at DATA and with length
1064 SIZE, to find the current location of variable of TYPE in the
1065 context of FRAME. BYTE_OFFSET is applied after the contents are
1068 static struct value
*
1069 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
1070 const gdb_byte
*data
, unsigned short size
,
1071 struct dwarf2_per_cu_data
*per_cu
,
1072 LONGEST byte_offset
)
1074 struct value
*retval
;
1075 struct dwarf_expr_baton baton
;
1076 struct dwarf_expr_context
*ctx
;
1077 struct cleanup
*old_chain
;
1078 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
1080 if (byte_offset
< 0)
1081 invalid_synthetic_pointer ();
1085 retval
= allocate_value (type
);
1086 VALUE_LVAL (retval
) = not_lval
;
1087 set_value_optimized_out (retval
, 1);
1091 baton
.frame
= frame
;
1092 baton
.per_cu
= per_cu
;
1094 ctx
= new_dwarf_expr_context ();
1095 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
1097 ctx
->gdbarch
= get_objfile_arch (objfile
);
1098 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
1099 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
1100 ctx
->baton
= &baton
;
1101 ctx
->read_reg
= dwarf_expr_read_reg
;
1102 ctx
->read_mem
= dwarf_expr_read_mem
;
1103 ctx
->get_frame_base
= dwarf_expr_frame_base
;
1104 ctx
->get_frame_cfa
= dwarf_expr_frame_cfa
;
1105 ctx
->get_frame_pc
= dwarf_expr_frame_pc
;
1106 ctx
->get_tls_address
= dwarf_expr_tls_address
;
1107 ctx
->dwarf_call
= dwarf_expr_dwarf_call
;
1109 dwarf_expr_eval (ctx
, data
, size
);
1110 if (ctx
->num_pieces
> 0)
1112 struct piece_closure
*c
;
1113 struct frame_id frame_id
= get_frame_id (frame
);
1114 ULONGEST bit_size
= 0;
1117 for (i
= 0; i
< ctx
->num_pieces
; ++i
)
1118 bit_size
+= ctx
->pieces
[i
].size
;
1119 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
1120 invalid_synthetic_pointer ();
1122 c
= allocate_piece_closure (per_cu
, ctx
->num_pieces
, ctx
->pieces
,
1124 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
1125 VALUE_FRAME_ID (retval
) = frame_id
;
1126 set_value_offset (retval
, byte_offset
);
1130 switch (ctx
->location
)
1132 case DWARF_VALUE_REGISTER
:
1134 struct gdbarch
*arch
= get_frame_arch (frame
);
1135 ULONGEST dwarf_regnum
= dwarf_expr_fetch (ctx
, 0);
1136 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
1138 if (byte_offset
!= 0)
1139 error (_("cannot use offset on synthetic pointer to register"));
1140 if (gdb_regnum
!= -1)
1141 retval
= value_from_register (type
, gdb_regnum
, frame
);
1143 error (_("Unable to access DWARF register number %s"),
1144 paddress (arch
, dwarf_regnum
));
1148 case DWARF_VALUE_MEMORY
:
1150 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
1151 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
1153 retval
= allocate_value_lazy (type
);
1154 VALUE_LVAL (retval
) = lval_memory
;
1155 if (in_stack_memory
)
1156 set_value_stack (retval
, 1);
1157 set_value_address (retval
, address
+ byte_offset
);
1161 case DWARF_VALUE_STACK
:
1163 ULONGEST value
= dwarf_expr_fetch (ctx
, 0);
1164 bfd_byte
*contents
, *tem
;
1165 size_t n
= ctx
->addr_size
;
1167 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
1168 invalid_synthetic_pointer ();
1171 store_unsigned_integer (tem
, n
,
1172 gdbarch_byte_order (ctx
->gdbarch
),
1178 retval
= allocate_value (type
);
1179 contents
= value_contents_raw (retval
);
1180 if (n
> TYPE_LENGTH (type
))
1181 n
= TYPE_LENGTH (type
);
1182 memcpy (contents
, tem
, n
);
1186 case DWARF_VALUE_LITERAL
:
1189 const bfd_byte
*ldata
;
1190 size_t n
= ctx
->len
;
1192 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
1193 invalid_synthetic_pointer ();
1195 retval
= allocate_value (type
);
1196 contents
= value_contents_raw (retval
);
1198 ldata
= ctx
->data
+ byte_offset
;
1201 if (n
> TYPE_LENGTH (type
))
1202 n
= TYPE_LENGTH (type
);
1203 memcpy (contents
, ldata
, n
);
1207 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
1208 operation by execute_stack_op. */
1209 case DWARF_VALUE_IMPLICIT_POINTER
:
1210 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
1211 it can only be encountered when making a piece. */
1212 case DWARF_VALUE_OPTIMIZED_OUT
:
1214 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1218 set_value_initialized (retval
, ctx
->initialized
);
1220 do_cleanups (old_chain
);
1225 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
1226 passes 0 as the byte_offset. */
1229 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
1230 const gdb_byte
*data
, unsigned short size
,
1231 struct dwarf2_per_cu_data
*per_cu
)
1233 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
1237 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
1239 struct needs_frame_baton
1242 struct dwarf2_per_cu_data
*per_cu
;
1245 /* Reads from registers do require a frame. */
1247 needs_frame_read_reg (void *baton
, int regnum
)
1249 struct needs_frame_baton
*nf_baton
= baton
;
1251 nf_baton
->needs_frame
= 1;
1255 /* Reads from memory do not require a frame. */
1257 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
1259 memset (buf
, 0, len
);
1262 /* Frame-relative accesses do require a frame. */
1264 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
1266 static gdb_byte lit0
= DW_OP_lit0
;
1267 struct needs_frame_baton
*nf_baton
= baton
;
1272 nf_baton
->needs_frame
= 1;
1275 /* CFA accesses require a frame. */
1278 needs_frame_frame_cfa (void *baton
)
1280 struct needs_frame_baton
*nf_baton
= baton
;
1282 nf_baton
->needs_frame
= 1;
1286 /* Thread-local accesses do require a frame. */
1288 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
1290 struct needs_frame_baton
*nf_baton
= baton
;
1292 nf_baton
->needs_frame
= 1;
1296 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
1299 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, size_t die_offset
)
1301 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
1303 per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
,
1304 ctx
->get_frame_pc
, ctx
->baton
);
1307 /* Return non-zero iff the location expression at DATA (length SIZE)
1308 requires a frame to evaluate. */
1311 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, unsigned short size
,
1312 struct dwarf2_per_cu_data
*per_cu
)
1314 struct needs_frame_baton baton
;
1315 struct dwarf_expr_context
*ctx
;
1317 struct cleanup
*old_chain
;
1318 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
1320 baton
.needs_frame
= 0;
1321 baton
.per_cu
= per_cu
;
1323 ctx
= new_dwarf_expr_context ();
1324 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
1326 ctx
->gdbarch
= get_objfile_arch (objfile
);
1327 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
1328 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
1329 ctx
->baton
= &baton
;
1330 ctx
->read_reg
= needs_frame_read_reg
;
1331 ctx
->read_mem
= needs_frame_read_mem
;
1332 ctx
->get_frame_base
= needs_frame_frame_base
;
1333 ctx
->get_frame_cfa
= needs_frame_frame_cfa
;
1334 ctx
->get_frame_pc
= needs_frame_frame_cfa
;
1335 ctx
->get_tls_address
= needs_frame_tls_address
;
1336 ctx
->dwarf_call
= needs_frame_dwarf_call
;
1338 dwarf_expr_eval (ctx
, data
, size
);
1340 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
1342 if (ctx
->num_pieces
> 0)
1346 /* If the location has several pieces, and any of them are in
1347 registers, then we will need a frame to fetch them from. */
1348 for (i
= 0; i
< ctx
->num_pieces
; i
++)
1349 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
1353 do_cleanups (old_chain
);
1355 return baton
.needs_frame
|| in_reg
;
1358 /* A helper function that throws an unimplemented error mentioning a
1359 given DWARF operator. */
1362 unimplemented (unsigned int op
)
1364 const char *name
= dwarf_stack_op_name (op
);
1367 error (_("DWARF operator %s cannot be translated to an agent expression"),
1370 error (_("Unknown DWARF operator 0x%02x cannot be translated "
1371 "to an agent expression"),
1375 /* A helper function to convert a DWARF register to an arch register.
1376 ARCH is the architecture.
1377 DWARF_REG is the register.
1378 This will throw an exception if the DWARF register cannot be
1379 translated to an architecture register. */
1382 translate_register (struct gdbarch
*arch
, int dwarf_reg
)
1384 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
1386 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
1390 /* A helper function that emits an access to memory. ARCH is the
1391 target architecture. EXPR is the expression which we are building.
1392 NBITS is the number of bits we want to read. This emits the
1393 opcodes needed to read the memory and then extract the desired
1397 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
1399 ULONGEST nbytes
= (nbits
+ 7) / 8;
1401 gdb_assert (nbits
> 0 && nbits
<= sizeof (LONGEST
));
1404 ax_trace_quick (expr
, nbytes
);
1407 ax_simple (expr
, aop_ref8
);
1408 else if (nbits
<= 16)
1409 ax_simple (expr
, aop_ref16
);
1410 else if (nbits
<= 32)
1411 ax_simple (expr
, aop_ref32
);
1413 ax_simple (expr
, aop_ref64
);
1415 /* If we read exactly the number of bytes we wanted, we're done. */
1416 if (8 * nbytes
== nbits
)
1419 if (gdbarch_bits_big_endian (arch
))
1421 /* On a bits-big-endian machine, we want the high-order
1423 ax_const_l (expr
, 8 * nbytes
- nbits
);
1424 ax_simple (expr
, aop_rsh_unsigned
);
1428 /* On a bits-little-endian box, we want the low-order NBITS. */
1429 ax_zero_ext (expr
, nbits
);
1433 /* A helper function to return the frame's PC. */
1436 get_ax_pc (void *baton
)
1438 struct agent_expr
*expr
= baton
;
1443 /* Compile a DWARF location expression to an agent expression.
1445 EXPR is the agent expression we are building.
1446 LOC is the agent value we modify.
1447 ARCH is the architecture.
1448 ADDR_SIZE is the size of addresses, in bytes.
1449 OP_PTR is the start of the location expression.
1450 OP_END is one past the last byte of the location expression.
1452 This will throw an exception for various kinds of errors -- for
1453 example, if the expression cannot be compiled, or if the expression
1457 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
1458 struct gdbarch
*arch
, unsigned int addr_size
,
1459 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
1460 struct dwarf2_per_cu_data
*per_cu
)
1462 struct cleanup
*cleanups
;
1464 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
1465 const gdb_byte
* const base
= op_ptr
;
1466 const gdb_byte
*previous_piece
= op_ptr
;
1467 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
1468 ULONGEST bits_collected
= 0;
1469 unsigned int addr_size_bits
= 8 * addr_size
;
1470 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
1472 offsets
= xmalloc ((op_end
- op_ptr
) * sizeof (int));
1473 cleanups
= make_cleanup (xfree
, offsets
);
1475 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
1478 make_cleanup (VEC_cleanup (int), &dw_labels
);
1479 make_cleanup (VEC_cleanup (int), &patches
);
1481 /* By default we are making an address. */
1482 loc
->kind
= axs_lvalue_memory
;
1484 while (op_ptr
< op_end
)
1486 enum dwarf_location_atom op
= *op_ptr
;
1487 ULONGEST uoffset
, reg
;
1491 offsets
[op_ptr
- base
] = expr
->len
;
1494 /* Our basic approach to code generation is to map DWARF
1495 operations directly to AX operations. However, there are
1498 First, DWARF works on address-sized units, but AX always uses
1499 LONGEST. For most operations we simply ignore this
1500 difference; instead we generate sign extensions as needed
1501 before division and comparison operations. It would be nice
1502 to omit the sign extensions, but there is no way to determine
1503 the size of the target's LONGEST. (This code uses the size
1504 of the host LONGEST in some cases -- that is a bug but it is
1507 Second, some DWARF operations cannot be translated to AX.
1508 For these we simply fail. See
1509 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
1544 ax_const_l (expr
, op
- DW_OP_lit0
);
1548 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
1549 op_ptr
+= addr_size
;
1550 /* Some versions of GCC emit DW_OP_addr before
1551 DW_OP_GNU_push_tls_address. In this case the value is an
1552 index, not an address. We don't support things like
1553 branching between the address and the TLS op. */
1554 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
1555 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
1556 ax_const_l (expr
, uoffset
);
1560 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
1564 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
1568 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
1572 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
1576 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
1580 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
1584 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
1588 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
1592 op_ptr
= read_uleb128 (op_ptr
, op_end
, &uoffset
);
1593 ax_const_l (expr
, uoffset
);
1596 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1597 ax_const_l (expr
, offset
);
1632 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
1633 loc
->u
.reg
= translate_register (arch
, op
- DW_OP_reg0
);
1634 loc
->kind
= axs_lvalue_register
;
1638 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
1639 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
1640 loc
->u
.reg
= translate_register (arch
, reg
);
1641 loc
->kind
= axs_lvalue_register
;
1644 case DW_OP_implicit_value
:
1648 op_ptr
= read_uleb128 (op_ptr
, op_end
, &len
);
1649 if (op_ptr
+ len
> op_end
)
1650 error (_("DW_OP_implicit_value: too few bytes available."));
1651 if (len
> sizeof (ULONGEST
))
1652 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
1655 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
1658 dwarf_expr_require_composition (op_ptr
, op_end
,
1659 "DW_OP_implicit_value");
1661 loc
->kind
= axs_rvalue
;
1665 case DW_OP_stack_value
:
1666 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
1667 loc
->kind
= axs_rvalue
;
1702 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1703 i
= translate_register (arch
, op
- DW_OP_breg0
);
1707 ax_const_l (expr
, offset
);
1708 ax_simple (expr
, aop_add
);
1713 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
1714 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1715 i
= translate_register (arch
, reg
);
1719 ax_const_l (expr
, offset
);
1720 ax_simple (expr
, aop_add
);
1726 const gdb_byte
*datastart
;
1728 unsigned int before_stack_len
;
1730 struct symbol
*framefunc
;
1731 LONGEST base_offset
= 0;
1733 b
= block_for_pc (expr
->scope
);
1736 error (_("No block found for address"));
1738 framefunc
= block_linkage_function (b
);
1741 error (_("No function found for block"));
1743 dwarf_expr_frame_base_1 (framefunc
, expr
->scope
,
1744 &datastart
, &datalen
);
1746 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1747 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
1748 datastart
+ datalen
, per_cu
);
1752 ax_const_l (expr
, offset
);
1753 ax_simple (expr
, aop_add
);
1756 loc
->kind
= axs_lvalue_memory
;
1761 ax_simple (expr
, aop_dup
);
1765 ax_simple (expr
, aop_pop
);
1770 ax_pick (expr
, offset
);
1774 ax_simple (expr
, aop_swap
);
1782 ax_simple (expr
, aop_rot
);
1786 case DW_OP_deref_size
:
1790 if (op
== DW_OP_deref_size
)
1798 ax_simple (expr
, aop_ref8
);
1801 ax_simple (expr
, aop_ref16
);
1804 ax_simple (expr
, aop_ref32
);
1807 ax_simple (expr
, aop_ref64
);
1810 /* Note that dwarf_stack_op_name will never return
1812 error (_("Unsupported size %d in %s"),
1813 size
, dwarf_stack_op_name (op
));
1819 /* Sign extend the operand. */
1820 ax_ext (expr
, addr_size_bits
);
1821 ax_simple (expr
, aop_dup
);
1822 ax_const_l (expr
, 0);
1823 ax_simple (expr
, aop_less_signed
);
1824 ax_simple (expr
, aop_log_not
);
1825 i
= ax_goto (expr
, aop_if_goto
);
1826 /* We have to emit 0 - X. */
1827 ax_const_l (expr
, 0);
1828 ax_simple (expr
, aop_swap
);
1829 ax_simple (expr
, aop_sub
);
1830 ax_label (expr
, i
, expr
->len
);
1834 /* No need to sign extend here. */
1835 ax_const_l (expr
, 0);
1836 ax_simple (expr
, aop_swap
);
1837 ax_simple (expr
, aop_sub
);
1841 /* Sign extend the operand. */
1842 ax_ext (expr
, addr_size_bits
);
1843 ax_simple (expr
, aop_bit_not
);
1846 case DW_OP_plus_uconst
:
1847 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
1848 /* It would be really weird to emit `DW_OP_plus_uconst 0',
1849 but we micro-optimize anyhow. */
1852 ax_const_l (expr
, reg
);
1853 ax_simple (expr
, aop_add
);
1858 ax_simple (expr
, aop_bit_and
);
1862 /* Sign extend the operands. */
1863 ax_ext (expr
, addr_size_bits
);
1864 ax_simple (expr
, aop_swap
);
1865 ax_ext (expr
, addr_size_bits
);
1866 ax_simple (expr
, aop_swap
);
1867 ax_simple (expr
, aop_div_signed
);
1871 ax_simple (expr
, aop_sub
);
1875 ax_simple (expr
, aop_rem_unsigned
);
1879 ax_simple (expr
, aop_mul
);
1883 ax_simple (expr
, aop_bit_or
);
1887 ax_simple (expr
, aop_add
);
1891 ax_simple (expr
, aop_lsh
);
1895 ax_simple (expr
, aop_rsh_unsigned
);
1899 ax_simple (expr
, aop_rsh_signed
);
1903 ax_simple (expr
, aop_bit_xor
);
1907 /* Sign extend the operands. */
1908 ax_ext (expr
, addr_size_bits
);
1909 ax_simple (expr
, aop_swap
);
1910 ax_ext (expr
, addr_size_bits
);
1911 /* Note no swap here: A <= B is !(B < A). */
1912 ax_simple (expr
, aop_less_signed
);
1913 ax_simple (expr
, aop_log_not
);
1917 /* Sign extend the operands. */
1918 ax_ext (expr
, addr_size_bits
);
1919 ax_simple (expr
, aop_swap
);
1920 ax_ext (expr
, addr_size_bits
);
1921 ax_simple (expr
, aop_swap
);
1922 /* A >= B is !(A < B). */
1923 ax_simple (expr
, aop_less_signed
);
1924 ax_simple (expr
, aop_log_not
);
1928 /* Sign extend the operands. */
1929 ax_ext (expr
, addr_size_bits
);
1930 ax_simple (expr
, aop_swap
);
1931 ax_ext (expr
, addr_size_bits
);
1932 /* No need for a second swap here. */
1933 ax_simple (expr
, aop_equal
);
1937 /* Sign extend the operands. */
1938 ax_ext (expr
, addr_size_bits
);
1939 ax_simple (expr
, aop_swap
);
1940 ax_ext (expr
, addr_size_bits
);
1941 ax_simple (expr
, aop_swap
);
1942 ax_simple (expr
, aop_less_signed
);
1946 /* Sign extend the operands. */
1947 ax_ext (expr
, addr_size_bits
);
1948 ax_simple (expr
, aop_swap
);
1949 ax_ext (expr
, addr_size_bits
);
1950 /* Note no swap here: A > B is B < A. */
1951 ax_simple (expr
, aop_less_signed
);
1955 /* Sign extend the operands. */
1956 ax_ext (expr
, addr_size_bits
);
1957 ax_simple (expr
, aop_swap
);
1958 ax_ext (expr
, addr_size_bits
);
1959 /* No need for a swap here. */
1960 ax_simple (expr
, aop_equal
);
1961 ax_simple (expr
, aop_log_not
);
1964 case DW_OP_call_frame_cfa
:
1965 dwarf2_compile_cfa_to_ax (expr
, loc
, arch
, expr
->scope
, per_cu
);
1966 loc
->kind
= axs_lvalue_memory
;
1969 case DW_OP_GNU_push_tls_address
:
1974 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
1976 i
= ax_goto (expr
, aop_goto
);
1977 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
1978 VEC_safe_push (int, patches
, i
);
1982 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
1984 /* Zero extend the operand. */
1985 ax_zero_ext (expr
, addr_size_bits
);
1986 i
= ax_goto (expr
, aop_if_goto
);
1987 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
1988 VEC_safe_push (int, patches
, i
);
1995 case DW_OP_bit_piece
:
1997 ULONGEST size
, offset
;
1999 if (op_ptr
- 1 == previous_piece
)
2000 error (_("Cannot translate empty pieces to agent expressions"));
2001 previous_piece
= op_ptr
- 1;
2003 op_ptr
= read_uleb128 (op_ptr
, op_end
, &size
);
2004 if (op
== DW_OP_piece
)
2010 op_ptr
= read_uleb128 (op_ptr
, op_end
, &offset
);
2012 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
2013 error (_("Expression pieces exceed word size"));
2015 /* Access the bits. */
2018 case axs_lvalue_register
:
2019 ax_reg (expr
, loc
->u
.reg
);
2022 case axs_lvalue_memory
:
2023 /* Offset the pointer, if needed. */
2026 ax_const_l (expr
, offset
/ 8);
2027 ax_simple (expr
, aop_add
);
2030 access_memory (arch
, expr
, size
);
2034 /* For a bits-big-endian target, shift up what we already
2035 have. For a bits-little-endian target, shift up the
2036 new data. Note that there is a potential bug here if
2037 the DWARF expression leaves multiple values on the
2039 if (bits_collected
> 0)
2041 if (bits_big_endian
)
2043 ax_simple (expr
, aop_swap
);
2044 ax_const_l (expr
, size
);
2045 ax_simple (expr
, aop_lsh
);
2046 /* We don't need a second swap here, because
2047 aop_bit_or is symmetric. */
2051 ax_const_l (expr
, size
);
2052 ax_simple (expr
, aop_lsh
);
2054 ax_simple (expr
, aop_bit_or
);
2057 bits_collected
+= size
;
2058 loc
->kind
= axs_rvalue
;
2062 case DW_OP_GNU_uninit
:
2068 struct dwarf2_locexpr_baton block
;
2069 int size
= (op
== DW_OP_call2
? 2 : 4);
2071 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
2074 block
= dwarf2_fetch_die_location_block (uoffset
, per_cu
,
2077 /* DW_OP_call_ref is currently not supported. */
2078 gdb_assert (block
.per_cu
== per_cu
);
2080 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
2081 block
.data
, block
.data
+ block
.size
,
2086 case DW_OP_call_ref
:
2094 /* Patch all the branches we emitted. */
2095 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
2097 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
2099 internal_error (__FILE__
, __LINE__
, _("invalid label"));
2100 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
2103 do_cleanups (cleanups
);
2107 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
2108 evaluator to calculate the location. */
2109 static struct value
*
2110 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
2112 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2115 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
2116 dlbaton
->size
, dlbaton
->per_cu
);
2121 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
2123 locexpr_read_needs_frame (struct symbol
*symbol
)
2125 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2127 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
2131 /* Return true if DATA points to the end of a piece. END is one past
2132 the last byte in the expression. */
2135 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
2137 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
2140 /* Nicely describe a single piece of a location, returning an updated
2141 position in the bytecode sequence. This function cannot recognize
2142 all locations; if a location is not recognized, it simply returns
2145 static const gdb_byte
*
2146 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
2147 CORE_ADDR addr
, struct objfile
*objfile
,
2148 const gdb_byte
*data
, const gdb_byte
*end
,
2149 unsigned int addr_size
)
2151 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2154 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
2156 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, data
[0] - DW_OP_reg0
);
2157 fprintf_filtered (stream
, _("a variable in $%s"),
2158 gdbarch_register_name (gdbarch
, regno
));
2161 else if (data
[0] == DW_OP_regx
)
2165 data
= read_uleb128 (data
+ 1, end
, ®
);
2166 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
);
2167 fprintf_filtered (stream
, _("a variable in $%s"),
2168 gdbarch_register_name (gdbarch
, regno
));
2170 else if (data
[0] == DW_OP_fbreg
)
2173 struct symbol
*framefunc
;
2175 LONGEST frame_offset
;
2176 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
2178 LONGEST base_offset
= 0;
2180 new_data
= read_sleb128 (data
+ 1, end
, &frame_offset
);
2181 if (!piece_end_p (new_data
, end
))
2185 b
= block_for_pc (addr
);
2188 error (_("No block found for address for symbol \"%s\"."),
2189 SYMBOL_PRINT_NAME (symbol
));
2191 framefunc
= block_linkage_function (b
);
2194 error (_("No function found for block for symbol \"%s\"."),
2195 SYMBOL_PRINT_NAME (symbol
));
2197 dwarf_expr_frame_base_1 (framefunc
, addr
, &base_data
, &base_size
);
2199 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
2201 const gdb_byte
*buf_end
;
2203 frame_reg
= base_data
[0] - DW_OP_breg0
;
2204 buf_end
= read_sleb128 (base_data
+ 1,
2205 base_data
+ base_size
, &base_offset
);
2206 if (buf_end
!= base_data
+ base_size
)
2207 error (_("Unexpected opcode after "
2208 "DW_OP_breg%u for symbol \"%s\"."),
2209 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
2211 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
2213 /* The frame base is just the register, with no offset. */
2214 frame_reg
= base_data
[0] - DW_OP_reg0
;
2219 /* We don't know what to do with the frame base expression,
2220 so we can't trace this variable; give up. */
2224 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, frame_reg
);
2226 fprintf_filtered (stream
,
2227 _("a variable at frame base reg $%s offset %s+%s"),
2228 gdbarch_register_name (gdbarch
, regno
),
2229 plongest (base_offset
), plongest (frame_offset
));
2231 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
2232 && piece_end_p (data
, end
))
2236 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, data
[0] - DW_OP_breg0
);
2238 data
= read_sleb128 (data
+ 1, end
, &offset
);
2240 fprintf_filtered (stream
,
2241 _("a variable at offset %s from base reg $%s"),
2243 gdbarch_register_name (gdbarch
, regno
));
2246 /* The location expression for a TLS variable looks like this (on a
2249 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
2250 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
2252 0x3 is the encoding for DW_OP_addr, which has an operand as long
2253 as the size of an address on the target machine (here is 8
2254 bytes). Note that more recent version of GCC emit DW_OP_const4u
2255 or DW_OP_const8u, depending on address size, rather than
2256 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
2257 The operand represents the offset at which the variable is within
2258 the thread local storage. */
2260 else if (data
+ 1 + addr_size
< end
2261 && (data
[0] == DW_OP_addr
2262 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
2263 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
2264 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
2265 && piece_end_p (data
+ 2 + addr_size
, end
))
2268 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
2269 gdbarch_byte_order (gdbarch
));
2271 fprintf_filtered (stream
,
2272 _("a thread-local variable at offset 0x%s "
2273 "in the thread-local storage for `%s'"),
2274 phex_nz (offset
, addr_size
), objfile
->name
);
2276 data
+= 1 + addr_size
+ 1;
2278 else if (data
[0] >= DW_OP_lit0
2279 && data
[0] <= DW_OP_lit31
2281 && data
[1] == DW_OP_stack_value
)
2283 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
2290 /* Disassemble an expression, stopping at the end of a piece or at the
2291 end of the expression. Returns a pointer to the next unread byte
2292 in the input expression. If ALL is nonzero, then this function
2293 will keep going until it reaches the end of the expression. */
2295 static const gdb_byte
*
2296 disassemble_dwarf_expression (struct ui_file
*stream
,
2297 struct gdbarch
*arch
, unsigned int addr_size
,
2299 const gdb_byte
*data
, const gdb_byte
*end
,
2302 const gdb_byte
*start
= data
;
2304 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
2308 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
2310 enum dwarf_location_atom op
= *data
++;
2315 name
= dwarf_stack_op_name (op
);
2318 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
2319 op
, (long) (data
- start
));
2320 fprintf_filtered (stream
, " % 4ld: %s", (long) (data
- start
), name
);
2325 ul
= extract_unsigned_integer (data
, addr_size
,
2326 gdbarch_byte_order (arch
));
2328 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
2332 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
2334 fprintf_filtered (stream
, " %s", pulongest (ul
));
2337 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
2339 fprintf_filtered (stream
, " %s", plongest (l
));
2342 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
2344 fprintf_filtered (stream
, " %s", pulongest (ul
));
2347 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
2349 fprintf_filtered (stream
, " %s", plongest (l
));
2352 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
2354 fprintf_filtered (stream
, " %s", pulongest (ul
));
2357 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
2359 fprintf_filtered (stream
, " %s", plongest (l
));
2362 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
2364 fprintf_filtered (stream
, " %s", pulongest (ul
));
2367 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
2369 fprintf_filtered (stream
, " %s", plongest (l
));
2372 data
= read_uleb128 (data
, end
, &ul
);
2373 fprintf_filtered (stream
, " %s", pulongest (ul
));
2376 data
= read_sleb128 (data
, end
, &l
);
2377 fprintf_filtered (stream
, " %s", plongest (l
));
2412 fprintf_filtered (stream
, " [$%s]",
2413 gdbarch_register_name (arch
, op
- DW_OP_reg0
));
2417 data
= read_uleb128 (data
, end
, &ul
);
2418 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
2419 gdbarch_register_name (arch
, (int) ul
));
2422 case DW_OP_implicit_value
:
2423 data
= read_uleb128 (data
, end
, &ul
);
2425 fprintf_filtered (stream
, " %s", pulongest (ul
));
2460 data
= read_sleb128 (data
, end
, &l
);
2461 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
2462 gdbarch_register_name (arch
, op
- DW_OP_breg0
));
2466 data
= read_uleb128 (data
, end
, &ul
);
2467 data
= read_sleb128 (data
, end
, &l
);
2468 fprintf_filtered (stream
, " register %s [$%s] offset %s",
2470 gdbarch_register_name (arch
, (int) ul
),
2475 data
= read_sleb128 (data
, end
, &l
);
2476 fprintf_filtered (stream
, " %s", plongest (l
));
2479 case DW_OP_xderef_size
:
2480 case DW_OP_deref_size
:
2482 fprintf_filtered (stream
, " %d", *data
);
2486 case DW_OP_plus_uconst
:
2487 data
= read_uleb128 (data
, end
, &ul
);
2488 fprintf_filtered (stream
, " %s", pulongest (ul
));
2492 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
2494 fprintf_filtered (stream
, " to %ld",
2495 (long) (data
+ l
- start
));
2499 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
2501 fprintf_filtered (stream
, " %ld",
2502 (long) (data
+ l
- start
));
2506 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
2508 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
2512 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
2514 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
2517 case DW_OP_call_ref
:
2518 ul
= extract_unsigned_integer (data
, offset_size
,
2519 gdbarch_byte_order (arch
));
2520 data
+= offset_size
;
2521 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
2525 data
= read_uleb128 (data
, end
, &ul
);
2526 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
2529 case DW_OP_bit_piece
:
2533 data
= read_uleb128 (data
, end
, &ul
);
2534 data
= read_uleb128 (data
, end
, &offset
);
2535 fprintf_filtered (stream
, " size %s offset %s (bits)",
2536 pulongest (ul
), pulongest (offset
));
2540 case DW_OP_GNU_implicit_pointer
:
2542 ul
= extract_unsigned_integer (data
, offset_size
,
2543 gdbarch_byte_order (arch
));
2544 data
+= offset_size
;
2546 data
= read_sleb128 (data
, end
, &l
);
2548 fprintf_filtered (stream
, " DIE %s offset %s",
2549 phex_nz (ul
, offset_size
),
2555 fprintf_filtered (stream
, "\n");
2561 /* Describe a single location, which may in turn consist of multiple
2565 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
2566 struct ui_file
*stream
,
2567 const gdb_byte
*data
, int size
,
2568 struct objfile
*objfile
, unsigned int addr_size
,
2571 const gdb_byte
*end
= data
+ size
;
2572 int first_piece
= 1, bad
= 0;
2576 const gdb_byte
*here
= data
;
2577 int disassemble
= 1;
2582 fprintf_filtered (stream
, _(", and "));
2584 if (!dwarf2_always_disassemble
)
2586 data
= locexpr_describe_location_piece (symbol
, stream
,
2588 data
, end
, addr_size
);
2589 /* If we printed anything, or if we have an empty piece,
2590 then don't disassemble. */
2592 || data
[0] == DW_OP_piece
2593 || data
[0] == DW_OP_bit_piece
)
2597 data
= disassemble_dwarf_expression (stream
,
2598 get_objfile_arch (objfile
),
2599 addr_size
, offset_size
, data
, end
,
2600 dwarf2_always_disassemble
);
2604 int empty
= data
== here
;
2607 fprintf_filtered (stream
, " ");
2608 if (data
[0] == DW_OP_piece
)
2612 data
= read_uleb128 (data
+ 1, end
, &bytes
);
2615 fprintf_filtered (stream
, _("an empty %s-byte piece"),
2618 fprintf_filtered (stream
, _(" [%s-byte piece]"),
2621 else if (data
[0] == DW_OP_bit_piece
)
2623 ULONGEST bits
, offset
;
2625 data
= read_uleb128 (data
+ 1, end
, &bits
);
2626 data
= read_uleb128 (data
, end
, &offset
);
2629 fprintf_filtered (stream
,
2630 _("an empty %s-bit piece"),
2633 fprintf_filtered (stream
,
2634 _(" [%s-bit piece, offset %s bits]"),
2635 pulongest (bits
), pulongest (offset
));
2645 if (bad
|| data
> end
)
2646 error (_("Corrupted DWARF2 expression for \"%s\"."),
2647 SYMBOL_PRINT_NAME (symbol
));
2650 /* Print a natural-language description of SYMBOL to STREAM. This
2651 version is for a symbol with a single location. */
2654 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
2655 struct ui_file
*stream
)
2657 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2658 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2659 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2660 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
2662 locexpr_describe_location_1 (symbol
, addr
, stream
,
2663 dlbaton
->data
, dlbaton
->size
,
2664 objfile
, addr_size
, offset_size
);
2667 /* Describe the location of SYMBOL as an agent value in VALUE, generating
2668 any necessary bytecode in AX. */
2671 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
2672 struct agent_expr
*ax
, struct axs_value
*value
)
2674 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2675 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2677 if (dlbaton
->data
== NULL
|| dlbaton
->size
== 0)
2678 value
->optimized_out
= 1;
2680 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
2681 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
2685 /* The set of location functions used with the DWARF-2 expression
2687 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
2688 locexpr_read_variable
,
2689 locexpr_read_needs_frame
,
2690 locexpr_describe_location
,
2691 locexpr_tracepoint_var_ref
2695 /* Wrapper functions for location lists. These generally find
2696 the appropriate location expression and call something above. */
2698 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
2699 evaluator to calculate the location. */
2700 static struct value
*
2701 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
2703 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2705 const gdb_byte
*data
;
2707 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
2709 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
2712 val
= allocate_value (SYMBOL_TYPE (symbol
));
2713 VALUE_LVAL (val
) = not_lval
;
2714 set_value_optimized_out (val
, 1);
2717 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
2723 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
2725 loclist_read_needs_frame (struct symbol
*symbol
)
2727 /* If there's a location list, then assume we need to have a frame
2728 to choose the appropriate location expression. With tracking of
2729 global variables this is not necessarily true, but such tracking
2730 is disabled in GCC at the moment until we figure out how to
2736 /* Print a natural-language description of SYMBOL to STREAM. This
2737 version applies when there is a list of different locations, each
2738 with a specified address range. */
2741 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
2742 struct ui_file
*stream
)
2744 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2745 CORE_ADDR low
, high
;
2746 const gdb_byte
*loc_ptr
, *buf_end
;
2747 int length
, first
= 1;
2748 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2749 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2750 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2751 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2752 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
2753 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
2754 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
2755 /* Adjust base_address for relocatable objects. */
2756 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
2757 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
2759 loc_ptr
= dlbaton
->data
;
2760 buf_end
= dlbaton
->data
+ dlbaton
->size
;
2762 fprintf_filtered (stream
, _("multi-location:\n"));
2764 /* Iterate through locations until we run out. */
2767 if (buf_end
- loc_ptr
< 2 * addr_size
)
2768 error (_("Corrupted DWARF expression for symbol \"%s\"."),
2769 SYMBOL_PRINT_NAME (symbol
));
2772 low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
2774 low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
2775 loc_ptr
+= addr_size
;
2778 high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
2780 high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
2781 loc_ptr
+= addr_size
;
2783 /* A base-address-selection entry. */
2784 if ((low
& base_mask
) == base_mask
)
2786 base_address
= high
+ base_offset
;
2787 fprintf_filtered (stream
, _(" Base address %s"),
2788 paddress (gdbarch
, base_address
));
2792 /* An end-of-list entry. */
2793 if (low
== 0 && high
== 0)
2796 /* Otherwise, a location expression entry. */
2797 low
+= base_address
;
2798 high
+= base_address
;
2800 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
2803 /* (It would improve readability to print only the minimum
2804 necessary digits of the second number of the range.) */
2805 fprintf_filtered (stream
, _(" Range %s-%s: "),
2806 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
2808 /* Now describe this particular location. */
2809 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
2810 objfile
, addr_size
, offset_size
);
2812 fprintf_filtered (stream
, "\n");
2818 /* Describe the location of SYMBOL as an agent value in VALUE, generating
2819 any necessary bytecode in AX. */
2821 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
2822 struct agent_expr
*ax
, struct axs_value
*value
)
2824 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2825 const gdb_byte
*data
;
2827 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2829 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
2830 if (data
== NULL
|| size
== 0)
2831 value
->optimized_out
= 1;
2833 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
2837 /* The set of location functions used with the DWARF-2 expression
2838 evaluator and location lists. */
2839 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
2840 loclist_read_variable
,
2841 loclist_read_needs_frame
,
2842 loclist_describe_location
,
2843 loclist_tracepoint_var_ref