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