2011-02-28 Michael Snyder <msnyder@vmware.com>
[deliverable/binutils-gdb.git] / gdb / dwarf2loc.c
1 /* DWARF 2 location expression support for GDB.
2
3 Copyright (C) 2003, 2005, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
5
6 Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
7
8 This file is part of GDB.
9
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.
14
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.
19
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/>. */
22
23 #include "defs.h"
24 #include "ui-out.h"
25 #include "value.h"
26 #include "frame.h"
27 #include "gdbcore.h"
28 #include "target.h"
29 #include "inferior.h"
30 #include "ax.h"
31 #include "ax-gdb.h"
32 #include "regcache.h"
33 #include "objfiles.h"
34 #include "exceptions.h"
35 #include "block.h"
36
37 #include "dwarf2.h"
38 #include "dwarf2expr.h"
39 #include "dwarf2loc.h"
40 #include "dwarf2-frame.h"
41
42 #include "gdb_string.h"
43 #include "gdb_assert.h"
44
45 extern int dwarf2_always_disassemble;
46
47 static void
48 dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
49 const gdb_byte **start, size_t *length);
50
51 static struct value *
52 dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
53 const gdb_byte *data, unsigned short size,
54 struct dwarf2_per_cu_data *per_cu,
55 LONGEST byte_offset);
56
57 /* A function for dealing with location lists. Given a
58 symbol baton (BATON) and a pc value (PC), find the appropriate
59 location expression, set *LOCEXPR_LENGTH, and return a pointer
60 to the beginning of the expression. Returns NULL on failure.
61
62 For now, only return the first matching location expression; there
63 can be more than one in the list. */
64
65 const gdb_byte *
66 dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton,
67 size_t *locexpr_length, CORE_ADDR pc)
68 {
69 CORE_ADDR low, high;
70 const gdb_byte *loc_ptr, *buf_end;
71 int length;
72 struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu);
73 struct gdbarch *gdbarch = get_objfile_arch (objfile);
74 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
75 unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu);
76 int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
77 CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
78 /* Adjust base_address for relocatable objects. */
79 CORE_ADDR base_offset = dwarf2_per_cu_text_offset (baton->per_cu);
80 CORE_ADDR base_address = baton->base_address + base_offset;
81
82 loc_ptr = baton->data;
83 buf_end = baton->data + baton->size;
84
85 while (1)
86 {
87 if (buf_end - loc_ptr < 2 * addr_size)
88 error (_("dwarf2_find_location_expression: "
89 "Corrupted DWARF expression."));
90
91 if (signed_addr_p)
92 low = extract_signed_integer (loc_ptr, addr_size, byte_order);
93 else
94 low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
95 loc_ptr += addr_size;
96
97 if (signed_addr_p)
98 high = extract_signed_integer (loc_ptr, addr_size, byte_order);
99 else
100 high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
101 loc_ptr += addr_size;
102
103 /* A base-address-selection entry. */
104 if ((low & base_mask) == base_mask)
105 {
106 base_address = high + base_offset;
107 continue;
108 }
109
110 /* An end-of-list entry. */
111 if (low == 0 && high == 0)
112 return NULL;
113
114 /* Otherwise, a location expression entry. */
115 low += base_address;
116 high += base_address;
117
118 length = extract_unsigned_integer (loc_ptr, 2, byte_order);
119 loc_ptr += 2;
120
121 if (pc >= low && pc < high)
122 {
123 *locexpr_length = length;
124 return loc_ptr;
125 }
126
127 loc_ptr += length;
128 }
129 }
130
131 /* This is the baton used when performing dwarf2 expression
132 evaluation. */
133 struct dwarf_expr_baton
134 {
135 struct frame_info *frame;
136 struct dwarf2_per_cu_data *per_cu;
137 };
138
139 /* Helper functions for dwarf2_evaluate_loc_desc. */
140
141 /* Using the frame specified in BATON, return the value of register
142 REGNUM, treated as a pointer. */
143 static CORE_ADDR
144 dwarf_expr_read_reg (void *baton, int dwarf_regnum)
145 {
146 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
147 struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
148 CORE_ADDR result;
149 int regnum;
150
151 regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
152 result = address_from_register (builtin_type (gdbarch)->builtin_data_ptr,
153 regnum, debaton->frame);
154 return result;
155 }
156
157 /* Read memory at ADDR (length LEN) into BUF. */
158
159 static void
160 dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
161 {
162 read_memory (addr, buf, len);
163 }
164
165 /* Using the frame specified in BATON, find the location expression
166 describing the frame base. Return a pointer to it in START and
167 its length in LENGTH. */
168 static void
169 dwarf_expr_frame_base (void *baton, const gdb_byte **start, size_t * length)
170 {
171 /* FIXME: cagney/2003-03-26: This code should be using
172 get_frame_base_address(), and then implement a dwarf2 specific
173 this_base method. */
174 struct symbol *framefunc;
175 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
176
177 /* Use block_linkage_function, which returns a real (not inlined)
178 function, instead of get_frame_function, which may return an
179 inlined function. */
180 framefunc = block_linkage_function (get_frame_block (debaton->frame, NULL));
181
182 /* If we found a frame-relative symbol then it was certainly within
183 some function associated with a frame. If we can't find the frame,
184 something has gone wrong. */
185 gdb_assert (framefunc != NULL);
186
187 dwarf_expr_frame_base_1 (framefunc,
188 get_frame_address_in_block (debaton->frame),
189 start, length);
190 }
191
192 static void
193 dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
194 const gdb_byte **start, size_t *length)
195 {
196 if (SYMBOL_LOCATION_BATON (framefunc) == NULL)
197 *start = NULL;
198 else if (SYMBOL_COMPUTED_OPS (framefunc) == &dwarf2_loclist_funcs)
199 {
200 struct dwarf2_loclist_baton *symbaton;
201
202 symbaton = SYMBOL_LOCATION_BATON (framefunc);
203 *start = dwarf2_find_location_expression (symbaton, length, pc);
204 }
205 else
206 {
207 struct dwarf2_locexpr_baton *symbaton;
208
209 symbaton = SYMBOL_LOCATION_BATON (framefunc);
210 if (symbaton != NULL)
211 {
212 *length = symbaton->size;
213 *start = symbaton->data;
214 }
215 else
216 *start = NULL;
217 }
218
219 if (*start == NULL)
220 error (_("Could not find the frame base for \"%s\"."),
221 SYMBOL_NATURAL_NAME (framefunc));
222 }
223
224 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
225 the frame in BATON. */
226
227 static CORE_ADDR
228 dwarf_expr_frame_cfa (void *baton)
229 {
230 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
231
232 return dwarf2_frame_cfa (debaton->frame);
233 }
234
235 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
236 the frame in BATON. */
237
238 static CORE_ADDR
239 dwarf_expr_frame_pc (void *baton)
240 {
241 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
242
243 return get_frame_address_in_block (debaton->frame);
244 }
245
246 /* Using the objfile specified in BATON, find the address for the
247 current thread's thread-local storage with offset OFFSET. */
248 static CORE_ADDR
249 dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
250 {
251 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
252 struct objfile *objfile = dwarf2_per_cu_objfile (debaton->per_cu);
253
254 return target_translate_tls_address (objfile, offset);
255 }
256
257 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
258 current CU (as is PER_CU). State of the CTX is not affected by the
259 call and return. */
260
261 static void
262 per_cu_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset,
263 struct dwarf2_per_cu_data *per_cu,
264 CORE_ADDR (*get_frame_pc) (void *baton),
265 void *baton)
266 {
267 struct dwarf2_locexpr_baton block;
268
269 block = dwarf2_fetch_die_location_block (die_offset, per_cu,
270 get_frame_pc, baton);
271
272 /* DW_OP_call_ref is currently not supported. */
273 gdb_assert (block.per_cu == per_cu);
274
275 dwarf_expr_eval (ctx, block.data, block.size);
276 }
277
278 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
279
280 static void
281 dwarf_expr_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset)
282 {
283 struct dwarf_expr_baton *debaton = ctx->baton;
284
285 return per_cu_dwarf_call (ctx, die_offset, debaton->per_cu,
286 ctx->get_frame_pc, ctx->baton);
287 }
288
289 struct piece_closure
290 {
291 /* Reference count. */
292 int refc;
293
294 /* The CU from which this closure's expression came. */
295 struct dwarf2_per_cu_data *per_cu;
296
297 /* The number of pieces used to describe this variable. */
298 int n_pieces;
299
300 /* The target address size, used only for DWARF_VALUE_STACK. */
301 int addr_size;
302
303 /* The pieces themselves. */
304 struct dwarf_expr_piece *pieces;
305 };
306
307 /* Allocate a closure for a value formed from separately-described
308 PIECES. */
309
310 static struct piece_closure *
311 allocate_piece_closure (struct dwarf2_per_cu_data *per_cu,
312 int n_pieces, struct dwarf_expr_piece *pieces,
313 int addr_size)
314 {
315 struct piece_closure *c = XZALLOC (struct piece_closure);
316
317 c->refc = 1;
318 c->per_cu = per_cu;
319 c->n_pieces = n_pieces;
320 c->addr_size = addr_size;
321 c->pieces = XCALLOC (n_pieces, struct dwarf_expr_piece);
322
323 memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
324
325 return c;
326 }
327
328 /* The lowest-level function to extract bits from a byte buffer.
329 SOURCE is the buffer. It is updated if we read to the end of a
330 byte.
331 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
332 updated to reflect the number of bits actually read.
333 NBITS is the number of bits we want to read. It is updated to
334 reflect the number of bits actually read. This function may read
335 fewer bits.
336 BITS_BIG_ENDIAN is taken directly from gdbarch.
337 This function returns the extracted bits. */
338
339 static unsigned int
340 extract_bits_primitive (const gdb_byte **source,
341 unsigned int *source_offset_bits,
342 int *nbits, int bits_big_endian)
343 {
344 unsigned int avail, mask, datum;
345
346 gdb_assert (*source_offset_bits < 8);
347
348 avail = 8 - *source_offset_bits;
349 if (avail > *nbits)
350 avail = *nbits;
351
352 mask = (1 << avail) - 1;
353 datum = **source;
354 if (bits_big_endian)
355 datum >>= 8 - (*source_offset_bits + *nbits);
356 else
357 datum >>= *source_offset_bits;
358 datum &= mask;
359
360 *nbits -= avail;
361 *source_offset_bits += avail;
362 if (*source_offset_bits >= 8)
363 {
364 *source_offset_bits -= 8;
365 ++*source;
366 }
367
368 return datum;
369 }
370
371 /* Extract some bits from a source buffer and move forward in the
372 buffer.
373
374 SOURCE is the source buffer. It is updated as bytes are read.
375 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
376 bits are read.
377 NBITS is the number of bits to read.
378 BITS_BIG_ENDIAN is taken directly from gdbarch.
379
380 This function returns the bits that were read. */
381
382 static unsigned int
383 extract_bits (const gdb_byte **source, unsigned int *source_offset_bits,
384 int nbits, int bits_big_endian)
385 {
386 unsigned int datum;
387
388 gdb_assert (nbits > 0 && nbits <= 8);
389
390 datum = extract_bits_primitive (source, source_offset_bits, &nbits,
391 bits_big_endian);
392 if (nbits > 0)
393 {
394 unsigned int more;
395
396 more = extract_bits_primitive (source, source_offset_bits, &nbits,
397 bits_big_endian);
398 if (bits_big_endian)
399 datum <<= nbits;
400 else
401 more <<= nbits;
402 datum |= more;
403 }
404
405 return datum;
406 }
407
408 /* Write some bits into a buffer and move forward in the buffer.
409
410 DATUM is the bits to write. The low-order bits of DATUM are used.
411 DEST is the destination buffer. It is updated as bytes are
412 written.
413 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
414 done.
415 NBITS is the number of valid bits in DATUM.
416 BITS_BIG_ENDIAN is taken directly from gdbarch. */
417
418 static void
419 insert_bits (unsigned int datum,
420 gdb_byte *dest, unsigned int dest_offset_bits,
421 int nbits, int bits_big_endian)
422 {
423 unsigned int mask;
424
425 gdb_assert (dest_offset_bits + nbits <= 8);
426
427 mask = (1 << nbits) - 1;
428 if (bits_big_endian)
429 {
430 datum <<= 8 - (dest_offset_bits + nbits);
431 mask <<= 8 - (dest_offset_bits + nbits);
432 }
433 else
434 {
435 datum <<= dest_offset_bits;
436 mask <<= dest_offset_bits;
437 }
438
439 gdb_assert ((datum & ~mask) == 0);
440
441 *dest = (*dest & ~mask) | datum;
442 }
443
444 /* Copy bits from a source to a destination.
445
446 DEST is where the bits should be written.
447 DEST_OFFSET_BITS is the bit offset into DEST.
448 SOURCE is the source of bits.
449 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
450 BIT_COUNT is the number of bits to copy.
451 BITS_BIG_ENDIAN is taken directly from gdbarch. */
452
453 static void
454 copy_bitwise (gdb_byte *dest, unsigned int dest_offset_bits,
455 const gdb_byte *source, unsigned int source_offset_bits,
456 unsigned int bit_count,
457 int bits_big_endian)
458 {
459 unsigned int dest_avail;
460 int datum;
461
462 /* Reduce everything to byte-size pieces. */
463 dest += dest_offset_bits / 8;
464 dest_offset_bits %= 8;
465 source += source_offset_bits / 8;
466 source_offset_bits %= 8;
467
468 dest_avail = 8 - dest_offset_bits % 8;
469
470 /* See if we can fill the first destination byte. */
471 if (dest_avail < bit_count)
472 {
473 datum = extract_bits (&source, &source_offset_bits, dest_avail,
474 bits_big_endian);
475 insert_bits (datum, dest, dest_offset_bits, dest_avail, bits_big_endian);
476 ++dest;
477 dest_offset_bits = 0;
478 bit_count -= dest_avail;
479 }
480
481 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
482 than 8 bits remaining. */
483 gdb_assert (dest_offset_bits % 8 == 0 || bit_count < 8);
484 for (; bit_count >= 8; bit_count -= 8)
485 {
486 datum = extract_bits (&source, &source_offset_bits, 8, bits_big_endian);
487 *dest++ = (gdb_byte) datum;
488 }
489
490 /* Finally, we may have a few leftover bits. */
491 gdb_assert (bit_count <= 8 - dest_offset_bits % 8);
492 if (bit_count > 0)
493 {
494 datum = extract_bits (&source, &source_offset_bits, bit_count,
495 bits_big_endian);
496 insert_bits (datum, dest, dest_offset_bits, bit_count, bits_big_endian);
497 }
498 }
499
500 static void
501 read_pieced_value (struct value *v)
502 {
503 int i;
504 long offset = 0;
505 ULONGEST bits_to_skip;
506 gdb_byte *contents;
507 struct piece_closure *c
508 = (struct piece_closure *) value_computed_closure (v);
509 struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
510 size_t type_len;
511 size_t buffer_size = 0;
512 char *buffer = NULL;
513 struct cleanup *cleanup;
514 int bits_big_endian
515 = gdbarch_bits_big_endian (get_type_arch (value_type (v)));
516
517 if (value_type (v) != value_enclosing_type (v))
518 internal_error (__FILE__, __LINE__,
519 _("Should not be able to create a lazy value with "
520 "an enclosing type"));
521
522 cleanup = make_cleanup (free_current_contents, &buffer);
523
524 contents = value_contents_raw (v);
525 bits_to_skip = 8 * value_offset (v);
526 if (value_bitsize (v))
527 {
528 bits_to_skip += value_bitpos (v);
529 type_len = value_bitsize (v);
530 }
531 else
532 type_len = 8 * TYPE_LENGTH (value_type (v));
533
534 for (i = 0; i < c->n_pieces && offset < type_len; i++)
535 {
536 struct dwarf_expr_piece *p = &c->pieces[i];
537 size_t this_size, this_size_bits;
538 long dest_offset_bits, source_offset_bits, source_offset;
539 const gdb_byte *intermediate_buffer;
540
541 /* Compute size, source, and destination offsets for copying, in
542 bits. */
543 this_size_bits = p->size;
544 if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
545 {
546 bits_to_skip -= this_size_bits;
547 continue;
548 }
549 if (this_size_bits > type_len - offset)
550 this_size_bits = type_len - offset;
551 if (bits_to_skip > 0)
552 {
553 dest_offset_bits = 0;
554 source_offset_bits = bits_to_skip;
555 this_size_bits -= bits_to_skip;
556 bits_to_skip = 0;
557 }
558 else
559 {
560 dest_offset_bits = offset;
561 source_offset_bits = 0;
562 }
563
564 this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
565 source_offset = source_offset_bits / 8;
566 if (buffer_size < this_size)
567 {
568 buffer_size = this_size;
569 buffer = xrealloc (buffer, buffer_size);
570 }
571 intermediate_buffer = buffer;
572
573 /* Copy from the source to DEST_BUFFER. */
574 switch (p->location)
575 {
576 case DWARF_VALUE_REGISTER:
577 {
578 struct gdbarch *arch = get_frame_arch (frame);
579 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.value);
580 int reg_offset = source_offset;
581
582 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
583 && this_size < register_size (arch, gdb_regnum))
584 {
585 /* Big-endian, and we want less than full size. */
586 reg_offset = register_size (arch, gdb_regnum) - this_size;
587 /* We want the lower-order THIS_SIZE_BITS of the bytes
588 we extract from the register. */
589 source_offset_bits += 8 * this_size - this_size_bits;
590 }
591
592 if (gdb_regnum != -1)
593 {
594 get_frame_register_bytes (frame, gdb_regnum, reg_offset,
595 this_size, buffer);
596 }
597 else
598 {
599 error (_("Unable to access DWARF register number %s"),
600 paddress (arch, p->v.value));
601 }
602 }
603 break;
604
605 case DWARF_VALUE_MEMORY:
606 read_value_memory (v, offset,
607 p->v.mem.in_stack_memory,
608 p->v.mem.addr + source_offset,
609 buffer, this_size);
610 break;
611
612 case DWARF_VALUE_STACK:
613 {
614 struct gdbarch *gdbarch = get_type_arch (value_type (v));
615 size_t n = this_size;
616
617 if (n > c->addr_size - source_offset)
618 n = (c->addr_size >= source_offset
619 ? c->addr_size - source_offset
620 : 0);
621 if (n == 0)
622 {
623 /* Nothing. */
624 }
625 else if (source_offset == 0)
626 store_unsigned_integer (buffer, n,
627 gdbarch_byte_order (gdbarch),
628 p->v.value);
629 else
630 {
631 gdb_byte bytes[sizeof (ULONGEST)];
632
633 store_unsigned_integer (bytes, n + source_offset,
634 gdbarch_byte_order (gdbarch),
635 p->v.value);
636 memcpy (buffer, bytes + source_offset, n);
637 }
638 }
639 break;
640
641 case DWARF_VALUE_LITERAL:
642 {
643 size_t n = this_size;
644
645 if (n > p->v.literal.length - source_offset)
646 n = (p->v.literal.length >= source_offset
647 ? p->v.literal.length - source_offset
648 : 0);
649 if (n != 0)
650 intermediate_buffer = p->v.literal.data + source_offset;
651 }
652 break;
653
654 /* These bits show up as zeros -- but do not cause the value
655 to be considered optimized-out. */
656 case DWARF_VALUE_IMPLICIT_POINTER:
657 break;
658
659 case DWARF_VALUE_OPTIMIZED_OUT:
660 set_value_optimized_out (v, 1);
661 break;
662
663 default:
664 internal_error (__FILE__, __LINE__, _("invalid location type"));
665 }
666
667 if (p->location != DWARF_VALUE_OPTIMIZED_OUT
668 && p->location != DWARF_VALUE_IMPLICIT_POINTER)
669 copy_bitwise (contents, dest_offset_bits,
670 intermediate_buffer, source_offset_bits % 8,
671 this_size_bits, bits_big_endian);
672
673 offset += this_size_bits;
674 }
675
676 do_cleanups (cleanup);
677 }
678
679 static void
680 write_pieced_value (struct value *to, struct value *from)
681 {
682 int i;
683 long offset = 0;
684 ULONGEST bits_to_skip;
685 const gdb_byte *contents;
686 struct piece_closure *c
687 = (struct piece_closure *) value_computed_closure (to);
688 struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
689 size_t type_len;
690 size_t buffer_size = 0;
691 char *buffer = NULL;
692 struct cleanup *cleanup;
693 int bits_big_endian
694 = gdbarch_bits_big_endian (get_type_arch (value_type (to)));
695
696 if (frame == NULL)
697 {
698 set_value_optimized_out (to, 1);
699 return;
700 }
701
702 cleanup = make_cleanup (free_current_contents, &buffer);
703
704 contents = value_contents (from);
705 bits_to_skip = 8 * value_offset (to);
706 if (value_bitsize (to))
707 {
708 bits_to_skip += value_bitpos (to);
709 type_len = value_bitsize (to);
710 }
711 else
712 type_len = 8 * TYPE_LENGTH (value_type (to));
713
714 for (i = 0; i < c->n_pieces && offset < type_len; i++)
715 {
716 struct dwarf_expr_piece *p = &c->pieces[i];
717 size_t this_size_bits, this_size;
718 long dest_offset_bits, source_offset_bits, dest_offset, source_offset;
719 int need_bitwise;
720 const gdb_byte *source_buffer;
721
722 this_size_bits = p->size;
723 if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
724 {
725 bits_to_skip -= this_size_bits;
726 continue;
727 }
728 if (this_size_bits > type_len - offset)
729 this_size_bits = type_len - offset;
730 if (bits_to_skip > 0)
731 {
732 dest_offset_bits = bits_to_skip;
733 source_offset_bits = 0;
734 this_size_bits -= bits_to_skip;
735 bits_to_skip = 0;
736 }
737 else
738 {
739 dest_offset_bits = 0;
740 source_offset_bits = offset;
741 }
742
743 this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
744 source_offset = source_offset_bits / 8;
745 dest_offset = dest_offset_bits / 8;
746 if (dest_offset_bits % 8 == 0 && source_offset_bits % 8 == 0)
747 {
748 source_buffer = contents + source_offset;
749 need_bitwise = 0;
750 }
751 else
752 {
753 if (buffer_size < this_size)
754 {
755 buffer_size = this_size;
756 buffer = xrealloc (buffer, buffer_size);
757 }
758 source_buffer = buffer;
759 need_bitwise = 1;
760 }
761
762 switch (p->location)
763 {
764 case DWARF_VALUE_REGISTER:
765 {
766 struct gdbarch *arch = get_frame_arch (frame);
767 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.value);
768 int reg_offset = dest_offset;
769
770 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
771 && this_size <= register_size (arch, gdb_regnum))
772 /* Big-endian, and we want less than full size. */
773 reg_offset = register_size (arch, gdb_regnum) - this_size;
774
775 if (gdb_regnum != -1)
776 {
777 if (need_bitwise)
778 {
779 get_frame_register_bytes (frame, gdb_regnum, reg_offset,
780 this_size, buffer);
781 copy_bitwise (buffer, dest_offset_bits,
782 contents, source_offset_bits,
783 this_size_bits,
784 bits_big_endian);
785 }
786
787 put_frame_register_bytes (frame, gdb_regnum, reg_offset,
788 this_size, source_buffer);
789 }
790 else
791 {
792 error (_("Unable to write to DWARF register number %s"),
793 paddress (arch, p->v.value));
794 }
795 }
796 break;
797 case DWARF_VALUE_MEMORY:
798 if (need_bitwise)
799 {
800 /* Only the first and last bytes can possibly have any
801 bits reused. */
802 read_memory (p->v.mem.addr + dest_offset, buffer, 1);
803 read_memory (p->v.mem.addr + dest_offset + this_size - 1,
804 buffer + this_size - 1, 1);
805 copy_bitwise (buffer, dest_offset_bits,
806 contents, source_offset_bits,
807 this_size_bits,
808 bits_big_endian);
809 }
810
811 write_memory (p->v.mem.addr + dest_offset,
812 source_buffer, this_size);
813 break;
814 default:
815 set_value_optimized_out (to, 1);
816 break;
817 }
818 offset += this_size_bits;
819 }
820
821 do_cleanups (cleanup);
822 }
823
824 /* A helper function that checks bit validity in a pieced value.
825 CHECK_FOR indicates the kind of validity checking.
826 DWARF_VALUE_MEMORY means to check whether any bit is valid.
827 DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
828 optimized out.
829 DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
830 implicit pointer. */
831
832 static int
833 check_pieced_value_bits (const struct value *value, int bit_offset,
834 int bit_length,
835 enum dwarf_value_location check_for)
836 {
837 struct piece_closure *c
838 = (struct piece_closure *) value_computed_closure (value);
839 int i;
840 int validity = (check_for == DWARF_VALUE_MEMORY
841 || check_for == DWARF_VALUE_IMPLICIT_POINTER);
842
843 bit_offset += 8 * value_offset (value);
844 if (value_bitsize (value))
845 bit_offset += value_bitpos (value);
846
847 for (i = 0; i < c->n_pieces && bit_length > 0; i++)
848 {
849 struct dwarf_expr_piece *p = &c->pieces[i];
850 size_t this_size_bits = p->size;
851
852 if (bit_offset > 0)
853 {
854 if (bit_offset >= this_size_bits)
855 {
856 bit_offset -= this_size_bits;
857 continue;
858 }
859
860 bit_length -= this_size_bits - bit_offset;
861 bit_offset = 0;
862 }
863 else
864 bit_length -= this_size_bits;
865
866 if (check_for == DWARF_VALUE_IMPLICIT_POINTER)
867 {
868 if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
869 return 0;
870 }
871 else if (p->location == DWARF_VALUE_OPTIMIZED_OUT
872 || p->location == DWARF_VALUE_IMPLICIT_POINTER)
873 {
874 if (validity)
875 return 0;
876 }
877 else
878 {
879 if (!validity)
880 return 1;
881 }
882 }
883
884 return validity;
885 }
886
887 static int
888 check_pieced_value_validity (const struct value *value, int bit_offset,
889 int bit_length)
890 {
891 return check_pieced_value_bits (value, bit_offset, bit_length,
892 DWARF_VALUE_MEMORY);
893 }
894
895 static int
896 check_pieced_value_invalid (const struct value *value)
897 {
898 return check_pieced_value_bits (value, 0,
899 8 * TYPE_LENGTH (value_type (value)),
900 DWARF_VALUE_OPTIMIZED_OUT);
901 }
902
903 /* An implementation of an lval_funcs method to see whether a value is
904 a synthetic pointer. */
905
906 static int
907 check_pieced_synthetic_pointer (const struct value *value, int bit_offset,
908 int bit_length)
909 {
910 return check_pieced_value_bits (value, bit_offset, bit_length,
911 DWARF_VALUE_IMPLICIT_POINTER);
912 }
913
914 /* A wrapper function for get_frame_address_in_block. */
915
916 static CORE_ADDR
917 get_frame_address_in_block_wrapper (void *baton)
918 {
919 return get_frame_address_in_block (baton);
920 }
921
922 /* An implementation of an lval_funcs method to indirect through a
923 pointer. This handles the synthetic pointer case when needed. */
924
925 static struct value *
926 indirect_pieced_value (struct value *value)
927 {
928 struct piece_closure *c
929 = (struct piece_closure *) value_computed_closure (value);
930 struct type *type;
931 struct frame_info *frame;
932 struct dwarf2_locexpr_baton baton;
933 int i, bit_offset, bit_length;
934 struct dwarf_expr_piece *piece = NULL;
935 struct value *result;
936 LONGEST byte_offset;
937
938 type = value_type (value);
939 if (TYPE_CODE (type) != TYPE_CODE_PTR)
940 return NULL;
941
942 bit_length = 8 * TYPE_LENGTH (type);
943 bit_offset = 8 * value_offset (value);
944 if (value_bitsize (value))
945 bit_offset += value_bitpos (value);
946
947 for (i = 0; i < c->n_pieces && bit_length > 0; i++)
948 {
949 struct dwarf_expr_piece *p = &c->pieces[i];
950 size_t this_size_bits = p->size;
951
952 if (bit_offset > 0)
953 {
954 if (bit_offset >= this_size_bits)
955 {
956 bit_offset -= this_size_bits;
957 continue;
958 }
959
960 bit_length -= this_size_bits - bit_offset;
961 bit_offset = 0;
962 }
963 else
964 bit_length -= this_size_bits;
965
966 if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
967 return NULL;
968
969 if (bit_length != 0)
970 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
971
972 piece = p;
973 break;
974 }
975
976 frame = get_selected_frame (_("No frame selected."));
977 byte_offset = value_as_address (value);
978
979 baton = dwarf2_fetch_die_location_block (piece->v.ptr.die, c->per_cu,
980 get_frame_address_in_block_wrapper,
981 frame);
982
983 result = dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
984 baton.data, baton.size, baton.per_cu,
985 byte_offset);
986
987 return result;
988 }
989
990 static void *
991 copy_pieced_value_closure (const struct value *v)
992 {
993 struct piece_closure *c
994 = (struct piece_closure *) value_computed_closure (v);
995
996 ++c->refc;
997 return c;
998 }
999
1000 static void
1001 free_pieced_value_closure (struct value *v)
1002 {
1003 struct piece_closure *c
1004 = (struct piece_closure *) value_computed_closure (v);
1005
1006 --c->refc;
1007 if (c->refc == 0)
1008 {
1009 xfree (c->pieces);
1010 xfree (c);
1011 }
1012 }
1013
1014 /* Functions for accessing a variable described by DW_OP_piece. */
1015 static struct lval_funcs pieced_value_funcs = {
1016 read_pieced_value,
1017 write_pieced_value,
1018 check_pieced_value_validity,
1019 check_pieced_value_invalid,
1020 indirect_pieced_value,
1021 check_pieced_synthetic_pointer,
1022 copy_pieced_value_closure,
1023 free_pieced_value_closure
1024 };
1025
1026 /* Helper function which throws an error if a synthetic pointer is
1027 invalid. */
1028
1029 static void
1030 invalid_synthetic_pointer (void)
1031 {
1032 error (_("access outside bounds of object "
1033 "referenced via synthetic pointer"));
1034 }
1035
1036 /* Evaluate a location description, starting at DATA and with length
1037 SIZE, to find the current location of variable of TYPE in the
1038 context of FRAME. BYTE_OFFSET is applied after the contents are
1039 computed. */
1040
1041 static struct value *
1042 dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
1043 const gdb_byte *data, unsigned short size,
1044 struct dwarf2_per_cu_data *per_cu,
1045 LONGEST byte_offset)
1046 {
1047 struct value *retval;
1048 struct dwarf_expr_baton baton;
1049 struct dwarf_expr_context *ctx;
1050 struct cleanup *old_chain;
1051 struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
1052
1053 if (byte_offset < 0)
1054 invalid_synthetic_pointer ();
1055
1056 if (size == 0)
1057 {
1058 retval = allocate_value (type);
1059 VALUE_LVAL (retval) = not_lval;
1060 set_value_optimized_out (retval, 1);
1061 return retval;
1062 }
1063
1064 baton.frame = frame;
1065 baton.per_cu = per_cu;
1066
1067 ctx = new_dwarf_expr_context ();
1068 old_chain = make_cleanup_free_dwarf_expr_context (ctx);
1069
1070 ctx->gdbarch = get_objfile_arch (objfile);
1071 ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
1072 ctx->offset = dwarf2_per_cu_text_offset (per_cu);
1073 ctx->baton = &baton;
1074 ctx->read_reg = dwarf_expr_read_reg;
1075 ctx->read_mem = dwarf_expr_read_mem;
1076 ctx->get_frame_base = dwarf_expr_frame_base;
1077 ctx->get_frame_cfa = dwarf_expr_frame_cfa;
1078 ctx->get_frame_pc = dwarf_expr_frame_pc;
1079 ctx->get_tls_address = dwarf_expr_tls_address;
1080 ctx->dwarf_call = dwarf_expr_dwarf_call;
1081
1082 dwarf_expr_eval (ctx, data, size);
1083 if (ctx->num_pieces > 0)
1084 {
1085 struct piece_closure *c;
1086 struct frame_id frame_id = get_frame_id (frame);
1087 ULONGEST bit_size = 0;
1088 int i;
1089
1090 for (i = 0; i < ctx->num_pieces; ++i)
1091 bit_size += ctx->pieces[i].size;
1092 if (8 * (byte_offset + TYPE_LENGTH (type)) > bit_size)
1093 invalid_synthetic_pointer ();
1094
1095 c = allocate_piece_closure (per_cu, ctx->num_pieces, ctx->pieces,
1096 ctx->addr_size);
1097 retval = allocate_computed_value (type, &pieced_value_funcs, c);
1098 VALUE_FRAME_ID (retval) = frame_id;
1099 set_value_offset (retval, byte_offset);
1100 }
1101 else
1102 {
1103 switch (ctx->location)
1104 {
1105 case DWARF_VALUE_REGISTER:
1106 {
1107 struct gdbarch *arch = get_frame_arch (frame);
1108 ULONGEST dwarf_regnum = dwarf_expr_fetch (ctx, 0);
1109 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
1110
1111 if (byte_offset != 0)
1112 error (_("cannot use offset on synthetic pointer to register"));
1113 if (gdb_regnum != -1)
1114 retval = value_from_register (type, gdb_regnum, frame);
1115 else
1116 error (_("Unable to access DWARF register number %s"),
1117 paddress (arch, dwarf_regnum));
1118 }
1119 break;
1120
1121 case DWARF_VALUE_MEMORY:
1122 {
1123 CORE_ADDR address = dwarf_expr_fetch_address (ctx, 0);
1124 int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
1125
1126 retval = allocate_value_lazy (type);
1127 VALUE_LVAL (retval) = lval_memory;
1128 if (in_stack_memory)
1129 set_value_stack (retval, 1);
1130 set_value_address (retval, address + byte_offset);
1131 }
1132 break;
1133
1134 case DWARF_VALUE_STACK:
1135 {
1136 ULONGEST value = dwarf_expr_fetch (ctx, 0);
1137 bfd_byte *contents, *tem;
1138 size_t n = ctx->addr_size;
1139
1140 if (byte_offset + TYPE_LENGTH (type) > n)
1141 invalid_synthetic_pointer ();
1142
1143 tem = alloca (n);
1144 store_unsigned_integer (tem, n,
1145 gdbarch_byte_order (ctx->gdbarch),
1146 value);
1147
1148 tem += byte_offset;
1149 n -= byte_offset;
1150
1151 retval = allocate_value (type);
1152 contents = value_contents_raw (retval);
1153 if (n > TYPE_LENGTH (type))
1154 n = TYPE_LENGTH (type);
1155 memcpy (contents, tem, n);
1156 }
1157 break;
1158
1159 case DWARF_VALUE_LITERAL:
1160 {
1161 bfd_byte *contents;
1162 const bfd_byte *ldata;
1163 size_t n = ctx->len;
1164
1165 if (byte_offset + TYPE_LENGTH (type) > n)
1166 invalid_synthetic_pointer ();
1167
1168 retval = allocate_value (type);
1169 contents = value_contents_raw (retval);
1170
1171 ldata = ctx->data + byte_offset;
1172 n -= byte_offset;
1173
1174 if (n > TYPE_LENGTH (type))
1175 n = TYPE_LENGTH (type);
1176 memcpy (contents, ldata, n);
1177 }
1178 break;
1179
1180 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
1181 operation by execute_stack_op. */
1182 case DWARF_VALUE_IMPLICIT_POINTER:
1183 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
1184 it can only be encountered when making a piece. */
1185 case DWARF_VALUE_OPTIMIZED_OUT:
1186 default:
1187 internal_error (__FILE__, __LINE__, _("invalid location type"));
1188 }
1189 }
1190
1191 set_value_initialized (retval, ctx->initialized);
1192
1193 do_cleanups (old_chain);
1194
1195 return retval;
1196 }
1197
1198 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
1199 passes 0 as the byte_offset. */
1200
1201 struct value *
1202 dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
1203 const gdb_byte *data, unsigned short size,
1204 struct dwarf2_per_cu_data *per_cu)
1205 {
1206 return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu, 0);
1207 }
1208
1209 \f
1210 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
1211
1212 struct needs_frame_baton
1213 {
1214 int needs_frame;
1215 struct dwarf2_per_cu_data *per_cu;
1216 };
1217
1218 /* Reads from registers do require a frame. */
1219 static CORE_ADDR
1220 needs_frame_read_reg (void *baton, int regnum)
1221 {
1222 struct needs_frame_baton *nf_baton = baton;
1223
1224 nf_baton->needs_frame = 1;
1225 return 1;
1226 }
1227
1228 /* Reads from memory do not require a frame. */
1229 static void
1230 needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
1231 {
1232 memset (buf, 0, len);
1233 }
1234
1235 /* Frame-relative accesses do require a frame. */
1236 static void
1237 needs_frame_frame_base (void *baton, const gdb_byte **start, size_t * length)
1238 {
1239 static gdb_byte lit0 = DW_OP_lit0;
1240 struct needs_frame_baton *nf_baton = baton;
1241
1242 *start = &lit0;
1243 *length = 1;
1244
1245 nf_baton->needs_frame = 1;
1246 }
1247
1248 /* CFA accesses require a frame. */
1249
1250 static CORE_ADDR
1251 needs_frame_frame_cfa (void *baton)
1252 {
1253 struct needs_frame_baton *nf_baton = baton;
1254
1255 nf_baton->needs_frame = 1;
1256 return 1;
1257 }
1258
1259 /* Thread-local accesses do require a frame. */
1260 static CORE_ADDR
1261 needs_frame_tls_address (void *baton, CORE_ADDR offset)
1262 {
1263 struct needs_frame_baton *nf_baton = baton;
1264
1265 nf_baton->needs_frame = 1;
1266 return 1;
1267 }
1268
1269 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
1270
1271 static void
1272 needs_frame_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset)
1273 {
1274 struct needs_frame_baton *nf_baton = ctx->baton;
1275
1276 return per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu,
1277 ctx->get_frame_pc, ctx->baton);
1278 }
1279
1280 /* Return non-zero iff the location expression at DATA (length SIZE)
1281 requires a frame to evaluate. */
1282
1283 static int
1284 dwarf2_loc_desc_needs_frame (const gdb_byte *data, unsigned short size,
1285 struct dwarf2_per_cu_data *per_cu)
1286 {
1287 struct needs_frame_baton baton;
1288 struct dwarf_expr_context *ctx;
1289 int in_reg;
1290 struct cleanup *old_chain;
1291 struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
1292
1293 baton.needs_frame = 0;
1294 baton.per_cu = per_cu;
1295
1296 ctx = new_dwarf_expr_context ();
1297 old_chain = make_cleanup_free_dwarf_expr_context (ctx);
1298
1299 ctx->gdbarch = get_objfile_arch (objfile);
1300 ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
1301 ctx->offset = dwarf2_per_cu_text_offset (per_cu);
1302 ctx->baton = &baton;
1303 ctx->read_reg = needs_frame_read_reg;
1304 ctx->read_mem = needs_frame_read_mem;
1305 ctx->get_frame_base = needs_frame_frame_base;
1306 ctx->get_frame_cfa = needs_frame_frame_cfa;
1307 ctx->get_frame_pc = needs_frame_frame_cfa;
1308 ctx->get_tls_address = needs_frame_tls_address;
1309 ctx->dwarf_call = needs_frame_dwarf_call;
1310
1311 dwarf_expr_eval (ctx, data, size);
1312
1313 in_reg = ctx->location == DWARF_VALUE_REGISTER;
1314
1315 if (ctx->num_pieces > 0)
1316 {
1317 int i;
1318
1319 /* If the location has several pieces, and any of them are in
1320 registers, then we will need a frame to fetch them from. */
1321 for (i = 0; i < ctx->num_pieces; i++)
1322 if (ctx->pieces[i].location == DWARF_VALUE_REGISTER)
1323 in_reg = 1;
1324 }
1325
1326 do_cleanups (old_chain);
1327
1328 return baton.needs_frame || in_reg;
1329 }
1330
1331 /* A helper function that throws an unimplemented error mentioning a
1332 given DWARF operator. */
1333
1334 static void
1335 unimplemented (unsigned int op)
1336 {
1337 const char *name = dwarf_stack_op_name (op);
1338
1339 if (name)
1340 error (_("DWARF operator %s cannot be translated to an agent expression"),
1341 name);
1342 else
1343 error (_("Unknown DWARF operator 0x%02x cannot be translated "
1344 "to an agent expression"),
1345 op);
1346 }
1347
1348 /* A helper function to convert a DWARF register to an arch register.
1349 ARCH is the architecture.
1350 DWARF_REG is the register.
1351 This will throw an exception if the DWARF register cannot be
1352 translated to an architecture register. */
1353
1354 static int
1355 translate_register (struct gdbarch *arch, int dwarf_reg)
1356 {
1357 int reg = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_reg);
1358 if (reg == -1)
1359 error (_("Unable to access DWARF register number %d"), dwarf_reg);
1360 return reg;
1361 }
1362
1363 /* A helper function that emits an access to memory. ARCH is the
1364 target architecture. EXPR is the expression which we are building.
1365 NBITS is the number of bits we want to read. This emits the
1366 opcodes needed to read the memory and then extract the desired
1367 bits. */
1368
1369 static void
1370 access_memory (struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits)
1371 {
1372 ULONGEST nbytes = (nbits + 7) / 8;
1373
1374 gdb_assert (nbits > 0 && nbits <= sizeof (LONGEST));
1375
1376 if (trace_kludge)
1377 ax_trace_quick (expr, nbytes);
1378
1379 if (nbits <= 8)
1380 ax_simple (expr, aop_ref8);
1381 else if (nbits <= 16)
1382 ax_simple (expr, aop_ref16);
1383 else if (nbits <= 32)
1384 ax_simple (expr, aop_ref32);
1385 else
1386 ax_simple (expr, aop_ref64);
1387
1388 /* If we read exactly the number of bytes we wanted, we're done. */
1389 if (8 * nbytes == nbits)
1390 return;
1391
1392 if (gdbarch_bits_big_endian (arch))
1393 {
1394 /* On a bits-big-endian machine, we want the high-order
1395 NBITS. */
1396 ax_const_l (expr, 8 * nbytes - nbits);
1397 ax_simple (expr, aop_rsh_unsigned);
1398 }
1399 else
1400 {
1401 /* On a bits-little-endian box, we want the low-order NBITS. */
1402 ax_zero_ext (expr, nbits);
1403 }
1404 }
1405
1406 /* A helper function to return the frame's PC. */
1407
1408 static CORE_ADDR
1409 get_ax_pc (void *baton)
1410 {
1411 struct agent_expr *expr = baton;
1412
1413 return expr->scope;
1414 }
1415
1416 /* Compile a DWARF location expression to an agent expression.
1417
1418 EXPR is the agent expression we are building.
1419 LOC is the agent value we modify.
1420 ARCH is the architecture.
1421 ADDR_SIZE is the size of addresses, in bytes.
1422 OP_PTR is the start of the location expression.
1423 OP_END is one past the last byte of the location expression.
1424
1425 This will throw an exception for various kinds of errors -- for
1426 example, if the expression cannot be compiled, or if the expression
1427 is invalid. */
1428
1429 void
1430 dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
1431 struct gdbarch *arch, unsigned int addr_size,
1432 const gdb_byte *op_ptr, const gdb_byte *op_end,
1433 struct dwarf2_per_cu_data *per_cu)
1434 {
1435 struct cleanup *cleanups;
1436 int i, *offsets;
1437 VEC(int) *dw_labels = NULL, *patches = NULL;
1438 const gdb_byte * const base = op_ptr;
1439 const gdb_byte *previous_piece = op_ptr;
1440 enum bfd_endian byte_order = gdbarch_byte_order (arch);
1441 ULONGEST bits_collected = 0;
1442 unsigned int addr_size_bits = 8 * addr_size;
1443 int bits_big_endian = gdbarch_bits_big_endian (arch);
1444
1445 offsets = xmalloc ((op_end - op_ptr) * sizeof (int));
1446 cleanups = make_cleanup (xfree, offsets);
1447
1448 for (i = 0; i < op_end - op_ptr; ++i)
1449 offsets[i] = -1;
1450
1451 make_cleanup (VEC_cleanup (int), &dw_labels);
1452 make_cleanup (VEC_cleanup (int), &patches);
1453
1454 /* By default we are making an address. */
1455 loc->kind = axs_lvalue_memory;
1456
1457 while (op_ptr < op_end)
1458 {
1459 enum dwarf_location_atom op = *op_ptr;
1460 ULONGEST uoffset, reg;
1461 LONGEST offset;
1462 int i;
1463
1464 offsets[op_ptr - base] = expr->len;
1465 ++op_ptr;
1466
1467 /* Our basic approach to code generation is to map DWARF
1468 operations directly to AX operations. However, there are
1469 some differences.
1470
1471 First, DWARF works on address-sized units, but AX always uses
1472 LONGEST. For most operations we simply ignore this
1473 difference; instead we generate sign extensions as needed
1474 before division and comparison operations. It would be nice
1475 to omit the sign extensions, but there is no way to determine
1476 the size of the target's LONGEST. (This code uses the size
1477 of the host LONGEST in some cases -- that is a bug but it is
1478 difficult to fix.)
1479
1480 Second, some DWARF operations cannot be translated to AX.
1481 For these we simply fail. See
1482 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
1483 switch (op)
1484 {
1485 case DW_OP_lit0:
1486 case DW_OP_lit1:
1487 case DW_OP_lit2:
1488 case DW_OP_lit3:
1489 case DW_OP_lit4:
1490 case DW_OP_lit5:
1491 case DW_OP_lit6:
1492 case DW_OP_lit7:
1493 case DW_OP_lit8:
1494 case DW_OP_lit9:
1495 case DW_OP_lit10:
1496 case DW_OP_lit11:
1497 case DW_OP_lit12:
1498 case DW_OP_lit13:
1499 case DW_OP_lit14:
1500 case DW_OP_lit15:
1501 case DW_OP_lit16:
1502 case DW_OP_lit17:
1503 case DW_OP_lit18:
1504 case DW_OP_lit19:
1505 case DW_OP_lit20:
1506 case DW_OP_lit21:
1507 case DW_OP_lit22:
1508 case DW_OP_lit23:
1509 case DW_OP_lit24:
1510 case DW_OP_lit25:
1511 case DW_OP_lit26:
1512 case DW_OP_lit27:
1513 case DW_OP_lit28:
1514 case DW_OP_lit29:
1515 case DW_OP_lit30:
1516 case DW_OP_lit31:
1517 ax_const_l (expr, op - DW_OP_lit0);
1518 break;
1519
1520 case DW_OP_addr:
1521 uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order);
1522 op_ptr += addr_size;
1523 /* Some versions of GCC emit DW_OP_addr before
1524 DW_OP_GNU_push_tls_address. In this case the value is an
1525 index, not an address. We don't support things like
1526 branching between the address and the TLS op. */
1527 if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
1528 uoffset += dwarf2_per_cu_text_offset (per_cu);
1529 ax_const_l (expr, uoffset);
1530 break;
1531
1532 case DW_OP_const1u:
1533 ax_const_l (expr, extract_unsigned_integer (op_ptr, 1, byte_order));
1534 op_ptr += 1;
1535 break;
1536 case DW_OP_const1s:
1537 ax_const_l (expr, extract_signed_integer (op_ptr, 1, byte_order));
1538 op_ptr += 1;
1539 break;
1540 case DW_OP_const2u:
1541 ax_const_l (expr, extract_unsigned_integer (op_ptr, 2, byte_order));
1542 op_ptr += 2;
1543 break;
1544 case DW_OP_const2s:
1545 ax_const_l (expr, extract_signed_integer (op_ptr, 2, byte_order));
1546 op_ptr += 2;
1547 break;
1548 case DW_OP_const4u:
1549 ax_const_l (expr, extract_unsigned_integer (op_ptr, 4, byte_order));
1550 op_ptr += 4;
1551 break;
1552 case DW_OP_const4s:
1553 ax_const_l (expr, extract_signed_integer (op_ptr, 4, byte_order));
1554 op_ptr += 4;
1555 break;
1556 case DW_OP_const8u:
1557 ax_const_l (expr, extract_unsigned_integer (op_ptr, 8, byte_order));
1558 op_ptr += 8;
1559 break;
1560 case DW_OP_const8s:
1561 ax_const_l (expr, extract_signed_integer (op_ptr, 8, byte_order));
1562 op_ptr += 8;
1563 break;
1564 case DW_OP_constu:
1565 op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
1566 ax_const_l (expr, uoffset);
1567 break;
1568 case DW_OP_consts:
1569 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
1570 ax_const_l (expr, offset);
1571 break;
1572
1573 case DW_OP_reg0:
1574 case DW_OP_reg1:
1575 case DW_OP_reg2:
1576 case DW_OP_reg3:
1577 case DW_OP_reg4:
1578 case DW_OP_reg5:
1579 case DW_OP_reg6:
1580 case DW_OP_reg7:
1581 case DW_OP_reg8:
1582 case DW_OP_reg9:
1583 case DW_OP_reg10:
1584 case DW_OP_reg11:
1585 case DW_OP_reg12:
1586 case DW_OP_reg13:
1587 case DW_OP_reg14:
1588 case DW_OP_reg15:
1589 case DW_OP_reg16:
1590 case DW_OP_reg17:
1591 case DW_OP_reg18:
1592 case DW_OP_reg19:
1593 case DW_OP_reg20:
1594 case DW_OP_reg21:
1595 case DW_OP_reg22:
1596 case DW_OP_reg23:
1597 case DW_OP_reg24:
1598 case DW_OP_reg25:
1599 case DW_OP_reg26:
1600 case DW_OP_reg27:
1601 case DW_OP_reg28:
1602 case DW_OP_reg29:
1603 case DW_OP_reg30:
1604 case DW_OP_reg31:
1605 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
1606 loc->u.reg = translate_register (arch, op - DW_OP_reg0);
1607 loc->kind = axs_lvalue_register;
1608 break;
1609
1610 case DW_OP_regx:
1611 op_ptr = read_uleb128 (op_ptr, op_end, &reg);
1612 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
1613 loc->u.reg = translate_register (arch, reg);
1614 loc->kind = axs_lvalue_register;
1615 break;
1616
1617 case DW_OP_implicit_value:
1618 {
1619 ULONGEST len;
1620
1621 op_ptr = read_uleb128 (op_ptr, op_end, &len);
1622 if (op_ptr + len > op_end)
1623 error (_("DW_OP_implicit_value: too few bytes available."));
1624 if (len > sizeof (ULONGEST))
1625 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
1626 (int) len);
1627
1628 ax_const_l (expr, extract_unsigned_integer (op_ptr, len,
1629 byte_order));
1630 op_ptr += len;
1631 dwarf_expr_require_composition (op_ptr, op_end,
1632 "DW_OP_implicit_value");
1633
1634 loc->kind = axs_rvalue;
1635 }
1636 break;
1637
1638 case DW_OP_stack_value:
1639 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
1640 loc->kind = axs_rvalue;
1641 break;
1642
1643 case DW_OP_breg0:
1644 case DW_OP_breg1:
1645 case DW_OP_breg2:
1646 case DW_OP_breg3:
1647 case DW_OP_breg4:
1648 case DW_OP_breg5:
1649 case DW_OP_breg6:
1650 case DW_OP_breg7:
1651 case DW_OP_breg8:
1652 case DW_OP_breg9:
1653 case DW_OP_breg10:
1654 case DW_OP_breg11:
1655 case DW_OP_breg12:
1656 case DW_OP_breg13:
1657 case DW_OP_breg14:
1658 case DW_OP_breg15:
1659 case DW_OP_breg16:
1660 case DW_OP_breg17:
1661 case DW_OP_breg18:
1662 case DW_OP_breg19:
1663 case DW_OP_breg20:
1664 case DW_OP_breg21:
1665 case DW_OP_breg22:
1666 case DW_OP_breg23:
1667 case DW_OP_breg24:
1668 case DW_OP_breg25:
1669 case DW_OP_breg26:
1670 case DW_OP_breg27:
1671 case DW_OP_breg28:
1672 case DW_OP_breg29:
1673 case DW_OP_breg30:
1674 case DW_OP_breg31:
1675 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
1676 i = translate_register (arch, op - DW_OP_breg0);
1677 ax_reg (expr, i);
1678 if (offset != 0)
1679 {
1680 ax_const_l (expr, offset);
1681 ax_simple (expr, aop_add);
1682 }
1683 break;
1684 case DW_OP_bregx:
1685 {
1686 op_ptr = read_uleb128 (op_ptr, op_end, &reg);
1687 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
1688 i = translate_register (arch, reg);
1689 ax_reg (expr, i);
1690 if (offset != 0)
1691 {
1692 ax_const_l (expr, offset);
1693 ax_simple (expr, aop_add);
1694 }
1695 }
1696 break;
1697 case DW_OP_fbreg:
1698 {
1699 const gdb_byte *datastart;
1700 size_t datalen;
1701 unsigned int before_stack_len;
1702 struct block *b;
1703 struct symbol *framefunc;
1704 LONGEST base_offset = 0;
1705
1706 b = block_for_pc (expr->scope);
1707
1708 if (!b)
1709 error (_("No block found for address"));
1710
1711 framefunc = block_linkage_function (b);
1712
1713 if (!framefunc)
1714 error (_("No function found for block"));
1715
1716 dwarf_expr_frame_base_1 (framefunc, expr->scope,
1717 &datastart, &datalen);
1718
1719 op_ptr = read_sleb128 (op_ptr, op_end, &offset);
1720 dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart,
1721 datastart + datalen, per_cu);
1722
1723 if (offset != 0)
1724 {
1725 ax_const_l (expr, offset);
1726 ax_simple (expr, aop_add);
1727 }
1728
1729 loc->kind = axs_lvalue_memory;
1730 }
1731 break;
1732
1733 case DW_OP_dup:
1734 ax_simple (expr, aop_dup);
1735 break;
1736
1737 case DW_OP_drop:
1738 ax_simple (expr, aop_pop);
1739 break;
1740
1741 case DW_OP_pick:
1742 offset = *op_ptr++;
1743 ax_pick (expr, offset);
1744 break;
1745
1746 case DW_OP_swap:
1747 ax_simple (expr, aop_swap);
1748 break;
1749
1750 case DW_OP_over:
1751 ax_pick (expr, 1);
1752 break;
1753
1754 case DW_OP_rot:
1755 ax_simple (expr, aop_rot);
1756 break;
1757
1758 case DW_OP_deref:
1759 case DW_OP_deref_size:
1760 {
1761 int size;
1762
1763 if (op == DW_OP_deref_size)
1764 size = *op_ptr++;
1765 else
1766 size = addr_size;
1767
1768 switch (size)
1769 {
1770 case 8:
1771 ax_simple (expr, aop_ref8);
1772 break;
1773 case 16:
1774 ax_simple (expr, aop_ref16);
1775 break;
1776 case 32:
1777 ax_simple (expr, aop_ref32);
1778 break;
1779 case 64:
1780 ax_simple (expr, aop_ref64);
1781 break;
1782 default:
1783 /* Note that dwarf_stack_op_name will never return
1784 NULL here. */
1785 error (_("Unsupported size %d in %s"),
1786 size, dwarf_stack_op_name (op));
1787 }
1788 }
1789 break;
1790
1791 case DW_OP_abs:
1792 /* Sign extend the operand. */
1793 ax_ext (expr, addr_size_bits);
1794 ax_simple (expr, aop_dup);
1795 ax_const_l (expr, 0);
1796 ax_simple (expr, aop_less_signed);
1797 ax_simple (expr, aop_log_not);
1798 i = ax_goto (expr, aop_if_goto);
1799 /* We have to emit 0 - X. */
1800 ax_const_l (expr, 0);
1801 ax_simple (expr, aop_swap);
1802 ax_simple (expr, aop_sub);
1803 ax_label (expr, i, expr->len);
1804 break;
1805
1806 case DW_OP_neg:
1807 /* No need to sign extend here. */
1808 ax_const_l (expr, 0);
1809 ax_simple (expr, aop_swap);
1810 ax_simple (expr, aop_sub);
1811 break;
1812
1813 case DW_OP_not:
1814 /* Sign extend the operand. */
1815 ax_ext (expr, addr_size_bits);
1816 ax_simple (expr, aop_bit_not);
1817 break;
1818
1819 case DW_OP_plus_uconst:
1820 op_ptr = read_uleb128 (op_ptr, op_end, &reg);
1821 /* It would be really weird to emit `DW_OP_plus_uconst 0',
1822 but we micro-optimize anyhow. */
1823 if (reg != 0)
1824 {
1825 ax_const_l (expr, reg);
1826 ax_simple (expr, aop_add);
1827 }
1828 break;
1829
1830 case DW_OP_and:
1831 ax_simple (expr, aop_bit_and);
1832 break;
1833
1834 case DW_OP_div:
1835 /* Sign extend the operands. */
1836 ax_ext (expr, addr_size_bits);
1837 ax_simple (expr, aop_swap);
1838 ax_ext (expr, addr_size_bits);
1839 ax_simple (expr, aop_swap);
1840 ax_simple (expr, aop_div_signed);
1841 break;
1842
1843 case DW_OP_minus:
1844 ax_simple (expr, aop_sub);
1845 break;
1846
1847 case DW_OP_mod:
1848 ax_simple (expr, aop_rem_unsigned);
1849 break;
1850
1851 case DW_OP_mul:
1852 ax_simple (expr, aop_mul);
1853 break;
1854
1855 case DW_OP_or:
1856 ax_simple (expr, aop_bit_or);
1857 break;
1858
1859 case DW_OP_plus:
1860 ax_simple (expr, aop_add);
1861 break;
1862
1863 case DW_OP_shl:
1864 ax_simple (expr, aop_lsh);
1865 break;
1866
1867 case DW_OP_shr:
1868 ax_simple (expr, aop_rsh_unsigned);
1869 break;
1870
1871 case DW_OP_shra:
1872 ax_simple (expr, aop_rsh_signed);
1873 break;
1874
1875 case DW_OP_xor:
1876 ax_simple (expr, aop_bit_xor);
1877 break;
1878
1879 case DW_OP_le:
1880 /* Sign extend the operands. */
1881 ax_ext (expr, addr_size_bits);
1882 ax_simple (expr, aop_swap);
1883 ax_ext (expr, addr_size_bits);
1884 /* Note no swap here: A <= B is !(B < A). */
1885 ax_simple (expr, aop_less_signed);
1886 ax_simple (expr, aop_log_not);
1887 break;
1888
1889 case DW_OP_ge:
1890 /* Sign extend the operands. */
1891 ax_ext (expr, addr_size_bits);
1892 ax_simple (expr, aop_swap);
1893 ax_ext (expr, addr_size_bits);
1894 ax_simple (expr, aop_swap);
1895 /* A >= B is !(A < B). */
1896 ax_simple (expr, aop_less_signed);
1897 ax_simple (expr, aop_log_not);
1898 break;
1899
1900 case DW_OP_eq:
1901 /* Sign extend the operands. */
1902 ax_ext (expr, addr_size_bits);
1903 ax_simple (expr, aop_swap);
1904 ax_ext (expr, addr_size_bits);
1905 /* No need for a second swap here. */
1906 ax_simple (expr, aop_equal);
1907 break;
1908
1909 case DW_OP_lt:
1910 /* Sign extend the operands. */
1911 ax_ext (expr, addr_size_bits);
1912 ax_simple (expr, aop_swap);
1913 ax_ext (expr, addr_size_bits);
1914 ax_simple (expr, aop_swap);
1915 ax_simple (expr, aop_less_signed);
1916 break;
1917
1918 case DW_OP_gt:
1919 /* Sign extend the operands. */
1920 ax_ext (expr, addr_size_bits);
1921 ax_simple (expr, aop_swap);
1922 ax_ext (expr, addr_size_bits);
1923 /* Note no swap here: A > B is B < A. */
1924 ax_simple (expr, aop_less_signed);
1925 break;
1926
1927 case DW_OP_ne:
1928 /* Sign extend the operands. */
1929 ax_ext (expr, addr_size_bits);
1930 ax_simple (expr, aop_swap);
1931 ax_ext (expr, addr_size_bits);
1932 /* No need for a swap here. */
1933 ax_simple (expr, aop_equal);
1934 ax_simple (expr, aop_log_not);
1935 break;
1936
1937 case DW_OP_call_frame_cfa:
1938 dwarf2_compile_cfa_to_ax (expr, loc, arch, expr->scope, per_cu);
1939 loc->kind = axs_lvalue_memory;
1940 break;
1941
1942 case DW_OP_GNU_push_tls_address:
1943 unimplemented (op);
1944 break;
1945
1946 case DW_OP_skip:
1947 offset = extract_signed_integer (op_ptr, 2, byte_order);
1948 op_ptr += 2;
1949 i = ax_goto (expr, aop_goto);
1950 VEC_safe_push (int, dw_labels, op_ptr + offset - base);
1951 VEC_safe_push (int, patches, i);
1952 break;
1953
1954 case DW_OP_bra:
1955 offset = extract_signed_integer (op_ptr, 2, byte_order);
1956 op_ptr += 2;
1957 /* Zero extend the operand. */
1958 ax_zero_ext (expr, addr_size_bits);
1959 i = ax_goto (expr, aop_if_goto);
1960 VEC_safe_push (int, dw_labels, op_ptr + offset - base);
1961 VEC_safe_push (int, patches, i);
1962 break;
1963
1964 case DW_OP_nop:
1965 break;
1966
1967 case DW_OP_piece:
1968 case DW_OP_bit_piece:
1969 {
1970 ULONGEST size, offset;
1971
1972 if (op_ptr - 1 == previous_piece)
1973 error (_("Cannot translate empty pieces to agent expressions"));
1974 previous_piece = op_ptr - 1;
1975
1976 op_ptr = read_uleb128 (op_ptr, op_end, &size);
1977 if (op == DW_OP_piece)
1978 {
1979 size *= 8;
1980 offset = 0;
1981 }
1982 else
1983 op_ptr = read_uleb128 (op_ptr, op_end, &offset);
1984
1985 if (bits_collected + size > 8 * sizeof (LONGEST))
1986 error (_("Expression pieces exceed word size"));
1987
1988 /* Access the bits. */
1989 switch (loc->kind)
1990 {
1991 case axs_lvalue_register:
1992 ax_reg (expr, loc->u.reg);
1993 break;
1994
1995 case axs_lvalue_memory:
1996 /* Offset the pointer, if needed. */
1997 if (offset > 8)
1998 {
1999 ax_const_l (expr, offset / 8);
2000 ax_simple (expr, aop_add);
2001 offset %= 8;
2002 }
2003 access_memory (arch, expr, size);
2004 break;
2005 }
2006
2007 /* For a bits-big-endian target, shift up what we already
2008 have. For a bits-little-endian target, shift up the
2009 new data. Note that there is a potential bug here if
2010 the DWARF expression leaves multiple values on the
2011 stack. */
2012 if (bits_collected > 0)
2013 {
2014 if (bits_big_endian)
2015 {
2016 ax_simple (expr, aop_swap);
2017 ax_const_l (expr, size);
2018 ax_simple (expr, aop_lsh);
2019 /* We don't need a second swap here, because
2020 aop_bit_or is symmetric. */
2021 }
2022 else
2023 {
2024 ax_const_l (expr, size);
2025 ax_simple (expr, aop_lsh);
2026 }
2027 ax_simple (expr, aop_bit_or);
2028 }
2029
2030 bits_collected += size;
2031 loc->kind = axs_rvalue;
2032 }
2033 break;
2034
2035 case DW_OP_GNU_uninit:
2036 unimplemented (op);
2037
2038 case DW_OP_call2:
2039 case DW_OP_call4:
2040 {
2041 struct dwarf2_locexpr_baton block;
2042 int size = (op == DW_OP_call2 ? 2 : 4);
2043
2044 uoffset = extract_unsigned_integer (op_ptr, size, byte_order);
2045 op_ptr += size;
2046
2047 block = dwarf2_fetch_die_location_block (uoffset, per_cu,
2048 get_ax_pc, expr);
2049
2050 /* DW_OP_call_ref is currently not supported. */
2051 gdb_assert (block.per_cu == per_cu);
2052
2053 dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
2054 block.data, block.data + block.size,
2055 per_cu);
2056 }
2057 break;
2058
2059 case DW_OP_call_ref:
2060 unimplemented (op);
2061
2062 default:
2063 unimplemented (op);
2064 }
2065 }
2066
2067 /* Patch all the branches we emitted. */
2068 for (i = 0; i < VEC_length (int, patches); ++i)
2069 {
2070 int targ = offsets[VEC_index (int, dw_labels, i)];
2071 if (targ == -1)
2072 internal_error (__FILE__, __LINE__, _("invalid label"));
2073 ax_label (expr, VEC_index (int, patches, i), targ);
2074 }
2075
2076 do_cleanups (cleanups);
2077 }
2078
2079 \f
2080 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
2081 evaluator to calculate the location. */
2082 static struct value *
2083 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
2084 {
2085 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2086 struct value *val;
2087
2088 val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, dlbaton->data,
2089 dlbaton->size, dlbaton->per_cu);
2090
2091 return val;
2092 }
2093
2094 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
2095 static int
2096 locexpr_read_needs_frame (struct symbol *symbol)
2097 {
2098 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2099
2100 return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
2101 dlbaton->per_cu);
2102 }
2103
2104 /* Return true if DATA points to the end of a piece. END is one past
2105 the last byte in the expression. */
2106
2107 static int
2108 piece_end_p (const gdb_byte *data, const gdb_byte *end)
2109 {
2110 return data == end || data[0] == DW_OP_piece || data[0] == DW_OP_bit_piece;
2111 }
2112
2113 /* Nicely describe a single piece of a location, returning an updated
2114 position in the bytecode sequence. This function cannot recognize
2115 all locations; if a location is not recognized, it simply returns
2116 DATA. */
2117
2118 static const gdb_byte *
2119 locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
2120 CORE_ADDR addr, struct objfile *objfile,
2121 const gdb_byte *data, const gdb_byte *end,
2122 unsigned int addr_size)
2123 {
2124 struct gdbarch *gdbarch = get_objfile_arch (objfile);
2125 int regno;
2126
2127 if (data[0] >= DW_OP_reg0 && data[0] <= DW_OP_reg31)
2128 {
2129 regno = gdbarch_dwarf2_reg_to_regnum (gdbarch, data[0] - DW_OP_reg0);
2130 fprintf_filtered (stream, _("a variable in $%s"),
2131 gdbarch_register_name (gdbarch, regno));
2132 data += 1;
2133 }
2134 else if (data[0] == DW_OP_regx)
2135 {
2136 ULONGEST reg;
2137
2138 data = read_uleb128 (data + 1, end, &reg);
2139 regno = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg);
2140 fprintf_filtered (stream, _("a variable in $%s"),
2141 gdbarch_register_name (gdbarch, regno));
2142 }
2143 else if (data[0] == DW_OP_fbreg)
2144 {
2145 struct block *b;
2146 struct symbol *framefunc;
2147 int frame_reg = 0;
2148 LONGEST frame_offset;
2149 const gdb_byte *base_data, *new_data, *save_data = data;
2150 size_t base_size;
2151 LONGEST base_offset = 0;
2152
2153 new_data = read_sleb128 (data + 1, end, &frame_offset);
2154 if (!piece_end_p (new_data, end))
2155 return data;
2156 data = new_data;
2157
2158 b = block_for_pc (addr);
2159
2160 if (!b)
2161 error (_("No block found for address for symbol \"%s\"."),
2162 SYMBOL_PRINT_NAME (symbol));
2163
2164 framefunc = block_linkage_function (b);
2165
2166 if (!framefunc)
2167 error (_("No function found for block for symbol \"%s\"."),
2168 SYMBOL_PRINT_NAME (symbol));
2169
2170 dwarf_expr_frame_base_1 (framefunc, addr, &base_data, &base_size);
2171
2172 if (base_data[0] >= DW_OP_breg0 && base_data[0] <= DW_OP_breg31)
2173 {
2174 const gdb_byte *buf_end;
2175
2176 frame_reg = base_data[0] - DW_OP_breg0;
2177 buf_end = read_sleb128 (base_data + 1,
2178 base_data + base_size, &base_offset);
2179 if (buf_end != base_data + base_size)
2180 error (_("Unexpected opcode after "
2181 "DW_OP_breg%u for symbol \"%s\"."),
2182 frame_reg, SYMBOL_PRINT_NAME (symbol));
2183 }
2184 else if (base_data[0] >= DW_OP_reg0 && base_data[0] <= DW_OP_reg31)
2185 {
2186 /* The frame base is just the register, with no offset. */
2187 frame_reg = base_data[0] - DW_OP_reg0;
2188 base_offset = 0;
2189 }
2190 else
2191 {
2192 /* We don't know what to do with the frame base expression,
2193 so we can't trace this variable; give up. */
2194 return save_data;
2195 }
2196
2197 regno = gdbarch_dwarf2_reg_to_regnum (gdbarch, frame_reg);
2198
2199 fprintf_filtered (stream,
2200 _("a variable at frame base reg $%s offset %s+%s"),
2201 gdbarch_register_name (gdbarch, regno),
2202 plongest (base_offset), plongest (frame_offset));
2203 }
2204 else if (data[0] >= DW_OP_breg0 && data[0] <= DW_OP_breg31
2205 && piece_end_p (data, end))
2206 {
2207 LONGEST offset;
2208
2209 regno = gdbarch_dwarf2_reg_to_regnum (gdbarch, data[0] - DW_OP_breg0);
2210
2211 data = read_sleb128 (data + 1, end, &offset);
2212
2213 fprintf_filtered (stream,
2214 _("a variable at offset %s from base reg $%s"),
2215 plongest (offset),
2216 gdbarch_register_name (gdbarch, regno));
2217 }
2218
2219 /* The location expression for a TLS variable looks like this (on a
2220 64-bit LE machine):
2221
2222 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
2223 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
2224
2225 0x3 is the encoding for DW_OP_addr, which has an operand as long
2226 as the size of an address on the target machine (here is 8
2227 bytes). Note that more recent version of GCC emit DW_OP_const4u
2228 or DW_OP_const8u, depending on address size, rather than
2229 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
2230 The operand represents the offset at which the variable is within
2231 the thread local storage. */
2232
2233 else if (data + 1 + addr_size < end
2234 && (data[0] == DW_OP_addr
2235 || (addr_size == 4 && data[0] == DW_OP_const4u)
2236 || (addr_size == 8 && data[0] == DW_OP_const8u))
2237 && data[1 + addr_size] == DW_OP_GNU_push_tls_address
2238 && piece_end_p (data + 2 + addr_size, end))
2239 {
2240 ULONGEST offset;
2241 offset = extract_unsigned_integer (data + 1, addr_size,
2242 gdbarch_byte_order (gdbarch));
2243
2244 fprintf_filtered (stream,
2245 _("a thread-local variable at offset 0x%s "
2246 "in the thread-local storage for `%s'"),
2247 phex_nz (offset, addr_size), objfile->name);
2248
2249 data += 1 + addr_size + 1;
2250 }
2251 else if (data[0] >= DW_OP_lit0
2252 && data[0] <= DW_OP_lit31
2253 && data + 1 < end
2254 && data[1] == DW_OP_stack_value)
2255 {
2256 fprintf_filtered (stream, _("the constant %d"), data[0] - DW_OP_lit0);
2257 data += 2;
2258 }
2259
2260 return data;
2261 }
2262
2263 /* Disassemble an expression, stopping at the end of a piece or at the
2264 end of the expression. Returns a pointer to the next unread byte
2265 in the input expression. If ALL is nonzero, then this function
2266 will keep going until it reaches the end of the expression. */
2267
2268 static const gdb_byte *
2269 disassemble_dwarf_expression (struct ui_file *stream,
2270 struct gdbarch *arch, unsigned int addr_size,
2271 int offset_size,
2272 const gdb_byte *data, const gdb_byte *end,
2273 int all)
2274 {
2275 const gdb_byte *start = data;
2276
2277 fprintf_filtered (stream, _("a complex DWARF expression:\n"));
2278
2279 while (data < end
2280 && (all
2281 || (data[0] != DW_OP_piece && data[0] != DW_OP_bit_piece)))
2282 {
2283 enum dwarf_location_atom op = *data++;
2284 ULONGEST ul;
2285 LONGEST l;
2286 const char *name;
2287
2288 name = dwarf_stack_op_name (op);
2289
2290 if (!name)
2291 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
2292 op, (long) (data - start));
2293 fprintf_filtered (stream, " % 4ld: %s", (long) (data - start), name);
2294
2295 switch (op)
2296 {
2297 case DW_OP_addr:
2298 ul = extract_unsigned_integer (data, addr_size,
2299 gdbarch_byte_order (arch));
2300 data += addr_size;
2301 fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size));
2302 break;
2303
2304 case DW_OP_const1u:
2305 ul = extract_unsigned_integer (data, 1, gdbarch_byte_order (arch));
2306 data += 1;
2307 fprintf_filtered (stream, " %s", pulongest (ul));
2308 break;
2309 case DW_OP_const1s:
2310 l = extract_signed_integer (data, 1, gdbarch_byte_order (arch));
2311 data += 1;
2312 fprintf_filtered (stream, " %s", plongest (l));
2313 break;
2314 case DW_OP_const2u:
2315 ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
2316 data += 2;
2317 fprintf_filtered (stream, " %s", pulongest (ul));
2318 break;
2319 case DW_OP_const2s:
2320 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
2321 data += 2;
2322 fprintf_filtered (stream, " %s", plongest (l));
2323 break;
2324 case DW_OP_const4u:
2325 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
2326 data += 4;
2327 fprintf_filtered (stream, " %s", pulongest (ul));
2328 break;
2329 case DW_OP_const4s:
2330 l = extract_signed_integer (data, 4, gdbarch_byte_order (arch));
2331 data += 4;
2332 fprintf_filtered (stream, " %s", plongest (l));
2333 break;
2334 case DW_OP_const8u:
2335 ul = extract_unsigned_integer (data, 8, gdbarch_byte_order (arch));
2336 data += 8;
2337 fprintf_filtered (stream, " %s", pulongest (ul));
2338 break;
2339 case DW_OP_const8s:
2340 l = extract_signed_integer (data, 8, gdbarch_byte_order (arch));
2341 data += 8;
2342 fprintf_filtered (stream, " %s", plongest (l));
2343 break;
2344 case DW_OP_constu:
2345 data = read_uleb128 (data, end, &ul);
2346 fprintf_filtered (stream, " %s", pulongest (ul));
2347 break;
2348 case DW_OP_consts:
2349 data = read_sleb128 (data, end, &l);
2350 fprintf_filtered (stream, " %s", plongest (l));
2351 break;
2352
2353 case DW_OP_reg0:
2354 case DW_OP_reg1:
2355 case DW_OP_reg2:
2356 case DW_OP_reg3:
2357 case DW_OP_reg4:
2358 case DW_OP_reg5:
2359 case DW_OP_reg6:
2360 case DW_OP_reg7:
2361 case DW_OP_reg8:
2362 case DW_OP_reg9:
2363 case DW_OP_reg10:
2364 case DW_OP_reg11:
2365 case DW_OP_reg12:
2366 case DW_OP_reg13:
2367 case DW_OP_reg14:
2368 case DW_OP_reg15:
2369 case DW_OP_reg16:
2370 case DW_OP_reg17:
2371 case DW_OP_reg18:
2372 case DW_OP_reg19:
2373 case DW_OP_reg20:
2374 case DW_OP_reg21:
2375 case DW_OP_reg22:
2376 case DW_OP_reg23:
2377 case DW_OP_reg24:
2378 case DW_OP_reg25:
2379 case DW_OP_reg26:
2380 case DW_OP_reg27:
2381 case DW_OP_reg28:
2382 case DW_OP_reg29:
2383 case DW_OP_reg30:
2384 case DW_OP_reg31:
2385 fprintf_filtered (stream, " [$%s]",
2386 gdbarch_register_name (arch, op - DW_OP_reg0));
2387 break;
2388
2389 case DW_OP_regx:
2390 data = read_uleb128 (data, end, &ul);
2391 fprintf_filtered (stream, " %s [$%s]", pulongest (ul),
2392 gdbarch_register_name (arch, (int) ul));
2393 break;
2394
2395 case DW_OP_implicit_value:
2396 data = read_uleb128 (data, end, &ul);
2397 data += ul;
2398 fprintf_filtered (stream, " %s", pulongest (ul));
2399 break;
2400
2401 case DW_OP_breg0:
2402 case DW_OP_breg1:
2403 case DW_OP_breg2:
2404 case DW_OP_breg3:
2405 case DW_OP_breg4:
2406 case DW_OP_breg5:
2407 case DW_OP_breg6:
2408 case DW_OP_breg7:
2409 case DW_OP_breg8:
2410 case DW_OP_breg9:
2411 case DW_OP_breg10:
2412 case DW_OP_breg11:
2413 case DW_OP_breg12:
2414 case DW_OP_breg13:
2415 case DW_OP_breg14:
2416 case DW_OP_breg15:
2417 case DW_OP_breg16:
2418 case DW_OP_breg17:
2419 case DW_OP_breg18:
2420 case DW_OP_breg19:
2421 case DW_OP_breg20:
2422 case DW_OP_breg21:
2423 case DW_OP_breg22:
2424 case DW_OP_breg23:
2425 case DW_OP_breg24:
2426 case DW_OP_breg25:
2427 case DW_OP_breg26:
2428 case DW_OP_breg27:
2429 case DW_OP_breg28:
2430 case DW_OP_breg29:
2431 case DW_OP_breg30:
2432 case DW_OP_breg31:
2433 data = read_sleb128 (data, end, &l);
2434 fprintf_filtered (stream, " %s [$%s]", plongest (l),
2435 gdbarch_register_name (arch, op - DW_OP_breg0));
2436 break;
2437
2438 case DW_OP_bregx:
2439 data = read_uleb128 (data, end, &ul);
2440 data = read_sleb128 (data, end, &l);
2441 fprintf_filtered (stream, " register %s [$%s] offset %s",
2442 pulongest (ul),
2443 gdbarch_register_name (arch, (int) ul),
2444 plongest (l));
2445 break;
2446
2447 case DW_OP_fbreg:
2448 data = read_sleb128 (data, end, &l);
2449 fprintf_filtered (stream, " %s", plongest (l));
2450 break;
2451
2452 case DW_OP_xderef_size:
2453 case DW_OP_deref_size:
2454 case DW_OP_pick:
2455 fprintf_filtered (stream, " %d", *data);
2456 ++data;
2457 break;
2458
2459 case DW_OP_plus_uconst:
2460 data = read_uleb128 (data, end, &ul);
2461 fprintf_filtered (stream, " %s", pulongest (ul));
2462 break;
2463
2464 case DW_OP_skip:
2465 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
2466 data += 2;
2467 fprintf_filtered (stream, " to %ld",
2468 (long) (data + l - start));
2469 break;
2470
2471 case DW_OP_bra:
2472 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
2473 data += 2;
2474 fprintf_filtered (stream, " %ld",
2475 (long) (data + l - start));
2476 break;
2477
2478 case DW_OP_call2:
2479 ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
2480 data += 2;
2481 fprintf_filtered (stream, " offset %s", phex_nz (ul, 2));
2482 break;
2483
2484 case DW_OP_call4:
2485 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
2486 data += 4;
2487 fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
2488 break;
2489
2490 case DW_OP_call_ref:
2491 ul = extract_unsigned_integer (data, offset_size,
2492 gdbarch_byte_order (arch));
2493 data += offset_size;
2494 fprintf_filtered (stream, " offset %s", phex_nz (ul, offset_size));
2495 break;
2496
2497 case DW_OP_piece:
2498 data = read_uleb128 (data, end, &ul);
2499 fprintf_filtered (stream, " %s (bytes)", pulongest (ul));
2500 break;
2501
2502 case DW_OP_bit_piece:
2503 {
2504 ULONGEST offset;
2505
2506 data = read_uleb128 (data, end, &ul);
2507 data = read_uleb128 (data, end, &offset);
2508 fprintf_filtered (stream, " size %s offset %s (bits)",
2509 pulongest (ul), pulongest (offset));
2510 }
2511 break;
2512
2513 case DW_OP_GNU_implicit_pointer:
2514 {
2515 ul = extract_unsigned_integer (data, offset_size,
2516 gdbarch_byte_order (arch));
2517 data += offset_size;
2518
2519 data = read_sleb128 (data, end, &l);
2520
2521 fprintf_filtered (stream, " DIE %s offset %s",
2522 phex_nz (ul, offset_size),
2523 plongest (l));
2524 }
2525 break;
2526 }
2527
2528 fprintf_filtered (stream, "\n");
2529 }
2530
2531 return data;
2532 }
2533
2534 /* Describe a single location, which may in turn consist of multiple
2535 pieces. */
2536
2537 static void
2538 locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr,
2539 struct ui_file *stream,
2540 const gdb_byte *data, int size,
2541 struct objfile *objfile, unsigned int addr_size,
2542 int offset_size)
2543 {
2544 const gdb_byte *end = data + size;
2545 int first_piece = 1, bad = 0;
2546
2547 while (data < end)
2548 {
2549 const gdb_byte *here = data;
2550 int disassemble = 1;
2551
2552 if (first_piece)
2553 first_piece = 0;
2554 else
2555 fprintf_filtered (stream, _(", and "));
2556
2557 if (!dwarf2_always_disassemble)
2558 {
2559 data = locexpr_describe_location_piece (symbol, stream,
2560 addr, objfile,
2561 data, end, addr_size);
2562 /* If we printed anything, or if we have an empty piece,
2563 then don't disassemble. */
2564 if (data != here
2565 || data[0] == DW_OP_piece
2566 || data[0] == DW_OP_bit_piece)
2567 disassemble = 0;
2568 }
2569 if (disassemble)
2570 data = disassemble_dwarf_expression (stream,
2571 get_objfile_arch (objfile),
2572 addr_size, offset_size, data, end,
2573 dwarf2_always_disassemble);
2574
2575 if (data < end)
2576 {
2577 int empty = data == here;
2578
2579 if (disassemble)
2580 fprintf_filtered (stream, " ");
2581 if (data[0] == DW_OP_piece)
2582 {
2583 ULONGEST bytes;
2584
2585 data = read_uleb128 (data + 1, end, &bytes);
2586
2587 if (empty)
2588 fprintf_filtered (stream, _("an empty %s-byte piece"),
2589 pulongest (bytes));
2590 else
2591 fprintf_filtered (stream, _(" [%s-byte piece]"),
2592 pulongest (bytes));
2593 }
2594 else if (data[0] == DW_OP_bit_piece)
2595 {
2596 ULONGEST bits, offset;
2597
2598 data = read_uleb128 (data + 1, end, &bits);
2599 data = read_uleb128 (data, end, &offset);
2600
2601 if (empty)
2602 fprintf_filtered (stream,
2603 _("an empty %s-bit piece"),
2604 pulongest (bits));
2605 else
2606 fprintf_filtered (stream,
2607 _(" [%s-bit piece, offset %s bits]"),
2608 pulongest (bits), pulongest (offset));
2609 }
2610 else
2611 {
2612 bad = 1;
2613 break;
2614 }
2615 }
2616 }
2617
2618 if (bad || data > end)
2619 error (_("Corrupted DWARF2 expression for \"%s\"."),
2620 SYMBOL_PRINT_NAME (symbol));
2621 }
2622
2623 /* Print a natural-language description of SYMBOL to STREAM. This
2624 version is for a symbol with a single location. */
2625
2626 static void
2627 locexpr_describe_location (struct symbol *symbol, CORE_ADDR addr,
2628 struct ui_file *stream)
2629 {
2630 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2631 struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
2632 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
2633 int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
2634
2635 locexpr_describe_location_1 (symbol, addr, stream,
2636 dlbaton->data, dlbaton->size,
2637 objfile, addr_size, offset_size);
2638 }
2639
2640 /* Describe the location of SYMBOL as an agent value in VALUE, generating
2641 any necessary bytecode in AX. */
2642
2643 static void
2644 locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
2645 struct agent_expr *ax, struct axs_value *value)
2646 {
2647 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2648 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
2649
2650 if (dlbaton->data == NULL || dlbaton->size == 0)
2651 value->optimized_out = 1;
2652 else
2653 dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size,
2654 dlbaton->data, dlbaton->data + dlbaton->size,
2655 dlbaton->per_cu);
2656 }
2657
2658 /* The set of location functions used with the DWARF-2 expression
2659 evaluator. */
2660 const struct symbol_computed_ops dwarf2_locexpr_funcs = {
2661 locexpr_read_variable,
2662 locexpr_read_needs_frame,
2663 locexpr_describe_location,
2664 locexpr_tracepoint_var_ref
2665 };
2666
2667
2668 /* Wrapper functions for location lists. These generally find
2669 the appropriate location expression and call something above. */
2670
2671 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
2672 evaluator to calculate the location. */
2673 static struct value *
2674 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
2675 {
2676 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2677 struct value *val;
2678 const gdb_byte *data;
2679 size_t size;
2680 CORE_ADDR pc = frame ? get_frame_address_in_block (frame) : 0;
2681
2682 data = dwarf2_find_location_expression (dlbaton, &size, pc);
2683 if (data == NULL)
2684 {
2685 val = allocate_value (SYMBOL_TYPE (symbol));
2686 VALUE_LVAL (val) = not_lval;
2687 set_value_optimized_out (val, 1);
2688 }
2689 else
2690 val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, data, size,
2691 dlbaton->per_cu);
2692
2693 return val;
2694 }
2695
2696 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
2697 static int
2698 loclist_read_needs_frame (struct symbol *symbol)
2699 {
2700 /* If there's a location list, then assume we need to have a frame
2701 to choose the appropriate location expression. With tracking of
2702 global variables this is not necessarily true, but such tracking
2703 is disabled in GCC at the moment until we figure out how to
2704 represent it. */
2705
2706 return 1;
2707 }
2708
2709 /* Print a natural-language description of SYMBOL to STREAM. This
2710 version applies when there is a list of different locations, each
2711 with a specified address range. */
2712
2713 static void
2714 loclist_describe_location (struct symbol *symbol, CORE_ADDR addr,
2715 struct ui_file *stream)
2716 {
2717 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2718 CORE_ADDR low, high;
2719 const gdb_byte *loc_ptr, *buf_end;
2720 int length, first = 1;
2721 struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
2722 struct gdbarch *gdbarch = get_objfile_arch (objfile);
2723 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2724 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
2725 int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
2726 int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
2727 CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
2728 /* Adjust base_address for relocatable objects. */
2729 CORE_ADDR base_offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
2730 CORE_ADDR base_address = dlbaton->base_address + base_offset;
2731
2732 loc_ptr = dlbaton->data;
2733 buf_end = dlbaton->data + dlbaton->size;
2734
2735 fprintf_filtered (stream, _("multi-location:\n"));
2736
2737 /* Iterate through locations until we run out. */
2738 while (1)
2739 {
2740 if (buf_end - loc_ptr < 2 * addr_size)
2741 error (_("Corrupted DWARF expression for symbol \"%s\"."),
2742 SYMBOL_PRINT_NAME (symbol));
2743
2744 if (signed_addr_p)
2745 low = extract_signed_integer (loc_ptr, addr_size, byte_order);
2746 else
2747 low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
2748 loc_ptr += addr_size;
2749
2750 if (signed_addr_p)
2751 high = extract_signed_integer (loc_ptr, addr_size, byte_order);
2752 else
2753 high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
2754 loc_ptr += addr_size;
2755
2756 /* A base-address-selection entry. */
2757 if ((low & base_mask) == base_mask)
2758 {
2759 base_address = high + base_offset;
2760 fprintf_filtered (stream, _(" Base address %s"),
2761 paddress (gdbarch, base_address));
2762 continue;
2763 }
2764
2765 /* An end-of-list entry. */
2766 if (low == 0 && high == 0)
2767 break;
2768
2769 /* Otherwise, a location expression entry. */
2770 low += base_address;
2771 high += base_address;
2772
2773 length = extract_unsigned_integer (loc_ptr, 2, byte_order);
2774 loc_ptr += 2;
2775
2776 /* (It would improve readability to print only the minimum
2777 necessary digits of the second number of the range.) */
2778 fprintf_filtered (stream, _(" Range %s-%s: "),
2779 paddress (gdbarch, low), paddress (gdbarch, high));
2780
2781 /* Now describe this particular location. */
2782 locexpr_describe_location_1 (symbol, low, stream, loc_ptr, length,
2783 objfile, addr_size, offset_size);
2784
2785 fprintf_filtered (stream, "\n");
2786
2787 loc_ptr += length;
2788 }
2789 }
2790
2791 /* Describe the location of SYMBOL as an agent value in VALUE, generating
2792 any necessary bytecode in AX. */
2793 static void
2794 loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
2795 struct agent_expr *ax, struct axs_value *value)
2796 {
2797 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
2798 const gdb_byte *data;
2799 size_t size;
2800 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
2801
2802 data = dwarf2_find_location_expression (dlbaton, &size, ax->scope);
2803 if (data == NULL || size == 0)
2804 value->optimized_out = 1;
2805 else
2806 dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size, data, data + size,
2807 dlbaton->per_cu);
2808 }
2809
2810 /* The set of location functions used with the DWARF-2 expression
2811 evaluator and location lists. */
2812 const struct symbol_computed_ops dwarf2_loclist_funcs = {
2813 loclist_read_variable,
2814 loclist_read_needs_frame,
2815 loclist_describe_location,
2816 loclist_tracepoint_var_ref
2817 };
This page took 0.091581 seconds and 4 git commands to generate.