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
,
553 int reg_offset
= source_offset
;
555 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
556 && this_size
< register_size (arch
, gdb_regnum
))
558 /* Big-endian, and we want less than full size. */
559 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
560 /* We want the lower-order THIS_SIZE_BITS of the bytes
561 we extract from the register. */
562 source_offset_bits
+= 8 * this_size
- this_size_bits
;
565 if (gdb_regnum
!= -1)
567 get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
572 error (_("Unable to access DWARF register number %s"),
573 paddress (arch
, p
->v
.expr
.value
));
578 case DWARF_VALUE_MEMORY
:
579 if (p
->v
.expr
.in_stack_memory
)
580 read_stack (p
->v
.expr
.value
+ source_offset
, buffer
, this_size
);
582 read_memory (p
->v
.expr
.value
+ source_offset
, buffer
, this_size
);
585 case DWARF_VALUE_STACK
:
587 struct gdbarch
*gdbarch
= get_type_arch (value_type (v
));
588 size_t n
= this_size
;
590 if (n
> c
->addr_size
- source_offset
)
591 n
= (c
->addr_size
>= source_offset
592 ? c
->addr_size
- source_offset
598 else if (source_offset
== 0)
599 store_unsigned_integer (buffer
, n
,
600 gdbarch_byte_order (gdbarch
),
604 gdb_byte bytes
[sizeof (ULONGEST
)];
606 store_unsigned_integer (bytes
, n
+ source_offset
,
607 gdbarch_byte_order (gdbarch
),
609 memcpy (buffer
, bytes
+ source_offset
, n
);
614 case DWARF_VALUE_LITERAL
:
616 size_t n
= this_size
;
618 if (n
> p
->v
.literal
.length
- source_offset
)
619 n
= (p
->v
.literal
.length
>= source_offset
620 ? p
->v
.literal
.length
- source_offset
623 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
627 case DWARF_VALUE_OPTIMIZED_OUT
:
628 set_value_optimized_out (v
, 1);
632 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
635 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
)
636 copy_bitwise (contents
, dest_offset_bits
,
637 intermediate_buffer
, source_offset_bits
% 8,
638 this_size_bits
, bits_big_endian
);
640 offset
+= this_size_bits
;
643 do_cleanups (cleanup
);
647 write_pieced_value (struct value
*to
, struct value
*from
)
651 ULONGEST bits_to_skip
;
652 const gdb_byte
*contents
;
653 struct piece_closure
*c
= (struct piece_closure
*) value_computed_closure (to
);
654 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
656 size_t buffer_size
= 0;
658 struct cleanup
*cleanup
;
660 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
664 set_value_optimized_out (to
, 1);
668 cleanup
= make_cleanup (free_current_contents
, &buffer
);
670 contents
= value_contents (from
);
671 bits_to_skip
= 8 * value_offset (to
);
672 if (value_bitsize (to
))
674 bits_to_skip
+= value_bitpos (to
);
675 type_len
= value_bitsize (to
);
678 type_len
= 8 * TYPE_LENGTH (value_type (to
));
680 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
682 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
683 size_t this_size_bits
, this_size
;
684 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
686 const gdb_byte
*source_buffer
;
688 this_size_bits
= p
->size
;
689 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
691 bits_to_skip
-= this_size_bits
;
694 if (this_size_bits
> type_len
- offset
)
695 this_size_bits
= type_len
- offset
;
696 if (bits_to_skip
> 0)
698 dest_offset_bits
= bits_to_skip
;
699 source_offset_bits
= 0;
700 this_size_bits
-= bits_to_skip
;
705 dest_offset_bits
= 0;
706 source_offset_bits
= offset
;
709 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
710 source_offset
= source_offset_bits
/ 8;
711 dest_offset
= dest_offset_bits
/ 8;
712 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
714 source_buffer
= contents
+ source_offset
;
719 if (buffer_size
< this_size
)
721 buffer_size
= this_size
;
722 buffer
= xrealloc (buffer
, buffer_size
);
724 source_buffer
= buffer
;
730 case DWARF_VALUE_REGISTER
:
732 struct gdbarch
*arch
= get_frame_arch (frame
);
733 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.expr
.value
);
734 int reg_offset
= dest_offset
;
736 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
737 && this_size
<= register_size (arch
, gdb_regnum
))
738 /* Big-endian, and we want less than full size. */
739 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
741 if (gdb_regnum
!= -1)
745 get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
747 copy_bitwise (buffer
, dest_offset_bits
,
748 contents
, source_offset_bits
,
753 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
754 this_size
, source_buffer
);
758 error (_("Unable to write to DWARF register number %s"),
759 paddress (arch
, p
->v
.expr
.value
));
763 case DWARF_VALUE_MEMORY
:
766 /* Only the first and last bytes can possibly have any
768 read_memory (p
->v
.expr
.value
+ dest_offset
, buffer
, 1);
769 read_memory (p
->v
.expr
.value
+ dest_offset
+ this_size
- 1,
770 buffer
+ this_size
- 1, 1);
771 copy_bitwise (buffer
, dest_offset_bits
,
772 contents
, source_offset_bits
,
777 write_memory (p
->v
.expr
.value
+ dest_offset
,
778 source_buffer
, this_size
);
781 set_value_optimized_out (to
, 1);
784 offset
+= this_size_bits
;
787 do_cleanups (cleanup
);
791 check_pieced_value_bits (const struct value
*value
, int bit_offset
,
792 int bit_length
, int validity
)
794 struct piece_closure
*c
795 = (struct piece_closure
*) value_computed_closure (value
);
798 bit_offset
+= 8 * value_offset (value
);
799 if (value_bitsize (value
))
800 bit_offset
+= value_bitpos (value
);
802 for (i
= 0; i
< c
->n_pieces
&& bit_length
> 0; i
++)
804 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
805 size_t this_size_bits
= p
->size
;
809 if (bit_offset
>= this_size_bits
)
811 bit_offset
-= this_size_bits
;
815 bit_length
-= this_size_bits
- bit_offset
;
819 bit_length
-= this_size_bits
;
821 if (p
->location
== DWARF_VALUE_OPTIMIZED_OUT
)
837 check_pieced_value_validity (const struct value
*value
, int bit_offset
,
840 return check_pieced_value_bits (value
, bit_offset
, bit_length
, 1);
844 check_pieced_value_invalid (const struct value
*value
)
846 return check_pieced_value_bits (value
, 0,
847 8 * TYPE_LENGTH (value_type (value
)), 0);
851 copy_pieced_value_closure (const struct value
*v
)
853 struct piece_closure
*c
= (struct piece_closure
*) value_computed_closure (v
);
860 free_pieced_value_closure (struct value
*v
)
862 struct piece_closure
*c
= (struct piece_closure
*) value_computed_closure (v
);
872 /* Functions for accessing a variable described by DW_OP_piece. */
873 static struct lval_funcs pieced_value_funcs
= {
876 check_pieced_value_validity
,
877 check_pieced_value_invalid
,
878 copy_pieced_value_closure
,
879 free_pieced_value_closure
882 /* Evaluate a location description, starting at DATA and with length
883 SIZE, to find the current location of variable of TYPE in the context
886 static struct value
*
887 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
888 const gdb_byte
*data
, unsigned short size
,
889 struct dwarf2_per_cu_data
*per_cu
)
891 struct value
*retval
;
892 struct dwarf_expr_baton baton
;
893 struct dwarf_expr_context
*ctx
;
894 struct cleanup
*old_chain
;
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 (dwarf2_per_cu_objfile (per_cu
));
911 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
913 ctx
->read_reg
= dwarf_expr_read_reg
;
914 ctx
->read_mem
= dwarf_expr_read_mem
;
915 ctx
->get_frame_base
= dwarf_expr_frame_base
;
916 ctx
->get_frame_cfa
= dwarf_expr_frame_cfa
;
917 ctx
->get_tls_address
= dwarf_expr_tls_address
;
918 ctx
->dwarf_call
= dwarf_expr_dwarf_call
;
920 dwarf_expr_eval (ctx
, data
, size
);
921 if (ctx
->num_pieces
> 0)
923 struct piece_closure
*c
;
924 struct frame_id frame_id
= get_frame_id (frame
);
926 c
= allocate_piece_closure (ctx
->num_pieces
, ctx
->pieces
,
928 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
929 VALUE_FRAME_ID (retval
) = frame_id
;
933 switch (ctx
->location
)
935 case DWARF_VALUE_REGISTER
:
937 struct gdbarch
*arch
= get_frame_arch (frame
);
938 CORE_ADDR dwarf_regnum
= dwarf_expr_fetch (ctx
, 0);
939 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
941 if (gdb_regnum
!= -1)
942 retval
= value_from_register (type
, gdb_regnum
, frame
);
944 error (_("Unable to access DWARF register number %s"),
945 paddress (arch
, dwarf_regnum
));
949 case DWARF_VALUE_MEMORY
:
951 CORE_ADDR address
= dwarf_expr_fetch (ctx
, 0);
952 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
954 retval
= allocate_value (type
);
955 VALUE_LVAL (retval
) = lval_memory
;
956 set_value_lazy (retval
, 1);
958 set_value_stack (retval
, 1);
959 set_value_address (retval
, address
);
963 case DWARF_VALUE_STACK
:
965 ULONGEST value
= (ULONGEST
) dwarf_expr_fetch (ctx
, 0);
967 size_t n
= ctx
->addr_size
;
969 retval
= allocate_value (type
);
970 contents
= value_contents_raw (retval
);
971 if (n
> TYPE_LENGTH (type
))
972 n
= TYPE_LENGTH (type
);
973 store_unsigned_integer (contents
, n
,
974 gdbarch_byte_order (ctx
->gdbarch
),
979 case DWARF_VALUE_LITERAL
:
984 retval
= allocate_value (type
);
985 contents
= value_contents_raw (retval
);
986 if (n
> TYPE_LENGTH (type
))
987 n
= TYPE_LENGTH (type
);
988 memcpy (contents
, ctx
->data
, n
);
992 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
993 it can only be encountered when making a piece. */
994 case DWARF_VALUE_OPTIMIZED_OUT
:
996 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
1000 set_value_initialized (retval
, ctx
->initialized
);
1002 do_cleanups (old_chain
);
1007 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
1009 struct needs_frame_baton
1012 struct dwarf2_per_cu_data
*per_cu
;
1015 /* Reads from registers do require a frame. */
1017 needs_frame_read_reg (void *baton
, int regnum
)
1019 struct needs_frame_baton
*nf_baton
= baton
;
1021 nf_baton
->needs_frame
= 1;
1025 /* Reads from memory do not require a frame. */
1027 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
1029 memset (buf
, 0, len
);
1032 /* Frame-relative accesses do require a frame. */
1034 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
1036 static gdb_byte lit0
= DW_OP_lit0
;
1037 struct needs_frame_baton
*nf_baton
= baton
;
1042 nf_baton
->needs_frame
= 1;
1045 /* CFA accesses require a frame. */
1048 needs_frame_frame_cfa (void *baton
)
1050 struct needs_frame_baton
*nf_baton
= baton
;
1052 nf_baton
->needs_frame
= 1;
1056 /* Thread-local accesses do require a frame. */
1058 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
1060 struct needs_frame_baton
*nf_baton
= baton
;
1062 nf_baton
->needs_frame
= 1;
1066 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
1069 needs_frame_dwarf_call (struct dwarf_expr_context
*ctx
, size_t die_offset
)
1071 struct needs_frame_baton
*nf_baton
= ctx
->baton
;
1073 return per_cu_dwarf_call (ctx
, die_offset
, nf_baton
->per_cu
);
1076 /* Return non-zero iff the location expression at DATA (length SIZE)
1077 requires a frame to evaluate. */
1080 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, unsigned short size
,
1081 struct dwarf2_per_cu_data
*per_cu
)
1083 struct needs_frame_baton baton
;
1084 struct dwarf_expr_context
*ctx
;
1086 struct cleanup
*old_chain
;
1088 baton
.needs_frame
= 0;
1089 baton
.per_cu
= per_cu
;
1091 ctx
= new_dwarf_expr_context ();
1092 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
1094 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (per_cu
));
1095 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
1096 ctx
->baton
= &baton
;
1097 ctx
->read_reg
= needs_frame_read_reg
;
1098 ctx
->read_mem
= needs_frame_read_mem
;
1099 ctx
->get_frame_base
= needs_frame_frame_base
;
1100 ctx
->get_frame_cfa
= needs_frame_frame_cfa
;
1101 ctx
->get_tls_address
= needs_frame_tls_address
;
1102 ctx
->dwarf_call
= needs_frame_dwarf_call
;
1104 dwarf_expr_eval (ctx
, data
, size
);
1106 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
1108 if (ctx
->num_pieces
> 0)
1112 /* If the location has several pieces, and any of them are in
1113 registers, then we will need a frame to fetch them from. */
1114 for (i
= 0; i
< ctx
->num_pieces
; i
++)
1115 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
1119 do_cleanups (old_chain
);
1121 return baton
.needs_frame
|| in_reg
;
1124 /* A helper function that throws an unimplemented error mentioning a
1125 given DWARF operator. */
1128 unimplemented (unsigned int op
)
1130 error (_("DWARF operator %s cannot be translated to an agent expression"),
1131 dwarf_stack_op_name (op
, 1));
1134 /* A helper function to convert a DWARF register to an arch register.
1135 ARCH is the architecture.
1136 DWARF_REG is the register.
1137 This will throw an exception if the DWARF register cannot be
1138 translated to an architecture register. */
1141 translate_register (struct gdbarch
*arch
, int dwarf_reg
)
1143 int reg
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_reg
);
1145 error (_("Unable to access DWARF register number %d"), dwarf_reg
);
1149 /* A helper function that emits an access to memory. ARCH is the
1150 target architecture. EXPR is the expression which we are building.
1151 NBITS is the number of bits we want to read. This emits the
1152 opcodes needed to read the memory and then extract the desired
1156 access_memory (struct gdbarch
*arch
, struct agent_expr
*expr
, ULONGEST nbits
)
1158 ULONGEST nbytes
= (nbits
+ 7) / 8;
1160 gdb_assert (nbits
> 0 && nbits
<= sizeof (LONGEST
));
1163 ax_trace_quick (expr
, nbytes
);
1166 ax_simple (expr
, aop_ref8
);
1167 else if (nbits
<= 16)
1168 ax_simple (expr
, aop_ref16
);
1169 else if (nbits
<= 32)
1170 ax_simple (expr
, aop_ref32
);
1172 ax_simple (expr
, aop_ref64
);
1174 /* If we read exactly the number of bytes we wanted, we're done. */
1175 if (8 * nbytes
== nbits
)
1178 if (gdbarch_bits_big_endian (arch
))
1180 /* On a bits-big-endian machine, we want the high-order
1182 ax_const_l (expr
, 8 * nbytes
- nbits
);
1183 ax_simple (expr
, aop_rsh_unsigned
);
1187 /* On a bits-little-endian box, we want the low-order NBITS. */
1188 ax_zero_ext (expr
, nbits
);
1192 /* Compile a DWARF location expression to an agent expression.
1194 EXPR is the agent expression we are building.
1195 LOC is the agent value we modify.
1196 ARCH is the architecture.
1197 ADDR_SIZE is the size of addresses, in bytes.
1198 OP_PTR is the start of the location expression.
1199 OP_END is one past the last byte of the location expression.
1201 This will throw an exception for various kinds of errors -- for
1202 example, if the expression cannot be compiled, or if the expression
1206 compile_dwarf_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
1207 struct gdbarch
*arch
, unsigned int addr_size
,
1208 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
1209 struct dwarf2_per_cu_data
*per_cu
)
1211 struct cleanup
*cleanups
;
1213 VEC(int) *dw_labels
= NULL
, *patches
= NULL
;
1214 const gdb_byte
* const base
= op_ptr
;
1215 const gdb_byte
*previous_piece
= op_ptr
;
1216 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
1217 ULONGEST bits_collected
= 0;
1218 unsigned int addr_size_bits
= 8 * addr_size
;
1219 int bits_big_endian
= gdbarch_bits_big_endian (arch
);
1221 offsets
= xmalloc ((op_end
- op_ptr
) * sizeof (int));
1222 cleanups
= make_cleanup (xfree
, offsets
);
1224 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
1227 make_cleanup (VEC_cleanup (int), &dw_labels
);
1228 make_cleanup (VEC_cleanup (int), &patches
);
1230 /* By default we are making an address. */
1231 loc
->kind
= axs_lvalue_memory
;
1233 while (op_ptr
< op_end
)
1235 enum dwarf_location_atom op
= *op_ptr
;
1237 ULONGEST uoffset
, reg
;
1241 offsets
[op_ptr
- base
] = expr
->len
;
1244 /* Our basic approach to code generation is to map DWARF
1245 operations directly to AX operations. However, there are
1248 First, DWARF works on address-sized units, but AX always uses
1249 LONGEST. For most operations we simply ignore this
1250 difference; instead we generate sign extensions as needed
1251 before division and comparison operations. It would be nice
1252 to omit the sign extensions, but there is no way to determine
1253 the size of the target's LONGEST. (This code uses the size
1254 of the host LONGEST in some cases -- that is a bug but it is
1257 Second, some DWARF operations cannot be translated to AX.
1258 For these we simply fail. See
1259 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
1294 ax_const_l (expr
, op
- DW_OP_lit0
);
1298 result
= dwarf2_read_address (arch
, op_ptr
, op_end
, addr_size
);
1299 ax_const_l (expr
, result
);
1300 op_ptr
+= addr_size
;
1304 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 1, byte_order
));
1308 ax_const_l (expr
, extract_signed_integer (op_ptr
, 1, byte_order
));
1312 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 2, byte_order
));
1316 ax_const_l (expr
, extract_signed_integer (op_ptr
, 2, byte_order
));
1320 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 4, byte_order
));
1324 ax_const_l (expr
, extract_signed_integer (op_ptr
, 4, byte_order
));
1328 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, 8, byte_order
));
1332 ax_const_l (expr
, extract_signed_integer (op_ptr
, 8, byte_order
));
1336 op_ptr
= read_uleb128 (op_ptr
, op_end
, &uoffset
);
1337 ax_const_l (expr
, uoffset
);
1340 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1341 ax_const_l (expr
, offset
);
1376 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
1377 loc
->u
.reg
= translate_register (arch
, op
- DW_OP_reg0
);
1378 loc
->kind
= axs_lvalue_register
;
1382 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
1383 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
1384 loc
->u
.reg
= translate_register (arch
, reg
);
1385 loc
->kind
= axs_lvalue_register
;
1388 case DW_OP_implicit_value
:
1392 op_ptr
= read_uleb128 (op_ptr
, op_end
, &len
);
1393 if (op_ptr
+ len
> op_end
)
1394 error (_("DW_OP_implicit_value: too few bytes available."));
1395 if (len
> sizeof (ULONGEST
))
1396 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
1399 ax_const_l (expr
, extract_unsigned_integer (op_ptr
, len
,
1402 dwarf_expr_require_composition (op_ptr
, op_end
,
1403 "DW_OP_implicit_value");
1405 loc
->kind
= axs_rvalue
;
1409 case DW_OP_stack_value
:
1410 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_stack_value");
1411 loc
->kind
= axs_rvalue
;
1446 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1447 i
= translate_register (arch
, op
- DW_OP_breg0
);
1451 ax_const_l (expr
, offset
);
1452 ax_simple (expr
, aop_add
);
1457 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
1458 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1459 i
= translate_register (arch
, reg
);
1463 ax_const_l (expr
, offset
);
1464 ax_simple (expr
, aop_add
);
1470 const gdb_byte
*datastart
;
1472 unsigned int before_stack_len
;
1474 struct symbol
*framefunc
;
1475 LONGEST base_offset
= 0;
1477 b
= block_for_pc (expr
->scope
);
1480 error (_("No block found for address"));
1482 framefunc
= block_linkage_function (b
);
1485 error (_("No function found for block"));
1487 dwarf_expr_frame_base_1 (framefunc
, expr
->scope
,
1488 &datastart
, &datalen
);
1490 op_ptr
= read_sleb128 (op_ptr
, op_end
, &offset
);
1491 compile_dwarf_to_ax (expr
, loc
, arch
, addr_size
, datastart
,
1492 datastart
+ datalen
, per_cu
);
1496 ax_const_l (expr
, offset
);
1497 ax_simple (expr
, aop_add
);
1500 loc
->kind
= axs_lvalue_memory
;
1505 ax_simple (expr
, aop_dup
);
1509 ax_simple (expr
, aop_pop
);
1518 ax_simple (expr
, aop_swap
);
1522 /* We can't directly support DW_OP_over, but GCC emits it as
1523 part of a sequence to implement signed modulus. As a
1524 hack, we recognize this sequence. Note that if GCC ever
1525 generates a branch to the middle of this sequence, then
1526 we will die somehow. */
1527 if (op_end
- op_ptr
>= 4
1528 && op_ptr
[0] == DW_OP_over
1529 && op_ptr
[1] == DW_OP_div
1530 && op_ptr
[2] == DW_OP_mul
1531 && op_ptr
[3] == DW_OP_minus
)
1533 /* Sign extend the operands. */
1534 ax_ext (expr
, addr_size_bits
);
1535 ax_simple (expr
, aop_swap
);
1536 ax_ext (expr
, addr_size_bits
);
1537 ax_simple (expr
, aop_swap
);
1538 ax_simple (expr
, aop_rem_signed
);
1550 case DW_OP_deref_size
:
1554 if (op
== DW_OP_deref_size
)
1562 ax_simple (expr
, aop_ref8
);
1565 ax_simple (expr
, aop_ref16
);
1568 ax_simple (expr
, aop_ref32
);
1571 ax_simple (expr
, aop_ref64
);
1574 error (_("Unsupported size %d in %s"),
1575 size
, dwarf_stack_op_name (op
, 1));
1581 /* Sign extend the operand. */
1582 ax_ext (expr
, addr_size_bits
);
1583 ax_simple (expr
, aop_dup
);
1584 ax_const_l (expr
, 0);
1585 ax_simple (expr
, aop_less_signed
);
1586 ax_simple (expr
, aop_log_not
);
1587 i
= ax_goto (expr
, aop_if_goto
);
1588 /* We have to emit 0 - X. */
1589 ax_const_l (expr
, 0);
1590 ax_simple (expr
, aop_swap
);
1591 ax_simple (expr
, aop_sub
);
1592 ax_label (expr
, i
, expr
->len
);
1596 /* No need to sign extend here. */
1597 ax_const_l (expr
, 0);
1598 ax_simple (expr
, aop_swap
);
1599 ax_simple (expr
, aop_sub
);
1603 /* Sign extend the operand. */
1604 ax_ext (expr
, addr_size_bits
);
1605 ax_simple (expr
, aop_bit_not
);
1608 case DW_OP_plus_uconst
:
1609 op_ptr
= read_uleb128 (op_ptr
, op_end
, ®
);
1610 /* It would be really weird to emit `DW_OP_plus_uconst 0',
1611 but we micro-optimize anyhow. */
1614 ax_const_l (expr
, reg
);
1615 ax_simple (expr
, aop_add
);
1620 ax_simple (expr
, aop_bit_and
);
1624 /* Sign extend the operands. */
1625 ax_ext (expr
, addr_size_bits
);
1626 ax_simple (expr
, aop_swap
);
1627 ax_ext (expr
, addr_size_bits
);
1628 ax_simple (expr
, aop_swap
);
1629 ax_simple (expr
, aop_div_signed
);
1633 ax_simple (expr
, aop_sub
);
1637 ax_simple (expr
, aop_rem_unsigned
);
1641 ax_simple (expr
, aop_mul
);
1645 ax_simple (expr
, aop_bit_or
);
1649 ax_simple (expr
, aop_add
);
1653 ax_simple (expr
, aop_lsh
);
1657 ax_simple (expr
, aop_rsh_unsigned
);
1661 ax_simple (expr
, aop_rsh_signed
);
1665 ax_simple (expr
, aop_bit_xor
);
1669 /* Sign extend the operands. */
1670 ax_ext (expr
, addr_size_bits
);
1671 ax_simple (expr
, aop_swap
);
1672 ax_ext (expr
, addr_size_bits
);
1673 /* Note no swap here: A <= B is !(B < A). */
1674 ax_simple (expr
, aop_less_signed
);
1675 ax_simple (expr
, aop_log_not
);
1679 /* Sign extend the operands. */
1680 ax_ext (expr
, addr_size_bits
);
1681 ax_simple (expr
, aop_swap
);
1682 ax_ext (expr
, addr_size_bits
);
1683 ax_simple (expr
, aop_swap
);
1684 /* A >= B is !(A < B). */
1685 ax_simple (expr
, aop_less_signed
);
1686 ax_simple (expr
, aop_log_not
);
1690 /* Sign extend the operands. */
1691 ax_ext (expr
, addr_size_bits
);
1692 ax_simple (expr
, aop_swap
);
1693 ax_ext (expr
, addr_size_bits
);
1694 /* No need for a second swap here. */
1695 ax_simple (expr
, aop_equal
);
1699 /* Sign extend the operands. */
1700 ax_ext (expr
, addr_size_bits
);
1701 ax_simple (expr
, aop_swap
);
1702 ax_ext (expr
, addr_size_bits
);
1703 ax_simple (expr
, aop_swap
);
1704 ax_simple (expr
, aop_less_signed
);
1708 /* Sign extend the operands. */
1709 ax_ext (expr
, addr_size_bits
);
1710 ax_simple (expr
, aop_swap
);
1711 ax_ext (expr
, addr_size_bits
);
1712 /* Note no swap here: A > B is B < A. */
1713 ax_simple (expr
, aop_less_signed
);
1717 /* Sign extend the operands. */
1718 ax_ext (expr
, addr_size_bits
);
1719 ax_simple (expr
, aop_swap
);
1720 ax_ext (expr
, addr_size_bits
);
1721 /* No need for a swap here. */
1722 ax_simple (expr
, aop_equal
);
1723 ax_simple (expr
, aop_log_not
);
1726 case DW_OP_call_frame_cfa
:
1730 case DW_OP_GNU_push_tls_address
:
1735 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
1737 i
= ax_goto (expr
, aop_goto
);
1738 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
1739 VEC_safe_push (int, patches
, i
);
1743 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
1745 /* Zero extend the operand. */
1746 ax_zero_ext (expr
, addr_size_bits
);
1747 i
= ax_goto (expr
, aop_if_goto
);
1748 VEC_safe_push (int, dw_labels
, op_ptr
+ offset
- base
);
1749 VEC_safe_push (int, patches
, i
);
1756 case DW_OP_bit_piece
:
1758 ULONGEST size
, offset
;
1760 if (op_ptr
- 1 == previous_piece
)
1761 error (_("Cannot translate empty pieces to agent expressions"));
1762 previous_piece
= op_ptr
- 1;
1764 op_ptr
= read_uleb128 (op_ptr
, op_end
, &size
);
1765 if (op
== DW_OP_piece
)
1771 op_ptr
= read_uleb128 (op_ptr
, op_end
, &offset
);
1773 if (bits_collected
+ size
> 8 * sizeof (LONGEST
))
1774 error (_("Expression pieces exceed word size"));
1776 /* Access the bits. */
1779 case axs_lvalue_register
:
1780 ax_reg (expr
, loc
->u
.reg
);
1783 case axs_lvalue_memory
:
1784 /* Offset the pointer, if needed. */
1787 ax_const_l (expr
, offset
/ 8);
1788 ax_simple (expr
, aop_add
);
1791 access_memory (arch
, expr
, size
);
1795 /* For a bits-big-endian target, shift up what we already
1796 have. For a bits-little-endian target, shift up the
1797 new data. Note that there is a potential bug here if
1798 the DWARF expression leaves multiple values on the
1800 if (bits_collected
> 0)
1802 if (bits_big_endian
)
1804 ax_simple (expr
, aop_swap
);
1805 ax_const_l (expr
, size
);
1806 ax_simple (expr
, aop_lsh
);
1807 /* We don't need a second swap here, because
1808 aop_bit_or is symmetric. */
1812 ax_const_l (expr
, size
);
1813 ax_simple (expr
, aop_lsh
);
1815 ax_simple (expr
, aop_bit_or
);
1818 bits_collected
+= size
;
1819 loc
->kind
= axs_rvalue
;
1823 case DW_OP_GNU_uninit
:
1829 struct dwarf2_locexpr_baton block
;
1830 int size
= (op
== DW_OP_call2
? 2 : 4);
1832 uoffset
= extract_unsigned_integer (op_ptr
, size
, byte_order
);
1835 block
= dwarf2_fetch_die_location_block (uoffset
, per_cu
);
1837 /* DW_OP_call_ref is currently not supported. */
1838 gdb_assert (block
.per_cu
== per_cu
);
1840 compile_dwarf_to_ax (expr
, loc
, arch
, addr_size
,
1841 block
.data
, block
.data
+ block
.size
,
1846 case DW_OP_call_ref
:
1850 error (_("Unhandled dwarf expression opcode 0x%x"), op
);
1854 /* Patch all the branches we emitted. */
1855 for (i
= 0; i
< VEC_length (int, patches
); ++i
)
1857 int targ
= offsets
[VEC_index (int, dw_labels
, i
)];
1859 internal_error (__FILE__
, __LINE__
, _("invalid label"));
1860 ax_label (expr
, VEC_index (int, patches
, i
), targ
);
1863 do_cleanups (cleanups
);
1867 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
1868 evaluator to calculate the location. */
1869 static struct value
*
1870 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
1872 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
1875 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
1876 dlbaton
->size
, dlbaton
->per_cu
);
1881 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
1883 locexpr_read_needs_frame (struct symbol
*symbol
)
1885 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
1887 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
1891 /* Return true if DATA points to the end of a piece. END is one past
1892 the last byte in the expression. */
1895 piece_end_p (const gdb_byte
*data
, const gdb_byte
*end
)
1897 return data
== end
|| data
[0] == DW_OP_piece
|| data
[0] == DW_OP_bit_piece
;
1900 /* Nicely describe a single piece of a location, returning an updated
1901 position in the bytecode sequence. This function cannot recognize
1902 all locations; if a location is not recognized, it simply returns
1905 static const gdb_byte
*
1906 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
1907 CORE_ADDR addr
, struct objfile
*objfile
,
1908 const gdb_byte
*data
, const gdb_byte
*end
,
1909 unsigned int addr_size
)
1911 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1914 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
1916 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, data
[0] - DW_OP_reg0
);
1917 fprintf_filtered (stream
, _("a variable in $%s"),
1918 gdbarch_register_name (gdbarch
, regno
));
1921 else if (data
[0] == DW_OP_regx
)
1925 data
= read_uleb128 (data
+ 1, end
, ®
);
1926 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
);
1927 fprintf_filtered (stream
, _("a variable in $%s"),
1928 gdbarch_register_name (gdbarch
, regno
));
1930 else if (data
[0] == DW_OP_fbreg
)
1933 struct symbol
*framefunc
;
1935 LONGEST frame_offset
;
1936 const gdb_byte
*base_data
, *new_data
;
1938 LONGEST base_offset
= 0;
1940 new_data
= read_sleb128 (data
+ 1, end
, &frame_offset
);
1941 if (!piece_end_p (new_data
, end
))
1945 b
= block_for_pc (addr
);
1948 error (_("No block found for address for symbol \"%s\"."),
1949 SYMBOL_PRINT_NAME (symbol
));
1951 framefunc
= block_linkage_function (b
);
1954 error (_("No function found for block for symbol \"%s\"."),
1955 SYMBOL_PRINT_NAME (symbol
));
1957 dwarf_expr_frame_base_1 (framefunc
, addr
, &base_data
, &base_size
);
1959 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
1961 const gdb_byte
*buf_end
;
1963 frame_reg
= base_data
[0] - DW_OP_breg0
;
1964 buf_end
= read_sleb128 (base_data
+ 1,
1965 base_data
+ base_size
, &base_offset
);
1966 if (buf_end
!= base_data
+ base_size
)
1967 error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
1968 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
1970 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
1972 /* The frame base is just the register, with no offset. */
1973 frame_reg
= base_data
[0] - DW_OP_reg0
;
1978 /* We don't know what to do with the frame base expression,
1979 so we can't trace this variable; give up. */
1980 error (_("Cannot describe location of symbol \"%s\"; "
1981 "DWARF 2 encoding not handled, "
1982 "first opcode in base data is 0x%x."),
1983 SYMBOL_PRINT_NAME (symbol
), base_data
[0]);
1986 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, frame_reg
);
1988 fprintf_filtered (stream
, _("a variable at frame base reg $%s offset %s+%s"),
1989 gdbarch_register_name (gdbarch
, regno
),
1990 plongest (base_offset
), plongest (frame_offset
));
1992 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
1993 && piece_end_p (data
, end
))
1997 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, data
[0] - DW_OP_breg0
);
1999 data
= read_sleb128 (data
+ 1, end
, &offset
);
2001 fprintf_filtered (stream
,
2002 _("a variable at offset %s from base reg $%s"),
2004 gdbarch_register_name (gdbarch
, regno
));
2007 /* The location expression for a TLS variable looks like this (on a
2010 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
2011 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
2013 0x3 is the encoding for DW_OP_addr, which has an operand as long
2014 as the size of an address on the target machine (here is 8
2015 bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
2016 The operand represents the offset at which the variable is within
2017 the thread local storage. */
2019 else if (data
+ 1 + addr_size
< end
2020 && data
[0] == DW_OP_addr
2021 && data
[1 + addr_size
] == DW_OP_GNU_push_tls_address
2022 && piece_end_p (data
+ 2 + addr_size
, end
))
2025 offset
= extract_unsigned_integer (data
+ 1, addr_size
,
2026 gdbarch_byte_order (gdbarch
));
2028 fprintf_filtered (stream
,
2029 _("a thread-local variable at offset 0x%s "
2030 "in the thread-local storage for `%s'"),
2031 phex_nz (offset
, addr_size
), objfile
->name
);
2033 data
+= 1 + addr_size
+ 1;
2035 else if (data
[0] >= DW_OP_lit0
2036 && data
[0] <= DW_OP_lit31
2038 && data
[1] == DW_OP_stack_value
)
2040 fprintf_filtered (stream
, _("the constant %d"), data
[0] - DW_OP_lit0
);
2047 /* Disassemble an expression, stopping at the end of a piece or at the
2048 end of the expression. Returns a pointer to the next unread byte
2049 in the input expression. If ALL is nonzero, then this function
2050 will keep going until it reaches the end of the expression. */
2052 static const gdb_byte
*
2053 disassemble_dwarf_expression (struct ui_file
*stream
,
2054 struct gdbarch
*arch
, unsigned int addr_size
,
2056 const gdb_byte
*data
, const gdb_byte
*end
,
2059 const gdb_byte
*start
= data
;
2061 fprintf_filtered (stream
, _("a complex DWARF expression:\n"));
2065 || (data
[0] != DW_OP_piece
&& data
[0] != DW_OP_bit_piece
)))
2067 enum dwarf_location_atom op
= *data
++;
2072 name
= dwarf_stack_op_name (op
, 0);
2075 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
2076 op
, (long) (data
- start
));
2077 fprintf_filtered (stream
, " % 4ld: %s", (long) (data
- start
), name
);
2082 ul
= extract_unsigned_integer (data
, addr_size
,
2083 gdbarch_byte_order (arch
));
2085 fprintf_filtered (stream
, " 0x%s", phex_nz (ul
, addr_size
));
2089 ul
= extract_unsigned_integer (data
, 1, gdbarch_byte_order (arch
));
2091 fprintf_filtered (stream
, " %s", pulongest (ul
));
2094 l
= extract_signed_integer (data
, 1, gdbarch_byte_order (arch
));
2096 fprintf_filtered (stream
, " %s", plongest (l
));
2099 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
2101 fprintf_filtered (stream
, " %s", pulongest (ul
));
2104 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
2106 fprintf_filtered (stream
, " %s", plongest (l
));
2109 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
2111 fprintf_filtered (stream
, " %s", pulongest (ul
));
2114 l
= extract_signed_integer (data
, 4, gdbarch_byte_order (arch
));
2116 fprintf_filtered (stream
, " %s", plongest (l
));
2119 ul
= extract_unsigned_integer (data
, 8, gdbarch_byte_order (arch
));
2121 fprintf_filtered (stream
, " %s", pulongest (ul
));
2124 l
= extract_signed_integer (data
, 8, gdbarch_byte_order (arch
));
2126 fprintf_filtered (stream
, " %s", plongest (l
));
2129 data
= read_uleb128 (data
, end
, &ul
);
2130 fprintf_filtered (stream
, " %s", pulongest (ul
));
2133 data
= read_sleb128 (data
, end
, &l
);
2134 fprintf_filtered (stream
, " %s", plongest (l
));
2169 fprintf_filtered (stream
, " [$%s]",
2170 gdbarch_register_name (arch
, op
- DW_OP_reg0
));
2174 data
= read_uleb128 (data
, end
, &ul
);
2175 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
2176 gdbarch_register_name (arch
, (int) ul
));
2179 case DW_OP_implicit_value
:
2180 data
= read_uleb128 (data
, end
, &ul
);
2182 fprintf_filtered (stream
, " %s", pulongest (ul
));
2217 data
= read_sleb128 (data
, end
, &ul
);
2218 fprintf_filtered (stream
, " %s [$%s]", pulongest (ul
),
2219 gdbarch_register_name (arch
, op
- DW_OP_breg0
));
2226 data
= read_uleb128 (data
, end
, &ul
);
2227 data
= read_sleb128 (data
, end
, &offset
);
2228 fprintf_filtered (stream
, " register %s [$%s] offset %s",
2230 gdbarch_register_name (arch
, (int) ul
),
2231 pulongest (offset
));
2236 data
= read_sleb128 (data
, end
, &ul
);
2237 fprintf_filtered (stream
, " %s", pulongest (ul
));
2240 case DW_OP_xderef_size
:
2241 case DW_OP_deref_size
:
2243 fprintf_filtered (stream
, " %d", *data
);
2247 case DW_OP_plus_uconst
:
2248 data
= read_uleb128 (data
, end
, &ul
);
2249 fprintf_filtered (stream
, " %s", pulongest (ul
));
2253 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
2255 fprintf_filtered (stream
, " to %ld",
2256 (long) (data
+ l
- start
));
2260 l
= extract_signed_integer (data
, 2, gdbarch_byte_order (arch
));
2262 fprintf_filtered (stream
, " %ld",
2263 (long) (data
+ l
- start
));
2267 ul
= extract_unsigned_integer (data
, 2, gdbarch_byte_order (arch
));
2269 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 2));
2273 ul
= extract_unsigned_integer (data
, 4, gdbarch_byte_order (arch
));
2275 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, 4));
2278 case DW_OP_call_ref
:
2279 ul
= extract_unsigned_integer (data
, offset_size
,
2280 gdbarch_byte_order (arch
));
2281 data
+= offset_size
;
2282 fprintf_filtered (stream
, " offset %s", phex_nz (ul
, offset_size
));
2286 data
= read_uleb128 (data
, end
, &ul
);
2287 fprintf_filtered (stream
, " %s (bytes)", pulongest (ul
));
2290 case DW_OP_bit_piece
:
2294 data
= read_uleb128 (data
, end
, &ul
);
2295 data
= read_uleb128 (data
, end
, &offset
);
2296 fprintf_filtered (stream
, " size %s offset %s (bits)",
2297 pulongest (ul
), pulongest (offset
));
2302 fprintf_filtered (stream
, "\n");
2308 /* Describe a single location, which may in turn consist of multiple
2312 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
2313 struct ui_file
*stream
,
2314 const gdb_byte
*data
, int size
,
2315 struct objfile
*objfile
, unsigned int addr_size
,
2318 const gdb_byte
*end
= data
+ size
;
2319 int first_piece
= 1, bad
= 0;
2323 const gdb_byte
*here
= data
;
2324 int disassemble
= 1;
2329 fprintf_filtered (stream
, _(", and "));
2331 if (!dwarf2_always_disassemble
)
2333 data
= locexpr_describe_location_piece (symbol
, stream
, addr
, objfile
,
2334 data
, end
, addr_size
);
2335 /* If we printed anything, or if we have an empty piece,
2336 then don't disassemble. */
2338 || data
[0] == DW_OP_piece
2339 || data
[0] == DW_OP_bit_piece
)
2343 data
= disassemble_dwarf_expression (stream
, get_objfile_arch (objfile
),
2344 addr_size
, offset_size
, data
, end
,
2345 dwarf2_always_disassemble
);
2349 int empty
= data
== here
;
2352 fprintf_filtered (stream
, " ");
2353 if (data
[0] == DW_OP_piece
)
2357 data
= read_uleb128 (data
+ 1, end
, &bytes
);
2360 fprintf_filtered (stream
, _("an empty %s-byte piece"),
2363 fprintf_filtered (stream
, _(" [%s-byte piece]"),
2366 else if (data
[0] == DW_OP_bit_piece
)
2368 ULONGEST bits
, offset
;
2370 data
= read_uleb128 (data
+ 1, end
, &bits
);
2371 data
= read_uleb128 (data
, end
, &offset
);
2374 fprintf_filtered (stream
,
2375 _("an empty %s-bit piece"),
2378 fprintf_filtered (stream
,
2379 _(" [%s-bit piece, offset %s bits]"),
2380 pulongest (bits
), pulongest (offset
));
2390 if (bad
|| data
> end
)
2391 error (_("Corrupted DWARF2 expression for \"%s\"."),
2392 SYMBOL_PRINT_NAME (symbol
));
2395 /* Print a natural-language description of SYMBOL to STREAM. This
2396 version is for a symbol with a single location. */
2399 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
2400 struct ui_file
*stream
)
2402 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2403 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2404 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2405 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
2407 locexpr_describe_location_1 (symbol
, addr
, stream
, dlbaton
->data
, dlbaton
->size
,
2408 objfile
, addr_size
, offset_size
);
2411 /* Describe the location of SYMBOL as an agent value in VALUE, generating
2412 any necessary bytecode in AX. */
2415 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
2416 struct agent_expr
*ax
, struct axs_value
*value
)
2418 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2419 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2421 compile_dwarf_to_ax (ax
, value
, gdbarch
, addr_size
,
2422 dlbaton
->data
, dlbaton
->data
+ dlbaton
->size
,
2426 /* The set of location functions used with the DWARF-2 expression
2428 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
2429 locexpr_read_variable
,
2430 locexpr_read_needs_frame
,
2431 locexpr_describe_location
,
2432 locexpr_tracepoint_var_ref
2436 /* Wrapper functions for location lists. These generally find
2437 the appropriate location expression and call something above. */
2439 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
2440 evaluator to calculate the location. */
2441 static struct value
*
2442 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
2444 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2446 const gdb_byte
*data
;
2449 data
= find_location_expression (dlbaton
, &size
,
2450 frame
? get_frame_address_in_block (frame
)
2454 val
= allocate_value (SYMBOL_TYPE (symbol
));
2455 VALUE_LVAL (val
) = not_lval
;
2456 set_value_optimized_out (val
, 1);
2459 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
2465 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
2467 loclist_read_needs_frame (struct symbol
*symbol
)
2469 /* If there's a location list, then assume we need to have a frame
2470 to choose the appropriate location expression. With tracking of
2471 global variables this is not necessarily true, but such tracking
2472 is disabled in GCC at the moment until we figure out how to
2478 /* Print a natural-language description of SYMBOL to STREAM. This
2479 version applies when there is a list of different locations, each
2480 with a specified address range. */
2483 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
2484 struct ui_file
*stream
)
2486 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2487 CORE_ADDR low
, high
;
2488 const gdb_byte
*loc_ptr
, *buf_end
;
2489 int length
, first
= 1;
2490 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
2491 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2492 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2493 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2494 int offset_size
= dwarf2_per_cu_offset_size (dlbaton
->per_cu
);
2495 int signed_addr_p
= bfd_get_sign_extend_vma (objfile
->obfd
);
2496 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
2497 /* Adjust base_address for relocatable objects. */
2498 CORE_ADDR base_offset
= ANOFFSET (objfile
->section_offsets
,
2499 SECT_OFF_TEXT (objfile
));
2500 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
2502 loc_ptr
= dlbaton
->data
;
2503 buf_end
= dlbaton
->data
+ dlbaton
->size
;
2505 fprintf_filtered (stream
, _("multi-location:\n"));
2507 /* Iterate through locations until we run out. */
2510 if (buf_end
- loc_ptr
< 2 * addr_size
)
2511 error (_("Corrupted DWARF expression for symbol \"%s\"."),
2512 SYMBOL_PRINT_NAME (symbol
));
2515 low
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
2517 low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
2518 loc_ptr
+= addr_size
;
2521 high
= extract_signed_integer (loc_ptr
, addr_size
, byte_order
);
2523 high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
2524 loc_ptr
+= addr_size
;
2526 /* A base-address-selection entry. */
2527 if ((low
& base_mask
) == base_mask
)
2529 base_address
= high
+ base_offset
;
2530 fprintf_filtered (stream
, _(" Base address %s"),
2531 paddress (gdbarch
, base_address
));
2535 /* An end-of-list entry. */
2536 if (low
== 0 && high
== 0)
2539 /* Otherwise, a location expression entry. */
2540 low
+= base_address
;
2541 high
+= base_address
;
2543 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
2546 /* (It would improve readability to print only the minimum
2547 necessary digits of the second number of the range.) */
2548 fprintf_filtered (stream
, _(" Range %s-%s: "),
2549 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
2551 /* Now describe this particular location. */
2552 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
2553 objfile
, addr_size
, offset_size
);
2555 fprintf_filtered (stream
, "\n");
2561 /* Describe the location of SYMBOL as an agent value in VALUE, generating
2562 any necessary bytecode in AX. */
2564 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
2565 struct agent_expr
*ax
, struct axs_value
*value
)
2567 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
2568 const gdb_byte
*data
;
2570 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
2572 data
= find_location_expression (dlbaton
, &size
, ax
->scope
);
2574 compile_dwarf_to_ax (ax
, value
, gdbarch
, addr_size
, data
, data
+ size
,
2578 /* The set of location functions used with the DWARF-2 expression
2579 evaluator and location lists. */
2580 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
2581 loclist_read_variable
,
2582 loclist_read_needs_frame
,
2583 loclist_describe_location
,
2584 loclist_tracepoint_var_ref