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