*** empty log message ***
[binutils-gdb.git] / gdb / value.c
1 /* Low level packing and unpacking of values for GDB, the GNU Debugger.
2
3 Copyright (C) 1986-2000, 2002-2012 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 "gdb_string.h"
23 #include "symtab.h"
24 #include "gdbtypes.h"
25 #include "value.h"
26 #include "gdbcore.h"
27 #include "command.h"
28 #include "gdbcmd.h"
29 #include "target.h"
30 #include "language.h"
31 #include "demangle.h"
32 #include "doublest.h"
33 #include "gdb_assert.h"
34 #include "regcache.h"
35 #include "block.h"
36 #include "dfp.h"
37 #include "objfiles.h"
38 #include "valprint.h"
39 #include "cli/cli-decode.h"
40 #include "exceptions.h"
41 #include "python/python.h"
42 #include <ctype.h>
43 #include "tracepoint.h"
44 #include "cp-abi.h"
45
46 /* Prototypes for exported functions. */
47
48 void _initialize_values (void);
49
50 /* Definition of a user function. */
51 struct internal_function
52 {
53 /* The name of the function. It is a bit odd to have this in the
54 function itself -- the user might use a differently-named
55 convenience variable to hold the function. */
56 char *name;
57
58 /* The handler. */
59 internal_function_fn handler;
60
61 /* User data for the handler. */
62 void *cookie;
63 };
64
65 /* Defines an [OFFSET, OFFSET + LENGTH) range. */
66
67 struct range
68 {
69 /* Lowest offset in the range. */
70 int offset;
71
72 /* Length of the range. */
73 int length;
74 };
75
76 typedef struct range range_s;
77
78 DEF_VEC_O(range_s);
79
80 /* Returns true if the ranges defined by [offset1, offset1+len1) and
81 [offset2, offset2+len2) overlap. */
82
83 static int
84 ranges_overlap (int offset1, int len1,
85 int offset2, int len2)
86 {
87 ULONGEST h, l;
88
89 l = max (offset1, offset2);
90 h = min (offset1 + len1, offset2 + len2);
91 return (l < h);
92 }
93
94 /* Returns true if the first argument is strictly less than the
95 second, useful for VEC_lower_bound. We keep ranges sorted by
96 offset and coalesce overlapping and contiguous ranges, so this just
97 compares the starting offset. */
98
99 static int
100 range_lessthan (const range_s *r1, const range_s *r2)
101 {
102 return r1->offset < r2->offset;
103 }
104
105 /* Returns true if RANGES contains any range that overlaps [OFFSET,
106 OFFSET+LENGTH). */
107
108 static int
109 ranges_contain (VEC(range_s) *ranges, int offset, int length)
110 {
111 range_s what;
112 int i;
113
114 what.offset = offset;
115 what.length = length;
116
117 /* We keep ranges sorted by offset and coalesce overlapping and
118 contiguous ranges, so to check if a range list contains a given
119 range, we can do a binary search for the position the given range
120 would be inserted if we only considered the starting OFFSET of
121 ranges. We call that position I. Since we also have LENGTH to
122 care for (this is a range afterall), we need to check if the
123 _previous_ range overlaps the I range. E.g.,
124
125 R
126 |---|
127 |---| |---| |------| ... |--|
128 0 1 2 N
129
130 I=1
131
132 In the case above, the binary search would return `I=1', meaning,
133 this OFFSET should be inserted at position 1, and the current
134 position 1 should be pushed further (and before 2). But, `0'
135 overlaps with R.
136
137 Then we need to check if the I range overlaps the I range itself.
138 E.g.,
139
140 R
141 |---|
142 |---| |---| |-------| ... |--|
143 0 1 2 N
144
145 I=1
146 */
147
148 i = VEC_lower_bound (range_s, ranges, &what, range_lessthan);
149
150 if (i > 0)
151 {
152 struct range *bef = VEC_index (range_s, ranges, i - 1);
153
154 if (ranges_overlap (bef->offset, bef->length, offset, length))
155 return 1;
156 }
157
158 if (i < VEC_length (range_s, ranges))
159 {
160 struct range *r = VEC_index (range_s, ranges, i);
161
162 if (ranges_overlap (r->offset, r->length, offset, length))
163 return 1;
164 }
165
166 return 0;
167 }
168
169 static struct cmd_list_element *functionlist;
170
171 /* Note that the fields in this structure are arranged to save a bit
172 of memory. */
173
174 struct value
175 {
176 /* Type of value; either not an lval, or one of the various
177 different possible kinds of lval. */
178 enum lval_type lval;
179
180 /* Is it modifiable? Only relevant if lval != not_lval. */
181 unsigned int modifiable : 1;
182
183 /* If zero, contents of this value are in the contents field. If
184 nonzero, contents are in inferior. If the lval field is lval_memory,
185 the contents are in inferior memory at location.address plus offset.
186 The lval field may also be lval_register.
187
188 WARNING: This field is used by the code which handles watchpoints
189 (see breakpoint.c) to decide whether a particular value can be
190 watched by hardware watchpoints. If the lazy flag is set for
191 some member of a value chain, it is assumed that this member of
192 the chain doesn't need to be watched as part of watching the
193 value itself. This is how GDB avoids watching the entire struct
194 or array when the user wants to watch a single struct member or
195 array element. If you ever change the way lazy flag is set and
196 reset, be sure to consider this use as well! */
197 unsigned int lazy : 1;
198
199 /* If nonzero, this is the value of a variable which does not
200 actually exist in the program. */
201 unsigned int optimized_out : 1;
202
203 /* If value is a variable, is it initialized or not. */
204 unsigned int initialized : 1;
205
206 /* If value is from the stack. If this is set, read_stack will be
207 used instead of read_memory to enable extra caching. */
208 unsigned int stack : 1;
209
210 /* If the value has been released. */
211 unsigned int released : 1;
212
213 /* Location of value (if lval). */
214 union
215 {
216 /* If lval == lval_memory, this is the address in the inferior.
217 If lval == lval_register, this is the byte offset into the
218 registers structure. */
219 CORE_ADDR address;
220
221 /* Pointer to internal variable. */
222 struct internalvar *internalvar;
223
224 /* If lval == lval_computed, this is a set of function pointers
225 to use to access and describe the value, and a closure pointer
226 for them to use. */
227 struct
228 {
229 /* Functions to call. */
230 const struct lval_funcs *funcs;
231
232 /* Closure for those functions to use. */
233 void *closure;
234 } computed;
235 } location;
236
237 /* Describes offset of a value within lval of a structure in bytes.
238 If lval == lval_memory, this is an offset to the address. If
239 lval == lval_register, this is a further offset from
240 location.address within the registers structure. Note also the
241 member embedded_offset below. */
242 int offset;
243
244 /* Only used for bitfields; number of bits contained in them. */
245 int bitsize;
246
247 /* Only used for bitfields; position of start of field. For
248 gdbarch_bits_big_endian=0 targets, it is the position of the LSB. For
249 gdbarch_bits_big_endian=1 targets, it is the position of the MSB. */
250 int bitpos;
251
252 /* The number of references to this value. When a value is created,
253 the value chain holds a reference, so REFERENCE_COUNT is 1. If
254 release_value is called, this value is removed from the chain but
255 the caller of release_value now has a reference to this value.
256 The caller must arrange for a call to value_free later. */
257 int reference_count;
258
259 /* Only used for bitfields; the containing value. This allows a
260 single read from the target when displaying multiple
261 bitfields. */
262 struct value *parent;
263
264 /* Frame register value is relative to. This will be described in
265 the lval enum above as "lval_register". */
266 struct frame_id frame_id;
267
268 /* Type of the value. */
269 struct type *type;
270
271 /* If a value represents a C++ object, then the `type' field gives
272 the object's compile-time type. If the object actually belongs
273 to some class derived from `type', perhaps with other base
274 classes and additional members, then `type' is just a subobject
275 of the real thing, and the full object is probably larger than
276 `type' would suggest.
277
278 If `type' is a dynamic class (i.e. one with a vtable), then GDB
279 can actually determine the object's run-time type by looking at
280 the run-time type information in the vtable. When this
281 information is available, we may elect to read in the entire
282 object, for several reasons:
283
284 - When printing the value, the user would probably rather see the
285 full object, not just the limited portion apparent from the
286 compile-time type.
287
288 - If `type' has virtual base classes, then even printing `type'
289 alone may require reaching outside the `type' portion of the
290 object to wherever the virtual base class has been stored.
291
292 When we store the entire object, `enclosing_type' is the run-time
293 type -- the complete object -- and `embedded_offset' is the
294 offset of `type' within that larger type, in bytes. The
295 value_contents() macro takes `embedded_offset' into account, so
296 most GDB code continues to see the `type' portion of the value,
297 just as the inferior would.
298
299 If `type' is a pointer to an object, then `enclosing_type' is a
300 pointer to the object's run-time type, and `pointed_to_offset' is
301 the offset in bytes from the full object to the pointed-to object
302 -- that is, the value `embedded_offset' would have if we followed
303 the pointer and fetched the complete object. (I don't really see
304 the point. Why not just determine the run-time type when you
305 indirect, and avoid the special case? The contents don't matter
306 until you indirect anyway.)
307
308 If we're not doing anything fancy, `enclosing_type' is equal to
309 `type', and `embedded_offset' is zero, so everything works
310 normally. */
311 struct type *enclosing_type;
312 int embedded_offset;
313 int pointed_to_offset;
314
315 /* Values are stored in a chain, so that they can be deleted easily
316 over calls to the inferior. Values assigned to internal
317 variables, put into the value history or exposed to Python are
318 taken off this list. */
319 struct value *next;
320
321 /* Register number if the value is from a register. */
322 short regnum;
323
324 /* Actual contents of the value. Target byte-order. NULL or not
325 valid if lazy is nonzero. */
326 gdb_byte *contents;
327
328 /* Unavailable ranges in CONTENTS. We mark unavailable ranges,
329 rather than available, since the common and default case is for a
330 value to be available. This is filled in at value read time. */
331 VEC(range_s) *unavailable;
332 };
333
334 int
335 value_bytes_available (const struct value *value, int offset, int length)
336 {
337 gdb_assert (!value->lazy);
338
339 return !ranges_contain (value->unavailable, offset, length);
340 }
341
342 int
343 value_entirely_available (struct value *value)
344 {
345 /* We can only tell whether the whole value is available when we try
346 to read it. */
347 if (value->lazy)
348 value_fetch_lazy (value);
349
350 if (VEC_empty (range_s, value->unavailable))
351 return 1;
352 return 0;
353 }
354
355 void
356 mark_value_bytes_unavailable (struct value *value, int offset, int length)
357 {
358 range_s newr;
359 int i;
360
361 /* Insert the range sorted. If there's overlap or the new range
362 would be contiguous with an existing range, merge. */
363
364 newr.offset = offset;
365 newr.length = length;
366
367 /* Do a binary search for the position the given range would be
368 inserted if we only considered the starting OFFSET of ranges.
369 Call that position I. Since we also have LENGTH to care for
370 (this is a range afterall), we need to check if the _previous_
371 range overlaps the I range. E.g., calling R the new range:
372
373 #1 - overlaps with previous
374
375 R
376 |-...-|
377 |---| |---| |------| ... |--|
378 0 1 2 N
379
380 I=1
381
382 In the case #1 above, the binary search would return `I=1',
383 meaning, this OFFSET should be inserted at position 1, and the
384 current position 1 should be pushed further (and become 2). But,
385 note that `0' overlaps with R, so we want to merge them.
386
387 A similar consideration needs to be taken if the new range would
388 be contiguous with the previous range:
389
390 #2 - contiguous with previous
391
392 R
393 |-...-|
394 |--| |---| |------| ... |--|
395 0 1 2 N
396
397 I=1
398
399 If there's no overlap with the previous range, as in:
400
401 #3 - not overlapping and not contiguous
402
403 R
404 |-...-|
405 |--| |---| |------| ... |--|
406 0 1 2 N
407
408 I=1
409
410 or if I is 0:
411
412 #4 - R is the range with lowest offset
413
414 R
415 |-...-|
416 |--| |---| |------| ... |--|
417 0 1 2 N
418
419 I=0
420
421 ... we just push the new range to I.
422
423 All the 4 cases above need to consider that the new range may
424 also overlap several of the ranges that follow, or that R may be
425 contiguous with the following range, and merge. E.g.,
426
427 #5 - overlapping following ranges
428
429 R
430 |------------------------|
431 |--| |---| |------| ... |--|
432 0 1 2 N
433
434 I=0
435
436 or:
437
438 R
439 |-------|
440 |--| |---| |------| ... |--|
441 0 1 2 N
442
443 I=1
444
445 */
446
447 i = VEC_lower_bound (range_s, value->unavailable, &newr, range_lessthan);
448 if (i > 0)
449 {
450 struct range *bef = VEC_index (range_s, value->unavailable, i - 1);
451
452 if (ranges_overlap (bef->offset, bef->length, offset, length))
453 {
454 /* #1 */
455 ULONGEST l = min (bef->offset, offset);
456 ULONGEST h = max (bef->offset + bef->length, offset + length);
457
458 bef->offset = l;
459 bef->length = h - l;
460 i--;
461 }
462 else if (offset == bef->offset + bef->length)
463 {
464 /* #2 */
465 bef->length += length;
466 i--;
467 }
468 else
469 {
470 /* #3 */
471 VEC_safe_insert (range_s, value->unavailable, i, &newr);
472 }
473 }
474 else
475 {
476 /* #4 */
477 VEC_safe_insert (range_s, value->unavailable, i, &newr);
478 }
479
480 /* Check whether the ranges following the one we've just added or
481 touched can be folded in (#5 above). */
482 if (i + 1 < VEC_length (range_s, value->unavailable))
483 {
484 struct range *t;
485 struct range *r;
486 int removed = 0;
487 int next = i + 1;
488
489 /* Get the range we just touched. */
490 t = VEC_index (range_s, value->unavailable, i);
491 removed = 0;
492
493 i = next;
494 for (; VEC_iterate (range_s, value->unavailable, i, r); i++)
495 if (r->offset <= t->offset + t->length)
496 {
497 ULONGEST l, h;
498
499 l = min (t->offset, r->offset);
500 h = max (t->offset + t->length, r->offset + r->length);
501
502 t->offset = l;
503 t->length = h - l;
504
505 removed++;
506 }
507 else
508 {
509 /* If we couldn't merge this one, we won't be able to
510 merge following ones either, since the ranges are
511 always sorted by OFFSET. */
512 break;
513 }
514
515 if (removed != 0)
516 VEC_block_remove (range_s, value->unavailable, next, removed);
517 }
518 }
519
520 /* Find the first range in RANGES that overlaps the range defined by
521 OFFSET and LENGTH, starting at element POS in the RANGES vector,
522 Returns the index into RANGES where such overlapping range was
523 found, or -1 if none was found. */
524
525 static int
526 find_first_range_overlap (VEC(range_s) *ranges, int pos,
527 int offset, int length)
528 {
529 range_s *r;
530 int i;
531
532 for (i = pos; VEC_iterate (range_s, ranges, i, r); i++)
533 if (ranges_overlap (r->offset, r->length, offset, length))
534 return i;
535
536 return -1;
537 }
538
539 int
540 value_available_contents_eq (const struct value *val1, int offset1,
541 const struct value *val2, int offset2,
542 int length)
543 {
544 int idx1 = 0, idx2 = 0;
545
546 /* This routine is used by printing routines, where we should
547 already have read the value. Note that we only know whether a
548 value chunk is available if we've tried to read it. */
549 gdb_assert (!val1->lazy && !val2->lazy);
550
551 while (length > 0)
552 {
553 range_s *r1, *r2;
554 ULONGEST l1, h1;
555 ULONGEST l2, h2;
556
557 idx1 = find_first_range_overlap (val1->unavailable, idx1,
558 offset1, length);
559 idx2 = find_first_range_overlap (val2->unavailable, idx2,
560 offset2, length);
561
562 /* The usual case is for both values to be completely available. */
563 if (idx1 == -1 && idx2 == -1)
564 return (memcmp (val1->contents + offset1,
565 val2->contents + offset2,
566 length) == 0);
567 /* The contents only match equal if the available set matches as
568 well. */
569 else if (idx1 == -1 || idx2 == -1)
570 return 0;
571
572 gdb_assert (idx1 != -1 && idx2 != -1);
573
574 r1 = VEC_index (range_s, val1->unavailable, idx1);
575 r2 = VEC_index (range_s, val2->unavailable, idx2);
576
577 /* Get the unavailable windows intersected by the incoming
578 ranges. The first and last ranges that overlap the argument
579 range may be wider than said incoming arguments ranges. */
580 l1 = max (offset1, r1->offset);
581 h1 = min (offset1 + length, r1->offset + r1->length);
582
583 l2 = max (offset2, r2->offset);
584 h2 = min (offset2 + length, r2->offset + r2->length);
585
586 /* Make them relative to the respective start offsets, so we can
587 compare them for equality. */
588 l1 -= offset1;
589 h1 -= offset1;
590
591 l2 -= offset2;
592 h2 -= offset2;
593
594 /* Different availability, no match. */
595 if (l1 != l2 || h1 != h2)
596 return 0;
597
598 /* Compare the _available_ contents. */
599 if (memcmp (val1->contents + offset1,
600 val2->contents + offset2,
601 l1) != 0)
602 return 0;
603
604 length -= h1;
605 offset1 += h1;
606 offset2 += h1;
607 }
608
609 return 1;
610 }
611
612 /* Prototypes for local functions. */
613
614 static void show_values (char *, int);
615
616 static void show_convenience (char *, int);
617
618
619 /* The value-history records all the values printed
620 by print commands during this session. Each chunk
621 records 60 consecutive values. The first chunk on
622 the chain records the most recent values.
623 The total number of values is in value_history_count. */
624
625 #define VALUE_HISTORY_CHUNK 60
626
627 struct value_history_chunk
628 {
629 struct value_history_chunk *next;
630 struct value *values[VALUE_HISTORY_CHUNK];
631 };
632
633 /* Chain of chunks now in use. */
634
635 static struct value_history_chunk *value_history_chain;
636
637 static int value_history_count; /* Abs number of last entry stored. */
638
639 \f
640 /* List of all value objects currently allocated
641 (except for those released by calls to release_value)
642 This is so they can be freed after each command. */
643
644 static struct value *all_values;
645
646 /* Allocate a lazy value for type TYPE. Its actual content is
647 "lazily" allocated too: the content field of the return value is
648 NULL; it will be allocated when it is fetched from the target. */
649
650 struct value *
651 allocate_value_lazy (struct type *type)
652 {
653 struct value *val;
654
655 /* Call check_typedef on our type to make sure that, if TYPE
656 is a TYPE_CODE_TYPEDEF, its length is set to the length
657 of the target type instead of zero. However, we do not
658 replace the typedef type by the target type, because we want
659 to keep the typedef in order to be able to set the VAL's type
660 description correctly. */
661 check_typedef (type);
662
663 val = (struct value *) xzalloc (sizeof (struct value));
664 val->contents = NULL;
665 val->next = all_values;
666 all_values = val;
667 val->type = type;
668 val->enclosing_type = type;
669 VALUE_LVAL (val) = not_lval;
670 val->location.address = 0;
671 VALUE_FRAME_ID (val) = null_frame_id;
672 val->offset = 0;
673 val->bitpos = 0;
674 val->bitsize = 0;
675 VALUE_REGNUM (val) = -1;
676 val->lazy = 1;
677 val->optimized_out = 0;
678 val->embedded_offset = 0;
679 val->pointed_to_offset = 0;
680 val->modifiable = 1;
681 val->initialized = 1; /* Default to initialized. */
682
683 /* Values start out on the all_values chain. */
684 val->reference_count = 1;
685
686 return val;
687 }
688
689 /* Allocate the contents of VAL if it has not been allocated yet. */
690
691 void
692 allocate_value_contents (struct value *val)
693 {
694 if (!val->contents)
695 val->contents = (gdb_byte *) xzalloc (TYPE_LENGTH (val->enclosing_type));
696 }
697
698 /* Allocate a value and its contents for type TYPE. */
699
700 struct value *
701 allocate_value (struct type *type)
702 {
703 struct value *val = allocate_value_lazy (type);
704
705 allocate_value_contents (val);
706 val->lazy = 0;
707 return val;
708 }
709
710 /* Allocate a value that has the correct length
711 for COUNT repetitions of type TYPE. */
712
713 struct value *
714 allocate_repeat_value (struct type *type, int count)
715 {
716 int low_bound = current_language->string_lower_bound; /* ??? */
717 /* FIXME-type-allocation: need a way to free this type when we are
718 done with it. */
719 struct type *array_type
720 = lookup_array_range_type (type, low_bound, count + low_bound - 1);
721
722 return allocate_value (array_type);
723 }
724
725 struct value *
726 allocate_computed_value (struct type *type,
727 const struct lval_funcs *funcs,
728 void *closure)
729 {
730 struct value *v = allocate_value_lazy (type);
731
732 VALUE_LVAL (v) = lval_computed;
733 v->location.computed.funcs = funcs;
734 v->location.computed.closure = closure;
735
736 return v;
737 }
738
739 /* Allocate NOT_LVAL value for type TYPE being OPTIMIZED_OUT. */
740
741 struct value *
742 allocate_optimized_out_value (struct type *type)
743 {
744 struct value *retval = allocate_value_lazy (type);
745
746 set_value_optimized_out (retval, 1);
747
748 return retval;
749 }
750
751 /* Accessor methods. */
752
753 struct value *
754 value_next (struct value *value)
755 {
756 return value->next;
757 }
758
759 struct type *
760 value_type (const struct value *value)
761 {
762 return value->type;
763 }
764 void
765 deprecated_set_value_type (struct value *value, struct type *type)
766 {
767 value->type = type;
768 }
769
770 int
771 value_offset (const struct value *value)
772 {
773 return value->offset;
774 }
775 void
776 set_value_offset (struct value *value, int offset)
777 {
778 value->offset = offset;
779 }
780
781 int
782 value_bitpos (const struct value *value)
783 {
784 return value->bitpos;
785 }
786 void
787 set_value_bitpos (struct value *value, int bit)
788 {
789 value->bitpos = bit;
790 }
791
792 int
793 value_bitsize (const struct value *value)
794 {
795 return value->bitsize;
796 }
797 void
798 set_value_bitsize (struct value *value, int bit)
799 {
800 value->bitsize = bit;
801 }
802
803 struct value *
804 value_parent (struct value *value)
805 {
806 return value->parent;
807 }
808
809 /* See value.h. */
810
811 void
812 set_value_parent (struct value *value, struct value *parent)
813 {
814 value->parent = parent;
815 }
816
817 gdb_byte *
818 value_contents_raw (struct value *value)
819 {
820 allocate_value_contents (value);
821 return value->contents + value->embedded_offset;
822 }
823
824 gdb_byte *
825 value_contents_all_raw (struct value *value)
826 {
827 allocate_value_contents (value);
828 return value->contents;
829 }
830
831 struct type *
832 value_enclosing_type (struct value *value)
833 {
834 return value->enclosing_type;
835 }
836
837 /* Look at value.h for description. */
838
839 struct type *
840 value_actual_type (struct value *value, int resolve_simple_types,
841 int *real_type_found)
842 {
843 struct value_print_options opts;
844 struct type *result;
845
846 get_user_print_options (&opts);
847
848 if (real_type_found)
849 *real_type_found = 0;
850 result = value_type (value);
851 if (opts.objectprint)
852 {
853 if (TYPE_CODE (result) == TYPE_CODE_PTR
854 || TYPE_CODE (result) == TYPE_CODE_REF)
855 {
856 struct type *real_type;
857
858 real_type = value_rtti_indirect_type (value, NULL, NULL, NULL);
859 if (real_type)
860 {
861 if (real_type_found)
862 *real_type_found = 1;
863 result = real_type;
864 }
865 }
866 else if (resolve_simple_types)
867 {
868 if (real_type_found)
869 *real_type_found = 1;
870 result = value_enclosing_type (value);
871 }
872 }
873
874 return result;
875 }
876
877 static void
878 require_not_optimized_out (const struct value *value)
879 {
880 if (value->optimized_out)
881 error (_("value has been optimized out"));
882 }
883
884 static void
885 require_available (const struct value *value)
886 {
887 if (!VEC_empty (range_s, value->unavailable))
888 throw_error (NOT_AVAILABLE_ERROR, _("value is not available"));
889 }
890
891 const gdb_byte *
892 value_contents_for_printing (struct value *value)
893 {
894 if (value->lazy)
895 value_fetch_lazy (value);
896 return value->contents;
897 }
898
899 const gdb_byte *
900 value_contents_for_printing_const (const struct value *value)
901 {
902 gdb_assert (!value->lazy);
903 return value->contents;
904 }
905
906 const gdb_byte *
907 value_contents_all (struct value *value)
908 {
909 const gdb_byte *result = value_contents_for_printing (value);
910 require_not_optimized_out (value);
911 require_available (value);
912 return result;
913 }
914
915 /* Copy LENGTH bytes of SRC value's (all) contents
916 (value_contents_all) starting at SRC_OFFSET, into DST value's (all)
917 contents, starting at DST_OFFSET. If unavailable contents are
918 being copied from SRC, the corresponding DST contents are marked
919 unavailable accordingly. Neither DST nor SRC may be lazy
920 values.
921
922 It is assumed the contents of DST in the [DST_OFFSET,
923 DST_OFFSET+LENGTH) range are wholly available. */
924
925 void
926 value_contents_copy_raw (struct value *dst, int dst_offset,
927 struct value *src, int src_offset, int length)
928 {
929 range_s *r;
930 int i;
931
932 /* A lazy DST would make that this copy operation useless, since as
933 soon as DST's contents were un-lazied (by a later value_contents
934 call, say), the contents would be overwritten. A lazy SRC would
935 mean we'd be copying garbage. */
936 gdb_assert (!dst->lazy && !src->lazy);
937
938 /* The overwritten DST range gets unavailability ORed in, not
939 replaced. Make sure to remember to implement replacing if it
940 turns out actually necessary. */
941 gdb_assert (value_bytes_available (dst, dst_offset, length));
942
943 /* Copy the data. */
944 memcpy (value_contents_all_raw (dst) + dst_offset,
945 value_contents_all_raw (src) + src_offset,
946 length);
947
948 /* Copy the meta-data, adjusted. */
949 for (i = 0; VEC_iterate (range_s, src->unavailable, i, r); i++)
950 {
951 ULONGEST h, l;
952
953 l = max (r->offset, src_offset);
954 h = min (r->offset + r->length, src_offset + length);
955
956 if (l < h)
957 mark_value_bytes_unavailable (dst,
958 dst_offset + (l - src_offset),
959 h - l);
960 }
961 }
962
963 /* Copy LENGTH bytes of SRC value's (all) contents
964 (value_contents_all) starting at SRC_OFFSET byte, into DST value's
965 (all) contents, starting at DST_OFFSET. If unavailable contents
966 are being copied from SRC, the corresponding DST contents are
967 marked unavailable accordingly. DST must not be lazy. If SRC is
968 lazy, it will be fetched now. If SRC is not valid (is optimized
969 out), an error is thrown.
970
971 It is assumed the contents of DST in the [DST_OFFSET,
972 DST_OFFSET+LENGTH) range are wholly available. */
973
974 void
975 value_contents_copy (struct value *dst, int dst_offset,
976 struct value *src, int src_offset, int length)
977 {
978 require_not_optimized_out (src);
979
980 if (src->lazy)
981 value_fetch_lazy (src);
982
983 value_contents_copy_raw (dst, dst_offset, src, src_offset, length);
984 }
985
986 int
987 value_lazy (struct value *value)
988 {
989 return value->lazy;
990 }
991
992 void
993 set_value_lazy (struct value *value, int val)
994 {
995 value->lazy = val;
996 }
997
998 int
999 value_stack (struct value *value)
1000 {
1001 return value->stack;
1002 }
1003
1004 void
1005 set_value_stack (struct value *value, int val)
1006 {
1007 value->stack = val;
1008 }
1009
1010 const gdb_byte *
1011 value_contents (struct value *value)
1012 {
1013 const gdb_byte *result = value_contents_writeable (value);
1014 require_not_optimized_out (value);
1015 require_available (value);
1016 return result;
1017 }
1018
1019 gdb_byte *
1020 value_contents_writeable (struct value *value)
1021 {
1022 if (value->lazy)
1023 value_fetch_lazy (value);
1024 return value_contents_raw (value);
1025 }
1026
1027 /* Return non-zero if VAL1 and VAL2 have the same contents. Note that
1028 this function is different from value_equal; in C the operator ==
1029 can return 0 even if the two values being compared are equal. */
1030
1031 int
1032 value_contents_equal (struct value *val1, struct value *val2)
1033 {
1034 struct type *type1;
1035 struct type *type2;
1036
1037 type1 = check_typedef (value_type (val1));
1038 type2 = check_typedef (value_type (val2));
1039 if (TYPE_LENGTH (type1) != TYPE_LENGTH (type2))
1040 return 0;
1041
1042 return (memcmp (value_contents (val1), value_contents (val2),
1043 TYPE_LENGTH (type1)) == 0);
1044 }
1045
1046 int
1047 value_optimized_out (struct value *value)
1048 {
1049 return value->optimized_out;
1050 }
1051
1052 void
1053 set_value_optimized_out (struct value *value, int val)
1054 {
1055 value->optimized_out = val;
1056 }
1057
1058 int
1059 value_entirely_optimized_out (const struct value *value)
1060 {
1061 if (!value->optimized_out)
1062 return 0;
1063 if (value->lval != lval_computed
1064 || !value->location.computed.funcs->check_any_valid)
1065 return 1;
1066 return !value->location.computed.funcs->check_any_valid (value);
1067 }
1068
1069 int
1070 value_bits_valid (const struct value *value, int offset, int length)
1071 {
1072 if (!value->optimized_out)
1073 return 1;
1074 if (value->lval != lval_computed
1075 || !value->location.computed.funcs->check_validity)
1076 return 0;
1077 return value->location.computed.funcs->check_validity (value, offset,
1078 length);
1079 }
1080
1081 int
1082 value_bits_synthetic_pointer (const struct value *value,
1083 int offset, int length)
1084 {
1085 if (value->lval != lval_computed
1086 || !value->location.computed.funcs->check_synthetic_pointer)
1087 return 0;
1088 return value->location.computed.funcs->check_synthetic_pointer (value,
1089 offset,
1090 length);
1091 }
1092
1093 int
1094 value_embedded_offset (struct value *value)
1095 {
1096 return value->embedded_offset;
1097 }
1098
1099 void
1100 set_value_embedded_offset (struct value *value, int val)
1101 {
1102 value->embedded_offset = val;
1103 }
1104
1105 int
1106 value_pointed_to_offset (struct value *value)
1107 {
1108 return value->pointed_to_offset;
1109 }
1110
1111 void
1112 set_value_pointed_to_offset (struct value *value, int val)
1113 {
1114 value->pointed_to_offset = val;
1115 }
1116
1117 const struct lval_funcs *
1118 value_computed_funcs (const struct value *v)
1119 {
1120 gdb_assert (value_lval_const (v) == lval_computed);
1121
1122 return v->location.computed.funcs;
1123 }
1124
1125 void *
1126 value_computed_closure (const struct value *v)
1127 {
1128 gdb_assert (v->lval == lval_computed);
1129
1130 return v->location.computed.closure;
1131 }
1132
1133 enum lval_type *
1134 deprecated_value_lval_hack (struct value *value)
1135 {
1136 return &value->lval;
1137 }
1138
1139 enum lval_type
1140 value_lval_const (const struct value *value)
1141 {
1142 return value->lval;
1143 }
1144
1145 CORE_ADDR
1146 value_address (const struct value *value)
1147 {
1148 if (value->lval == lval_internalvar
1149 || value->lval == lval_internalvar_component)
1150 return 0;
1151 if (value->parent != NULL)
1152 return value_address (value->parent) + value->offset;
1153 else
1154 return value->location.address + value->offset;
1155 }
1156
1157 CORE_ADDR
1158 value_raw_address (struct value *value)
1159 {
1160 if (value->lval == lval_internalvar
1161 || value->lval == lval_internalvar_component)
1162 return 0;
1163 return value->location.address;
1164 }
1165
1166 void
1167 set_value_address (struct value *value, CORE_ADDR addr)
1168 {
1169 gdb_assert (value->lval != lval_internalvar
1170 && value->lval != lval_internalvar_component);
1171 value->location.address = addr;
1172 }
1173
1174 struct internalvar **
1175 deprecated_value_internalvar_hack (struct value *value)
1176 {
1177 return &value->location.internalvar;
1178 }
1179
1180 struct frame_id *
1181 deprecated_value_frame_id_hack (struct value *value)
1182 {
1183 return &value->frame_id;
1184 }
1185
1186 short *
1187 deprecated_value_regnum_hack (struct value *value)
1188 {
1189 return &value->regnum;
1190 }
1191
1192 int
1193 deprecated_value_modifiable (struct value *value)
1194 {
1195 return value->modifiable;
1196 }
1197 void
1198 deprecated_set_value_modifiable (struct value *value, int modifiable)
1199 {
1200 value->modifiable = modifiable;
1201 }
1202 \f
1203 /* Return a mark in the value chain. All values allocated after the
1204 mark is obtained (except for those released) are subject to being freed
1205 if a subsequent value_free_to_mark is passed the mark. */
1206 struct value *
1207 value_mark (void)
1208 {
1209 return all_values;
1210 }
1211
1212 /* Take a reference to VAL. VAL will not be deallocated until all
1213 references are released. */
1214
1215 void
1216 value_incref (struct value *val)
1217 {
1218 val->reference_count++;
1219 }
1220
1221 /* Release a reference to VAL, which was acquired with value_incref.
1222 This function is also called to deallocate values from the value
1223 chain. */
1224
1225 void
1226 value_free (struct value *val)
1227 {
1228 if (val)
1229 {
1230 gdb_assert (val->reference_count > 0);
1231 val->reference_count--;
1232 if (val->reference_count > 0)
1233 return;
1234
1235 /* If there's an associated parent value, drop our reference to
1236 it. */
1237 if (val->parent != NULL)
1238 value_free (val->parent);
1239
1240 if (VALUE_LVAL (val) == lval_computed)
1241 {
1242 const struct lval_funcs *funcs = val->location.computed.funcs;
1243
1244 if (funcs->free_closure)
1245 funcs->free_closure (val);
1246 }
1247
1248 xfree (val->contents);
1249 VEC_free (range_s, val->unavailable);
1250 }
1251 xfree (val);
1252 }
1253
1254 /* Free all values allocated since MARK was obtained by value_mark
1255 (except for those released). */
1256 void
1257 value_free_to_mark (struct value *mark)
1258 {
1259 struct value *val;
1260 struct value *next;
1261
1262 for (val = all_values; val && val != mark; val = next)
1263 {
1264 next = val->next;
1265 val->released = 1;
1266 value_free (val);
1267 }
1268 all_values = val;
1269 }
1270
1271 /* Free all the values that have been allocated (except for those released).
1272 Call after each command, successful or not.
1273 In practice this is called before each command, which is sufficient. */
1274
1275 void
1276 free_all_values (void)
1277 {
1278 struct value *val;
1279 struct value *next;
1280
1281 for (val = all_values; val; val = next)
1282 {
1283 next = val->next;
1284 val->released = 1;
1285 value_free (val);
1286 }
1287
1288 all_values = 0;
1289 }
1290
1291 /* Frees all the elements in a chain of values. */
1292
1293 void
1294 free_value_chain (struct value *v)
1295 {
1296 struct value *next;
1297
1298 for (; v; v = next)
1299 {
1300 next = value_next (v);
1301 value_free (v);
1302 }
1303 }
1304
1305 /* Remove VAL from the chain all_values
1306 so it will not be freed automatically. */
1307
1308 void
1309 release_value (struct value *val)
1310 {
1311 struct value *v;
1312
1313 if (all_values == val)
1314 {
1315 all_values = val->next;
1316 val->next = NULL;
1317 val->released = 1;
1318 return;
1319 }
1320
1321 for (v = all_values; v; v = v->next)
1322 {
1323 if (v->next == val)
1324 {
1325 v->next = val->next;
1326 val->next = NULL;
1327 val->released = 1;
1328 break;
1329 }
1330 }
1331 }
1332
1333 /* If the value is not already released, release it.
1334 If the value is already released, increment its reference count.
1335 That is, this function ensures that the value is released from the
1336 value chain and that the caller owns a reference to it. */
1337
1338 void
1339 release_value_or_incref (struct value *val)
1340 {
1341 if (val->released)
1342 value_incref (val);
1343 else
1344 release_value (val);
1345 }
1346
1347 /* Release all values up to mark */
1348 struct value *
1349 value_release_to_mark (struct value *mark)
1350 {
1351 struct value *val;
1352 struct value *next;
1353
1354 for (val = next = all_values; next; next = next->next)
1355 {
1356 if (next->next == mark)
1357 {
1358 all_values = next->next;
1359 next->next = NULL;
1360 return val;
1361 }
1362 next->released = 1;
1363 }
1364 all_values = 0;
1365 return val;
1366 }
1367
1368 /* Return a copy of the value ARG.
1369 It contains the same contents, for same memory address,
1370 but it's a different block of storage. */
1371
1372 struct value *
1373 value_copy (struct value *arg)
1374 {
1375 struct type *encl_type = value_enclosing_type (arg);
1376 struct value *val;
1377
1378 if (value_lazy (arg))
1379 val = allocate_value_lazy (encl_type);
1380 else
1381 val = allocate_value (encl_type);
1382 val->type = arg->type;
1383 VALUE_LVAL (val) = VALUE_LVAL (arg);
1384 val->location = arg->location;
1385 val->offset = arg->offset;
1386 val->bitpos = arg->bitpos;
1387 val->bitsize = arg->bitsize;
1388 VALUE_FRAME_ID (val) = VALUE_FRAME_ID (arg);
1389 VALUE_REGNUM (val) = VALUE_REGNUM (arg);
1390 val->lazy = arg->lazy;
1391 val->optimized_out = arg->optimized_out;
1392 val->embedded_offset = value_embedded_offset (arg);
1393 val->pointed_to_offset = arg->pointed_to_offset;
1394 val->modifiable = arg->modifiable;
1395 if (!value_lazy (val))
1396 {
1397 memcpy (value_contents_all_raw (val), value_contents_all_raw (arg),
1398 TYPE_LENGTH (value_enclosing_type (arg)));
1399
1400 }
1401 val->unavailable = VEC_copy (range_s, arg->unavailable);
1402 val->parent = arg->parent;
1403 if (val->parent)
1404 value_incref (val->parent);
1405 if (VALUE_LVAL (val) == lval_computed)
1406 {
1407 const struct lval_funcs *funcs = val->location.computed.funcs;
1408
1409 if (funcs->copy_closure)
1410 val->location.computed.closure = funcs->copy_closure (val);
1411 }
1412 return val;
1413 }
1414
1415 /* Return a version of ARG that is non-lvalue. */
1416
1417 struct value *
1418 value_non_lval (struct value *arg)
1419 {
1420 if (VALUE_LVAL (arg) != not_lval)
1421 {
1422 struct type *enc_type = value_enclosing_type (arg);
1423 struct value *val = allocate_value (enc_type);
1424
1425 memcpy (value_contents_all_raw (val), value_contents_all (arg),
1426 TYPE_LENGTH (enc_type));
1427 val->type = arg->type;
1428 set_value_embedded_offset (val, value_embedded_offset (arg));
1429 set_value_pointed_to_offset (val, value_pointed_to_offset (arg));
1430 return val;
1431 }
1432 return arg;
1433 }
1434
1435 void
1436 set_value_component_location (struct value *component,
1437 const struct value *whole)
1438 {
1439 if (whole->lval == lval_internalvar)
1440 VALUE_LVAL (component) = lval_internalvar_component;
1441 else
1442 VALUE_LVAL (component) = whole->lval;
1443
1444 component->location = whole->location;
1445 if (whole->lval == lval_computed)
1446 {
1447 const struct lval_funcs *funcs = whole->location.computed.funcs;
1448
1449 if (funcs->copy_closure)
1450 component->location.computed.closure = funcs->copy_closure (whole);
1451 }
1452 }
1453
1454 \f
1455 /* Access to the value history. */
1456
1457 /* Record a new value in the value history.
1458 Returns the absolute history index of the entry.
1459 Result of -1 indicates the value was not saved; otherwise it is the
1460 value history index of this new item. */
1461
1462 int
1463 record_latest_value (struct value *val)
1464 {
1465 int i;
1466
1467 /* We don't want this value to have anything to do with the inferior anymore.
1468 In particular, "set $1 = 50" should not affect the variable from which
1469 the value was taken, and fast watchpoints should be able to assume that
1470 a value on the value history never changes. */
1471 if (value_lazy (val))
1472 value_fetch_lazy (val);
1473 /* We preserve VALUE_LVAL so that the user can find out where it was fetched
1474 from. This is a bit dubious, because then *&$1 does not just return $1
1475 but the current contents of that location. c'est la vie... */
1476 val->modifiable = 0;
1477 release_value (val);
1478
1479 /* Here we treat value_history_count as origin-zero
1480 and applying to the value being stored now. */
1481
1482 i = value_history_count % VALUE_HISTORY_CHUNK;
1483 if (i == 0)
1484 {
1485 struct value_history_chunk *new
1486 = (struct value_history_chunk *)
1487
1488 xmalloc (sizeof (struct value_history_chunk));
1489 memset (new->values, 0, sizeof new->values);
1490 new->next = value_history_chain;
1491 value_history_chain = new;
1492 }
1493
1494 value_history_chain->values[i] = val;
1495
1496 /* Now we regard value_history_count as origin-one
1497 and applying to the value just stored. */
1498
1499 return ++value_history_count;
1500 }
1501
1502 /* Return a copy of the value in the history with sequence number NUM. */
1503
1504 struct value *
1505 access_value_history (int num)
1506 {
1507 struct value_history_chunk *chunk;
1508 int i;
1509 int absnum = num;
1510
1511 if (absnum <= 0)
1512 absnum += value_history_count;
1513
1514 if (absnum <= 0)
1515 {
1516 if (num == 0)
1517 error (_("The history is empty."));
1518 else if (num == 1)
1519 error (_("There is only one value in the history."));
1520 else
1521 error (_("History does not go back to $$%d."), -num);
1522 }
1523 if (absnum > value_history_count)
1524 error (_("History has not yet reached $%d."), absnum);
1525
1526 absnum--;
1527
1528 /* Now absnum is always absolute and origin zero. */
1529
1530 chunk = value_history_chain;
1531 for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK
1532 - absnum / VALUE_HISTORY_CHUNK;
1533 i > 0; i--)
1534 chunk = chunk->next;
1535
1536 return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]);
1537 }
1538
1539 static void
1540 show_values (char *num_exp, int from_tty)
1541 {
1542 int i;
1543 struct value *val;
1544 static int num = 1;
1545
1546 if (num_exp)
1547 {
1548 /* "show values +" should print from the stored position.
1549 "show values <exp>" should print around value number <exp>. */
1550 if (num_exp[0] != '+' || num_exp[1] != '\0')
1551 num = parse_and_eval_long (num_exp) - 5;
1552 }
1553 else
1554 {
1555 /* "show values" means print the last 10 values. */
1556 num = value_history_count - 9;
1557 }
1558
1559 if (num <= 0)
1560 num = 1;
1561
1562 for (i = num; i < num + 10 && i <= value_history_count; i++)
1563 {
1564 struct value_print_options opts;
1565
1566 val = access_value_history (i);
1567 printf_filtered (("$%d = "), i);
1568 get_user_print_options (&opts);
1569 value_print (val, gdb_stdout, &opts);
1570 printf_filtered (("\n"));
1571 }
1572
1573 /* The next "show values +" should start after what we just printed. */
1574 num += 10;
1575
1576 /* Hitting just return after this command should do the same thing as
1577 "show values +". If num_exp is null, this is unnecessary, since
1578 "show values +" is not useful after "show values". */
1579 if (from_tty && num_exp)
1580 {
1581 num_exp[0] = '+';
1582 num_exp[1] = '\0';
1583 }
1584 }
1585 \f
1586 /* Internal variables. These are variables within the debugger
1587 that hold values assigned by debugger commands.
1588 The user refers to them with a '$' prefix
1589 that does not appear in the variable names stored internally. */
1590
1591 struct internalvar
1592 {
1593 struct internalvar *next;
1594 char *name;
1595
1596 /* We support various different kinds of content of an internal variable.
1597 enum internalvar_kind specifies the kind, and union internalvar_data
1598 provides the data associated with this particular kind. */
1599
1600 enum internalvar_kind
1601 {
1602 /* The internal variable is empty. */
1603 INTERNALVAR_VOID,
1604
1605 /* The value of the internal variable is provided directly as
1606 a GDB value object. */
1607 INTERNALVAR_VALUE,
1608
1609 /* A fresh value is computed via a call-back routine on every
1610 access to the internal variable. */
1611 INTERNALVAR_MAKE_VALUE,
1612
1613 /* The internal variable holds a GDB internal convenience function. */
1614 INTERNALVAR_FUNCTION,
1615
1616 /* The variable holds an integer value. */
1617 INTERNALVAR_INTEGER,
1618
1619 /* The variable holds a GDB-provided string. */
1620 INTERNALVAR_STRING,
1621
1622 } kind;
1623
1624 union internalvar_data
1625 {
1626 /* A value object used with INTERNALVAR_VALUE. */
1627 struct value *value;
1628
1629 /* The call-back routine used with INTERNALVAR_MAKE_VALUE. */
1630 struct
1631 {
1632 /* The functions to call. */
1633 const struct internalvar_funcs *functions;
1634
1635 /* The function's user-data. */
1636 void *data;
1637 } make_value;
1638
1639 /* The internal function used with INTERNALVAR_FUNCTION. */
1640 struct
1641 {
1642 struct internal_function *function;
1643 /* True if this is the canonical name for the function. */
1644 int canonical;
1645 } fn;
1646
1647 /* An integer value used with INTERNALVAR_INTEGER. */
1648 struct
1649 {
1650 /* If type is non-NULL, it will be used as the type to generate
1651 a value for this internal variable. If type is NULL, a default
1652 integer type for the architecture is used. */
1653 struct type *type;
1654 LONGEST val;
1655 } integer;
1656
1657 /* A string value used with INTERNALVAR_STRING. */
1658 char *string;
1659 } u;
1660 };
1661
1662 static struct internalvar *internalvars;
1663
1664 /* If the variable does not already exist create it and give it the
1665 value given. If no value is given then the default is zero. */
1666 static void
1667 init_if_undefined_command (char* args, int from_tty)
1668 {
1669 struct internalvar* intvar;
1670
1671 /* Parse the expression - this is taken from set_command(). */
1672 struct expression *expr = parse_expression (args);
1673 register struct cleanup *old_chain =
1674 make_cleanup (free_current_contents, &expr);
1675
1676 /* Validate the expression.
1677 Was the expression an assignment?
1678 Or even an expression at all? */
1679 if (expr->nelts == 0 || expr->elts[0].opcode != BINOP_ASSIGN)
1680 error (_("Init-if-undefined requires an assignment expression."));
1681
1682 /* Extract the variable from the parsed expression.
1683 In the case of an assign the lvalue will be in elts[1] and elts[2]. */
1684 if (expr->elts[1].opcode != OP_INTERNALVAR)
1685 error (_("The first parameter to init-if-undefined "
1686 "should be a GDB variable."));
1687 intvar = expr->elts[2].internalvar;
1688
1689 /* Only evaluate the expression if the lvalue is void.
1690 This may still fail if the expresssion is invalid. */
1691 if (intvar->kind == INTERNALVAR_VOID)
1692 evaluate_expression (expr);
1693
1694 do_cleanups (old_chain);
1695 }
1696
1697
1698 /* Look up an internal variable with name NAME. NAME should not
1699 normally include a dollar sign.
1700
1701 If the specified internal variable does not exist,
1702 the return value is NULL. */
1703
1704 struct internalvar *
1705 lookup_only_internalvar (const char *name)
1706 {
1707 struct internalvar *var;
1708
1709 for (var = internalvars; var; var = var->next)
1710 if (strcmp (var->name, name) == 0)
1711 return var;
1712
1713 return NULL;
1714 }
1715
1716 /* Complete NAME by comparing it to the names of internal variables.
1717 Returns a vector of newly allocated strings, or NULL if no matches
1718 were found. */
1719
1720 VEC (char_ptr) *
1721 complete_internalvar (const char *name)
1722 {
1723 VEC (char_ptr) *result = NULL;
1724 struct internalvar *var;
1725 int len;
1726
1727 len = strlen (name);
1728
1729 for (var = internalvars; var; var = var->next)
1730 if (strncmp (var->name, name, len) == 0)
1731 {
1732 char *r = xstrdup (var->name);
1733
1734 VEC_safe_push (char_ptr, result, r);
1735 }
1736
1737 return result;
1738 }
1739
1740 /* Create an internal variable with name NAME and with a void value.
1741 NAME should not normally include a dollar sign. */
1742
1743 struct internalvar *
1744 create_internalvar (const char *name)
1745 {
1746 struct internalvar *var;
1747
1748 var = (struct internalvar *) xmalloc (sizeof (struct internalvar));
1749 var->name = concat (name, (char *)NULL);
1750 var->kind = INTERNALVAR_VOID;
1751 var->next = internalvars;
1752 internalvars = var;
1753 return var;
1754 }
1755
1756 /* Create an internal variable with name NAME and register FUN as the
1757 function that value_of_internalvar uses to create a value whenever
1758 this variable is referenced. NAME should not normally include a
1759 dollar sign. DATA is passed uninterpreted to FUN when it is
1760 called. CLEANUP, if not NULL, is called when the internal variable
1761 is destroyed. It is passed DATA as its only argument. */
1762
1763 struct internalvar *
1764 create_internalvar_type_lazy (const char *name,
1765 const struct internalvar_funcs *funcs,
1766 void *data)
1767 {
1768 struct internalvar *var = create_internalvar (name);
1769
1770 var->kind = INTERNALVAR_MAKE_VALUE;
1771 var->u.make_value.functions = funcs;
1772 var->u.make_value.data = data;
1773 return var;
1774 }
1775
1776 /* See documentation in value.h. */
1777
1778 int
1779 compile_internalvar_to_ax (struct internalvar *var,
1780 struct agent_expr *expr,
1781 struct axs_value *value)
1782 {
1783 if (var->kind != INTERNALVAR_MAKE_VALUE
1784 || var->u.make_value.functions->compile_to_ax == NULL)
1785 return 0;
1786
1787 var->u.make_value.functions->compile_to_ax (var, expr, value,
1788 var->u.make_value.data);
1789 return 1;
1790 }
1791
1792 /* Look up an internal variable with name NAME. NAME should not
1793 normally include a dollar sign.
1794
1795 If the specified internal variable does not exist,
1796 one is created, with a void value. */
1797
1798 struct internalvar *
1799 lookup_internalvar (const char *name)
1800 {
1801 struct internalvar *var;
1802
1803 var = lookup_only_internalvar (name);
1804 if (var)
1805 return var;
1806
1807 return create_internalvar (name);
1808 }
1809
1810 /* Return current value of internal variable VAR. For variables that
1811 are not inherently typed, use a value type appropriate for GDBARCH. */
1812
1813 struct value *
1814 value_of_internalvar (struct gdbarch *gdbarch, struct internalvar *var)
1815 {
1816 struct value *val;
1817 struct trace_state_variable *tsv;
1818
1819 /* If there is a trace state variable of the same name, assume that
1820 is what we really want to see. */
1821 tsv = find_trace_state_variable (var->name);
1822 if (tsv)
1823 {
1824 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
1825 &(tsv->value));
1826 if (tsv->value_known)
1827 val = value_from_longest (builtin_type (gdbarch)->builtin_int64,
1828 tsv->value);
1829 else
1830 val = allocate_value (builtin_type (gdbarch)->builtin_void);
1831 return val;
1832 }
1833
1834 switch (var->kind)
1835 {
1836 case INTERNALVAR_VOID:
1837 val = allocate_value (builtin_type (gdbarch)->builtin_void);
1838 break;
1839
1840 case INTERNALVAR_FUNCTION:
1841 val = allocate_value (builtin_type (gdbarch)->internal_fn);
1842 break;
1843
1844 case INTERNALVAR_INTEGER:
1845 if (!var->u.integer.type)
1846 val = value_from_longest (builtin_type (gdbarch)->builtin_int,
1847 var->u.integer.val);
1848 else
1849 val = value_from_longest (var->u.integer.type, var->u.integer.val);
1850 break;
1851
1852 case INTERNALVAR_STRING:
1853 val = value_cstring (var->u.string, strlen (var->u.string),
1854 builtin_type (gdbarch)->builtin_char);
1855 break;
1856
1857 case INTERNALVAR_VALUE:
1858 val = value_copy (var->u.value);
1859 if (value_lazy (val))
1860 value_fetch_lazy (val);
1861 break;
1862
1863 case INTERNALVAR_MAKE_VALUE:
1864 val = (*var->u.make_value.functions->make_value) (gdbarch, var,
1865 var->u.make_value.data);
1866 break;
1867
1868 default:
1869 internal_error (__FILE__, __LINE__, _("bad kind"));
1870 }
1871
1872 /* Change the VALUE_LVAL to lval_internalvar so that future operations
1873 on this value go back to affect the original internal variable.
1874
1875 Do not do this for INTERNALVAR_MAKE_VALUE variables, as those have
1876 no underlying modifyable state in the internal variable.
1877
1878 Likewise, if the variable's value is a computed lvalue, we want
1879 references to it to produce another computed lvalue, where
1880 references and assignments actually operate through the
1881 computed value's functions.
1882
1883 This means that internal variables with computed values
1884 behave a little differently from other internal variables:
1885 assignments to them don't just replace the previous value
1886 altogether. At the moment, this seems like the behavior we
1887 want. */
1888
1889 if (var->kind != INTERNALVAR_MAKE_VALUE
1890 && val->lval != lval_computed)
1891 {
1892 VALUE_LVAL (val) = lval_internalvar;
1893 VALUE_INTERNALVAR (val) = var;
1894 }
1895
1896 return val;
1897 }
1898
1899 int
1900 get_internalvar_integer (struct internalvar *var, LONGEST *result)
1901 {
1902 if (var->kind == INTERNALVAR_INTEGER)
1903 {
1904 *result = var->u.integer.val;
1905 return 1;
1906 }
1907
1908 if (var->kind == INTERNALVAR_VALUE)
1909 {
1910 struct type *type = check_typedef (value_type (var->u.value));
1911
1912 if (TYPE_CODE (type) == TYPE_CODE_INT)
1913 {
1914 *result = value_as_long (var->u.value);
1915 return 1;
1916 }
1917 }
1918
1919 return 0;
1920 }
1921
1922 static int
1923 get_internalvar_function (struct internalvar *var,
1924 struct internal_function **result)
1925 {
1926 switch (var->kind)
1927 {
1928 case INTERNALVAR_FUNCTION:
1929 *result = var->u.fn.function;
1930 return 1;
1931
1932 default:
1933 return 0;
1934 }
1935 }
1936
1937 void
1938 set_internalvar_component (struct internalvar *var, int offset, int bitpos,
1939 int bitsize, struct value *newval)
1940 {
1941 gdb_byte *addr;
1942
1943 switch (var->kind)
1944 {
1945 case INTERNALVAR_VALUE:
1946 addr = value_contents_writeable (var->u.value);
1947
1948 if (bitsize)
1949 modify_field (value_type (var->u.value), addr + offset,
1950 value_as_long (newval), bitpos, bitsize);
1951 else
1952 memcpy (addr + offset, value_contents (newval),
1953 TYPE_LENGTH (value_type (newval)));
1954 break;
1955
1956 default:
1957 /* We can never get a component of any other kind. */
1958 internal_error (__FILE__, __LINE__, _("set_internalvar_component"));
1959 }
1960 }
1961
1962 void
1963 set_internalvar (struct internalvar *var, struct value *val)
1964 {
1965 enum internalvar_kind new_kind;
1966 union internalvar_data new_data = { 0 };
1967
1968 if (var->kind == INTERNALVAR_FUNCTION && var->u.fn.canonical)
1969 error (_("Cannot overwrite convenience function %s"), var->name);
1970
1971 /* Prepare new contents. */
1972 switch (TYPE_CODE (check_typedef (value_type (val))))
1973 {
1974 case TYPE_CODE_VOID:
1975 new_kind = INTERNALVAR_VOID;
1976 break;
1977
1978 case TYPE_CODE_INTERNAL_FUNCTION:
1979 gdb_assert (VALUE_LVAL (val) == lval_internalvar);
1980 new_kind = INTERNALVAR_FUNCTION;
1981 get_internalvar_function (VALUE_INTERNALVAR (val),
1982 &new_data.fn.function);
1983 /* Copies created here are never canonical. */
1984 break;
1985
1986 default:
1987 new_kind = INTERNALVAR_VALUE;
1988 new_data.value = value_copy (val);
1989 new_data.value->modifiable = 1;
1990
1991 /* Force the value to be fetched from the target now, to avoid problems
1992 later when this internalvar is referenced and the target is gone or
1993 has changed. */
1994 if (value_lazy (new_data.value))
1995 value_fetch_lazy (new_data.value);
1996
1997 /* Release the value from the value chain to prevent it from being
1998 deleted by free_all_values. From here on this function should not
1999 call error () until new_data is installed into the var->u to avoid
2000 leaking memory. */
2001 release_value (new_data.value);
2002 break;
2003 }
2004
2005 /* Clean up old contents. */
2006 clear_internalvar (var);
2007
2008 /* Switch over. */
2009 var->kind = new_kind;
2010 var->u = new_data;
2011 /* End code which must not call error(). */
2012 }
2013
2014 void
2015 set_internalvar_integer (struct internalvar *var, LONGEST l)
2016 {
2017 /* Clean up old contents. */
2018 clear_internalvar (var);
2019
2020 var->kind = INTERNALVAR_INTEGER;
2021 var->u.integer.type = NULL;
2022 var->u.integer.val = l;
2023 }
2024
2025 void
2026 set_internalvar_string (struct internalvar *var, const char *string)
2027 {
2028 /* Clean up old contents. */
2029 clear_internalvar (var);
2030
2031 var->kind = INTERNALVAR_STRING;
2032 var->u.string = xstrdup (string);
2033 }
2034
2035 static void
2036 set_internalvar_function (struct internalvar *var, struct internal_function *f)
2037 {
2038 /* Clean up old contents. */
2039 clear_internalvar (var);
2040
2041 var->kind = INTERNALVAR_FUNCTION;
2042 var->u.fn.function = f;
2043 var->u.fn.canonical = 1;
2044 /* Variables installed here are always the canonical version. */
2045 }
2046
2047 void
2048 clear_internalvar (struct internalvar *var)
2049 {
2050 /* Clean up old contents. */
2051 switch (var->kind)
2052 {
2053 case INTERNALVAR_VALUE:
2054 value_free (var->u.value);
2055 break;
2056
2057 case INTERNALVAR_STRING:
2058 xfree (var->u.string);
2059 break;
2060
2061 case INTERNALVAR_MAKE_VALUE:
2062 if (var->u.make_value.functions->destroy != NULL)
2063 var->u.make_value.functions->destroy (var->u.make_value.data);
2064 break;
2065
2066 default:
2067 break;
2068 }
2069
2070 /* Reset to void kind. */
2071 var->kind = INTERNALVAR_VOID;
2072 }
2073
2074 char *
2075 internalvar_name (struct internalvar *var)
2076 {
2077 return var->name;
2078 }
2079
2080 static struct internal_function *
2081 create_internal_function (const char *name,
2082 internal_function_fn handler, void *cookie)
2083 {
2084 struct internal_function *ifn = XNEW (struct internal_function);
2085
2086 ifn->name = xstrdup (name);
2087 ifn->handler = handler;
2088 ifn->cookie = cookie;
2089 return ifn;
2090 }
2091
2092 char *
2093 value_internal_function_name (struct value *val)
2094 {
2095 struct internal_function *ifn;
2096 int result;
2097
2098 gdb_assert (VALUE_LVAL (val) == lval_internalvar);
2099 result = get_internalvar_function (VALUE_INTERNALVAR (val), &ifn);
2100 gdb_assert (result);
2101
2102 return ifn->name;
2103 }
2104
2105 struct value *
2106 call_internal_function (struct gdbarch *gdbarch,
2107 const struct language_defn *language,
2108 struct value *func, int argc, struct value **argv)
2109 {
2110 struct internal_function *ifn;
2111 int result;
2112
2113 gdb_assert (VALUE_LVAL (func) == lval_internalvar);
2114 result = get_internalvar_function (VALUE_INTERNALVAR (func), &ifn);
2115 gdb_assert (result);
2116
2117 return (*ifn->handler) (gdbarch, language, ifn->cookie, argc, argv);
2118 }
2119
2120 /* The 'function' command. This does nothing -- it is just a
2121 placeholder to let "help function NAME" work. This is also used as
2122 the implementation of the sub-command that is created when
2123 registering an internal function. */
2124 static void
2125 function_command (char *command, int from_tty)
2126 {
2127 /* Do nothing. */
2128 }
2129
2130 /* Clean up if an internal function's command is destroyed. */
2131 static void
2132 function_destroyer (struct cmd_list_element *self, void *ignore)
2133 {
2134 xfree (self->name);
2135 xfree (self->doc);
2136 }
2137
2138 /* Add a new internal function. NAME is the name of the function; DOC
2139 is a documentation string describing the function. HANDLER is
2140 called when the function is invoked. COOKIE is an arbitrary
2141 pointer which is passed to HANDLER and is intended for "user
2142 data". */
2143 void
2144 add_internal_function (const char *name, const char *doc,
2145 internal_function_fn handler, void *cookie)
2146 {
2147 struct cmd_list_element *cmd;
2148 struct internal_function *ifn;
2149 struct internalvar *var = lookup_internalvar (name);
2150
2151 ifn = create_internal_function (name, handler, cookie);
2152 set_internalvar_function (var, ifn);
2153
2154 cmd = add_cmd (xstrdup (name), no_class, function_command, (char *) doc,
2155 &functionlist);
2156 cmd->destroyer = function_destroyer;
2157 }
2158
2159 /* Update VALUE before discarding OBJFILE. COPIED_TYPES is used to
2160 prevent cycles / duplicates. */
2161
2162 void
2163 preserve_one_value (struct value *value, struct objfile *objfile,
2164 htab_t copied_types)
2165 {
2166 if (TYPE_OBJFILE (value->type) == objfile)
2167 value->type = copy_type_recursive (objfile, value->type, copied_types);
2168
2169 if (TYPE_OBJFILE (value->enclosing_type) == objfile)
2170 value->enclosing_type = copy_type_recursive (objfile,
2171 value->enclosing_type,
2172 copied_types);
2173 }
2174
2175 /* Likewise for internal variable VAR. */
2176
2177 static void
2178 preserve_one_internalvar (struct internalvar *var, struct objfile *objfile,
2179 htab_t copied_types)
2180 {
2181 switch (var->kind)
2182 {
2183 case INTERNALVAR_INTEGER:
2184 if (var->u.integer.type && TYPE_OBJFILE (var->u.integer.type) == objfile)
2185 var->u.integer.type
2186 = copy_type_recursive (objfile, var->u.integer.type, copied_types);
2187 break;
2188
2189 case INTERNALVAR_VALUE:
2190 preserve_one_value (var->u.value, objfile, copied_types);
2191 break;
2192 }
2193 }
2194
2195 /* Update the internal variables and value history when OBJFILE is
2196 discarded; we must copy the types out of the objfile. New global types
2197 will be created for every convenience variable which currently points to
2198 this objfile's types, and the convenience variables will be adjusted to
2199 use the new global types. */
2200
2201 void
2202 preserve_values (struct objfile *objfile)
2203 {
2204 htab_t copied_types;
2205 struct value_history_chunk *cur;
2206 struct internalvar *var;
2207 int i;
2208
2209 /* Create the hash table. We allocate on the objfile's obstack, since
2210 it is soon to be deleted. */
2211 copied_types = create_copied_types_hash (objfile);
2212
2213 for (cur = value_history_chain; cur; cur = cur->next)
2214 for (i = 0; i < VALUE_HISTORY_CHUNK; i++)
2215 if (cur->values[i])
2216 preserve_one_value (cur->values[i], objfile, copied_types);
2217
2218 for (var = internalvars; var; var = var->next)
2219 preserve_one_internalvar (var, objfile, copied_types);
2220
2221 preserve_python_values (objfile, copied_types);
2222
2223 htab_delete (copied_types);
2224 }
2225
2226 static void
2227 show_convenience (char *ignore, int from_tty)
2228 {
2229 struct gdbarch *gdbarch = get_current_arch ();
2230 struct internalvar *var;
2231 int varseen = 0;
2232 struct value_print_options opts;
2233
2234 get_user_print_options (&opts);
2235 for (var = internalvars; var; var = var->next)
2236 {
2237 volatile struct gdb_exception ex;
2238
2239 if (!varseen)
2240 {
2241 varseen = 1;
2242 }
2243 printf_filtered (("$%s = "), var->name);
2244
2245 TRY_CATCH (ex, RETURN_MASK_ERROR)
2246 {
2247 struct value *val;
2248
2249 val = value_of_internalvar (gdbarch, var);
2250 value_print (val, gdb_stdout, &opts);
2251 }
2252 if (ex.reason < 0)
2253 fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
2254 printf_filtered (("\n"));
2255 }
2256 if (!varseen)
2257 {
2258 /* This text does not mention convenience functions on purpose.
2259 The user can't create them except via Python, and if Python support
2260 is installed this message will never be printed ($_streq will
2261 exist). */
2262 printf_unfiltered (_("No debugger convenience variables now defined.\n"
2263 "Convenience variables have "
2264 "names starting with \"$\";\n"
2265 "use \"set\" as in \"set "
2266 "$foo = 5\" to define them.\n"));
2267 }
2268 }
2269 \f
2270 /* Extract a value as a C number (either long or double).
2271 Knows how to convert fixed values to double, or
2272 floating values to long.
2273 Does not deallocate the value. */
2274
2275 LONGEST
2276 value_as_long (struct value *val)
2277 {
2278 /* This coerces arrays and functions, which is necessary (e.g.
2279 in disassemble_command). It also dereferences references, which
2280 I suspect is the most logical thing to do. */
2281 val = coerce_array (val);
2282 return unpack_long (value_type (val), value_contents (val));
2283 }
2284
2285 DOUBLEST
2286 value_as_double (struct value *val)
2287 {
2288 DOUBLEST foo;
2289 int inv;
2290
2291 foo = unpack_double (value_type (val), value_contents (val), &inv);
2292 if (inv)
2293 error (_("Invalid floating value found in program."));
2294 return foo;
2295 }
2296
2297 /* Extract a value as a C pointer. Does not deallocate the value.
2298 Note that val's type may not actually be a pointer; value_as_long
2299 handles all the cases. */
2300 CORE_ADDR
2301 value_as_address (struct value *val)
2302 {
2303 struct gdbarch *gdbarch = get_type_arch (value_type (val));
2304
2305 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
2306 whether we want this to be true eventually. */
2307 #if 0
2308 /* gdbarch_addr_bits_remove is wrong if we are being called for a
2309 non-address (e.g. argument to "signal", "info break", etc.), or
2310 for pointers to char, in which the low bits *are* significant. */
2311 return gdbarch_addr_bits_remove (gdbarch, value_as_long (val));
2312 #else
2313
2314 /* There are several targets (IA-64, PowerPC, and others) which
2315 don't represent pointers to functions as simply the address of
2316 the function's entry point. For example, on the IA-64, a
2317 function pointer points to a two-word descriptor, generated by
2318 the linker, which contains the function's entry point, and the
2319 value the IA-64 "global pointer" register should have --- to
2320 support position-independent code. The linker generates
2321 descriptors only for those functions whose addresses are taken.
2322
2323 On such targets, it's difficult for GDB to convert an arbitrary
2324 function address into a function pointer; it has to either find
2325 an existing descriptor for that function, or call malloc and
2326 build its own. On some targets, it is impossible for GDB to
2327 build a descriptor at all: the descriptor must contain a jump
2328 instruction; data memory cannot be executed; and code memory
2329 cannot be modified.
2330
2331 Upon entry to this function, if VAL is a value of type `function'
2332 (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
2333 value_address (val) is the address of the function. This is what
2334 you'll get if you evaluate an expression like `main'. The call
2335 to COERCE_ARRAY below actually does all the usual unary
2336 conversions, which includes converting values of type `function'
2337 to `pointer to function'. This is the challenging conversion
2338 discussed above. Then, `unpack_long' will convert that pointer
2339 back into an address.
2340
2341 So, suppose the user types `disassemble foo' on an architecture
2342 with a strange function pointer representation, on which GDB
2343 cannot build its own descriptors, and suppose further that `foo'
2344 has no linker-built descriptor. The address->pointer conversion
2345 will signal an error and prevent the command from running, even
2346 though the next step would have been to convert the pointer
2347 directly back into the same address.
2348
2349 The following shortcut avoids this whole mess. If VAL is a
2350 function, just return its address directly. */
2351 if (TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
2352 || TYPE_CODE (value_type (val)) == TYPE_CODE_METHOD)
2353 return value_address (val);
2354
2355 val = coerce_array (val);
2356
2357 /* Some architectures (e.g. Harvard), map instruction and data
2358 addresses onto a single large unified address space. For
2359 instance: An architecture may consider a large integer in the
2360 range 0x10000000 .. 0x1000ffff to already represent a data
2361 addresses (hence not need a pointer to address conversion) while
2362 a small integer would still need to be converted integer to
2363 pointer to address. Just assume such architectures handle all
2364 integer conversions in a single function. */
2365
2366 /* JimB writes:
2367
2368 I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we
2369 must admonish GDB hackers to make sure its behavior matches the
2370 compiler's, whenever possible.
2371
2372 In general, I think GDB should evaluate expressions the same way
2373 the compiler does. When the user copies an expression out of
2374 their source code and hands it to a `print' command, they should
2375 get the same value the compiler would have computed. Any
2376 deviation from this rule can cause major confusion and annoyance,
2377 and needs to be justified carefully. In other words, GDB doesn't
2378 really have the freedom to do these conversions in clever and
2379 useful ways.
2380
2381 AndrewC pointed out that users aren't complaining about how GDB
2382 casts integers to pointers; they are complaining that they can't
2383 take an address from a disassembly listing and give it to `x/i'.
2384 This is certainly important.
2385
2386 Adding an architecture method like integer_to_address() certainly
2387 makes it possible for GDB to "get it right" in all circumstances
2388 --- the target has complete control over how things get done, so
2389 people can Do The Right Thing for their target without breaking
2390 anyone else. The standard doesn't specify how integers get
2391 converted to pointers; usually, the ABI doesn't either, but
2392 ABI-specific code is a more reasonable place to handle it. */
2393
2394 if (TYPE_CODE (value_type (val)) != TYPE_CODE_PTR
2395 && TYPE_CODE (value_type (val)) != TYPE_CODE_REF
2396 && gdbarch_integer_to_address_p (gdbarch))
2397 return gdbarch_integer_to_address (gdbarch, value_type (val),
2398 value_contents (val));
2399
2400 return unpack_long (value_type (val), value_contents (val));
2401 #endif
2402 }
2403 \f
2404 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
2405 as a long, or as a double, assuming the raw data is described
2406 by type TYPE. Knows how to convert different sizes of values
2407 and can convert between fixed and floating point. We don't assume
2408 any alignment for the raw data. Return value is in host byte order.
2409
2410 If you want functions and arrays to be coerced to pointers, and
2411 references to be dereferenced, call value_as_long() instead.
2412
2413 C++: It is assumed that the front-end has taken care of
2414 all matters concerning pointers to members. A pointer
2415 to member which reaches here is considered to be equivalent
2416 to an INT (or some size). After all, it is only an offset. */
2417
2418 LONGEST
2419 unpack_long (struct type *type, const gdb_byte *valaddr)
2420 {
2421 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
2422 enum type_code code = TYPE_CODE (type);
2423 int len = TYPE_LENGTH (type);
2424 int nosign = TYPE_UNSIGNED (type);
2425
2426 switch (code)
2427 {
2428 case TYPE_CODE_TYPEDEF:
2429 return unpack_long (check_typedef (type), valaddr);
2430 case TYPE_CODE_ENUM:
2431 case TYPE_CODE_FLAGS:
2432 case TYPE_CODE_BOOL:
2433 case TYPE_CODE_INT:
2434 case TYPE_CODE_CHAR:
2435 case TYPE_CODE_RANGE:
2436 case TYPE_CODE_MEMBERPTR:
2437 if (nosign)
2438 return extract_unsigned_integer (valaddr, len, byte_order);
2439 else
2440 return extract_signed_integer (valaddr, len, byte_order);
2441
2442 case TYPE_CODE_FLT:
2443 return extract_typed_floating (valaddr, type);
2444
2445 case TYPE_CODE_DECFLOAT:
2446 /* libdecnumber has a function to convert from decimal to integer, but
2447 it doesn't work when the decimal number has a fractional part. */
2448 return decimal_to_doublest (valaddr, len, byte_order);
2449
2450 case TYPE_CODE_PTR:
2451 case TYPE_CODE_REF:
2452 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
2453 whether we want this to be true eventually. */
2454 return extract_typed_address (valaddr, type);
2455
2456 default:
2457 error (_("Value can't be converted to integer."));
2458 }
2459 return 0; /* Placate lint. */
2460 }
2461
2462 /* Return a double value from the specified type and address.
2463 INVP points to an int which is set to 0 for valid value,
2464 1 for invalid value (bad float format). In either case,
2465 the returned double is OK to use. Argument is in target
2466 format, result is in host format. */
2467
2468 DOUBLEST
2469 unpack_double (struct type *type, const gdb_byte *valaddr, int *invp)
2470 {
2471 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
2472 enum type_code code;
2473 int len;
2474 int nosign;
2475
2476 *invp = 0; /* Assume valid. */
2477 CHECK_TYPEDEF (type);
2478 code = TYPE_CODE (type);
2479 len = TYPE_LENGTH (type);
2480 nosign = TYPE_UNSIGNED (type);
2481 if (code == TYPE_CODE_FLT)
2482 {
2483 /* NOTE: cagney/2002-02-19: There was a test here to see if the
2484 floating-point value was valid (using the macro
2485 INVALID_FLOAT). That test/macro have been removed.
2486
2487 It turns out that only the VAX defined this macro and then
2488 only in a non-portable way. Fixing the portability problem
2489 wouldn't help since the VAX floating-point code is also badly
2490 bit-rotten. The target needs to add definitions for the
2491 methods gdbarch_float_format and gdbarch_double_format - these
2492 exactly describe the target floating-point format. The
2493 problem here is that the corresponding floatformat_vax_f and
2494 floatformat_vax_d values these methods should be set to are
2495 also not defined either. Oops!
2496
2497 Hopefully someone will add both the missing floatformat
2498 definitions and the new cases for floatformat_is_valid (). */
2499
2500 if (!floatformat_is_valid (floatformat_from_type (type), valaddr))
2501 {
2502 *invp = 1;
2503 return 0.0;
2504 }
2505
2506 return extract_typed_floating (valaddr, type);
2507 }
2508 else if (code == TYPE_CODE_DECFLOAT)
2509 return decimal_to_doublest (valaddr, len, byte_order);
2510 else if (nosign)
2511 {
2512 /* Unsigned -- be sure we compensate for signed LONGEST. */
2513 return (ULONGEST) unpack_long (type, valaddr);
2514 }
2515 else
2516 {
2517 /* Signed -- we are OK with unpack_long. */
2518 return unpack_long (type, valaddr);
2519 }
2520 }
2521
2522 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
2523 as a CORE_ADDR, assuming the raw data is described by type TYPE.
2524 We don't assume any alignment for the raw data. Return value is in
2525 host byte order.
2526
2527 If you want functions and arrays to be coerced to pointers, and
2528 references to be dereferenced, call value_as_address() instead.
2529
2530 C++: It is assumed that the front-end has taken care of
2531 all matters concerning pointers to members. A pointer
2532 to member which reaches here is considered to be equivalent
2533 to an INT (or some size). After all, it is only an offset. */
2534
2535 CORE_ADDR
2536 unpack_pointer (struct type *type, const gdb_byte *valaddr)
2537 {
2538 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
2539 whether we want this to be true eventually. */
2540 return unpack_long (type, valaddr);
2541 }
2542
2543 \f
2544 /* Get the value of the FIELDNO'th field (which must be static) of
2545 TYPE. Return NULL if the field doesn't exist or has been
2546 optimized out. */
2547
2548 struct value *
2549 value_static_field (struct type *type, int fieldno)
2550 {
2551 struct value *retval;
2552
2553 switch (TYPE_FIELD_LOC_KIND (type, fieldno))
2554 {
2555 case FIELD_LOC_KIND_PHYSADDR:
2556 retval = value_at_lazy (TYPE_FIELD_TYPE (type, fieldno),
2557 TYPE_FIELD_STATIC_PHYSADDR (type, fieldno));
2558 break;
2559 case FIELD_LOC_KIND_PHYSNAME:
2560 {
2561 const char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
2562 /* TYPE_FIELD_NAME (type, fieldno); */
2563 struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0);
2564
2565 if (sym == NULL)
2566 {
2567 /* With some compilers, e.g. HP aCC, static data members are
2568 reported as non-debuggable symbols. */
2569 struct minimal_symbol *msym = lookup_minimal_symbol (phys_name,
2570 NULL, NULL);
2571
2572 if (!msym)
2573 return NULL;
2574 else
2575 {
2576 retval = value_at_lazy (TYPE_FIELD_TYPE (type, fieldno),
2577 SYMBOL_VALUE_ADDRESS (msym));
2578 }
2579 }
2580 else
2581 retval = value_of_variable (sym, NULL);
2582 break;
2583 }
2584 default:
2585 gdb_assert_not_reached ("unexpected field location kind");
2586 }
2587
2588 return retval;
2589 }
2590
2591 /* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.
2592 You have to be careful here, since the size of the data area for the value
2593 is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger
2594 than the old enclosing type, you have to allocate more space for the
2595 data. */
2596
2597 void
2598 set_value_enclosing_type (struct value *val, struct type *new_encl_type)
2599 {
2600 if (TYPE_LENGTH (new_encl_type) > TYPE_LENGTH (value_enclosing_type (val)))
2601 val->contents =
2602 (gdb_byte *) xrealloc (val->contents, TYPE_LENGTH (new_encl_type));
2603
2604 val->enclosing_type = new_encl_type;
2605 }
2606
2607 /* Given a value ARG1 (offset by OFFSET bytes)
2608 of a struct or union type ARG_TYPE,
2609 extract and return the value of one of its (non-static) fields.
2610 FIELDNO says which field. */
2611
2612 struct value *
2613 value_primitive_field (struct value *arg1, int offset,
2614 int fieldno, struct type *arg_type)
2615 {
2616 struct value *v;
2617 struct type *type;
2618
2619 CHECK_TYPEDEF (arg_type);
2620 type = TYPE_FIELD_TYPE (arg_type, fieldno);
2621
2622 /* Call check_typedef on our type to make sure that, if TYPE
2623 is a TYPE_CODE_TYPEDEF, its length is set to the length
2624 of the target type instead of zero. However, we do not
2625 replace the typedef type by the target type, because we want
2626 to keep the typedef in order to be able to print the type
2627 description correctly. */
2628 check_typedef (type);
2629
2630 if (value_optimized_out (arg1))
2631 v = allocate_optimized_out_value (type);
2632 else if (TYPE_FIELD_BITSIZE (arg_type, fieldno))
2633 {
2634 /* Handle packed fields.
2635
2636 Create a new value for the bitfield, with bitpos and bitsize
2637 set. If possible, arrange offset and bitpos so that we can
2638 do a single aligned read of the size of the containing type.
2639 Otherwise, adjust offset to the byte containing the first
2640 bit. Assume that the address, offset, and embedded offset
2641 are sufficiently aligned. */
2642
2643 int bitpos = TYPE_FIELD_BITPOS (arg_type, fieldno);
2644 int container_bitsize = TYPE_LENGTH (type) * 8;
2645
2646 v = allocate_value_lazy (type);
2647 v->bitsize = TYPE_FIELD_BITSIZE (arg_type, fieldno);
2648 if ((bitpos % container_bitsize) + v->bitsize <= container_bitsize
2649 && TYPE_LENGTH (type) <= (int) sizeof (LONGEST))
2650 v->bitpos = bitpos % container_bitsize;
2651 else
2652 v->bitpos = bitpos % 8;
2653 v->offset = (value_embedded_offset (arg1)
2654 + offset
2655 + (bitpos - v->bitpos) / 8);
2656 v->parent = arg1;
2657 value_incref (v->parent);
2658 if (!value_lazy (arg1))
2659 value_fetch_lazy (v);
2660 }
2661 else if (fieldno < TYPE_N_BASECLASSES (arg_type))
2662 {
2663 /* This field is actually a base subobject, so preserve the
2664 entire object's contents for later references to virtual
2665 bases, etc. */
2666 int boffset;
2667
2668 /* Lazy register values with offsets are not supported. */
2669 if (VALUE_LVAL (arg1) == lval_register && value_lazy (arg1))
2670 value_fetch_lazy (arg1);
2671
2672 /* We special case virtual inheritance here because this
2673 requires access to the contents, which we would rather avoid
2674 for references to ordinary fields of unavailable values. */
2675 if (BASETYPE_VIA_VIRTUAL (arg_type, fieldno))
2676 boffset = baseclass_offset (arg_type, fieldno,
2677 value_contents (arg1),
2678 value_embedded_offset (arg1),
2679 value_address (arg1),
2680 arg1);
2681 else
2682 boffset = TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
2683
2684 if (value_lazy (arg1))
2685 v = allocate_value_lazy (value_enclosing_type (arg1));
2686 else
2687 {
2688 v = allocate_value (value_enclosing_type (arg1));
2689 value_contents_copy_raw (v, 0, arg1, 0,
2690 TYPE_LENGTH (value_enclosing_type (arg1)));
2691 }
2692 v->type = type;
2693 v->offset = value_offset (arg1);
2694 v->embedded_offset = offset + value_embedded_offset (arg1) + boffset;
2695 }
2696 else
2697 {
2698 /* Plain old data member */
2699 offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
2700
2701 /* Lazy register values with offsets are not supported. */
2702 if (VALUE_LVAL (arg1) == lval_register && value_lazy (arg1))
2703 value_fetch_lazy (arg1);
2704
2705 if (value_lazy (arg1))
2706 v = allocate_value_lazy (type);
2707 else
2708 {
2709 v = allocate_value (type);
2710 value_contents_copy_raw (v, value_embedded_offset (v),
2711 arg1, value_embedded_offset (arg1) + offset,
2712 TYPE_LENGTH (type));
2713 }
2714 v->offset = (value_offset (arg1) + offset
2715 + value_embedded_offset (arg1));
2716 }
2717 set_value_component_location (v, arg1);
2718 VALUE_REGNUM (v) = VALUE_REGNUM (arg1);
2719 VALUE_FRAME_ID (v) = VALUE_FRAME_ID (arg1);
2720 return v;
2721 }
2722
2723 /* Given a value ARG1 of a struct or union type,
2724 extract and return the value of one of its (non-static) fields.
2725 FIELDNO says which field. */
2726
2727 struct value *
2728 value_field (struct value *arg1, int fieldno)
2729 {
2730 return value_primitive_field (arg1, 0, fieldno, value_type (arg1));
2731 }
2732
2733 /* Return a non-virtual function as a value.
2734 F is the list of member functions which contains the desired method.
2735 J is an index into F which provides the desired method.
2736
2737 We only use the symbol for its address, so be happy with either a
2738 full symbol or a minimal symbol. */
2739
2740 struct value *
2741 value_fn_field (struct value **arg1p, struct fn_field *f,
2742 int j, struct type *type,
2743 int offset)
2744 {
2745 struct value *v;
2746 struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
2747 const char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
2748 struct symbol *sym;
2749 struct minimal_symbol *msym;
2750
2751 sym = lookup_symbol (physname, 0, VAR_DOMAIN, 0);
2752 if (sym != NULL)
2753 {
2754 msym = NULL;
2755 }
2756 else
2757 {
2758 gdb_assert (sym == NULL);
2759 msym = lookup_minimal_symbol (physname, NULL, NULL);
2760 if (msym == NULL)
2761 return NULL;
2762 }
2763
2764 v = allocate_value (ftype);
2765 if (sym)
2766 {
2767 set_value_address (v, BLOCK_START (SYMBOL_BLOCK_VALUE (sym)));
2768 }
2769 else
2770 {
2771 /* The minimal symbol might point to a function descriptor;
2772 resolve it to the actual code address instead. */
2773 struct objfile *objfile = msymbol_objfile (msym);
2774 struct gdbarch *gdbarch = get_objfile_arch (objfile);
2775
2776 set_value_address (v,
2777 gdbarch_convert_from_func_ptr_addr
2778 (gdbarch, SYMBOL_VALUE_ADDRESS (msym), &current_target));
2779 }
2780
2781 if (arg1p)
2782 {
2783 if (type != value_type (*arg1p))
2784 *arg1p = value_ind (value_cast (lookup_pointer_type (type),
2785 value_addr (*arg1p)));
2786
2787 /* Move the `this' pointer according to the offset.
2788 VALUE_OFFSET (*arg1p) += offset; */
2789 }
2790
2791 return v;
2792 }
2793
2794 \f
2795
2796 /* Helper function for both unpack_value_bits_as_long and
2797 unpack_bits_as_long. See those functions for more details on the
2798 interface; the only difference is that this function accepts either
2799 a NULL or a non-NULL ORIGINAL_VALUE. */
2800
2801 static int
2802 unpack_value_bits_as_long_1 (struct type *field_type, const gdb_byte *valaddr,
2803 int embedded_offset, int bitpos, int bitsize,
2804 const struct value *original_value,
2805 LONGEST *result)
2806 {
2807 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (field_type));
2808 ULONGEST val;
2809 ULONGEST valmask;
2810 int lsbcount;
2811 int bytes_read;
2812 int read_offset;
2813
2814 /* Read the minimum number of bytes required; there may not be
2815 enough bytes to read an entire ULONGEST. */
2816 CHECK_TYPEDEF (field_type);
2817 if (bitsize)
2818 bytes_read = ((bitpos % 8) + bitsize + 7) / 8;
2819 else
2820 bytes_read = TYPE_LENGTH (field_type);
2821
2822 read_offset = bitpos / 8;
2823
2824 if (original_value != NULL
2825 && !value_bytes_available (original_value, embedded_offset + read_offset,
2826 bytes_read))
2827 return 0;
2828
2829 val = extract_unsigned_integer (valaddr + embedded_offset + read_offset,
2830 bytes_read, byte_order);
2831
2832 /* Extract bits. See comment above. */
2833
2834 if (gdbarch_bits_big_endian (get_type_arch (field_type)))
2835 lsbcount = (bytes_read * 8 - bitpos % 8 - bitsize);
2836 else
2837 lsbcount = (bitpos % 8);
2838 val >>= lsbcount;
2839
2840 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
2841 If the field is signed, and is negative, then sign extend. */
2842
2843 if ((bitsize > 0) && (bitsize < 8 * (int) sizeof (val)))
2844 {
2845 valmask = (((ULONGEST) 1) << bitsize) - 1;
2846 val &= valmask;
2847 if (!TYPE_UNSIGNED (field_type))
2848 {
2849 if (val & (valmask ^ (valmask >> 1)))
2850 {
2851 val |= ~valmask;
2852 }
2853 }
2854 }
2855
2856 *result = val;
2857 return 1;
2858 }
2859
2860 /* Unpack a bitfield of the specified FIELD_TYPE, from the object at
2861 VALADDR + EMBEDDED_OFFSET, and store the result in *RESULT.
2862 VALADDR points to the contents of ORIGINAL_VALUE, which must not be
2863 NULL. The bitfield starts at BITPOS bits and contains BITSIZE
2864 bits.
2865
2866 Returns false if the value contents are unavailable, otherwise
2867 returns true, indicating a valid value has been stored in *RESULT.
2868
2869 Extracting bits depends on endianness of the machine. Compute the
2870 number of least significant bits to discard. For big endian machines,
2871 we compute the total number of bits in the anonymous object, subtract
2872 off the bit count from the MSB of the object to the MSB of the
2873 bitfield, then the size of the bitfield, which leaves the LSB discard
2874 count. For little endian machines, the discard count is simply the
2875 number of bits from the LSB of the anonymous object to the LSB of the
2876 bitfield.
2877
2878 If the field is signed, we also do sign extension. */
2879
2880 int
2881 unpack_value_bits_as_long (struct type *field_type, const gdb_byte *valaddr,
2882 int embedded_offset, int bitpos, int bitsize,
2883 const struct value *original_value,
2884 LONGEST *result)
2885 {
2886 gdb_assert (original_value != NULL);
2887
2888 return unpack_value_bits_as_long_1 (field_type, valaddr, embedded_offset,
2889 bitpos, bitsize, original_value, result);
2890
2891 }
2892
2893 /* Unpack a field FIELDNO of the specified TYPE, from the object at
2894 VALADDR + EMBEDDED_OFFSET. VALADDR points to the contents of
2895 ORIGINAL_VALUE. See unpack_value_bits_as_long for more
2896 details. */
2897
2898 static int
2899 unpack_value_field_as_long_1 (struct type *type, const gdb_byte *valaddr,
2900 int embedded_offset, int fieldno,
2901 const struct value *val, LONGEST *result)
2902 {
2903 int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
2904 int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
2905 struct type *field_type = TYPE_FIELD_TYPE (type, fieldno);
2906
2907 return unpack_value_bits_as_long_1 (field_type, valaddr, embedded_offset,
2908 bitpos, bitsize, val,
2909 result);
2910 }
2911
2912 /* Unpack a field FIELDNO of the specified TYPE, from the object at
2913 VALADDR + EMBEDDED_OFFSET. VALADDR points to the contents of
2914 ORIGINAL_VALUE, which must not be NULL. See
2915 unpack_value_bits_as_long for more details. */
2916
2917 int
2918 unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr,
2919 int embedded_offset, int fieldno,
2920 const struct value *val, LONGEST *result)
2921 {
2922 gdb_assert (val != NULL);
2923
2924 return unpack_value_field_as_long_1 (type, valaddr, embedded_offset,
2925 fieldno, val, result);
2926 }
2927
2928 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous
2929 object at VALADDR. See unpack_value_bits_as_long for more details.
2930 This function differs from unpack_value_field_as_long in that it
2931 operates without a struct value object. */
2932
2933 LONGEST
2934 unpack_field_as_long (struct type *type, const gdb_byte *valaddr, int fieldno)
2935 {
2936 LONGEST result;
2937
2938 unpack_value_field_as_long_1 (type, valaddr, 0, fieldno, NULL, &result);
2939 return result;
2940 }
2941
2942 /* Return a new value with type TYPE, which is FIELDNO field of the
2943 object at VALADDR + EMBEDDEDOFFSET. VALADDR points to the contents
2944 of VAL. If the VAL's contents required to extract the bitfield
2945 from are unavailable, the new value is correspondingly marked as
2946 unavailable. */
2947
2948 struct value *
2949 value_field_bitfield (struct type *type, int fieldno,
2950 const gdb_byte *valaddr,
2951 int embedded_offset, const struct value *val)
2952 {
2953 LONGEST l;
2954
2955 if (!unpack_value_field_as_long (type, valaddr, embedded_offset, fieldno,
2956 val, &l))
2957 {
2958 struct type *field_type = TYPE_FIELD_TYPE (type, fieldno);
2959 struct value *retval = allocate_value (field_type);
2960 mark_value_bytes_unavailable (retval, 0, TYPE_LENGTH (field_type));
2961 return retval;
2962 }
2963 else
2964 {
2965 return value_from_longest (TYPE_FIELD_TYPE (type, fieldno), l);
2966 }
2967 }
2968
2969 /* Modify the value of a bitfield. ADDR points to a block of memory in
2970 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
2971 is the desired value of the field, in host byte order. BITPOS and BITSIZE
2972 indicate which bits (in target bit order) comprise the bitfield.
2973 Requires 0 < BITSIZE <= lbits, 0 <= BITPOS % 8 + BITSIZE <= lbits, and
2974 0 <= BITPOS, where lbits is the size of a LONGEST in bits. */
2975
2976 void
2977 modify_field (struct type *type, gdb_byte *addr,
2978 LONGEST fieldval, int bitpos, int bitsize)
2979 {
2980 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
2981 ULONGEST oword;
2982 ULONGEST mask = (ULONGEST) -1 >> (8 * sizeof (ULONGEST) - bitsize);
2983 int bytesize;
2984
2985 /* Normalize BITPOS. */
2986 addr += bitpos / 8;
2987 bitpos %= 8;
2988
2989 /* If a negative fieldval fits in the field in question, chop
2990 off the sign extension bits. */
2991 if ((~fieldval & ~(mask >> 1)) == 0)
2992 fieldval &= mask;
2993
2994 /* Warn if value is too big to fit in the field in question. */
2995 if (0 != (fieldval & ~mask))
2996 {
2997 /* FIXME: would like to include fieldval in the message, but
2998 we don't have a sprintf_longest. */
2999 warning (_("Value does not fit in %d bits."), bitsize);
3000
3001 /* Truncate it, otherwise adjoining fields may be corrupted. */
3002 fieldval &= mask;
3003 }
3004
3005 /* Ensure no bytes outside of the modified ones get accessed as it may cause
3006 false valgrind reports. */
3007
3008 bytesize = (bitpos + bitsize + 7) / 8;
3009 oword = extract_unsigned_integer (addr, bytesize, byte_order);
3010
3011 /* Shifting for bit field depends on endianness of the target machine. */
3012 if (gdbarch_bits_big_endian (get_type_arch (type)))
3013 bitpos = bytesize * 8 - bitpos - bitsize;
3014
3015 oword &= ~(mask << bitpos);
3016 oword |= fieldval << bitpos;
3017
3018 store_unsigned_integer (addr, bytesize, byte_order, oword);
3019 }
3020 \f
3021 /* Pack NUM into BUF using a target format of TYPE. */
3022
3023 void
3024 pack_long (gdb_byte *buf, struct type *type, LONGEST num)
3025 {
3026 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
3027 int len;
3028
3029 type = check_typedef (type);
3030 len = TYPE_LENGTH (type);
3031
3032 switch (TYPE_CODE (type))
3033 {
3034 case TYPE_CODE_INT:
3035 case TYPE_CODE_CHAR:
3036 case TYPE_CODE_ENUM:
3037 case TYPE_CODE_FLAGS:
3038 case TYPE_CODE_BOOL:
3039 case TYPE_CODE_RANGE:
3040 case TYPE_CODE_MEMBERPTR:
3041 store_signed_integer (buf, len, byte_order, num);
3042 break;
3043
3044 case TYPE_CODE_REF:
3045 case TYPE_CODE_PTR:
3046 store_typed_address (buf, type, (CORE_ADDR) num);
3047 break;
3048
3049 default:
3050 error (_("Unexpected type (%d) encountered for integer constant."),
3051 TYPE_CODE (type));
3052 }
3053 }
3054
3055
3056 /* Pack NUM into BUF using a target format of TYPE. */
3057
3058 static void
3059 pack_unsigned_long (gdb_byte *buf, struct type *type, ULONGEST num)
3060 {
3061 int len;
3062 enum bfd_endian byte_order;
3063
3064 type = check_typedef (type);
3065 len = TYPE_LENGTH (type);
3066 byte_order = gdbarch_byte_order (get_type_arch (type));
3067
3068 switch (TYPE_CODE (type))
3069 {
3070 case TYPE_CODE_INT:
3071 case TYPE_CODE_CHAR:
3072 case TYPE_CODE_ENUM:
3073 case TYPE_CODE_FLAGS:
3074 case TYPE_CODE_BOOL:
3075 case TYPE_CODE_RANGE:
3076 case TYPE_CODE_MEMBERPTR:
3077 store_unsigned_integer (buf, len, byte_order, num);
3078 break;
3079
3080 case TYPE_CODE_REF:
3081 case TYPE_CODE_PTR:
3082 store_typed_address (buf, type, (CORE_ADDR) num);
3083 break;
3084
3085 default:
3086 error (_("Unexpected type (%d) encountered "
3087 "for unsigned integer constant."),
3088 TYPE_CODE (type));
3089 }
3090 }
3091
3092
3093 /* Convert C numbers into newly allocated values. */
3094
3095 struct value *
3096 value_from_longest (struct type *type, LONGEST num)
3097 {
3098 struct value *val = allocate_value (type);
3099
3100 pack_long (value_contents_raw (val), type, num);
3101 return val;
3102 }
3103
3104
3105 /* Convert C unsigned numbers into newly allocated values. */
3106
3107 struct value *
3108 value_from_ulongest (struct type *type, ULONGEST num)
3109 {
3110 struct value *val = allocate_value (type);
3111
3112 pack_unsigned_long (value_contents_raw (val), type, num);
3113
3114 return val;
3115 }
3116
3117
3118 /* Create a value representing a pointer of type TYPE to the address
3119 ADDR. */
3120 struct value *
3121 value_from_pointer (struct type *type, CORE_ADDR addr)
3122 {
3123 struct value *val = allocate_value (type);
3124
3125 store_typed_address (value_contents_raw (val), check_typedef (type), addr);
3126 return val;
3127 }
3128
3129
3130 /* Create a value of type TYPE whose contents come from VALADDR, if it
3131 is non-null, and whose memory address (in the inferior) is
3132 ADDRESS. */
3133
3134 struct value *
3135 value_from_contents_and_address (struct type *type,
3136 const gdb_byte *valaddr,
3137 CORE_ADDR address)
3138 {
3139 struct value *v;
3140
3141 if (valaddr == NULL)
3142 v = allocate_value_lazy (type);
3143 else
3144 {
3145 v = allocate_value (type);
3146 memcpy (value_contents_raw (v), valaddr, TYPE_LENGTH (type));
3147 }
3148 set_value_address (v, address);
3149 VALUE_LVAL (v) = lval_memory;
3150 return v;
3151 }
3152
3153 /* Create a value of type TYPE holding the contents CONTENTS.
3154 The new value is `not_lval'. */
3155
3156 struct value *
3157 value_from_contents (struct type *type, const gdb_byte *contents)
3158 {
3159 struct value *result;
3160
3161 result = allocate_value (type);
3162 memcpy (value_contents_raw (result), contents, TYPE_LENGTH (type));
3163 return result;
3164 }
3165
3166 struct value *
3167 value_from_double (struct type *type, DOUBLEST num)
3168 {
3169 struct value *val = allocate_value (type);
3170 struct type *base_type = check_typedef (type);
3171 enum type_code code = TYPE_CODE (base_type);
3172
3173 if (code == TYPE_CODE_FLT)
3174 {
3175 store_typed_floating (value_contents_raw (val), base_type, num);
3176 }
3177 else
3178 error (_("Unexpected type encountered for floating constant."));
3179
3180 return val;
3181 }
3182
3183 struct value *
3184 value_from_decfloat (struct type *type, const gdb_byte *dec)
3185 {
3186 struct value *val = allocate_value (type);
3187
3188 memcpy (value_contents_raw (val), dec, TYPE_LENGTH (type));
3189 return val;
3190 }
3191
3192 /* Extract a value from the history file. Input will be of the form
3193 $digits or $$digits. See block comment above 'write_dollar_variable'
3194 for details. */
3195
3196 struct value *
3197 value_from_history_ref (char *h, char **endp)
3198 {
3199 int index, len;
3200
3201 if (h[0] == '$')
3202 len = 1;
3203 else
3204 return NULL;
3205
3206 if (h[1] == '$')
3207 len = 2;
3208
3209 /* Find length of numeral string. */
3210 for (; isdigit (h[len]); len++)
3211 ;
3212
3213 /* Make sure numeral string is not part of an identifier. */
3214 if (h[len] == '_' || isalpha (h[len]))
3215 return NULL;
3216
3217 /* Now collect the index value. */
3218 if (h[1] == '$')
3219 {
3220 if (len == 2)
3221 {
3222 /* For some bizarre reason, "$$" is equivalent to "$$1",
3223 rather than to "$$0" as it ought to be! */
3224 index = -1;
3225 *endp += len;
3226 }
3227 else
3228 index = -strtol (&h[2], endp, 10);
3229 }
3230 else
3231 {
3232 if (len == 1)
3233 {
3234 /* "$" is equivalent to "$0". */
3235 index = 0;
3236 *endp += len;
3237 }
3238 else
3239 index = strtol (&h[1], endp, 10);
3240 }
3241
3242 return access_value_history (index);
3243 }
3244
3245 struct value *
3246 coerce_ref_if_computed (const struct value *arg)
3247 {
3248 const struct lval_funcs *funcs;
3249
3250 if (TYPE_CODE (check_typedef (value_type (arg))) != TYPE_CODE_REF)
3251 return NULL;
3252
3253 if (value_lval_const (arg) != lval_computed)
3254 return NULL;
3255
3256 funcs = value_computed_funcs (arg);
3257 if (funcs->coerce_ref == NULL)
3258 return NULL;
3259
3260 return funcs->coerce_ref (arg);
3261 }
3262
3263 /* Look at value.h for description. */
3264
3265 struct value *
3266 readjust_indirect_value_type (struct value *value, struct type *enc_type,
3267 struct type *original_type,
3268 struct value *original_value)
3269 {
3270 /* Re-adjust type. */
3271 deprecated_set_value_type (value, TYPE_TARGET_TYPE (original_type));
3272
3273 /* Add embedding info. */
3274 set_value_enclosing_type (value, enc_type);
3275 set_value_embedded_offset (value, value_pointed_to_offset (original_value));
3276
3277 /* We may be pointing to an object of some derived type. */
3278 return value_full_object (value, NULL, 0, 0, 0);
3279 }
3280
3281 struct value *
3282 coerce_ref (struct value *arg)
3283 {
3284 struct type *value_type_arg_tmp = check_typedef (value_type (arg));
3285 struct value *retval;
3286 struct type *enc_type;
3287
3288 retval = coerce_ref_if_computed (arg);
3289 if (retval)
3290 return retval;
3291
3292 if (TYPE_CODE (value_type_arg_tmp) != TYPE_CODE_REF)
3293 return arg;
3294
3295 enc_type = check_typedef (value_enclosing_type (arg));
3296 enc_type = TYPE_TARGET_TYPE (enc_type);
3297
3298 retval = value_at_lazy (enc_type,
3299 unpack_pointer (value_type (arg),
3300 value_contents (arg)));
3301 return readjust_indirect_value_type (retval, enc_type,
3302 value_type_arg_tmp, arg);
3303 }
3304
3305 struct value *
3306 coerce_array (struct value *arg)
3307 {
3308 struct type *type;
3309
3310 arg = coerce_ref (arg);
3311 type = check_typedef (value_type (arg));
3312
3313 switch (TYPE_CODE (type))
3314 {
3315 case TYPE_CODE_ARRAY:
3316 if (!TYPE_VECTOR (type) && current_language->c_style_arrays)
3317 arg = value_coerce_array (arg);
3318 break;
3319 case TYPE_CODE_FUNC:
3320 arg = value_coerce_function (arg);
3321 break;
3322 }
3323 return arg;
3324 }
3325 \f
3326
3327 /* Return true if the function returning the specified type is using
3328 the convention of returning structures in memory (passing in the
3329 address as a hidden first parameter). */
3330
3331 int
3332 using_struct_return (struct gdbarch *gdbarch,
3333 struct value *function, struct type *value_type)
3334 {
3335 enum type_code code = TYPE_CODE (value_type);
3336
3337 if (code == TYPE_CODE_ERROR)
3338 error (_("Function return type unknown."));
3339
3340 if (code == TYPE_CODE_VOID)
3341 /* A void return value is never in memory. See also corresponding
3342 code in "print_return_value". */
3343 return 0;
3344
3345 /* Probe the architecture for the return-value convention. */
3346 return (gdbarch_return_value (gdbarch, function, value_type,
3347 NULL, NULL, NULL)
3348 != RETURN_VALUE_REGISTER_CONVENTION);
3349 }
3350
3351 /* Set the initialized field in a value struct. */
3352
3353 void
3354 set_value_initialized (struct value *val, int status)
3355 {
3356 val->initialized = status;
3357 }
3358
3359 /* Return the initialized field in a value struct. */
3360
3361 int
3362 value_initialized (struct value *val)
3363 {
3364 return val->initialized;
3365 }
3366
3367 void
3368 _initialize_values (void)
3369 {
3370 add_cmd ("convenience", no_class, show_convenience, _("\
3371 Debugger convenience (\"$foo\") variables and functions.\n\
3372 Convenience variables are created when you assign them values;\n\
3373 thus, \"set $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\
3374 \n\
3375 A few convenience variables are given values automatically:\n\
3376 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
3377 \"$__\" holds the contents of the last address examined with \"x\"."
3378 #ifdef HAVE_PYTHON
3379 "\n\n\
3380 Convenience functions are defined via the Python API."
3381 #endif
3382 ), &showlist);
3383
3384 add_cmd ("values", no_set_class, show_values, _("\
3385 Elements of value history around item number IDX (or last ten)."),
3386 &showlist);
3387
3388 add_com ("init-if-undefined", class_vars, init_if_undefined_command, _("\
3389 Initialize a convenience variable if necessary.\n\
3390 init-if-undefined VARIABLE = EXPRESSION\n\
3391 Set an internal VARIABLE to the result of the EXPRESSION if it does not\n\
3392 exist or does not contain a value. The EXPRESSION is not evaluated if the\n\
3393 VARIABLE is already initialized."));
3394
3395 add_prefix_cmd ("function", no_class, function_command, _("\
3396 Placeholder command for showing help on convenience functions."),
3397 &functionlist, "function ", 0, &cmdlist);
3398 }