1 /* DWARF 2 location expression support for GDB.
3 Copyright (C) 2003, 2005, 2007, 2008, 2009, 2010
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
);
51 /* A helper function for dealing with location lists. Given a
52 symbol baton (BATON) and a pc value (PC), find the appropriate
53 location expression, set *LOCEXPR_LENGTH, and return a pointer
54 to the beginning of the expression. Returns NULL on failure.
56 For now, only return the first matching location expression; there
57 can be more than one in the list. */
59 static const gdb_byte
*
60 find_location_expression (struct dwarf2_loclist_baton
*baton
,
61 size_t *locexpr_length
, CORE_ADDR pc
)
64 const gdb_byte
*loc_ptr
, *buf_end
;
66 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
67 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
68 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
69 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
70 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
71 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
72 /* Adjust base_address for relocatable objects. */
73 CORE_ADDR base_offset
= ANOFFSET (objfile
->section_offsets
,
74 SECT_OFF_TEXT (objfile
));
75 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
77 loc_ptr
= baton
->data
;
78 buf_end
= baton
->data
+ baton
->size
;
82 if (buf_end
- loc_ptr
< 2 * addr_size
)
83 error (_("find_location_expression: Corrupted DWARF expression."));
86 low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
88 low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
92 high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
94 high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
97 /* A base-address-selection entry. */
98 if ((low
& base_mask
) == base_mask
)
100 base_address
= high
+ base_offset
;
104 /* An end-of-list entry. */
105 if (low
== 0 && high
== 0)
108 /* Otherwise, a location expression entry. */
110 high
+= base_address
;
112 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
115 if (pc
>= low
&& pc
< high
)
117 *locexpr_length
= length
;
125 /* This is the baton used when performing dwarf2 expression
127 struct dwarf_expr_baton
129 struct frame_info
*frame
;
130 struct dwarf2_per_cu_data
*per_cu
;
133 /* Helper functions for dwarf2_evaluate_loc_desc. */
135 /* Using the frame specified in BATON, return the value of register
136 REGNUM, treated as a pointer. */
138 dwarf_expr_read_reg (void *baton
, int dwarf_regnum
)
140 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
141 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
145 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
146 result
= address_from_register (builtin_type (gdbarch
)->builtin_data_ptr
,
147 regnum
, debaton
->frame
);
151 /* Read memory at ADDR (length LEN) into BUF. */
154 dwarf_expr_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
156 read_memory (addr
, buf
, len
);
159 /* Using the frame specified in BATON, find the location expression
160 describing the frame base. Return a pointer to it in START and
161 its length in LENGTH. */
163 dwarf_expr_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
165 /* FIXME: cagney/2003-03-26: This code should be using
166 get_frame_base_address(), and then implement a dwarf2 specific
168 struct symbol
*framefunc
;
169 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
171 /* Use block_linkage_function, which returns a real (not inlined)
172 function, instead of get_frame_function, which may return an
174 framefunc
= block_linkage_function (get_frame_block (debaton
->frame
, NULL
));
176 /* If we found a frame-relative symbol then it was certainly within
177 some function associated with a frame. If we can't find the frame,
178 something has gone wrong. */
179 gdb_assert (framefunc
!= NULL
);
181 dwarf_expr_frame_base_1 (framefunc
,
182 get_frame_address_in_block (debaton
->frame
),
187 dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
188 const gdb_byte
**start
, size_t *length
)
190 if (SYMBOL_LOCATION_BATON (framefunc
) == NULL
)
192 else if (SYMBOL_COMPUTED_OPS (framefunc
) == &dwarf2_loclist_funcs
)
194 struct dwarf2_loclist_baton
*symbaton
;
196 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
197 *start
= find_location_expression (symbaton
, length
, pc
);
201 struct dwarf2_locexpr_baton
*symbaton
;
203 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
204 if (symbaton
!= NULL
)
206 *length
= symbaton
->size
;
207 *start
= symbaton
->data
;
214 error (_("Could not find the frame base for \"%s\"."),
215 SYMBOL_NATURAL_NAME (framefunc
));
218 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
219 the frame in BATON. */
222 dwarf_expr_frame_cfa (void *baton
)
224 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
226 return dwarf2_frame_cfa (debaton
->frame
);
229 /* Using the objfile specified in BATON, find the address for the
230 current thread's thread-local storage with offset OFFSET. */
232 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
234 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
235 struct objfile
*objfile
= dwarf2_per_cu_objfile (debaton
->per_cu
);
237 return target_translate_tls_address (objfile
, offset
);
240 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in current CU
241 (as is PER_CU). State of the CTX is not affected by the call and return. */
244 per_cu_dwarf_call (struct dwarf_expr_context
*ctx
, size_t die_offset
,
245 struct dwarf2_per_cu_data
*per_cu
)
247 struct dwarf2_locexpr_baton block
;
249 block
= dwarf2_fetch_die_location_block (die_offset
, per_cu
);
251 /* DW_OP_call_ref is currently not supported. */
252 gdb_assert (block
.per_cu
== per_cu
);
254 dwarf_expr_eval (ctx
, block
.data
, block
.size
);
257 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
260 dwarf_expr_dwarf_call (struct dwarf_expr_context
*ctx
, size_t die_offset
)
262 struct dwarf_expr_baton
*debaton
= ctx
->baton
;
264 return per_cu_dwarf_call (ctx
, die_offset
, debaton
->per_cu
);
269 /* Reference count. */
272 /* The number of pieces used to describe this variable. */
275 /* The target address size, used only for DWARF_VALUE_STACK. */
278 /* The pieces themselves. */
279 struct dwarf_expr_piece
*pieces
;
282 /* Allocate a closure for a value formed from separately-described
285 static struct piece_closure
*
286 allocate_piece_closure (int n_pieces
, struct dwarf_expr_piece
*pieces
,
289 struct piece_closure
*c
= XZALLOC (struct piece_closure
);
292 c
->n_pieces
= n_pieces
;
293 c
->addr_size
= addr_size
;
294 c
->pieces
= XCALLOC (n_pieces
, struct dwarf_expr_piece
);
296 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
301 /* The lowest-level function to extract bits from a byte buffer.
302 SOURCE is the buffer. It is updated if we read to the end of a
304 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
305 updated to reflect the number of bits actually read.
306 NBITS is the number of bits we want to read. It is updated to
307 reflect the number of bits actually read. This function may read
309 BITS_BIG_ENDIAN is taken directly from gdbarch.
310 This function returns the extracted bits. */
313 extract_bits_primitive (const gdb_byte
**source
,
314 unsigned int *source_offset_bits
,
315 int *nbits
, int bits_big_endian
)
317 unsigned int avail
, mask
, datum
;
319 gdb_assert (*source_offset_bits
< 8);
321 avail
= 8 - *source_offset_bits
;
325 mask
= (1 << avail
) - 1;
328 datum
>>= 8 - (*source_offset_bits
+ *nbits
);
330 datum
>>= *source_offset_bits
;
334 *source_offset_bits
+= avail
;
335 if (*source_offset_bits
>= 8)
337 *source_offset_bits
-= 8;
344 /* Extract some bits from a source buffer and move forward in the
347 SOURCE is the source buffer. It is updated as bytes are read.
348 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
350 NBITS is the number of bits to read.
351 BITS_BIG_ENDIAN is taken directly from gdbarch.
353 This function returns the bits that were read. */
356 extract_bits (const gdb_byte
**source
, unsigned int *source_offset_bits
,
357 int nbits
, int bits_big_endian
)
361 gdb_assert (nbits
> 0 && nbits
<= 8);
363 datum
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
369 more
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
381 /* Write some bits into a buffer and move forward in the buffer.
383 DATUM is the bits to write. The low-order bits of DATUM are used.
384 DEST is the destination buffer. It is updated as bytes are
386 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
388 NBITS is the number of valid bits in DATUM.
389 BITS_BIG_ENDIAN is taken directly from gdbarch. */
392 insert_bits (unsigned int datum
,
393 gdb_byte
*dest
, unsigned int dest_offset_bits
,
394 int nbits
, int bits_big_endian
)
398 gdb_assert (dest_offset_bits
>= 0 && dest_offset_bits
+ nbits
<= 8);
400 mask
= (1 << nbits
) - 1;
403 datum
<<= 8 - (dest_offset_bits
+ nbits
);
404 mask
<<= 8 - (dest_offset_bits
+ nbits
);
408 datum
<<= dest_offset_bits
;
409 mask
<<= dest_offset_bits
;
412 gdb_assert ((datum
& ~mask
) == 0);
414 *dest
= (*dest
& ~mask
) | datum
;
417 /* Copy bits from a source to a destination.
419 DEST is where the bits should be written.
420 DEST_OFFSET_BITS is the bit offset into DEST.
421 SOURCE is the source of bits.
422 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
423 BIT_COUNT is the number of bits to copy.
424 BITS_BIG_ENDIAN is taken directly from gdbarch. */
427 copy_bitwise (gdb_byte
*dest
, unsigned int dest_offset_bits
,
428 const gdb_byte
*source
, unsigned int source_offset_bits
,
429 unsigned int bit_count
,
432 unsigned int dest_avail
;
435 /* Reduce everything to byte-size pieces. */
436 dest
+= dest_offset_bits
/ 8;
437 dest_offset_bits
%= 8;
438 source
+= source_offset_bits
/ 8;
439 source_offset_bits
%= 8;
441 dest_avail
= 8 - dest_offset_bits
% 8;
443 /* See if we can fill the first destination byte. */
444 if (dest_avail
< bit_count
)
446 datum
= extract_bits (&source
, &source_offset_bits
, dest_avail
,
448 insert_bits (datum
, dest
, dest_offset_bits
, dest_avail
, bits_big_endian
);
450 dest_offset_bits
= 0;
451 bit_count
-= dest_avail
;
454 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
455 than 8 bits remaining. */
456 gdb_assert (dest_offset_bits
% 8 == 0 || bit_count
< 8);
457 for (; bit_count
>= 8; bit_count
-= 8)
459 datum
= extract_bits (&source
, &source_offset_bits
, 8, bits_big_endian
);
460 *dest
++ = (gdb_byte
) datum
;
463 /* Finally, we may have a few leftover bits. */
464 gdb_assert (bit_count
<= 8 - dest_offset_bits
% 8);
467 datum
= extract_bits (&source
, &source_offset_bits
, bit_count
,
469 insert_bits (datum
, dest
, dest_offset_bits
, bit_count
, bits_big_endian
);
474 read_pieced_value (struct value
*v
)
478 ULONGEST bits_to_skip
;
480 struct piece_closure
*c
= (struct piece_closure
*) value_computed_closure (v
);
481 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (v
));
483 size_t buffer_size
= 0;
485 struct cleanup
*cleanup
;
487 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
489 if (value_type (v
) != value_enclosing_type (v
))
490 internal_error (__FILE__
, __LINE__
,
491 _("Should not be able to create a lazy value with "
492 "an enclosing type"));
494 cleanup
= make_cleanup (free_current_contents
, &buffer
);
496 contents
= value_contents_raw (v
);
497 bits_to_skip
= 8 * value_offset (v
);
498 if (value_bitsize (v
))
500 bits_to_skip
+= value_bitpos (v
);
501 type_len
= value_bitsize (v
);
504 type_len
= 8 * TYPE_LENGTH (value_type (v
));
506 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
508 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
509 size_t this_size
, this_size_bits
;
510 long dest_offset_bits
, source_offset_bits
, source_offset
;
511 const gdb_byte
*intermediate_buffer
;
513 /* Compute size, source, and destination offsets for copying, in
515 this_size_bits
= p
->size
;
516 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
518 bits_to_skip
-= this_size_bits
;
521 if (this_size_bits
> type_len
- offset
)
522 this_size_bits
= type_len
- offset
;
523 if (bits_to_skip
> 0)
525 dest_offset_bits
= 0;
526 source_offset_bits
= bits_to_skip
;
527 this_size_bits
-= bits_to_skip
;
532 dest_offset_bits
= offset
;
533 source_offset_bits
= 0;
536 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
537 source_offset
= source_offset_bits
/ 8;
538 if (buffer_size
< this_size
)
540 buffer_size
= this_size
;
541 buffer
= xrealloc (buffer
, buffer_size
);
543 intermediate_buffer
= buffer
;
545 /* Copy from the source to DEST_BUFFER. */
548 case DWARF_VALUE_REGISTER
:
550 struct gdbarch
*arch
= get_frame_arch (frame
);
551 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.value
);
552 int reg_offset
= source_offset
;
554 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
555 && this_size
< register_size (arch
, gdb_regnum
))
557 /* Big-endian, and we want less than full size. */
558 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
559 /* We want the lower-order THIS_SIZE_BITS of the bytes
560 we extract from the register. */
561 source_offset_bits
+= 8 * this_size
- this_size_bits
;
564 if (gdb_regnum
!= -1)
566 get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
571 error (_("Unable to access DWARF register number %s"),
572 paddress (arch
, p
->v
.value
));
577 case DWARF_VALUE_MEMORY
:
578 if (p
->v
.mem
.in_stack_memory
)
579 read_stack (p
->v
.mem
.addr
+ source_offset
, buffer
, this_size
);
581 read_memory (p
->v
.mem
.addr
+ source_offset
, buffer
, this_size
);
584 case DWARF_VALUE_STACK
:
586 struct gdbarch
*gdbarch
= get_type_arch (value_type (v
));
587 size_t n
= this_size
;
589 if (n
> c
->addr_size
- source_offset
)
590 n
= (c
->addr_size
>= source_offset
591 ? c
->addr_size
- source_offset
597 else if (source_offset
== 0)
598 store_unsigned_integer (buffer
, n
,
599 gdbarch_byte_order (gdbarch
),
603 gdb_byte bytes
[sizeof (ULONGEST
)];
605 store_unsigned_integer (bytes
, n
+ source_offset
,
606 gdbarch_byte_order (gdbarch
),
608 memcpy (buffer
, bytes
+ source_offset
, n
);
613 case DWARF_VALUE_LITERAL
:
615 size_t n
= this_size
;
617 if (n
> p
->v
.literal
.length
- source_offset
)
618 n
= (p
->v
.literal
.length
>= source_offset
619 ? p
->v
.literal
.length
- source_offset
622 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
626 case DWARF_VALUE_OPTIMIZED_OUT
:
627 set_value_optimized_out (v
, 1);
631 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
634 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
)
635 copy_bitwise (contents
, dest_offset_bits
,
636 intermediate_buffer
, source_offset_bits
% 8,
637 this_size_bits
, bits_big_endian
);
639 offset
+= this_size_bits
;
642 do_cleanups (cleanup
);
646 write_pieced_value (struct value
*to
, struct value
*from
)
650 ULONGEST bits_to_skip
;
651 const gdb_byte
*contents
;
652 struct piece_closure
*c
= (struct piece_closure
*) value_computed_closure (to
);
653 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
655 size_t buffer_size
= 0;
657 struct cleanup
*cleanup
;
659 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
663 set_value_optimized_out (to
, 1);
667 cleanup
= make_cleanup (free_current_contents
, &buffer
);
669 contents
= value_contents (from
);
670 bits_to_skip
= 8 * value_offset (to
);
671 if (value_bitsize (to
))
673 bits_to_skip
+= value_bitpos (to
);
674 type_len
= value_bitsize (to
);
677 type_len
= 8 * TYPE_LENGTH (value_type (to
));
679 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
681 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
682 size_t this_size_bits
, this_size
;
683 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
685 const gdb_byte
*source_buffer
;
687 this_size_bits
= p
->size
;
688 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
690 bits_to_skip
-= this_size_bits
;
693 if (this_size_bits
> type_len
- offset
)
694 this_size_bits
= type_len
- offset
;
695 if (bits_to_skip
> 0)
697 dest_offset_bits
= bits_to_skip
;
698 source_offset_bits
= 0;
699 this_size_bits
-= bits_to_skip
;
704 dest_offset_bits
= 0;
705 source_offset_bits
= offset
;
708 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
709 source_offset
= source_offset_bits
/ 8;
710 dest_offset
= dest_offset_bits
/ 8;
711 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
713 source_buffer
= contents
+ source_offset
;
718 if (buffer_size
< this_size
)
720 buffer_size
= this_size
;
721 buffer
= xrealloc (buffer
, buffer_size
);
723 source_buffer
= buffer
;
729 case DWARF_VALUE_REGISTER
:
731 struct gdbarch
*arch
= get_frame_arch (frame
);
732 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.value
);
733 int reg_offset
= dest_offset
;
735 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
736 && this_size
<= register_size (arch
, gdb_regnum
))
737 /* Big-endian, and we want less than full size. */
738 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
740 if (gdb_regnum
!= -1)
744 get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
746 copy_bitwise (buffer
, dest_offset_bits
,
747 contents
, source_offset_bits
,
752 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
753 this_size
, source_buffer
);
757 error (_("Unable to write to DWARF register number %s"),
758 paddress (arch
, p
->v
.value
));
762 case DWARF_VALUE_MEMORY
:
765 /* Only the first and last bytes can possibly have any
767 read_memory (p
->v
.mem
.addr
+ dest_offset
, buffer
, 1);
768 read_memory (p
->v
.mem
.addr
+ dest_offset
+ this_size
- 1,
769 buffer
+ this_size
- 1, 1);
770 copy_bitwise (buffer
, dest_offset_bits
,
771 contents
, source_offset_bits
,
776 write_memory (p
->v
.mem
.addr
+ dest_offset
,
777 source_buffer
, this_size
);
780 set_value_optimized_out (to
, 1);
783 offset
+= this_size_bits
;
786 do_cleanups (cleanup
);
790 check_pieced_value_bits (const struct value
*value
, int bit_offset
,
791 int bit_length
, int validity
)
793 struct piece_closure
*c
794 = (struct piece_closure
*) value_computed_closure (value
);
797 bit_offset
+= 8 * value_offset (value
);
798 if (value_bitsize (value
))
799 bit_offset
+= value_bitpos (value
);
801 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
803 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
804 size_t this_size_bits
= p
->size
;
808 if (bit_offset
>= this_size_bits
)
810 bit_offset
-= this_size_bits
;
814 bit_length
-= this_size_bits
- bit_offset
;
818 bit_length
-= this_size_bits
;
820 if (p
->location
== DWARF_VALUE_OPTIMIZED_OUT
)
836 check_pieced_value_validity (const struct value
*value
, int bit_offset
,
839 return check_pieced_value_bits (value
, bit_offset
, bit_length
, 1);
843 check_pieced_value_invalid (const struct value
*value
)
845 return check_pieced_value_bits (value
, 0,
846 8 * TYPE_LENGTH (value_type (value
)), 0);
850 copy_pieced_value_closure (const struct value
*v
)
852 struct piece_closure
*c
= (struct piece_closure
*) value_computed_closure (v
);
859 free_pieced_value_closure (struct value
*v
)
861 struct piece_closure
*c
= (struct piece_closure
*) value_computed_closure (v
);
871 /* Functions for accessing a variable described by DW_OP_piece. */
872 static struct lval_funcs pieced_value_funcs
= {
875 check_pieced_value_validity
,
876 check_pieced_value_invalid
,
877 copy_pieced_value_closure
,
878 free_pieced_value_closure
881 /* Evaluate a location description, starting at DATA and with length
882 SIZE, to find the current location of variable of TYPE in the context
885 static struct value
*
886 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
887 const gdb_byte
*data
, unsigned short size
,
888 struct dwarf2_per_cu_data
*per_cu
)
890 struct value
*retval
;
891 struct dwarf_expr_baton baton
;
892 struct dwarf_expr_context
*ctx
;
893 struct cleanup
*old_chain
;
897 retval
= allocate_value (type
);
898 VALUE_LVAL (retval
) = not_lval
;
899 set_value_optimized_out (retval
, 1);
904 baton
.per_cu
= per_cu
;
906 ctx
= new_dwarf_expr_context ();
907 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
909 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (per_cu
));
910 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
912 ctx
->read_reg
= dwarf_expr_read_reg
;
913 ctx
->read_mem
= dwarf_expr_read_mem
;
914 ctx
->get_frame_base
= dwarf_expr_frame_base
;
915 ctx
->get_frame_cfa
= dwarf_expr_frame_cfa
;
916 ctx
->get_tls_address
= dwarf_expr_tls_address
;
917 ctx
->dwarf_call
= dwarf_expr_dwarf_call
;
919 dwarf_expr_eval (ctx
, data
, size
);
920 if (ctx
->num_pieces
> 0)
922 struct piece_closure
*c
;
923 struct frame_id frame_id
= get_frame_id (frame
);
925 c
= allocate_piece_closure (ctx
->num_pieces
, ctx
->pieces
,
927 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
928 VALUE_FRAME_ID (retval
) = frame_id
;
932 switch (ctx
->location
)
934 case DWARF_VALUE_REGISTER
:
936 struct gdbarch
*arch
= get_frame_arch (frame
);
937 ULONGEST dwarf_regnum
= dwarf_expr_fetch (ctx
, 0);
938 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
940 if (gdb_regnum
!= -1)
941 retval
= value_from_register (type
, gdb_regnum
, frame
);
943 error (_("Unable to access DWARF register number %s"),
944 paddress (arch
, dwarf_regnum
));
948 case DWARF_VALUE_MEMORY
:
950 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
951 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
953 retval
= allocate_value (type
);
954 VALUE_LVAL (retval
) = lval_memory
;
955 set_value_lazy (retval
, 1);
957 set_value_stack (retval
, 1);
958 set_value_address (retval
, address
);
962 case DWARF_VALUE_STACK
:
964 ULONGEST value
= dwarf_expr_fetch (ctx
, 0);
966 size_t n
= ctx
->addr_size
;
968 retval
= allocate_value (type
);
969 contents
= value_contents_raw (retval
);
970 if (n
> TYPE_LENGTH (type
))
971 n
= TYPE_LENGTH (type
);
972 store_unsigned_integer (contents
, n
,
973 gdbarch_byte_order (ctx
->gdbarch
),
978 case DWARF_VALUE_LITERAL
:
983 retval
= allocate_value (type
);
984 contents
= value_contents_raw (retval
);
985 if (n
> TYPE_LENGTH (type
))
986 n
= TYPE_LENGTH (type
);
987 memcpy (contents
, ctx
->data
, n
);
991 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
992 it can only be encountered when making a piece. */
993 case DWARF_VALUE_OPTIMIZED_OUT
:
995 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
999 set_value_initialized (retval
, ctx
->initialized
);
1001 do_cleanups (old_chain
);
1006 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
1008 struct needs_frame_baton
1011 struct dwarf2_per_cu_data
*per_cu
;
1014 /* Reads from registers do require a frame. */
1016 needs_frame_read_reg (void *baton
, int regnum
)
1018 struct needs_frame_baton
*nf_baton
= baton
;
1020 nf_baton
->needs_frame
= 1;
1024 /* Reads from memory do not require a frame. */
1026 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
1028 memset (buf
, 0, len
);
1031 /* Frame-relative accesses do require a frame. */
1033 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
1035 static gdb_byte lit0
= DW_OP_lit0
;
1036 struct needs_frame_baton
*nf_baton
= baton
;
1041 nf_baton
->needs_frame
= 1;
1044 /* CFA accesses require a frame. */
1047 needs_frame_frame_cfa (void *baton
)
1049 struct needs_frame_baton
*nf_baton
= baton
;
1051 nf_baton
->needs_frame
= 1;
1055 /* Thread-local accesses do require a frame. */
1057 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
1059 struct needs_frame_baton
*nf_baton
= baton
;
1061 nf_baton
->needs_frame
= 1;
1065 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
1068 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, size_t die_offset
)
1070 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
1072 return per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
);
1075 /* Return non-zero iff the location expression at DATA (length SIZE)
1076 requires a frame to evaluate. */
1079 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, unsigned short size
,
1080 struct dwarf2_per_cu_data
*per_cu
)
1082 struct needs_frame_baton baton
;
1083 struct dwarf_expr_context
*ctx
;
1085 struct cleanup
*old_chain
;
1087 baton
.needs_frame
= 0;
1088 baton
.per_cu
= per_cu
;
1090 ctx
= new_dwarf_expr_context ();
1091 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
1093 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (per_cu
));
1094 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
1095 ctx
->baton
= &baton
;
1096 ctx
->read_reg
= needs_frame_read_reg
;
1097 ctx
->read_mem
= needs_frame_read_mem
;
1098 ctx
->get_frame_base
= needs_frame_frame_base
;
1099 ctx
->get_frame_cfa
= needs_frame_frame_cfa
;
1100 ctx
->get_tls_address
= needs_frame_tls_address
;
1101 ctx
->dwarf_call
= needs_frame_dwarf_call
;
1103 dwarf_expr_eval (ctx
, data
, size
);
1105 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
1107 if (ctx
->num_pieces
> 0)
1111 /* If the location has several pieces, and any of them are in
1112 registers, then we will need a frame to fetch them from. */
1113 for (i
= 0; i
< ctx
->num_pieces
; i
++)
1114 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
1118 do_cleanups (old_chain
);
1120 return baton
.needs_frame
|| in_reg
;
1123 /* A helper function that throws an unimplemented error mentioning a
1124 given DWARF operator. */
1127 unimplemented (unsigned int op
)
1129 error (_("DWARF operator %s cannot be translated to an agent expression"),
1130 dwarf_stack_op_name (op
, 1));
1133 /* A helper function to convert a DWARF register to an arch register.
1134 ARCH is the architecture.
1135 DWARF_REG is the register.
1136 This will throw an exception if the DWARF register cannot be
1137 translated to an architecture register. */
1140 translate_register (struct gdbarch
*arch
, int dwarf_reg
)
1142 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
1144 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
1148 /* A helper function that emits an access to memory. ARCH is the
1149 target architecture. EXPR is the expression which we are building.
1150 NBITS is the number of bits we want to read. This emits the
1151 opcodes needed to read the memory and then extract the desired
1155 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
1157 ULONGEST nbytes
= (nbits
+ 7) / 8;
1159 gdb_assert (nbits
> 0 && nbits
<= sizeof (LONGEST
));
1162 ax_trace_quick (expr
, nbytes
);
1165 ax_simple (expr
, aop_ref8
);
1166 else if (nbits
<= 16)
1167 ax_simple (expr
, aop_ref16
);
1168 else if (nbits
<= 32)
1169 ax_simple (expr
, aop_ref32
);
1171 ax_simple (expr
, aop_ref64
);
1173 /* If we read exactly the number of bytes we wanted, we're done. */
1174 if (8 * nbytes
== nbits
)
1177 if (gdbarch_bits_big_endian (arch
))
1179 /* On a bits-big-endian machine, we want the high-order
1181 ax_const_l (expr
, 8 * nbytes
- nbits
);
1182 ax_simple (expr
, aop_rsh_unsigned
);
1186 /* On a bits-little-endian box, we want the low-order NBITS. */
1187 ax_zero_ext (expr
, nbits
);
1191 /* Compile a DWARF location expression to an agent expression.
1193 EXPR is the agent expression we are building.
1194 LOC is the agent value we modify.
1195 ARCH is the architecture.
1196 ADDR_SIZE is the size of addresses, in bytes.
1197 OP_PTR is the start of the location expression.
1198 OP_END is one past the last byte of the location expression.
1200 This will throw an exception for various kinds of errors -- for
1201 example, if the expression cannot be compiled, or if the expression
1205 compile_dwarf_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
1206 struct gdbarch
*arch
, unsigned int addr_size
,
1207 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
1208 struct dwarf2_per_cu_data
*per_cu
)
1210 struct cleanup
*cleanups
;
1212 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
1213 const gdb_byte
* const base
= op_ptr
;
1214 const gdb_byte
*previous_piece
= op_ptr
;
1215 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
1216 ULONGEST bits_collected
= 0;
1217 unsigned int addr_size_bits
= 8 * addr_size
;
1218 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
1220 offsets
= xmalloc ((op_end
- op_ptr
) * sizeof (int));
1221 cleanups
= make_cleanup (xfree
, offsets
);
1223 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
1226 make_cleanup (VEC_cleanup (int), &dw_labels
);
1227 make_cleanup (VEC_cleanup (int), &patches
);
1229 /* By default we are making an address. */
1230 loc
->kind
= axs_lvalue_memory
;
1232 while (op_ptr
< op_end
)
1234 enum dwarf_location_atom op
= *op_ptr
;
1235 ULONGEST uoffset
, reg
;
1239 offsets
[op_ptr
- base
] = expr
->len
;
1242 /* Our basic approach to code generation is to map DWARF
1243 operations directly to AX operations. However, there are
1246 First, DWARF works on address-sized units, but AX always uses
1247 LONGEST. For most operations we simply ignore this
1248 difference; instead we generate sign extensions as needed
1249 before division and comparison operations. It would be nice
1250 to omit the sign extensions, but there is no way to determine
1251 the size of the target's LONGEST. (This code uses the size
1252 of the host LONGEST in some cases -- that is a bug but it is
1255 Second, some DWARF operations cannot be translated to AX.
1256 For these we simply fail. See
1257 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
1292 ax_const_l (expr
, op
- DW_OP_lit0
);
1296 ax_const_l (expr
, extract_unsigned_integer (op_ptr
,
1297 addr_size
, byte_order
));
1298 op_ptr
+= addr_size
;
1302 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
1306 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
1310 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
1314 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
1318 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
1322 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
1326 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
1330 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
1334 op_ptr
= read_uleb128 (op_ptr
, op_end
, &uoffset
);
1335 ax_const_l (expr
, uoffset
);
1338 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1339 ax_const_l (expr
, offset
);
1374 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
1375 loc
->u
.reg
= translate_register (arch
, op
- DW_OP_reg0
);
1376 loc
->kind
= axs_lvalue_register
;
1380 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
1381 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
1382 loc
->u
.reg
= translate_register (arch
, reg
);
1383 loc
->kind
= axs_lvalue_register
;
1386 case DW_OP_implicit_value
:
1390 op_ptr
= read_uleb128 (op_ptr
, op_end
, &len
);
1391 if (op_ptr
+ len
> op_end
)
1392 error (_("DW_OP_implicit_value: too few bytes available."));
1393 if (len
> sizeof (ULONGEST
))
1394 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
1397 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
1400 dwarf_expr_require_composition (op_ptr
, op_end
,
1401 "DW_OP_implicit_value");
1403 loc
->kind
= axs_rvalue
;
1407 case DW_OP_stack_value
:
1408 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
1409 loc
->kind
= axs_rvalue
;
1444 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1445 i
= translate_register (arch
, op
- DW_OP_breg0
);
1449 ax_const_l (expr
, offset
);
1450 ax_simple (expr
, aop_add
);
1455 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
1456 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1457 i
= translate_register (arch
, reg
);
1461 ax_const_l (expr
, offset
);
1462 ax_simple (expr
, aop_add
);
1468 const gdb_byte
*datastart
;
1470 unsigned int before_stack_len
;
1472 struct symbol
*framefunc
;
1473 LONGEST base_offset
= 0;
1475 b
= block_for_pc (expr
->scope
);
1478 error (_("No block found for address"));
1480 framefunc
= block_linkage_function (b
);
1483 error (_("No function found for block"));
1485 dwarf_expr_frame_base_1 (framefunc
, expr
->scope
,
1486 &datastart
, &datalen
);
1488 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1489 compile_dwarf_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
1490 datastart
+ datalen
, per_cu
);
1494 ax_const_l (expr
, offset
);
1495 ax_simple (expr
, aop_add
);
1498 loc
->kind
= axs_lvalue_memory
;
1503 ax_simple (expr
, aop_dup
);
1507 ax_simple (expr
, aop_pop
);
1516 ax_simple (expr
, aop_swap
);
1520 /* We can't directly support DW_OP_over, but GCC emits it as
1521 part of a sequence to implement signed modulus. As a
1522 hack, we recognize this sequence. Note that if GCC ever
1523 generates a branch to the middle of this sequence, then
1524 we will die somehow. */
1525 if (op_end
- op_ptr
>= 4
1526 && op_ptr
[0] == DW_OP_over
1527 && op_ptr
[1] == DW_OP_div
1528 && op_ptr
[2] == DW_OP_mul
1529 && op_ptr
[3] == DW_OP_minus
)
1531 /* Sign extend the operands. */
1532 ax_ext (expr
, addr_size_bits
);
1533 ax_simple (expr
, aop_swap
);
1534 ax_ext (expr
, addr_size_bits
);
1535 ax_simple (expr
, aop_swap
);
1536 ax_simple (expr
, aop_rem_signed
);
1548 case DW_OP_deref_size
:
1552 if (op
== DW_OP_deref_size
)
1560 ax_simple (expr
, aop_ref8
);
1563 ax_simple (expr
, aop_ref16
);
1566 ax_simple (expr
, aop_ref32
);
1569 ax_simple (expr
, aop_ref64
);
1572 error (_("Unsupported size %d in %s"),
1573 size
, dwarf_stack_op_name (op
, 1));
1579 /* Sign extend the operand. */
1580 ax_ext (expr
, addr_size_bits
);
1581 ax_simple (expr
, aop_dup
);
1582 ax_const_l (expr
, 0);
1583 ax_simple (expr
, aop_less_signed
);
1584 ax_simple (expr
, aop_log_not
);
1585 i
= ax_goto (expr
, aop_if_goto
);
1586 /* We have to emit 0 - X. */
1587 ax_const_l (expr
, 0);
1588 ax_simple (expr
, aop_swap
);
1589 ax_simple (expr
, aop_sub
);
1590 ax_label (expr
, i
, expr
->len
);
1594 /* No need to sign extend here. */
1595 ax_const_l (expr
, 0);
1596 ax_simple (expr
, aop_swap
);
1597 ax_simple (expr
, aop_sub
);
1601 /* Sign extend the operand. */
1602 ax_ext (expr
, addr_size_bits
);
1603 ax_simple (expr
, aop_bit_not
);
1606 case DW_OP_plus_uconst
:
1607 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
1608 /* It would be really weird to emit `DW_OP_plus_uconst 0',
1609 but we micro-optimize anyhow. */
1612 ax_const_l (expr
, reg
);
1613 ax_simple (expr
, aop_add
);
1618 ax_simple (expr
, aop_bit_and
);
1622 /* Sign extend the operands. */
1623 ax_ext (expr
, addr_size_bits
);
1624 ax_simple (expr
, aop_swap
);
1625 ax_ext (expr
, addr_size_bits
);
1626 ax_simple (expr
, aop_swap
);
1627 ax_simple (expr
, aop_div_signed
);
1631 ax_simple (expr
, aop_sub
);
1635 ax_simple (expr
, aop_rem_unsigned
);
1639 ax_simple (expr
, aop_mul
);
1643 ax_simple (expr
, aop_bit_or
);
1647 ax_simple (expr
, aop_add
);
1651 ax_simple (expr
, aop_lsh
);
1655 ax_simple (expr
, aop_rsh_unsigned
);
1659 ax_simple (expr
, aop_rsh_signed
);
1663 ax_simple (expr
, aop_bit_xor
);
1667 /* Sign extend the operands. */
1668 ax_ext (expr
, addr_size_bits
);
1669 ax_simple (expr
, aop_swap
);
1670 ax_ext (expr
, addr_size_bits
);
1671 /* Note no swap here: A <= B is !(B < A). */
1672 ax_simple (expr
, aop_less_signed
);
1673 ax_simple (expr
, aop_log_not
);
1677 /* Sign extend the operands. */
1678 ax_ext (expr
, addr_size_bits
);
1679 ax_simple (expr
, aop_swap
);
1680 ax_ext (expr
, addr_size_bits
);
1681 ax_simple (expr
, aop_swap
);
1682 /* A >= B is !(A < B). */
1683 ax_simple (expr
, aop_less_signed
);
1684 ax_simple (expr
, aop_log_not
);
1688 /* Sign extend the operands. */
1689 ax_ext (expr
, addr_size_bits
);
1690 ax_simple (expr
, aop_swap
);
1691 ax_ext (expr
, addr_size_bits
);
1692 /* No need for a second swap here. */
1693 ax_simple (expr
, aop_equal
);
1697 /* Sign extend the operands. */
1698 ax_ext (expr
, addr_size_bits
);
1699 ax_simple (expr
, aop_swap
);
1700 ax_ext (expr
, addr_size_bits
);
1701 ax_simple (expr
, aop_swap
);
1702 ax_simple (expr
, aop_less_signed
);
1706 /* Sign extend the operands. */
1707 ax_ext (expr
, addr_size_bits
);
1708 ax_simple (expr
, aop_swap
);
1709 ax_ext (expr
, addr_size_bits
);
1710 /* Note no swap here: A > B is B < A. */
1711 ax_simple (expr
, aop_less_signed
);
1715 /* Sign extend the operands. */
1716 ax_ext (expr
, addr_size_bits
);
1717 ax_simple (expr
, aop_swap
);
1718 ax_ext (expr
, addr_size_bits
);
1719 /* No need for a swap here. */
1720 ax_simple (expr
, aop_equal
);
1721 ax_simple (expr
, aop_log_not
);
1724 case DW_OP_call_frame_cfa
:
1728 case DW_OP_GNU_push_tls_address
:
1733 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
1735 i
= ax_goto (expr
, aop_goto
);
1736 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
1737 VEC_safe_push (int, patches
, i
);
1741 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
1743 /* Zero extend the operand. */
1744 ax_zero_ext (expr
, addr_size_bits
);
1745 i
= ax_goto (expr
, aop_if_goto
);
1746 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
1747 VEC_safe_push (int, patches
, i
);
1754 case DW_OP_bit_piece
:
1756 ULONGEST size
, offset
;
1758 if (op_ptr
- 1 == previous_piece
)
1759 error (_("Cannot translate empty pieces to agent expressions"));
1760 previous_piece
= op_ptr
- 1;
1762 op_ptr
= read_uleb128 (op_ptr
, op_end
, &size
);
1763 if (op
== DW_OP_piece
)
1769 op_ptr
= read_uleb128 (op_ptr
, op_end
, &offset
);
1771 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
1772 error (_("Expression pieces exceed word size"));
1774 /* Access the bits. */
1777 case axs_lvalue_register
:
1778 ax_reg (expr
, loc
->u
.reg
);
1781 case axs_lvalue_memory
:
1782 /* Offset the pointer, if needed. */
1785 ax_const_l (expr
, offset
/ 8);
1786 ax_simple (expr
, aop_add
);
1789 access_memory (arch
, expr
, size
);
1793 /* For a bits-big-endian target, shift up what we already
1794 have. For a bits-little-endian target, shift up the
1795 new data. Note that there is a potential bug here if
1796 the DWARF expression leaves multiple values on the
1798 if (bits_collected
> 0)
1800 if (bits_big_endian
)
1802 ax_simple (expr
, aop_swap
);
1803 ax_const_l (expr
, size
);
1804 ax_simple (expr
, aop_lsh
);
1805 /* We don't need a second swap here, because
1806 aop_bit_or is symmetric. */
1810 ax_const_l (expr
, size
);
1811 ax_simple (expr
, aop_lsh
);
1813 ax_simple (expr
, aop_bit_or
);
1816 bits_collected
+= size
;
1817 loc
->kind
= axs_rvalue
;
1821 case DW_OP_GNU_uninit
:
1827 struct dwarf2_locexpr_baton block
;
1828 int size
= (op
== DW_OP_call2
? 2 : 4);
1830 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
1833 block
= dwarf2_fetch_die_location_block (uoffset
, per_cu
);
1835 /* DW_OP_call_ref is currently not supported. */
1836 gdb_assert (block
.per_cu
== per_cu
);
1838 compile_dwarf_to_ax (expr
, loc
, arch
, addr_size
,
1839 block
.data
, block
.data
+ block
.size
,
1844 case DW_OP_call_ref
:
1848 error (_("Unhandled dwarf expression opcode 0x%x"), op
);
1852 /* Patch all the branches we emitted. */
1853 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
1855 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
1857 internal_error (__FILE__
, __LINE__
, _("invalid label"));
1858 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
1861 do_cleanups (cleanups
);
1865 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
1866 evaluator to calculate the location. */
1867 static struct value
*
1868 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
1870 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
1873 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
1874 dlbaton
->size
, dlbaton
->per_cu
);
1879 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
1881 locexpr_read_needs_frame (struct symbol
*symbol
)
1883 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
1885 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
1889 /* Return true if DATA points to the end of a piece. END is one past
1890 the last byte in the expression. */
1893 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
1895 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
1898 /* Nicely describe a single piece of a location, returning an updated
1899 position in the bytecode sequence. This function cannot recognize
1900 all locations; if a location is not recognized, it simply returns
1903 static const gdb_byte
*
1904 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
1905 CORE_ADDR addr
, struct objfile
*objfile
,
1906 const gdb_byte
*data
, const gdb_byte
*end
,
1907 unsigned int addr_size
)
1909 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1912 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
1914 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, data
[0] - DW_OP_reg0
);
1915 fprintf_filtered (stream
, _("a variable in $%s"),
1916 gdbarch_register_name (gdbarch
, regno
));
1919 else if (data
[0] == DW_OP_regx
)
1923 data
= read_uleb128 (data
+ 1, end
, ®
);
1924 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
);
1925 fprintf_filtered (stream
, _("a variable in $%s"),
1926 gdbarch_register_name (gdbarch
, regno
));
1928 else if (data
[0] == DW_OP_fbreg
)
1931 struct symbol
*framefunc
;
1933 LONGEST frame_offset
;
1934 const gdb_byte
*base_data
, *new_data
;
1936 LONGEST base_offset
= 0;
1938 new_data
= read_sleb128 (data
+ 1, end
, &frame_offset
);
1939 if (!piece_end_p (new_data
, end
))
1943 b
= block_for_pc (addr
);
1946 error (_("No block found for address for symbol \"%s\"."),
1947 SYMBOL_PRINT_NAME (symbol
));
1949 framefunc
= block_linkage_function (b
);
1952 error (_("No function found for block for symbol \"%s\"."),
1953 SYMBOL_PRINT_NAME (symbol
));
1955 dwarf_expr_frame_base_1 (framefunc
, addr
, &base_data
, &base_size
);
1957 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
1959 const gdb_byte
*buf_end
;
1961 frame_reg
= base_data
[0] - DW_OP_breg0
;
1962 buf_end
= read_sleb128 (base_data
+ 1,
1963 base_data
+ base_size
, &base_offset
);
1964 if (buf_end
!= base_data
+ base_size
)
1965 error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
1966 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
1968 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
1970 /* The frame base is just the register, with no offset. */
1971 frame_reg
= base_data
[0] - DW_OP_reg0
;
1976 /* We don't know what to do with the frame base expression,
1977 so we can't trace this variable; give up. */
1978 error (_("Cannot describe location of symbol \"%s\"; "
1979 "DWARF 2 encoding not handled, "
1980 "first opcode in base data is 0x%x."),
1981 SYMBOL_PRINT_NAME (symbol
), base_data
[0]);
1984 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, frame_reg
);
1986 fprintf_filtered (stream
, _("a variable at frame base reg $%s offset %s+%s"),
1987 gdbarch_register_name (gdbarch
, regno
),
1988 plongest (base_offset
), plongest (frame_offset
));
1990 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
1991 && piece_end_p (data
, end
))
1995 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, data
[0] - DW_OP_breg0
);
1997 data
= read_sleb128 (data
+ 1, end
, &offset
);
1999 fprintf_filtered (stream
,
2000 _("a variable at offset %s from base reg $%s"),
2002 gdbarch_register_name (gdbarch
, regno
));
2005 /* The location expression for a TLS variable looks like this (on a
2008 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
2009 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
2011 0x3 is the encoding for DW_OP_addr, which has an operand as long
2012 as the size of an address on the target machine (here is 8
2013 bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
2014 The operand represents the offset at which the variable is within
2015 the thread local storage. */
2017 else if (data
+ 1 + addr_size
< end
2018 && data
[0] == DW_OP_addr
2019 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
2020 && piece_end_p (data
+ 2 + addr_size
, end
))
2023 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
2024 gdbarch_byte_order (gdbarch
));
2026 fprintf_filtered (stream
,
2027 _("a thread-local variable at offset 0x%s "
2028 "in the thread-local storage for `%s'"),
2029 phex_nz (offset
, addr_size
), objfile
->name
);
2031 data
+= 1 + addr_size
+ 1;
2033 else if (data
[0] >= DW_OP_lit0
2034 && data
[0] <= DW_OP_lit31
2036 && data
[1] == DW_OP_stack_value
)
2038 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
2045 /* Disassemble an expression, stopping at the end of a piece or at the
2046 end of the expression. Returns a pointer to the next unread byte
2047 in the input expression. If ALL is nonzero, then this function
2048 will keep going until it reaches the end of the expression. */
2050 static const gdb_byte
*
2051 disassemble_dwarf_expression (struct ui_file
*stream
,
2052 struct gdbarch
*arch
, unsigned int addr_size
,
2054 const gdb_byte
*data
, const gdb_byte
*end
,
2057 const gdb_byte
*start
= data
;
2059 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
2063 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
2065 enum dwarf_location_atom op
= *data
++;
2070 name
= dwarf_stack_op_name (op
, 0);
2073 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
2074 op
, (long) (data
- start
));
2075 fprintf_filtered (stream
, " % 4ld: %s", (long) (data
- start
), name
);
2080 ul
= extract_unsigned_integer (data
, addr_size
,
2081 gdbarch_byte_order (arch
));
2083 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
2087 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
2089 fprintf_filtered (stream
, " %s", pulongest (ul
));
2092 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
2094 fprintf_filtered (stream
, " %s", plongest (l
));
2097 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
2099 fprintf_filtered (stream
, " %s", pulongest (ul
));
2102 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
2104 fprintf_filtered (stream
, " %s", plongest (l
));
2107 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
2109 fprintf_filtered (stream
, " %s", pulongest (ul
));
2112 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
2114 fprintf_filtered (stream
, " %s", plongest (l
));
2117 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
2119 fprintf_filtered (stream
, " %s", pulongest (ul
));
2122 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
2124 fprintf_filtered (stream
, " %s", plongest (l
));
2127 data
= read_uleb128 (data
, end
, &ul
);
2128 fprintf_filtered (stream
, " %s", pulongest (ul
));
2131 data
= read_sleb128 (data
, end
, &l
);
2132 fprintf_filtered (stream
, " %s", plongest (l
));
2167 fprintf_filtered (stream
, " [$%s]",
2168 gdbarch_register_name (arch
, op
- DW_OP_reg0
));
2172 data
= read_uleb128 (data
, end
, &ul
);
2173 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
2174 gdbarch_register_name (arch
, (int) ul
));
2177 case DW_OP_implicit_value
:
2178 data
= read_uleb128 (data
, end
, &ul
);
2180 fprintf_filtered (stream
, " %s", pulongest (ul
));
2215 data
= read_sleb128 (data
, end
, &ul
);
2216 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
2217 gdbarch_register_name (arch
, op
- DW_OP_breg0
));
2224 data
= read_uleb128 (data
, end
, &ul
);
2225 data
= read_sleb128 (data
, end
, &offset
);
2226 fprintf_filtered (stream
, " register %s [$%s] offset %s",
2228 gdbarch_register_name (arch
, (int) ul
),
2229 pulongest (offset
));
2234 data
= read_sleb128 (data
, end
, &ul
);
2235 fprintf_filtered (stream
, " %s", pulongest (ul
));
2238 case DW_OP_xderef_size
:
2239 case DW_OP_deref_size
:
2241 fprintf_filtered (stream
, " %d", *data
);
2245 case DW_OP_plus_uconst
:
2246 data
= read_uleb128 (data
, end
, &ul
);
2247 fprintf_filtered (stream
, " %s", pulongest (ul
));
2251 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
2253 fprintf_filtered (stream
, " to %ld",
2254 (long) (data
+ l
- start
));
2258 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
2260 fprintf_filtered (stream
, " %ld",
2261 (long) (data
+ l
- start
));
2265 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
2267 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
2271 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
2273 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
2276 case DW_OP_call_ref
:
2277 ul
= extract_unsigned_integer (data
, offset_size
,
2278 gdbarch_byte_order (arch
));
2279 data
+= offset_size
;
2280 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
2284 data
= read_uleb128 (data
, end
, &ul
);
2285 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
2288 case DW_OP_bit_piece
:
2292 data
= read_uleb128 (data
, end
, &ul
);
2293 data
= read_uleb128 (data
, end
, &offset
);
2294 fprintf_filtered (stream
, " size %s offset %s (bits)",
2295 pulongest (ul
), pulongest (offset
));
2300 fprintf_filtered (stream
, "\n");
2306 /* Describe a single location, which may in turn consist of multiple
2310 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
2311 struct ui_file
*stream
,
2312 const gdb_byte
*data
, int size
,
2313 struct objfile
*objfile
, unsigned int addr_size
,
2316 const gdb_byte
*end
= data
+ size
;
2317 int first_piece
= 1, bad
= 0;
2321 const gdb_byte
*here
= data
;
2322 int disassemble
= 1;
2327 fprintf_filtered (stream
, _(", and "));
2329 if (!dwarf2_always_disassemble
)
2331 data
= locexpr_describe_location_piece (symbol
, stream
, addr
, objfile
,
2332 data
, end
, addr_size
);
2333 /* If we printed anything, or if we have an empty piece,
2334 then don't disassemble. */
2336 || data
[0] == DW_OP_piece
2337 || data
[0] == DW_OP_bit_piece
)
2341 data
= disassemble_dwarf_expression (stream
, get_objfile_arch (objfile
),
2342 addr_size
, offset_size
, data
, end
,
2343 dwarf2_always_disassemble
);
2347 int empty
= data
== here
;
2350 fprintf_filtered (stream
, " ");
2351 if (data
[0] == DW_OP_piece
)
2355 data
= read_uleb128 (data
+ 1, end
, &bytes
);
2358 fprintf_filtered (stream
, _("an empty %s-byte piece"),
2361 fprintf_filtered (stream
, _(" [%s-byte piece]"),
2364 else if (data
[0] == DW_OP_bit_piece
)
2366 ULONGEST bits
, offset
;
2368 data
= read_uleb128 (data
+ 1, end
, &bits
);
2369 data
= read_uleb128 (data
, end
, &offset
);
2372 fprintf_filtered (stream
,
2373 _("an empty %s-bit piece"),
2376 fprintf_filtered (stream
,
2377 _(" [%s-bit piece, offset %s bits]"),
2378 pulongest (bits
), pulongest (offset
));
2388 if (bad
|| data
> end
)
2389 error (_("Corrupted DWARF2 expression for \"%s\"."),
2390 SYMBOL_PRINT_NAME (symbol
));
2393 /* Print a natural-language description of SYMBOL to STREAM. This
2394 version is for a symbol with a single location. */
2397 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
2398 struct ui_file
*stream
)
2400 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2401 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2402 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2403 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
2405 locexpr_describe_location_1 (symbol
, addr
, stream
, dlbaton
->data
, dlbaton
->size
,
2406 objfile
, addr_size
, offset_size
);
2409 /* Describe the location of SYMBOL as an agent value in VALUE, generating
2410 any necessary bytecode in AX. */
2413 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
2414 struct agent_expr
*ax
, struct axs_value
*value
)
2416 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2417 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2419 compile_dwarf_to_ax (ax
, value
, gdbarch
, addr_size
,
2420 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
2424 /* The set of location functions used with the DWARF-2 expression
2426 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
2427 locexpr_read_variable
,
2428 locexpr_read_needs_frame
,
2429 locexpr_describe_location
,
2430 locexpr_tracepoint_var_ref
2434 /* Wrapper functions for location lists. These generally find
2435 the appropriate location expression and call something above. */
2437 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
2438 evaluator to calculate the location. */
2439 static struct value
*
2440 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
2442 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2444 const gdb_byte
*data
;
2447 data
= find_location_expression (dlbaton
, &size
,
2448 frame
? get_frame_address_in_block (frame
)
2452 val
= allocate_value (SYMBOL_TYPE (symbol
));
2453 VALUE_LVAL (val
) = not_lval
;
2454 set_value_optimized_out (val
, 1);
2457 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
2463 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
2465 loclist_read_needs_frame (struct symbol
*symbol
)
2467 /* If there's a location list, then assume we need to have a frame
2468 to choose the appropriate location expression. With tracking of
2469 global variables this is not necessarily true, but such tracking
2470 is disabled in GCC at the moment until we figure out how to
2476 /* Print a natural-language description of SYMBOL to STREAM. This
2477 version applies when there is a list of different locations, each
2478 with a specified address range. */
2481 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
2482 struct ui_file
*stream
)
2484 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2485 CORE_ADDR low
, high
;
2486 const gdb_byte
*loc_ptr
, *buf_end
;
2487 int length
, first
= 1;
2488 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2489 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2490 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2491 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2492 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
2493 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
2494 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
2495 /* Adjust base_address for relocatable objects. */
2496 CORE_ADDR base_offset
= ANOFFSET (objfile
->section_offsets
,
2497 SECT_OFF_TEXT (objfile
));
2498 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
2500 loc_ptr
= dlbaton
->data
;
2501 buf_end
= dlbaton
->data
+ dlbaton
->size
;
2503 fprintf_filtered (stream
, _("multi-location:\n"));
2505 /* Iterate through locations until we run out. */
2508 if (buf_end
- loc_ptr
< 2 * addr_size
)
2509 error (_("Corrupted DWARF expression for symbol \"%s\"."),
2510 SYMBOL_PRINT_NAME (symbol
));
2513 low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
2515 low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
2516 loc_ptr
+= addr_size
;
2519 high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
2521 high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
2522 loc_ptr
+= addr_size
;
2524 /* A base-address-selection entry. */
2525 if ((low
& base_mask
) == base_mask
)
2527 base_address
= high
+ base_offset
;
2528 fprintf_filtered (stream
, _(" Base address %s"),
2529 paddress (gdbarch
, base_address
));
2533 /* An end-of-list entry. */
2534 if (low
== 0 && high
== 0)
2537 /* Otherwise, a location expression entry. */
2538 low
+= base_address
;
2539 high
+= base_address
;
2541 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
2544 /* (It would improve readability to print only the minimum
2545 necessary digits of the second number of the range.) */
2546 fprintf_filtered (stream
, _(" Range %s-%s: "),
2547 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
2549 /* Now describe this particular location. */
2550 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
2551 objfile
, addr_size
, offset_size
);
2553 fprintf_filtered (stream
, "\n");
2559 /* Describe the location of SYMBOL as an agent value in VALUE, generating
2560 any necessary bytecode in AX. */
2562 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
2563 struct agent_expr
*ax
, struct axs_value
*value
)
2565 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2566 const gdb_byte
*data
;
2568 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2570 data
= find_location_expression (dlbaton
, &size
, ax
->scope
);
2572 compile_dwarf_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
2576 /* The set of location functions used with the DWARF-2 expression
2577 evaluator and location lists. */
2578 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
2579 loclist_read_variable
,
2580 loclist_read_needs_frame
,
2581 loclist_describe_location
,
2582 loclist_tracepoint_var_ref