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