1 /* Low level packing and unpacking of values for GDB, the GNU Debugger.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
5 2009 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_string.h"
34 #include "gdb_assert.h"
41 #include "python/python.h"
43 /* Prototypes for exported functions. */
45 void _initialize_values (void);
49 /* Type of value; either not an lval, or one of the various
50 different possible kinds of lval. */
53 /* Is it modifiable? Only relevant if lval != not_lval. */
56 /* Location of value (if lval). */
59 /* If lval == lval_memory, this is the address in the inferior.
60 If lval == lval_register, this is the byte offset into the
61 registers structure. */
64 /* Pointer to internal variable. */
65 struct internalvar
*internalvar
;
68 /* Describes offset of a value within lval of a structure in bytes.
69 If lval == lval_memory, this is an offset to the address. If
70 lval == lval_register, this is a further offset from
71 location.address within the registers structure. Note also the
72 member embedded_offset below. */
75 /* Only used for bitfields; number of bits contained in them. */
78 /* Only used for bitfields; position of start of field. For
79 gdbarch_bits_big_endian=0 targets, it is the position of the LSB. For
80 gdbarch_bits_big_endian=1 targets, it is the position of the MSB. */
83 /* Frame register value is relative to. This will be described in
84 the lval enum above as "lval_register". */
85 struct frame_id frame_id
;
87 /* Type of the value. */
90 /* If a value represents a C++ object, then the `type' field gives
91 the object's compile-time type. If the object actually belongs
92 to some class derived from `type', perhaps with other base
93 classes and additional members, then `type' is just a subobject
94 of the real thing, and the full object is probably larger than
97 If `type' is a dynamic class (i.e. one with a vtable), then GDB
98 can actually determine the object's run-time type by looking at
99 the run-time type information in the vtable. When this
100 information is available, we may elect to read in the entire
101 object, for several reasons:
103 - When printing the value, the user would probably rather see the
104 full object, not just the limited portion apparent from the
107 - If `type' has virtual base classes, then even printing `type'
108 alone may require reaching outside the `type' portion of the
109 object to wherever the virtual base class has been stored.
111 When we store the entire object, `enclosing_type' is the run-time
112 type -- the complete object -- and `embedded_offset' is the
113 offset of `type' within that larger type, in bytes. The
114 value_contents() macro takes `embedded_offset' into account, so
115 most GDB code continues to see the `type' portion of the value,
116 just as the inferior would.
118 If `type' is a pointer to an object, then `enclosing_type' is a
119 pointer to the object's run-time type, and `pointed_to_offset' is
120 the offset in bytes from the full object to the pointed-to object
121 -- that is, the value `embedded_offset' would have if we followed
122 the pointer and fetched the complete object. (I don't really see
123 the point. Why not just determine the run-time type when you
124 indirect, and avoid the special case? The contents don't matter
125 until you indirect anyway.)
127 If we're not doing anything fancy, `enclosing_type' is equal to
128 `type', and `embedded_offset' is zero, so everything works
130 struct type
*enclosing_type
;
132 int pointed_to_offset
;
134 /* Values are stored in a chain, so that they can be deleted easily
135 over calls to the inferior. Values assigned to internal
136 variables, put into the value history or exposed to Python are
137 taken off this list. */
140 /* Register number if the value is from a register. */
143 /* If zero, contents of this value are in the contents field. If
144 nonzero, contents are in inferior. If the lval field is lval_memory,
145 the contents are in inferior memory at location.address plus offset.
146 The lval field may also be lval_register.
148 WARNING: This field is used by the code which handles watchpoints
149 (see breakpoint.c) to decide whether a particular value can be
150 watched by hardware watchpoints. If the lazy flag is set for
151 some member of a value chain, it is assumed that this member of
152 the chain doesn't need to be watched as part of watching the
153 value itself. This is how GDB avoids watching the entire struct
154 or array when the user wants to watch a single struct member or
155 array element. If you ever change the way lazy flag is set and
156 reset, be sure to consider this use as well! */
159 /* If nonzero, this is the value of a variable which does not
160 actually exist in the program. */
163 /* If value is a variable, is it initialized or not. */
166 /* Actual contents of the value. Target byte-order. NULL or not
167 valid if lazy is nonzero. */
171 /* Prototypes for local functions. */
173 static void show_values (char *, int);
175 static void show_convenience (char *, int);
178 /* The value-history records all the values printed
179 by print commands during this session. Each chunk
180 records 60 consecutive values. The first chunk on
181 the chain records the most recent values.
182 The total number of values is in value_history_count. */
184 #define VALUE_HISTORY_CHUNK 60
186 struct value_history_chunk
188 struct value_history_chunk
*next
;
189 struct value
*values
[VALUE_HISTORY_CHUNK
];
192 /* Chain of chunks now in use. */
194 static struct value_history_chunk
*value_history_chain
;
196 static int value_history_count
; /* Abs number of last entry stored */
198 /* List of all value objects currently allocated
199 (except for those released by calls to release_value)
200 This is so they can be freed after each command. */
202 static struct value
*all_values
;
204 /* Allocate a lazy value for type TYPE. Its actual content is
205 "lazily" allocated too: the content field of the return value is
206 NULL; it will be allocated when it is fetched from the target. */
209 allocate_value_lazy (struct type
*type
)
212 struct type
*atype
= check_typedef (type
);
214 val
= (struct value
*) xzalloc (sizeof (struct value
));
215 val
->contents
= NULL
;
216 val
->next
= all_values
;
219 val
->enclosing_type
= type
;
220 VALUE_LVAL (val
) = not_lval
;
221 VALUE_ADDRESS (val
) = 0;
222 VALUE_FRAME_ID (val
) = null_frame_id
;
226 VALUE_REGNUM (val
) = -1;
228 val
->optimized_out
= 0;
229 val
->embedded_offset
= 0;
230 val
->pointed_to_offset
= 0;
232 val
->initialized
= 1; /* Default to initialized. */
236 /* Allocate the contents of VAL if it has not been allocated yet. */
239 allocate_value_contents (struct value
*val
)
242 val
->contents
= (gdb_byte
*) xzalloc (TYPE_LENGTH (val
->enclosing_type
));
245 /* Allocate a value and its contents for type TYPE. */
248 allocate_value (struct type
*type
)
250 struct value
*val
= allocate_value_lazy (type
);
251 allocate_value_contents (val
);
256 /* Allocate a value that has the correct length
257 for COUNT repetitions of type TYPE. */
260 allocate_repeat_value (struct type
*type
, int count
)
262 int low_bound
= current_language
->string_lower_bound
; /* ??? */
263 /* FIXME-type-allocation: need a way to free this type when we are
265 struct type
*range_type
266 = create_range_type ((struct type
*) NULL
, builtin_type_int32
,
267 low_bound
, count
+ low_bound
- 1);
268 /* FIXME-type-allocation: need a way to free this type when we are
270 return allocate_value (create_array_type ((struct type
*) NULL
,
274 /* Needed if another module needs to maintain its on list of values. */
276 value_prepend_to_list (struct value
**head
, struct value
*val
)
282 /* Needed if another module needs to maintain its on list of values. */
284 value_remove_from_list (struct value
**head
, struct value
*val
)
289 *head
= (*head
)->next
;
291 for (prev
= *head
; prev
->next
; prev
= prev
->next
)
292 if (prev
->next
== val
)
294 prev
->next
= val
->next
;
299 /* Accessor methods. */
302 value_next (struct value
*value
)
308 value_type (struct value
*value
)
313 deprecated_set_value_type (struct value
*value
, struct type
*type
)
319 value_offset (struct value
*value
)
321 return value
->offset
;
324 set_value_offset (struct value
*value
, int offset
)
326 value
->offset
= offset
;
330 value_bitpos (struct value
*value
)
332 return value
->bitpos
;
335 set_value_bitpos (struct value
*value
, int bit
)
341 value_bitsize (struct value
*value
)
343 return value
->bitsize
;
346 set_value_bitsize (struct value
*value
, int bit
)
348 value
->bitsize
= bit
;
352 value_contents_raw (struct value
*value
)
354 allocate_value_contents (value
);
355 return value
->contents
+ value
->embedded_offset
;
359 value_contents_all_raw (struct value
*value
)
361 allocate_value_contents (value
);
362 return value
->contents
;
366 value_enclosing_type (struct value
*value
)
368 return value
->enclosing_type
;
372 value_contents_all (struct value
*value
)
375 value_fetch_lazy (value
);
376 return value
->contents
;
380 value_lazy (struct value
*value
)
386 set_value_lazy (struct value
*value
, int val
)
392 value_contents (struct value
*value
)
394 return value_contents_writeable (value
);
398 value_contents_writeable (struct value
*value
)
401 value_fetch_lazy (value
);
402 return value_contents_raw (value
);
405 /* Return non-zero if VAL1 and VAL2 have the same contents. Note that
406 this function is different from value_equal; in C the operator ==
407 can return 0 even if the two values being compared are equal. */
410 value_contents_equal (struct value
*val1
, struct value
*val2
)
416 type1
= check_typedef (value_type (val1
));
417 type2
= check_typedef (value_type (val2
));
418 len
= TYPE_LENGTH (type1
);
419 if (len
!= TYPE_LENGTH (type2
))
422 return (memcmp (value_contents (val1
), value_contents (val2
), len
) == 0);
426 value_optimized_out (struct value
*value
)
428 return value
->optimized_out
;
432 set_value_optimized_out (struct value
*value
, int val
)
434 value
->optimized_out
= val
;
438 value_embedded_offset (struct value
*value
)
440 return value
->embedded_offset
;
444 set_value_embedded_offset (struct value
*value
, int val
)
446 value
->embedded_offset
= val
;
450 value_pointed_to_offset (struct value
*value
)
452 return value
->pointed_to_offset
;
456 set_value_pointed_to_offset (struct value
*value
, int val
)
458 value
->pointed_to_offset
= val
;
462 deprecated_value_lval_hack (struct value
*value
)
468 deprecated_value_address_hack (struct value
*value
)
470 return &value
->location
.address
;
473 struct internalvar
**
474 deprecated_value_internalvar_hack (struct value
*value
)
476 return &value
->location
.internalvar
;
480 deprecated_value_frame_id_hack (struct value
*value
)
482 return &value
->frame_id
;
486 deprecated_value_regnum_hack (struct value
*value
)
488 return &value
->regnum
;
492 deprecated_value_modifiable (struct value
*value
)
494 return value
->modifiable
;
497 deprecated_set_value_modifiable (struct value
*value
, int modifiable
)
499 value
->modifiable
= modifiable
;
502 /* Return a mark in the value chain. All values allocated after the
503 mark is obtained (except for those released) are subject to being freed
504 if a subsequent value_free_to_mark is passed the mark. */
512 value_free (struct value
*val
)
515 xfree (val
->contents
);
519 /* Free all values allocated since MARK was obtained by value_mark
520 (except for those released). */
522 value_free_to_mark (struct value
*mark
)
527 for (val
= all_values
; val
&& val
!= mark
; val
= next
)
535 /* Free all the values that have been allocated (except for those released).
536 Called after each command, successful or not. */
539 free_all_values (void)
544 for (val
= all_values
; val
; val
= next
)
553 /* Remove VAL from the chain all_values
554 so it will not be freed automatically. */
557 release_value (struct value
*val
)
561 if (all_values
== val
)
563 all_values
= val
->next
;
567 for (v
= all_values
; v
; v
= v
->next
)
577 /* Release all values up to mark */
579 value_release_to_mark (struct value
*mark
)
584 for (val
= next
= all_values
; next
; next
= next
->next
)
585 if (next
->next
== mark
)
587 all_values
= next
->next
;
595 /* Return a copy of the value ARG.
596 It contains the same contents, for same memory address,
597 but it's a different block of storage. */
600 value_copy (struct value
*arg
)
602 struct type
*encl_type
= value_enclosing_type (arg
);
605 if (value_lazy (arg
))
606 val
= allocate_value_lazy (encl_type
);
608 val
= allocate_value (encl_type
);
609 val
->type
= arg
->type
;
610 VALUE_LVAL (val
) = VALUE_LVAL (arg
);
611 val
->location
= arg
->location
;
612 val
->offset
= arg
->offset
;
613 val
->bitpos
= arg
->bitpos
;
614 val
->bitsize
= arg
->bitsize
;
615 VALUE_FRAME_ID (val
) = VALUE_FRAME_ID (arg
);
616 VALUE_REGNUM (val
) = VALUE_REGNUM (arg
);
617 val
->lazy
= arg
->lazy
;
618 val
->optimized_out
= arg
->optimized_out
;
619 val
->embedded_offset
= value_embedded_offset (arg
);
620 val
->pointed_to_offset
= arg
->pointed_to_offset
;
621 val
->modifiable
= arg
->modifiable
;
622 if (!value_lazy (val
))
624 memcpy (value_contents_all_raw (val
), value_contents_all_raw (arg
),
625 TYPE_LENGTH (value_enclosing_type (arg
)));
632 set_value_component_location (struct value
*component
, struct value
*whole
)
634 if (VALUE_LVAL (whole
) == lval_internalvar
)
635 VALUE_LVAL (component
) = lval_internalvar_component
;
637 VALUE_LVAL (component
) = VALUE_LVAL (whole
);
638 component
->location
= whole
->location
;
642 /* Access to the value history. */
644 /* Record a new value in the value history.
645 Returns the absolute history index of the entry.
646 Result of -1 indicates the value was not saved; otherwise it is the
647 value history index of this new item. */
650 record_latest_value (struct value
*val
)
654 /* We don't want this value to have anything to do with the inferior anymore.
655 In particular, "set $1 = 50" should not affect the variable from which
656 the value was taken, and fast watchpoints should be able to assume that
657 a value on the value history never changes. */
658 if (value_lazy (val
))
659 value_fetch_lazy (val
);
660 /* We preserve VALUE_LVAL so that the user can find out where it was fetched
661 from. This is a bit dubious, because then *&$1 does not just return $1
662 but the current contents of that location. c'est la vie... */
666 /* Here we treat value_history_count as origin-zero
667 and applying to the value being stored now. */
669 i
= value_history_count
% VALUE_HISTORY_CHUNK
;
672 struct value_history_chunk
*new
673 = (struct value_history_chunk
*)
674 xmalloc (sizeof (struct value_history_chunk
));
675 memset (new->values
, 0, sizeof new->values
);
676 new->next
= value_history_chain
;
677 value_history_chain
= new;
680 value_history_chain
->values
[i
] = val
;
682 /* Now we regard value_history_count as origin-one
683 and applying to the value just stored. */
685 return ++value_history_count
;
688 /* Return a copy of the value in the history with sequence number NUM. */
691 access_value_history (int num
)
693 struct value_history_chunk
*chunk
;
698 absnum
+= value_history_count
;
703 error (_("The history is empty."));
705 error (_("There is only one value in the history."));
707 error (_("History does not go back to $$%d."), -num
);
709 if (absnum
> value_history_count
)
710 error (_("History has not yet reached $%d."), absnum
);
714 /* Now absnum is always absolute and origin zero. */
716 chunk
= value_history_chain
;
717 for (i
= (value_history_count
- 1) / VALUE_HISTORY_CHUNK
- absnum
/ VALUE_HISTORY_CHUNK
;
721 return value_copy (chunk
->values
[absnum
% VALUE_HISTORY_CHUNK
]);
725 show_values (char *num_exp
, int from_tty
)
733 /* "show values +" should print from the stored position.
734 "show values <exp>" should print around value number <exp>. */
735 if (num_exp
[0] != '+' || num_exp
[1] != '\0')
736 num
= parse_and_eval_long (num_exp
) - 5;
740 /* "show values" means print the last 10 values. */
741 num
= value_history_count
- 9;
747 for (i
= num
; i
< num
+ 10 && i
<= value_history_count
; i
++)
749 struct value_print_options opts
;
750 val
= access_value_history (i
);
751 printf_filtered (("$%d = "), i
);
752 get_user_print_options (&opts
);
753 value_print (val
, gdb_stdout
, &opts
);
754 printf_filtered (("\n"));
757 /* The next "show values +" should start after what we just printed. */
760 /* Hitting just return after this command should do the same thing as
761 "show values +". If num_exp is null, this is unnecessary, since
762 "show values +" is not useful after "show values". */
763 if (from_tty
&& num_exp
)
770 /* Internal variables. These are variables within the debugger
771 that hold values assigned by debugger commands.
772 The user refers to them with a '$' prefix
773 that does not appear in the variable names stored internally. */
775 static struct internalvar
*internalvars
;
777 /* If the variable does not already exist create it and give it the value given.
778 If no value is given then the default is zero. */
780 init_if_undefined_command (char* args
, int from_tty
)
782 struct internalvar
* intvar
;
784 /* Parse the expression - this is taken from set_command(). */
785 struct expression
*expr
= parse_expression (args
);
786 register struct cleanup
*old_chain
=
787 make_cleanup (free_current_contents
, &expr
);
789 /* Validate the expression.
790 Was the expression an assignment?
791 Or even an expression at all? */
792 if (expr
->nelts
== 0 || expr
->elts
[0].opcode
!= BINOP_ASSIGN
)
793 error (_("Init-if-undefined requires an assignment expression."));
795 /* Extract the variable from the parsed expression.
796 In the case of an assign the lvalue will be in elts[1] and elts[2]. */
797 if (expr
->elts
[1].opcode
!= OP_INTERNALVAR
)
798 error (_("The first parameter to init-if-undefined should be a GDB variable."));
799 intvar
= expr
->elts
[2].internalvar
;
801 /* Only evaluate the expression if the lvalue is void.
802 This may still fail if the expresssion is invalid. */
803 if (TYPE_CODE (value_type (intvar
->value
)) == TYPE_CODE_VOID
)
804 evaluate_expression (expr
);
806 do_cleanups (old_chain
);
810 /* Look up an internal variable with name NAME. NAME should not
811 normally include a dollar sign.
813 If the specified internal variable does not exist,
814 the return value is NULL. */
817 lookup_only_internalvar (char *name
)
819 struct internalvar
*var
;
821 for (var
= internalvars
; var
; var
= var
->next
)
822 if (strcmp (var
->name
, name
) == 0)
829 /* Create an internal variable with name NAME and with a void value.
830 NAME should not normally include a dollar sign. */
833 create_internalvar (char *name
)
835 struct internalvar
*var
;
836 var
= (struct internalvar
*) xmalloc (sizeof (struct internalvar
));
837 var
->name
= concat (name
, (char *)NULL
);
838 var
->value
= allocate_value (builtin_type_void
);
839 var
->endian
= gdbarch_byte_order (current_gdbarch
);
840 release_value (var
->value
);
841 var
->next
= internalvars
;
847 /* Look up an internal variable with name NAME. NAME should not
848 normally include a dollar sign.
850 If the specified internal variable does not exist,
851 one is created, with a void value. */
854 lookup_internalvar (char *name
)
856 struct internalvar
*var
;
858 var
= lookup_only_internalvar (name
);
862 return create_internalvar (name
);
866 value_of_internalvar (struct internalvar
*var
)
872 val
= value_copy (var
->value
);
873 if (value_lazy (val
))
874 value_fetch_lazy (val
);
875 VALUE_LVAL (val
) = lval_internalvar
;
876 VALUE_INTERNALVAR (val
) = var
;
878 /* Values are always stored in the target's byte order. When connected to a
879 target this will most likely always be correct, so there's normally no
880 need to worry about it.
882 However, internal variables can be set up before the target endian is
883 known and so may become out of date. Fix it up before anybody sees.
885 Internal variables usually hold simple scalar values, and we can
886 correct those. More complex values (e.g. structures and floating
887 point types) are left alone, because they would be too complicated
890 if (var
->endian
!= gdbarch_byte_order (current_gdbarch
))
892 gdb_byte
*array
= value_contents_raw (val
);
893 struct type
*type
= check_typedef (value_enclosing_type (val
));
894 switch (TYPE_CODE (type
))
898 /* Reverse the bytes. */
899 for (i
= 0, j
= TYPE_LENGTH (type
) - 1; i
< j
; i
++, j
--)
913 set_internalvar_component (struct internalvar
*var
, int offset
, int bitpos
,
914 int bitsize
, struct value
*newval
)
916 gdb_byte
*addr
= value_contents_writeable (var
->value
) + offset
;
919 modify_field (addr
, value_as_long (newval
),
922 memcpy (addr
, value_contents (newval
), TYPE_LENGTH (value_type (newval
)));
926 set_internalvar (struct internalvar
*var
, struct value
*val
)
928 struct value
*newval
;
930 newval
= value_copy (val
);
931 newval
->modifiable
= 1;
933 /* Force the value to be fetched from the target now, to avoid problems
934 later when this internalvar is referenced and the target is gone or
936 if (value_lazy (newval
))
937 value_fetch_lazy (newval
);
939 /* Begin code which must not call error(). If var->value points to
940 something free'd, an error() obviously leaves a dangling pointer.
941 But we also get a danling pointer if var->value points to
942 something in the value chain (i.e., before release_value is
943 called), because after the error free_all_values will get called before
945 value_free (var
->value
);
947 var
->endian
= gdbarch_byte_order (current_gdbarch
);
948 release_value (newval
);
949 /* End code which must not call error(). */
953 internalvar_name (struct internalvar
*var
)
958 /* Update VALUE before discarding OBJFILE. COPIED_TYPES is used to
959 prevent cycles / duplicates. */
962 preserve_one_value (struct value
*value
, struct objfile
*objfile
,
965 if (TYPE_OBJFILE (value
->type
) == objfile
)
966 value
->type
= copy_type_recursive (objfile
, value
->type
, copied_types
);
968 if (TYPE_OBJFILE (value
->enclosing_type
) == objfile
)
969 value
->enclosing_type
= copy_type_recursive (objfile
,
970 value
->enclosing_type
,
974 /* Update the internal variables and value history when OBJFILE is
975 discarded; we must copy the types out of the objfile. New global types
976 will be created for every convenience variable which currently points to
977 this objfile's types, and the convenience variables will be adjusted to
978 use the new global types. */
981 preserve_values (struct objfile
*objfile
)
984 struct value_history_chunk
*cur
;
985 struct internalvar
*var
;
989 /* Create the hash table. We allocate on the objfile's obstack, since
990 it is soon to be deleted. */
991 copied_types
= create_copied_types_hash (objfile
);
993 for (cur
= value_history_chain
; cur
; cur
= cur
->next
)
994 for (i
= 0; i
< VALUE_HISTORY_CHUNK
; i
++)
996 preserve_one_value (cur
->values
[i
], objfile
, copied_types
);
998 for (var
= internalvars
; var
; var
= var
->next
)
999 preserve_one_value (var
->value
, objfile
, copied_types
);
1001 for (val
= values_in_python
; val
; val
= val
->next
)
1002 preserve_one_value (val
, objfile
, copied_types
);
1004 htab_delete (copied_types
);
1008 show_convenience (char *ignore
, int from_tty
)
1010 struct internalvar
*var
;
1012 struct value_print_options opts
;
1014 get_user_print_options (&opts
);
1015 for (var
= internalvars
; var
; var
= var
->next
)
1021 printf_filtered (("$%s = "), var
->name
);
1022 value_print (value_of_internalvar (var
), gdb_stdout
,
1024 printf_filtered (("\n"));
1027 printf_unfiltered (_("\
1028 No debugger convenience variables now defined.\n\
1029 Convenience variables have names starting with \"$\";\n\
1030 use \"set\" as in \"set $foo = 5\" to define them.\n"));
1033 /* Extract a value as a C number (either long or double).
1034 Knows how to convert fixed values to double, or
1035 floating values to long.
1036 Does not deallocate the value. */
1039 value_as_long (struct value
*val
)
1041 /* This coerces arrays and functions, which is necessary (e.g.
1042 in disassemble_command). It also dereferences references, which
1043 I suspect is the most logical thing to do. */
1044 val
= coerce_array (val
);
1045 return unpack_long (value_type (val
), value_contents (val
));
1049 value_as_double (struct value
*val
)
1054 foo
= unpack_double (value_type (val
), value_contents (val
), &inv
);
1056 error (_("Invalid floating value found in program."));
1060 /* Extract a value as a C pointer. Does not deallocate the value.
1061 Note that val's type may not actually be a pointer; value_as_long
1062 handles all the cases. */
1064 value_as_address (struct value
*val
)
1066 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
1067 whether we want this to be true eventually. */
1069 /* gdbarch_addr_bits_remove is wrong if we are being called for a
1070 non-address (e.g. argument to "signal", "info break", etc.), or
1071 for pointers to char, in which the low bits *are* significant. */
1072 return gdbarch_addr_bits_remove (current_gdbarch
, value_as_long (val
));
1075 /* There are several targets (IA-64, PowerPC, and others) which
1076 don't represent pointers to functions as simply the address of
1077 the function's entry point. For example, on the IA-64, a
1078 function pointer points to a two-word descriptor, generated by
1079 the linker, which contains the function's entry point, and the
1080 value the IA-64 "global pointer" register should have --- to
1081 support position-independent code. The linker generates
1082 descriptors only for those functions whose addresses are taken.
1084 On such targets, it's difficult for GDB to convert an arbitrary
1085 function address into a function pointer; it has to either find
1086 an existing descriptor for that function, or call malloc and
1087 build its own. On some targets, it is impossible for GDB to
1088 build a descriptor at all: the descriptor must contain a jump
1089 instruction; data memory cannot be executed; and code memory
1092 Upon entry to this function, if VAL is a value of type `function'
1093 (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
1094 VALUE_ADDRESS (val) is the address of the function. This is what
1095 you'll get if you evaluate an expression like `main'. The call
1096 to COERCE_ARRAY below actually does all the usual unary
1097 conversions, which includes converting values of type `function'
1098 to `pointer to function'. This is the challenging conversion
1099 discussed above. Then, `unpack_long' will convert that pointer
1100 back into an address.
1102 So, suppose the user types `disassemble foo' on an architecture
1103 with a strange function pointer representation, on which GDB
1104 cannot build its own descriptors, and suppose further that `foo'
1105 has no linker-built descriptor. The address->pointer conversion
1106 will signal an error and prevent the command from running, even
1107 though the next step would have been to convert the pointer
1108 directly back into the same address.
1110 The following shortcut avoids this whole mess. If VAL is a
1111 function, just return its address directly. */
1112 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_FUNC
1113 || TYPE_CODE (value_type (val
)) == TYPE_CODE_METHOD
)
1114 return VALUE_ADDRESS (val
);
1116 val
= coerce_array (val
);
1118 /* Some architectures (e.g. Harvard), map instruction and data
1119 addresses onto a single large unified address space. For
1120 instance: An architecture may consider a large integer in the
1121 range 0x10000000 .. 0x1000ffff to already represent a data
1122 addresses (hence not need a pointer to address conversion) while
1123 a small integer would still need to be converted integer to
1124 pointer to address. Just assume such architectures handle all
1125 integer conversions in a single function. */
1129 I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we
1130 must admonish GDB hackers to make sure its behavior matches the
1131 compiler's, whenever possible.
1133 In general, I think GDB should evaluate expressions the same way
1134 the compiler does. When the user copies an expression out of
1135 their source code and hands it to a `print' command, they should
1136 get the same value the compiler would have computed. Any
1137 deviation from this rule can cause major confusion and annoyance,
1138 and needs to be justified carefully. In other words, GDB doesn't
1139 really have the freedom to do these conversions in clever and
1142 AndrewC pointed out that users aren't complaining about how GDB
1143 casts integers to pointers; they are complaining that they can't
1144 take an address from a disassembly listing and give it to `x/i'.
1145 This is certainly important.
1147 Adding an architecture method like integer_to_address() certainly
1148 makes it possible for GDB to "get it right" in all circumstances
1149 --- the target has complete control over how things get done, so
1150 people can Do The Right Thing for their target without breaking
1151 anyone else. The standard doesn't specify how integers get
1152 converted to pointers; usually, the ABI doesn't either, but
1153 ABI-specific code is a more reasonable place to handle it. */
1155 if (TYPE_CODE (value_type (val
)) != TYPE_CODE_PTR
1156 && TYPE_CODE (value_type (val
)) != TYPE_CODE_REF
1157 && gdbarch_integer_to_address_p (current_gdbarch
))
1158 return gdbarch_integer_to_address (current_gdbarch
, value_type (val
),
1159 value_contents (val
));
1161 return unpack_long (value_type (val
), value_contents (val
));
1165 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
1166 as a long, or as a double, assuming the raw data is described
1167 by type TYPE. Knows how to convert different sizes of values
1168 and can convert between fixed and floating point. We don't assume
1169 any alignment for the raw data. Return value is in host byte order.
1171 If you want functions and arrays to be coerced to pointers, and
1172 references to be dereferenced, call value_as_long() instead.
1174 C++: It is assumed that the front-end has taken care of
1175 all matters concerning pointers to members. A pointer
1176 to member which reaches here is considered to be equivalent
1177 to an INT (or some size). After all, it is only an offset. */
1180 unpack_long (struct type
*type
, const gdb_byte
*valaddr
)
1182 enum type_code code
= TYPE_CODE (type
);
1183 int len
= TYPE_LENGTH (type
);
1184 int nosign
= TYPE_UNSIGNED (type
);
1188 case TYPE_CODE_TYPEDEF
:
1189 return unpack_long (check_typedef (type
), valaddr
);
1190 case TYPE_CODE_ENUM
:
1191 case TYPE_CODE_FLAGS
:
1192 case TYPE_CODE_BOOL
:
1194 case TYPE_CODE_CHAR
:
1195 case TYPE_CODE_RANGE
:
1196 case TYPE_CODE_MEMBERPTR
:
1198 return extract_unsigned_integer (valaddr
, len
);
1200 return extract_signed_integer (valaddr
, len
);
1203 return extract_typed_floating (valaddr
, type
);
1205 case TYPE_CODE_DECFLOAT
:
1206 /* libdecnumber has a function to convert from decimal to integer, but
1207 it doesn't work when the decimal number has a fractional part. */
1208 return decimal_to_doublest (valaddr
, len
);
1212 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
1213 whether we want this to be true eventually. */
1214 return extract_typed_address (valaddr
, type
);
1217 error (_("Value can't be converted to integer."));
1219 return 0; /* Placate lint. */
1222 /* Return a double value from the specified type and address.
1223 INVP points to an int which is set to 0 for valid value,
1224 1 for invalid value (bad float format). In either case,
1225 the returned double is OK to use. Argument is in target
1226 format, result is in host format. */
1229 unpack_double (struct type
*type
, const gdb_byte
*valaddr
, int *invp
)
1231 enum type_code code
;
1235 *invp
= 0; /* Assume valid. */
1236 CHECK_TYPEDEF (type
);
1237 code
= TYPE_CODE (type
);
1238 len
= TYPE_LENGTH (type
);
1239 nosign
= TYPE_UNSIGNED (type
);
1240 if (code
== TYPE_CODE_FLT
)
1242 /* NOTE: cagney/2002-02-19: There was a test here to see if the
1243 floating-point value was valid (using the macro
1244 INVALID_FLOAT). That test/macro have been removed.
1246 It turns out that only the VAX defined this macro and then
1247 only in a non-portable way. Fixing the portability problem
1248 wouldn't help since the VAX floating-point code is also badly
1249 bit-rotten. The target needs to add definitions for the
1250 methods gdbarch_float_format and gdbarch_double_format - these
1251 exactly describe the target floating-point format. The
1252 problem here is that the corresponding floatformat_vax_f and
1253 floatformat_vax_d values these methods should be set to are
1254 also not defined either. Oops!
1256 Hopefully someone will add both the missing floatformat
1257 definitions and the new cases for floatformat_is_valid (). */
1259 if (!floatformat_is_valid (floatformat_from_type (type
), valaddr
))
1265 return extract_typed_floating (valaddr
, type
);
1267 else if (code
== TYPE_CODE_DECFLOAT
)
1268 return decimal_to_doublest (valaddr
, len
);
1271 /* Unsigned -- be sure we compensate for signed LONGEST. */
1272 return (ULONGEST
) unpack_long (type
, valaddr
);
1276 /* Signed -- we are OK with unpack_long. */
1277 return unpack_long (type
, valaddr
);
1281 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
1282 as a CORE_ADDR, assuming the raw data is described by type TYPE.
1283 We don't assume any alignment for the raw data. Return value is in
1286 If you want functions and arrays to be coerced to pointers, and
1287 references to be dereferenced, call value_as_address() instead.
1289 C++: It is assumed that the front-end has taken care of
1290 all matters concerning pointers to members. A pointer
1291 to member which reaches here is considered to be equivalent
1292 to an INT (or some size). After all, it is only an offset. */
1295 unpack_pointer (struct type
*type
, const gdb_byte
*valaddr
)
1297 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
1298 whether we want this to be true eventually. */
1299 return unpack_long (type
, valaddr
);
1303 /* Get the value of the FIELDN'th field (which must be static) of
1304 TYPE. Return NULL if the field doesn't exist or has been
1308 value_static_field (struct type
*type
, int fieldno
)
1310 struct value
*retval
;
1312 if (TYPE_FIELD_LOC_KIND (type
, fieldno
) == FIELD_LOC_KIND_PHYSADDR
)
1314 retval
= value_at (TYPE_FIELD_TYPE (type
, fieldno
),
1315 TYPE_FIELD_STATIC_PHYSADDR (type
, fieldno
));
1319 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
1320 struct symbol
*sym
= lookup_symbol (phys_name
, 0, VAR_DOMAIN
, 0);
1323 /* With some compilers, e.g. HP aCC, static data members are reported
1324 as non-debuggable symbols */
1325 struct minimal_symbol
*msym
= lookup_minimal_symbol (phys_name
, NULL
, NULL
);
1330 retval
= value_at (TYPE_FIELD_TYPE (type
, fieldno
),
1331 SYMBOL_VALUE_ADDRESS (msym
));
1336 /* SYM should never have a SYMBOL_CLASS which will require
1337 read_var_value to use the FRAME parameter. */
1338 if (symbol_read_needs_frame (sym
))
1339 warning (_("static field's value depends on the current "
1340 "frame - bad debug info?"));
1341 retval
= read_var_value (sym
, NULL
);
1343 if (retval
&& VALUE_LVAL (retval
) == lval_memory
)
1344 SET_FIELD_PHYSADDR (TYPE_FIELD (type
, fieldno
),
1345 VALUE_ADDRESS (retval
));
1350 /* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.
1351 You have to be careful here, since the size of the data area for the value
1352 is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger
1353 than the old enclosing type, you have to allocate more space for the data.
1354 The return value is a pointer to the new version of this value structure. */
1357 value_change_enclosing_type (struct value
*val
, struct type
*new_encl_type
)
1359 if (TYPE_LENGTH (new_encl_type
) > TYPE_LENGTH (value_enclosing_type (val
)))
1361 (gdb_byte
*) xrealloc (val
->contents
, TYPE_LENGTH (new_encl_type
));
1363 val
->enclosing_type
= new_encl_type
;
1367 /* Given a value ARG1 (offset by OFFSET bytes)
1368 of a struct or union type ARG_TYPE,
1369 extract and return the value of one of its (non-static) fields.
1370 FIELDNO says which field. */
1373 value_primitive_field (struct value
*arg1
, int offset
,
1374 int fieldno
, struct type
*arg_type
)
1379 CHECK_TYPEDEF (arg_type
);
1380 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
1382 /* Handle packed fields */
1384 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
1386 v
= value_from_longest (type
,
1387 unpack_field_as_long (arg_type
,
1388 value_contents (arg1
)
1391 v
->bitpos
= TYPE_FIELD_BITPOS (arg_type
, fieldno
) % 8;
1392 v
->bitsize
= TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
1393 v
->offset
= value_offset (arg1
) + offset
1394 + TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
1396 else if (fieldno
< TYPE_N_BASECLASSES (arg_type
))
1398 /* This field is actually a base subobject, so preserve the
1399 entire object's contents for later references to virtual
1402 /* Lazy register values with offsets are not supported. */
1403 if (VALUE_LVAL (arg1
) == lval_register
&& value_lazy (arg1
))
1404 value_fetch_lazy (arg1
);
1406 if (value_lazy (arg1
))
1407 v
= allocate_value_lazy (value_enclosing_type (arg1
));
1410 v
= allocate_value (value_enclosing_type (arg1
));
1411 memcpy (value_contents_all_raw (v
), value_contents_all_raw (arg1
),
1412 TYPE_LENGTH (value_enclosing_type (arg1
)));
1415 v
->offset
= value_offset (arg1
);
1416 v
->embedded_offset
= (offset
+ value_embedded_offset (arg1
)
1417 + TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8);
1421 /* Plain old data member */
1422 offset
+= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
1424 /* Lazy register values with offsets are not supported. */
1425 if (VALUE_LVAL (arg1
) == lval_register
&& value_lazy (arg1
))
1426 value_fetch_lazy (arg1
);
1428 if (value_lazy (arg1
))
1429 v
= allocate_value_lazy (type
);
1432 v
= allocate_value (type
);
1433 memcpy (value_contents_raw (v
),
1434 value_contents_raw (arg1
) + offset
,
1435 TYPE_LENGTH (type
));
1437 v
->offset
= (value_offset (arg1
) + offset
1438 + value_embedded_offset (arg1
));
1440 set_value_component_location (v
, arg1
);
1441 VALUE_REGNUM (v
) = VALUE_REGNUM (arg1
);
1442 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (arg1
);
1446 /* Given a value ARG1 of a struct or union type,
1447 extract and return the value of one of its (non-static) fields.
1448 FIELDNO says which field. */
1451 value_field (struct value
*arg1
, int fieldno
)
1453 return value_primitive_field (arg1
, 0, fieldno
, value_type (arg1
));
1456 /* Return a non-virtual function as a value.
1457 F is the list of member functions which contains the desired method.
1458 J is an index into F which provides the desired method.
1460 We only use the symbol for its address, so be happy with either a
1461 full symbol or a minimal symbol.
1465 value_fn_field (struct value
**arg1p
, struct fn_field
*f
, int j
, struct type
*type
,
1469 struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
1470 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1472 struct minimal_symbol
*msym
;
1474 sym
= lookup_symbol (physname
, 0, VAR_DOMAIN
, 0);
1481 gdb_assert (sym
== NULL
);
1482 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
1487 v
= allocate_value (ftype
);
1490 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1494 /* The minimal symbol might point to a function descriptor;
1495 resolve it to the actual code address instead. */
1496 struct objfile
*objfile
= msymbol_objfile (msym
);
1497 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1500 = gdbarch_convert_from_func_ptr_addr
1501 (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
), ¤t_target
);
1506 if (type
!= value_type (*arg1p
))
1507 *arg1p
= value_ind (value_cast (lookup_pointer_type (type
),
1508 value_addr (*arg1p
)));
1510 /* Move the `this' pointer according to the offset.
1511 VALUE_OFFSET (*arg1p) += offset;
1519 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1522 Extracting bits depends on endianness of the machine. Compute the
1523 number of least significant bits to discard. For big endian machines,
1524 we compute the total number of bits in the anonymous object, subtract
1525 off the bit count from the MSB of the object to the MSB of the
1526 bitfield, then the size of the bitfield, which leaves the LSB discard
1527 count. For little endian machines, the discard count is simply the
1528 number of bits from the LSB of the anonymous object to the LSB of the
1531 If the field is signed, we also do sign extension. */
1534 unpack_field_as_long (struct type
*type
, const gdb_byte
*valaddr
, int fieldno
)
1538 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
1539 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
1541 struct type
*field_type
;
1543 val
= extract_unsigned_integer (valaddr
+ bitpos
/ 8, sizeof (val
));
1544 field_type
= TYPE_FIELD_TYPE (type
, fieldno
);
1545 CHECK_TYPEDEF (field_type
);
1547 /* Extract bits. See comment above. */
1549 if (gdbarch_bits_big_endian (current_gdbarch
))
1550 lsbcount
= (sizeof val
* 8 - bitpos
% 8 - bitsize
);
1552 lsbcount
= (bitpos
% 8);
1555 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1556 If the field is signed, and is negative, then sign extend. */
1558 if ((bitsize
> 0) && (bitsize
< 8 * (int) sizeof (val
)))
1560 valmask
= (((ULONGEST
) 1) << bitsize
) - 1;
1562 if (!TYPE_UNSIGNED (field_type
))
1564 if (val
& (valmask
^ (valmask
>> 1)))
1573 /* Modify the value of a bitfield. ADDR points to a block of memory in
1574 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1575 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1576 indicate which bits (in target bit order) comprise the bitfield.
1577 Requires 0 < BITSIZE <= lbits, 0 <= BITPOS+BITSIZE <= lbits, and
1578 0 <= BITPOS, where lbits is the size of a LONGEST in bits. */
1581 modify_field (gdb_byte
*addr
, LONGEST fieldval
, int bitpos
, int bitsize
)
1584 ULONGEST mask
= (ULONGEST
) -1 >> (8 * sizeof (ULONGEST
) - bitsize
);
1586 /* If a negative fieldval fits in the field in question, chop
1587 off the sign extension bits. */
1588 if ((~fieldval
& ~(mask
>> 1)) == 0)
1591 /* Warn if value is too big to fit in the field in question. */
1592 if (0 != (fieldval
& ~mask
))
1594 /* FIXME: would like to include fieldval in the message, but
1595 we don't have a sprintf_longest. */
1596 warning (_("Value does not fit in %d bits."), bitsize
);
1598 /* Truncate it, otherwise adjoining fields may be corrupted. */
1602 oword
= extract_unsigned_integer (addr
, sizeof oword
);
1604 /* Shifting for bit field depends on endianness of the target machine. */
1605 if (gdbarch_bits_big_endian (current_gdbarch
))
1606 bitpos
= sizeof (oword
) * 8 - bitpos
- bitsize
;
1608 oword
&= ~(mask
<< bitpos
);
1609 oword
|= fieldval
<< bitpos
;
1611 store_unsigned_integer (addr
, sizeof oword
, oword
);
1614 /* Pack NUM into BUF using a target format of TYPE. */
1617 pack_long (gdb_byte
*buf
, struct type
*type
, LONGEST num
)
1621 type
= check_typedef (type
);
1622 len
= TYPE_LENGTH (type
);
1624 switch (TYPE_CODE (type
))
1627 case TYPE_CODE_CHAR
:
1628 case TYPE_CODE_ENUM
:
1629 case TYPE_CODE_FLAGS
:
1630 case TYPE_CODE_BOOL
:
1631 case TYPE_CODE_RANGE
:
1632 case TYPE_CODE_MEMBERPTR
:
1633 store_signed_integer (buf
, len
, num
);
1638 store_typed_address (buf
, type
, (CORE_ADDR
) num
);
1642 error (_("Unexpected type (%d) encountered for integer constant."),
1648 /* Convert C numbers into newly allocated values. */
1651 value_from_longest (struct type
*type
, LONGEST num
)
1653 struct value
*val
= allocate_value (type
);
1655 pack_long (value_contents_raw (val
), type
, num
);
1661 /* Create a value representing a pointer of type TYPE to the address
1664 value_from_pointer (struct type
*type
, CORE_ADDR addr
)
1666 struct value
*val
= allocate_value (type
);
1667 store_typed_address (value_contents_raw (val
), type
, addr
);
1672 /* Create a value for a string constant to be stored locally
1673 (not in the inferior's memory space, but in GDB memory).
1674 This is analogous to value_from_longest, which also does not
1675 use inferior memory. String shall NOT contain embedded nulls. */
1678 value_from_string (char *ptr
)
1681 int len
= strlen (ptr
);
1682 int lowbound
= current_language
->string_lower_bound
;
1683 struct type
*string_char_type
;
1684 struct type
*rangetype
;
1685 struct type
*stringtype
;
1687 rangetype
= create_range_type ((struct type
*) NULL
,
1689 lowbound
, len
+ lowbound
- 1);
1690 string_char_type
= language_string_char_type (current_language
,
1692 stringtype
= create_array_type ((struct type
*) NULL
,
1695 val
= allocate_value (stringtype
);
1696 memcpy (value_contents_raw (val
), ptr
, len
);
1700 /* Create a value of type TYPE whose contents come from VALADDR, if it
1701 is non-null, and whose memory address (in the inferior) is
1705 value_from_contents_and_address (struct type
*type
,
1706 const gdb_byte
*valaddr
,
1709 struct value
*v
= allocate_value (type
);
1710 if (valaddr
== NULL
)
1711 set_value_lazy (v
, 1);
1713 memcpy (value_contents_raw (v
), valaddr
, TYPE_LENGTH (type
));
1714 VALUE_ADDRESS (v
) = address
;
1715 VALUE_LVAL (v
) = lval_memory
;
1720 value_from_double (struct type
*type
, DOUBLEST num
)
1722 struct value
*val
= allocate_value (type
);
1723 struct type
*base_type
= check_typedef (type
);
1724 enum type_code code
= TYPE_CODE (base_type
);
1725 int len
= TYPE_LENGTH (base_type
);
1727 if (code
== TYPE_CODE_FLT
)
1729 store_typed_floating (value_contents_raw (val
), base_type
, num
);
1732 error (_("Unexpected type encountered for floating constant."));
1738 value_from_decfloat (struct type
*type
, const gdb_byte
*dec
)
1740 struct value
*val
= allocate_value (type
);
1742 memcpy (value_contents_raw (val
), dec
, TYPE_LENGTH (type
));
1748 coerce_ref (struct value
*arg
)
1750 struct type
*value_type_arg_tmp
= check_typedef (value_type (arg
));
1751 if (TYPE_CODE (value_type_arg_tmp
) == TYPE_CODE_REF
)
1752 arg
= value_at_lazy (TYPE_TARGET_TYPE (value_type_arg_tmp
),
1753 unpack_pointer (value_type (arg
),
1754 value_contents (arg
)));
1759 coerce_array (struct value
*arg
)
1763 arg
= coerce_ref (arg
);
1764 type
= check_typedef (value_type (arg
));
1766 switch (TYPE_CODE (type
))
1768 case TYPE_CODE_ARRAY
:
1769 if (current_language
->c_style_arrays
)
1770 arg
= value_coerce_array (arg
);
1772 case TYPE_CODE_FUNC
:
1773 arg
= value_coerce_function (arg
);
1780 /* Return true if the function returning the specified type is using
1781 the convention of returning structures in memory (passing in the
1782 address as a hidden first parameter). */
1785 using_struct_return (struct type
*func_type
, struct type
*value_type
)
1787 enum type_code code
= TYPE_CODE (value_type
);
1789 if (code
== TYPE_CODE_ERROR
)
1790 error (_("Function return type unknown."));
1792 if (code
== TYPE_CODE_VOID
)
1793 /* A void return value is never in memory. See also corresponding
1794 code in "print_return_value". */
1797 /* Probe the architecture for the return-value convention. */
1798 return (gdbarch_return_value (current_gdbarch
, func_type
, value_type
,
1800 != RETURN_VALUE_REGISTER_CONVENTION
);
1803 /* Set the initialized field in a value struct. */
1806 set_value_initialized (struct value
*val
, int status
)
1808 val
->initialized
= status
;
1811 /* Return the initialized field in a value struct. */
1814 value_initialized (struct value
*val
)
1816 return val
->initialized
;
1820 _initialize_values (void)
1822 add_cmd ("convenience", no_class
, show_convenience
, _("\
1823 Debugger convenience (\"$foo\") variables.\n\
1824 These variables are created when you assign them values;\n\
1825 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\
1827 A few convenience variables are given values automatically:\n\
1828 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1829 \"$__\" holds the contents of the last address examined with \"x\"."),
1832 add_cmd ("values", no_class
, show_values
,
1833 _("Elements of value history around item number IDX (or last ten)."),
1836 add_com ("init-if-undefined", class_vars
, init_if_undefined_command
, _("\
1837 Initialize a convenience variable if necessary.\n\
1838 init-if-undefined VARIABLE = EXPRESSION\n\
1839 Set an internal VARIABLE to the result of the EXPRESSION if it does not\n\
1840 exist or does not contain a value. The EXPRESSION is not evaluated if the\n\
1841 VARIABLE is already initialized."));