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"
46 dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
47 const gdb_byte
**start
, size_t *length
);
49 /* A helper function for dealing with location lists. Given a
50 symbol baton (BATON) and a pc value (PC), find the appropriate
51 location expression, set *LOCEXPR_LENGTH, and return a pointer
52 to the beginning of the expression. Returns NULL on failure.
54 For now, only return the first matching location expression; there
55 can be more than one in the list. */
57 static const gdb_byte
*
58 find_location_expression (struct dwarf2_loclist_baton
*baton
,
59 size_t *locexpr_length
, CORE_ADDR pc
)
62 const gdb_byte
*loc_ptr
, *buf_end
;
64 struct objfile
*objfile
= dwarf2_per_cu_objfile (baton
->per_cu
);
65 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
66 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
67 unsigned int addr_size
= dwarf2_per_cu_addr_size (baton
->per_cu
);
68 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
69 /* Adjust base_address for relocatable objects. */
70 CORE_ADDR base_offset
= ANOFFSET (objfile
->section_offsets
,
71 SECT_OFF_TEXT (objfile
));
72 CORE_ADDR base_address
= baton
->base_address
+ base_offset
;
74 loc_ptr
= baton
->data
;
75 buf_end
= baton
->data
+ baton
->size
;
79 if (buf_end
- loc_ptr
< 2 * addr_size
)
80 error (_("find_location_expression: Corrupted DWARF expression."));
82 low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
85 /* A base-address-selection entry. */
88 base_address
= dwarf2_read_address (gdbarch
,
89 loc_ptr
, buf_end
, addr_size
);
94 high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
97 /* An end-of-list entry. */
98 if (low
== 0 && high
== 0)
101 /* Otherwise, a location expression entry. */
103 high
+= base_address
;
105 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
108 if (pc
>= low
&& pc
< high
)
110 *locexpr_length
= length
;
118 /* This is the baton used when performing dwarf2 expression
120 struct dwarf_expr_baton
122 struct frame_info
*frame
;
123 struct objfile
*objfile
;
126 /* Helper functions for dwarf2_evaluate_loc_desc. */
128 /* Using the frame specified in BATON, return the value of register
129 REGNUM, treated as a pointer. */
131 dwarf_expr_read_reg (void *baton
, int dwarf_regnum
)
133 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
134 struct gdbarch
*gdbarch
= get_frame_arch (debaton
->frame
);
138 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, dwarf_regnum
);
139 result
= address_from_register (builtin_type (gdbarch
)->builtin_data_ptr
,
140 regnum
, debaton
->frame
);
144 /* Read memory at ADDR (length LEN) into BUF. */
147 dwarf_expr_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
149 read_memory (addr
, buf
, len
);
152 /* Using the frame specified in BATON, find the location expression
153 describing the frame base. Return a pointer to it in START and
154 its length in LENGTH. */
156 dwarf_expr_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
158 /* FIXME: cagney/2003-03-26: This code should be using
159 get_frame_base_address(), and then implement a dwarf2 specific
161 struct symbol
*framefunc
;
162 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
164 /* Use block_linkage_function, which returns a real (not inlined)
165 function, instead of get_frame_function, which may return an
167 framefunc
= block_linkage_function (get_frame_block (debaton
->frame
, NULL
));
169 /* If we found a frame-relative symbol then it was certainly within
170 some function associated with a frame. If we can't find the frame,
171 something has gone wrong. */
172 gdb_assert (framefunc
!= NULL
);
174 dwarf_expr_frame_base_1 (framefunc
,
175 get_frame_address_in_block (debaton
->frame
),
180 dwarf_expr_frame_base_1 (struct symbol
*framefunc
, CORE_ADDR pc
,
181 const gdb_byte
**start
, size_t *length
)
183 if (SYMBOL_LOCATION_BATON (framefunc
) == NULL
)
185 else if (SYMBOL_COMPUTED_OPS (framefunc
) == &dwarf2_loclist_funcs
)
187 struct dwarf2_loclist_baton
*symbaton
;
189 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
190 *start
= find_location_expression (symbaton
, length
, pc
);
194 struct dwarf2_locexpr_baton
*symbaton
;
196 symbaton
= SYMBOL_LOCATION_BATON (framefunc
);
197 if (symbaton
!= NULL
)
199 *length
= symbaton
->size
;
200 *start
= symbaton
->data
;
207 error (_("Could not find the frame base for \"%s\"."),
208 SYMBOL_NATURAL_NAME (framefunc
));
211 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
212 the frame in BATON. */
215 dwarf_expr_frame_cfa (void *baton
)
217 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
219 return dwarf2_frame_cfa (debaton
->frame
);
222 /* Using the objfile specified in BATON, find the address for the
223 current thread's thread-local storage with offset OFFSET. */
225 dwarf_expr_tls_address (void *baton
, CORE_ADDR offset
)
227 struct dwarf_expr_baton
*debaton
= (struct dwarf_expr_baton
*) baton
;
229 return target_translate_tls_address (debaton
->objfile
, offset
);
234 /* Reference count. */
237 /* The number of pieces used to describe this variable. */
240 /* The target address size, used only for DWARF_VALUE_STACK. */
243 /* The pieces themselves. */
244 struct dwarf_expr_piece
*pieces
;
247 /* Allocate a closure for a value formed from separately-described
250 static struct piece_closure
*
251 allocate_piece_closure (int n_pieces
, struct dwarf_expr_piece
*pieces
,
254 struct piece_closure
*c
= XZALLOC (struct piece_closure
);
257 c
->n_pieces
= n_pieces
;
258 c
->addr_size
= addr_size
;
259 c
->pieces
= XCALLOC (n_pieces
, struct dwarf_expr_piece
);
261 memcpy (c
->pieces
, pieces
, n_pieces
* sizeof (struct dwarf_expr_piece
));
266 /* The lowest-level function to extract bits from a byte buffer.
267 SOURCE is the buffer. It is updated if we read to the end of a
269 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
270 updated to reflect the number of bits actually read.
271 NBITS is the number of bits we want to read. It is updated to
272 reflect the number of bits actually read. This function may read
274 BITS_BIG_ENDIAN is taken directly from gdbarch.
275 This function returns the extracted bits. */
278 extract_bits_primitive (const gdb_byte
**source
,
279 unsigned int *source_offset_bits
,
280 int *nbits
, int bits_big_endian
)
282 unsigned int avail
, mask
, datum
;
284 gdb_assert (*source_offset_bits
< 8);
286 avail
= 8 - *source_offset_bits
;
290 mask
= (1 << avail
) - 1;
293 datum
>>= 8 - (*source_offset_bits
+ *nbits
);
295 datum
>>= *source_offset_bits
;
299 *source_offset_bits
+= avail
;
300 if (*source_offset_bits
>= 8)
302 *source_offset_bits
-= 8;
309 /* Extract some bits from a source buffer and move forward in the
312 SOURCE is the source buffer. It is updated as bytes are read.
313 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
315 NBITS is the number of bits to read.
316 BITS_BIG_ENDIAN is taken directly from gdbarch.
318 This function returns the bits that were read. */
321 extract_bits (const gdb_byte
**source
, unsigned int *source_offset_bits
,
322 int nbits
, int bits_big_endian
)
326 gdb_assert (nbits
> 0 && nbits
<= 8);
328 datum
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
334 more
= extract_bits_primitive (source
, source_offset_bits
, &nbits
,
346 /* Write some bits into a buffer and move forward in the buffer.
348 DATUM is the bits to write. The low-order bits of DATUM are used.
349 DEST is the destination buffer. It is updated as bytes are
351 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
353 NBITS is the number of valid bits in DATUM.
354 BITS_BIG_ENDIAN is taken directly from gdbarch. */
357 insert_bits (unsigned int datum
,
358 gdb_byte
*dest
, unsigned int dest_offset_bits
,
359 int nbits
, int bits_big_endian
)
363 gdb_assert (dest_offset_bits
>= 0 && dest_offset_bits
+ nbits
<= 8);
365 mask
= (1 << nbits
) - 1;
368 datum
<<= 8 - (dest_offset_bits
+ nbits
);
369 mask
<<= 8 - (dest_offset_bits
+ nbits
);
373 datum
<<= dest_offset_bits
;
374 mask
<<= dest_offset_bits
;
377 gdb_assert ((datum
& ~mask
) == 0);
379 *dest
= (*dest
& ~mask
) | datum
;
382 /* Copy bits from a source to a destination.
384 DEST is where the bits should be written.
385 DEST_OFFSET_BITS is the bit offset into DEST.
386 SOURCE is the source of bits.
387 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
388 BIT_COUNT is the number of bits to copy.
389 BITS_BIG_ENDIAN is taken directly from gdbarch. */
392 copy_bitwise (gdb_byte
*dest
, unsigned int dest_offset_bits
,
393 const gdb_byte
*source
, unsigned int source_offset_bits
,
394 unsigned int bit_count
,
397 unsigned int dest_avail
;
400 /* Reduce everything to byte-size pieces. */
401 dest
+= dest_offset_bits
/ 8;
402 dest_offset_bits
%= 8;
403 source
+= source_offset_bits
/ 8;
404 source_offset_bits
%= 8;
406 dest_avail
= 8 - dest_offset_bits
% 8;
408 /* See if we can fill the first destination byte. */
409 if (dest_avail
< bit_count
)
411 datum
= extract_bits (&source
, &source_offset_bits
, dest_avail
,
413 insert_bits (datum
, dest
, dest_offset_bits
, dest_avail
, bits_big_endian
);
415 dest_offset_bits
= 0;
416 bit_count
-= dest_avail
;
419 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
420 than 8 bits remaining. */
421 gdb_assert (dest_offset_bits
% 8 == 0 || bit_count
< 8);
422 for (; bit_count
>= 8; bit_count
-= 8)
424 datum
= extract_bits (&source
, &source_offset_bits
, 8, bits_big_endian
);
425 *dest
++ = (gdb_byte
) datum
;
428 /* Finally, we may have a few leftover bits. */
429 gdb_assert (bit_count
<= 8 - dest_offset_bits
% 8);
432 datum
= extract_bits (&source
, &source_offset_bits
, bit_count
,
434 insert_bits (datum
, dest
, dest_offset_bits
, bit_count
, bits_big_endian
);
439 read_pieced_value (struct value
*v
)
443 ULONGEST bits_to_skip
;
445 struct piece_closure
*c
= (struct piece_closure
*) value_computed_closure (v
);
446 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (v
));
448 size_t buffer_size
= 0;
450 struct cleanup
*cleanup
;
452 = gdbarch_bits_big_endian (get_type_arch (value_type (v
)));
454 if (value_type (v
) != value_enclosing_type (v
))
455 internal_error (__FILE__
, __LINE__
,
456 _("Should not be able to create a lazy value with "
457 "an enclosing type"));
459 cleanup
= make_cleanup (free_current_contents
, &buffer
);
461 contents
= value_contents_raw (v
);
462 bits_to_skip
= 8 * value_offset (v
);
463 type_len
= 8 * TYPE_LENGTH (value_type (v
));
465 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
467 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
468 size_t this_size
, this_size_bits
;
469 long dest_offset_bits
, source_offset_bits
, source_offset
;
470 const gdb_byte
*intermediate_buffer
;
472 /* Compute size, source, and destination offsets for copying, in
474 this_size_bits
= p
->size
;
475 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
477 bits_to_skip
-= this_size_bits
;
480 if (this_size_bits
> type_len
- offset
)
481 this_size_bits
= type_len
- offset
;
482 if (bits_to_skip
> 0)
484 dest_offset_bits
= 0;
485 source_offset_bits
= bits_to_skip
;
486 this_size_bits
-= bits_to_skip
;
491 dest_offset_bits
= offset
;
492 source_offset_bits
= 0;
495 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
496 source_offset
= source_offset_bits
/ 8;
497 if (buffer_size
< this_size
)
499 buffer_size
= this_size
;
500 buffer
= xrealloc (buffer
, buffer_size
);
502 intermediate_buffer
= buffer
;
504 /* Copy from the source to DEST_BUFFER. */
507 case DWARF_VALUE_REGISTER
:
509 struct gdbarch
*arch
= get_frame_arch (frame
);
510 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
,
512 int reg_offset
= source_offset
;
514 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
515 && this_size
< register_size (arch
, gdb_regnum
))
517 /* Big-endian, and we want less than full size. */
518 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
519 /* We want the lower-order THIS_SIZE_BITS of the bytes
520 we extract from the register. */
521 source_offset_bits
+= 8 * this_size
- this_size_bits
;
524 if (gdb_regnum
!= -1)
526 get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
531 error (_("Unable to access DWARF register number %s"),
532 paddress (arch
, p
->v
.expr
.value
));
537 case DWARF_VALUE_MEMORY
:
538 if (p
->v
.expr
.in_stack_memory
)
539 read_stack (p
->v
.expr
.value
+ source_offset
, buffer
, this_size
);
541 read_memory (p
->v
.expr
.value
+ source_offset
, buffer
, this_size
);
544 case DWARF_VALUE_STACK
:
546 struct gdbarch
*gdbarch
= get_type_arch (value_type (v
));
547 size_t n
= this_size
;
549 if (n
> c
->addr_size
- source_offset
)
550 n
= (c
->addr_size
>= source_offset
551 ? c
->addr_size
- source_offset
557 else if (source_offset
== 0)
558 store_unsigned_integer (buffer
, n
,
559 gdbarch_byte_order (gdbarch
),
563 gdb_byte bytes
[sizeof (ULONGEST
)];
565 store_unsigned_integer (bytes
, n
+ source_offset
,
566 gdbarch_byte_order (gdbarch
),
568 memcpy (buffer
, bytes
+ source_offset
, n
);
573 case DWARF_VALUE_LITERAL
:
575 size_t n
= this_size
;
577 if (n
> p
->v
.literal
.length
- source_offset
)
578 n
= (p
->v
.literal
.length
>= source_offset
579 ? p
->v
.literal
.length
- source_offset
582 intermediate_buffer
= p
->v
.literal
.data
+ source_offset
;
586 case DWARF_VALUE_OPTIMIZED_OUT
:
587 /* We just leave the bits empty for now. This is not ideal
588 but gdb currently does not have a nice way to represent
589 optimized-out pieces. */
590 warning (_("bits %ld-%ld in computed object were optimized out; "
591 "replacing with zeroes"),
593 offset
+ (long) this_size_bits
);
597 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
600 if (p
->location
!= DWARF_VALUE_OPTIMIZED_OUT
)
601 copy_bitwise (contents
, dest_offset_bits
,
602 intermediate_buffer
, source_offset_bits
% 8,
603 this_size_bits
, bits_big_endian
);
605 offset
+= this_size_bits
;
608 do_cleanups (cleanup
);
612 write_pieced_value (struct value
*to
, struct value
*from
)
616 ULONGEST bits_to_skip
;
617 const gdb_byte
*contents
;
618 struct piece_closure
*c
= (struct piece_closure
*) value_computed_closure (to
);
619 struct frame_info
*frame
= frame_find_by_id (VALUE_FRAME_ID (to
));
621 size_t buffer_size
= 0;
623 struct cleanup
*cleanup
;
625 = gdbarch_bits_big_endian (get_type_arch (value_type (to
)));
629 set_value_optimized_out (to
, 1);
633 cleanup
= make_cleanup (free_current_contents
, &buffer
);
635 contents
= value_contents (from
);
636 bits_to_skip
= 8 * value_offset (to
);
637 type_len
= 8 * TYPE_LENGTH (value_type (to
));
638 for (i
= 0; i
< c
->n_pieces
&& offset
< type_len
; i
++)
640 struct dwarf_expr_piece
*p
= &c
->pieces
[i
];
641 size_t this_size_bits
, this_size
;
642 long dest_offset_bits
, source_offset_bits
, dest_offset
, source_offset
;
644 const gdb_byte
*source_buffer
;
646 this_size_bits
= p
->size
;
647 if (bits_to_skip
> 0 && bits_to_skip
>= this_size_bits
)
649 bits_to_skip
-= this_size_bits
;
652 if (this_size_bits
> type_len
- offset
)
653 this_size_bits
= type_len
- offset
;
654 if (bits_to_skip
> 0)
656 dest_offset_bits
= bits_to_skip
;
657 source_offset_bits
= 0;
658 this_size_bits
-= bits_to_skip
;
663 dest_offset_bits
= 0;
664 source_offset_bits
= offset
;
667 this_size
= (this_size_bits
+ source_offset_bits
% 8 + 7) / 8;
668 source_offset
= source_offset_bits
/ 8;
669 dest_offset
= dest_offset_bits
/ 8;
670 if (dest_offset_bits
% 8 == 0 && source_offset_bits
% 8 == 0)
672 source_buffer
= contents
+ source_offset
;
677 if (buffer_size
< this_size
)
679 buffer_size
= this_size
;
680 buffer
= xrealloc (buffer
, buffer_size
);
682 source_buffer
= buffer
;
688 case DWARF_VALUE_REGISTER
:
690 struct gdbarch
*arch
= get_frame_arch (frame
);
691 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, p
->v
.expr
.value
);
692 int reg_offset
= dest_offset
;
694 if (gdbarch_byte_order (arch
) == BFD_ENDIAN_BIG
695 && this_size
<= register_size (arch
, gdb_regnum
))
696 /* Big-endian, and we want less than full size. */
697 reg_offset
= register_size (arch
, gdb_regnum
) - this_size
;
699 if (gdb_regnum
!= -1)
703 get_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
705 copy_bitwise (buffer
, dest_offset_bits
,
706 contents
, source_offset_bits
,
711 put_frame_register_bytes (frame
, gdb_regnum
, reg_offset
,
712 this_size
, source_buffer
);
716 error (_("Unable to write to DWARF register number %s"),
717 paddress (arch
, p
->v
.expr
.value
));
721 case DWARF_VALUE_MEMORY
:
724 /* Only the first and last bytes can possibly have any
726 read_memory (p
->v
.expr
.value
+ dest_offset
, buffer
, 1);
727 read_memory (p
->v
.expr
.value
+ dest_offset
+ this_size
- 1,
728 buffer
+ this_size
- 1, 1);
729 copy_bitwise (buffer
, dest_offset_bits
,
730 contents
, source_offset_bits
,
735 write_memory (p
->v
.expr
.value
+ dest_offset
,
736 source_buffer
, this_size
);
739 set_value_optimized_out (to
, 1);
742 offset
+= this_size_bits
;
746 do_cleanups (cleanup
);
750 copy_pieced_value_closure (struct value
*v
)
752 struct piece_closure
*c
= (struct piece_closure
*) value_computed_closure (v
);
759 free_pieced_value_closure (struct value
*v
)
761 struct piece_closure
*c
= (struct piece_closure
*) value_computed_closure (v
);
771 /* Functions for accessing a variable described by DW_OP_piece. */
772 static struct lval_funcs pieced_value_funcs
= {
775 copy_pieced_value_closure
,
776 free_pieced_value_closure
779 /* Evaluate a location description, starting at DATA and with length
780 SIZE, to find the current location of variable of TYPE in the context
783 static struct value
*
784 dwarf2_evaluate_loc_desc (struct type
*type
, struct frame_info
*frame
,
785 const gdb_byte
*data
, unsigned short size
,
786 struct dwarf2_per_cu_data
*per_cu
)
788 struct value
*retval
;
789 struct dwarf_expr_baton baton
;
790 struct dwarf_expr_context
*ctx
;
791 struct cleanup
*old_chain
;
795 retval
= allocate_value (type
);
796 VALUE_LVAL (retval
) = not_lval
;
797 set_value_optimized_out (retval
, 1);
802 baton
.objfile
= dwarf2_per_cu_objfile (per_cu
);
804 ctx
= new_dwarf_expr_context ();
805 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
807 ctx
->gdbarch
= get_objfile_arch (baton
.objfile
);
808 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
810 ctx
->read_reg
= dwarf_expr_read_reg
;
811 ctx
->read_mem
= dwarf_expr_read_mem
;
812 ctx
->get_frame_base
= dwarf_expr_frame_base
;
813 ctx
->get_frame_cfa
= dwarf_expr_frame_cfa
;
814 ctx
->get_tls_address
= dwarf_expr_tls_address
;
816 dwarf_expr_eval (ctx
, data
, size
);
817 if (ctx
->num_pieces
> 0)
819 struct piece_closure
*c
;
820 struct frame_id frame_id
= get_frame_id (frame
);
822 c
= allocate_piece_closure (ctx
->num_pieces
, ctx
->pieces
,
824 retval
= allocate_computed_value (type
, &pieced_value_funcs
, c
);
825 VALUE_FRAME_ID (retval
) = frame_id
;
829 switch (ctx
->location
)
831 case DWARF_VALUE_REGISTER
:
833 struct gdbarch
*arch
= get_frame_arch (frame
);
834 CORE_ADDR dwarf_regnum
= dwarf_expr_fetch (ctx
, 0);
835 int gdb_regnum
= gdbarch_dwarf2_reg_to_regnum (arch
, dwarf_regnum
);
837 if (gdb_regnum
!= -1)
838 retval
= value_from_register (type
, gdb_regnum
, frame
);
840 error (_("Unable to access DWARF register number %s"),
841 paddress (arch
, dwarf_regnum
));
845 case DWARF_VALUE_MEMORY
:
847 CORE_ADDR address
= dwarf_expr_fetch (ctx
, 0);
848 int in_stack_memory
= dwarf_expr_fetch_in_stack_memory (ctx
, 0);
850 retval
= allocate_value (type
);
851 VALUE_LVAL (retval
) = lval_memory
;
852 set_value_lazy (retval
, 1);
854 set_value_stack (retval
, 1);
855 set_value_address (retval
, address
);
859 case DWARF_VALUE_STACK
:
861 ULONGEST value
= (ULONGEST
) dwarf_expr_fetch (ctx
, 0);
863 size_t n
= ctx
->addr_size
;
865 retval
= allocate_value (type
);
866 contents
= value_contents_raw (retval
);
867 if (n
> TYPE_LENGTH (type
))
868 n
= TYPE_LENGTH (type
);
869 store_unsigned_integer (contents
, n
,
870 gdbarch_byte_order (ctx
->gdbarch
),
875 case DWARF_VALUE_LITERAL
:
880 retval
= allocate_value (type
);
881 contents
= value_contents_raw (retval
);
882 if (n
> TYPE_LENGTH (type
))
883 n
= TYPE_LENGTH (type
);
884 memcpy (contents
, ctx
->data
, n
);
888 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
889 it can only be encountered when making a piece. */
890 case DWARF_VALUE_OPTIMIZED_OUT
:
892 internal_error (__FILE__
, __LINE__
, _("invalid location type"));
896 set_value_initialized (retval
, ctx
->initialized
);
898 do_cleanups (old_chain
);
903 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
905 struct needs_frame_baton
910 /* Reads from registers do require a frame. */
912 needs_frame_read_reg (void *baton
, int regnum
)
914 struct needs_frame_baton
*nf_baton
= baton
;
916 nf_baton
->needs_frame
= 1;
920 /* Reads from memory do not require a frame. */
922 needs_frame_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
924 memset (buf
, 0, len
);
927 /* Frame-relative accesses do require a frame. */
929 needs_frame_frame_base (void *baton
, const gdb_byte
**start
, size_t * length
)
931 static gdb_byte lit0
= DW_OP_lit0
;
932 struct needs_frame_baton
*nf_baton
= baton
;
937 nf_baton
->needs_frame
= 1;
940 /* CFA accesses require a frame. */
943 needs_frame_frame_cfa (void *baton
)
945 struct needs_frame_baton
*nf_baton
= baton
;
947 nf_baton
->needs_frame
= 1;
951 /* Thread-local accesses do require a frame. */
953 needs_frame_tls_address (void *baton
, CORE_ADDR offset
)
955 struct needs_frame_baton
*nf_baton
= baton
;
957 nf_baton
->needs_frame
= 1;
961 /* Return non-zero iff the location expression at DATA (length SIZE)
962 requires a frame to evaluate. */
965 dwarf2_loc_desc_needs_frame (const gdb_byte
*data
, unsigned short size
,
966 struct dwarf2_per_cu_data
*per_cu
)
968 struct needs_frame_baton baton
;
969 struct dwarf_expr_context
*ctx
;
971 struct cleanup
*old_chain
;
973 baton
.needs_frame
= 0;
975 ctx
= new_dwarf_expr_context ();
976 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
978 ctx
->gdbarch
= get_objfile_arch (dwarf2_per_cu_objfile (per_cu
));
979 ctx
->addr_size
= dwarf2_per_cu_addr_size (per_cu
);
981 ctx
->read_reg
= needs_frame_read_reg
;
982 ctx
->read_mem
= needs_frame_read_mem
;
983 ctx
->get_frame_base
= needs_frame_frame_base
;
984 ctx
->get_frame_cfa
= needs_frame_frame_cfa
;
985 ctx
->get_tls_address
= needs_frame_tls_address
;
987 dwarf_expr_eval (ctx
, data
, size
);
989 in_reg
= ctx
->location
== DWARF_VALUE_REGISTER
;
991 if (ctx
->num_pieces
> 0)
995 /* If the location has several pieces, and any of them are in
996 registers, then we will need a frame to fetch them from. */
997 for (i
= 0; i
< ctx
->num_pieces
; i
++)
998 if (ctx
->pieces
[i
].location
== DWARF_VALUE_REGISTER
)
1002 do_cleanups (old_chain
);
1004 return baton
.needs_frame
|| in_reg
;
1007 /* This struct keeps track of the pieces that make up a multi-location
1008 object, for use in agent expression generation. It is
1009 superficially similar to struct dwarf_expr_piece, but
1010 dwarf_expr_piece is designed for use in immediate evaluation, and
1011 does not, for example, have a way to record both base register and
1016 /* Memory vs register, etc */
1017 enum axs_lvalue_kind kind
;
1019 /* If non-zero, number of bytes in this fragment */
1022 /* (GDB-numbered) reg, or base reg if >= 0 */
1025 /* offset from reg */
1029 static const gdb_byte
*
1030 dwarf2_tracepoint_var_loc (struct symbol
*symbol
,
1031 struct agent_expr
*ax
,
1032 struct axs_var_loc
*loc
,
1033 struct gdbarch
*gdbarch
,
1034 const gdb_byte
*data
, const gdb_byte
*end
)
1036 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
1038 loc
->kind
= axs_lvalue_register
;
1039 loc
->reg
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, data
[0] - DW_OP_reg0
);
1042 else if (data
[0] == DW_OP_regx
)
1046 data
= read_uleb128 (data
+ 1, end
, ®
);
1047 loc
->kind
= axs_lvalue_register
;
1048 loc
->reg
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
);
1050 else if (data
[0] == DW_OP_fbreg
)
1053 struct symbol
*framefunc
;
1055 LONGEST frame_offset
;
1056 const gdb_byte
*base_data
;
1058 LONGEST base_offset
= 0;
1060 b
= block_for_pc (ax
->scope
);
1063 error (_("No block found for address"));
1065 framefunc
= block_linkage_function (b
);
1068 error (_("No function found for block"));
1070 dwarf_expr_frame_base_1 (framefunc
, ax
->scope
,
1071 &base_data
, &base_size
);
1073 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
1075 const gdb_byte
*buf_end
;
1077 frame_reg
= base_data
[0] - DW_OP_breg0
;
1078 buf_end
= read_sleb128 (base_data
+ 1,
1079 base_data
+ base_size
, &base_offset
);
1080 if (buf_end
!= base_data
+ base_size
)
1081 error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
1082 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
1084 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
1086 /* The frame base is just the register, with no offset. */
1087 frame_reg
= base_data
[0] - DW_OP_reg0
;
1092 /* We don't know what to do with the frame base expression,
1093 so we can't trace this variable; give up. */
1094 error (_("Cannot generate expression to collect symbol \"%s\"; DWARF 2 encoding not handled, first opcode in base data is 0x%x."),
1095 SYMBOL_PRINT_NAME (symbol
), base_data
[0]);
1098 data
= read_sleb128 (data
+ 1, end
, &frame_offset
);
1100 loc
->kind
= axs_lvalue_memory
;
1101 loc
->reg
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, frame_reg
);
1102 loc
->offset
= base_offset
+ frame_offset
;
1104 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
)
1109 reg
= data
[0] - DW_OP_breg0
;
1110 data
= read_sleb128 (data
+ 1, end
, &offset
);
1112 loc
->kind
= axs_lvalue_memory
;
1113 loc
->reg
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
);
1114 loc
->offset
= offset
;
1117 error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
1118 data
[0], SYMBOL_PRINT_NAME (symbol
));
1123 /* Given the location of a piece, issue bytecodes that will access it. */
1126 dwarf2_tracepoint_var_access (struct agent_expr
*ax
,
1127 struct axs_value
*value
,
1128 struct axs_var_loc
*loc
)
1130 value
->kind
= loc
->kind
;
1134 case axs_lvalue_register
:
1135 value
->u
.reg
= loc
->reg
;
1138 case axs_lvalue_memory
:
1139 ax_reg (ax
, loc
->reg
);
1142 ax_const_l (ax
, loc
->offset
);
1143 ax_simple (ax
, aop_add
);
1148 internal_error (__FILE__
, __LINE__
, _("Unhandled value kind in dwarf2_tracepoint_var_access"));
1153 dwarf2_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
1154 struct agent_expr
*ax
, struct axs_value
*value
,
1155 const gdb_byte
*data
, int size
)
1157 const gdb_byte
*end
= data
+ size
;
1158 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1159 /* In practice, a variable is not going to be spread across
1160 dozens of registers or memory locations. If someone comes up
1161 with a real-world example, revisit this. */
1162 #define MAX_FRAGS 16
1163 struct axs_var_loc fragments
[MAX_FRAGS
];
1164 int nfrags
= 0, frag
;
1170 if (!data
|| size
== 0)
1172 value
->optimized_out
= 1;
1180 if (nfrags
== MAX_FRAGS
)
1181 error (_("Too many pieces in location for \"%s\"."),
1182 SYMBOL_PRINT_NAME (symbol
));
1184 fragments
[nfrags
].bytes
= 0;
1185 data
= dwarf2_tracepoint_var_loc (symbol
, ax
, &fragments
[nfrags
],
1186 gdbarch
, data
, end
);
1190 else if (data
[0] == DW_OP_piece
)
1194 data
= read_uleb128 (data
+ 1, end
, &bytes
);
1195 /* Only deal with 4 byte fragments for now. */
1197 error (_("DW_OP_piece %s not supported in location for \"%s\"."),
1198 pulongest (bytes
), SYMBOL_PRINT_NAME (symbol
));
1199 fragments
[nfrags
- 1].bytes
= bytes
;
1210 if (bad
|| data
> end
)
1211 error (_("Corrupted DWARF expression for \"%s\"."),
1212 SYMBOL_PRINT_NAME (symbol
));
1214 /* If single expression, no pieces, convert to external format. */
1217 dwarf2_tracepoint_var_access (ax
, value
, &fragments
[0]);
1221 if (length
!= TYPE_LENGTH (value
->type
))
1222 error (_("Inconsistent piece information for \"%s\"."),
1223 SYMBOL_PRINT_NAME (symbol
));
1225 /* Emit bytecodes to assemble the pieces into a single stack entry. */
1227 for ((frag
= (byte_order
== BFD_ENDIAN_BIG
? 0 : nfrags
- 1));
1229 (frag
+= (byte_order
== BFD_ENDIAN_BIG
? 1 : -1)))
1233 /* shift the previous fragment up 32 bits */
1234 ax_const_l (ax
, 32);
1235 ax_simple (ax
, aop_lsh
);
1238 dwarf2_tracepoint_var_access (ax
, value
, &fragments
[frag
]);
1240 switch (value
->kind
)
1242 case axs_lvalue_register
:
1243 ax_reg (ax
, value
->u
.reg
);
1246 case axs_lvalue_memory
:
1248 extern int trace_kludge
; /* Ugh. */
1250 gdb_assert (fragments
[frag
].bytes
== 4);
1252 ax_trace_quick (ax
, 4);
1253 ax_simple (ax
, aop_ref32
);
1260 /* or the new fragment into the previous */
1261 ax_zero_ext (ax
, 32);
1262 ax_simple (ax
, aop_bit_or
);
1266 value
->kind
= axs_rvalue
;
1270 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
1271 evaluator to calculate the location. */
1272 static struct value
*
1273 locexpr_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
1275 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
1278 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, dlbaton
->data
,
1279 dlbaton
->size
, dlbaton
->per_cu
);
1284 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
1286 locexpr_read_needs_frame (struct symbol
*symbol
)
1288 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
1290 return dwarf2_loc_desc_needs_frame (dlbaton
->data
, dlbaton
->size
,
1294 /* Describe a single piece of a location, returning an updated
1295 position in the bytecode sequence. */
1297 static const gdb_byte
*
1298 locexpr_describe_location_piece (struct symbol
*symbol
, struct ui_file
*stream
,
1299 CORE_ADDR addr
, struct objfile
*objfile
,
1300 const gdb_byte
*data
, int size
,
1301 unsigned int addr_size
)
1303 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1306 if (data
[0] >= DW_OP_reg0
&& data
[0] <= DW_OP_reg31
)
1308 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, data
[0] - DW_OP_reg0
);
1309 fprintf_filtered (stream
, _("a variable in $%s"),
1310 gdbarch_register_name (gdbarch
, regno
));
1313 else if (data
[0] == DW_OP_regx
)
1317 data
= read_uleb128 (data
+ 1, data
+ size
, ®
);
1318 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
);
1319 fprintf_filtered (stream
, _("a variable in $%s"),
1320 gdbarch_register_name (gdbarch
, regno
));
1322 else if (data
[0] == DW_OP_fbreg
)
1325 struct symbol
*framefunc
;
1327 LONGEST frame_offset
;
1328 const gdb_byte
*base_data
;
1330 LONGEST base_offset
= 0;
1332 b
= block_for_pc (addr
);
1335 error (_("No block found for address for symbol \"%s\"."),
1336 SYMBOL_PRINT_NAME (symbol
));
1338 framefunc
= block_linkage_function (b
);
1341 error (_("No function found for block for symbol \"%s\"."),
1342 SYMBOL_PRINT_NAME (symbol
));
1344 dwarf_expr_frame_base_1 (framefunc
, addr
, &base_data
, &base_size
);
1346 if (base_data
[0] >= DW_OP_breg0
&& base_data
[0] <= DW_OP_breg31
)
1348 const gdb_byte
*buf_end
;
1350 frame_reg
= base_data
[0] - DW_OP_breg0
;
1351 buf_end
= read_sleb128 (base_data
+ 1,
1352 base_data
+ base_size
, &base_offset
);
1353 if (buf_end
!= base_data
+ base_size
)
1354 error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
1355 frame_reg
, SYMBOL_PRINT_NAME (symbol
));
1357 else if (base_data
[0] >= DW_OP_reg0
&& base_data
[0] <= DW_OP_reg31
)
1359 /* The frame base is just the register, with no offset. */
1360 frame_reg
= base_data
[0] - DW_OP_reg0
;
1365 /* We don't know what to do with the frame base expression,
1366 so we can't trace this variable; give up. */
1367 error (_("Cannot describe location of symbol \"%s\"; "
1368 "DWARF 2 encoding not handled, "
1369 "first opcode in base data is 0x%x."),
1370 SYMBOL_PRINT_NAME (symbol
), base_data
[0]);
1373 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, frame_reg
);
1375 data
= read_sleb128 (data
+ 1, data
+ size
, &frame_offset
);
1377 fprintf_filtered (stream
, _("a variable at frame base reg $%s offset %s+%s"),
1378 gdbarch_register_name (gdbarch
, regno
),
1379 plongest (base_offset
), plongest (frame_offset
));
1381 else if (data
[0] >= DW_OP_breg0
&& data
[0] <= DW_OP_breg31
)
1385 regno
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, data
[0] - DW_OP_breg0
);
1387 data
= read_sleb128 (data
+ 1, data
+ size
, &offset
);
1389 fprintf_filtered (stream
,
1390 _("a variable at offset %s from base reg $%s"),
1392 gdbarch_register_name (gdbarch
, regno
));
1395 /* The location expression for a TLS variable looks like this (on a
1398 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
1399 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
1401 0x3 is the encoding for DW_OP_addr, which has an operand as long
1402 as the size of an address on the target machine (here is 8
1403 bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
1404 The operand represents the offset at which the variable is within
1405 the thread local storage. */
1408 && data
[size
- 1] == DW_OP_GNU_push_tls_address
1409 && data
[0] == DW_OP_addr
)
1411 CORE_ADDR offset
= dwarf2_read_address (gdbarch
,
1416 fprintf_filtered (stream
,
1417 _("a thread-local variable at offset %s "
1418 "in the thread-local storage for `%s'"),
1419 paddress (gdbarch
, offset
), objfile
->name
);
1421 data
+= 1 + addr_size
+ 1;
1424 fprintf_filtered (stream
,
1425 _("a variable with complex or multiple locations (DWARF2)"));
1430 /* Describe a single location, which may in turn consist of multiple
1434 locexpr_describe_location_1 (struct symbol
*symbol
, CORE_ADDR addr
,
1435 struct ui_file
*stream
,
1436 const gdb_byte
*data
, int size
,
1437 struct objfile
*objfile
, unsigned int addr_size
)
1439 const gdb_byte
*end
= data
+ size
;
1440 int piece_done
= 0, first_piece
= 1, bad
= 0;
1442 /* A multi-piece description consists of multiple sequences of bytes
1443 each followed by DW_OP_piece + length of piece. */
1451 fprintf_filtered (stream
, _(", and "));
1453 data
= locexpr_describe_location_piece (symbol
, stream
, addr
, objfile
,
1454 data
, size
, addr_size
);
1457 else if (data
[0] == DW_OP_piece
)
1461 data
= read_uleb128 (data
+ 1, end
, &bytes
);
1463 fprintf_filtered (stream
, _(" [%s-byte piece]"), pulongest (bytes
));
1474 if (bad
|| data
> end
)
1475 error (_("Corrupted DWARF2 expression for \"%s\"."),
1476 SYMBOL_PRINT_NAME (symbol
));
1479 /* Print a natural-language description of SYMBOL to STREAM. This
1480 version is for a symbol with a single location. */
1483 locexpr_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
1484 struct ui_file
*stream
)
1486 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
1487 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
1488 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
1490 locexpr_describe_location_1 (symbol
, addr
, stream
, dlbaton
->data
, dlbaton
->size
,
1491 objfile
, addr_size
);
1494 /* Describe the location of SYMBOL as an agent value in VALUE, generating
1495 any necessary bytecode in AX. */
1498 locexpr_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
1499 struct agent_expr
*ax
, struct axs_value
*value
)
1501 struct dwarf2_locexpr_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
1503 dwarf2_tracepoint_var_ref (symbol
, gdbarch
, ax
, value
,
1504 dlbaton
->data
, dlbaton
->size
);
1507 /* The set of location functions used with the DWARF-2 expression
1509 const struct symbol_computed_ops dwarf2_locexpr_funcs
= {
1510 locexpr_read_variable
,
1511 locexpr_read_needs_frame
,
1512 locexpr_describe_location
,
1513 locexpr_tracepoint_var_ref
1517 /* Wrapper functions for location lists. These generally find
1518 the appropriate location expression and call something above. */
1520 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
1521 evaluator to calculate the location. */
1522 static struct value
*
1523 loclist_read_variable (struct symbol
*symbol
, struct frame_info
*frame
)
1525 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
1527 const gdb_byte
*data
;
1530 data
= find_location_expression (dlbaton
, &size
,
1531 frame
? get_frame_address_in_block (frame
)
1535 val
= allocate_value (SYMBOL_TYPE (symbol
));
1536 VALUE_LVAL (val
) = not_lval
;
1537 set_value_optimized_out (val
, 1);
1540 val
= dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol
), frame
, data
, size
,
1546 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
1548 loclist_read_needs_frame (struct symbol
*symbol
)
1550 /* If there's a location list, then assume we need to have a frame
1551 to choose the appropriate location expression. With tracking of
1552 global variables this is not necessarily true, but such tracking
1553 is disabled in GCC at the moment until we figure out how to
1559 /* Print a natural-language description of SYMBOL to STREAM. This
1560 version applies when there is a list of different locations, each
1561 with a specified address range. */
1564 loclist_describe_location (struct symbol
*symbol
, CORE_ADDR addr
,
1565 struct ui_file
*stream
)
1567 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
1568 CORE_ADDR low
, high
;
1569 const gdb_byte
*loc_ptr
, *buf_end
;
1570 int length
, first
= 1;
1571 struct objfile
*objfile
= dwarf2_per_cu_objfile (dlbaton
->per_cu
);
1572 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1573 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1574 unsigned int addr_size
= dwarf2_per_cu_addr_size (dlbaton
->per_cu
);
1575 CORE_ADDR base_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
1576 /* Adjust base_address for relocatable objects. */
1577 CORE_ADDR base_offset
= ANOFFSET (objfile
->section_offsets
,
1578 SECT_OFF_TEXT (objfile
));
1579 CORE_ADDR base_address
= dlbaton
->base_address
+ base_offset
;
1581 loc_ptr
= dlbaton
->data
;
1582 buf_end
= dlbaton
->data
+ dlbaton
->size
;
1584 fprintf_filtered (stream
, _("multi-location ("));
1586 /* Iterate through locations until we run out. */
1589 if (buf_end
- loc_ptr
< 2 * addr_size
)
1590 error (_("Corrupted DWARF expression for symbol \"%s\"."),
1591 SYMBOL_PRINT_NAME (symbol
));
1593 low
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
1594 loc_ptr
+= addr_size
;
1596 /* A base-address-selection entry. */
1597 if (low
== base_mask
)
1599 base_address
= dwarf2_read_address (gdbarch
,
1600 loc_ptr
, buf_end
, addr_size
);
1601 fprintf_filtered (stream
, _("[base address %s]"),
1602 paddress (gdbarch
, base_address
));
1603 loc_ptr
+= addr_size
;
1607 high
= extract_unsigned_integer (loc_ptr
, addr_size
, byte_order
);
1608 loc_ptr
+= addr_size
;
1610 /* An end-of-list entry. */
1611 if (low
== 0 && high
== 0)
1613 /* Indicate the end of the list, for readability. */
1614 fprintf_filtered (stream
, _(")"));
1618 /* Otherwise, a location expression entry. */
1619 low
+= base_address
;
1620 high
+= base_address
;
1622 length
= extract_unsigned_integer (loc_ptr
, 2, byte_order
);
1625 /* Separate the different locations with a semicolon. */
1629 fprintf_filtered (stream
, _("; "));
1631 /* (It would improve readability to print only the minimum
1632 necessary digits of the second number of the range.) */
1633 fprintf_filtered (stream
, _("range %s-%s, "),
1634 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
1636 /* Now describe this particular location. */
1637 locexpr_describe_location_1 (symbol
, low
, stream
, loc_ptr
, length
,
1638 objfile
, addr_size
);
1644 /* Describe the location of SYMBOL as an agent value in VALUE, generating
1645 any necessary bytecode in AX. */
1647 loclist_tracepoint_var_ref (struct symbol
*symbol
, struct gdbarch
*gdbarch
,
1648 struct agent_expr
*ax
, struct axs_value
*value
)
1650 struct dwarf2_loclist_baton
*dlbaton
= SYMBOL_LOCATION_BATON (symbol
);
1651 const gdb_byte
*data
;
1654 data
= find_location_expression (dlbaton
, &size
, ax
->scope
);
1656 dwarf2_tracepoint_var_ref (symbol
, gdbarch
, ax
, value
, data
, size
);
1659 /* The set of location functions used with the DWARF-2 expression
1660 evaluator and location lists. */
1661 const struct symbol_computed_ops dwarf2_loclist_funcs
= {
1662 loclist_read_variable
,
1663 loclist_read_needs_frame
,
1664 loclist_describe_location
,
1665 loclist_tracepoint_var_ref