GDB (xrefs)

/tmp/gdb-8.1/gdb/value.c
Go to the documentation of this file.
1 /* Low level packing and unpacking of values for GDB, the GNU Debugger.
2
3 Copyright (C) 1986-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #include "defs.h"
21 #include "arch-utils.h"
22 #include "symtab.h"
23 #include "gdbtypes.h"
24 #include "value.h"
25 #include "gdbcore.h"
26 #include "command.h"
27 #include "gdbcmd.h"
28 #include "target.h"
29 #include "language.h"
30 #include "demangle.h"
31 #include "regcache.h"
32 #include "block.h"
33 #include "target-float.h"
34 #include "objfiles.h"
35 #include "valprint.h"
36 #include "cli/cli-decode.h"
37 #include "extension.h"
38 #include <ctype.h>
39 #include "tracepoint.h"
40 #include "cp-abi.h"
41 #include "user-regs.h"
42 #include <algorithm>
43 #include "completer.h"
44
45 /* Definition of a user function. */
46 struct internal_function
47 {
48 /* The name of the function. It is a bit odd to have this in the
49 function itself -- the user might use a differently-named
50 convenience variable to hold the function. */
51 char *name;
52
53 /* The handler. */
54 internal_function_fn handler;
55
56 /* User data for the handler. */
57 void *cookie;
58 };
59
60 /* Defines an [OFFSET, OFFSET + LENGTH) range. */
61
62 struct range
63 {
64 /* Lowest offset in the range. */
65 LONGEST offset;
66
67 /* Length of the range. */
68 LONGEST length;
69 };
70
71 typedef struct range range_s;
72
73 DEF_VEC_O(range_s);
74
75 /* Returns true if the ranges defined by [offset1, offset1+len1) and
76 [offset2, offset2+len2) overlap. */
77
78 static int
79 ranges_overlap (LONGEST offset1, LONGEST len1,
80 LONGEST offset2, LONGEST len2)
81 {
82 ULONGEST h, l;
83
84 l = std::max (offset1, offset2);
85 h = std::min (offset1 + len1, offset2 + len2);
86 return (l < h);
87 }
88
89 /* Returns true if the first argument is strictly less than the
90 second, useful for VEC_lower_bound. We keep ranges sorted by
91 offset and coalesce overlapping and contiguous ranges, so this just
92 compares the starting offset. */
93
94 static int
95 range_lessthan (const range_s *r1, const range_s *r2)
96 {
97 return r1->offset < r2->offset;
98 }
99
100 /* Returns true if RANGES contains any range that overlaps [OFFSET,
101 OFFSET+LENGTH). */
102
103 static int
104 ranges_contain (VEC(range_s) *ranges, LONGEST offset, LONGEST length)
105 {
106 range_s what;
107 LONGEST i;
108
109 what.offset = offset;
110 what.length = length;
111
112 /* We keep ranges sorted by offset and coalesce overlapping and
113 contiguous ranges, so to check if a range list contains a given
114 range, we can do a binary search for the position the given range
115 would be inserted if we only considered the starting OFFSET of
116 ranges. We call that position I. Since we also have LENGTH to
117 care for (this is a range afterall), we need to check if the
118 _previous_ range overlaps the I range. E.g.,
119
120 R
121 |---|
122 |---| |---| |------| ... |--|
123 0 1 2 N
124
125 I=1
126
127 In the case above, the binary search would return `I=1', meaning,
128 this OFFSET should be inserted at position 1, and the current
129 position 1 should be pushed further (and before 2). But, `0'
130 overlaps with R.
131
132 Then we need to check if the I range overlaps the I range itself.
133 E.g.,
134
135 R
136 |---|
137 |---| |---| |-------| ... |--|
138 0 1 2 N
139
140 I=1
141 */
142
143 i = VEC_lower_bound (range_s, ranges, &what, range_lessthan);
144
145 if (i > 0)
146 {
147 struct range *bef = VEC_index (range_s, ranges, i - 1);
148
149 if (ranges_overlap (bef->offset, bef->length, offset, length))
150 return 1;
151 }
152
153 if (i < VEC_length (range_s, ranges))
154 {
155 struct range *r = VEC_index (range_s, ranges, i);
156
157 if (ranges_overlap (r->offset, r->length, offset, length))
158 return 1;
159 }
160
161 return 0;
162 }
163
164 static struct cmd_list_element *functionlist;
165
166 /* Note that the fields in this structure are arranged to save a bit
167 of memory. */
168
169 struct value
170 {
171 /* Type of value; either not an lval, or one of the various
172 different possible kinds of lval. */
173 enum lval_type lval;
174
175 /* Is it modifiable? Only relevant if lval != not_lval. */
176 unsigned int modifiable : 1;
177
178 /* If zero, contents of this value are in the contents field. If
179 nonzero, contents are in inferior. If the lval field is lval_memory,
180 the contents are in inferior memory at location.address plus offset.
181 The lval field may also be lval_register.
182
183 WARNING: This field is used by the code which handles watchpoints
184 (see breakpoint.c) to decide whether a particular value can be
185 watched by hardware watchpoints. If the lazy flag is set for
186 some member of a value chain, it is assumed that this member of
187 the chain doesn't need to be watched as part of watching the
188 value itself. This is how GDB avoids watching the entire struct
189 or array when the user wants to watch a single struct member or
190 array element. If you ever change the way lazy flag is set and
191 reset, be sure to consider this use as well! */
192 unsigned int lazy : 1;
193
194 /* If value is a variable, is it initialized or not. */
195 unsigned int initialized : 1;
196
197 /* If value is from the stack. If this is set, read_stack will be
198 used instead of read_memory to enable extra caching. */
199 unsigned int stack : 1;
200
201 /* If the value has been released. */
202 unsigned int released : 1;
203
204 /* Location of value (if lval). */
205 union
206 {
207 /* If lval == lval_memory, this is the address in the inferior */
208 CORE_ADDR address;
209
210 /*If lval == lval_register, the value is from a register. */
211 struct
212 {
213 /* Register number. */
214 int regnum;
215 /* Frame ID of "next" frame to which a register value is relative.
216 If the register value is found relative to frame F, then the
217 frame id of F->next will be stored in next_frame_id. */
218 struct frame_id next_frame_id;
219 } reg;
220
221 /* Pointer to internal variable. */
222 struct internalvar *internalvar;
223
224 /* Pointer to xmethod worker. */
225 struct xmethod_worker *xm_worker;
226
227 /* If lval == lval_computed, this is a set of function pointers
228 to use to access and describe the value, and a closure pointer
229 for them to use. */
230 struct
231 {
232 /* Functions to call. */
233 const struct lval_funcs *funcs;
234
235 /* Closure for those functions to use. */
236 void *closure;
237 } computed;
238 } location;
239
240 /* Describes offset of a value within lval of a structure in target
241 addressable memory units. Note also the member embedded_offset
242 below. */
243 LONGEST offset;
244
245 /* Only used for bitfields; number of bits contained in them. */
246 LONGEST bitsize;
247
248 /* Only used for bitfields; position of start of field. For
249 gdbarch_bits_big_endian=0 targets, it is the position of the LSB. For
250 gdbarch_bits_big_endian=1 targets, it is the position of the MSB. */
251 LONGEST bitpos;
252
253 /* The number of references to this value. When a value is created,
254 the value chain holds a reference, so REFERENCE_COUNT is 1. If
255 release_value is called, this value is removed from the chain but
256 the caller of release_value now has a reference to this value.
257 The caller must arrange for a call to value_free later. */
258 int reference_count;
259
260 /* Only used for bitfields; the containing value. This allows a
261 single read from the target when displaying multiple
262 bitfields. */
263 struct value *parent;
264
265 /* Type of the value. */
266 struct type *type;
267
268 /* If a value represents a C++ object, then the `type' field gives
269 the object's compile-time type. If the object actually belongs
270 to some class derived from `type', perhaps with other base
271 classes and additional members, then `type' is just a subobject
272 of the real thing, and the full object is probably larger than
273 `type' would suggest.
274
275 If `type' is a dynamic class (i.e. one with a vtable), then GDB
276 can actually determine the object's run-time type by looking at
277 the run-time type information in the vtable. When this
278 information is available, we may elect to read in the entire
279 object, for several reasons:
280
281 - When printing the value, the user would probably rather see the
282 full object, not just the limited portion apparent from the
283 compile-time type.
284
285 - If `type' has virtual base classes, then even printing `type'
286 alone may require reaching outside the `type' portion of the
287 object to wherever the virtual base class has been stored.
288
289 When we store the entire object, `enclosing_type' is the run-time
290 type -- the complete object -- and `embedded_offset' is the
291 offset of `type' within that larger type, in target addressable memory
292 units. The value_contents() macro takes `embedded_offset' into account,
293 so most GDB code continues to see the `type' portion of the value, just
294 as the inferior would.
295
296 If `type' is a pointer to an object, then `enclosing_type' is a
297 pointer to the object's run-time type, and `pointed_to_offset' is
298 the offset in target addressable memory units from the full object
299 to the pointed-to object -- that is, the value `embedded_offset' would
300 have if we followed the pointer and fetched the complete object.
301 (I don't really see the point. Why not just determine the
302 run-time type when you indirect, and avoid the special case? The
303 contents don't matter until you indirect anyway.)
304
305 If we're not doing anything fancy, `enclosing_type' is equal to
306 `type', and `embedded_offset' is zero, so everything works
307 normally. */
308 struct type *enclosing_type;
309 LONGEST embedded_offset;
310 LONGEST pointed_to_offset;
311
312 /* Values are stored in a chain, so that they can be deleted easily
313 over calls to the inferior. Values assigned to internal
314 variables, put into the value history or exposed to Python are
315 taken off this list. */
316 struct value *next;
317
318 /* Actual contents of the value. Target byte-order. NULL or not
319 valid if lazy is nonzero. */
320 gdb_byte *contents;
321
322 /* Unavailable ranges in CONTENTS. We mark unavailable ranges,
323 rather than available, since the common and default case is for a
324 value to be available. This is filled in at value read time.
325 The unavailable ranges are tracked in bits. Note that a contents
326 bit that has been optimized out doesn't really exist in the
327 program, so it can't be marked unavailable either. */
328 VEC(range_s) *unavailable;
329
330 /* Likewise, but for optimized out contents (a chunk of the value of
331 a variable that does not actually exist in the program). If LVAL
332 is lval_register, this is a register ($pc, $sp, etc., never a
333 program variable) that has not been saved in the frame. Not
334 saved registers and optimized-out program variables values are
335 treated pretty much the same, except not-saved registers have a
336 different string representation and related error strings. */
337 VEC(range_s) *optimized_out;
338 };
339
340 /* See value.h. */
341
342 struct gdbarch *
343 get_value_arch (const struct value *value)
344 {
345 return get_type_arch (value_type (value));
346 }
347
348 int
349 value_bits_available (const struct value *value, LONGEST offset, LONGEST length)
350 {
351 gdb_assert (!value->lazy);
352
353 return !ranges_contain (value->unavailable, offset, length);
354 }
355
356 int
357 value_bytes_available (const struct value *value,
358 LONGEST offset, LONGEST length)
359 {
360 return value_bits_available (value,
361 offset * TARGET_CHAR_BIT,
362 length * TARGET_CHAR_BIT);
363 }
364
365 int
366 value_bits_any_optimized_out (const struct value *value, int bit_offset, int bit_length)
367 {
368 gdb_assert (!value->lazy);
369
370 return ranges_contain (value->optimized_out, bit_offset, bit_length);
371 }
372
373 int
374 value_entirely_available (struct value *value)
375 {
376 /* We can only tell whether the whole value is available when we try
377 to read it. */
378 if (value->lazy)
379 value_fetch_lazy (value);
380
381 if (VEC_empty (range_s, value->unavailable))
382 return 1;
383 return 0;
384 }
385
386 /* Returns true if VALUE is entirely covered by RANGES. If the value
387 is lazy, it'll be read now. Note that RANGE is a pointer to
388 pointer because reading the value might change *RANGE. */
389
390 static int
391 value_entirely_covered_by_range_vector (struct value *value,
392 VEC(range_s) **ranges)
393 {
394 /* We can only tell whether the whole value is optimized out /
395 unavailable when we try to read it. */
396 if (value->lazy)
397 value_fetch_lazy (value);
398
399 if (VEC_length (range_s, *ranges) == 1)
400 {
401 struct range *t = VEC_index (range_s, *ranges, 0);
402
403 if (t->offset == 0
404 && t->length == (TARGET_CHAR_BIT
405 * TYPE_LENGTH (value_enclosing_type (value))))
406 return 1;
407 }
408
409 return 0;
410 }
411
412 int
413 value_entirely_unavailable (struct value *value)
414 {
415 return value_entirely_covered_by_range_vector (value, &value->unavailable);
416 }
417
418 int
419 value_entirely_optimized_out (struct value *value)
420 {
421 return value_entirely_covered_by_range_vector (value, &value->optimized_out);
422 }
423
424 /* Insert into the vector pointed to by VECTORP the bit range starting of
425 OFFSET bits, and extending for the next LENGTH bits. */
426
427 static void
428 insert_into_bit_range_vector (VEC(range_s) **vectorp,
429 LONGEST offset, LONGEST length)
430 {
431 range_s newr;
432 int i;
433
434 /* Insert the range sorted. If there's overlap or the new range
435 would be contiguous with an existing range, merge. */
436
437 newr.offset = offset;
438 newr.length = length;
439
440 /* Do a binary search for the position the given range would be
441 inserted if we only considered the starting OFFSET of ranges.
442 Call that position I. Since we also have LENGTH to care for
443 (this is a range afterall), we need to check if the _previous_
444 range overlaps the I range. E.g., calling R the new range:
445
446 #1 - overlaps with previous
447
448 R
449 |-...-|
450 |---| |---| |------| ... |--|
451 0 1 2 N
452
453 I=1
454
455 In the case #1 above, the binary search would return `I=1',
456 meaning, this OFFSET should be inserted at position 1, and the
457 current position 1 should be pushed further (and become 2). But,
458 note that `0' overlaps with R, so we want to merge them.
459
460 A similar consideration needs to be taken if the new range would
461 be contiguous with the previous range:
462
463 #2 - contiguous with previous
464
465 R
466 |-...-|
467 |--| |---| |------| ... |--|
468 0 1 2 N
469
470 I=1
471
472 If there's no overlap with the previous range, as in:
473
474 #3 - not overlapping and not contiguous
475
476 R
477 |-...-|
478 |--| |---| |------| ... |--|
479 0 1 2 N
480
481 I=1
482
483 or if I is 0:
484
485 #4 - R is the range with lowest offset
486
487 R
488 |-...-|
489 |--| |---| |------| ... |--|
490 0 1 2 N
491
492 I=0
493
494 ... we just push the new range to I.
495
496 All the 4 cases above need to consider that the new range may
497 also overlap several of the ranges that follow, or that R may be
498 contiguous with the following range, and merge. E.g.,
499
500 #5 - overlapping following ranges
501
502 R
503 |------------------------|
504 |--| |---| |------| ... |--|
505 0 1 2 N
506
507 I=0
508
509 or:
510
511 R
512 |-------|
513 |--| |---| |------| ... |--|
514 0 1 2 N
515
516 I=1
517
518 */
519
520 i = VEC_lower_bound (range_s, *vectorp, &newr, range_lessthan);
521 if (i > 0)
522 {
523 struct range *bef = VEC_index (range_s, *vectorp, i - 1);
524
525 if (ranges_overlap (bef->offset, bef->length, offset, length))
526 {
527 /* #1 */
528 ULONGEST l = std::min (bef->offset, offset);
529 ULONGEST h = std::max (bef->offset + bef->length, offset + length);
530
531 bef->offset = l;
532 bef->length = h - l;
533 i--;
534 }
535 else if (offset == bef->offset + bef->length)
536 {
537 /* #2 */
538 bef->length += length;
539 i--;
540 }
541 else
542 {
543 /* #3 */
544 VEC_safe_insert (range_s, *vectorp, i, &newr);
545 }
546 }
547 else
548 {
549 /* #4 */
550 VEC_safe_insert (range_s, *vectorp, i, &newr);
551 }
552
553 /* Check whether the ranges following the one we've just added or
554 touched can be folded in (#5 above). */
555 if (i + 1 < VEC_length (range_s, *vectorp))
556 {
557 struct range *t;
558 struct range *r;
559 int removed = 0;
560 int next = i + 1;
561
562 /* Get the range we just touched. */
563 t = VEC_index (range_s, *vectorp, i);
564 removed = 0;
565
566 i = next;
567 for (; VEC_iterate (range_s, *vectorp, i, r); i++)
568 if (r->offset <= t->offset + t->length)
569 {
570 ULONGEST l, h;
571
572 l = std::min (t->offset, r->offset);
573 h = std::max (t->offset + t->length, r->offset + r->length);
574
575 t->offset = l;
576 t->length = h - l;
577
578 removed++;
579 }
580 else
581 {
582 /* If we couldn't merge this one, we won't be able to
583 merge following ones either, since the ranges are
584 always sorted by OFFSET. */
585 break;
586 }
587
588 if (removed != 0)
589 VEC_block_remove (range_s, *vectorp, next, removed);
590 }
591 }
592
593 void
594 mark_value_bits_unavailable (struct value *value,
595 LONGEST offset, LONGEST length)
596 {
597 insert_into_bit_range_vector (&value->unavailable, offset, length);
598 }
599
600 void
601 mark_value_bytes_unavailable (struct value *value,
602 LONGEST offset, LONGEST length)
603 {
604 mark_value_bits_unavailable (value,
605 offset * TARGET_CHAR_BIT,
606 length * TARGET_CHAR_BIT);
607 }
608
609 /* Find the first range in RANGES that overlaps the range defined by
610 OFFSET and LENGTH, starting at element POS in the RANGES vector,
611 Returns the index into RANGES where such overlapping range was
612 found, or -1 if none was found. */
613
614 static int
615 find_first_range_overlap (VEC(range_s) *ranges, int pos,
616 LONGEST offset, LONGEST length)
617 {
618 range_s *r;
619 int i;
620
621 for (i = pos; VEC_iterate (range_s, ranges, i, r); i++)
622 if (ranges_overlap (r->offset, r->length, offset, length))
623 return i;
624
625 return -1;
626 }
627
628 /* Compare LENGTH_BITS of memory at PTR1 + OFFSET1_BITS with the memory at
629 PTR2 + OFFSET2_BITS. Return 0 if the memory is the same, otherwise
630 return non-zero.
631
632 It must always be the case that:
633 OFFSET1_BITS % TARGET_CHAR_BIT == OFFSET2_BITS % TARGET_CHAR_BIT
634
635 It is assumed that memory can be accessed from:
636 PTR + (OFFSET_BITS / TARGET_CHAR_BIT)
637 to:
638 PTR + ((OFFSET_BITS + LENGTH_BITS + TARGET_CHAR_BIT - 1)
639 / TARGET_CHAR_BIT) */
640 static int
641 memcmp_with_bit_offsets (const gdb_byte *ptr1, size_t offset1_bits,
642 const gdb_byte *ptr2, size_t offset2_bits,
643 size_t length_bits)
644 {
645 gdb_assert (offset1_bits % TARGET_CHAR_BIT
646 == offset2_bits % TARGET_CHAR_BIT);
647
648 if (offset1_bits % TARGET_CHAR_BIT != 0)
649 {
650 size_t bits;
651 gdb_byte mask, b1, b2;
652
653 /* The offset from the base pointers PTR1 and PTR2 is not a complete
654 number of bytes. A number of bits up to either the next exact
655 byte boundary, or LENGTH_BITS (which ever is sooner) will be
656 compared. */
657 bits = TARGET_CHAR_BIT - offset1_bits % TARGET_CHAR_BIT;
658 gdb_assert (bits < sizeof (mask) * TARGET_CHAR_BIT);
659 mask = (1 << bits) - 1;
660
661 if (length_bits < bits)
662 {
663 mask &= ~(gdb_byte) ((1 << (bits - length_bits)) - 1);
664 bits = length_bits;
665 }
666
667 /* Now load the two bytes and mask off the bits we care about. */
668 b1 = *(ptr1 + offset1_bits / TARGET_CHAR_BIT) & mask;
669 b2 = *(ptr2 + offset2_bits / TARGET_CHAR_BIT) & mask;
670
671 if (b1 != b2)
672 return 1;
673
674 /* Now update the length and offsets to take account of the bits
675 we've just compared. */
676 length_bits -= bits;
677 offset1_bits += bits;
678 offset2_bits += bits;
679 }
680
681 if (length_bits % TARGET_CHAR_BIT != 0)
682 {
683 size_t bits;
684 size_t o1, o2;
685 gdb_byte mask, b1, b2;
686
687 /* The length is not an exact number of bytes. After the previous
688 IF.. block then the offsets are byte aligned, or the
689 length is zero (in which case this code is not reached). Compare
690 a number of bits at the end of the region, starting from an exact
691 byte boundary. */
692 bits = length_bits % TARGET_CHAR_BIT;
693 o1 = offset1_bits + length_bits - bits;
694 o2 = offset2_bits + length_bits - bits;
695
696 gdb_assert (bits < sizeof (mask) * TARGET_CHAR_BIT);
697 mask = ((1 << bits) - 1) << (TARGET_CHAR_BIT - bits);
698
699 gdb_assert (o1 % TARGET_CHAR_BIT == 0);
700 gdb_assert (o2 % TARGET_CHAR_BIT == 0);
701
702 b1 = *(ptr1 + o1 / TARGET_CHAR_BIT) & mask;
703 b2 = *(ptr2 + o2 / TARGET_CHAR_BIT) & mask;
704
705 if (b1 != b2)
706 return 1;
707
708 length_bits -= bits;
709 }
710
711 if (length_bits > 0)
712 {
713 /* We've now taken care of any stray "bits" at the start, or end of
714 the region to compare, the remainder can be covered with a simple
715 memcmp. */
716 gdb_assert (offset1_bits % TARGET_CHAR_BIT == 0);
717 gdb_assert (offset2_bits % TARGET_CHAR_BIT == 0);
718 gdb_assert (length_bits % TARGET_CHAR_BIT == 0);
719
720 return memcmp (ptr1 + offset1_bits / TARGET_CHAR_BIT,
721 ptr2 + offset2_bits / TARGET_CHAR_BIT,
722 length_bits / TARGET_CHAR_BIT);
723 }
724
725 /* Length is zero, regions match. */
726 return 0;
727 }
728
729 /* Helper struct for find_first_range_overlap_and_match and
730 value_contents_bits_eq. Keep track of which slot of a given ranges
731 vector have we last looked at. */
732
733 struct ranges_and_idx
734 {
735 /* The ranges. */
736 VEC(range_s) *ranges;
737
738 /* The range we've last found in RANGES. Given ranges are sorted,
739 we can start the next lookup here. */
740 int idx;
741 };
742
743 /* Helper function for value_contents_bits_eq. Compare LENGTH bits of
744 RP1's ranges starting at OFFSET1 bits with LENGTH bits of RP2's
745 ranges starting at OFFSET2 bits. Return true if the ranges match
746 and fill in *L and *H with the overlapping window relative to
747 (both) OFFSET1 or OFFSET2. */
748
749 static int
750 find_first_range_overlap_and_match (struct ranges_and_idx *rp1,
751 struct ranges_and_idx *rp2,
752 LONGEST offset1, LONGEST offset2,
753 LONGEST length, ULONGEST *l, ULONGEST *h)
754 {
755 rp1->idx = find_first_range_overlap (rp1->ranges, rp1->idx,
756 offset1, length);
757 rp2->idx = find_first_range_overlap (rp2->ranges, rp2->idx,
758 offset2, length);
759
760 if (rp1->idx == -1 && rp2->idx == -1)
761 {
762 *l = length;
763 *h = length;
764 return 1;
765 }
766 else if (rp1->idx == -1 || rp2->idx == -1)
767 return 0;
768 else
769 {
770 range_s *r1, *r2;
771 ULONGEST l1, h1;
772 ULONGEST l2, h2;
773
774 r1 = VEC_index (range_s, rp1->ranges, rp1->idx);
775 r2 = VEC_index (range_s, rp2->ranges, rp2->idx);
776
777 /* Get the unavailable windows intersected by the incoming
778 ranges. The first and last ranges that overlap the argument
779 range may be wider than said incoming arguments ranges. */
780 l1 = std::max (offset1, r1->offset);
781 h1 = std::min (offset1 + length, r1->offset + r1->length);
782
783 l2 = std::max (offset2, r2->offset);
784 h2 = std::min (offset2 + length, offset2 + r2->length);
785
786 /* Make them relative to the respective start offsets, so we can
787 compare them for equality. */
788 l1 -= offset1;
789 h1 -= offset1;
790
791 l2 -= offset2;
792 h2 -= offset2;
793
794 /* Different ranges, no match. */
795 if (l1 != l2 || h1 != h2)
796 return 0;
797
798 *h = h1;
799 *l = l1;
800 return 1;
801 }
802 }
803
804 /* Helper function for value_contents_eq. The only difference is that
805 this function is bit rather than byte based.
806
807 Compare LENGTH bits of VAL1's contents starting at OFFSET1 bits
808 with LENGTH bits of VAL2's contents starting at OFFSET2 bits.
809 Return true if the available bits match. */
810
811 static bool
812 value_contents_bits_eq (const struct value *val1, int offset1,
813 const struct value *val2, int offset2,
814 int length)
815 {
816 /* Each array element corresponds to a ranges source (unavailable,
817 optimized out). '1' is for VAL1, '2' for VAL2. */
818 struct ranges_and_idx rp1[2], rp2[2];
819
820 /* See function description in value.h. */
821 gdb_assert (!val1->lazy && !val2->lazy);
822
823 /* We shouldn't be trying to compare past the end of the values. */
824 gdb_assert (offset1 + length
825 <= TYPE_LENGTH (val1->enclosing_type) * TARGET_CHAR_BIT);
826 gdb_assert (offset2 + length
827 <= TYPE_LENGTH (val2->enclosing_type) * TARGET_CHAR_BIT);
828
829 memset (&rp1, 0, sizeof (rp1));
830 memset (&rp2, 0, sizeof (rp2));
831 rp1[0].ranges = val1->unavailable;
832 rp2[0].ranges = val2->unavailable;
833 rp1[1].ranges = val1->optimized_out;
834 rp2[1].ranges = val2->optimized_out;
835
836 while (length > 0)
837 {
838 ULONGEST l = 0, h = 0; /* init for gcc -Wall */
839 int i;
840
841 for (i = 0; i < 2; i++)
842 {
843 ULONGEST l_tmp, h_tmp;
844
845 /* The contents only match equal if the invalid/unavailable
846 contents ranges match as well. */
847 if (!find_first_range_overlap_and_match (&rp1[i], &rp2[i],
848 offset1, offset2, length,
849 &l_tmp, &h_tmp))
850 return false;
851
852 /* We're interested in the lowest/first range found. */
853 if (i == 0 || l_tmp < l)
854 {
855 l = l_tmp;
856 h = h_tmp;
857 }
858 }
859
860 /* Compare the available/valid contents. */
861 if (memcmp_with_bit_offsets (val1->contents, offset1,
862 val2->contents, offset2, l) != 0)
863 return false;
864
865 length -= h;
866 offset1 += h;
867 offset2 += h;
868 }
869
870 return true;
871 }
872
873 bool
874 value_contents_eq (const struct value *val1, LONGEST offset1,
875 const struct value *val2, LONGEST offset2,
876 LONGEST length)
877 {
878 return value_contents_bits_eq (val1, offset1 * TARGET_CHAR_BIT,
879 val2, offset2 * TARGET_CHAR_BIT,
880 length * TARGET_CHAR_BIT);
881 }
882
883
884 /* The value-history records all the values printed
885 by print commands during this session. Each chunk
886 records 60 consecutive values. The first chunk on
887 the chain records the most recent values.
888 The total number of values is in value_history_count. */
889
890 #define VALUE_HISTORY_CHUNK 60
891
892 struct value_history_chunk
893 {
894 struct value_history_chunk *next;
895 struct value *values[VALUE_HISTORY_CHUNK];
896 };
897
898 /* Chain of chunks now in use. */
899
900 static struct value_history_chunk *value_history_chain;
901
902 static int value_history_count; /* Abs number of last entry stored. */
903
904
905 /* List of all value objects currently allocated
906 (except for those released by calls to release_value)
907 This is so they can be freed after each command. */
908
909 static struct value *all_values;
910
911 /* Allocate a lazy value for type TYPE. Its actual content is
912 "lazily" allocated too: the content field of the return value is
913 NULL; it will be allocated when it is fetched from the target. */
914
915 struct value *
916 allocate_value_lazy (struct type *type)
917 {
918 struct value *val;
919
920 /* Call check_typedef on our type to make sure that, if TYPE
921 is a TYPE_CODE_TYPEDEF, its length is set to the length
922 of the target type instead of zero. However, we do not
923 replace the typedef type by the target type, because we want
924 to keep the typedef in order to be able to set the VAL's type
925 description correctly. */
926 check_typedef (type);
927
928 val = XCNEW (struct value);
929 val->contents = NULL;
930 val->next = all_values;
931 all_values = val;
932 val->type = type;
933 val->enclosing_type = type;
934 VALUE_LVAL (val) = not_lval;
935 val->location.address = 0;
936 val->offset = 0;
937 val->bitpos = 0;
938 val->bitsize = 0;
939 val->lazy = 1;
940 val->embedded_offset = 0;
941 val->pointed_to_offset = 0;
942 val->modifiable = 1;
943 val->initialized = 1; /* Default to initialized. */
944
945 /* Values start out on the all_values chain. */
946 val->reference_count = 1;
947
948 return val;
949 }
950
951 /* The maximum size, in bytes, that GDB will try to allocate for a value.
952 The initial value of 64k was not selected for any specific reason, it is
953 just a reasonable starting point. */
954
955 static int max_value_size = 65536; /* 64k bytes */
956
957 /* It is critical that the MAX_VALUE_SIZE is at least as big as the size of
958 LONGEST, otherwise GDB will not be able to parse integer values from the
959 CLI; for example if the MAX_VALUE_SIZE could be set to 1 then GDB would
960 be unable to parse "set max-value-size 2".
961
962 As we want a consistent GDB experience across hosts with different sizes
963 of LONGEST, this arbitrary minimum value was selected, so long as this
964 is bigger than LONGEST on all GDB supported hosts we're fine. */
965
966 #define MIN_VALUE_FOR_MAX_VALUE_SIZE 16
967 gdb_static_assert (sizeof (LONGEST) <= MIN_VALUE_FOR_MAX_VALUE_SIZE);
968
969 /* Implement the "set max-value-size" command. */
970
971 static void
972 set_max_value_size (const char *args, int from_tty,
973 struct cmd_list_element *c)
974 {
975 gdb_assert (max_value_size == -1 || max_value_size >= 0);
976
977 if (max_value_size > -1 && max_value_size < MIN_VALUE_FOR_MAX_VALUE_SIZE)
978 {
979 max_value_size = MIN_VALUE_FOR_MAX_VALUE_SIZE;
980 error (_("max-value-size set too low, increasing to %d bytes"),
981 max_value_size);
982 }
983 }
984
985 /* Implement the "show max-value-size" command. */
986
987 static void
988 show_max_value_size (struct ui_file *file, int from_tty,
989 struct cmd_list_element *c, const char *value)
990 {
991 if (max_value_size == -1)
992 fprintf_filtered (file, _("Maximum value size is unlimited.\n"));
993 else
994 fprintf_filtered (file, _("Maximum value size is %d bytes.\n"),
995 max_value_size);
996 }
997
998 /* Called before we attempt to allocate or reallocate a buffer for the
999 contents of a value. TYPE is the type of the value for which we are
1000 allocating the buffer. If the buffer is too large (based on the user
1001 controllable setting) then throw an error. If this function returns
1002 then we should attempt to allocate the buffer. */
1003
1004 static void
1005 check_type_length_before_alloc (const struct type *type)
1006 {
1007 unsigned int length = TYPE_LENGTH (type);
1008
1009 if (max_value_size > -1 && length > max_value_size)
1010 {
1011 if (TYPE_NAME (type) != NULL)
1012 error (_("value of type `%s' requires %u bytes, which is more "
1013 "than max-value-size"), TYPE_NAME (type), length);
1014 else
1015 error (_("value requires %u bytes, which is more than "
1016 "max-value-size"), length);
1017 }
1018 }
1019
1020 /* Allocate the contents of VAL if it has not been allocated yet. */
1021
1022 static void
1023 allocate_value_contents (struct value *val)
1024 {
1025 if (!val->contents)
1026 {
1027 check_type_length_before_alloc (val->enclosing_type);
1028 val->contents
1029 = (gdb_byte *) xzalloc (TYPE_LENGTH (val->enclosing_type));
1030 }
1031 }
1032
1033 /* Allocate a value and its contents for type TYPE. */
1034
1035 struct value *
1036 allocate_value (struct type *type)
1037 {
1038 struct value *val = allocate_value_lazy (type);
1039
1040 allocate_value_contents (val);
1041 val->lazy = 0;
1042 return val;
1043 }
1044
1045 /* Allocate a value that has the correct length
1046 for COUNT repetitions of type TYPE. */
1047
1048 struct value *
1049 allocate_repeat_value (struct type *type, int count)
1050 {
1051 int low_bound = current_language->string_lower_bound; /* ??? */
1052 /* FIXME-type-allocation: need a way to free this type when we are
1053 done with it. */
1054 struct type *array_type
1055 = lookup_array_range_type (type, low_bound, count + low_bound - 1);
1056
1057 return allocate_value (array_type);
1058 }
1059
1060 struct value *
1061 allocate_computed_value (struct type *type,
1062 const struct lval_funcs *funcs,
1063 void *closure)
1064 {
1065 struct value *v = allocate_value_lazy (type);
1066
1067 VALUE_LVAL (v) = lval_computed;
1068 v->location.computed.funcs = funcs;
1069 v->location.computed.closure = closure;
1070
1071 return v;
1072 }
1073
1074 /* Allocate NOT_LVAL value for type TYPE being OPTIMIZED_OUT. */
1075
1076 struct value *
1077 allocate_optimized_out_value (struct type *type)
1078 {
1079 struct value *retval = allocate_value_lazy (type);
1080
1081 mark_value_bytes_optimized_out (retval, 0, TYPE_LENGTH (type));
1082 set_value_lazy (retval, 0);
1083 return retval;
1084 }
1085
1086 /* Accessor methods. */
1087
1088 struct value *
1089 value_next (const struct value *value)
1090 {
1091 return value->next;
1092 }
1093
1094 struct type *
1095 value_type (const struct value *value)
1096 {
1097 return value->type;
1098 }
1099 void
1100 deprecated_set_value_type (struct value *value, struct type *type)
1101 {
1102 value->type = type;
1103 }
1104
1105 LONGEST
1106 value_offset (const struct value *value)
1107 {
1108 return value->offset;
1109 }
1110 void
1111 set_value_offset (struct value *value, LONGEST offset)
1112 {
1113 value->offset = offset;
1114 }
1115
1116 LONGEST
1117 value_bitpos (const struct value *value)
1118 {
1119 return value->bitpos;
1120 }
1121 void
1122 set_value_bitpos (struct value *value, LONGEST bit)
1123 {
1124 value->bitpos = bit;
1125 }
1126
1127 LONGEST
1128 value_bitsize (const struct value *value)
1129 {
1130 return value->bitsize;
1131 }
1132 void
1133 set_value_bitsize (struct value *value, LONGEST bit)
1134 {
1135 value->bitsize = bit;
1136 }
1137
1138 struct value *
1139 value_parent (const struct value *value)
1140 {
1141 return value->parent;
1142 }
1143
1144 /* See value.h. */
1145
1146 void
1147 set_value_parent (struct value *value, struct value *parent)
1148 {
1149 struct value *old = value->parent;
1150
1151 value->parent = parent;
1152 if (parent != NULL)
1153 value_incref (parent);
1154 value_free (old);
1155 }
1156
1157 gdb_byte *
1158 value_contents_raw (struct value *value)
1159 {
1160 struct gdbarch *arch = get_value_arch (value);
1161 int unit_size = gdbarch_addressable_memory_unit_size (arch);
1162
1163 allocate_value_contents (value);
1164 return value->contents + value->embedded_offset * unit_size;
1165 }
1166
1167 gdb_byte *
1168 value_contents_all_raw (struct value *value)
1169 {
1170 allocate_value_contents (value);
1171 return value->contents;
1172 }
1173
1174 struct type *
1175 value_enclosing_type (const struct value *value)
1176 {
1177 return value->enclosing_type;
1178 }
1179
1180 /* Look at value.h for description. */
1181
1182 struct type *
1183 value_actual_type (struct value *value, int resolve_simple_types,
1184 int *real_type_found)
1185 {
1186 struct value_print_options opts;
1187 struct type *result;
1188
1189 get_user_print_options (&opts);
1190
1191 if (real_type_found)
1192 *real_type_found = 0;
1193 result = value_type (value);
1194 if (opts.objectprint)
1195 {
1196 /* If result's target type is TYPE_CODE_STRUCT, proceed to
1197 fetch its rtti type. */
1198 if ((TYPE_CODE (result) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (result))
1199 && TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (result)))
1200 == TYPE_CODE_STRUCT
1201 && !value_optimized_out (value))
1202 {
1203 struct type *real_type;
1204
1205 real_type = value_rtti_indirect_type (value, NULL, NULL, NULL);
1206 if (real_type)
1207 {
1208 if (real_type_found)
1209 *real_type_found = 1;
1210 result = real_type;
1211 }
1212 }
1213 else if (resolve_simple_types)
1214 {
1215 if (real_type_found)
1216 *real_type_found = 1;
1217 result = value_enclosing_type (value);
1218 }
1219 }
1220
1221 return result;
1222 }
1223
1224 void
1225 error_value_optimized_out (void)
1226 {
1227 error (_("value has been optimized out"));
1228 }
1229
1230 static void
1231 require_not_optimized_out (const struct value *value)
1232 {
1233 if (!VEC_empty (range_s, value->optimized_out))
1234 {
1235 if (value->lval == lval_register)
1236 error (_("register has not been saved in frame"));
1237 else
1238 error_value_optimized_out ();
1239 }
1240 }
1241
1242 static void
1243 require_available (const struct value *value)
1244 {
1245 if (!VEC_empty (range_s, value->unavailable))
1246 throw_error (NOT_AVAILABLE_ERROR, _("value is not available"));
1247 }
1248
1249 const gdb_byte *
1250 value_contents_for_printing (struct value *value)
1251 {
1252 if (value->lazy)
1253 value_fetch_lazy (value);
1254 return value->contents;
1255 }
1256
1257 const gdb_byte *
1258 value_contents_for_printing_const (const struct value *value)
1259 {
1260 gdb_assert (!value->lazy);
1261 return value->contents;
1262 }
1263
1264 const gdb_byte *
1265 value_contents_all (struct value *value)
1266 {
1267 const gdb_byte *result = value_contents_for_printing (value);
1268 require_not_optimized_out (value);
1269 require_available (value);
1270 return result;
1271 }
1272
1273 /* Copy ranges in SRC_RANGE that overlap [SRC_BIT_OFFSET,
1274 SRC_BIT_OFFSET+BIT_LENGTH) ranges into *DST_RANGE, adjusted. */
1275
1276 static void
1277 ranges_copy_adjusted (VEC (range_s) **dst_range, int dst_bit_offset,
1278 VEC (range_s) *src_range, int src_bit_offset,
1279 int bit_length)
1280 {
1281 range_s *r;
1282 int i;
1283
1284 for (i = 0; VEC_iterate (range_s, src_range, i, r); i++)
1285 {
1286 ULONGEST h, l;
1287
1288 l = std::max (r->offset, (LONGEST) src_bit_offset);
1289 h = std::min (r->offset + r->length,
1290 (LONGEST) src_bit_offset + bit_length);
1291
1292 if (l < h)
1293 insert_into_bit_range_vector (dst_range,
1294 dst_bit_offset + (l - src_bit_offset),
1295 h - l);
1296 }
1297 }
1298
1299 /* Copy the ranges metadata in SRC that overlaps [SRC_BIT_OFFSET,
1300 SRC_BIT_OFFSET+BIT_LENGTH) into DST, adjusted. */
1301
1302 static void
1303 value_ranges_copy_adjusted (struct value *dst, int dst_bit_offset,
1304 const struct value *src, int src_bit_offset,
1305 int bit_length)
1306 {
1307 ranges_copy_adjusted (&dst->unavailable, dst_bit_offset,
1308 src->unavailable, src_bit_offset,
1309 bit_length);
1310 ranges_copy_adjusted (&dst->optimized_out, dst_bit_offset,
1311 src->optimized_out, src_bit_offset,
1312 bit_length);
1313 }
1314
1315 /* Copy LENGTH target addressable memory units of SRC value's (all) contents
1316 (value_contents_all) starting at SRC_OFFSET, into DST value's (all)
1317 contents, starting at DST_OFFSET. If unavailable contents are
1318 being copied from SRC, the corresponding DST contents are marked
1319 unavailable accordingly. Neither DST nor SRC may be lazy
1320 values.
1321
1322 It is assumed the contents of DST in the [DST_OFFSET,
1323 DST_OFFSET+LENGTH) range are wholly available. */
1324
1325 void
1326 value_contents_copy_raw (struct value *dst, LONGEST dst_offset,
1327 struct value *src, LONGEST src_offset, LONGEST length)
1328 {
1329 LONGEST src_bit_offset, dst_bit_offset, bit_length;
1330 struct gdbarch *arch = get_value_arch (src);
1331 int unit_size = gdbarch_addressable_memory_unit_size (arch);
1332
1333 /* A lazy DST would make that this copy operation useless, since as
1334 soon as DST's contents were un-lazied (by a later value_contents
1335 call, say), the contents would be overwritten. A lazy SRC would
1336 mean we'd be copying garbage. */
1337 gdb_assert (!dst->lazy && !src->lazy);
1338
1339 /* The overwritten DST range gets unavailability ORed in, not
1340 replaced. Make sure to remember to implement replacing if it
1341 turns out actually necessary. */
1342 gdb_assert (value_bytes_available (dst, dst_offset, length));
1343 gdb_assert (!value_bits_any_optimized_out (dst,
1344 TARGET_CHAR_BIT * dst_offset,
1345 TARGET_CHAR_BIT * length));
1346
1347 /* Copy the data. */
1348 memcpy (value_contents_all_raw (dst) + dst_offset * unit_size,
1349 value_contents_all_raw (src) + src_offset * unit_size,
1350 length * unit_size);
1351
1352 /* Copy the meta-data, adjusted. */
1353 src_bit_offset = src_offset * unit_size * HOST_CHAR_BIT;
1354 dst_bit_offset = dst_offset * unit_size * HOST_CHAR_BIT;
1355 bit_length = length * unit_size * HOST_CHAR_BIT;
1356
1357 value_ranges_copy_adjusted (dst, dst_bit_offset,
1358 src, src_bit_offset,
1359 bit_length);
1360 }
1361
1362 /* Copy LENGTH bytes of SRC value's (all) contents
1363 (value_contents_all) starting at SRC_OFFSET byte, into DST value's
1364 (all) contents, starting at DST_OFFSET. If unavailable contents
1365 are being copied from SRC, the corresponding DST contents are
1366 marked unavailable accordingly. DST must not be lazy. If SRC is
1367 lazy, it will be fetched now.
1368
1369 It is assumed the contents of DST in the [DST_OFFSET,
1370 DST_OFFSET+LENGTH) range are wholly available. */
1371
1372 void
1373 value_contents_copy (struct value *dst, LONGEST dst_offset,
1374 struct value *src, LONGEST src_offset, LONGEST length)
1375 {
1376 if (src->lazy)
1377 value_fetch_lazy (src);
1378
1379 value_contents_copy_raw (dst, dst_offset, src, src_offset, length);
1380 }
1381
1382 int
1383 value_lazy (const struct value *value)
1384 {
1385 return value->lazy;
1386 }
1387
1388 void
1389 set_value_lazy (struct value *value, int val)
1390 {
1391 value->lazy = val;
1392 }
1393
1394 int
1395 value_stack (const struct value *value)
1396 {
1397 return value->stack;
1398 }
1399
1400 void
1401 set_value_stack (struct value *value, int val)
1402 {
1403 value->stack = val;
1404 }
1405
1406 const gdb_byte *
1407 value_contents (struct value *value)
1408 {
1409 const gdb_byte *result = value_contents_writeable (value);
1410 require_not_optimized_out (value);
1411 require_available (value);
1412 return result;
1413 }
1414
1415 gdb_byte *
1416 value_contents_writeable (struct value *value)
1417 {
1418 if (value->lazy)
1419 value_fetch_lazy (value);
1420 return value_contents_raw (value);
1421 }
1422
1423 int
1424 value_optimized_out (struct value *value)
1425 {
1426 /* We can only know if a value is optimized out once we have tried to
1427 fetch it. */
1428 if (VEC_empty (range_s, value->optimized_out) && value->lazy)
1429 {
1430 TRY
1431 {
1432 value_fetch_lazy (value);
1433 }
1434 CATCH (ex, RETURN_MASK_ERROR)
1435 {
1436 /* Fall back to checking value->optimized_out. */
1437 }
1438 END_CATCH
1439 }
1440
1441 return !VEC_empty (range_s, value->optimized_out);
1442 }
1443
1444 /* Mark contents of VALUE as optimized out, starting at OFFSET bytes, and
1445 the following LENGTH bytes. */
1446
1447 void
1448 mark_value_bytes_optimized_out (struct value *value, int offset, int length)
1449 {
1450 mark_value_bits_optimized_out (value,
1451 offset * TARGET_CHAR_BIT,
1452 length * TARGET_CHAR_BIT);
1453 }
1454
1455 /* See value.h. */
1456
1457 void
1458 mark_value_bits_optimized_out (struct value *value,
1459 LONGEST offset, LONGEST length)
1460 {
1461 insert_into_bit_range_vector (&value->optimized_out, offset, length);
1462 }
1463
1464 int
1465 value_bits_synthetic_pointer (const struct value *value,
1466 LONGEST offset, LONGEST length)
1467 {
1468 if (value->lval != lval_computed
1469 || !value->location.computed.funcs->check_synthetic_pointer)
1470 return 0;
1471 return value->location.computed.funcs->check_synthetic_pointer (value,
1472 offset,
1473 length);
1474 }
1475
1476 LONGEST
1477 value_embedded_offset (const struct value *value)
1478 {
1479 return value->embedded_offset;
1480 }
1481
1482 void
1483 set_value_embedded_offset (struct value *value, LONGEST val)
1484 {
1485 value->embedded_offset = val;
1486 }
1487
1488 LONGEST
1489 value_pointed_to_offset (const struct value *value)
1490 {
1491 return value->pointed_to_offset;
1492 }
1493
1494 void
1495 set_value_pointed_to_offset (struct value *value, LONGEST val)
1496 {
1497 value->pointed_to_offset = val;
1498 }
1499
1500 const struct lval_funcs *
1501 value_computed_funcs (const struct value *v)
1502 {
1503 gdb_assert (value_lval_const (v) == lval_computed);
1504
1505 return v->location.computed.funcs;
1506 }
1507
1508 void *
1509 value_computed_closure (const struct value *v)
1510 {
1511 gdb_assert (v->lval == lval_computed);
1512
1513 return v->location.computed.closure;
1514 }
1515
1516 enum lval_type *
1517 deprecated_value_lval_hack (struct value *value)
1518 {
1519 return &value->lval;
1520 }
1521
1522 enum lval_type
1523 value_lval_const (const struct value *value)
1524 {
1525 return value->lval;
1526 }
1527
1528 CORE_ADDR
1529 value_address (const struct value *value)
1530 {
1531 if (value->lval != lval_memory)
1532 return 0;
1533 if (value->parent != NULL)
1534 return value_address (value->parent) + value->offset;
1535 if (NULL != TYPE_DATA_LOCATION (value_type (value)))
1536 {
1537 gdb_assert (PROP_CONST == TYPE_DATA_LOCATION_KIND (value_type (value)));
1538 return TYPE_DATA_LOCATION_ADDR (value_type (value));
1539 }
1540
1541 return value->location.address + value->offset;
1542 }
1543
1544 CORE_ADDR
1545 value_raw_address (const struct value *value)
1546 {
1547 if (value->lval != lval_memory)
1548 return 0;
1549 return value->location.address;
1550 }
1551
1552 void
1553 set_value_address (struct value *value, CORE_ADDR addr)
1554 {
1555 gdb_assert (value->lval == lval_memory);
1556 value->location.address = addr;
1557 }
1558
1559 struct internalvar **
1560 deprecated_value_internalvar_hack (struct value *value)
1561 {
1562 return &value->location.internalvar;
1563 }
1564
1565 struct frame_id *
1566 deprecated_value_next_frame_id_hack (struct value *value)
1567 {
1568 gdb_assert (value->lval == lval_register);
1569 return &value->location.reg.next_frame_id;
1570 }
1571
1572 int *
1573 deprecated_value_regnum_hack (struct value *value)
1574 {
1575 gdb_assert (value->lval == lval_register);
1576 return &value->location.reg.regnum;
1577 }
1578
1579 int
1580 deprecated_value_modifiable (const struct value *value)
1581 {
1582 return value->modifiable;
1583 }
1584
1585 /* Return a mark in the value chain. All values allocated after the
1586 mark is obtained (except for those released) are subject to being freed
1587 if a subsequent value_free_to_mark is passed the mark. */
1588 struct value *
1589 value_mark (void)
1590 {
1591 return all_values;
1592 }
1593
1594 /* Take a reference to VAL. VAL will not be deallocated until all
1595 references are released. */
1596
1597 void
1598 value_incref (struct value *val)
1599 {
1600 val->reference_count++;
1601 }
1602
1603 /* Release a reference to VAL, which was acquired with value_incref.
1604 This function is also called to deallocate values from the value
1605 chain. */
1606
1607 void
1608 value_free (struct value *val)
1609 {
1610 if (val)
1611 {
1612 gdb_assert (val->reference_count > 0);
1613 val->reference_count--;
1614 if (val->reference_count > 0)
1615 return;
1616
1617 /* If there's an associated parent value, drop our reference to
1618 it. */
1619 if (val->parent != NULL)
1620 value_free (val->parent);
1621
1622 if (VALUE_LVAL (val) == lval_computed)
1623 {
1624 const struct lval_funcs *funcs = val->location.computed.funcs;
1625
1626 if (funcs->free_closure)
1627 funcs->free_closure (val);
1628 }
1629 else if (VALUE_LVAL (val) == lval_xcallable)
1630 free_xmethod_worker (val->location.xm_worker);
1631
1632 xfree (val->contents);
1633 VEC_free (range_s, val->unavailable);
1634 }
1635 xfree (val);
1636 }
1637
1638 /* Free all values allocated since MARK was obtained by value_mark
1639 (except for those released). */
1640 void
1641 value_free_to_mark (const struct value *mark)
1642 {
1643 struct value *val;
1644 struct value *next;
1645
1646 for (val = all_values; val && val != mark; val = next)
1647 {
1648 next = val->next;
1649 val->released = 1;
1650 value_free (val);
1651 }
1652 all_values = val;
1653 }
1654
1655 /* Free all the values that have been allocated (except for those released).
1656 Call after each command, successful or not.
1657 In practice this is called before each command, which is sufficient. */
1658
1659 void
1660 free_all_values (void)
1661 {
1662 struct value *val;
1663 struct value *next;
1664
1665 for (val = all_values; val; val = next)
1666 {
1667 next = val->next;
1668 val->released = 1;
1669 value_free (val);
1670 }
1671
1672 all_values = 0;
1673 }
1674
1675 /* Frees all the elements in a chain of values. */
1676
1677 void
1678 free_value_chain (struct value *v)
1679 {
1680 struct value *next;
1681
1682 for (; v; v = next)
1683 {
1684 next = value_next (v);
1685 value_free (v);
1686 }
1687 }
1688
1689 /* Remove VAL from the chain all_values
1690 so it will not be freed automatically. */
1691
1692 void
1693 release_value (struct value *val)
1694 {
1695 struct value *v;
1696
1697 if (all_values == val)
1698 {
1699 all_values = val->next;
1700 val->next = NULL;
1701 val->released = 1;
1702 return;
1703 }
1704
1705 for (v = all_values; v; v = v->next)
1706 {
1707 if (v->next == val)
1708 {
1709 v->next = val->next;
1710 val->next = NULL;
1711 val->released = 1;
1712 break;
1713 }
1714 }
1715 }
1716
1717 /* If the value is not already released, release it.
1718 If the value is already released, increment its reference count.
1719 That is, this function ensures that the value is released from the
1720 value chain and that the caller owns a reference to it. */
1721
1722 void
1723 release_value_or_incref (struct value *val)
1724 {
1725 if (val->released)
1726 value_incref (val);
1727 else
1728 release_value (val);
1729 }
1730
1731 /* Release all values up to mark */
1732 struct value *
1733 value_release_to_mark (const struct value *mark)
1734 {
1735 struct value *val;
1736 struct value *next;
1737
1738 for (val = next = all_values; next; next = next->next)
1739 {
1740 if (next->next == mark)
1741 {
1742 all_values = next->next;
1743 next->next = NULL;
1744 return val;
1745 }
1746 next->released = 1;
1747 }
1748 all_values = 0;
1749 return val;
1750 }
1751
1752 /* Return a copy of the value ARG.
1753 It contains the same contents, for same memory address,
1754 but it's a different block of storage. */
1755
1756 struct value *
1757 value_copy (struct value *arg)
1758 {
1759 struct type *encl_type = value_enclosing_type (arg);
1760 struct value *val;
1761
1762 if (value_lazy (arg))
1763 val = allocate_value_lazy (encl_type);
1764 else
1765 val = allocate_value (encl_type);
1766 val->type = arg->type;
1767 VALUE_LVAL (val) = VALUE_LVAL (arg);
1768 val->location = arg->location;
1769 val->offset = arg->offset;
1770 val->bitpos = arg->bitpos;
1771 val->bitsize = arg->bitsize;
1772 val->lazy = arg->lazy;
1773 val->embedded_offset = value_embedded_offset (arg);
1774 val->pointed_to_offset = arg->pointed_to_offset;
1775 val->modifiable = arg->modifiable;
1776 if (!value_lazy (val))
1777 {
1778 memcpy (value_contents_all_raw (val), value_contents_all_raw (arg),
1779 TYPE_LENGTH (value_enclosing_type (arg)));
1780
1781 }
1782 val->unavailable = VEC_copy (range_s, arg->unavailable);
1783 val->optimized_out = VEC_copy (range_s, arg->optimized_out);
1784 set_value_parent (val, arg->parent);
1785 if (VALUE_LVAL (val) == lval_computed)
1786 {
1787 const struct lval_funcs *funcs = val->location.computed.funcs;
1788
1789 if (funcs->copy_closure)
1790 val->location.computed.closure = funcs->copy_closure (val);
1791 }
1792 return val;
1793 }
1794
1795 /* Return a "const" and/or "volatile" qualified version of the value V.
1796 If CNST is true, then the returned value will be qualified with
1797 "const".
1798 if VOLTL is true, then the returned value will be qualified with
1799 "volatile". */
1800
1801 struct value *
1802 make_cv_value (int cnst, int voltl, struct value *v)
1803 {
1804 struct type *val_type = value_type (v);
1805 struct type *enclosing_type = value_enclosing_type (v);
1806 struct value *cv_val = value_copy (v);
1807
1808 deprecated_set_value_type (cv_val,
1809 make_cv_type (cnst, voltl, val_type, NULL));
1810 set_value_enclosing_type (cv_val,
1811 make_cv_type (cnst, voltl, enclosing_type, NULL));
1812
1813 return cv_val;
1814 }
1815
1816 /* Return a version of ARG that is non-lvalue. */
1817
1818 struct value *
1819 value_non_lval (struct value *arg)
1820 {
1821 if (VALUE_LVAL (arg) != not_lval)
1822 {
1823 struct type *enc_type = value_enclosing_type (arg);
1824 struct value *val = allocate_value (enc_type);
1825
1826 memcpy (value_contents_all_raw (val), value_contents_all (arg),
1827 TYPE_LENGTH (enc_type));
1828 val->type = arg->type;
1829 set_value_embedded_offset (val, value_embedded_offset (arg));
1830 set_value_pointed_to_offset (val, value_pointed_to_offset (arg));
1831 return val;
1832 }
1833 return arg;
1834 }
1835
1836 /* Write contents of V at ADDR and set its lval type to be LVAL_MEMORY. */
1837
1838 void
1839 value_force_lval (struct value *v, CORE_ADDR addr)
1840 {
1841 gdb_assert (VALUE_LVAL (v) == not_lval);
1842
1843 write_memory (addr, value_contents_raw (v), TYPE_LENGTH (value_type (v)));
1844 v->lval = lval_memory;
1845 v->location.address = addr;
1846 }
1847
1848 void
1849 set_value_component_location (struct value *component,
1850 const struct value *whole)
1851 {
1852 struct type *type;
1853
1854 gdb_assert (whole->lval != lval_xcallable);
1855
1856 if (whole->lval == lval_internalvar)
1857 VALUE_LVAL (component) = lval_internalvar_component;
1858 else
1859 VALUE_LVAL (component) = whole->lval;
1860
1861 component->location = whole->location;
1862 if (whole->lval == lval_computed)
1863 {
1864 const struct lval_funcs *funcs = whole->location.computed.funcs;
1865
1866 if (funcs->copy_closure)
1867 component->location.computed.closure = funcs->copy_closure (whole);
1868 }
1869
1870 /* If type has a dynamic resolved location property
1871 update it's value address. */
1872 type = value_type (whole);
1873 if (NULL != TYPE_DATA_LOCATION (type)
1874 && TYPE_DATA_LOCATION_KIND (type) == PROP_CONST)
1875 set_value_address (component, TYPE_DATA_LOCATION_ADDR (type));
1876 }
1877
1878 /* Access to the value history. */
1879
1880 /* Record a new value in the value history.
1881 Returns the absolute history index of the entry. */
1882
1883 int
1884 record_latest_value (struct value *val)
1885 {
1886 int i;
1887
1888 /* We don't want this value to have anything to do with the inferior anymore.
1889 In particular, "set $1 = 50" should not affect the variable from which
1890 the value was taken, and fast watchpoints should be able to assume that
1891 a value on the value history never changes. */
1892 if (value_lazy (val))
1893 value_fetch_lazy (val);
1894 /* We preserve VALUE_LVAL so that the user can find out where it was fetched
1895 from. This is a bit dubious, because then *&$1 does not just return $1
1896 but the current contents of that location. c'est la vie... */
1897 val->modifiable = 0;
1898
1899 /* The value may have already been released, in which case we're adding a
1900 new reference for its entry in the history. That is why we call
1901 release_value_or_incref here instead of release_value. */
1902 release_value_or_incref (val);
1903
1904 /* Here we treat value_history_count as origin-zero
1905 and applying to the value being stored now. */
1906
1907 i = value_history_count % VALUE_HISTORY_CHUNK;
1908 if (i == 0)
1909 {
1910 struct value_history_chunk *newobj = XCNEW (struct value_history_chunk);
1911
1912 newobj->next = value_history_chain;
1913 value_history_chain = newobj;
1914 }
1915
1916 value_history_chain->values[i] = val;
1917
1918 /* Now we regard value_history_count as origin-one
1919 and applying to the value just stored. */
1920
1921 return ++value_history_count;
1922 }
1923
1924 /* Return a copy of the value in the history with sequence number NUM. */
1925
1926 struct value *
1927 access_value_history (int num)
1928 {
1929 struct value_history_chunk *chunk;
1930 int i;
1931 int absnum = num;
1932
1933 if (absnum <= 0)
1934 absnum += value_history_count;
1935
1936 if (absnum <= 0)
1937 {
1938 if (num == 0)
1939 error (_("The history is empty."));
1940 else if (num == 1)
1941 error (_("There is only one value in the history."));
1942 else
1943 error (_("History does not go back to $$%d."), -num);
1944 }
1945 if (absnum > value_history_count)
1946 error (_("History has not yet reached $%d."), absnum);
1947
1948 absnum--;
1949
1950 /* Now absnum is always absolute and origin zero. */
1951
1952 chunk = value_history_chain;
1953 for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK
1954 - absnum / VALUE_HISTORY_CHUNK;
1955 i > 0; i--)
1956 chunk = chunk->next;
1957
1958 return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]);
1959 }
1960
1961 static void
1962 show_values (const char *num_exp, int from_tty)
1963 {
1964 int i;
1965 struct value *val;
1966 static int num = 1;
1967
1968 if (num_exp)
1969 {
1970 /* "show values +" should print from the stored position.
1971 "show values <exp>" should print around value number <exp>. */
1972 if (num_exp[0] != '+' || num_exp[1] != '\0')
1973 num = parse_and_eval_long (num_exp) - 5;
1974 }
1975 else
1976 {
1977 /* "show values" means print the last 10 values. */
1978 num = value_history_count - 9;
1979 }
1980
1981 if (num <= 0)
1982 num = 1;
1983
1984 for (i = num; i < num + 10 && i <= value_history_count; i++)
1985 {
1986 struct value_print_options opts;
1987
1988 val = access_value_history (i);
1989 printf_filtered (("$%d = "), i);
1990 get_user_print_options (&opts);
1991 value_print (val, gdb_stdout, &opts);
1992 printf_filtered (("\n"));
1993 }
1994
1995 /* The next "show values +" should start after what we just printed. */
1996 num += 10;
1997
1998 /* Hitting just return after this command should do the same thing as
1999 "show values +". If num_exp is null, this is unnecessary, since
2000 "show values +" is not useful after "show values". */
2001 if (from_tty && num_exp)
2002 set_repeat_arguments ("+");
2003 }
2004
2005 enum internalvar_kind
2006 {
2007 /* The internal variable is empty. */
2008 INTERNALVAR_VOID,
2009
2010 /* The value of the internal variable is provided directly as
2011 a GDB value object. */
2012 INTERNALVAR_VALUE,
2013
2014 /* A fresh value is computed via a call-back routine on every
2015 access to the internal variable. */
2016 INTERNALVAR_MAKE_VALUE,
2017
2018 /* The internal variable holds a GDB internal convenience function. */
2019 INTERNALVAR_FUNCTION,
2020
2021 /* The variable holds an integer value. */
2022 INTERNALVAR_INTEGER,
2023
2024 /* The variable holds a GDB-provided string. */
2025 INTERNALVAR_STRING,
2026 };
2027
2028 union internalvar_data
2029 {
2030 /* A value object used with INTERNALVAR_VALUE. */
2031 struct value *value;
2032
2033 /* The call-back routine used with INTERNALVAR_MAKE_VALUE. */
2034 struct
2035 {
2036 /* The functions to call. */
2037 const struct internalvar_funcs *functions;
2038
2039 /* The function's user-data. */
2040 void *data;
2041 } make_value;
2042
2043 /* The internal function used with INTERNALVAR_FUNCTION. */
2044 struct
2045 {
2046 struct internal_function *function;
2047 /* True if this is the canonical name for the function. */
2048 int canonical;
2049 } fn;
2050
2051 /* An integer value used with INTERNALVAR_INTEGER. */
2052 struct
2053 {
2054 /* If type is non-NULL, it will be used as the type to generate
2055 a value for this internal variable. If type is NULL, a default
2056 integer type for the architecture is used. */
2057 struct type *type;
2058 LONGEST val;
2059 } integer;
2060
2061 /* A string value used with INTERNALVAR_STRING. */
2062 char *string;
2063 };
2064
2065 /* Internal variables. These are variables within the debugger
2066 that hold values assigned by debugger commands.
2067 The user refers to them with a '$' prefix
2068 that does not appear in the variable names stored internally. */
2069
2070 struct internalvar
2071 {
2072 struct internalvar *next;
2073 char *name;
2074
2075 /* We support various different kinds of content of an internal variable.
2076 enum internalvar_kind specifies the kind, and union internalvar_data
2077 provides the data associated with this particular kind. */
2078
2079 enum internalvar_kind kind;
2080
2081 union internalvar_data u;
2082 };
2083
2084 static struct internalvar *internalvars;
2085
2086 /* If the variable does not already exist create it and give it the
2087 value given. If no value is given then the default is zero. */
2088 static void
2089 init_if_undefined_command (const char* args, int from_tty)
2090 {
2091 struct internalvar* intvar;
2092
2093 /* Parse the expression - this is taken from set_command(). */
2094 expression_up expr = parse_expression (args);
2095
2096 /* Validate the expression.
2097 Was the expression an assignment?
2098 Or even an expression at all? */
2099 if (expr->nelts == 0 || expr->elts[0].opcode != BINOP_ASSIGN)
2100 error (_("Init-if-undefined requires an assignment expression."));
2101
2102 /* Extract the variable from the parsed expression.
2103 In the case of an assign the lvalue will be in elts[1] and elts[2]. */
2104 if (expr->elts[1].opcode != OP_INTERNALVAR)
2105 error (_("The first parameter to init-if-undefined "
2106 "should be a GDB variable."));
2107 intvar = expr->elts[2].internalvar;
2108
2109 /* Only evaluate the expression if the lvalue is void.
2110 This may still fail if the expresssion is invalid. */
2111 if (intvar->kind == INTERNALVAR_VOID)
2112 evaluate_expression (expr.get ());
2113 }
2114
2115
2116 /* Look up an internal variable with name NAME. NAME should not
2117 normally include a dollar sign.
2118
2119 If the specified internal variable does not exist,
2120 the return value is NULL. */
2121
2122 struct internalvar *
2123 lookup_only_internalvar (const char *name)
2124 {
2125 struct internalvar *var;
2126
2127 for (var = internalvars; var; var = var->next)
2128 if (strcmp (var->name, name) == 0)
2129 return var;
2130
2131 return NULL;
2132 }
2133
2134 /* Complete NAME by comparing it to the names of internal
2135 variables. */
2136
2137 void
2138 complete_internalvar (completion_tracker &tracker, const char *name)
2139 {
2140 struct internalvar *var;
2141 int len;
2142
2143 len = strlen (name);
2144
2145 for (var = internalvars; var; var = var->next)
2146 if (strncmp (var->name, name, len) == 0)
2147 {
2148 gdb::unique_xmalloc_ptr<char> copy (xstrdup (var->name));
2149
2150 tracker.add_completion (std::move (copy));
2151 }
2152 }
2153
2154 /* Create an internal variable with name NAME and with a void value.
2155 NAME should not normally include a dollar sign. */
2156
2157 struct internalvar *
2158 create_internalvar (const char *name)
2159 {
2160 struct internalvar *var = XNEW (struct internalvar);
2161
2162 var->name = concat (name, (char *)NULL);
2163 var->kind = INTERNALVAR_VOID;
2164 var->next = internalvars;
2165 internalvars = var;
2166 return var;
2167 }
2168
2169 /* Create an internal variable with name NAME and register FUN as the
2170 function that value_of_internalvar uses to create a value whenever
2171 this variable is referenced. NAME should not normally include a
2172 dollar sign. DATA is passed uninterpreted to FUN when it is
2173 called. CLEANUP, if not NULL, is called when the internal variable
2174 is destroyed. It is passed DATA as its only argument. */
2175
2176 struct internalvar *
2177 create_internalvar_type_lazy (const char *name,
2178 const struct internalvar_funcs *funcs,
2179 void *data)
2180 {
2181 struct internalvar *var = create_internalvar (name);
2182
2183 var->kind = INTERNALVAR_MAKE_VALUE;
2184 var->u.make_value.functions = funcs;
2185 var->u.make_value.data = data;
2186 return var;
2187 }
2188
2189 /* See documentation in value.h. */
2190
2191 int
2192 compile_internalvar_to_ax (struct internalvar *var,
2193 struct agent_expr *expr,
2194 struct axs_value *value)
2195 {
2196 if (var->kind != INTERNALVAR_MAKE_VALUE
2197 || var->u.make_value.functions->compile_to_ax == NULL)
2198 return 0;
2199
2200 var->u.make_value.functions->compile_to_ax (var, expr, value,
2201 var->u.make_value.data);
2202 return 1;
2203 }
2204
2205 /* Look up an internal variable with name NAME. NAME should not
2206 normally include a dollar sign.
2207
2208 If the specified internal variable does not exist,
2209 one is created, with a void value. */
2210
2211 struct internalvar *
2212 lookup_internalvar (const char *name)
2213 {
2214 struct internalvar *var;
2215
2216 var = lookup_only_internalvar (name);
2217 if (var)
2218 return var;
2219
2220 return create_internalvar (name);
2221 }
2222
2223 /* Return current value of internal variable VAR. For variables that
2224 are not inherently typed, use a value type appropriate for GDBARCH. */
2225
2226 struct value *
2227 value_of_internalvar (struct gdbarch *gdbarch, struct internalvar *var)
2228 {
2229 struct value *val;
2230 struct trace_state_variable *tsv;
2231
2232 /* If there is a trace state variable of the same name, assume that
2233 is what we really want to see. */
2234 tsv = find_trace_state_variable (var->name);
2235 if (tsv)
2236 {
2237 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
2238 &(tsv->value));
2239 if (tsv->value_known)
2240 val = value_from_longest (builtin_type (gdbarch)->builtin_int64,
2241 tsv->value);
2242 else
2243 val = allocate_value (builtin_type (gdbarch)->builtin_void);
2244 return val;
2245 }
2246
2247 switch (var->kind)
2248 {
2249 case INTERNALVAR_VOID:
2250 val = allocate_value (builtin_type (gdbarch)->builtin_void);
2251 break;
2252
2253 case INTERNALVAR_FUNCTION:
2254 val = allocate_value (builtin_type (gdbarch)->internal_fn);
2255 break;
2256
2257 case INTERNALVAR_INTEGER:
2258 if (!var->u.integer.type)
2259 val = value_from_longest (builtin_type (gdbarch)->builtin_int,
2260 var->u.integer.val);
2261 else
2262 val = value_from_longest (var->u.integer.type, var->u.integer.val);
2263 break;
2264
2265 case INTERNALVAR_STRING:
2266 val = value_cstring (var->u.string, strlen (var->u.string),
2267 builtin_type (gdbarch)->builtin_char);
2268 break;
2269
2270 case INTERNALVAR_VALUE:
2271 val = value_copy (var->u.value);
2272 if (value_lazy (val))
2273 value_fetch_lazy (val);
2274 break;
2275
2276 case INTERNALVAR_MAKE_VALUE:
2277 val = (*var->u.make_value.functions->make_value) (gdbarch, var,
2278 var->u.make_value.data);
2279 break;
2280
2281 default:
2282 internal_error (__FILE__, __LINE__, _("bad kind"));
2283 }
2284
2285 /* Change the VALUE_LVAL to lval_internalvar so that future operations
2286 on this value go back to affect the original internal variable.
2287
2288 Do not do this for INTERNALVAR_MAKE_VALUE variables, as those have
2289 no underlying modifyable state in the internal variable.
2290
2291 Likewise, if the variable's value is a computed lvalue, we want
2292 references to it to produce another computed lvalue, where
2293 references and assignments actually operate through the
2294 computed value's functions.
2295
2296 This means that internal variables with computed values
2297 behave a little differently from other internal variables:
2298 assignments to them don't just replace the previous value
2299 altogether. At the moment, this seems like the behavior we
2300 want. */
2301
2302 if (var->kind != INTERNALVAR_MAKE_VALUE
2303 && val->lval != lval_computed)
2304 {
2305 VALUE_LVAL (val) = lval_internalvar;
2306 VALUE_INTERNALVAR (val) = var;
2307 }
2308
2309 return val;
2310 }
2311
2312 int
2313 get_internalvar_integer (struct internalvar *var, LONGEST *result)
2314 {
2315 if (var->kind == INTERNALVAR_INTEGER)
2316 {
2317 *result = var->u.integer.val;
2318 return 1;
2319 }
2320
2321 if (var->kind == INTERNALVAR_VALUE)
2322 {
2323 struct type *type = check_typedef (value_type (var->u.value));
2324
2325 if (TYPE_CODE (type) == TYPE_CODE_INT)
2326 {
2327 *result = value_as_long (var->u.value);
2328 return 1;
2329 }
2330 }
2331
2332 return 0;
2333 }
2334
2335 static int
2336 get_internalvar_function (struct internalvar *var,
2337 struct internal_function **result)
2338 {
2339 switch (var->kind)
2340 {
2341 case INTERNALVAR_FUNCTION:
2342 *result = var->u.fn.function;
2343 return 1;
2344
2345 default:
2346 return 0;
2347 }
2348 }
2349
2350 void
2351 set_internalvar_component (struct internalvar *var,
2352 LONGEST offset, LONGEST bitpos,
2353 LONGEST bitsize, struct value *newval)
2354 {
2355 gdb_byte *addr;
2356 struct gdbarch *arch;
2357 int unit_size;
2358
2359 switch (var->kind)
2360 {
2361 case INTERNALVAR_VALUE:
2362 addr = value_contents_writeable (var->u.value);
2363 arch = get_value_arch (var->u.value);
2364 unit_size = gdbarch_addressable_memory_unit_size (arch);
2365
2366 if (bitsize)
2367 modify_field (value_type (var->u.value), addr + offset,
2368 value_as_long (newval), bitpos, bitsize);
2369 else
2370 memcpy (addr + offset * unit_size, value_contents (newval),
2371 TYPE_LENGTH (value_type (newval)));
2372 break;
2373
2374 default:
2375 /* We can never get a component of any other kind. */
2376 internal_error (__FILE__, __LINE__, _("set_internalvar_component"));
2377 }
2378 }
2379
2380 void
2381 set_internalvar (struct internalvar *var, struct value *val)
2382 {
2383 enum internalvar_kind new_kind;
2384 union internalvar_data new_data = { 0 };
2385
2386 if (var->kind == INTERNALVAR_FUNCTION && var->u.fn.canonical)
2387 error (_("Cannot overwrite convenience function %s"), var->name);
2388
2389 /* Prepare new contents. */
2390 switch (TYPE_CODE (check_typedef (value_type (val))))
2391 {
2392 case TYPE_CODE_VOID:
2393 new_kind = INTERNALVAR_VOID;
2394 break;
2395
2396 case TYPE_CODE_INTERNAL_FUNCTION:
2397 gdb_assert (VALUE_LVAL (val) == lval_internalvar);
2398 new_kind = INTERNALVAR_FUNCTION;
2399 get_internalvar_function (VALUE_INTERNALVAR (val),
2400 &new_data.fn.function);
2401 /* Copies created here are never canonical. */
2402 break;
2403
2404 default:
2405 new_kind = INTERNALVAR_VALUE;
2406 new_data.value = value_copy (val);
2407 new_data.value->modifiable = 1;
2408
2409 /* Force the value to be fetched from the target now, to avoid problems
2410 later when this internalvar is referenced and the target is gone or
2411 has changed. */
2412 if (value_lazy (new_data.value))
2413 value_fetch_lazy (new_data.value);
2414
2415 /* Release the value from the value chain to prevent it from being
2416 deleted by free_all_values. From here on this function should not
2417 call error () until new_data is installed into the var->u to avoid
2418 leaking memory. */
2419 release_value (new_data.value);
2420
2421 /* Internal variables which are created from values with a dynamic
2422 location don't need the location property of the origin anymore.
2423 The resolved dynamic location is used prior then any other address
2424 when accessing the value.
2425 If we keep it, we would still refer to the origin value.
2426 Remove the location property in case it exist. */
2427 remove_dyn_prop (DYN_PROP_DATA_LOCATION, value_type (new_data.value));
2428
2429 break;
2430 }
2431
2432 /* Clean up old contents. */
2433 clear_internalvar (var);
2434
2435 /* Switch over. */
2436 var->kind = new_kind;
2437 var->u = new_data;
2438 /* End code which must not call error(). */
2439 }
2440
2441 void
2442 set_internalvar_integer (struct internalvar *var, LONGEST l)
2443 {
2444 /* Clean up old contents. */
2445 clear_internalvar (var);
2446
2447 var->kind = INTERNALVAR_INTEGER;
2448 var->u.integer.type = NULL;
2449 var->u.integer.val = l;
2450 }
2451
2452 void
2453 set_internalvar_string (struct internalvar *var, const char *string)
2454 {
2455 /* Clean up old contents. */
2456 clear_internalvar (var);
2457
2458 var->kind = INTERNALVAR_STRING;
2459 var->u.string = xstrdup (string);
2460 }
2461
2462 static void
2463 set_internalvar_function (struct internalvar *var, struct internal_function *f)
2464 {
2465 /* Clean up old contents. */
2466 clear_internalvar (var);
2467
2468 var->kind = INTERNALVAR_FUNCTION;
2469 var->u.fn.function = f;
2470 var->u.fn.canonical = 1;
2471 /* Variables installed here are always the canonical version. */
2472 }
2473
2474 void
2475 clear_internalvar (struct internalvar *var)
2476 {
2477 /* Clean up old contents. */
2478 switch (var->kind)
2479 {
2480 case INTERNALVAR_VALUE:
2481 value_free (var->u.value);
2482 break;
2483
2484 case INTERNALVAR_STRING:
2485 xfree (var->u.string);
2486 break;
2487
2488 case INTERNALVAR_MAKE_VALUE:
2489 if (var->u.make_value.functions->destroy != NULL)
2490 var->u.make_value.functions->destroy (var->u.make_value.data);
2491 break;
2492
2493 default:
2494 break;
2495 }
2496
2497 /* Reset to void kind. */
2498 var->kind = INTERNALVAR_VOID;
2499 }
2500
2501 char *
2502 internalvar_name (const struct internalvar *var)
2503 {
2504 return var->name;
2505 }
2506
2507 static struct internal_function *
2508 create_internal_function (const char *name,
2509 internal_function_fn handler, void *cookie)
2510 {
2511 struct internal_function *ifn = XNEW (struct internal_function);
2512
2513 ifn->name = xstrdup (name);
2514 ifn->handler = handler;
2515 ifn->cookie = cookie;
2516 return ifn;
2517 }
2518
2519 char *
2520 value_internal_function_name (struct value *val)
2521 {
2522 struct internal_function *ifn;
2523 int result;
2524
2525 gdb_assert (VALUE_LVAL (val) == lval_internalvar);
2526 result = get_internalvar_function (VALUE_INTERNALVAR (val), &ifn);
2527 gdb_assert (result);
2528
2529 return ifn->name;
2530 }
2531
2532 struct value *
2533 call_internal_function (struct gdbarch *gdbarch,
2534 const struct language_defn *language,
2535 struct value *func, int argc, struct value **argv)
2536 {
2537 struct internal_function *ifn;
2538 int result;
2539
2540 gdb_assert (VALUE_LVAL (func) == lval_internalvar);
2541 result = get_internalvar_function (VALUE_INTERNALVAR (func), &ifn);
2542 gdb_assert (result);
2543
2544 return (*ifn->handler) (gdbarch, language, ifn->cookie, argc, argv);
2545 }
2546
2547 /* The 'function' command. This does nothing -- it is just a
2548 placeholder to let "help function NAME" work. This is also used as
2549 the implementation of the sub-command that is created when
2550 registering an internal function. */
2551 static void
2552 function_command (const char *command, int from_tty)
2553 {
2554 /* Do nothing. */
2555 }
2556
2557 /* Clean up if an internal function's command is destroyed. */
2558 static void
2559 function_destroyer (struct cmd_list_element *self, void *ignore)
2560 {
2561 xfree ((char *) self->name);
2562 xfree ((char *) self->doc);
2563 }
2564
2565 /* Add a new internal function. NAME is the name of the function; DOC
2566 is a documentation string describing the function. HANDLER is
2567 called when the function is invoked. COOKIE is an arbitrary
2568 pointer which is passed to HANDLER and is intended for "user
2569 data". */
2570 void
2571 add_internal_function (const char *name, const char *doc,
2572 internal_function_fn handler, void *cookie)
2573 {
2574 struct cmd_list_element *cmd;
2575 struct internal_function *ifn;
2576 struct internalvar *var = lookup_internalvar (name);
2577
2578 ifn = create_internal_function (name, handler, cookie);
2579 set_internalvar_function (var, ifn);
2580
2581 cmd = add_cmd (xstrdup (name), no_class, function_command, (char *) doc,
2582 &functionlist);
2583 cmd->destroyer = function_destroyer;
2584 }
2585
2586 /* Update VALUE before discarding OBJFILE. COPIED_TYPES is used to
2587 prevent cycles / duplicates. */
2588
2589 void
2590 preserve_one_value (struct value *value, struct objfile *objfile,
2591 htab_t copied_types)
2592 {
2593 if (TYPE_OBJFILE (value->type) == objfile)
2594 value->type = copy_type_recursive (objfile, value->type, copied_types);
2595
2596 if (TYPE_OBJFILE (value->enclosing_type) == objfile)
2597 value->enclosing_type = copy_type_recursive (objfile,
2598 value->enclosing_type,
2599 copied_types);
2600 }
2601
2602 /* Likewise for internal variable VAR. */
2603
2604 static void
2605 preserve_one_internalvar (struct internalvar *var, struct objfile *objfile,
2606 htab_t copied_types)
2607 {
2608 switch (var->kind)
2609 {
2610 case INTERNALVAR_INTEGER:
2611 if (var->u.integer.type && TYPE_OBJFILE (var->u.integer.type) == objfile)
2612 var->u.integer.type
2613 = copy_type_recursive (objfile, var->u.integer.type, copied_types);
2614 break;
2615
2616 case INTERNALVAR_VALUE:
2617 preserve_one_value (var->u.value, objfile, copied_types);
2618 break;
2619 }
2620 }
2621
2622 /* Update the internal variables and value history when OBJFILE is
2623 discarded; we must copy the types out of the objfile. New global types
2624 will be created for every convenience variable which currently points to
2625 this objfile's types, and the convenience variables will be adjusted to
2626 use the new global types. */
2627
2628 void
2629 preserve_values (struct objfile *objfile)
2630 {
2631 htab_t copied_types;
2632 struct value_history_chunk *cur;
2633 struct internalvar *var;
2634 int i;
2635
2636 /* Create the hash table. We allocate on the objfile's obstack, since
2637 it is soon to be deleted. */
2638 copied_types = create_copied_types_hash (objfile);
2639
2640 for (cur = value_history_chain; cur; cur = cur->next)
2641 for (i = 0; i < VALUE_HISTORY_CHUNK; i++)
2642 if (cur->values[i])
2643 preserve_one_value (cur->values[i], objfile, copied_types);
2644
2645 for (var = internalvars; var; var = var->next)
2646 preserve_one_internalvar (var, objfile, copied_types);
2647
2648 preserve_ext_lang_values (objfile, copied_types);
2649
2650 htab_delete (copied_types);
2651 }
2652
2653 static void
2654 show_convenience (const char *ignore, int from_tty)
2655 {
2656 struct gdbarch *gdbarch = get_current_arch ();
2657 struct internalvar *var;
2658 int varseen = 0;
2659 struct value_print_options opts;
2660
2661 get_user_print_options (&opts);
2662 for (var = internalvars; var; var = var->next)
2663 {
2664
2665 if (!varseen)
2666 {
2667 varseen = 1;
2668 }
2669 printf_filtered (("$%s = "), var->name);
2670
2671 TRY
2672 {
2673 struct value *val;
2674
2675 val = value_of_internalvar (gdbarch, var);
2676 value_print (val, gdb_stdout, &opts);
2677 }
2678 CATCH (ex, RETURN_MASK_ERROR)
2679 {
2680 fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
2681 }
2682 END_CATCH
2683
2684 printf_filtered (("\n"));
2685 }
2686 if (!varseen)
2687 {
2688 /* This text does not mention convenience functions on purpose.
2689 The user can't create them except via Python, and if Python support
2690 is installed this message will never be printed ($_streq will
2691 exist). */
2692 printf_unfiltered (_("No debugger convenience variables now defined.\n"
2693 "Convenience variables have "
2694 "names starting with \"$\";\n"
2695 "use \"set\" as in \"set "
2696 "$foo = 5\" to define them.\n"));
2697 }
2698 }
2699
2700 /* Return the TYPE_CODE_XMETHOD value corresponding to WORKER. */
2701
2702 struct value *
2703 value_of_xmethod (struct xmethod_worker *worker)
2704 {
2705 if (worker->value == NULL)
2706 {
2707 struct value *v;
2708
2709 v = allocate_value (builtin_type (target_gdbarch ())->xmethod);
2710 v->lval = lval_xcallable;
2711 v->location.xm_worker = worker;
2712 v->modifiable = 0;
2713 worker->value = v;
2714 }
2715
2716 return worker->value;
2717 }
2718
2719 /* Return the type of the result of TYPE_CODE_XMETHOD value METHOD. */
2720
2721 struct type *
2722 result_type_of_xmethod (struct value *method, int argc, struct value **argv)
2723 {
2724 gdb_assert (TYPE_CODE (value_type (method)) == TYPE_CODE_XMETHOD
2725 && method->lval == lval_xcallable && argc > 0);
2726
2727 return get_xmethod_result_type (method->location.xm_worker,
2728 argv[0], argv + 1, argc - 1);
2729 }
2730
2731 /* Call the xmethod corresponding to the TYPE_CODE_XMETHOD value METHOD. */
2732
2733 struct value *
2734 call_xmethod (struct value *method, int argc, struct value **argv)
2735 {
2736 gdb_assert (TYPE_CODE (value_type (method)) == TYPE_CODE_XMETHOD
2737 && method->lval == lval_xcallable && argc > 0);
2738
2739 return invoke_xmethod (method->location.xm_worker,
2740 argv[0], argv + 1, argc - 1);
2741 }
2742
2743 /* Extract a value as a C number (either long or double).
2744 Knows how to convert fixed values to double, or
2745 floating values to long.
2746 Does not deallocate the value. */
2747
2748 LONGEST
2749 value_as_long (struct value *val)
2750 {
2751 /* This coerces arrays and functions, which is necessary (e.g.
2752 in disassemble_command). It also dereferences references, which
2753 I suspect is the most logical thing to do. */
2754 val = coerce_array (val);
2755 return unpack_long (value_type (val), value_contents (val));
2756 }
2757
2758 /* Extract a value as a C pointer. Does not deallocate the value.
2759 Note that val's type may not actually be a pointer; value_as_long
2760 handles all the cases. */
2761 CORE_ADDR
2762 value_as_address (struct value *val)
2763 {
2764 struct gdbarch *gdbarch = get_type_arch (value_type (val));
2765
2766 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
2767 whether we want this to be true eventually. */
2768 #if 0
2769 /* gdbarch_addr_bits_remove is wrong if we are being called for a
2770 non-address (e.g. argument to "signal", "info break", etc.), or
2771 for pointers to char, in which the low bits *are* significant. */
2772 return gdbarch_addr_bits_remove (gdbarch, value_as_long (val));
2773 #else
2774
2775 /* There are several targets (IA-64, PowerPC, and others) which
2776 don't represent pointers to functions as simply the address of
2777 the function's entry point. For example, on the IA-64, a
2778 function pointer points to a two-word descriptor, generated by
2779 the linker, which contains the function's entry point, and the
2780 value the IA-64 "global pointer" register should have --- to
2781 support position-independent code. The linker generates
2782 descriptors only for those functions whose addresses are taken.
2783
2784 On such targets, it's difficult for GDB to convert an arbitrary
2785 function address into a function pointer; it has to either find
2786 an existing descriptor for that function, or call malloc and
2787 build its own. On some targets, it is impossible for GDB to
2788 build a descriptor at all: the descriptor must contain a jump
2789 instruction; data memory cannot be executed; and code memory
2790 cannot be modified.
2791
2792 Upon entry to this function, if VAL is a value of type `function'
2793 (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
2794 value_address (val) is the address of the function. This is what
2795 you'll get if you evaluate an expression like `main'. The call
2796 to COERCE_ARRAY below actually does all the usual unary
2797 conversions, which includes converting values of type `function'
2798 to `pointer to function'. This is the challenging conversion
2799 discussed above. Then, `unpack_long' will convert that pointer
2800 back into an address.
2801
2802 So, suppose the user types `disassemble foo' on an architecture
2803 with a strange function pointer representation, on which GDB
2804 cannot build its own descriptors, and suppose further that `foo'
2805 has no linker-built descriptor. The address->pointer conversion
2806 will signal an error and prevent the command from running, even
2807 though the next step would have been to convert the pointer
2808 directly back into the same address.
2809
2810 The following shortcut avoids this whole mess. If VAL is a
2811 function, just return its address directly. */
2812 if (TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
2813 || TYPE_CODE (value_type (val)) == TYPE_CODE_METHOD)
2814 return value_address (val);
2815
2816 val = coerce_array (val);
2817
2818 /* Some architectures (e.g. Harvard), map instruction and data
2819 addresses onto a single large unified address space. For
2820 instance: An architecture may consider a large integer in the
2821 range 0x10000000 .. 0x1000ffff to already represent a data
2822 addresses (hence not need a pointer to address conversion) while
2823 a small integer would still need to be converted integer to
2824 pointer to address. Just assume such architectures handle all
2825 integer conversions in a single function. */
2826
2827 /* JimB writes:
2828
2829 I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we
2830 must admonish GDB hackers to make sure its behavior matches the
2831 compiler's, whenever possible.
2832
2833 In general, I think GDB should evaluate expressions the same way
2834 the compiler does. When the user copies an expression out of
2835 their source code and hands it to a `print' command, they should
2836 get the same value the compiler would have computed. Any
2837 deviation from this rule can cause major confusion and annoyance,
2838 and needs to be justified carefully. In other words, GDB doesn't
2839 really have the freedom to do these conversions in clever and
2840 useful ways.
2841
2842 AndrewC pointed out that users aren't complaining about how GDB
2843 casts integers to pointers; they are complaining that they can't
2844 take an address from a disassembly listing and give it to `x/i'.
2845 This is certainly important.
2846
2847 Adding an architecture method like integer_to_address() certainly
2848 makes it possible for GDB to "get it right" in all circumstances
2849 --- the target has complete control over how things get done, so
2850 people can Do The Right Thing for their target without breaking
2851 anyone else. The standard doesn't specify how integers get
2852 converted to pointers; usually, the ABI doesn't either, but
2853 ABI-specific code is a more reasonable place to handle it. */
2854
2855 if (TYPE_CODE (value_type (val)) != TYPE_CODE_PTR
2856 && !TYPE_IS_REFERENCE (value_type (val))
2857 && gdbarch_integer_to_address_p (gdbarch))
2858 return gdbarch_integer_to_address (gdbarch, value_type (val),
2859 value_contents (val));
2860
2861 return unpack_long (value_type (val), value_contents (val));
2862 #endif
2863 }
2864
2865 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
2866 as a long, or as a double, assuming the raw data is described
2867 by type TYPE. Knows how to convert different sizes of values
2868 and can convert between fixed and floating point. We don't assume
2869 any alignment for the raw data. Return value is in host byte order.
2870
2871 If you want functions and arrays to be coerced to pointers, and
2872 references to be dereferenced, call value_as_long() instead.
2873
2874 C++: It is assumed that the front-end has taken care of
2875 all matters concerning pointers to members. A pointer
2876 to member which reaches here is considered to be equivalent
2877 to an INT (or some size). After all, it is only an offset. */
2878
2879 LONGEST
2880 unpack_long (struct type *type, const gdb_byte *valaddr)
2881 {
2882 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
2883 enum type_code code = TYPE_CODE (type);
2884 int len = TYPE_LENGTH (type);
2885 int nosign = TYPE_UNSIGNED (type);
2886
2887 switch (code)
2888 {
2889 case TYPE_CODE_TYPEDEF:
2890 return unpack_long (check_typedef (type), valaddr);
2891 case TYPE_CODE_ENUM:
2892 case TYPE_CODE_FLAGS:
2893 case TYPE_CODE_BOOL:
2894 case TYPE_CODE_INT:
2895 case TYPE_CODE_CHAR:
2896 case TYPE_CODE_RANGE:
2897 case TYPE_CODE_MEMBERPTR:
2898 if (nosign)
2899 return extract_unsigned_integer (valaddr, len, byte_order);
2900 else
2901 return extract_signed_integer (valaddr, len, byte_order);
2902
2903 case TYPE_CODE_FLT:
2904 case TYPE_CODE_DECFLOAT:
2905 return target_float_to_longest (valaddr, type);
2906
2907 case TYPE_CODE_PTR:
2908 case TYPE_CODE_REF:
2909 case TYPE_CODE_RVALUE_REF:
2910 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
2911 whether we want this to be true eventually. */
2912 return extract_typed_address (valaddr, type);
2913
2914 default:
2915 error (_("Value can't be converted to integer."));
2916 }
2917 return 0; /* Placate lint. */
2918 }
2919
2920 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
2921 as a CORE_ADDR, assuming the raw data is described by type TYPE.
2922 We don't assume any alignment for the raw data. Return value is in
2923 host byte order.
2924
2925 If you want functions and arrays to be coerced to pointers, and
2926 references to be dereferenced, call value_as_address() instead.
2927
2928 C++: It is assumed that the front-end has taken care of
2929 all matters concerning pointers to members. A pointer
2930 to member which reaches here is considered to be equivalent
2931 to an INT (or some size). After all, it is only an offset. */
2932
2933 CORE_ADDR
2934 unpack_pointer (struct type *type, const gdb_byte *valaddr)
2935 {
2936 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
2937 whether we want this to be true eventually. */
2938 return unpack_long (type, valaddr);
2939 }
2940
2941 bool
2942 is_floating_value (struct value *val)
2943 {
2944 struct type *type = check_typedef (value_type (val));
2945
2946 if (is_floating_type (type))
2947 {
2948 if (!target_float_is_valid (value_contents (val), type))
2949 error (_("Invalid floating value found in program."));
2950 return true;
2951 }
2952
2953 return false;
2954 }
2955
2956
2957 /* Get the value of the FIELDNO'th field (which must be static) of
2958 TYPE. */
2959
2960 struct value *
2961 value_static_field (struct type *type, int fieldno)
2962 {
2963 struct value *retval;
2964
2965 switch (TYPE_FIELD_LOC_KIND (type, fieldno))
2966 {
2967 case FIELD_LOC_KIND_PHYSADDR:
2968 retval = value_at_lazy (TYPE_FIELD_TYPE (type, fieldno),
2969 TYPE_FIELD_STATIC_PHYSADDR (type, fieldno));
2970 break;
2971 case FIELD_LOC_KIND_PHYSNAME:
2972 {
2973 const char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
2974 /* TYPE_FIELD_NAME (type, fieldno); */
2975 struct block_symbol sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0);
2976
2977 if (sym.symbol == NULL)
2978 {
2979 /* With some compilers, e.g. HP aCC, static data members are
2980 reported as non-debuggable symbols. */
2981 struct bound_minimal_symbol msym
2982 = lookup_minimal_symbol (phys_name, NULL, NULL);
2983
2984 if (!msym.minsym)
2985 return allocate_optimized_out_value (type);
2986 else
2987 {
2988 retval = value_at_lazy (TYPE_FIELD_TYPE (type, fieldno),
2989 BMSYMBOL_VALUE_ADDRESS (msym));
2990 }
2991 }
2992 else
2993 retval = value_of_variable (sym.symbol, sym.block);
2994 break;
2995 }
2996 default:
2997 gdb_assert_not_reached ("unexpected field location kind");
2998 }
2999
3000 return retval;
3001 }
3002
3003 /* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.
3004 You have to be careful here, since the size of the data area for the value
3005 is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger
3006 than the old enclosing type, you have to allocate more space for the
3007 data. */
3008
3009 void
3010 set_value_enclosing_type (struct value *val, struct type *new_encl_type)
3011 {
3012 if (TYPE_LENGTH (new_encl_type) > TYPE_LENGTH (value_enclosing_type (val)))
3013 {
3014 check_type_length_before_alloc (new_encl_type);
3015 val->contents
3016 = (gdb_byte *) xrealloc (val->contents, TYPE_LENGTH (new_encl_type));
3017 }
3018
3019 val->enclosing_type = new_encl_type;
3020 }
3021
3022 /* Given a value ARG1 (offset by OFFSET bytes)
3023 of a struct or union type ARG_TYPE,
3024 extract and return the value of one of its (non-static) fields.
3025 FIELDNO says which field. */
3026
3027 struct value *
3028 value_primitive_field (struct value *arg1, LONGEST offset,
3029 int fieldno, struct type *arg_type)
3030 {
3031 struct value *v;
3032 struct type *type;
3033 struct gdbarch *arch = get_value_arch (arg1);
3034 int unit_size = gdbarch_addressable_memory_unit_size (arch);
3035
3036 arg_type = check_typedef (arg_type);
3037 type = TYPE_FIELD_TYPE (arg_type, fieldno);
3038
3039 /* Call check_typedef on our type to make sure that, if TYPE
3040 is a TYPE_CODE_TYPEDEF, its length is set to the length
3041 of the target type instead of zero. However, we do not
3042 replace the typedef type by the target type, because we want
3043 to keep the typedef in order to be able to print the type
3044 description correctly. */
3045 check_typedef (type);
3046
3047 if (TYPE_FIELD_BITSIZE (arg_type, fieldno))
3048 {
3049 /* Handle packed fields.
3050
3051 Create a new value for the bitfield, with bitpos and bitsize
3052 set. If possible, arrange offset and bitpos so that we can
3053 do a single aligned read of the size of the containing type.
3054 Otherwise, adjust offset to the byte containing the first
3055 bit. Assume that the address, offset, and embedded offset
3056 are sufficiently aligned. */
3057
3058 LONGEST bitpos = TYPE_FIELD_BITPOS (arg_type, fieldno);
3059 LONGEST container_bitsize = TYPE_LENGTH (type) * 8;
3060
3061 v = allocate_value_lazy (type);
3062 v->bitsize = TYPE_FIELD_BITSIZE (arg_type, fieldno);
3063 if ((bitpos % container_bitsize) + v->bitsize <= container_bitsize
3064 && TYPE_LENGTH (type) <= (int) sizeof (LONGEST))
3065 v->bitpos = bitpos % container_bitsize;
3066 else
3067 v->bitpos = bitpos % 8;
3068 v->offset = (value_embedded_offset (arg1)
3069 + offset
3070 + (bitpos - v->bitpos) / 8);
3071 set_value_parent (v, arg1);
3072 if (!value_lazy (arg1))
3073 value_fetch_lazy (v);
3074 }
3075 else if (fieldno < TYPE_N_BASECLASSES (arg_type))
3076 {
3077 /* This field is actually a base subobject, so preserve the
3078 entire object's contents for later references to virtual
3079 bases, etc. */
3080 LONGEST boffset;
3081
3082 /* Lazy register values with offsets are not supported. */
3083 if (VALUE_LVAL (arg1) == lval_register && value_lazy (arg1))
3084 value_fetch_lazy (arg1);
3085
3086 /* We special case virtual inheritance here because this
3087 requires access to the contents, which we would rather avoid
3088 for references to ordinary fields of unavailable values. */
3089 if (BASETYPE_VIA_VIRTUAL (arg_type, fieldno))
3090 boffset = baseclass_offset (arg_type, fieldno,
3091 value_contents (arg1),
3092 value_embedded_offset (arg1),
3093 value_address (arg1),
3094 arg1);
3095 else
3096 boffset = TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
3097
3098 if (value_lazy (arg1))
3099 v = allocate_value_lazy (value_enclosing_type (arg1));
3100 else
3101 {
3102 v = allocate_value (value_enclosing_type (arg1));
3103 value_contents_copy_raw (v, 0, arg1, 0,
3104 TYPE_LENGTH (value_enclosing_type (arg1)));
3105 }
3106 v->type = type;
3107 v->offset = value_offset (arg1);
3108 v->embedded_offset = offset + value_embedded_offset (arg1) + boffset;
3109 }
3110 else if (NULL != TYPE_DATA_LOCATION (type))
3111 {
3112 /* Field is a dynamic data member. */
3113
3114 gdb_assert (0 == offset);
3115 /* We expect an already resolved data location. */
3116 gdb_assert (PROP_CONST == TYPE_DATA_LOCATION_KIND (type));
3117 /* For dynamic data types defer memory allocation
3118 until we actual access the value. */
3119 v = allocate_value_lazy (type);
3120 }
3121 else
3122 {
3123 /* Plain old data member */
3124 offset += (TYPE_FIELD_BITPOS (arg_type, fieldno)
3125 / (HOST_CHAR_BIT * unit_size));
3126
3127 /* Lazy register values with offsets are not supported. */
3128 if (VALUE_LVAL (arg1) == lval_register && value_lazy (arg1))
3129 value_fetch_lazy (arg1);
3130
3131 if (value_lazy (arg1))
3132 v = allocate_value_lazy (type);
3133 else
3134 {
3135 v = allocate_value (type);
3136 value_contents_copy_raw (v, value_embedded_offset (v),
3137 arg1, value_embedded_offset (arg1) + offset,
3138 type_length_units (type));
3139 }
3140 v->offset = (value_offset (arg1) + offset
3141 + value_embedded_offset (arg1));
3142 }
3143 set_value_component_location (v, arg1);
3144 return v;
3145 }
3146
3147 /* Given a value ARG1 of a struct or union type,
3148 extract and return the value of one of its (non-static) fields.
3149 FIELDNO says which field. */
3150
3151 struct value *
3152 value_field (struct value *arg1, int fieldno)
3153 {
3154 return value_primitive_field (arg1, 0, fieldno, value_type (arg1));
3155 }
3156
3157 /* Return a non-virtual function as a value.
3158 F is the list of member functions which contains the desired method.
3159 J is an index into F which provides the desired method.
3160
3161 We only use the symbol for its address, so be happy with either a
3162 full symbol or a minimal symbol. */
3163
3164 struct value *
3165 value_fn_field (struct value **arg1p, struct fn_field *f,
3166 int j, struct type *type,
3167 LONGEST offset)
3168 {
3169 struct value *v;
3170 struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
3171 const char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
3172 struct symbol *sym;
3173 struct bound_minimal_symbol msym;
3174
3175 sym = lookup_symbol (physname, 0, VAR_DOMAIN, 0).symbol;
3176 if (sym != NULL)
3177 {
3178 memset (&msym, 0, sizeof (msym));
3179 }
3180 else
3181 {
3182 gdb_assert (sym == NULL);
3183 msym = lookup_bound_minimal_symbol (physname);
3184 if (msym.minsym == NULL)
3185 return NULL;
3186 }
3187
3188 v = allocate_value (ftype);
3189 VALUE_LVAL (v) = lval_memory;
3190 if (sym)
3191 {
3192 set_value_address (v, BLOCK_START (SYMBOL_BLOCK_VALUE (sym)));
3193 }
3194 else
3195 {
3196 /* The minimal symbol might point to a function descriptor;
3197 resolve it to the actual code address instead. */
3198 struct objfile *objfile = msym.objfile;
3199 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3200
3201 set_value_address (v,
3202 gdbarch_convert_from_func_ptr_addr
3203 (gdbarch, BMSYMBOL_VALUE_ADDRESS (msym), &current_target));
3204 }
3205
3206 if (arg1p)
3207 {
3208 if (type != value_type (*arg1p))
3209 *arg1p = value_ind (value_cast (lookup_pointer_type (type),
3210 value_addr (*arg1p)));
3211
3212 /* Move the `this' pointer according to the offset.
3213 VALUE_OFFSET (*arg1p) += offset; */
3214 }
3215
3216 return v;
3217 }
3218
3219
3220
3221 /* Unpack a bitfield of the specified FIELD_TYPE, from the object at
3222 VALADDR, and store the result in *RESULT.
3223 The bitfield starts at BITPOS bits and contains BITSIZE bits.
3224
3225 Extracting bits depends on endianness of the machine. Compute the
3226 number of least significant bits to discard. For big endian machines,
3227 we compute the total number of bits in the anonymous object, subtract
3228 off the bit count from the MSB of the object to the MSB of the
3229 bitfield, then the size of the bitfield, which leaves the LSB discard
3230 count. For little endian machines, the discard count is simply the
3231 number of bits from the LSB of the anonymous object to the LSB of the
3232 bitfield.
3233
3234 If the field is signed, we also do sign extension. */
3235
3236 static LONGEST
3237 unpack_bits_as_long (struct type *field_type, const gdb_byte *valaddr,
3238 LONGEST bitpos, LONGEST bitsize)
3239 {
3240 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (field_type));
3241 ULONGEST val;
3242 ULONGEST valmask;
3243 int lsbcount;
3244 LONGEST bytes_read;
3245 LONGEST read_offset;
3246
3247 /* Read the minimum number of bytes required; there may not be
3248 enough bytes to read an entire ULONGEST. */
3249 field_type = check_typedef (field_type);
3250 if (bitsize)
3251 bytes_read = ((bitpos % 8) + bitsize + 7) / 8;
3252 else
3253 bytes_read = TYPE_LENGTH (field_type);
3254
3255 read_offset = bitpos / 8;
3256
3257 val = extract_unsigned_integer (valaddr + read_offset,
3258 bytes_read, byte_order);
3259
3260 /* Extract bits. See comment above. */
3261
3262 if (gdbarch_bits_big_endian (get_type_arch (field_type)))
3263 lsbcount = (bytes_read * 8 - bitpos % 8 - bitsize);
3264 else
3265 lsbcount = (bitpos % 8);
3266 val >>= lsbcount;
3267
3268 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
3269 If the field is signed, and is negative, then sign extend. */
3270
3271 if ((bitsize > 0) && (bitsize < 8 * (int) sizeof (val)))
3272 {
3273 valmask = (((ULONGEST) 1) << bitsize) - 1;
3274 val &= valmask;
3275 if (!TYPE_UNSIGNED (field_type))
3276 {
3277 if (val & (valmask ^ (valmask >> 1)))
3278 {
3279 val |= ~valmask;
3280 }
3281 }
3282 }
3283
3284 return val;
3285 }
3286
3287 /* Unpack a field FIELDNO of the specified TYPE, from the object at
3288 VALADDR + EMBEDDED_OFFSET. VALADDR points to the contents of
3289 ORIGINAL_VALUE, which must not be NULL. See
3290 unpack_value_bits_as_long for more details. */
3291
3292 int
3293 unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr,
3294 LONGEST embedded_offset, int fieldno,
3295 const struct value *val, LONGEST *result)
3296 {
3297 int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
3298 int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
3299 struct type *field_type = TYPE_FIELD_TYPE (type, fieldno);
3300 int bit_offset;
3301
3302 gdb_assert (val != NULL);
3303
3304 bit_offset = embedded_offset * TARGET_CHAR_BIT + bitpos;
3305 if (value_bits_any_optimized_out (val, bit_offset, bitsize)
3306 || !value_bits_available (val, bit_offset, bitsize))
3307 return 0;
3308
3309 *result = unpack_bits_as_long (field_type, valaddr + embedded_offset,
3310 bitpos, bitsize);
3311 return 1;
3312 }
3313
3314 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous
3315 object at VALADDR. See unpack_bits_as_long for more details. */
3316
3317 LONGEST
3318 unpack_field_as_long (struct type *type, const gdb_byte *valaddr, int fieldno)
3319 {
3320 int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
3321 int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
3322 struct type *field_type = TYPE_FIELD_TYPE (type, fieldno);
3323
3324 return unpack_bits_as_long (field_type, valaddr, bitpos, bitsize);
3325 }
3326
3327 /* Unpack a bitfield of BITSIZE bits found at BITPOS in the object at
3328 VALADDR + EMBEDDEDOFFSET that has the type of DEST_VAL and store
3329 the contents in DEST_VAL, zero or sign extending if the type of
3330 DEST_VAL is wider than BITSIZE. VALADDR points to the contents of
3331 VAL. If the VAL's contents required to extract the bitfield from
3332 are unavailable/optimized out, DEST_VAL is correspondingly
3333 marked unavailable/optimized out. */
3334
3335 void
3336 unpack_value_bitfield (struct value *dest_val,
3337 LONGEST bitpos, LONGEST bitsize,
3338 const gdb_byte *valaddr, LONGEST embedded_offset,
3339 const struct value *val)
3340 {
3341 enum bfd_endian byte_order;
3342 int src_bit_offset;
3343 int dst_bit_offset;
3344 struct type *field_type = value_type (dest_val);
3345
3346 byte_order = gdbarch_byte_order (get_type_arch (field_type));
3347
3348 /* First, unpack and sign extend the bitfield as if it was wholly
3349 valid. Optimized out/unavailable bits are read as zero, but
3350 that's OK, as they'll end up marked below. If the VAL is
3351 wholly-invalid we may have skipped allocating its contents,
3352 though. See allocate_optimized_out_value. */
3353 if (valaddr != NULL)
3354 {
3355 LONGEST num;
3356
3357 num = unpack_bits_as_long (field_type, valaddr + embedded_offset,
3358 bitpos, bitsize);
3359 store_signed_integer (value_contents_raw (dest_val),
3360 TYPE_LENGTH (field_type), byte_order, num);
3361 }
3362
3363 /* Now copy the optimized out / unavailability ranges to the right
3364 bits. */
3365 src_bit_offset = embedded_offset * TARGET_CHAR_BIT + bitpos;
3366 if (byte_order == BFD_ENDIAN_BIG)
3367 dst_bit_offset = TYPE_LENGTH (field_type) * TARGET_CHAR_BIT - bitsize;
3368 else
3369 dst_bit_offset = 0;
3370 value_ranges_copy_adjusted (dest_val, dst_bit_offset,
3371 val, src_bit_offset, bitsize);
3372 }
3373
3374 /* Return a new value with type TYPE, which is FIELDNO field of the
3375 object at VALADDR + EMBEDDEDOFFSET. VALADDR points to the contents
3376 of VAL. If the VAL's contents required to extract the bitfield
3377 from are unavailable/optimized out, the new value is
3378 correspondingly marked unavailable/optimized out. */
3379
3380 struct value *
3381 value_field_bitfield (struct type *type, int fieldno,
3382 const gdb_byte *valaddr,
3383 LONGEST embedded_offset, const struct value *val)
3384 {
3385 int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
3386 int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
3387 struct value *res_val = allocate_value (TYPE_FIELD_TYPE (type, fieldno));
3388
3389 unpack_value_bitfield (res_val, bitpos, bitsize,
3390 valaddr, embedded_offset, val);
3391
3392 return res_val;
3393 }
3394
3395 /* Modify the value of a bitfield. ADDR points to a block of memory in
3396 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
3397 is the desired value of the field, in host byte order. BITPOS and BITSIZE
3398 indicate which bits (in target bit order) comprise the bitfield.
3399 Requires 0 < BITSIZE <= lbits, 0 <= BITPOS % 8 + BITSIZE <= lbits, and
3400 0 <= BITPOS, where lbits is the size of a LONGEST in bits. */
3401
3402 void
3403 modify_field (struct type *type, gdb_byte *addr,
3404 LONGEST fieldval, LONGEST bitpos, LONGEST bitsize)
3405 {
3406 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
3407 ULONGEST oword;
3408 ULONGEST mask = (ULONGEST) -1 >> (8 * sizeof (ULONGEST) - bitsize);
3409 LONGEST bytesize;
3410
3411 /* Normalize BITPOS. */
3412 addr += bitpos / 8;
3413 bitpos %= 8;
3414
3415 /* If a negative fieldval fits in the field in question, chop
3416 off the sign extension bits. */
3417 if ((~fieldval & ~(mask >> 1)) == 0)
3418 fieldval &= mask;
3419
3420 /* Warn if value is too big to fit in the field in question. */
3421 if (0 != (fieldval & ~mask))
3422 {
3423 /* FIXME: would like to include fieldval in the message, but
3424 we don't have a sprintf_longest. */
3425 warning (_("Value does not fit in %s bits."), plongest (bitsize));
3426
3427 /* Truncate it, otherwise adjoining fields may be corrupted. */
3428 fieldval &= mask;
3429 }
3430
3431 /* Ensure no bytes outside of the modified ones get accessed as it may cause
3432 false valgrind reports. */
3433
3434 bytesize = (bitpos + bitsize + 7) / 8;
3435 oword = extract_unsigned_integer (addr, bytesize, byte_order);
3436
3437 /* Shifting for bit field depends on endianness of the target machine. */
3438 if (gdbarch_bits_big_endian (get_type_arch (type)))
3439 bitpos = bytesize * 8 - bitpos - bitsize;
3440
3441 oword &= ~(mask << bitpos);
3442 oword |= fieldval << bitpos;
3443
3444 store_unsigned_integer (addr, bytesize, byte_order, oword);
3445 }
3446
3447 /* Pack NUM into BUF using a target format of TYPE. */
3448
3449 void
3450 pack_long (gdb_byte *buf, struct type *type, LONGEST num)
3451 {
3452 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
3453 LONGEST len;
3454
3455 type = check_typedef (type);
3456 len = TYPE_LENGTH (type);
3457
3458 switch (TYPE_CODE (type))
3459 {
3460 case TYPE_CODE_INT:
3461 case TYPE_CODE_CHAR:
3462 case TYPE_CODE_ENUM:
3463 case TYPE_CODE_FLAGS:
3464 case TYPE_CODE_BOOL:
3465 case TYPE_CODE_RANGE:
3466 case TYPE_CODE_MEMBERPTR:
3467 store_signed_integer (buf, len, byte_order, num);
3468 break;
3469
3470 case TYPE_CODE_REF:
3471 case TYPE_CODE_RVALUE_REF:
3472 case TYPE_CODE_PTR:
3473 store_typed_address (buf, type, (CORE_ADDR) num);
3474 break;
3475
3476 case TYPE_CODE_FLT:
3477 case TYPE_CODE_DECFLOAT:
3478 target_float_from_longest (buf, type, num);
3479 break;
3480
3481 default:
3482 error (_("Unexpected type (%d) encountered for integer constant."),
3483 TYPE_CODE (type));
3484 }
3485 }
3486
3487
3488 /* Pack NUM into BUF using a target format of TYPE. */
3489
3490 static void
3491 pack_unsigned_long (gdb_byte *buf, struct type *type, ULONGEST num)
3492 {
3493 LONGEST len;
3494 enum bfd_endian byte_order;
3495
3496 type = check_typedef (type);
3497 len = TYPE_LENGTH (type);
3498 byte_order = gdbarch_byte_order (get_type_arch (type));
3499
3500 switch (TYPE_CODE (type))
3501 {
3502 case TYPE_CODE_INT:
3503 case TYPE_CODE_CHAR:
3504 case TYPE_CODE_ENUM:
3505 case TYPE_CODE_FLAGS:
3506 case TYPE_CODE_BOOL:
3507 case TYPE_CODE_RANGE:
3508 case TYPE_CODE_MEMBERPTR:
3509 store_unsigned_integer (buf, len, byte_order, num);
3510 break;
3511
3512 case TYPE_CODE_REF:
3513 case TYPE_CODE_RVALUE_REF:
3514 case TYPE_CODE_PTR:
3515 store_typed_address (buf, type, (CORE_ADDR) num);
3516 break;
3517
3518 case TYPE_CODE_FLT:
3519 case TYPE_CODE_DECFLOAT:
3520 target_float_from_ulongest (buf, type, num);
3521 break;
3522
3523 default:
3524 error (_("Unexpected type (%d) encountered "
3525 "for unsigned integer constant."),
3526 TYPE_CODE (type));
3527 }
3528 }
3529
3530
3531 /* Convert C numbers into newly allocated values. */
3532
3533 struct value *
3534 value_from_longest (struct type *type, LONGEST num)
3535 {
3536 struct value *val = allocate_value (type);
3537
3538 pack_long (value_contents_raw (val), type, num);
3539 return val;
3540 }
3541
3542
3543 /* Convert C unsigned numbers into newly allocated values. */
3544
3545 struct value *
3546 value_from_ulongest (struct type *type, ULONGEST num)
3547 {
3548 struct value *val = allocate_value (type);
3549
3550 pack_unsigned_long (value_contents_raw (val), type, num);
3551
3552 return val;
3553 }
3554
3555
3556 /* Create a value representing a pointer of type TYPE to the address
3557 ADDR. */
3558
3559 struct value *
3560 value_from_pointer (struct type *type, CORE_ADDR addr)
3561 {
3562 struct value *val = allocate_value (type);
3563
3564 store_typed_address (value_contents_raw (val),
3565 check_typedef (type), addr);
3566 return val;
3567 }
3568
3569
3570 /* Create a value of type TYPE whose contents come from VALADDR, if it
3571 is non-null, and whose memory address (in the inferior) is
3572 ADDRESS. The type of the created value may differ from the passed
3573 type TYPE. Make sure to retrieve values new type after this call.
3574 Note that TYPE is not passed through resolve_dynamic_type; this is
3575 a special API intended for use only by Ada. */
3576
3577 struct value *
3578 value_from_contents_and_address_unresolved (struct type *type,
3579 const gdb_byte *valaddr,
3580 CORE_ADDR address)
3581 {
3582 struct value *v;
3583
3584 if (valaddr == NULL)
3585 v = allocate_value_lazy (type);
3586 else
3587 v = value_from_contents (type, valaddr);
3588 VALUE_LVAL (v) = lval_memory;
3589 set_value_address (v, address);
3590 return v;
3591 }
3592
3593 /* Create a value of type TYPE whose contents come from VALADDR, if it
3594 is non-null, and whose memory address (in the inferior) is
3595 ADDRESS. The type of the created value may differ from the passed
3596 type TYPE. Make sure to retrieve values new type after this call. */
3597
3598 struct value *
3599 value_from_contents_and_address (struct type *type,
3600 const gdb_byte *valaddr,
3601 CORE_ADDR address)
3602 {
3603 struct type *resolved_type = resolve_dynamic_type (type, valaddr, address);
3604 struct type *resolved_type_no_typedef = check_typedef (resolved_type);
3605 struct value *v;
3606
3607 if (valaddr == NULL)
3608 v = allocate_value_lazy (resolved_type);
3609 else
3610 v = value_from_contents (resolved_type, valaddr);
3611 if (TYPE_DATA_LOCATION (resolved_type_no_typedef) != NULL
3612 && TYPE_DATA_LOCATION_KIND (resolved_type_no_typedef) == PROP_CONST)
3613 address = TYPE_DATA_LOCATION_ADDR (resolved_type_no_typedef);
3614 VALUE_LVAL (v) = lval_memory;
3615 set_value_address (v, address);
3616 return v;
3617 }
3618
3619 /* Create a value of type TYPE holding the contents CONTENTS.
3620 The new value is `not_lval'. */
3621
3622 struct value *
3623 value_from_contents (struct type *type, const gdb_byte *contents)
3624 {
3625 struct value *result;
3626
3627 result = allocate_value (type);
3628 memcpy (value_contents_raw (result), contents, TYPE_LENGTH (type));
3629 return result;
3630 }
3631
3632 /* Extract a value from the history file. Input will be of the form
3633 $digits or $$digits. See block comment above 'write_dollar_variable'
3634 for details. */
3635
3636 struct value *
3637 value_from_history_ref (const char *h, const char **endp)
3638 {
3639 int index, len;
3640
3641 if (h[0] == '$')
3642 len = 1;
3643 else
3644 return NULL;
3645
3646 if (h[1] == '$')
3647 len = 2;
3648
3649 /* Find length of numeral string. */
3650 for (; isdigit (h[len]); len++)
3651 ;
3652
3653 /* Make sure numeral string is not part of an identifier. */
3654 if (h[len] == '_' || isalpha (h[len]))
3655 return NULL;
3656
3657 /* Now collect the index value. */
3658 if (h[1] == '$')
3659 {
3660 if (len == 2)
3661 {
3662 /* For some bizarre reason, "$$" is equivalent to "$$1",
3663 rather than to "$$0" as it ought to be! */
3664 index = -1;
3665 *endp += len;
3666 }
3667 else
3668 {
3669 char *local_end;
3670
3671 index = -strtol (&h[2], &local_end, 10);
3672 *endp = local_end;
3673 }
3674 }
3675 else
3676 {
3677 if (len == 1)
3678 {
3679 /* "$" is equivalent to "$0". */
3680 index = 0;
3681 *endp += len;
3682 }
3683 else
3684 {
3685 char *local_end;
3686
3687 index = strtol (&h[1], &local_end, 10);
3688 *endp = local_end;
3689 }
3690 }
3691
3692 return access_value_history (index);
3693 }
3694
3695 /* Get the component value (offset by OFFSET bytes) of a struct or
3696 union WHOLE. Component's type is TYPE. */
3697
3698 struct value *
3699 value_from_component (struct value *whole, struct type *type, LONGEST offset)
3700 {
3701 struct value *v;
3702
3703 if (VALUE_LVAL (whole) == lval_memory && value_lazy (whole))
3704 v = allocate_value_lazy (type);
3705 else
3706 {
3707 v = allocate_value (type);
3708 value_contents_copy (v, value_embedded_offset (v),
3709 whole, value_embedded_offset (whole) + offset,
3710 type_length_units (type));
3711 }
3712 v->offset = value_offset (whole) + offset + value_embedded_offset (whole);
3713 set_value_component_location (v, whole);
3714
3715 return v;
3716 }
3717
3718 struct value *
3719 coerce_ref_if_computed (const struct value *arg)
3720 {
3721 const struct lval_funcs *funcs;
3722
3723 if (!TYPE_IS_REFERENCE (check_typedef (value_type (arg))))
3724 return NULL;
3725
3726 if (value_lval_const (arg) != lval_computed)
3727 return NULL;
3728
3729 funcs = value_computed_funcs (arg);
3730 if (funcs->coerce_ref == NULL)
3731 return NULL;
3732
3733 return funcs->coerce_ref (arg);
3734 }
3735
3736 /* Look at value.h for description. */
3737
3738 struct value *
3739 readjust_indirect_value_type (struct value *value, struct type *enc_type,
3740 const struct type *original_type,
3741 const struct value *original_value)
3742 {
3743 /* Re-adjust type. */
3744 deprecated_set_value_type (value, TYPE_TARGET_TYPE (original_type));
3745
3746 /* Add embedding info. */
3747 set_value_enclosing_type (value, enc_type);
3748 set_value_embedded_offset (value, value_pointed_to_offset (original_value));
3749
3750 /* We may be pointing to an object of some derived type. */
3751 return value_full_object (value, NULL, 0, 0, 0);
3752 }
3753
3754 struct value *
3755 coerce_ref (struct value *arg)
3756 {
3757 struct type *value_type_arg_tmp = check_typedef (value_type (arg));
3758 struct value *retval;
3759 struct type *enc_type;
3760
3761 retval = coerce_ref_if_computed (arg);
3762 if (retval)
3763 return retval;
3764
3765 if (!TYPE_IS_REFERENCE (value_type_arg_tmp))
3766 return arg;
3767
3768 enc_type = check_typedef (value_enclosing_type (arg));
3769 enc_type = TYPE_TARGET_TYPE (enc_type);
3770
3771 retval = value_at_lazy (enc_type,
3772 unpack_pointer (value_type (arg),
3773 value_contents (arg)));
3774 enc_type = value_type (retval);
3775 return readjust_indirect_value_type (retval, enc_type,
3776 value_type_arg_tmp, arg);
3777 }
3778
3779 struct value *
3780 coerce_array (struct value *arg)
3781 {
3782 struct type *type;
3783
3784 arg = coerce_ref (arg);
3785 type = check_typedef (value_type (arg));
3786
3787 switch (TYPE_CODE (type))
3788 {
3789 case TYPE_CODE_ARRAY:
3790 if (!TYPE_VECTOR (type) && current_language->c_style_arrays)
3791 arg = value_coerce_array (arg);
3792 break;
3793 case TYPE_CODE_FUNC:
3794 arg = value_coerce_function (arg);
3795 break;
3796 }
3797 return arg;
3798 }
3799
3800
3801 /* Return the return value convention that will be used for the
3802 specified type. */
3803
3804 enum return_value_convention
3805 struct_return_convention (struct gdbarch *gdbarch,
3806 struct value *function, struct type *value_type)
3807 {
3808 enum type_code code = TYPE_CODE (value_type);
3809
3810 if (code == TYPE_CODE_ERROR)
3811 error (_("Function return type unknown."));
3812
3813 /* Probe the architecture for the return-value convention. */
3814 return gdbarch_return_value (gdbarch, function, value_type,
3815 NULL, NULL, NULL);
3816 }
3817
3818 /* Return true if the function returning the specified type is using
3819 the convention of returning structures in memory (passing in the
3820 address as a hidden first parameter). */
3821
3822 int
3823 using_struct_return (struct gdbarch *gdbarch,
3824 struct value *function, struct type *value_type)
3825 {
3826 if (TYPE_CODE (value_type) == TYPE_CODE_VOID)
3827 /* A void return value is never in memory. See also corresponding
3828 code in "print_return_value". */
3829 return 0;
3830
3831 return (struct_return_convention (gdbarch, function, value_type)
3832 != RETURN_VALUE_REGISTER_CONVENTION);
3833 }
3834
3835 /* Set the initialized field in a value struct. */
3836
3837 void
3838 set_value_initialized (struct value *val, int status)
3839 {
3840 val->initialized = status;
3841 }
3842
3843 /* Return the initialized field in a value struct. */
3844
3845 int
3846 value_initialized (const struct value *val)
3847 {
3848 return val->initialized;
3849 }
3850
3851 /* Load the actual content of a lazy value. Fetch the data from the
3852 user's process and clear the lazy flag to indicate that the data in
3853 the buffer is valid.
3854
3855 If the value is zero-length, we avoid calling read_memory, which
3856 would abort. We mark the value as fetched anyway -- all 0 bytes of
3857 it. */
3858
3859 void
3860 value_fetch_lazy (struct value *val)
3861 {
3862 gdb_assert (value_lazy (val));
3863 allocate_value_contents (val);
3864 /* A value is either lazy, or fully fetched. The
3865 availability/validity is only established as we try to fetch a
3866 value. */
3867 gdb_assert (VEC_empty (range_s, val->optimized_out));
3868 gdb_assert (VEC_empty (range_s, val->unavailable));
3869 if (value_bitsize (val))
3870 {
3871 /* To read a lazy bitfield, read the entire enclosing value. This
3872 prevents reading the same block of (possibly volatile) memory once
3873 per bitfield. It would be even better to read only the containing
3874 word, but we have no way to record that just specific bits of a
3875 value have been fetched. */
3876 struct type *type = check_typedef (value_type (val));
3877 struct value *parent = value_parent (val);
3878
3879 if (value_lazy (parent))
3880 value_fetch_lazy (parent);
3881
3882 unpack_value_bitfield (val,
3883 value_bitpos (val), value_bitsize (val),
3884 value_contents_for_printing (parent),
3885 value_offset (val), parent);
3886 }
3887 else if (VALUE_LVAL (val) == lval_memory)
3888 {
3889 CORE_ADDR addr = value_address (val);
3890 struct type *type = check_typedef (value_enclosing_type (val));
3891
3892 if (TYPE_LENGTH (type))
3893 read_value_memory (val, 0, value_stack (val),
3894 addr, value_contents_all_raw (val),
3895 type_length_units (type));
3896 }
3897 else if (VALUE_LVAL (val) == lval_register)
3898 {
3899 struct frame_info *next_frame;
3900 int regnum;
3901 struct type *type = check_typedef (value_type (val));
3902 struct value *new_val = val, *mark = value_mark ();
3903
3904 /* Offsets are not supported here; lazy register values must
3905 refer to the entire register. */
3906 gdb_assert (value_offset (val) == 0);
3907
3908 while (VALUE_LVAL (new_val) == lval_register && value_lazy (new_val))
3909 {
3910 struct frame_id next_frame_id = VALUE_NEXT_FRAME_ID (new_val);
3911
3912 next_frame = frame_find_by_id (next_frame_id);
3913 regnum = VALUE_REGNUM (new_val);
3914
3915 gdb_assert (next_frame != NULL);
3916
3917 /* Convertible register routines are used for multi-register
3918 values and for interpretation in different types
3919 (e.g. float or int from a double register). Lazy
3920 register values should have the register's natural type,
3921 so they do not apply. */
3922 gdb_assert (!gdbarch_convert_register_p (get_frame_arch (next_frame),
3923 regnum, type));
3924
3925 /* FRAME was obtained, above, via VALUE_NEXT_FRAME_ID.
3926 Since a "->next" operation was performed when setting
3927 this field, we do not need to perform a "next" operation
3928 again when unwinding the register. That's why
3929 frame_unwind_register_value() is called here instead of
3930 get_frame_register_value(). */
3931 new_val = frame_unwind_register_value (next_frame, regnum);
3932
3933 /* If we get another lazy lval_register value, it means the
3934 register is found by reading it from NEXT_FRAME's next frame.
3935 frame_unwind_register_value should never return a value with
3936 the frame id pointing to NEXT_FRAME. If it does, it means we
3937 either have two consecutive frames with the same frame id
3938 in the frame chain, or some code is trying to unwind
3939 behind get_prev_frame's back (e.g., a frame unwind
3940 sniffer trying to unwind), bypassing its validations. In
3941 any case, it should always be an internal error to end up
3942 in this situation. */
3943 if (VALUE_LVAL (new_val) == lval_register
3944 && value_lazy (new_val)
3945 && frame_id_eq (VALUE_NEXT_FRAME_ID (new_val), next_frame_id))
3946 internal_error (__FILE__, __LINE__,
3947 _("infinite loop while fetching a register"));
3948 }
3949
3950 /* If it's still lazy (for instance, a saved register on the
3951 stack), fetch it. */
3952 if (value_lazy (new_val))
3953 value_fetch_lazy (new_val);
3954
3955 /* Copy the contents and the unavailability/optimized-out
3956 meta-data from NEW_VAL to VAL. */
3957 set_value_lazy (val, 0);
3958 value_contents_copy (val, value_embedded_offset (val),
3959 new_val, value_embedded_offset (new_val),
3960 type_length_units (type));
3961
3962 if (frame_debug)
3963 {
3964 struct gdbarch *gdbarch;
3965 struct frame_info *frame;
3966 /* VALUE_FRAME_ID is used here, instead of VALUE_NEXT_FRAME_ID,
3967 so that the frame level will be shown correctly. */
3968 frame = frame_find_by_id (VALUE_FRAME_ID (val));
3969 regnum = VALUE_REGNUM (val);
3970 gdbarch = get_frame_arch (frame);
3971
3972 fprintf_unfiltered (gdb_stdlog,
3973 "{ value_fetch_lazy "
3974 "(frame=%d,regnum=%d(%s),...) ",
3975 frame_relative_level (frame), regnum,
3976 user_reg_map_regnum_to_name (gdbarch, regnum));
3977
3978 fprintf_unfiltered (gdb_stdlog, "->");
3979 if (value_optimized_out (new_val))
3980 {
3981 fprintf_unfiltered (gdb_stdlog, " ");
3982 val_print_optimized_out (new_val, gdb_stdlog);
3983 }
3984 else
3985 {
3986 int i;
3987 const gdb_byte *buf = value_contents (new_val);
3988
3989 if (VALUE_LVAL (new_val) == lval_register)
3990 fprintf_unfiltered (gdb_stdlog, " register=%d",
3991 VALUE_REGNUM (new_val));
3992 else if (VALUE_LVAL (new_val) == lval_memory)
3993 fprintf_unfiltered (gdb_stdlog, " address=%s",
3994 paddress (gdbarch,
3995 value_address (new_val)));
3996 else
3997 fprintf_unfiltered (gdb_stdlog, " computed");
3998
3999 fprintf_unfiltered (gdb_stdlog, " bytes=");
4000 fprintf_unfiltered (gdb_stdlog, "[");
4001 for (i = 0; i < register_size (gdbarch, regnum); i++)
4002 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
4003 fprintf_unfiltered (gdb_stdlog, "]");
4004 }
4005
4006 fprintf_unfiltered (gdb_stdlog, " }\n");
4007 }
4008
4009 /* Dispose of the intermediate values. This prevents
4010 watchpoints from trying to watch the saved frame pointer. */
4011 value_free_to_mark (mark);
4012 }
4013 else if (VALUE_LVAL (val) == lval_computed
4014 && value_computed_funcs (val)->read != NULL)
4015 value_computed_funcs (val)->read (val);
4016 else
4017 internal_error (__FILE__, __LINE__, _("Unexpected lazy value type."));
4018
4019 set_value_lazy (val, 0);
4020 }
4021
4022 /* Implementation of the convenience function $_isvoid. */
4023
4024 static struct value *
4025 isvoid_internal_fn (struct gdbarch *gdbarch,
4026 const struct language_defn *language,
4027 void *cookie, int argc, struct value **argv)
4028 {
4029 int ret;
4030
4031 if (argc != 1)
4032 error (_("You must provide one argument for $_isvoid."));
4033
4034 ret = TYPE_CODE (value_type (argv[0])) == TYPE_CODE_VOID;
4035
4036 return value_from_longest (builtin_type (gdbarch)->builtin_int, ret);
4037 }
4038
4039 void
4040 _initialize_values (void)
4041 {
4042 add_cmd ("convenience", no_class, show_convenience, _("\
4043 Debugger convenience (\"$foo\") variables and functions.\n\
4044 Convenience variables are created when you assign them values;\n\
4045 thus, \"set $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\
4046 \n\
4047 A few convenience variables are given values automatically:\n\
4048 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
4049 \"$__\" holds the contents of the last address examined with \"x\"."
4050 #ifdef HAVE_PYTHON
4051 "\n\n\
4052 Convenience functions are defined via the Python API."
4053 #endif
4054 ), &showlist);
4055 add_alias_cmd ("conv", "convenience", no_class, 1, &showlist);
4056
4057 add_cmd ("values", no_set_class, show_values, _("\
4058 Elements of value history around item number IDX (or last ten)."),
4059 &showlist);
4060
4061 add_com ("init-if-undefined", class_vars, init_if_undefined_command, _("\
4062 Initialize a convenience variable if necessary.\n\
4063 init-if-undefined VARIABLE = EXPRESSION\n\
4064 Set an internal VARIABLE to the result of the EXPRESSION if it does not\n\
4065 exist or does not contain a value. The EXPRESSION is not evaluated if the\n\
4066 VARIABLE is already initialized."));
4067
4068 add_prefix_cmd ("function", no_class, function_command, _("\
4069 Placeholder command for showing help on convenience functions."),
4070 &functionlist, "function ", 0, &cmdlist);
4071
4072 add_internal_function ("_isvoid", _("\
4073 Check whether an expression is void.\n\
4074 Usage: $_isvoid (expression)\n\
4075 Return 1 if the expression is void, zero otherwise."),
4076 isvoid_internal_fn, NULL);
4077
4078 add_setshow_zuinteger_unlimited_cmd ("max-value-size",
4079 class_support, &max_value_size, _("\
4080 Set maximum sized value gdb will load from the inferior."), _("\
4081 Show maximum sized value gdb will load from the inferior."), _("\
4082 Use this to control the maximum size, in bytes, of a value that gdb\n\
4083 will load from the inferior. Setting this value to 'unlimited'\n\
4084 disables checking.\n\
4085 Setting this does not invalidate already allocated values, it only\n\
4086 prevents future values, larger than this size, from being allocated."),
4087 set_max_value_size,
4088 show_max_value_size,
4089 &setlist, &showlist);
4090 }
gdbarch_integer_to_address
CORE_ADDR gdbarch_integer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
Definition: gdbarch.c:2704
target_gdbarch
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5467
gdbarch
Definition: gdbarch.c:127
frame_find_by_id
struct frame_info * frame_find_by_id(struct frame_id id)
Definition: frame.c:803
type::length
unsigned int length
Definition: gdbtypes.h:803
TYPE_FIELD_STATIC_PHYSNAME
#define TYPE_FIELD_STATIC_PHYSNAME(thistype, n)
Definition: gdbtypes.h:1376
user_reg_map_regnum_to_name
const char * user_reg_map_regnum_to_name(struct gdbarch *gdbarch, int regnum)
Definition: user-regs.c:193
read
ssize_t read(int fd, void *buf, size_t count)
Definition: expect-read1.c:26
TYPE_CODE_BOOL
Definition: gdbtypes.h:164
axs_value
Definition: ax-gdb.h:77
deprecated_value_next_frame_id_hack
struct frame_id * deprecated_value_next_frame_id_hack(struct value *value)
Definition: value.c:1566
value_mark
struct value * value_mark(void)
Definition: value.c:1589
xmethod_worker
Definition: extension.h:151
type_code
type_code
Definition: gdbtypes.h:80
lval_funcs::read
void(* read)(struct value *v)
Definition: value.h:226
TYPE_CODE_ARRAY
Definition: gdbtypes.h:104
completer.h
language_defn::string_lower_bound
char string_lower_bound
Definition: language.h:312
lookup_array_range_type
struct type * lookup_array_range_type(struct type *element_type, LONGEST low_bound, LONGEST high_bound)
Definition: gdbtypes.c:1232
lval_computed
Definition: defs.h:394
create_internalvar
struct internalvar * create_internalvar(const char *name)
Definition: value.c:2158
set_value_embedded_offset
void set_value_embedded_offset(struct value *value, LONGEST val)
Definition: value.c:1483
extract_typed_address
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition: findvar.c:154
value_next
struct value * value_next(const struct value *value)
Definition: value.c:1089
mark_value_bits_unavailable
void mark_value_bits_unavailable(struct value *value, LONGEST offset, LONGEST length)
Definition: value.c:594
value_addr
struct value * value_addr(struct value *arg1)
Definition: valops.c:1462
internalvar::u
union internalvar_data u
Definition: value.c:2081
value_history_count
static int value_history_count
Definition: value.c:902
TYPE_CODE_ENUM
Definition: gdbtypes.h:108
VALUE_FRAME_ID
#define VALUE_FRAME_ID(val)
Definition: value.h:447
VALUE_HISTORY_CHUNK
#define VALUE_HISTORY_CHUNK
Definition: value.c:890
make_cv_value
struct value * make_cv_value(int cnst, int voltl, struct value *v)
Definition: value.c:1802
ranges_and_idx
Definition: value.c:733
set_value_initialized
void set_value_initialized(struct value *val, int status)
Definition: value.c:3838
value_print
void value_print(struct value *val, struct ui_file *stream, const struct value_print_options *options)
Definition: valprint.c:1163
value::reference_count
int reference_count
Definition: value.c:258
offset1
unsigned short offset1
Definition: go32-nat.c:1072
value_from_contents_and_address
struct value * value_from_contents_and_address(struct type *type, const gdb_byte *valaddr, CORE_ADDR address)
Definition: value.c:3599
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
value::type
struct type * type
Definition: value.c:266
allocate_value_contents
static void allocate_value_contents(struct value *val)
Definition: value.c:1023
TYPE_N_BASECLASSES
#define TYPE_N_BASECLASSES(thistype)
Definition: gdbtypes.h:1331
internalvar_funcs::make_value
struct value *(* make_value)(struct gdbarch *arch, struct internalvar *var, void *data)
Definition: value.h:952
command.h
expression_up
gdb::unique_xmalloc_ptr< expression > expression_up
Definition: expression.h:87
internalvar_data::data
void * data
Definition: value.c:2040
set_internalvar_component
void set_internalvar_component(struct internalvar *var, LONGEST offset, LONGEST bitpos, LONGEST bitsize, struct value *newval)
Definition: value.c:2351
xfree
void xfree(void *)
internalvar_data::value
struct value * value
Definition: value.c:2031
FIELD_LOC_KIND_PHYSADDR
Definition: gdbtypes.h:456
internal_function::handler
internal_function_fn handler
Definition: value.c:54
deprecated_value_internalvar_hack
struct internalvar ** deprecated_value_internalvar_hack(struct value *value)
Definition: value.c:1560
no_class
Definition: command.h:41
value_entirely_optimized_out
int value_entirely_optimized_out(struct value *value)
Definition: value.c:419
value::location
union value::@186 location
value_from_contents
struct value * value_from_contents(struct type *type, const gdb_byte *contents)
Definition: value.c:3623
class_support
Definition: command.h:42
value::embedded_offset
LONGEST embedded_offset
Definition: value.c:309
unpack_pointer
CORE_ADDR unpack_pointer(struct type *type, const gdb_byte *valaddr)
Definition: value.c:2934
TYPE_OBJFILE
#define TYPE_OBJFILE(t)
Definition: gdbtypes.h:291
value_as_long
LONGEST value_as_long(struct value *val)
Definition: value.c:2749
cmd_list_element
Definition: cli-decode.h:46
value::next_frame_id
struct frame_id next_frame_id
Definition: value.c:218
func
void(* func)(char *)
Definition: remote-fileio.c:1104
value_contents_bits_eq
static bool value_contents_bits_eq(const struct value *val1, int offset1, const struct value *val2, int offset2, int length)
Definition: value.c:812
BMSYMBOL_VALUE_ADDRESS
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:691
warning
void warning(const char *fmt,...)
Definition: errors.c:26
VALUE_NEXT_FRAME_ID
#define VALUE_NEXT_FRAME_ID(val)
Definition: value.h:441
value_embedded_offset
LONGEST value_embedded_offset(const struct value *value)
Definition: value.c:1477
INTERNALVAR_MAKE_VALUE
Definition: value.c:2016
internalvar::name
char * name
Definition: value.c:2073
value_coerce_array
struct value * value_coerce_array(struct value *arg1)
Definition: valops.c:1426
TYPE_NAME
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1224
value::lazy
unsigned int lazy
Definition: value.c:192
value_bitsize
LONGEST value_bitsize(const struct value *value)
Definition: value.c:1128
ranges_overlap
static int ranges_overlap(LONGEST offset1, LONGEST len1, LONGEST offset2, LONGEST len2)
Definition: value.c:79
show_convenience
static void show_convenience(const char *ignore, int from_tty)
Definition: value.c:2654
deprecated_value_lval_hack
enum lval_type * deprecated_value_lval_hack(struct value *value)
Definition: value.c:1517
lookup_only_internalvar
struct internalvar * lookup_only_internalvar(const char *name)
Definition: value.c:2123
value_incref
void value_incref(struct value *val)
Definition: value.c:1598
deprecated_value_modifiable
int deprecated_value_modifiable(const struct value *value)
Definition: value.c:1580
value_enclosing_type
struct type * value_enclosing_type(const struct value *value)
Definition: value.c:1175
compile_internalvar_to_ax
int compile_internalvar_to_ax(struct internalvar *var, struct agent_expr *expr, struct axs_value *value)
Definition: value.c:2192
invoke_xmethod
struct value * invoke_xmethod(struct xmethod_worker *worker, struct value *obj, struct value **args, int nargs)
Definition: extension.c:998
plongest
char * plongest(LONGEST l)
Definition: print-utils.c:137
functionlist
static struct cmd_list_element * functionlist
Definition: value.c:164
lval_register
Definition: defs.h:385
DYN_PROP_DATA_LOCATION
Definition: gdbtypes.h:422
get_internalvar_integer
int get_internalvar_integer(struct internalvar *var, LONGEST *result)
Definition: value.c:2313
range::length
LONGEST length
Definition: value.c:68
TYPE_CODE_RANGE
Definition: gdbtypes.h:127
value::released
unsigned int released
Definition: value.c:202
TYPE_CODE_FLAGS
Definition: gdbtypes.h:109
call_xmethod
struct value * call_xmethod(struct value *method, int argc, struct value **argv)
Definition: value.c:2734
mark_value_bytes_unavailable
void mark_value_bytes_unavailable(struct value *value, LONGEST offset, LONGEST length)
Definition: value.c:601
RETURN_MASK_ERROR
Definition: common-exceptions.h:43
pack_unsigned_long
static void pack_unsigned_long(gdb_byte *buf, struct type *type, ULONGEST num)
Definition: value.c:3491
allocate_value_lazy
struct value * allocate_value_lazy(struct type *type)
Definition: value.c:916
TYPE_CODE_INT
Definition: gdbtypes.h:111
memset
void * memset(T *s, int c, size_t n)=delete
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
value_computed_closure
void * value_computed_closure(const struct value *v)
Definition: value.c:1509
remove_dyn_prop
void remove_dyn_prop(enum dynamic_prop_node_kind prop_kind, struct type *type)
Definition: gdbtypes.c:2363
BASETYPE_VIA_VIRTUAL
#define BASETYPE_VIA_VIRTUAL(thistype, index)
Definition: gdbtypes.h:1338
value::xm_worker
struct xmethod_worker * xm_worker
Definition: value.c:225
internalvar_data::make_value
struct internalvar_data::@189 make_value
return_value_convention
return_value_convention
Definition: defs.h:247
VALUE_INTERNALVAR
#define VALUE_INTERNALVAR(val)
Definition: value.h:434
type_length_units
unsigned int type_length_units(struct type *type)
Definition: gdbtypes.c:260
VEC_block_remove
#define VEC_block_remove(T, V, I, L)
Definition: vec.h:376
value_lazy
int value_lazy(const struct value *value)
Definition: value.c:1383
value_coerce_function
struct value * value_coerce_function(struct value *arg1)
Definition: valops.c:1446
INTERNALVAR_VOID
Definition: value.c:2008
lval_internalvar
Definition: defs.h:387
coerce_ref
struct value * coerce_ref(struct value *arg)
Definition: value.c:3755
value_free
void value_free(struct value *val)
Definition: value.c:1608
add_cmd
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:262
DEF_VEC_O
DEF_VEC_O(range_s)
class_vars
Definition: command.h:41
read_value_memory
void read_value_memory(struct value *val, LONGEST bit_offset, int stack, CORE_ADDR memaddr, gdb_byte *buffer, size_t length)
Definition: valops.c:950
baseclass_offset
int baseclass_offset(struct type *type, int index, const gdb_byte *valaddr, LONGEST embedded_offset, CORE_ADDR address, const struct value *val)
Definition: cp-abi.c:68
TYPE_CODE_DECFLOAT
Definition: gdbtypes.h:173
value_ind
struct value * value_ind(struct value *arg1)
Definition: valops.c:1542
agent_expr
Definition: ax.h:83
set_value_lazy
void set_value_lazy(struct value *value, int val)
Definition: value.c:1389
frame_info
Definition: frame.c:85
value_copy
struct value * value_copy(struct value *arg)
Definition: value.c:1757
value_from_contents_and_address_unresolved
struct value * value_from_contents_and_address_unresolved(struct type *type, const gdb_byte *valaddr, CORE_ADDR address)
Definition: value.c:3578
lval_funcs
Definition: value.h:220
no_set_class
Definition: command.h:45
cmdlist
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:79
lookup_symbol
struct block_symbol lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1893
VEC
#define VEC(T)
Definition: vec.h:414
lval_internalvar_component
Definition: defs.h:391
lookup_internalvar
struct internalvar * lookup_internalvar(const char *name)
Definition: value.c:2212
_
#define _(String)
Definition: gdb_locale.h:35
value_contents_for_printing
const gdb_byte * value_contents_for_printing(struct value *value)
Definition: value.c:1250
value_history_chunk::next
struct value_history_chunk * next
Definition: value.c:894
ui_file
Definition: ui-file.h:26
internalvar_data::fn
struct internalvar_data::@190 fn
value_bytes_available
int value_bytes_available(const struct value *value, LONGEST offset, LONGEST length)
Definition: value.c:357
TYPE_CODE_RVALUE_REF
Definition: gdbtypes.h:158
defs.h
TYPE_DATA_LOCATION_KIND
#define TYPE_DATA_LOCATION_KIND(thistype)
Definition: gdbtypes.h:1264
lval_type
lval_type
Definition: defs.h:378
builtin_type
Definition: gdbtypes.h:1495
range_lessthan
static int range_lessthan(const range_s *r1, const range_s *r2)
Definition: value.c:95
internal_function_fn
struct value *(* internal_function_fn)(struct gdbarch *gdbarch, const struct language_defn *language, void *cookie, int argc, struct value **argv)
Definition: value.h:1144
BLOCK_START
#define BLOCK_START(bl)
Definition: block.h:105
bits
#define bits(obj, st, fn)
Definition: aarch64-tdep.c:64
value_bits_any_optimized_out
int value_bits_any_optimized_out(const struct value *value, int bit_offset, int bit_length)
Definition: value.c:366
internalvar
Definition: value.c:2070
VEC_lower_bound
#define VEC_lower_bound(T, V, O, LT)
Definition: vec.h:399
fn_field
Definition: gdbtypes.h:832
call_internal_function
struct value * call_internal_function(struct gdbarch *gdbarch, const struct language_defn *language, struct value *func, int argc, struct value **argv)
Definition: value.c:2533
mark_value_bits_optimized_out
void mark_value_bits_optimized_out(struct value *value, LONGEST offset, LONGEST length)
Definition: value.c:1458
TYPE_FIELD_TYPE
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1371
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
trace_state_variable::number
int number
Definition: tracepoint.h:56
VALUE_LVAL
#define VALUE_LVAL(val)
Definition: value.h:414
TYPE_DATA_LOCATION
#define TYPE_DATA_LOCATION(thistype)
Definition: gdbtypes.h:1258
internalvar_data::functions
const struct internalvar_funcs * functions
Definition: value.c:2037
allocate_value
struct value * allocate_value(struct type *type)
Definition: value.c:1036
internalvar::next
struct internalvar * next
Definition: value.c:2072
gdbarch_convert_register_p
int gdbarch_convert_register_p(struct gdbarch *gdbarch, int regnum, struct type *type)
Definition: gdbarch.c:2595
value_stack
int value_stack(const struct value *value)
Definition: value.c:1395
gdbarch_integer_to_address_p
int gdbarch_integer_to_address_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2697
unpack_value_bitfield
void unpack_value_bitfield(struct value *dest_val, LONGEST bitpos, LONGEST bitsize, const gdb_byte *valaddr, LONGEST embedded_offset, const struct value *val)
Definition: value.c:3336
printf_filtered
void printf_filtered(const char *format,...)
Definition: utils.c:2045
value_history_chain
static struct value_history_chunk * value_history_chain
Definition: value.c:900
paddress
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2745
objfiles.h
cli-decode.h
function_destroyer
static void function_destroyer(struct cmd_list_element *self, void *ignore)
Definition: value.c:2559
arch-utils.h
TYPE_IS_REFERENCE
#define TYPE_IS_REFERENCE(t)
Definition: gdbtypes.h:332
internalvar_funcs::compile_to_ax
void(* compile_to_ax)(struct internalvar *var, struct agent_expr *expr, struct axs_value *value, void *data)
Definition: value.h:963
language_defn
Definition: language.h:132
value_lval_const
enum lval_type value_lval_const(const struct value *value)
Definition: value.c:1523
XNEW
#define XNEW(T)
Definition: poison.h:109
deprecated_set_value_type
void deprecated_set_value_type(struct value *value, struct type *type)
Definition: value.c:1100
set_value_address
void set_value_address(struct value *value, CORE_ADDR addr)
Definition: value.c:1553
target_float_from_longest
void target_float_from_longest(gdb_byte *addr, const struct type *type, LONGEST val)
Definition: target-float.c:2388
add_prefix_cmd
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:367
value_non_lval
struct value * value_non_lval(struct value *arg)
Definition: value.c:1819
gdbarch_addressable_memory_unit_size
int gdbarch_addressable_memory_unit_size(struct gdbarch *gdbarch)
Definition: gdbarch.c:5030
value::lval
enum lval_type lval
Definition: value.c:173
value_offset
LONGEST value_offset(const struct value *value)
Definition: value.c:1106
NOT_AVAILABLE_ERROR
Definition: common-exceptions.h:82
value::closure
void * closure
Definition: value.c:236
target_get_trace_state_variable_value
#define target_get_trace_state_variable_value(tsv, val)
Definition: target.h:2165
evaluate_expression
struct value * evaluate_expression(struct expression *exp)
Definition: eval.c:144
insert_into_bit_range_vector
static void insert_into_bit_range_vector(VEC(range_s) **vectorp, LONGEST offset, LONGEST length)
Definition: value.c:428
TRY
#define TRY
Definition: common-exceptions.h:246
free_value_chain
void free_value_chain(struct value *v)
Definition: value.c:1678
TYPE_CODE_VOID
Definition: gdbtypes.h:124
symtab.h
target-float.h
frame_id_eq
int frame_id_eq(struct frame_id l, struct frame_id r)
Definition: frame.c:674
TYPE_CODE_TYPEDEF
Definition: gdbtypes.h:169
val_print_optimized_out
void val_print_optimized_out(const struct value *val, struct ui_file *stream)
Definition: valprint.c:353
value::contents
gdb_byte * contents
Definition: value.c:320
isvoid_internal_fn
static struct value * isvoid_internal_fn(struct gdbarch *gdbarch, const struct language_defn *language, void *cookie, int argc, struct value **argv)
Definition: value.c:4025
function_command
static void function_command(const char *command, int from_tty)
Definition: value.c:2552
lval_memory
Definition: defs.h:383
setlist
struct cmd_list_element * setlist
Definition: cli-cmds.c:111
name
const char *const name
Definition: aarch64-tdep.c:76
value_contents_eq
bool value_contents_eq(const struct value *val1, LONGEST offset1, const struct value *val2, LONGEST offset2, LONGEST length)
Definition: value.c:874
require_not_optimized_out
static void require_not_optimized_out(const struct value *value)
Definition: value.c:1231
TYPE_FN_FIELD_PHYSNAME
#define TYPE_FN_FIELD_PHYSNAME(thisfn, n)
Definition: gdbtypes.h:1426
INTERNALVAR_STRING
Definition: value.c:2025
VEC_iterate
#define VEC_iterate(T, V, I, P)
Definition: vec.h:181
internalvar_funcs
Definition: value.h:946
preserve_one_value
void preserve_one_value(struct value *value, struct objfile *objfile, htab_t copied_types)
Definition: value.c:2590
free_xmethod_worker
void free_xmethod_worker(struct xmethod_worker *worker)
Definition: extension.c:1010
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
result_type_of_xmethod
struct type * result_type_of_xmethod(struct value *method, int argc, struct value **argv)
Definition: value.c:2722
value_contents
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1407
value::computed
struct value::@186::@188 computed
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
value_field
struct value * value_field(struct value *arg1, int fieldno)
Definition: value.c:3152
unpack_bits_as_long
static LONGEST unpack_bits_as_long(struct type *field_type, const gdb_byte *valaddr, LONGEST bitpos, LONGEST bitsize)
Definition: value.c:3237
internalvars
static struct internalvar * internalvars
Definition: value.c:2084
show_max_value_size
static void show_max_value_size(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: value.c:988
value_print_options
Definition: valprint.h:25
TYPE_CODE_CHAR
Definition: gdbtypes.h:160
unpack_field_as_long
LONGEST unpack_field_as_long(struct type *type, const gdb_byte *valaddr, int fieldno)
Definition: value.c:3318
internalvar_data::val
LONGEST val
Definition: value.c:2058
all_values
static struct value * all_values
Definition: value.c:909
HAVE_PYTHON
#define HAVE_PYTHON
Definition: config.h:380
gdb::unique_xmalloc_ptr
std::unique_ptr< T, xfree_deleter< T > > unique_xmalloc_ptr
Definition: gdb_unique_ptr.h:48
current_target
struct target_ops current_target
internalvar_data::string
char * string
Definition: value.c:2062
gdbarch_addr_bits_remove
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:3208
allocate_computed_value
struct value * allocate_computed_value(struct type *type, const struct lval_funcs *funcs, void *closure)
Definition: value.c:1061
PROP_CONST
Definition: gdbtypes.h:379
value_history_chunk
Definition: value.c:892
value::reg
struct value::@186::@187 reg
MIN_VALUE_FOR_MAX_VALUE_SIZE
#define MIN_VALUE_FOR_MAX_VALUE_SIZE
Definition: value.c:966
value_ranges_copy_adjusted
static void value_ranges_copy_adjusted(struct value *dst, int dst_bit_offset, const struct value *src, int src_bit_offset, int bit_length)
Definition: value.c:1303
value_static_field
struct value * value_static_field(struct type *type, int fieldno)
Definition: value.c:2961
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
xzalloc
void * xzalloc(size_t size)
Definition: common-utils.c:92
extract_unsigned_integer
static ULONGEST extract_unsigned_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:577
preserve_ext_lang_values
void preserve_ext_lang_values(struct objfile *objfile, htab_t copied_types)
Definition: extension.c:592
lval_funcs::copy_closure
void *(* copy_closure)(const struct value *v)
Definition: value.h:256
value_bits_available
int value_bits_available(const struct value *value, LONGEST offset, LONGEST length)
Definition: value.c:349
block_symbol::block
const struct block * block
Definition: symtab.h:1140
INTERNALVAR_FUNCTION
Definition: value.c:2019
regcache.h
memcmp_with_bit_offsets
static int memcmp_with_bit_offsets(const gdb_byte *ptr1, size_t offset1_bits, const gdb_byte *ptr2, size_t offset2_bits, size_t length_bits)
Definition: value.c:641
bound_minimal_symbol
Definition: minsyms.h:29
set_value_enclosing_type
void set_value_enclosing_type(struct value *val, struct type *new_encl_type)
Definition: value.c:3010
gdbarch_convert_from_func_ptr_addr
CORE_ADDR gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
Definition: gdbarch.c:3191
internalvar_data::type
struct type * type
Definition: value.c:2057
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
set_repeat_arguments
void set_repeat_arguments(const char *args)
Definition: top.c:531
cmd_list_element::destroyer
void(* destroyer)(struct cmd_list_element *self, void *context)
Definition: cli-decode.h:177
using_struct_return
int using_struct_return(struct gdbarch *gdbarch, struct value *function, struct type *value_type)
Definition: value.c:3823
showlist
struct cmd_list_element * showlist
Definition: cli-cmds.c:119
preserve_values
void preserve_values(struct objfile *objfile)
Definition: value.c:2629
value_contents_all
const gdb_byte * value_contents_all(struct value *value)
Definition: value.c:1265
TYPE_VECTOR
#define TYPE_VECTOR(t)
Definition: gdbtypes.h:252
block_symbol
Definition: symtab.h:1133
find_first_range_overlap
static int find_first_range_overlap(VEC(range_s) *ranges, int pos, LONGEST offset, LONGEST length)
Definition: value.c:615
TYPE_CODE_FLT
Definition: gdbtypes.h:116
set_value_parent
void set_value_parent(struct value *value, struct value *parent)
Definition: value.c:1147
gdb_assert_not_reached
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:55
internalvar::kind
enum internalvar_kind kind
Definition: value.c:2079
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
VEC_length
#define VEC_length(T, V)
Definition: vec.h:140
internalvar_name
char * internalvar_name(const struct internalvar *var)
Definition: value.c:2502
set_internalvar
void set_internalvar(struct internalvar *var, struct value *val)
Definition: value.c:2381
lval_funcs::coerce_ref
struct value *(* coerce_ref)(const struct value *value)
Definition: value.h:243
copy_type_recursive
struct type * copy_type_recursive(struct objfile *objfile, struct type *type, htab_t copied_types)
Definition: gdbtypes.c:4763
set_internalvar_function
static void set_internalvar_function(struct internalvar *var, struct internal_function *f)
Definition: value.c:2463
get_objfile_arch
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:445
gdb_static_assert
gdb_static_assert(sizeof(LONGEST)<=MIN_VALUE_FOR_MAX_VALUE_SIZE)
get_xmethod_result_type
struct type * get_xmethod_result_type(struct xmethod_worker *worker, struct value *object, struct value **args, int nargs)
Definition: extension.c:972
TARGET_CHAR_BIT
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
show_values
static void show_values(const char *num_exp, int from_tty)
Definition: value.c:1962
intvar
static struct internalvar * intvar
Definition: p-exp.c:260
type
Definition: gdbtypes.h:749
value_of_xmethod
struct value * value_of_xmethod(struct xmethod_worker *worker)
Definition: value.c:2703
VALUE_REGNUM
#define VALUE_REGNUM(val)
Definition: value.h:451
language.h
tracepoint.h
INTERNALVAR_VALUE
Definition: value.c:2012
VEC_index
#define VEC_index(T, V, I)
Definition: vec.h:167
coerce_ref_if_computed
struct value * coerce_ref_if_computed(const struct value *arg)
Definition: value.c:3719
value::parent
struct value * parent
Definition: value.c:263
get_type_arch
struct gdbarch * get_type_arch(const struct type *type)
Definition: gdbtypes.c:234
value_initialized
int value_initialized(const struct value *val)
Definition: value.c:3846
get_current_arch
struct gdbarch * get_current_arch(void)
Definition: arch-utils.c:798
gdbarch_return_value
enum return_value_convention gdbarch_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: gdbarch.c:2728
value_contents_writeable
gdb_byte * value_contents_writeable(struct value *value)
Definition: value.c:1416
coerce_array
struct value * coerce_array(struct value *arg)
Definition: value.c:3780
type
static const char * type
Definition: language.c:113
internalvar_data::canonical
int canonical
Definition: value.c:2048
value_from_longest
struct value * value_from_longest(struct type *type, LONGEST num)
Definition: value.c:3534
unpack_value_field_as_long
int unpack_value_field_as_long(struct type *type, const gdb_byte *valaddr, LONGEST embedded_offset, int fieldno, const struct value *val, LONGEST *result)
Definition: value.c:3293
status
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition: gnu-nat.c:1822
create_copied_types_hash
htab_t create_copied_types_hash(struct objfile *objfile)
Definition: gdbtypes.c:4724
value_at_lazy
struct value * value_at_lazy(struct type *type, CORE_ADDR addr)
Definition: valops.c:944
value_contents_for_printing_const
const gdb_byte * value_contents_for_printing_const(const struct value *value)
Definition: value.c:1258
value_cast
struct value * value_cast(struct type *type, struct value *arg2)
Definition: valops.c:351
internal_function::cookie
void * cookie
Definition: value.c:57
TYPE_DATA_LOCATION_ADDR
#define TYPE_DATA_LOCATION_ADDR(thistype)
Definition: gdbtypes.h:1262
value::bitsize
LONGEST bitsize
Definition: value.c:246
internalvar_data::function
struct internal_function * function
Definition: value.c:2046
internalvar_data
Definition: value.c:2028
range
Definition: value.c:62
value_contents_all_raw
gdb_byte * value_contents_all_raw(struct value *value)
Definition: value.c:1168
set_max_value_size
static void set_max_value_size(const char *args, int from_tty, struct cmd_list_element *c)
Definition: value.c:972
set_value_offset
void set_value_offset(struct value *value, LONGEST offset)
Definition: value.c:1111
language_defn::c_style_arrays
char c_style_arrays
Definition: language.h:309
regnum
int regnum
Definition: aarch64-tdep.c:77
printf_unfiltered
void printf_unfiltered(const char *format,...)
Definition: utils.c:2056
value_bitpos
LONGEST value_bitpos(const struct value *value)
Definition: value.c:1117
struct_return_convention
enum return_value_convention struct_return_convention(struct gdbarch *gdbarch, struct value *function, struct type *value_type)
Definition: value.c:3805
frame_unwind_register_value
struct value * frame_unwind_register_value(struct frame_info *frame, int regnum)
Definition: frame.c:1172
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
value_full_object
struct value * value_full_object(struct value *argp, struct type *rtype, int xfull, int xtop, int xusing_enc)
Definition: valops.c:3662
TYPE_FIELD_BITSIZE
#define TYPE_FIELD_BITSIZE(thistype, n)
Definition: gdbtypes.h:1380
TYPE_CODE_ERROR
Definition: gdbtypes.h:138
value_of_internalvar
struct value * value_of_internalvar(struct gdbarch *gdbarch, struct internalvar *var)
Definition: value.c:2227
unpack_long
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)
Definition: value.c:2880
TYPE_CODE_REF
Definition: gdbtypes.h:156
TYPE_CODE_FUNC
Definition: gdbtypes.h:110
TYPE_FIELD_BITPOS
#define TYPE_FIELD_BITPOS(thistype, n)
Definition: gdbtypes.h:1374
extension.h
TYPE_UNSIGNED
#define TYPE_UNSIGNED(t)
Definition: gdbtypes.h:205
add_alias_cmd
struct cmd_list_element * add_alias_cmd(const char *name, cmd_list_element *old, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
Definition: cli-decode.c:306
block_symbol::symbol
struct symbol * symbol
Definition: symtab.h:1136
value_raw_address
CORE_ADDR value_raw_address(const struct value *value)
Definition: value.c:1545
target_float_from_ulongest
void target_float_from_ulongest(gdb_byte *addr, const struct type *type, ULONGEST val)
Definition: target-float.c:2398
ranges_copy_adjusted
static void ranges_copy_adjusted(VEC(range_s) **dst_range, int dst_bit_offset, VEC(range_s) *src_range, int src_bit_offset, int bit_length)
Definition: value.c:1277
user-regs.h
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
VEC_empty
#define VEC_empty(T, V)
Definition: vec.h:148
value::next
struct value * next
Definition: value.c:316
value
Definition: value.c:169
value_release_to_mark
struct value * value_release_to_mark(const struct value *mark)
Definition: value.c:1733
init_if_undefined_command
static void init_if_undefined_command(const char *args, int from_tty)
Definition: value.c:2089
TYPE_CODE_XMETHOD
Definition: gdbtypes.h:181
value_fn_field
struct value * value_fn_field(struct value **arg1p, struct fn_field *f, int j, struct type *type, LONGEST offset)
Definition: value.c:3165
value_bits_synthetic_pointer
int value_bits_synthetic_pointer(const struct value *value, LONGEST offset, LONGEST length)
Definition: value.c:1465
xrealloc
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:52
objfile
Definition: objfiles.h:286
range::offset
LONGEST offset
Definition: value.c:65
FIELD_LOC_KIND_PHYSNAME
Definition: gdbtypes.h:457
TYPE_CODE_PTR
Definition: gdbtypes.h:84
internalvar_data::integer
struct internalvar_data::@191 integer
is_floating_type
int is_floating_type(struct type *t)
Definition: gdbtypes.c:3041
release_value_or_incref
void release_value_or_incref(struct value *val)
Definition: value.c:1723
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
value_history_chunk::values
struct value * values[VALUE_HISTORY_CHUNK]
Definition: value.c:895
xmethod_worker::value
struct value * value
Definition: extension.h:161
TYPE_FN_FIELD_TYPE
#define TYPE_FN_FIELD_TYPE(thisfn, n)
Definition: gdbtypes.h:1427
allocate_repeat_value
struct value * allocate_repeat_value(struct type *type, int count)
Definition: value.c:1049
value_entirely_available
int value_entirely_available(struct value *value)
Definition: value.c:374
free_all_values
void free_all_values(void)
Definition: value.c:1660
value_from_pointer
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
Definition: value.c:3560
read_offset
static LONGEST read_offset(bfd *, const gdb_byte *, const struct comp_unit_head *, unsigned int *)
Definition: dwarf2read.c:19326
make_cv_type
struct type * make_cv_type(int cnst, int voltl, struct type *type, struct type **typeptr)
Definition: gdbtypes.c:691
current_language
const struct language_defn * current_language
Definition: language.c:81
value_optimized_out
int value_optimized_out(struct value *value)
Definition: value.c:1424
TYPE_TARGET_TYPE
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1226
value_fetch_lazy
void value_fetch_lazy(struct value *val)
Definition: value.c:3860
VEC_copy
#define VEC_copy(T, V)
Definition: vec.h:222
value_internal_function_name
char * value_internal_function_name(struct value *val)
Definition: value.c:2520
mark_value_bytes_optimized_out
void mark_value_bytes_optimized_out(struct value *value, int offset, int length)
Definition: value.c:1448
max_value_size
static int max_value_size
Definition: value.c:955
XCNEW
#define XCNEW(T)
Definition: poison.h:121
gdbcore.h
frame_relative_level
int frame_relative_level(struct frame_info *fi)
Definition: frame.c:2610
SYMBOL_BLOCK_VALUE
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:467
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
set_internalvar_string
void set_internalvar_string(struct internalvar *var, const char *string)
Definition: value.c:2453
resolve_dynamic_type
struct type * resolve_dynamic_type(struct type *type, const gdb_byte *valaddr, CORE_ADDR addr)
Definition: gdbtypes.c:2317
_initialize_values
void _initialize_values(void)
Definition: value.c:4040
value_of_variable
struct value * value_of_variable(struct symbol *var, const struct block *b)
Definition: valops.c:1296
trace_state_variable::value
LONGEST value
Definition: tracepoint.h:67
value_contents_copy
void value_contents_copy(struct value *dst, LONGEST dst_offset, struct value *src, LONGEST src_offset, LONGEST length)
Definition: value.c:1373
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
set_internalvar_integer
void set_internalvar_integer(struct internalvar *var, LONGEST l)
Definition: value.c:2442
trace_state_variable
Definition: tracepoint.h:49
bit
#define bit(obj, st)
Definition: aarch64-tdep.c:63
get_user_print_options
void get_user_print_options(struct value_print_options *opts)
Definition: valprint.c:120
offset
int offset
Definition: agent.c:65
internal_function
Definition: value.c:46
lookup_bound_minimal_symbol
struct bound_minimal_symbol lookup_bound_minimal_symbol(const char *name)
Definition: minsyms.c:430
code
int code
Definition: ser-unix.c:239
target_float_is_valid
bool target_float_is_valid(const gdb_byte *addr, const struct type *type)
Definition: target-float.c:2305
value::stack
unsigned int stack
Definition: value.c:199
VEC_free
#define VEC_free(T, V)
Definition: vec.h:196
set_value_pointed_to_offset
void set_value_pointed_to_offset(struct value *value, LONGEST val)
Definition: value.c:1495
create_internal_function
static struct internal_function * create_internal_function(const char *name, internal_function_fn handler, void *cookie)
Definition: value.c:2508
completion_tracker::add_completion
void add_completion(gdb::unique_xmalloc_ptr< char > name, completion_match_for_lcd *match_for_lcd=NULL, const char *text=NULL, const char *word=NULL)
Definition: completer.c:1550
clear_internalvar
void clear_internalvar(struct internalvar *var)
Definition: value.c:2475
value::bitpos
LONGEST bitpos
Definition: value.c:251
TYPE_CODE_MEMBERPTR
Definition: gdbtypes.h:154
value_pointed_to_offset
LONGEST value_pointed_to_offset(const struct value *value)
Definition: value.c:1489
extract_signed_integer
static LONGEST extract_signed_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:570
add_internal_function
void add_internal_function(const char *name, const char *doc, internal_function_fn handler, void *cookie)
Definition: value.c:2571
target.h
get_internalvar_function
static int get_internalvar_function(struct internalvar *var, struct internal_function **result)
Definition: value.c:2336
TYPE_CODE_INTERNAL_FUNCTION
Definition: gdbtypes.h:178
VAR_DOMAIN
Definition: symtab.h:739
complete_internalvar
void complete_internalvar(completion_tracker &tracker, const char *name)
Definition: value.c:2138
value_free_to_mark
void value_free_to_mark(const struct value *mark)
Definition: value.c:1641
value.h
error_value_optimized_out
void error_value_optimized_out(void)
Definition: value.c:1225
find_first_range_overlap_and_match
static int find_first_range_overlap_and_match(struct ranges_and_idx *rp1, struct ranges_and_idx *rp2, LONGEST offset1, LONGEST offset2, LONGEST length, ULONGEST *l, ULONGEST *h)
Definition: value.c:750
value::modifiable
unsigned int modifiable
Definition: value.c:176
record_latest_value
int record_latest_value(struct value *val)
Definition: value.c:1884
set_value_stack
void set_value_stack(struct value *value, int val)
Definition: value.c:1401
value::funcs
const struct lval_funcs * funcs
Definition: value.c:233
set_value_bitsize
void set_value_bitsize(struct value *value, LONGEST bit)
Definition: value.c:1133
gdbtypes.h
value_parent
struct value * value_parent(const struct value *value)
Definition: value.c:1139
gdbarch_bits_big_endian
int gdbarch_bits_big_endian(struct gdbarch *gdbarch)
Definition: gdbarch.c:1545
internalvar_funcs::destroy
void(* destroy)(void *data)
Definition: value.h:972
value::pointed_to_offset
LONGEST pointed_to_offset
Definition: value.c:310
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
value_field_bitfield
struct value * value_field_bitfield(struct type *type, int fieldno, const gdb_byte *valaddr, LONGEST embedded_offset, const struct value *val)
Definition: value.c:3381
ignore
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:879
language
language
Definition: defs.h:203
parse_expression
expression_up parse_expression(const char *)
Definition: parse.c:1237
release_value
void release_value(struct value *val)
Definition: value.c:1693
register_size
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:164
check_type_length_before_alloc
static void check_type_length_before_alloc(const struct type *type)
Definition: value.c:1005
value_force_lval
void value_force_lval(struct value *v, CORE_ADDR addr)
Definition: value.c:1839
value_primitive_field
struct value * value_primitive_field(struct value *arg1, LONGEST offset, int fieldno, struct type *arg_type)
Definition: value.c:3028
completion_tracker
Definition: completer.h:310
gdb_stdlog
#define gdb_stdlog
Definition: utils.h:349
find_trace_state_variable
struct trace_state_variable * find_trace_state_variable(const char *name)
Definition: tracepoint.c:281
value_type
struct type * value_type(const struct value *value)
Definition: value.c:1095
lval_funcs::free_closure
void(* free_closure)(struct value *v)
Definition: value.h:264
symbol
Definition: symtab.h:1049
deprecated_value_regnum_hack
int * deprecated_value_regnum_hack(struct value *value)
Definition: value.c:1573
access_value_history
struct value * access_value_history(int num)
Definition: value.c:1927
value_from_ulongest
struct value * value_from_ulongest(struct type *type, ULONGEST num)
Definition: value.c:3546
value_as_address
CORE_ADDR value_as_address(struct value *val)
Definition: value.c:2762
value_contents_copy_raw
void value_contents_copy_raw(struct value *dst, LONGEST dst_offset, struct value *src, LONGEST src_offset, LONGEST length)
Definition: value.c:1326
value::regnum
int regnum
Definition: value.c:214
TYPE_FIELD_STATIC_PHYSADDR
#define TYPE_FIELD_STATIC_PHYSADDR(thistype, n)
Definition: gdbtypes.h:1377
value_contents_raw
gdb_byte * value_contents_raw(struct value *value)
Definition: value.c:1158
VEC_safe_insert
#define VEC_safe_insert(T, V, I, O)
Definition: vec.h:343
internal_function::name
char * name
Definition: value.c:51
gdb.argv
argv
Definition: __init__.py:63
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
bound_minimal_symbol::objfile
struct objfile * objfile
Definition: minsyms.h:39
HOST_CHAR_BIT
#define HOST_CHAR_BIT
Definition: host-defs.h:40
store_typed_address
void store_typed_address(gdb_byte *buf, struct type *type, CORE_ADDR addr)
Definition: findvar.c:207
value::address
CORE_ADDR address
Definition: value.c:208
preserve_one_internalvar
static void preserve_one_internalvar(struct internalvar *var, struct objfile *objfile, htab_t copied_types)
Definition: value.c:2605
readjust_indirect_value_type
struct value * readjust_indirect_value_type(struct value *value, struct type *enc_type, const struct type *original_type, const struct value *original_value)
Definition: value.c:3739
frame_debug
unsigned int frame_debug
Definition: frame.c:274
value_cstring
struct value * value_cstring(const char *ptr, ssize_t len, struct type *char_type)
Definition: valops.c:1652
get_value_arch
struct gdbarch * get_value_arch(const struct value *value)
Definition: value.c:343
value_entirely_covered_by_range_vector
static int value_entirely_covered_by_range_vector(struct value *value, VEC(range_s) **ranges)
Definition: value.c:391
allocate_optimized_out_value
struct value * allocate_optimized_out_value(struct type *type)
Definition: value.c:1077
target_float_to_longest
LONGEST target_float_to_longest(const gdb_byte *addr, const struct type *type)
Definition: target-float.c:2379
write_memory
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:394
add_com
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:902
TYPE_FIELD_LOC_KIND
#define TYPE_FIELD_LOC_KIND(thistype, n)
Definition: gdbtypes.h:1373
valprint.h
TYPE_CODE_METHOD
Definition: gdbtypes.h:141
value_address
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1529
not_lval
Definition: defs.h:381
internalvar_kind
internalvar_kind
Definition: value.c:2005
lookup_minimal_symbol
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:311
RETURN_VALUE_REGISTER_CONVENTION
Definition: defs.h:251
value::offset
LONGEST offset
Definition: value.c:243
value_from_component
struct value * value_from_component(struct value *whole, struct type *type, LONGEST offset)
Definition: value.c:3699
pack_long
void pack_long(gdb_byte *buf, struct type *type, LONGEST num)
Definition: value.c:3450
gdbarch::byte_order
enum bfd_endian byte_order
Definition: gdbarch.c:137
set_value_bitpos
void set_value_bitpos(struct value *value, LONGEST bit)
Definition: value.c:1122
value_print_options::objectprint
int objectprint
Definition: valprint.h:47
gdbcmd.h
lval_xcallable
Definition: defs.h:389
create_internalvar_type_lazy
struct internalvar * create_internalvar_type_lazy(const char *name, const struct internalvar_funcs *funcs, void *data)
Definition: value.c:2177
value_entirely_unavailable
int value_entirely_unavailable(struct value *value)
Definition: value.c:413
value_actual_type
struct type * value_actual_type(struct value *value, int resolve_simple_types, int *real_type_found)
Definition: value.c:1183
add_setshow_zuinteger_unlimited_cmd
void add_setshow_zuinteger_unlimited_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:765
store_signed_integer
static void store_signed_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, LONGEST val)
Definition: defs.h:597
value::initialized
unsigned int initialized
Definition: value.c:195
error
void error(const char *fmt,...)
Definition: errors.c:38
trace_state_variable::value_known
int value_known
Definition: tracepoint.h:64
value_from_history_ref
struct value * value_from_history_ref(const char *h, const char **endp)
Definition: value.c:3637
require_available
static void require_available(const struct value *value)
Definition: value.c:1243
lookup_pointer_type
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:381
frame_id
Definition: frame.h:111
get_frame_arch
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2691
block.h
throw_error
void throw_error(enum errors error, const char *fmt,...)
Definition: common-exceptions.c:389
LONGEST
long long LONGEST
Definition: common-types.h:52
is_floating_value
bool is_floating_value(struct value *val)
Definition: value.c:2942
cp-abi.h
value::internalvar
struct internalvar * internalvar
Definition: value.c:222
value::enclosing_type
struct type * enclosing_type
Definition: value.c:308
set_value_component_location
void set_value_component_location(struct value *component, const struct value *whole)
Definition: value.c:1849
ranges_contain
static int ranges_contain(VEC(range_s) *ranges, LONGEST offset, LONGEST length)
Definition: value.c:104
INTERNALVAR_INTEGER
Definition: value.c:2022
store_unsigned_integer
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition: defs.h:604
modify_field
void modify_field(struct type *type, gdb_byte *addr, LONGEST fieldval, LONGEST bitpos, LONGEST bitsize)
Definition: value.c:3403
gdb_stdout
#define gdb_stdout
Definition: utils.h:340
value_rtti_indirect_type
struct type * value_rtti_indirect_type(struct value *v, int *full, LONGEST *top, int *using_enc)
Definition: valops.c:3595
value_computed_funcs
const struct lval_funcs * value_computed_funcs(const struct value *v)
Definition: value.c:1501
parse_and_eval_long
LONGEST parse_and_eval_long(const char *exp)
Definition: eval.c:111