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
);
289 /* Callback function for dwarf2_evaluate_loc_desc. */
292 dwarf_expr_get_base_type (struct dwarf_expr_context
*ctx
, size_t die_offset
)
294 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
296 return dwarf2_get_die_type (die_offset
, debaton
->per_cu
);
301 /* Reference count. */
304 /* The CU from which this closure's expression came. */
305 struct dwarf2_per_cu_data
*per_cu
;
307 /* The number of pieces used to describe this variable. */
310 /* The target address size, used only for DWARF_VALUE_STACK. */
313 /* The pieces themselves. */
314 struct dwarf_expr_piece
*pieces
;
317 /* Allocate a closure for a value formed from separately-described
320 static struct piece_closure
*
321 allocate_piece_closure (struct dwarf2_per_cu_data
*per_cu
,
322 int n_pieces
, struct dwarf_expr_piece
*pieces
,
325 struct piece_closure
*c
= XZALLOC (struct piece_closure
);
330 c
->n_pieces
= n_pieces
;
331 c
->addr_size
= addr_size
;
332 c
->pieces
= XCALLOC (n_pieces
, struct dwarf_expr_piece
);
334 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
335 for (i
= 0; i
< n_pieces
; ++i
)
336 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
337 value_incref (c
->pieces
[i
].v
.value
);
342 /* The lowest-level function to extract bits from a byte buffer.
343 SOURCE is the buffer. It is updated if we read to the end of a
345 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
346 updated to reflect the number of bits actually read.
347 NBITS is the number of bits we want to read. It is updated to
348 reflect the number of bits actually read. This function may read
350 BITS_BIG_ENDIAN is taken directly from gdbarch.
351 This function returns the extracted bits. */
354 extract_bits_primitive (const gdb_byte
**source
,
355 unsigned int *source_offset_bits
,
356 int *nbits
, int bits_big_endian
)
358 unsigned int avail
, mask
, datum
;
360 gdb_assert (*source_offset_bits
< 8);
362 avail
= 8 - *source_offset_bits
;
366 mask
= (1 << avail
) - 1;
369 datum
>>= 8 - (*source_offset_bits
+ *nbits
);
371 datum
>>= *source_offset_bits
;
375 *source_offset_bits
+= avail
;
376 if (*source_offset_bits
>= 8)
378 *source_offset_bits
-= 8;
385 /* Extract some bits from a source buffer and move forward in the
388 SOURCE is the source buffer. It is updated as bytes are read.
389 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
391 NBITS is the number of bits to read.
392 BITS_BIG_ENDIAN is taken directly from gdbarch.
394 This function returns the bits that were read. */
397 extract_bits (const gdb_byte
**source
, unsigned int *source_offset_bits
,
398 int nbits
, int bits_big_endian
)
402 gdb_assert (nbits
> 0 && nbits
<= 8);
404 datum
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
410 more
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
422 /* Write some bits into a buffer and move forward in the buffer.
424 DATUM is the bits to write. The low-order bits of DATUM are used.
425 DEST is the destination buffer. It is updated as bytes are
427 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
429 NBITS is the number of valid bits in DATUM.
430 BITS_BIG_ENDIAN is taken directly from gdbarch. */
433 insert_bits (unsigned int datum
,
434 gdb_byte
*dest
, unsigned int dest_offset_bits
,
435 int nbits
, int bits_big_endian
)
439 gdb_assert (dest_offset_bits
+ nbits
<= 8);
441 mask
= (1 << nbits
) - 1;
444 datum
<<= 8 - (dest_offset_bits
+ nbits
);
445 mask
<<= 8 - (dest_offset_bits
+ nbits
);
449 datum
<<= dest_offset_bits
;
450 mask
<<= dest_offset_bits
;
453 gdb_assert ((datum
& ~mask
) == 0);
455 *dest
= (*dest
& ~mask
) | datum
;
458 /* Copy bits from a source to a destination.
460 DEST is where the bits should be written.
461 DEST_OFFSET_BITS is the bit offset into DEST.
462 SOURCE is the source of bits.
463 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
464 BIT_COUNT is the number of bits to copy.
465 BITS_BIG_ENDIAN is taken directly from gdbarch. */
468 copy_bitwise (gdb_byte
*dest
, unsigned int dest_offset_bits
,
469 const gdb_byte
*source
, unsigned int source_offset_bits
,
470 unsigned int bit_count
,
473 unsigned int dest_avail
;
476 /* Reduce everything to byte-size pieces. */
477 dest
+= dest_offset_bits
/ 8;
478 dest_offset_bits
%= 8;
479 source
+= source_offset_bits
/ 8;
480 source_offset_bits
%= 8;
482 dest_avail
= 8 - dest_offset_bits
% 8;
484 /* See if we can fill the first destination byte. */
485 if (dest_avail
< bit_count
)
487 datum
= extract_bits (&source
, &source_offset_bits
, dest_avail
,
489 insert_bits (datum
, dest
, dest_offset_bits
, dest_avail
, bits_big_endian
);
491 dest_offset_bits
= 0;
492 bit_count
-= dest_avail
;
495 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
496 than 8 bits remaining. */
497 gdb_assert (dest_offset_bits
% 8 == 0 || bit_count
< 8);
498 for (; bit_count
>= 8; bit_count
-= 8)
500 datum
= extract_bits (&source
, &source_offset_bits
, 8, bits_big_endian
);
501 *dest
++ = (gdb_byte
) datum
;
504 /* Finally, we may have a few leftover bits. */
505 gdb_assert (bit_count
<= 8 - dest_offset_bits
% 8);
508 datum
= extract_bits (&source
, &source_offset_bits
, bit_count
,
510 insert_bits (datum
, dest
, dest_offset_bits
, bit_count
, bits_big_endian
);
515 read_pieced_value (struct value
*v
)
519 ULONGEST bits_to_skip
;
521 struct piece_closure
*c
522 = (struct piece_closure
*) value_computed_closure (v
);
523 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (v
));
525 size_t buffer_size
= 0;
527 struct cleanup
*cleanup
;
529 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
531 if (value_type (v
) != value_enclosing_type (v
))
532 internal_error (__FILE__
, __LINE__
,
533 _("Should not be able to create a lazy value with "
534 "an enclosing type"));
536 cleanup
= make_cleanup (free_current_contents
, &buffer
);
538 contents
= value_contents_raw (v
);
539 bits_to_skip
= 8 * value_offset (v
);
540 if (value_bitsize (v
))
542 bits_to_skip
+= value_bitpos (v
);
543 type_len
= value_bitsize (v
);
546 type_len
= 8 * TYPE_LENGTH (value_type (v
));
548 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
550 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
551 size_t this_size
, this_size_bits
;
552 long dest_offset_bits
, source_offset_bits
, source_offset
;
553 const gdb_byte
*intermediate_buffer
;
555 /* Compute size, source, and destination offsets for copying, in
557 this_size_bits
= p
->size
;
558 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
560 bits_to_skip
-= this_size_bits
;
563 if (this_size_bits
> type_len
- offset
)
564 this_size_bits
= type_len
- offset
;
565 if (bits_to_skip
> 0)
567 dest_offset_bits
= 0;
568 source_offset_bits
= bits_to_skip
;
569 this_size_bits
-= bits_to_skip
;
574 dest_offset_bits
= offset
;
575 source_offset_bits
= 0;
578 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
579 source_offset
= source_offset_bits
/ 8;
580 if (buffer_size
< this_size
)
582 buffer_size
= this_size
;
583 buffer
= xrealloc (buffer
, buffer_size
);
585 intermediate_buffer
= buffer
;
587 /* Copy from the source to DEST_BUFFER. */
590 case DWARF_VALUE_REGISTER
:
592 struct gdbarch
*arch
= get_frame_arch (frame
);
593 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
594 int reg_offset
= source_offset
;
596 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
597 && this_size
< register_size (arch
, gdb_regnum
))
599 /* Big-endian, and we want less than full size. */
600 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
601 /* We want the lower-order THIS_SIZE_BITS of the bytes
602 we extract from the register. */
603 source_offset_bits
+= 8 * this_size
- this_size_bits
;
606 if (gdb_regnum
!= -1)
610 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
614 /* Just so garbage doesn't ever shine through. */
615 memset (buffer
, 0, this_size
);
618 set_value_optimized_out (v
, 1);
620 mark_value_bytes_unavailable (v
, offset
, this_size
);
625 error (_("Unable to access DWARF register number %s"),
626 paddress (arch
, p
->v
.regno
));
631 case DWARF_VALUE_MEMORY
:
632 read_value_memory (v
, offset
,
633 p
->v
.mem
.in_stack_memory
,
634 p
->v
.mem
.addr
+ source_offset
,
638 case DWARF_VALUE_STACK
:
640 size_t n
= this_size
;
642 if (n
> c
->addr_size
- source_offset
)
643 n
= (c
->addr_size
>= source_offset
644 ? c
->addr_size
- source_offset
652 const gdb_byte
*val_bytes
= value_contents_all (p
->v
.value
);
654 intermediate_buffer
= val_bytes
+ source_offset
;
659 case DWARF_VALUE_LITERAL
:
661 size_t n
= this_size
;
663 if (n
> p
->v
.literal
.length
- source_offset
)
664 n
= (p
->v
.literal
.length
>= source_offset
665 ? p
->v
.literal
.length
- source_offset
668 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
672 /* These bits show up as zeros -- but do not cause the value
673 to be considered optimized-out. */
674 case DWARF_VALUE_IMPLICIT_POINTER
:
677 case DWARF_VALUE_OPTIMIZED_OUT
:
678 set_value_optimized_out (v
, 1);
682 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
685 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
686 && p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
687 copy_bitwise (contents
, dest_offset_bits
,
688 intermediate_buffer
, source_offset_bits
% 8,
689 this_size_bits
, bits_big_endian
);
691 offset
+= this_size_bits
;
694 do_cleanups (cleanup
);
698 write_pieced_value (struct value
*to
, struct value
*from
)
702 ULONGEST bits_to_skip
;
703 const gdb_byte
*contents
;
704 struct piece_closure
*c
705 = (struct piece_closure
*) value_computed_closure (to
);
706 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
708 size_t buffer_size
= 0;
710 struct cleanup
*cleanup
;
712 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
716 set_value_optimized_out (to
, 1);
720 cleanup
= make_cleanup (free_current_contents
, &buffer
);
722 contents
= value_contents (from
);
723 bits_to_skip
= 8 * value_offset (to
);
724 if (value_bitsize (to
))
726 bits_to_skip
+= value_bitpos (to
);
727 type_len
= value_bitsize (to
);
730 type_len
= 8 * TYPE_LENGTH (value_type (to
));
732 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
734 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
735 size_t this_size_bits
, this_size
;
736 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
738 const gdb_byte
*source_buffer
;
740 this_size_bits
= p
->size
;
741 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
743 bits_to_skip
-= this_size_bits
;
746 if (this_size_bits
> type_len
- offset
)
747 this_size_bits
= type_len
- offset
;
748 if (bits_to_skip
> 0)
750 dest_offset_bits
= bits_to_skip
;
751 source_offset_bits
= 0;
752 this_size_bits
-= bits_to_skip
;
757 dest_offset_bits
= 0;
758 source_offset_bits
= offset
;
761 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
762 source_offset
= source_offset_bits
/ 8;
763 dest_offset
= dest_offset_bits
/ 8;
764 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
766 source_buffer
= contents
+ source_offset
;
771 if (buffer_size
< this_size
)
773 buffer_size
= this_size
;
774 buffer
= xrealloc (buffer
, buffer_size
);
776 source_buffer
= buffer
;
782 case DWARF_VALUE_REGISTER
:
784 struct gdbarch
*arch
= get_frame_arch (frame
);
785 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.regno
);
786 int reg_offset
= dest_offset
;
788 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
789 && this_size
<= register_size (arch
, gdb_regnum
))
790 /* Big-endian, and we want less than full size. */
791 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
793 if (gdb_regnum
!= -1)
799 if (!get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
804 error (_("Can't do read-modify-write to "
805 "update bitfield; containing word has been "
808 throw_error (NOT_AVAILABLE_ERROR
,
809 _("Can't do read-modify-write to update "
810 "bitfield; containing word "
813 copy_bitwise (buffer
, dest_offset_bits
,
814 contents
, source_offset_bits
,
819 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
820 this_size
, source_buffer
);
824 error (_("Unable to write to DWARF register number %s"),
825 paddress (arch
, p
->v
.regno
));
829 case DWARF_VALUE_MEMORY
:
832 /* Only the first and last bytes can possibly have any
834 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
, 1);
835 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
836 buffer
+ this_size
- 1, 1);
837 copy_bitwise (buffer
, dest_offset_bits
,
838 contents
, source_offset_bits
,
843 write_memory (p
->v
.mem
.addr
+ dest_offset
,
844 source_buffer
, this_size
);
847 set_value_optimized_out (to
, 1);
850 offset
+= this_size_bits
;
853 do_cleanups (cleanup
);
856 /* A helper function that checks bit validity in a pieced value.
857 CHECK_FOR indicates the kind of validity checking.
858 DWARF_VALUE_MEMORY means to check whether any bit is valid.
859 DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
861 DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
865 check_pieced_value_bits (const struct value
*value
, int bit_offset
,
867 enum dwarf_value_location check_for
)
869 struct piece_closure
*c
870 = (struct piece_closure
*) value_computed_closure (value
);
872 int validity
= (check_for
== DWARF_VALUE_MEMORY
873 || check_for
== DWARF_VALUE_IMPLICIT_POINTER
);
875 bit_offset
+= 8 * value_offset (value
);
876 if (value_bitsize (value
))
877 bit_offset
+= value_bitpos (value
);
879 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
881 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
882 size_t this_size_bits
= p
->size
;
886 if (bit_offset
>= this_size_bits
)
888 bit_offset
-= this_size_bits
;
892 bit_length
-= this_size_bits
- bit_offset
;
896 bit_length
-= this_size_bits
;
898 if (check_for
== DWARF_VALUE_IMPLICIT_POINTER
)
900 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
903 else if (p
->location
== DWARF_VALUE_OPTIMIZED_OUT
904 || p
->location
== DWARF_VALUE_IMPLICIT_POINTER
)
920 check_pieced_value_validity (const struct value
*value
, int bit_offset
,
923 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
928 check_pieced_value_invalid (const struct value
*value
)
930 return check_pieced_value_bits (value
, 0,
931 8 * TYPE_LENGTH (value_type (value
)),
932 DWARF_VALUE_OPTIMIZED_OUT
);
935 /* An implementation of an lval_funcs method to see whether a value is
936 a synthetic pointer. */
939 check_pieced_synthetic_pointer (const struct value
*value
, int bit_offset
,
942 return check_pieced_value_bits (value
, bit_offset
, bit_length
,
943 DWARF_VALUE_IMPLICIT_POINTER
);
946 /* A wrapper function for get_frame_address_in_block. */
949 get_frame_address_in_block_wrapper (void *baton
)
951 return get_frame_address_in_block (baton
);
954 /* An implementation of an lval_funcs method to indirect through a
955 pointer. This handles the synthetic pointer case when needed. */
957 static struct value
*
958 indirect_pieced_value (struct value
*value
)
960 struct piece_closure
*c
961 = (struct piece_closure
*) value_computed_closure (value
);
963 struct frame_info
*frame
;
964 struct dwarf2_locexpr_baton baton
;
965 int i
, bit_offset
, bit_length
;
966 struct dwarf_expr_piece
*piece
= NULL
;
967 struct value
*result
;
970 type
= value_type (value
);
971 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
974 bit_length
= 8 * TYPE_LENGTH (type
);
975 bit_offset
= 8 * value_offset (value
);
976 if (value_bitsize (value
))
977 bit_offset
+= value_bitpos (value
);
979 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
981 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
982 size_t this_size_bits
= p
->size
;
986 if (bit_offset
>= this_size_bits
)
988 bit_offset
-= this_size_bits
;
992 bit_length
-= this_size_bits
- bit_offset
;
996 bit_length
-= this_size_bits
;
998 if (p
->location
!= DWARF_VALUE_IMPLICIT_POINTER
)
1001 if (bit_length
!= 0)
1002 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
1008 frame
= get_selected_frame (_("No frame selected."));
1009 byte_offset
= value_as_address (value
);
1012 baton
= dwarf2_fetch_die_location_block (piece
->v
.ptr
.die
, c
->per_cu
,
1013 get_frame_address_in_block_wrapper
,
1016 result
= dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type
), frame
,
1017 baton
.data
, baton
.size
, baton
.per_cu
,
1024 copy_pieced_value_closure (const struct value
*v
)
1026 struct piece_closure
*c
1027 = (struct piece_closure
*) value_computed_closure (v
);
1034 free_pieced_value_closure (struct value
*v
)
1036 struct piece_closure
*c
1037 = (struct piece_closure
*) value_computed_closure (v
);
1044 for (i
= 0; i
< c
->n_pieces
; ++i
)
1045 if (c
->pieces
[i
].location
== DWARF_VALUE_STACK
)
1046 value_free (c
->pieces
[i
].v
.value
);
1053 /* Functions for accessing a variable described by DW_OP_piece. */
1054 static struct lval_funcs pieced_value_funcs
= {
1057 check_pieced_value_validity
,
1058 check_pieced_value_invalid
,
1059 indirect_pieced_value
,
1060 check_pieced_synthetic_pointer
,
1061 copy_pieced_value_closure
,
1062 free_pieced_value_closure
1065 /* Helper function which throws an error if a synthetic pointer is
1069 invalid_synthetic_pointer (void)
1071 error (_("access outside bounds of object "
1072 "referenced via synthetic pointer"));
1075 /* Evaluate a location description, starting at DATA and with length
1076 SIZE, to find the current location of variable of TYPE in the
1077 context of FRAME. BYTE_OFFSET is applied after the contents are
1080 static struct value
*
1081 dwarf2_evaluate_loc_desc_full (struct type
*type
, struct frame_info
*frame
,
1082 const gdb_byte
*data
, unsigned short size
,
1083 struct dwarf2_per_cu_data
*per_cu
,
1084 LONGEST byte_offset
)
1086 struct value
*retval
;
1087 struct dwarf_expr_baton baton
;
1088 struct dwarf_expr_context
*ctx
;
1089 struct cleanup
*old_chain
, *value_chain
;
1090 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
1091 volatile struct gdb_exception ex
;
1093 if (byte_offset
< 0)
1094 invalid_synthetic_pointer ();
1098 retval
= allocate_value (type
);
1099 VALUE_LVAL (retval
) = not_lval
;
1100 set_value_optimized_out (retval
, 1);
1104 baton
.frame
= frame
;
1105 baton
.per_cu
= per_cu
;
1107 ctx
= new_dwarf_expr_context ();
1108 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
1109 value_chain
= make_cleanup_value_free_to_mark (value_mark ());
1111 ctx
->gdbarch
= get_objfile_arch (objfile
);
1112 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
1113 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
1114 ctx
->baton
= &baton
;
1115 ctx
->read_reg
= dwarf_expr_read_reg
;
1116 ctx
->read_mem
= dwarf_expr_read_mem
;
1117 ctx
->get_frame_base
= dwarf_expr_frame_base
;
1118 ctx
->get_frame_cfa
= dwarf_expr_frame_cfa
;
1119 ctx
->get_frame_pc
= dwarf_expr_frame_pc
;
1120 ctx
->get_tls_address
= dwarf_expr_tls_address
;
1121 ctx
->dwarf_call
= dwarf_expr_dwarf_call
;
1122 ctx
->get_base_type
= dwarf_expr_get_base_type
;
1124 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
1126 dwarf_expr_eval (ctx
, data
, size
);
1130 if (ex
.error
== NOT_AVAILABLE_ERROR
)
1132 do_cleanups (old_chain
);
1133 retval
= allocate_value (type
);
1134 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (type
));
1138 throw_exception (ex
);
1141 if (ctx
->num_pieces
> 0)
1143 struct piece_closure
*c
;
1144 struct frame_id frame_id
= get_frame_id (frame
);
1145 ULONGEST bit_size
= 0;
1148 for (i
= 0; i
< ctx
->num_pieces
; ++i
)
1149 bit_size
+= ctx
->pieces
[i
].size
;
1150 if (8 * (byte_offset
+ TYPE_LENGTH (type
)) > bit_size
)
1151 invalid_synthetic_pointer ();
1153 c
= allocate_piece_closure (per_cu
, ctx
->num_pieces
, ctx
->pieces
,
1155 /* We must clean up the value chain after creating the piece
1156 closure but before allocating the result. */
1157 do_cleanups (value_chain
);
1158 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
1159 VALUE_FRAME_ID (retval
) = frame_id
;
1160 set_value_offset (retval
, byte_offset
);
1164 switch (ctx
->location
)
1166 case DWARF_VALUE_REGISTER
:
1168 struct gdbarch
*arch
= get_frame_arch (frame
);
1169 ULONGEST dwarf_regnum
= value_as_long (dwarf_expr_fetch (ctx
, 0));
1170 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
1172 if (byte_offset
!= 0)
1173 error (_("cannot use offset on synthetic pointer to register"));
1174 do_cleanups (value_chain
);
1175 if (gdb_regnum
!= -1)
1176 retval
= value_from_register (type
, gdb_regnum
, frame
);
1178 error (_("Unable to access DWARF register number %s"),
1179 paddress (arch
, dwarf_regnum
));
1183 case DWARF_VALUE_MEMORY
:
1185 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
1186 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
1188 do_cleanups (value_chain
);
1189 retval
= allocate_value_lazy (type
);
1190 VALUE_LVAL (retval
) = lval_memory
;
1191 if (in_stack_memory
)
1192 set_value_stack (retval
, 1);
1193 set_value_address (retval
, address
+ byte_offset
);
1197 case DWARF_VALUE_STACK
:
1199 struct value
*value
= dwarf_expr_fetch (ctx
, 0);
1201 const gdb_byte
*val_bytes
;
1202 size_t n
= TYPE_LENGTH (value_type (value
));
1204 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
1205 invalid_synthetic_pointer ();
1207 val_bytes
= value_contents_all (value
);
1208 val_bytes
+= byte_offset
;
1211 /* Preserve VALUE because we are going to free values back
1212 to the mark, but we still need the value contents
1214 value_incref (value
);
1215 do_cleanups (value_chain
);
1216 make_cleanup_value_free (value
);
1218 retval
= allocate_value (type
);
1219 contents
= value_contents_raw (retval
);
1220 if (n
> TYPE_LENGTH (type
))
1221 n
= TYPE_LENGTH (type
);
1222 memcpy (contents
, val_bytes
, n
);
1226 case DWARF_VALUE_LITERAL
:
1229 const bfd_byte
*ldata
;
1230 size_t n
= ctx
->len
;
1232 if (byte_offset
+ TYPE_LENGTH (type
) > n
)
1233 invalid_synthetic_pointer ();
1235 do_cleanups (value_chain
);
1236 retval
= allocate_value (type
);
1237 contents
= value_contents_raw (retval
);
1239 ldata
= ctx
->data
+ byte_offset
;
1242 if (n
> TYPE_LENGTH (type
))
1243 n
= TYPE_LENGTH (type
);
1244 memcpy (contents
, ldata
, n
);
1248 case DWARF_VALUE_OPTIMIZED_OUT
:
1249 do_cleanups (value_chain
);
1250 retval
= allocate_value (type
);
1251 VALUE_LVAL (retval
) = not_lval
;
1252 set_value_optimized_out (retval
, 1);
1255 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
1256 operation by execute_stack_op. */
1257 case DWARF_VALUE_IMPLICIT_POINTER
:
1258 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
1259 it can only be encountered when making a piece. */
1261 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1265 set_value_initialized (retval
, ctx
->initialized
);
1267 do_cleanups (old_chain
);
1272 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
1273 passes 0 as the byte_offset. */
1276 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
1277 const gdb_byte
*data
, unsigned short size
,
1278 struct dwarf2_per_cu_data
*per_cu
)
1280 return dwarf2_evaluate_loc_desc_full (type
, frame
, data
, size
, per_cu
, 0);
1284 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
1286 struct needs_frame_baton
1289 struct dwarf2_per_cu_data
*per_cu
;
1292 /* Reads from registers do require a frame. */
1294 needs_frame_read_reg (void *baton
, int regnum
)
1296 struct needs_frame_baton
*nf_baton
= baton
;
1298 nf_baton
->needs_frame
= 1;
1302 /* Reads from memory do not require a frame. */
1304 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
1306 memset (buf
, 0, len
);
1309 /* Frame-relative accesses do require a frame. */
1311 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
1313 static gdb_byte lit0
= DW_OP_lit0
;
1314 struct needs_frame_baton
*nf_baton
= baton
;
1319 nf_baton
->needs_frame
= 1;
1322 /* CFA accesses require a frame. */
1325 needs_frame_frame_cfa (void *baton
)
1327 struct needs_frame_baton
*nf_baton
= baton
;
1329 nf_baton
->needs_frame
= 1;
1333 /* Thread-local accesses do require a frame. */
1335 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
1337 struct needs_frame_baton
*nf_baton
= baton
;
1339 nf_baton
->needs_frame
= 1;
1343 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
1346 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, size_t die_offset
)
1348 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
1350 per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
,
1351 ctx
->get_frame_pc
, ctx
->baton
);
1354 /* Return non-zero iff the location expression at DATA (length SIZE)
1355 requires a frame to evaluate. */
1358 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, unsigned short size
,
1359 struct dwarf2_per_cu_data
*per_cu
)
1361 struct needs_frame_baton baton
;
1362 struct dwarf_expr_context
*ctx
;
1364 struct cleanup
*old_chain
;
1365 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
1367 baton
.needs_frame
= 0;
1368 baton
.per_cu
= per_cu
;
1370 ctx
= new_dwarf_expr_context ();
1371 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
1372 make_cleanup_value_free_to_mark (value_mark ());
1374 ctx
->gdbarch
= get_objfile_arch (objfile
);
1375 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
1376 ctx
->offset
= dwarf2_per_cu_text_offset (per_cu
);
1377 ctx
->baton
= &baton
;
1378 ctx
->read_reg
= needs_frame_read_reg
;
1379 ctx
->read_mem
= needs_frame_read_mem
;
1380 ctx
->get_frame_base
= needs_frame_frame_base
;
1381 ctx
->get_frame_cfa
= needs_frame_frame_cfa
;
1382 ctx
->get_frame_pc
= needs_frame_frame_cfa
;
1383 ctx
->get_tls_address
= needs_frame_tls_address
;
1384 ctx
->dwarf_call
= needs_frame_dwarf_call
;
1386 dwarf_expr_eval (ctx
, data
, size
);
1388 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
1390 if (ctx
->num_pieces
> 0)
1394 /* If the location has several pieces, and any of them are in
1395 registers, then we will need a frame to fetch them from. */
1396 for (i
= 0; i
< ctx
->num_pieces
; i
++)
1397 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
1401 do_cleanups (old_chain
);
1403 return baton
.needs_frame
|| in_reg
;
1406 /* A helper function that throws an unimplemented error mentioning a
1407 given DWARF operator. */
1410 unimplemented (unsigned int op
)
1412 const char *name
= dwarf_stack_op_name (op
);
1415 error (_("DWARF operator %s cannot be translated to an agent expression"),
1418 error (_("Unknown DWARF operator 0x%02x cannot be translated "
1419 "to an agent expression"),
1423 /* A helper function to convert a DWARF register to an arch register.
1424 ARCH is the architecture.
1425 DWARF_REG is the register.
1426 This will throw an exception if the DWARF register cannot be
1427 translated to an architecture register. */
1430 translate_register (struct gdbarch
*arch
, int dwarf_reg
)
1432 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
1434 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
1438 /* A helper function that emits an access to memory. ARCH is the
1439 target architecture. EXPR is the expression which we are building.
1440 NBITS is the number of bits we want to read. This emits the
1441 opcodes needed to read the memory and then extract the desired
1445 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
1447 ULONGEST nbytes
= (nbits
+ 7) / 8;
1449 gdb_assert (nbits
> 0 && nbits
<= sizeof (LONGEST
));
1452 ax_trace_quick (expr
, nbytes
);
1455 ax_simple (expr
, aop_ref8
);
1456 else if (nbits
<= 16)
1457 ax_simple (expr
, aop_ref16
);
1458 else if (nbits
<= 32)
1459 ax_simple (expr
, aop_ref32
);
1461 ax_simple (expr
, aop_ref64
);
1463 /* If we read exactly the number of bytes we wanted, we're done. */
1464 if (8 * nbytes
== nbits
)
1467 if (gdbarch_bits_big_endian (arch
))
1469 /* On a bits-big-endian machine, we want the high-order
1471 ax_const_l (expr
, 8 * nbytes
- nbits
);
1472 ax_simple (expr
, aop_rsh_unsigned
);
1476 /* On a bits-little-endian box, we want the low-order NBITS. */
1477 ax_zero_ext (expr
, nbits
);
1481 /* A helper function to return the frame's PC. */
1484 get_ax_pc (void *baton
)
1486 struct agent_expr
*expr
= baton
;
1491 /* Compile a DWARF location expression to an agent expression.
1493 EXPR is the agent expression we are building.
1494 LOC is the agent value we modify.
1495 ARCH is the architecture.
1496 ADDR_SIZE is the size of addresses, in bytes.
1497 OP_PTR is the start of the location expression.
1498 OP_END is one past the last byte of the location expression.
1500 This will throw an exception for various kinds of errors -- for
1501 example, if the expression cannot be compiled, or if the expression
1505 dwarf2_compile_expr_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
1506 struct gdbarch
*arch
, unsigned int addr_size
,
1507 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
1508 struct dwarf2_per_cu_data
*per_cu
)
1510 struct cleanup
*cleanups
;
1512 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
1513 const gdb_byte
* const base
= op_ptr
;
1514 const gdb_byte
*previous_piece
= op_ptr
;
1515 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
1516 ULONGEST bits_collected
= 0;
1517 unsigned int addr_size_bits
= 8 * addr_size
;
1518 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
1520 offsets
= xmalloc ((op_end
- op_ptr
) * sizeof (int));
1521 cleanups
= make_cleanup (xfree
, offsets
);
1523 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
1526 make_cleanup (VEC_cleanup (int), &dw_labels
);
1527 make_cleanup (VEC_cleanup (int), &patches
);
1529 /* By default we are making an address. */
1530 loc
->kind
= axs_lvalue_memory
;
1532 while (op_ptr
< op_end
)
1534 enum dwarf_location_atom op
= *op_ptr
;
1535 ULONGEST uoffset
, reg
;
1539 offsets
[op_ptr
- base
] = expr
->len
;
1542 /* Our basic approach to code generation is to map DWARF
1543 operations directly to AX operations. However, there are
1546 First, DWARF works on address-sized units, but AX always uses
1547 LONGEST. For most operations we simply ignore this
1548 difference; instead we generate sign extensions as needed
1549 before division and comparison operations. It would be nice
1550 to omit the sign extensions, but there is no way to determine
1551 the size of the target's LONGEST. (This code uses the size
1552 of the host LONGEST in some cases -- that is a bug but it is
1555 Second, some DWARF operations cannot be translated to AX.
1556 For these we simply fail. See
1557 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
1592 ax_const_l (expr
, op
- DW_OP_lit0
);
1596 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
1597 op_ptr
+= addr_size
;
1598 /* Some versions of GCC emit DW_OP_addr before
1599 DW_OP_GNU_push_tls_address. In this case the value is an
1600 index, not an address. We don't support things like
1601 branching between the address and the TLS op. */
1602 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
1603 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
1604 ax_const_l (expr
, uoffset
);
1608 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
1612 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
1616 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
1620 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
1624 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
1628 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
1632 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
1636 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
1640 op_ptr
= read_uleb128 (op_ptr
, op_end
, &uoffset
);
1641 ax_const_l (expr
, uoffset
);
1644 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1645 ax_const_l (expr
, offset
);
1680 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
1681 loc
->u
.reg
= translate_register (arch
, op
- DW_OP_reg0
);
1682 loc
->kind
= axs_lvalue_register
;
1686 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
1687 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
1688 loc
->u
.reg
= translate_register (arch
, reg
);
1689 loc
->kind
= axs_lvalue_register
;
1692 case DW_OP_implicit_value
:
1696 op_ptr
= read_uleb128 (op_ptr
, op_end
, &len
);
1697 if (op_ptr
+ len
> op_end
)
1698 error (_("DW_OP_implicit_value: too few bytes available."));
1699 if (len
> sizeof (ULONGEST
))
1700 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
1703 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
1706 dwarf_expr_require_composition (op_ptr
, op_end
,
1707 "DW_OP_implicit_value");
1709 loc
->kind
= axs_rvalue
;
1713 case DW_OP_stack_value
:
1714 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
1715 loc
->kind
= axs_rvalue
;
1750 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1751 i
= translate_register (arch
, op
- DW_OP_breg0
);
1755 ax_const_l (expr
, offset
);
1756 ax_simple (expr
, aop_add
);
1761 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
1762 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1763 i
= translate_register (arch
, reg
);
1767 ax_const_l (expr
, offset
);
1768 ax_simple (expr
, aop_add
);
1774 const gdb_byte
*datastart
;
1776 unsigned int before_stack_len
;
1778 struct symbol
*framefunc
;
1779 LONGEST base_offset
= 0;
1781 b
= block_for_pc (expr
->scope
);
1784 error (_("No block found for address"));
1786 framefunc
= block_linkage_function (b
);
1789 error (_("No function found for block"));
1791 dwarf_expr_frame_base_1 (framefunc
, expr
->scope
,
1792 &datastart
, &datalen
);
1794 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1795 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
1796 datastart
+ datalen
, per_cu
);
1800 ax_const_l (expr
, offset
);
1801 ax_simple (expr
, aop_add
);
1804 loc
->kind
= axs_lvalue_memory
;
1809 ax_simple (expr
, aop_dup
);
1813 ax_simple (expr
, aop_pop
);
1818 ax_pick (expr
, offset
);
1822 ax_simple (expr
, aop_swap
);
1830 ax_simple (expr
, aop_rot
);
1834 case DW_OP_deref_size
:
1838 if (op
== DW_OP_deref_size
)
1846 ax_simple (expr
, aop_ref8
);
1849 ax_simple (expr
, aop_ref16
);
1852 ax_simple (expr
, aop_ref32
);
1855 ax_simple (expr
, aop_ref64
);
1858 /* Note that dwarf_stack_op_name will never return
1860 error (_("Unsupported size %d in %s"),
1861 size
, dwarf_stack_op_name (op
));
1867 /* Sign extend the operand. */
1868 ax_ext (expr
, addr_size_bits
);
1869 ax_simple (expr
, aop_dup
);
1870 ax_const_l (expr
, 0);
1871 ax_simple (expr
, aop_less_signed
);
1872 ax_simple (expr
, aop_log_not
);
1873 i
= ax_goto (expr
, aop_if_goto
);
1874 /* We have to emit 0 - X. */
1875 ax_const_l (expr
, 0);
1876 ax_simple (expr
, aop_swap
);
1877 ax_simple (expr
, aop_sub
);
1878 ax_label (expr
, i
, expr
->len
);
1882 /* No need to sign extend here. */
1883 ax_const_l (expr
, 0);
1884 ax_simple (expr
, aop_swap
);
1885 ax_simple (expr
, aop_sub
);
1889 /* Sign extend the operand. */
1890 ax_ext (expr
, addr_size_bits
);
1891 ax_simple (expr
, aop_bit_not
);
1894 case DW_OP_plus_uconst
:
1895 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
1896 /* It would be really weird to emit `DW_OP_plus_uconst 0',
1897 but we micro-optimize anyhow. */
1900 ax_const_l (expr
, reg
);
1901 ax_simple (expr
, aop_add
);
1906 ax_simple (expr
, aop_bit_and
);
1910 /* Sign extend the operands. */
1911 ax_ext (expr
, addr_size_bits
);
1912 ax_simple (expr
, aop_swap
);
1913 ax_ext (expr
, addr_size_bits
);
1914 ax_simple (expr
, aop_swap
);
1915 ax_simple (expr
, aop_div_signed
);
1919 ax_simple (expr
, aop_sub
);
1923 ax_simple (expr
, aop_rem_unsigned
);
1927 ax_simple (expr
, aop_mul
);
1931 ax_simple (expr
, aop_bit_or
);
1935 ax_simple (expr
, aop_add
);
1939 ax_simple (expr
, aop_lsh
);
1943 ax_simple (expr
, aop_rsh_unsigned
);
1947 ax_simple (expr
, aop_rsh_signed
);
1951 ax_simple (expr
, aop_bit_xor
);
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 /* Note no swap here: A <= B is !(B < A). */
1960 ax_simple (expr
, aop_less_signed
);
1961 ax_simple (expr
, aop_log_not
);
1965 /* Sign extend the operands. */
1966 ax_ext (expr
, addr_size_bits
);
1967 ax_simple (expr
, aop_swap
);
1968 ax_ext (expr
, addr_size_bits
);
1969 ax_simple (expr
, aop_swap
);
1970 /* A >= B is !(A < B). */
1971 ax_simple (expr
, aop_less_signed
);
1972 ax_simple (expr
, aop_log_not
);
1976 /* Sign extend the operands. */
1977 ax_ext (expr
, addr_size_bits
);
1978 ax_simple (expr
, aop_swap
);
1979 ax_ext (expr
, addr_size_bits
);
1980 /* No need for a second swap here. */
1981 ax_simple (expr
, aop_equal
);
1985 /* Sign extend the operands. */
1986 ax_ext (expr
, addr_size_bits
);
1987 ax_simple (expr
, aop_swap
);
1988 ax_ext (expr
, addr_size_bits
);
1989 ax_simple (expr
, aop_swap
);
1990 ax_simple (expr
, aop_less_signed
);
1994 /* Sign extend the operands. */
1995 ax_ext (expr
, addr_size_bits
);
1996 ax_simple (expr
, aop_swap
);
1997 ax_ext (expr
, addr_size_bits
);
1998 /* Note no swap here: A > B is B < A. */
1999 ax_simple (expr
, aop_less_signed
);
2003 /* Sign extend the operands. */
2004 ax_ext (expr
, addr_size_bits
);
2005 ax_simple (expr
, aop_swap
);
2006 ax_ext (expr
, addr_size_bits
);
2007 /* No need for a swap here. */
2008 ax_simple (expr
, aop_equal
);
2009 ax_simple (expr
, aop_log_not
);
2012 case DW_OP_call_frame_cfa
:
2013 dwarf2_compile_cfa_to_ax (expr
, loc
, arch
, expr
->scope
, per_cu
);
2014 loc
->kind
= axs_lvalue_memory
;
2017 case DW_OP_GNU_push_tls_address
:
2022 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
2024 i
= ax_goto (expr
, aop_goto
);
2025 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
2026 VEC_safe_push (int, patches
, i
);
2030 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
2032 /* Zero extend the operand. */
2033 ax_zero_ext (expr
, addr_size_bits
);
2034 i
= ax_goto (expr
, aop_if_goto
);
2035 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
2036 VEC_safe_push (int, patches
, i
);
2043 case DW_OP_bit_piece
:
2045 ULONGEST size
, offset
;
2047 if (op_ptr
- 1 == previous_piece
)
2048 error (_("Cannot translate empty pieces to agent expressions"));
2049 previous_piece
= op_ptr
- 1;
2051 op_ptr
= read_uleb128 (op_ptr
, op_end
, &size
);
2052 if (op
== DW_OP_piece
)
2058 op_ptr
= read_uleb128 (op_ptr
, op_end
, &offset
);
2060 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
2061 error (_("Expression pieces exceed word size"));
2063 /* Access the bits. */
2066 case axs_lvalue_register
:
2067 ax_reg (expr
, loc
->u
.reg
);
2070 case axs_lvalue_memory
:
2071 /* Offset the pointer, if needed. */
2074 ax_const_l (expr
, offset
/ 8);
2075 ax_simple (expr
, aop_add
);
2078 access_memory (arch
, expr
, size
);
2082 /* For a bits-big-endian target, shift up what we already
2083 have. For a bits-little-endian target, shift up the
2084 new data. Note that there is a potential bug here if
2085 the DWARF expression leaves multiple values on the
2087 if (bits_collected
> 0)
2089 if (bits_big_endian
)
2091 ax_simple (expr
, aop_swap
);
2092 ax_const_l (expr
, size
);
2093 ax_simple (expr
, aop_lsh
);
2094 /* We don't need a second swap here, because
2095 aop_bit_or is symmetric. */
2099 ax_const_l (expr
, size
);
2100 ax_simple (expr
, aop_lsh
);
2102 ax_simple (expr
, aop_bit_or
);
2105 bits_collected
+= size
;
2106 loc
->kind
= axs_rvalue
;
2110 case DW_OP_GNU_uninit
:
2116 struct dwarf2_locexpr_baton block
;
2117 int size
= (op
== DW_OP_call2
? 2 : 4);
2119 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
2122 block
= dwarf2_fetch_die_location_block (uoffset
, per_cu
,
2125 /* DW_OP_call_ref is currently not supported. */
2126 gdb_assert (block
.per_cu
== per_cu
);
2128 dwarf2_compile_expr_to_ax (expr
, loc
, arch
, addr_size
,
2129 block
.data
, block
.data
+ block
.size
,
2134 case DW_OP_call_ref
:
2142 /* Patch all the branches we emitted. */
2143 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
2145 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
2147 internal_error (__FILE__
, __LINE__
, _("invalid label"));
2148 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
2151 do_cleanups (cleanups
);
2155 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
2156 evaluator to calculate the location. */
2157 static struct value
*
2158 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
2160 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2163 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
2164 dlbaton
->size
, dlbaton
->per_cu
);
2169 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
2171 locexpr_read_needs_frame (struct symbol
*symbol
)
2173 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2175 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
2179 /* Return true if DATA points to the end of a piece. END is one past
2180 the last byte in the expression. */
2183 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
2185 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
2188 /* Nicely describe a single piece of a location, returning an updated
2189 position in the bytecode sequence. This function cannot recognize
2190 all locations; if a location is not recognized, it simply returns
2193 static const gdb_byte
*
2194 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
2195 CORE_ADDR addr
, struct objfile
*objfile
,
2196 const gdb_byte
*data
, const gdb_byte
*end
,
2197 unsigned int addr_size
)
2199 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2202 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
2204 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, data
[0] - DW_OP_reg0
);
2205 fprintf_filtered (stream
, _("a variable in $%s"),
2206 gdbarch_register_name (gdbarch
, regno
));
2209 else if (data
[0] == DW_OP_regx
)
2213 data
= read_uleb128 (data
+ 1, end
, ®
);
2214 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
);
2215 fprintf_filtered (stream
, _("a variable in $%s"),
2216 gdbarch_register_name (gdbarch
, regno
));
2218 else if (data
[0] == DW_OP_fbreg
)
2221 struct symbol
*framefunc
;
2223 LONGEST frame_offset
;
2224 const gdb_byte
*base_data
, *new_data
, *save_data
= data
;
2226 LONGEST base_offset
= 0;
2228 new_data
= read_sleb128 (data
+ 1, end
, &frame_offset
);
2229 if (!piece_end_p (new_data
, end
))
2233 b
= block_for_pc (addr
);
2236 error (_("No block found for address for symbol \"%s\"."),
2237 SYMBOL_PRINT_NAME (symbol
));
2239 framefunc
= block_linkage_function (b
);
2242 error (_("No function found for block for symbol \"%s\"."),
2243 SYMBOL_PRINT_NAME (symbol
));
2245 dwarf_expr_frame_base_1 (framefunc
, addr
, &base_data
, &base_size
);
2247 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
2249 const gdb_byte
*buf_end
;
2251 frame_reg
= base_data
[0] - DW_OP_breg0
;
2252 buf_end
= read_sleb128 (base_data
+ 1,
2253 base_data
+ base_size
, &base_offset
);
2254 if (buf_end
!= base_data
+ base_size
)
2255 error (_("Unexpected opcode after "
2256 "DW_OP_breg%u for symbol \"%s\"."),
2257 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
2259 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
2261 /* The frame base is just the register, with no offset. */
2262 frame_reg
= base_data
[0] - DW_OP_reg0
;
2267 /* We don't know what to do with the frame base expression,
2268 so we can't trace this variable; give up. */
2272 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, frame_reg
);
2274 fprintf_filtered (stream
,
2275 _("a variable at frame base reg $%s offset %s+%s"),
2276 gdbarch_register_name (gdbarch
, regno
),
2277 plongest (base_offset
), plongest (frame_offset
));
2279 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
2280 && piece_end_p (data
, end
))
2284 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, data
[0] - DW_OP_breg0
);
2286 data
= read_sleb128 (data
+ 1, end
, &offset
);
2288 fprintf_filtered (stream
,
2289 _("a variable at offset %s from base reg $%s"),
2291 gdbarch_register_name (gdbarch
, regno
));
2294 /* The location expression for a TLS variable looks like this (on a
2297 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
2298 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
2300 0x3 is the encoding for DW_OP_addr, which has an operand as long
2301 as the size of an address on the target machine (here is 8
2302 bytes). Note that more recent version of GCC emit DW_OP_const4u
2303 or DW_OP_const8u, depending on address size, rather than
2304 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
2305 The operand represents the offset at which the variable is within
2306 the thread local storage. */
2308 else if (data
+ 1 + addr_size
< end
2309 && (data
[0] == DW_OP_addr
2310 || (addr_size
== 4 && data
[0] == DW_OP_const4u
)
2311 || (addr_size
== 8 && data
[0] == DW_OP_const8u
))
2312 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
2313 && piece_end_p (data
+ 2 + addr_size
, end
))
2316 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
2317 gdbarch_byte_order (gdbarch
));
2319 fprintf_filtered (stream
,
2320 _("a thread-local variable at offset 0x%s "
2321 "in the thread-local storage for `%s'"),
2322 phex_nz (offset
, addr_size
), objfile
->name
);
2324 data
+= 1 + addr_size
+ 1;
2326 else if (data
[0] >= DW_OP_lit0
2327 && data
[0] <= DW_OP_lit31
2329 && data
[1] == DW_OP_stack_value
)
2331 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
2338 /* Disassemble an expression, stopping at the end of a piece or at the
2339 end of the expression. Returns a pointer to the next unread byte
2340 in the input expression. If ALL is nonzero, then this function
2341 will keep going until it reaches the end of the expression. */
2343 static const gdb_byte
*
2344 disassemble_dwarf_expression (struct ui_file
*stream
,
2345 struct gdbarch
*arch
, unsigned int addr_size
,
2347 const gdb_byte
*data
, const gdb_byte
*end
,
2350 const gdb_byte
*start
= data
;
2352 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
2356 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
2358 enum dwarf_location_atom op
= *data
++;
2363 name
= dwarf_stack_op_name (op
);
2366 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
2367 op
, (long) (data
- 1 - start
));
2368 fprintf_filtered (stream
, " % 4ld: %s", (long) (data
- 1 - start
), name
);
2373 ul
= extract_unsigned_integer (data
, addr_size
,
2374 gdbarch_byte_order (arch
));
2376 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
2380 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
2382 fprintf_filtered (stream
, " %s", pulongest (ul
));
2385 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
2387 fprintf_filtered (stream
, " %s", plongest (l
));
2390 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
2392 fprintf_filtered (stream
, " %s", pulongest (ul
));
2395 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
2397 fprintf_filtered (stream
, " %s", plongest (l
));
2400 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
2402 fprintf_filtered (stream
, " %s", pulongest (ul
));
2405 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
2407 fprintf_filtered (stream
, " %s", plongest (l
));
2410 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
2412 fprintf_filtered (stream
, " %s", pulongest (ul
));
2415 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
2417 fprintf_filtered (stream
, " %s", plongest (l
));
2420 data
= read_uleb128 (data
, end
, &ul
);
2421 fprintf_filtered (stream
, " %s", pulongest (ul
));
2424 data
= read_sleb128 (data
, end
, &l
);
2425 fprintf_filtered (stream
, " %s", plongest (l
));
2460 fprintf_filtered (stream
, " [$%s]",
2461 gdbarch_register_name (arch
, op
- DW_OP_reg0
));
2465 data
= read_uleb128 (data
, end
, &ul
);
2466 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
2467 gdbarch_register_name (arch
, (int) ul
));
2470 case DW_OP_implicit_value
:
2471 data
= read_uleb128 (data
, end
, &ul
);
2473 fprintf_filtered (stream
, " %s", pulongest (ul
));
2508 data
= read_sleb128 (data
, end
, &l
);
2509 fprintf_filtered (stream
, " %s [$%s]", plongest (l
),
2510 gdbarch_register_name (arch
, op
- DW_OP_breg0
));
2514 data
= read_uleb128 (data
, end
, &ul
);
2515 data
= read_sleb128 (data
, end
, &l
);
2516 fprintf_filtered (stream
, " register %s [$%s] offset %s",
2518 gdbarch_register_name (arch
, (int) ul
),
2523 data
= read_sleb128 (data
, end
, &l
);
2524 fprintf_filtered (stream
, " %s", plongest (l
));
2527 case DW_OP_xderef_size
:
2528 case DW_OP_deref_size
:
2530 fprintf_filtered (stream
, " %d", *data
);
2534 case DW_OP_plus_uconst
:
2535 data
= read_uleb128 (data
, end
, &ul
);
2536 fprintf_filtered (stream
, " %s", pulongest (ul
));
2540 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
2542 fprintf_filtered (stream
, " to %ld",
2543 (long) (data
+ l
- start
));
2547 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
2549 fprintf_filtered (stream
, " %ld",
2550 (long) (data
+ l
- start
));
2554 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
2556 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
2560 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
2562 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
2565 case DW_OP_call_ref
:
2566 ul
= extract_unsigned_integer (data
, offset_size
,
2567 gdbarch_byte_order (arch
));
2568 data
+= offset_size
;
2569 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
2573 data
= read_uleb128 (data
, end
, &ul
);
2574 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
2577 case DW_OP_bit_piece
:
2581 data
= read_uleb128 (data
, end
, &ul
);
2582 data
= read_uleb128 (data
, end
, &offset
);
2583 fprintf_filtered (stream
, " size %s offset %s (bits)",
2584 pulongest (ul
), pulongest (offset
));
2588 case DW_OP_GNU_implicit_pointer
:
2590 ul
= extract_unsigned_integer (data
, offset_size
,
2591 gdbarch_byte_order (arch
));
2592 data
+= offset_size
;
2594 data
= read_sleb128 (data
, end
, &l
);
2596 fprintf_filtered (stream
, " DIE %s offset %s",
2597 phex_nz (ul
, offset_size
),
2603 fprintf_filtered (stream
, "\n");
2609 /* Describe a single location, which may in turn consist of multiple
2613 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
2614 struct ui_file
*stream
,
2615 const gdb_byte
*data
, int size
,
2616 struct objfile
*objfile
, unsigned int addr_size
,
2619 const gdb_byte
*end
= data
+ size
;
2620 int first_piece
= 1, bad
= 0;
2624 const gdb_byte
*here
= data
;
2625 int disassemble
= 1;
2630 fprintf_filtered (stream
, _(", and "));
2632 if (!dwarf2_always_disassemble
)
2634 data
= locexpr_describe_location_piece (symbol
, stream
,
2636 data
, end
, addr_size
);
2637 /* If we printed anything, or if we have an empty piece,
2638 then don't disassemble. */
2640 || data
[0] == DW_OP_piece
2641 || data
[0] == DW_OP_bit_piece
)
2645 data
= disassemble_dwarf_expression (stream
,
2646 get_objfile_arch (objfile
),
2647 addr_size
, offset_size
, data
, end
,
2648 dwarf2_always_disassemble
);
2652 int empty
= data
== here
;
2655 fprintf_filtered (stream
, " ");
2656 if (data
[0] == DW_OP_piece
)
2660 data
= read_uleb128 (data
+ 1, end
, &bytes
);
2663 fprintf_filtered (stream
, _("an empty %s-byte piece"),
2666 fprintf_filtered (stream
, _(" [%s-byte piece]"),
2669 else if (data
[0] == DW_OP_bit_piece
)
2671 ULONGEST bits
, offset
;
2673 data
= read_uleb128 (data
+ 1, end
, &bits
);
2674 data
= read_uleb128 (data
, end
, &offset
);
2677 fprintf_filtered (stream
,
2678 _("an empty %s-bit piece"),
2681 fprintf_filtered (stream
,
2682 _(" [%s-bit piece, offset %s bits]"),
2683 pulongest (bits
), pulongest (offset
));
2693 if (bad
|| data
> end
)
2694 error (_("Corrupted DWARF2 expression for \"%s\"."),
2695 SYMBOL_PRINT_NAME (symbol
));
2698 /* Print a natural-language description of SYMBOL to STREAM. This
2699 version is for a symbol with a single location. */
2702 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
2703 struct ui_file
*stream
)
2705 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2706 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2707 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2708 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
2710 locexpr_describe_location_1 (symbol
, addr
, stream
,
2711 dlbaton
->data
, dlbaton
->size
,
2712 objfile
, addr_size
, offset_size
);
2715 /* Describe the location of SYMBOL as an agent value in VALUE, generating
2716 any necessary bytecode in AX. */
2719 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
2720 struct agent_expr
*ax
, struct axs_value
*value
)
2722 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2723 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2725 if (dlbaton
->data
== NULL
|| dlbaton
->size
== 0)
2726 value
->optimized_out
= 1;
2728 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
,
2729 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
2733 /* The set of location functions used with the DWARF-2 expression
2735 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
2736 locexpr_read_variable
,
2737 locexpr_read_needs_frame
,
2738 locexpr_describe_location
,
2739 locexpr_tracepoint_var_ref
2743 /* Wrapper functions for location lists. These generally find
2744 the appropriate location expression and call something above. */
2746 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
2747 evaluator to calculate the location. */
2748 static struct value
*
2749 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
2751 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2753 const gdb_byte
*data
;
2755 CORE_ADDR pc
= frame
? get_frame_address_in_block (frame
) : 0;
2757 data
= dwarf2_find_location_expression (dlbaton
, &size
, pc
);
2760 val
= allocate_value (SYMBOL_TYPE (symbol
));
2761 VALUE_LVAL (val
) = not_lval
;
2762 set_value_optimized_out (val
, 1);
2765 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
2771 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
2773 loclist_read_needs_frame (struct symbol
*symbol
)
2775 /* If there's a location list, then assume we need to have a frame
2776 to choose the appropriate location expression. With tracking of
2777 global variables this is not necessarily true, but such tracking
2778 is disabled in GCC at the moment until we figure out how to
2784 /* Print a natural-language description of SYMBOL to STREAM. This
2785 version applies when there is a list of different locations, each
2786 with a specified address range. */
2789 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
2790 struct ui_file
*stream
)
2792 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2793 CORE_ADDR low
, high
;
2794 const gdb_byte
*loc_ptr
, *buf_end
;
2795 int length
, first
= 1;
2796 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2797 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2798 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2799 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2800 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
2801 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
2802 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
2803 /* Adjust base_address for relocatable objects. */
2804 CORE_ADDR base_offset
= dwarf2_per_cu_text_offset (dlbaton
->per_cu
);
2805 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
2807 loc_ptr
= dlbaton
->data
;
2808 buf_end
= dlbaton
->data
+ dlbaton
->size
;
2810 fprintf_filtered (stream
, _("multi-location:\n"));
2812 /* Iterate through locations until we run out. */
2815 if (buf_end
- loc_ptr
< 2 * addr_size
)
2816 error (_("Corrupted DWARF expression for symbol \"%s\"."),
2817 SYMBOL_PRINT_NAME (symbol
));
2820 low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
2822 low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
2823 loc_ptr
+= addr_size
;
2826 high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
2828 high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
2829 loc_ptr
+= addr_size
;
2831 /* A base-address-selection entry. */
2832 if ((low
& base_mask
) == base_mask
)
2834 base_address
= high
+ base_offset
;
2835 fprintf_filtered (stream
, _(" Base address %s"),
2836 paddress (gdbarch
, base_address
));
2840 /* An end-of-list entry. */
2841 if (low
== 0 && high
== 0)
2844 /* Otherwise, a location expression entry. */
2845 low
+= base_address
;
2846 high
+= base_address
;
2848 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
2851 /* (It would improve readability to print only the minimum
2852 necessary digits of the second number of the range.) */
2853 fprintf_filtered (stream
, _(" Range %s-%s: "),
2854 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
2856 /* Now describe this particular location. */
2857 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
2858 objfile
, addr_size
, offset_size
);
2860 fprintf_filtered (stream
, "\n");
2866 /* Describe the location of SYMBOL as an agent value in VALUE, generating
2867 any necessary bytecode in AX. */
2869 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
2870 struct agent_expr
*ax
, struct axs_value
*value
)
2872 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2873 const gdb_byte
*data
;
2875 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2877 data
= dwarf2_find_location_expression (dlbaton
, &size
, ax
->scope
);
2878 if (data
== NULL
|| size
== 0)
2879 value
->optimized_out
= 1;
2881 dwarf2_compile_expr_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
2885 /* The set of location functions used with the DWARF-2 expression
2886 evaluator and location lists. */
2887 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
2888 loclist_read_variable
,
2889 loclist_read_needs_frame
,
2890 loclist_describe_location
,
2891 loclist_tracepoint_var_ref