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 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
)));
631 /* Access to the value history. */
633 /* Record a new value in the value history.
634 Returns the absolute history index of the entry.
635 Result of -1 indicates the value was not saved; otherwise it is the
636 value history index of this new item. */
639 record_latest_value (struct value
*val
)
643 /* We don't want this value to have anything to do with the inferior anymore.
644 In particular, "set $1 = 50" should not affect the variable from which
645 the value was taken, and fast watchpoints should be able to assume that
646 a value on the value history never changes. */
647 if (value_lazy (val
))
648 value_fetch_lazy (val
);
649 /* We preserve VALUE_LVAL so that the user can find out where it was fetched
650 from. This is a bit dubious, because then *&$1 does not just return $1
651 but the current contents of that location. c'est la vie... */
655 /* Here we treat value_history_count as origin-zero
656 and applying to the value being stored now. */
658 i
= value_history_count
% VALUE_HISTORY_CHUNK
;
661 struct value_history_chunk
*new
662 = (struct value_history_chunk
*)
663 xmalloc (sizeof (struct value_history_chunk
));
664 memset (new->values
, 0, sizeof new->values
);
665 new->next
= value_history_chain
;
666 value_history_chain
= new;
669 value_history_chain
->values
[i
] = val
;
671 /* Now we regard value_history_count as origin-one
672 and applying to the value just stored. */
674 return ++value_history_count
;
677 /* Return a copy of the value in the history with sequence number NUM. */
680 access_value_history (int num
)
682 struct value_history_chunk
*chunk
;
687 absnum
+= value_history_count
;
692 error (_("The history is empty."));
694 error (_("There is only one value in the history."));
696 error (_("History does not go back to $$%d."), -num
);
698 if (absnum
> value_history_count
)
699 error (_("History has not yet reached $%d."), absnum
);
703 /* Now absnum is always absolute and origin zero. */
705 chunk
= value_history_chain
;
706 for (i
= (value_history_count
- 1) / VALUE_HISTORY_CHUNK
- absnum
/ VALUE_HISTORY_CHUNK
;
710 return value_copy (chunk
->values
[absnum
% VALUE_HISTORY_CHUNK
]);
714 show_values (char *num_exp
, int from_tty
)
722 /* "show values +" should print from the stored position.
723 "show values <exp>" should print around value number <exp>. */
724 if (num_exp
[0] != '+' || num_exp
[1] != '\0')
725 num
= parse_and_eval_long (num_exp
) - 5;
729 /* "show values" means print the last 10 values. */
730 num
= value_history_count
- 9;
736 for (i
= num
; i
< num
+ 10 && i
<= value_history_count
; i
++)
738 struct value_print_options opts
;
739 val
= access_value_history (i
);
740 printf_filtered (("$%d = "), i
);
741 get_user_print_options (&opts
);
742 value_print (val
, gdb_stdout
, &opts
);
743 printf_filtered (("\n"));
746 /* The next "show values +" should start after what we just printed. */
749 /* Hitting just return after this command should do the same thing as
750 "show values +". If num_exp is null, this is unnecessary, since
751 "show values +" is not useful after "show values". */
752 if (from_tty
&& num_exp
)
759 /* Internal variables. These are variables within the debugger
760 that hold values assigned by debugger commands.
761 The user refers to them with a '$' prefix
762 that does not appear in the variable names stored internally. */
764 static struct internalvar
*internalvars
;
766 /* If the variable does not already exist create it and give it the value given.
767 If no value is given then the default is zero. */
769 init_if_undefined_command (char* args
, int from_tty
)
771 struct internalvar
* intvar
;
773 /* Parse the expression - this is taken from set_command(). */
774 struct expression
*expr
= parse_expression (args
);
775 register struct cleanup
*old_chain
=
776 make_cleanup (free_current_contents
, &expr
);
778 /* Validate the expression.
779 Was the expression an assignment?
780 Or even an expression at all? */
781 if (expr
->nelts
== 0 || expr
->elts
[0].opcode
!= BINOP_ASSIGN
)
782 error (_("Init-if-undefined requires an assignment expression."));
784 /* Extract the variable from the parsed expression.
785 In the case of an assign the lvalue will be in elts[1] and elts[2]. */
786 if (expr
->elts
[1].opcode
!= OP_INTERNALVAR
)
787 error (_("The first parameter to init-if-undefined should be a GDB variable."));
788 intvar
= expr
->elts
[2].internalvar
;
790 /* Only evaluate the expression if the lvalue is void.
791 This may still fail if the expresssion is invalid. */
792 if (TYPE_CODE (value_type (intvar
->value
)) == TYPE_CODE_VOID
)
793 evaluate_expression (expr
);
795 do_cleanups (old_chain
);
799 /* Look up an internal variable with name NAME. NAME should not
800 normally include a dollar sign.
802 If the specified internal variable does not exist,
803 the return value is NULL. */
806 lookup_only_internalvar (char *name
)
808 struct internalvar
*var
;
810 for (var
= internalvars
; var
; var
= var
->next
)
811 if (strcmp (var
->name
, name
) == 0)
818 /* Create an internal variable with name NAME and with a void value.
819 NAME should not normally include a dollar sign. */
822 create_internalvar (char *name
)
824 struct internalvar
*var
;
825 var
= (struct internalvar
*) xmalloc (sizeof (struct internalvar
));
826 var
->name
= concat (name
, (char *)NULL
);
827 var
->value
= allocate_value (builtin_type_void
);
828 var
->endian
= gdbarch_byte_order (current_gdbarch
);
829 release_value (var
->value
);
830 var
->next
= internalvars
;
836 /* Look up an internal variable with name NAME. NAME should not
837 normally include a dollar sign.
839 If the specified internal variable does not exist,
840 one is created, with a void value. */
843 lookup_internalvar (char *name
)
845 struct internalvar
*var
;
847 var
= lookup_only_internalvar (name
);
851 return create_internalvar (name
);
855 value_of_internalvar (struct internalvar
*var
)
861 val
= value_copy (var
->value
);
862 if (value_lazy (val
))
863 value_fetch_lazy (val
);
864 VALUE_LVAL (val
) = lval_internalvar
;
865 VALUE_INTERNALVAR (val
) = var
;
867 /* Values are always stored in the target's byte order. When connected to a
868 target this will most likely always be correct, so there's normally no
869 need to worry about it.
871 However, internal variables can be set up before the target endian is
872 known and so may become out of date. Fix it up before anybody sees.
874 Internal variables usually hold simple scalar values, and we can
875 correct those. More complex values (e.g. structures and floating
876 point types) are left alone, because they would be too complicated
879 if (var
->endian
!= gdbarch_byte_order (current_gdbarch
))
881 gdb_byte
*array
= value_contents_raw (val
);
882 struct type
*type
= check_typedef (value_enclosing_type (val
));
883 switch (TYPE_CODE (type
))
887 /* Reverse the bytes. */
888 for (i
= 0, j
= TYPE_LENGTH (type
) - 1; i
< j
; i
++, j
--)
902 set_internalvar_component (struct internalvar
*var
, int offset
, int bitpos
,
903 int bitsize
, struct value
*newval
)
905 gdb_byte
*addr
= value_contents_writeable (var
->value
) + offset
;
908 modify_field (addr
, value_as_long (newval
),
911 memcpy (addr
, value_contents (newval
), TYPE_LENGTH (value_type (newval
)));
915 set_internalvar (struct internalvar
*var
, struct value
*val
)
917 struct value
*newval
;
919 newval
= value_copy (val
);
920 newval
->modifiable
= 1;
922 /* Force the value to be fetched from the target now, to avoid problems
923 later when this internalvar is referenced and the target is gone or
925 if (value_lazy (newval
))
926 value_fetch_lazy (newval
);
928 /* Begin code which must not call error(). If var->value points to
929 something free'd, an error() obviously leaves a dangling pointer.
930 But we also get a danling pointer if var->value points to
931 something in the value chain (i.e., before release_value is
932 called), because after the error free_all_values will get called before
936 var
->endian
= gdbarch_byte_order (current_gdbarch
);
937 release_value (newval
);
938 /* End code which must not call error(). */
942 internalvar_name (struct internalvar
*var
)
947 /* Update VALUE before discarding OBJFILE. COPIED_TYPES is used to
948 prevent cycles / duplicates. */
951 preserve_one_value (struct value
*value
, struct objfile
*objfile
,
954 if (TYPE_OBJFILE (value
->type
) == objfile
)
955 value
->type
= copy_type_recursive (objfile
, value
->type
, copied_types
);
957 if (TYPE_OBJFILE (value
->enclosing_type
) == objfile
)
958 value
->enclosing_type
= copy_type_recursive (objfile
,
959 value
->enclosing_type
,
963 /* Update the internal variables and value history when OBJFILE is
964 discarded; we must copy the types out of the objfile. New global types
965 will be created for every convenience variable which currently points to
966 this objfile's types, and the convenience variables will be adjusted to
967 use the new global types. */
970 preserve_values (struct objfile
*objfile
)
973 struct value_history_chunk
*cur
;
974 struct internalvar
*var
;
978 /* Create the hash table. We allocate on the objfile's obstack, since
979 it is soon to be deleted. */
980 copied_types
= create_copied_types_hash (objfile
);
982 for (cur
= value_history_chain
; cur
; cur
= cur
->next
)
983 for (i
= 0; i
< VALUE_HISTORY_CHUNK
; i
++)
985 preserve_one_value (cur
->values
[i
], objfile
, copied_types
);
987 for (var
= internalvars
; var
; var
= var
->next
)
988 preserve_one_value (var
->value
, objfile
, copied_types
);
990 for (val
= values_in_python
; val
; val
= val
->next
)
991 preserve_one_value (val
, objfile
, copied_types
);
993 htab_delete (copied_types
);
997 show_convenience (char *ignore
, int from_tty
)
999 struct internalvar
*var
;
1001 struct value_print_options opts
;
1003 get_user_print_options (&opts
);
1004 for (var
= internalvars
; var
; var
= var
->next
)
1010 printf_filtered (("$%s = "), var
->name
);
1011 value_print (value_of_internalvar (var
), gdb_stdout
,
1013 printf_filtered (("\n"));
1016 printf_unfiltered (_("\
1017 No debugger convenience variables now defined.\n\
1018 Convenience variables have names starting with \"$\";\n\
1019 use \"set\" as in \"set $foo = 5\" to define them.\n"));
1022 /* Extract a value as a C number (either long or double).
1023 Knows how to convert fixed values to double, or
1024 floating values to long.
1025 Does not deallocate the value. */
1028 value_as_long (struct value
*val
)
1030 /* This coerces arrays and functions, which is necessary (e.g.
1031 in disassemble_command). It also dereferences references, which
1032 I suspect is the most logical thing to do. */
1033 val
= coerce_array (val
);
1034 return unpack_long (value_type (val
), value_contents (val
));
1038 value_as_double (struct value
*val
)
1043 foo
= unpack_double (value_type (val
), value_contents (val
), &inv
);
1045 error (_("Invalid floating value found in program."));
1049 /* Extract a value as a C pointer. Does not deallocate the value.
1050 Note that val's type may not actually be a pointer; value_as_long
1051 handles all the cases. */
1053 value_as_address (struct value
*val
)
1055 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
1056 whether we want this to be true eventually. */
1058 /* gdbarch_addr_bits_remove is wrong if we are being called for a
1059 non-address (e.g. argument to "signal", "info break", etc.), or
1060 for pointers to char, in which the low bits *are* significant. */
1061 return gdbarch_addr_bits_remove (current_gdbarch
, value_as_long (val
));
1064 /* There are several targets (IA-64, PowerPC, and others) which
1065 don't represent pointers to functions as simply the address of
1066 the function's entry point. For example, on the IA-64, a
1067 function pointer points to a two-word descriptor, generated by
1068 the linker, which contains the function's entry point, and the
1069 value the IA-64 "global pointer" register should have --- to
1070 support position-independent code. The linker generates
1071 descriptors only for those functions whose addresses are taken.
1073 On such targets, it's difficult for GDB to convert an arbitrary
1074 function address into a function pointer; it has to either find
1075 an existing descriptor for that function, or call malloc and
1076 build its own. On some targets, it is impossible for GDB to
1077 build a descriptor at all: the descriptor must contain a jump
1078 instruction; data memory cannot be executed; and code memory
1081 Upon entry to this function, if VAL is a value of type `function'
1082 (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
1083 VALUE_ADDRESS (val) is the address of the function. This is what
1084 you'll get if you evaluate an expression like `main'. The call
1085 to COERCE_ARRAY below actually does all the usual unary
1086 conversions, which includes converting values of type `function'
1087 to `pointer to function'. This is the challenging conversion
1088 discussed above. Then, `unpack_long' will convert that pointer
1089 back into an address.
1091 So, suppose the user types `disassemble foo' on an architecture
1092 with a strange function pointer representation, on which GDB
1093 cannot build its own descriptors, and suppose further that `foo'
1094 has no linker-built descriptor. The address->pointer conversion
1095 will signal an error and prevent the command from running, even
1096 though the next step would have been to convert the pointer
1097 directly back into the same address.
1099 The following shortcut avoids this whole mess. If VAL is a
1100 function, just return its address directly. */
1101 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_FUNC
1102 || TYPE_CODE (value_type (val
)) == TYPE_CODE_METHOD
)
1103 return VALUE_ADDRESS (val
);
1105 val
= coerce_array (val
);
1107 /* Some architectures (e.g. Harvard), map instruction and data
1108 addresses onto a single large unified address space. For
1109 instance: An architecture may consider a large integer in the
1110 range 0x10000000 .. 0x1000ffff to already represent a data
1111 addresses (hence not need a pointer to address conversion) while
1112 a small integer would still need to be converted integer to
1113 pointer to address. Just assume such architectures handle all
1114 integer conversions in a single function. */
1118 I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we
1119 must admonish GDB hackers to make sure its behavior matches the
1120 compiler's, whenever possible.
1122 In general, I think GDB should evaluate expressions the same way
1123 the compiler does. When the user copies an expression out of
1124 their source code and hands it to a `print' command, they should
1125 get the same value the compiler would have computed. Any
1126 deviation from this rule can cause major confusion and annoyance,
1127 and needs to be justified carefully. In other words, GDB doesn't
1128 really have the freedom to do these conversions in clever and
1131 AndrewC pointed out that users aren't complaining about how GDB
1132 casts integers to pointers; they are complaining that they can't
1133 take an address from a disassembly listing and give it to `x/i'.
1134 This is certainly important.
1136 Adding an architecture method like integer_to_address() certainly
1137 makes it possible for GDB to "get it right" in all circumstances
1138 --- the target has complete control over how things get done, so
1139 people can Do The Right Thing for their target without breaking
1140 anyone else. The standard doesn't specify how integers get
1141 converted to pointers; usually, the ABI doesn't either, but
1142 ABI-specific code is a more reasonable place to handle it. */
1144 if (TYPE_CODE (value_type (val
)) != TYPE_CODE_PTR
1145 && TYPE_CODE (value_type (val
)) != TYPE_CODE_REF
1146 && gdbarch_integer_to_address_p (current_gdbarch
))
1147 return gdbarch_integer_to_address (current_gdbarch
, value_type (val
),
1148 value_contents (val
));
1150 return unpack_long (value_type (val
), value_contents (val
));
1154 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
1155 as a long, or as a double, assuming the raw data is described
1156 by type TYPE. Knows how to convert different sizes of values
1157 and can convert between fixed and floating point. We don't assume
1158 any alignment for the raw data. Return value is in host byte order.
1160 If you want functions and arrays to be coerced to pointers, and
1161 references to be dereferenced, call value_as_long() instead.
1163 C++: It is assumed that the front-end has taken care of
1164 all matters concerning pointers to members. A pointer
1165 to member which reaches here is considered to be equivalent
1166 to an INT (or some size). After all, it is only an offset. */
1169 unpack_long (struct type
*type
, const gdb_byte
*valaddr
)
1171 enum type_code code
= TYPE_CODE (type
);
1172 int len
= TYPE_LENGTH (type
);
1173 int nosign
= TYPE_UNSIGNED (type
);
1177 case TYPE_CODE_TYPEDEF
:
1178 return unpack_long (check_typedef (type
), valaddr
);
1179 case TYPE_CODE_ENUM
:
1180 case TYPE_CODE_FLAGS
:
1181 case TYPE_CODE_BOOL
:
1183 case TYPE_CODE_CHAR
:
1184 case TYPE_CODE_RANGE
:
1185 case TYPE_CODE_MEMBERPTR
:
1187 return extract_unsigned_integer (valaddr
, len
);
1189 return extract_signed_integer (valaddr
, len
);
1192 return extract_typed_floating (valaddr
, type
);
1194 case TYPE_CODE_DECFLOAT
:
1195 /* libdecnumber has a function to convert from decimal to integer, but
1196 it doesn't work when the decimal number has a fractional part. */
1197 return decimal_to_doublest (valaddr
, len
);
1201 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
1202 whether we want this to be true eventually. */
1203 return extract_typed_address (valaddr
, type
);
1206 error (_("Value can't be converted to integer."));
1208 return 0; /* Placate lint. */
1211 /* Return a double value from the specified type and address.
1212 INVP points to an int which is set to 0 for valid value,
1213 1 for invalid value (bad float format). In either case,
1214 the returned double is OK to use. Argument is in target
1215 format, result is in host format. */
1218 unpack_double (struct type
*type
, const gdb_byte
*valaddr
, int *invp
)
1220 enum type_code code
;
1224 *invp
= 0; /* Assume valid. */
1225 CHECK_TYPEDEF (type
);
1226 code
= TYPE_CODE (type
);
1227 len
= TYPE_LENGTH (type
);
1228 nosign
= TYPE_UNSIGNED (type
);
1229 if (code
== TYPE_CODE_FLT
)
1231 /* NOTE: cagney/2002-02-19: There was a test here to see if the
1232 floating-point value was valid (using the macro
1233 INVALID_FLOAT). That test/macro have been removed.
1235 It turns out that only the VAX defined this macro and then
1236 only in a non-portable way. Fixing the portability problem
1237 wouldn't help since the VAX floating-point code is also badly
1238 bit-rotten. The target needs to add definitions for the
1239 methods gdbarch_float_format and gdbarch_double_format - these
1240 exactly describe the target floating-point format. The
1241 problem here is that the corresponding floatformat_vax_f and
1242 floatformat_vax_d values these methods should be set to are
1243 also not defined either. Oops!
1245 Hopefully someone will add both the missing floatformat
1246 definitions and the new cases for floatformat_is_valid (). */
1248 if (!floatformat_is_valid (floatformat_from_type (type
), valaddr
))
1254 return extract_typed_floating (valaddr
, type
);
1256 else if (code
== TYPE_CODE_DECFLOAT
)
1257 return decimal_to_doublest (valaddr
, len
);
1260 /* Unsigned -- be sure we compensate for signed LONGEST. */
1261 return (ULONGEST
) unpack_long (type
, valaddr
);
1265 /* Signed -- we are OK with unpack_long. */
1266 return unpack_long (type
, valaddr
);
1270 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
1271 as a CORE_ADDR, assuming the raw data is described by type TYPE.
1272 We don't assume any alignment for the raw data. Return value is in
1275 If you want functions and arrays to be coerced to pointers, and
1276 references to be dereferenced, call value_as_address() instead.
1278 C++: It is assumed that the front-end has taken care of
1279 all matters concerning pointers to members. A pointer
1280 to member which reaches here is considered to be equivalent
1281 to an INT (or some size). After all, it is only an offset. */
1284 unpack_pointer (struct type
*type
, const gdb_byte
*valaddr
)
1286 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
1287 whether we want this to be true eventually. */
1288 return unpack_long (type
, valaddr
);
1292 /* Get the value of the FIELDN'th field (which must be static) of
1293 TYPE. Return NULL if the field doesn't exist or has been
1297 value_static_field (struct type
*type
, int fieldno
)
1299 struct value
*retval
;
1301 if (TYPE_FIELD_LOC_KIND (type
, fieldno
) == FIELD_LOC_KIND_PHYSADDR
)
1303 retval
= value_at (TYPE_FIELD_TYPE (type
, fieldno
),
1304 TYPE_FIELD_STATIC_PHYSADDR (type
, fieldno
));
1308 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
1309 struct symbol
*sym
= lookup_symbol (phys_name
, 0, VAR_DOMAIN
, 0);
1312 /* With some compilers, e.g. HP aCC, static data members are reported
1313 as non-debuggable symbols */
1314 struct minimal_symbol
*msym
= lookup_minimal_symbol (phys_name
, NULL
, NULL
);
1319 retval
= value_at (TYPE_FIELD_TYPE (type
, fieldno
),
1320 SYMBOL_VALUE_ADDRESS (msym
));
1325 /* SYM should never have a SYMBOL_CLASS which will require
1326 read_var_value to use the FRAME parameter. */
1327 if (symbol_read_needs_frame (sym
))
1328 warning (_("static field's value depends on the current "
1329 "frame - bad debug info?"));
1330 retval
= read_var_value (sym
, NULL
);
1332 if (retval
&& VALUE_LVAL (retval
) == lval_memory
)
1333 SET_FIELD_PHYSADDR (TYPE_FIELD (type
, fieldno
),
1334 VALUE_ADDRESS (retval
));
1339 /* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.
1340 You have to be careful here, since the size of the data area for the value
1341 is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger
1342 than the old enclosing type, you have to allocate more space for the data.
1343 The return value is a pointer to the new version of this value structure. */
1346 value_change_enclosing_type (struct value
*val
, struct type
*new_encl_type
)
1348 if (TYPE_LENGTH (new_encl_type
) > TYPE_LENGTH (value_enclosing_type (val
)))
1350 (gdb_byte
*) xrealloc (val
->contents
, TYPE_LENGTH (new_encl_type
));
1352 val
->enclosing_type
= new_encl_type
;
1356 /* Given a value ARG1 (offset by OFFSET bytes)
1357 of a struct or union type ARG_TYPE,
1358 extract and return the value of one of its (non-static) fields.
1359 FIELDNO says which field. */
1362 value_primitive_field (struct value
*arg1
, int offset
,
1363 int fieldno
, struct type
*arg_type
)
1368 CHECK_TYPEDEF (arg_type
);
1369 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
1371 /* Handle packed fields */
1373 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
1375 v
= value_from_longest (type
,
1376 unpack_field_as_long (arg_type
,
1377 value_contents (arg1
)
1380 v
->bitpos
= TYPE_FIELD_BITPOS (arg_type
, fieldno
) % 8;
1381 v
->bitsize
= TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
1382 v
->offset
= value_offset (arg1
) + offset
1383 + TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
1385 else if (fieldno
< TYPE_N_BASECLASSES (arg_type
))
1387 /* This field is actually a base subobject, so preserve the
1388 entire object's contents for later references to virtual
1391 /* Lazy register values with offsets are not supported. */
1392 if (VALUE_LVAL (arg1
) == lval_register
&& value_lazy (arg1
))
1393 value_fetch_lazy (arg1
);
1395 if (value_lazy (arg1
))
1396 v
= allocate_value_lazy (value_enclosing_type (arg1
));
1399 v
= allocate_value (value_enclosing_type (arg1
));
1400 memcpy (value_contents_all_raw (v
), value_contents_all_raw (arg1
),
1401 TYPE_LENGTH (value_enclosing_type (arg1
)));
1404 v
->offset
= value_offset (arg1
);
1405 v
->embedded_offset
= (offset
+ value_embedded_offset (arg1
)
1406 + TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8);
1410 /* Plain old data member */
1411 offset
+= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
1413 /* Lazy register values with offsets are not supported. */
1414 if (VALUE_LVAL (arg1
) == lval_register
&& value_lazy (arg1
))
1415 value_fetch_lazy (arg1
);
1417 if (value_lazy (arg1
))
1418 v
= allocate_value_lazy (type
);
1421 v
= allocate_value (type
);
1422 memcpy (value_contents_raw (v
),
1423 value_contents_raw (arg1
) + offset
,
1424 TYPE_LENGTH (type
));
1426 v
->offset
= (value_offset (arg1
) + offset
1427 + value_embedded_offset (arg1
));
1429 VALUE_LVAL (v
) = VALUE_LVAL (arg1
);
1430 if (VALUE_LVAL (arg1
) == lval_internalvar
)
1431 VALUE_LVAL (v
) = lval_internalvar_component
;
1432 v
->location
= arg1
->location
;
1433 VALUE_REGNUM (v
) = VALUE_REGNUM (arg1
);
1434 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (arg1
);
1438 /* Given a value ARG1 of a struct or union type,
1439 extract and return the value of one of its (non-static) fields.
1440 FIELDNO says which field. */
1443 value_field (struct value
*arg1
, int fieldno
)
1445 return value_primitive_field (arg1
, 0, fieldno
, value_type (arg1
));
1448 /* Return a non-virtual function as a value.
1449 F is the list of member functions which contains the desired method.
1450 J is an index into F which provides the desired method.
1452 We only use the symbol for its address, so be happy with either a
1453 full symbol or a minimal symbol.
1457 value_fn_field (struct value
**arg1p
, struct fn_field
*f
, int j
, struct type
*type
,
1461 struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
1462 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1464 struct minimal_symbol
*msym
;
1466 sym
= lookup_symbol (physname
, 0, VAR_DOMAIN
, 0);
1473 gdb_assert (sym
== NULL
);
1474 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
1479 v
= allocate_value (ftype
);
1482 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1486 /* The minimal symbol might point to a function descriptor;
1487 resolve it to the actual code address instead. */
1488 struct objfile
*objfile
= msymbol_objfile (msym
);
1489 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1492 = gdbarch_convert_from_func_ptr_addr
1493 (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
), ¤t_target
);
1498 if (type
!= value_type (*arg1p
))
1499 *arg1p
= value_ind (value_cast (lookup_pointer_type (type
),
1500 value_addr (*arg1p
)));
1502 /* Move the `this' pointer according to the offset.
1503 VALUE_OFFSET (*arg1p) += offset;
1511 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1514 Extracting bits depends on endianness of the machine. Compute the
1515 number of least significant bits to discard. For big endian machines,
1516 we compute the total number of bits in the anonymous object, subtract
1517 off the bit count from the MSB of the object to the MSB of the
1518 bitfield, then the size of the bitfield, which leaves the LSB discard
1519 count. For little endian machines, the discard count is simply the
1520 number of bits from the LSB of the anonymous object to the LSB of the
1523 If the field is signed, we also do sign extension. */
1526 unpack_field_as_long (struct type
*type
, const gdb_byte
*valaddr
, int fieldno
)
1530 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
1531 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
1533 struct type
*field_type
;
1535 val
= extract_unsigned_integer (valaddr
+ bitpos
/ 8, sizeof (val
));
1536 field_type
= TYPE_FIELD_TYPE (type
, fieldno
);
1537 CHECK_TYPEDEF (field_type
);
1539 /* Extract bits. See comment above. */
1541 if (gdbarch_bits_big_endian (current_gdbarch
))
1542 lsbcount
= (sizeof val
* 8 - bitpos
% 8 - bitsize
);
1544 lsbcount
= (bitpos
% 8);
1547 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1548 If the field is signed, and is negative, then sign extend. */
1550 if ((bitsize
> 0) && (bitsize
< 8 * (int) sizeof (val
)))
1552 valmask
= (((ULONGEST
) 1) << bitsize
) - 1;
1554 if (!TYPE_UNSIGNED (field_type
))
1556 if (val
& (valmask
^ (valmask
>> 1)))
1565 /* Modify the value of a bitfield. ADDR points to a block of memory in
1566 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1567 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1568 indicate which bits (in target bit order) comprise the bitfield.
1569 Requires 0 < BITSIZE <= lbits, 0 <= BITPOS+BITSIZE <= lbits, and
1570 0 <= BITPOS, where lbits is the size of a LONGEST in bits. */
1573 modify_field (gdb_byte
*addr
, LONGEST fieldval
, int bitpos
, int bitsize
)
1576 ULONGEST mask
= (ULONGEST
) -1 >> (8 * sizeof (ULONGEST
) - bitsize
);
1578 /* If a negative fieldval fits in the field in question, chop
1579 off the sign extension bits. */
1580 if ((~fieldval
& ~(mask
>> 1)) == 0)
1583 /* Warn if value is too big to fit in the field in question. */
1584 if (0 != (fieldval
& ~mask
))
1586 /* FIXME: would like to include fieldval in the message, but
1587 we don't have a sprintf_longest. */
1588 warning (_("Value does not fit in %d bits."), bitsize
);
1590 /* Truncate it, otherwise adjoining fields may be corrupted. */
1594 oword
= extract_unsigned_integer (addr
, sizeof oword
);
1596 /* Shifting for bit field depends on endianness of the target machine. */
1597 if (gdbarch_bits_big_endian (current_gdbarch
))
1598 bitpos
= sizeof (oword
) * 8 - bitpos
- bitsize
;
1600 oword
&= ~(mask
<< bitpos
);
1601 oword
|= fieldval
<< bitpos
;
1603 store_unsigned_integer (addr
, sizeof oword
, oword
);
1606 /* Pack NUM into BUF using a target format of TYPE. */
1609 pack_long (gdb_byte
*buf
, struct type
*type
, LONGEST num
)
1613 type
= check_typedef (type
);
1614 len
= TYPE_LENGTH (type
);
1616 switch (TYPE_CODE (type
))
1619 case TYPE_CODE_CHAR
:
1620 case TYPE_CODE_ENUM
:
1621 case TYPE_CODE_FLAGS
:
1622 case TYPE_CODE_BOOL
:
1623 case TYPE_CODE_RANGE
:
1624 case TYPE_CODE_MEMBERPTR
:
1625 store_signed_integer (buf
, len
, num
);
1630 store_typed_address (buf
, type
, (CORE_ADDR
) num
);
1634 error (_("Unexpected type (%d) encountered for integer constant."),
1640 /* Convert C numbers into newly allocated values. */
1643 value_from_longest (struct type
*type
, LONGEST num
)
1645 struct value
*val
= allocate_value (type
);
1647 pack_long (value_contents_raw (val
), type
, num
);
1653 /* Create a value representing a pointer of type TYPE to the address
1656 value_from_pointer (struct type
*type
, CORE_ADDR addr
)
1658 struct value
*val
= allocate_value (type
);
1659 store_typed_address (value_contents_raw (val
), type
, addr
);
1664 /* Create a value for a string constant to be stored locally
1665 (not in the inferior's memory space, but in GDB memory).
1666 This is analogous to value_from_longest, which also does not
1667 use inferior memory. String shall NOT contain embedded nulls. */
1670 value_from_string (char *ptr
)
1673 int len
= strlen (ptr
);
1674 int lowbound
= current_language
->string_lower_bound
;
1675 struct type
*string_char_type
;
1676 struct type
*rangetype
;
1677 struct type
*stringtype
;
1679 rangetype
= create_range_type ((struct type
*) NULL
,
1681 lowbound
, len
+ lowbound
- 1);
1682 string_char_type
= language_string_char_type (current_language
,
1684 stringtype
= create_array_type ((struct type
*) NULL
,
1687 val
= allocate_value (stringtype
);
1688 memcpy (value_contents_raw (val
), ptr
, len
);
1692 /* Create a value of type TYPE whose contents come from VALADDR, if it
1693 is non-null, and whose memory address (in the inferior) is
1697 value_from_contents_and_address (struct type
*type
,
1698 const gdb_byte
*valaddr
,
1701 struct value
*v
= allocate_value (type
);
1702 if (valaddr
== NULL
)
1703 set_value_lazy (v
, 1);
1705 memcpy (value_contents_raw (v
), valaddr
, TYPE_LENGTH (type
));
1706 VALUE_ADDRESS (v
) = address
;
1708 VALUE_LVAL (v
) = lval_memory
;
1713 value_from_double (struct type
*type
, DOUBLEST num
)
1715 struct value
*val
= allocate_value (type
);
1716 struct type
*base_type
= check_typedef (type
);
1717 enum type_code code
= TYPE_CODE (base_type
);
1718 int len
= TYPE_LENGTH (base_type
);
1720 if (code
== TYPE_CODE_FLT
)
1722 store_typed_floating (value_contents_raw (val
), base_type
, num
);
1725 error (_("Unexpected type encountered for floating constant."));
1731 value_from_decfloat (struct type
*type
, const gdb_byte
*dec
)
1733 struct value
*val
= allocate_value (type
);
1735 memcpy (value_contents_raw (val
), dec
, TYPE_LENGTH (type
));
1741 coerce_ref (struct value
*arg
)
1743 struct type
*value_type_arg_tmp
= check_typedef (value_type (arg
));
1744 if (TYPE_CODE (value_type_arg_tmp
) == TYPE_CODE_REF
)
1745 arg
= value_at_lazy (TYPE_TARGET_TYPE (value_type_arg_tmp
),
1746 unpack_pointer (value_type (arg
),
1747 value_contents (arg
)));
1752 coerce_array (struct value
*arg
)
1756 arg
= coerce_ref (arg
);
1757 type
= check_typedef (value_type (arg
));
1759 switch (TYPE_CODE (type
))
1761 case TYPE_CODE_ARRAY
:
1762 if (current_language
->c_style_arrays
)
1763 arg
= value_coerce_array (arg
);
1765 case TYPE_CODE_FUNC
:
1766 arg
= value_coerce_function (arg
);
1773 /* Return true if the function returning the specified type is using
1774 the convention of returning structures in memory (passing in the
1775 address as a hidden first parameter). */
1778 using_struct_return (struct type
*func_type
, struct type
*value_type
)
1780 enum type_code code
= TYPE_CODE (value_type
);
1782 if (code
== TYPE_CODE_ERROR
)
1783 error (_("Function return type unknown."));
1785 if (code
== TYPE_CODE_VOID
)
1786 /* A void return value is never in memory. See also corresponding
1787 code in "print_return_value". */
1790 /* Probe the architecture for the return-value convention. */
1791 return (gdbarch_return_value (current_gdbarch
, func_type
, value_type
,
1793 != RETURN_VALUE_REGISTER_CONVENTION
);
1796 /* Set the initialized field in a value struct. */
1799 set_value_initialized (struct value
*val
, int status
)
1801 val
->initialized
= status
;
1804 /* Return the initialized field in a value struct. */
1807 value_initialized (struct value
*val
)
1809 return val
->initialized
;
1813 _initialize_values (void)
1815 add_cmd ("convenience", no_class
, show_convenience
, _("\
1816 Debugger convenience (\"$foo\") variables.\n\
1817 These variables are created when you assign them values;\n\
1818 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\
1820 A few convenience variables are given values automatically:\n\
1821 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1822 \"$__\" holds the contents of the last address examined with \"x\"."),
1825 add_cmd ("values", no_class
, show_values
,
1826 _("Elements of value history around item number IDX (or last ten)."),
1829 add_com ("init-if-undefined", class_vars
, init_if_undefined_command
, _("\
1830 Initialize a convenience variable if necessary.\n\
1831 init-if-undefined VARIABLE = EXPRESSION\n\
1832 Set an internal VARIABLE to the result of the EXPRESSION if it does not\n\
1833 exist or does not contain a value. The EXPRESSION is not evaluated if the\n\
1834 VARIABLE is already initialized."));