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
;
894 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
898 retval
= allocate_value (type
);
899 VALUE_LVAL (retval
) = not_lval
;
900 set_value_optimized_out (retval
, 1);
905 baton
.per_cu
= per_cu
;
907 ctx
= new_dwarf_expr_context ();
908 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
910 ctx
->gdbarch
= get_objfile_arch (objfile
);
911 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
912 ctx
->offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
914 ctx
->read_reg
= dwarf_expr_read_reg
;
915 ctx
->read_mem
= dwarf_expr_read_mem
;
916 ctx
->get_frame_base
= dwarf_expr_frame_base
;
917 ctx
->get_frame_cfa
= dwarf_expr_frame_cfa
;
918 ctx
->get_tls_address
= dwarf_expr_tls_address
;
919 ctx
->dwarf_call
= dwarf_expr_dwarf_call
;
921 dwarf_expr_eval (ctx
, data
, size
);
922 if (ctx
->num_pieces
> 0)
924 struct piece_closure
*c
;
925 struct frame_id frame_id
= get_frame_id (frame
);
927 c
= allocate_piece_closure (ctx
->num_pieces
, ctx
->pieces
,
929 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
930 VALUE_FRAME_ID (retval
) = frame_id
;
934 switch (ctx
->location
)
936 case DWARF_VALUE_REGISTER
:
938 struct gdbarch
*arch
= get_frame_arch (frame
);
939 ULONGEST dwarf_regnum
= dwarf_expr_fetch (ctx
, 0);
940 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
942 if (gdb_regnum
!= -1)
943 retval
= value_from_register (type
, gdb_regnum
, frame
);
945 error (_("Unable to access DWARF register number %s"),
946 paddress (arch
, dwarf_regnum
));
950 case DWARF_VALUE_MEMORY
:
952 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
953 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
955 retval
= allocate_value (type
);
956 VALUE_LVAL (retval
) = lval_memory
;
957 set_value_lazy (retval
, 1);
959 set_value_stack (retval
, 1);
960 set_value_address (retval
, address
);
964 case DWARF_VALUE_STACK
:
966 ULONGEST value
= dwarf_expr_fetch (ctx
, 0);
968 size_t n
= ctx
->addr_size
;
970 retval
= allocate_value (type
);
971 contents
= value_contents_raw (retval
);
972 if (n
> TYPE_LENGTH (type
))
973 n
= TYPE_LENGTH (type
);
974 store_unsigned_integer (contents
, n
,
975 gdbarch_byte_order (ctx
->gdbarch
),
980 case DWARF_VALUE_LITERAL
:
985 retval
= allocate_value (type
);
986 contents
= value_contents_raw (retval
);
987 if (n
> TYPE_LENGTH (type
))
988 n
= TYPE_LENGTH (type
);
989 memcpy (contents
, ctx
->data
, n
);
993 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
994 it can only be encountered when making a piece. */
995 case DWARF_VALUE_OPTIMIZED_OUT
:
997 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1001 set_value_initialized (retval
, ctx
->initialized
);
1003 do_cleanups (old_chain
);
1008 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
1010 struct needs_frame_baton
1013 struct dwarf2_per_cu_data
*per_cu
;
1016 /* Reads from registers do require a frame. */
1018 needs_frame_read_reg (void *baton
, int regnum
)
1020 struct needs_frame_baton
*nf_baton
= baton
;
1022 nf_baton
->needs_frame
= 1;
1026 /* Reads from memory do not require a frame. */
1028 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
1030 memset (buf
, 0, len
);
1033 /* Frame-relative accesses do require a frame. */
1035 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
1037 static gdb_byte lit0
= DW_OP_lit0
;
1038 struct needs_frame_baton
*nf_baton
= baton
;
1043 nf_baton
->needs_frame
= 1;
1046 /* CFA accesses require a frame. */
1049 needs_frame_frame_cfa (void *baton
)
1051 struct needs_frame_baton
*nf_baton
= baton
;
1053 nf_baton
->needs_frame
= 1;
1057 /* Thread-local accesses do require a frame. */
1059 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
1061 struct needs_frame_baton
*nf_baton
= baton
;
1063 nf_baton
->needs_frame
= 1;
1067 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
1070 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, size_t die_offset
)
1072 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
1074 return per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
);
1077 /* Return non-zero iff the location expression at DATA (length SIZE)
1078 requires a frame to evaluate. */
1081 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, unsigned short size
,
1082 struct dwarf2_per_cu_data
*per_cu
)
1084 struct needs_frame_baton baton
;
1085 struct dwarf_expr_context
*ctx
;
1087 struct cleanup
*old_chain
;
1088 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
1090 baton
.needs_frame
= 0;
1091 baton
.per_cu
= per_cu
;
1093 ctx
= new_dwarf_expr_context ();
1094 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
1096 ctx
->gdbarch
= get_objfile_arch (objfile
);
1097 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
1098 ctx
->offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1099 ctx
->baton
= &baton
;
1100 ctx
->read_reg
= needs_frame_read_reg
;
1101 ctx
->read_mem
= needs_frame_read_mem
;
1102 ctx
->get_frame_base
= needs_frame_frame_base
;
1103 ctx
->get_frame_cfa
= needs_frame_frame_cfa
;
1104 ctx
->get_tls_address
= needs_frame_tls_address
;
1105 ctx
->dwarf_call
= needs_frame_dwarf_call
;
1107 dwarf_expr_eval (ctx
, data
, size
);
1109 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
1111 if (ctx
->num_pieces
> 0)
1115 /* If the location has several pieces, and any of them are in
1116 registers, then we will need a frame to fetch them from. */
1117 for (i
= 0; i
< ctx
->num_pieces
; i
++)
1118 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
1122 do_cleanups (old_chain
);
1124 return baton
.needs_frame
|| in_reg
;
1127 /* A helper function that throws an unimplemented error mentioning a
1128 given DWARF operator. */
1131 unimplemented (unsigned int op
)
1133 error (_("DWARF operator %s cannot be translated to an agent expression"),
1134 dwarf_stack_op_name (op
, 1));
1137 /* A helper function to convert a DWARF register to an arch register.
1138 ARCH is the architecture.
1139 DWARF_REG is the register.
1140 This will throw an exception if the DWARF register cannot be
1141 translated to an architecture register. */
1144 translate_register (struct gdbarch
*arch
, int dwarf_reg
)
1146 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
1148 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
1152 /* A helper function that emits an access to memory. ARCH is the
1153 target architecture. EXPR is the expression which we are building.
1154 NBITS is the number of bits we want to read. This emits the
1155 opcodes needed to read the memory and then extract the desired
1159 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
1161 ULONGEST nbytes
= (nbits
+ 7) / 8;
1163 gdb_assert (nbits
> 0 && nbits
<= sizeof (LONGEST
));
1166 ax_trace_quick (expr
, nbytes
);
1169 ax_simple (expr
, aop_ref8
);
1170 else if (nbits
<= 16)
1171 ax_simple (expr
, aop_ref16
);
1172 else if (nbits
<= 32)
1173 ax_simple (expr
, aop_ref32
);
1175 ax_simple (expr
, aop_ref64
);
1177 /* If we read exactly the number of bytes we wanted, we're done. */
1178 if (8 * nbytes
== nbits
)
1181 if (gdbarch_bits_big_endian (arch
))
1183 /* On a bits-big-endian machine, we want the high-order
1185 ax_const_l (expr
, 8 * nbytes
- nbits
);
1186 ax_simple (expr
, aop_rsh_unsigned
);
1190 /* On a bits-little-endian box, we want the low-order NBITS. */
1191 ax_zero_ext (expr
, nbits
);
1195 /* Compile a DWARF location expression to an agent expression.
1197 EXPR is the agent expression we are building.
1198 LOC is the agent value we modify.
1199 ARCH is the architecture.
1200 ADDR_SIZE is the size of addresses, in bytes.
1201 OP_PTR is the start of the location expression.
1202 OP_END is one past the last byte of the location expression.
1204 This will throw an exception for various kinds of errors -- for
1205 example, if the expression cannot be compiled, or if the expression
1209 compile_dwarf_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
1210 struct gdbarch
*arch
, unsigned int addr_size
,
1211 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
1212 struct dwarf2_per_cu_data
*per_cu
)
1214 struct cleanup
*cleanups
;
1216 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
1217 const gdb_byte
* const base
= op_ptr
;
1218 const gdb_byte
*previous_piece
= op_ptr
;
1219 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
1220 ULONGEST bits_collected
= 0;
1221 unsigned int addr_size_bits
= 8 * addr_size
;
1222 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
1224 offsets
= xmalloc ((op_end
- op_ptr
) * sizeof (int));
1225 cleanups
= make_cleanup (xfree
, offsets
);
1227 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
1230 make_cleanup (VEC_cleanup (int), &dw_labels
);
1231 make_cleanup (VEC_cleanup (int), &patches
);
1233 /* By default we are making an address. */
1234 loc
->kind
= axs_lvalue_memory
;
1236 while (op_ptr
< op_end
)
1238 enum dwarf_location_atom op
= *op_ptr
;
1239 ULONGEST uoffset
, reg
;
1243 offsets
[op_ptr
- base
] = expr
->len
;
1246 /* Our basic approach to code generation is to map DWARF
1247 operations directly to AX operations. However, there are
1250 First, DWARF works on address-sized units, but AX always uses
1251 LONGEST. For most operations we simply ignore this
1252 difference; instead we generate sign extensions as needed
1253 before division and comparison operations. It would be nice
1254 to omit the sign extensions, but there is no way to determine
1255 the size of the target's LONGEST. (This code uses the size
1256 of the host LONGEST in some cases -- that is a bug but it is
1259 Second, some DWARF operations cannot be translated to AX.
1260 For these we simply fail. See
1261 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
1296 ax_const_l (expr
, op
- DW_OP_lit0
);
1300 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
1301 op_ptr
+= addr_size
;
1302 /* Some versions of GCC emit DW_OP_addr before
1303 DW_OP_GNU_push_tls_address. In this case the value is an
1304 index, not an address. We don't support things like
1305 branching between the address and the TLS op. */
1306 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
1308 struct objfile
*objfile
= dwarf2_per_cu_objfile (per_cu
);
1310 uoffset
+= ANOFFSET (objfile
->section_offsets
,
1311 SECT_OFF_TEXT (objfile
));
1313 ax_const_l (expr
, uoffset
);
1317 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
1321 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
1325 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
1329 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
1333 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
1337 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
1341 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
1345 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
1349 op_ptr
= read_uleb128 (op_ptr
, op_end
, &uoffset
);
1350 ax_const_l (expr
, uoffset
);
1353 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1354 ax_const_l (expr
, offset
);
1389 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
1390 loc
->u
.reg
= translate_register (arch
, op
- DW_OP_reg0
);
1391 loc
->kind
= axs_lvalue_register
;
1395 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
1396 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
1397 loc
->u
.reg
= translate_register (arch
, reg
);
1398 loc
->kind
= axs_lvalue_register
;
1401 case DW_OP_implicit_value
:
1405 op_ptr
= read_uleb128 (op_ptr
, op_end
, &len
);
1406 if (op_ptr
+ len
> op_end
)
1407 error (_("DW_OP_implicit_value: too few bytes available."));
1408 if (len
> sizeof (ULONGEST
))
1409 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
1412 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
1415 dwarf_expr_require_composition (op_ptr
, op_end
,
1416 "DW_OP_implicit_value");
1418 loc
->kind
= axs_rvalue
;
1422 case DW_OP_stack_value
:
1423 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
1424 loc
->kind
= axs_rvalue
;
1459 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1460 i
= translate_register (arch
, op
- DW_OP_breg0
);
1464 ax_const_l (expr
, offset
);
1465 ax_simple (expr
, aop_add
);
1470 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
1471 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1472 i
= translate_register (arch
, reg
);
1476 ax_const_l (expr
, offset
);
1477 ax_simple (expr
, aop_add
);
1483 const gdb_byte
*datastart
;
1485 unsigned int before_stack_len
;
1487 struct symbol
*framefunc
;
1488 LONGEST base_offset
= 0;
1490 b
= block_for_pc (expr
->scope
);
1493 error (_("No block found for address"));
1495 framefunc
= block_linkage_function (b
);
1498 error (_("No function found for block"));
1500 dwarf_expr_frame_base_1 (framefunc
, expr
->scope
,
1501 &datastart
, &datalen
);
1503 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1504 compile_dwarf_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
1505 datastart
+ datalen
, per_cu
);
1509 ax_const_l (expr
, offset
);
1510 ax_simple (expr
, aop_add
);
1513 loc
->kind
= axs_lvalue_memory
;
1518 ax_simple (expr
, aop_dup
);
1522 ax_simple (expr
, aop_pop
);
1531 ax_simple (expr
, aop_swap
);
1535 /* We can't directly support DW_OP_over, but GCC emits it as
1536 part of a sequence to implement signed modulus. As a
1537 hack, we recognize this sequence. Note that if GCC ever
1538 generates a branch to the middle of this sequence, then
1539 we will die somehow. */
1540 if (op_end
- op_ptr
>= 4
1541 && op_ptr
[0] == DW_OP_over
1542 && op_ptr
[1] == DW_OP_div
1543 && op_ptr
[2] == DW_OP_mul
1544 && op_ptr
[3] == DW_OP_minus
)
1546 /* Sign extend the operands. */
1547 ax_ext (expr
, addr_size_bits
);
1548 ax_simple (expr
, aop_swap
);
1549 ax_ext (expr
, addr_size_bits
);
1550 ax_simple (expr
, aop_swap
);
1551 ax_simple (expr
, aop_rem_signed
);
1563 case DW_OP_deref_size
:
1567 if (op
== DW_OP_deref_size
)
1575 ax_simple (expr
, aop_ref8
);
1578 ax_simple (expr
, aop_ref16
);
1581 ax_simple (expr
, aop_ref32
);
1584 ax_simple (expr
, aop_ref64
);
1587 error (_("Unsupported size %d in %s"),
1588 size
, dwarf_stack_op_name (op
, 1));
1594 /* Sign extend the operand. */
1595 ax_ext (expr
, addr_size_bits
);
1596 ax_simple (expr
, aop_dup
);
1597 ax_const_l (expr
, 0);
1598 ax_simple (expr
, aop_less_signed
);
1599 ax_simple (expr
, aop_log_not
);
1600 i
= ax_goto (expr
, aop_if_goto
);
1601 /* We have to emit 0 - X. */
1602 ax_const_l (expr
, 0);
1603 ax_simple (expr
, aop_swap
);
1604 ax_simple (expr
, aop_sub
);
1605 ax_label (expr
, i
, expr
->len
);
1609 /* No need to sign extend here. */
1610 ax_const_l (expr
, 0);
1611 ax_simple (expr
, aop_swap
);
1612 ax_simple (expr
, aop_sub
);
1616 /* Sign extend the operand. */
1617 ax_ext (expr
, addr_size_bits
);
1618 ax_simple (expr
, aop_bit_not
);
1621 case DW_OP_plus_uconst
:
1622 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
1623 /* It would be really weird to emit `DW_OP_plus_uconst 0',
1624 but we micro-optimize anyhow. */
1627 ax_const_l (expr
, reg
);
1628 ax_simple (expr
, aop_add
);
1633 ax_simple (expr
, aop_bit_and
);
1637 /* Sign extend the operands. */
1638 ax_ext (expr
, addr_size_bits
);
1639 ax_simple (expr
, aop_swap
);
1640 ax_ext (expr
, addr_size_bits
);
1641 ax_simple (expr
, aop_swap
);
1642 ax_simple (expr
, aop_div_signed
);
1646 ax_simple (expr
, aop_sub
);
1650 ax_simple (expr
, aop_rem_unsigned
);
1654 ax_simple (expr
, aop_mul
);
1658 ax_simple (expr
, aop_bit_or
);
1662 ax_simple (expr
, aop_add
);
1666 ax_simple (expr
, aop_lsh
);
1670 ax_simple (expr
, aop_rsh_unsigned
);
1674 ax_simple (expr
, aop_rsh_signed
);
1678 ax_simple (expr
, aop_bit_xor
);
1682 /* Sign extend the operands. */
1683 ax_ext (expr
, addr_size_bits
);
1684 ax_simple (expr
, aop_swap
);
1685 ax_ext (expr
, addr_size_bits
);
1686 /* Note no swap here: A <= B is !(B < A). */
1687 ax_simple (expr
, aop_less_signed
);
1688 ax_simple (expr
, aop_log_not
);
1692 /* Sign extend the operands. */
1693 ax_ext (expr
, addr_size_bits
);
1694 ax_simple (expr
, aop_swap
);
1695 ax_ext (expr
, addr_size_bits
);
1696 ax_simple (expr
, aop_swap
);
1697 /* A >= B is !(A < B). */
1698 ax_simple (expr
, aop_less_signed
);
1699 ax_simple (expr
, aop_log_not
);
1703 /* Sign extend the operands. */
1704 ax_ext (expr
, addr_size_bits
);
1705 ax_simple (expr
, aop_swap
);
1706 ax_ext (expr
, addr_size_bits
);
1707 /* No need for a second swap here. */
1708 ax_simple (expr
, aop_equal
);
1712 /* Sign extend the operands. */
1713 ax_ext (expr
, addr_size_bits
);
1714 ax_simple (expr
, aop_swap
);
1715 ax_ext (expr
, addr_size_bits
);
1716 ax_simple (expr
, aop_swap
);
1717 ax_simple (expr
, aop_less_signed
);
1721 /* Sign extend the operands. */
1722 ax_ext (expr
, addr_size_bits
);
1723 ax_simple (expr
, aop_swap
);
1724 ax_ext (expr
, addr_size_bits
);
1725 /* Note no swap here: A > B is B < A. */
1726 ax_simple (expr
, aop_less_signed
);
1730 /* Sign extend the operands. */
1731 ax_ext (expr
, addr_size_bits
);
1732 ax_simple (expr
, aop_swap
);
1733 ax_ext (expr
, addr_size_bits
);
1734 /* No need for a swap here. */
1735 ax_simple (expr
, aop_equal
);
1736 ax_simple (expr
, aop_log_not
);
1739 case DW_OP_call_frame_cfa
:
1743 case DW_OP_GNU_push_tls_address
:
1748 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
1750 i
= ax_goto (expr
, aop_goto
);
1751 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
1752 VEC_safe_push (int, patches
, i
);
1756 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
1758 /* Zero extend the operand. */
1759 ax_zero_ext (expr
, addr_size_bits
);
1760 i
= ax_goto (expr
, aop_if_goto
);
1761 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
1762 VEC_safe_push (int, patches
, i
);
1769 case DW_OP_bit_piece
:
1771 ULONGEST size
, offset
;
1773 if (op_ptr
- 1 == previous_piece
)
1774 error (_("Cannot translate empty pieces to agent expressions"));
1775 previous_piece
= op_ptr
- 1;
1777 op_ptr
= read_uleb128 (op_ptr
, op_end
, &size
);
1778 if (op
== DW_OP_piece
)
1784 op_ptr
= read_uleb128 (op_ptr
, op_end
, &offset
);
1786 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
1787 error (_("Expression pieces exceed word size"));
1789 /* Access the bits. */
1792 case axs_lvalue_register
:
1793 ax_reg (expr
, loc
->u
.reg
);
1796 case axs_lvalue_memory
:
1797 /* Offset the pointer, if needed. */
1800 ax_const_l (expr
, offset
/ 8);
1801 ax_simple (expr
, aop_add
);
1804 access_memory (arch
, expr
, size
);
1808 /* For a bits-big-endian target, shift up what we already
1809 have. For a bits-little-endian target, shift up the
1810 new data. Note that there is a potential bug here if
1811 the DWARF expression leaves multiple values on the
1813 if (bits_collected
> 0)
1815 if (bits_big_endian
)
1817 ax_simple (expr
, aop_swap
);
1818 ax_const_l (expr
, size
);
1819 ax_simple (expr
, aop_lsh
);
1820 /* We don't need a second swap here, because
1821 aop_bit_or is symmetric. */
1825 ax_const_l (expr
, size
);
1826 ax_simple (expr
, aop_lsh
);
1828 ax_simple (expr
, aop_bit_or
);
1831 bits_collected
+= size
;
1832 loc
->kind
= axs_rvalue
;
1836 case DW_OP_GNU_uninit
:
1842 struct dwarf2_locexpr_baton block
;
1843 int size
= (op
== DW_OP_call2
? 2 : 4);
1845 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
1848 block
= dwarf2_fetch_die_location_block (uoffset
, per_cu
);
1850 /* DW_OP_call_ref is currently not supported. */
1851 gdb_assert (block
.per_cu
== per_cu
);
1853 compile_dwarf_to_ax (expr
, loc
, arch
, addr_size
,
1854 block
.data
, block
.data
+ block
.size
,
1859 case DW_OP_call_ref
:
1863 error (_("Unhandled dwarf expression opcode 0x%x"), op
);
1867 /* Patch all the branches we emitted. */
1868 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
1870 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
1872 internal_error (__FILE__
, __LINE__
, _("invalid label"));
1873 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
1876 do_cleanups (cleanups
);
1880 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
1881 evaluator to calculate the location. */
1882 static struct value
*
1883 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
1885 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
1888 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
1889 dlbaton
->size
, dlbaton
->per_cu
);
1894 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
1896 locexpr_read_needs_frame (struct symbol
*symbol
)
1898 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
1900 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
1904 /* Return true if DATA points to the end of a piece. END is one past
1905 the last byte in the expression. */
1908 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
1910 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
1913 /* Nicely describe a single piece of a location, returning an updated
1914 position in the bytecode sequence. This function cannot recognize
1915 all locations; if a location is not recognized, it simply returns
1918 static const gdb_byte
*
1919 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
1920 CORE_ADDR addr
, struct objfile
*objfile
,
1921 const gdb_byte
*data
, const gdb_byte
*end
,
1922 unsigned int addr_size
)
1924 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1927 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
1929 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, data
[0] - DW_OP_reg0
);
1930 fprintf_filtered (stream
, _("a variable in $%s"),
1931 gdbarch_register_name (gdbarch
, regno
));
1934 else if (data
[0] == DW_OP_regx
)
1938 data
= read_uleb128 (data
+ 1, end
, ®
);
1939 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
);
1940 fprintf_filtered (stream
, _("a variable in $%s"),
1941 gdbarch_register_name (gdbarch
, regno
));
1943 else if (data
[0] == DW_OP_fbreg
)
1946 struct symbol
*framefunc
;
1948 LONGEST frame_offset
;
1949 const gdb_byte
*base_data
, *new_data
;
1951 LONGEST base_offset
= 0;
1953 new_data
= read_sleb128 (data
+ 1, end
, &frame_offset
);
1954 if (!piece_end_p (new_data
, end
))
1958 b
= block_for_pc (addr
);
1961 error (_("No block found for address for symbol \"%s\"."),
1962 SYMBOL_PRINT_NAME (symbol
));
1964 framefunc
= block_linkage_function (b
);
1967 error (_("No function found for block for symbol \"%s\"."),
1968 SYMBOL_PRINT_NAME (symbol
));
1970 dwarf_expr_frame_base_1 (framefunc
, addr
, &base_data
, &base_size
);
1972 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
1974 const gdb_byte
*buf_end
;
1976 frame_reg
= base_data
[0] - DW_OP_breg0
;
1977 buf_end
= read_sleb128 (base_data
+ 1,
1978 base_data
+ base_size
, &base_offset
);
1979 if (buf_end
!= base_data
+ base_size
)
1980 error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
1981 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
1983 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
1985 /* The frame base is just the register, with no offset. */
1986 frame_reg
= base_data
[0] - DW_OP_reg0
;
1991 /* We don't know what to do with the frame base expression,
1992 so we can't trace this variable; give up. */
1993 error (_("Cannot describe location of symbol \"%s\"; "
1994 "DWARF 2 encoding not handled, "
1995 "first opcode in base data is 0x%x."),
1996 SYMBOL_PRINT_NAME (symbol
), base_data
[0]);
1999 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, frame_reg
);
2001 fprintf_filtered (stream
, _("a variable at frame base reg $%s offset %s+%s"),
2002 gdbarch_register_name (gdbarch
, regno
),
2003 plongest (base_offset
), plongest (frame_offset
));
2005 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
2006 && piece_end_p (data
, end
))
2010 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, data
[0] - DW_OP_breg0
);
2012 data
= read_sleb128 (data
+ 1, end
, &offset
);
2014 fprintf_filtered (stream
,
2015 _("a variable at offset %s from base reg $%s"),
2017 gdbarch_register_name (gdbarch
, regno
));
2020 /* The location expression for a TLS variable looks like this (on a
2023 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
2024 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
2026 0x3 is the encoding for DW_OP_addr, which has an operand as long
2027 as the size of an address on the target machine (here is 8
2028 bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
2029 The operand represents the offset at which the variable is within
2030 the thread local storage. */
2032 else if (data
+ 1 + addr_size
< end
2033 && data
[0] == DW_OP_addr
2034 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
2035 && piece_end_p (data
+ 2 + addr_size
, end
))
2038 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
2039 gdbarch_byte_order (gdbarch
));
2041 fprintf_filtered (stream
,
2042 _("a thread-local variable at offset 0x%s "
2043 "in the thread-local storage for `%s'"),
2044 phex_nz (offset
, addr_size
), objfile
->name
);
2046 data
+= 1 + addr_size
+ 1;
2048 else if (data
[0] >= DW_OP_lit0
2049 && data
[0] <= DW_OP_lit31
2051 && data
[1] == DW_OP_stack_value
)
2053 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
2060 /* Disassemble an expression, stopping at the end of a piece or at the
2061 end of the expression. Returns a pointer to the next unread byte
2062 in the input expression. If ALL is nonzero, then this function
2063 will keep going until it reaches the end of the expression. */
2065 static const gdb_byte
*
2066 disassemble_dwarf_expression (struct ui_file
*stream
,
2067 struct gdbarch
*arch
, unsigned int addr_size
,
2069 const gdb_byte
*data
, const gdb_byte
*end
,
2072 const gdb_byte
*start
= data
;
2074 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
2078 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
2080 enum dwarf_location_atom op
= *data
++;
2085 name
= dwarf_stack_op_name (op
, 0);
2088 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
2089 op
, (long) (data
- start
));
2090 fprintf_filtered (stream
, " % 4ld: %s", (long) (data
- start
), name
);
2095 ul
= extract_unsigned_integer (data
, addr_size
,
2096 gdbarch_byte_order (arch
));
2098 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
2102 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
2104 fprintf_filtered (stream
, " %s", pulongest (ul
));
2107 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
2109 fprintf_filtered (stream
, " %s", plongest (l
));
2112 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
2114 fprintf_filtered (stream
, " %s", pulongest (ul
));
2117 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
2119 fprintf_filtered (stream
, " %s", plongest (l
));
2122 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
2124 fprintf_filtered (stream
, " %s", pulongest (ul
));
2127 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
2129 fprintf_filtered (stream
, " %s", plongest (l
));
2132 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
2134 fprintf_filtered (stream
, " %s", pulongest (ul
));
2137 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
2139 fprintf_filtered (stream
, " %s", plongest (l
));
2142 data
= read_uleb128 (data
, end
, &ul
);
2143 fprintf_filtered (stream
, " %s", pulongest (ul
));
2146 data
= read_sleb128 (data
, end
, &l
);
2147 fprintf_filtered (stream
, " %s", plongest (l
));
2182 fprintf_filtered (stream
, " [$%s]",
2183 gdbarch_register_name (arch
, op
- DW_OP_reg0
));
2187 data
= read_uleb128 (data
, end
, &ul
);
2188 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
2189 gdbarch_register_name (arch
, (int) ul
));
2192 case DW_OP_implicit_value
:
2193 data
= read_uleb128 (data
, end
, &ul
);
2195 fprintf_filtered (stream
, " %s", pulongest (ul
));
2230 data
= read_sleb128 (data
, end
, &ul
);
2231 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
2232 gdbarch_register_name (arch
, op
- DW_OP_breg0
));
2239 data
= read_uleb128 (data
, end
, &ul
);
2240 data
= read_sleb128 (data
, end
, &offset
);
2241 fprintf_filtered (stream
, " register %s [$%s] offset %s",
2243 gdbarch_register_name (arch
, (int) ul
),
2244 pulongest (offset
));
2249 data
= read_sleb128 (data
, end
, &ul
);
2250 fprintf_filtered (stream
, " %s", pulongest (ul
));
2253 case DW_OP_xderef_size
:
2254 case DW_OP_deref_size
:
2256 fprintf_filtered (stream
, " %d", *data
);
2260 case DW_OP_plus_uconst
:
2261 data
= read_uleb128 (data
, end
, &ul
);
2262 fprintf_filtered (stream
, " %s", pulongest (ul
));
2266 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
2268 fprintf_filtered (stream
, " to %ld",
2269 (long) (data
+ l
- start
));
2273 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
2275 fprintf_filtered (stream
, " %ld",
2276 (long) (data
+ l
- start
));
2280 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
2282 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
2286 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
2288 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
2291 case DW_OP_call_ref
:
2292 ul
= extract_unsigned_integer (data
, offset_size
,
2293 gdbarch_byte_order (arch
));
2294 data
+= offset_size
;
2295 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
2299 data
= read_uleb128 (data
, end
, &ul
);
2300 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
2303 case DW_OP_bit_piece
:
2307 data
= read_uleb128 (data
, end
, &ul
);
2308 data
= read_uleb128 (data
, end
, &offset
);
2309 fprintf_filtered (stream
, " size %s offset %s (bits)",
2310 pulongest (ul
), pulongest (offset
));
2315 fprintf_filtered (stream
, "\n");
2321 /* Describe a single location, which may in turn consist of multiple
2325 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
2326 struct ui_file
*stream
,
2327 const gdb_byte
*data
, int size
,
2328 struct objfile
*objfile
, unsigned int addr_size
,
2331 const gdb_byte
*end
= data
+ size
;
2332 int first_piece
= 1, bad
= 0;
2336 const gdb_byte
*here
= data
;
2337 int disassemble
= 1;
2342 fprintf_filtered (stream
, _(", and "));
2344 if (!dwarf2_always_disassemble
)
2346 data
= locexpr_describe_location_piece (symbol
, stream
, addr
, objfile
,
2347 data
, end
, addr_size
);
2348 /* If we printed anything, or if we have an empty piece,
2349 then don't disassemble. */
2351 || data
[0] == DW_OP_piece
2352 || data
[0] == DW_OP_bit_piece
)
2356 data
= disassemble_dwarf_expression (stream
, get_objfile_arch (objfile
),
2357 addr_size
, offset_size
, data
, end
,
2358 dwarf2_always_disassemble
);
2362 int empty
= data
== here
;
2365 fprintf_filtered (stream
, " ");
2366 if (data
[0] == DW_OP_piece
)
2370 data
= read_uleb128 (data
+ 1, end
, &bytes
);
2373 fprintf_filtered (stream
, _("an empty %s-byte piece"),
2376 fprintf_filtered (stream
, _(" [%s-byte piece]"),
2379 else if (data
[0] == DW_OP_bit_piece
)
2381 ULONGEST bits
, offset
;
2383 data
= read_uleb128 (data
+ 1, end
, &bits
);
2384 data
= read_uleb128 (data
, end
, &offset
);
2387 fprintf_filtered (stream
,
2388 _("an empty %s-bit piece"),
2391 fprintf_filtered (stream
,
2392 _(" [%s-bit piece, offset %s bits]"),
2393 pulongest (bits
), pulongest (offset
));
2403 if (bad
|| data
> end
)
2404 error (_("Corrupted DWARF2 expression for \"%s\"."),
2405 SYMBOL_PRINT_NAME (symbol
));
2408 /* Print a natural-language description of SYMBOL to STREAM. This
2409 version is for a symbol with a single location. */
2412 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
2413 struct ui_file
*stream
)
2415 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2416 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2417 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2418 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
2420 locexpr_describe_location_1 (symbol
, addr
, stream
, dlbaton
->data
, dlbaton
->size
,
2421 objfile
, addr_size
, offset_size
);
2424 /* Describe the location of SYMBOL as an agent value in VALUE, generating
2425 any necessary bytecode in AX. */
2428 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
2429 struct agent_expr
*ax
, struct axs_value
*value
)
2431 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2432 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2434 if (dlbaton
->data
== NULL
|| dlbaton
->size
== 0)
2435 value
->optimized_out
= 1;
2437 compile_dwarf_to_ax (ax
, value
, gdbarch
, addr_size
,
2438 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
2442 /* The set of location functions used with the DWARF-2 expression
2444 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
2445 locexpr_read_variable
,
2446 locexpr_read_needs_frame
,
2447 locexpr_describe_location
,
2448 locexpr_tracepoint_var_ref
2452 /* Wrapper functions for location lists. These generally find
2453 the appropriate location expression and call something above. */
2455 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
2456 evaluator to calculate the location. */
2457 static struct value
*
2458 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
2460 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2462 const gdb_byte
*data
;
2465 data
= find_location_expression (dlbaton
, &size
,
2466 frame
? get_frame_address_in_block (frame
)
2470 val
= allocate_value (SYMBOL_TYPE (symbol
));
2471 VALUE_LVAL (val
) = not_lval
;
2472 set_value_optimized_out (val
, 1);
2475 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
2481 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
2483 loclist_read_needs_frame (struct symbol
*symbol
)
2485 /* If there's a location list, then assume we need to have a frame
2486 to choose the appropriate location expression. With tracking of
2487 global variables this is not necessarily true, but such tracking
2488 is disabled in GCC at the moment until we figure out how to
2494 /* Print a natural-language description of SYMBOL to STREAM. This
2495 version applies when there is a list of different locations, each
2496 with a specified address range. */
2499 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
2500 struct ui_file
*stream
)
2502 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2503 CORE_ADDR low
, high
;
2504 const gdb_byte
*loc_ptr
, *buf_end
;
2505 int length
, first
= 1;
2506 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2507 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2508 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2509 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2510 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
2511 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
2512 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
2513 /* Adjust base_address for relocatable objects. */
2514 CORE_ADDR base_offset
= ANOFFSET (objfile
->section_offsets
,
2515 SECT_OFF_TEXT (objfile
));
2516 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
2518 loc_ptr
= dlbaton
->data
;
2519 buf_end
= dlbaton
->data
+ dlbaton
->size
;
2521 fprintf_filtered (stream
, _("multi-location:\n"));
2523 /* Iterate through locations until we run out. */
2526 if (buf_end
- loc_ptr
< 2 * addr_size
)
2527 error (_("Corrupted DWARF expression for symbol \"%s\"."),
2528 SYMBOL_PRINT_NAME (symbol
));
2531 low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
2533 low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
2534 loc_ptr
+= addr_size
;
2537 high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
2539 high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
2540 loc_ptr
+= addr_size
;
2542 /* A base-address-selection entry. */
2543 if ((low
& base_mask
) == base_mask
)
2545 base_address
= high
+ base_offset
;
2546 fprintf_filtered (stream
, _(" Base address %s"),
2547 paddress (gdbarch
, base_address
));
2551 /* An end-of-list entry. */
2552 if (low
== 0 && high
== 0)
2555 /* Otherwise, a location expression entry. */
2556 low
+= base_address
;
2557 high
+= base_address
;
2559 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
2562 /* (It would improve readability to print only the minimum
2563 necessary digits of the second number of the range.) */
2564 fprintf_filtered (stream
, _(" Range %s-%s: "),
2565 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
2567 /* Now describe this particular location. */
2568 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
2569 objfile
, addr_size
, offset_size
);
2571 fprintf_filtered (stream
, "\n");
2577 /* Describe the location of SYMBOL as an agent value in VALUE, generating
2578 any necessary bytecode in AX. */
2580 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
2581 struct agent_expr
*ax
, struct axs_value
*value
)
2583 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2584 const gdb_byte
*data
;
2586 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2588 data
= find_location_expression (dlbaton
, &size
, ax
->scope
);
2589 if (data
== NULL
|| size
== 0)
2590 value
->optimized_out
= 1;
2592 compile_dwarf_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
2596 /* The set of location functions used with the DWARF-2 expression
2597 evaluator and location lists. */
2598 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
2599 loclist_read_variable
,
2600 loclist_read_needs_frame
,
2601 loclist_describe_location
,
2602 loclist_tracepoint_var_ref