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