1 /* Low level packing and unpacking of values for GDB, the GNU Debugger.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005 Free
5 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 2 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, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 #include "gdb_string.h"
37 #include "gdb_assert.h"
41 /* Prototypes for exported functions. */
43 void _initialize_values (void);
45 /* Prototypes for local functions. */
47 static void show_values (char *, int);
49 static void show_convenience (char *, int);
52 /* The value-history records all the values printed
53 by print commands during this session. Each chunk
54 records 60 consecutive values. The first chunk on
55 the chain records the most recent values.
56 The total number of values is in value_history_count. */
58 #define VALUE_HISTORY_CHUNK 60
60 struct value_history_chunk
62 struct value_history_chunk
*next
;
63 struct value
*values
[VALUE_HISTORY_CHUNK
];
66 /* Chain of chunks now in use. */
68 static struct value_history_chunk
*value_history_chain
;
70 static int value_history_count
; /* Abs number of last entry stored */
72 /* List of all value objects currently allocated
73 (except for those released by calls to release_value)
74 This is so they can be freed after each command. */
76 static struct value
*all_values
;
78 /* Allocate a value that has the correct length for type TYPE. */
81 allocate_value (struct type
*type
)
84 struct type
*atype
= check_typedef (type
);
86 val
= (struct value
*) xzalloc (sizeof (struct value
) + TYPE_LENGTH (atype
));
87 val
->next
= all_values
;
90 val
->enclosing_type
= type
;
91 VALUE_LVAL (val
) = not_lval
;
92 VALUE_ADDRESS (val
) = 0;
93 VALUE_FRAME_ID (val
) = null_frame_id
;
97 VALUE_REGNUM (val
) = -1;
99 val
->optimized_out
= 0;
100 val
->embedded_offset
= 0;
101 VALUE_POINTED_TO_OFFSET (val
) = 0;
106 /* Allocate a value that has the correct length
107 for COUNT repetitions type TYPE. */
110 allocate_repeat_value (struct type
*type
, int count
)
112 int low_bound
= current_language
->string_lower_bound
; /* ??? */
113 /* FIXME-type-allocation: need a way to free this type when we are
115 struct type
*range_type
116 = create_range_type ((struct type
*) NULL
, builtin_type_int
,
117 low_bound
, count
+ low_bound
- 1);
118 /* FIXME-type-allocation: need a way to free this type when we are
120 return allocate_value (create_array_type ((struct type
*) NULL
,
124 /* Accessor methods. */
127 value_type (struct value
*value
)
133 value_offset (struct value
*value
)
135 return value
->offset
;
139 value_bitpos (struct value
*value
)
141 return value
->bitpos
;
145 value_bitsize (struct value
*value
)
147 return value
->bitsize
;
151 value_contents_raw (struct value
*value
)
153 return value
->aligner
.contents
+ value
->embedded_offset
;
157 value_contents_all_raw (struct value
*value
)
159 return value
->aligner
.contents
;
163 value_enclosing_type (struct value
*value
)
165 return value
->enclosing_type
;
169 value_contents_all (struct value
*value
)
172 value_fetch_lazy (value
);
173 return value
->aligner
.contents
;
177 value_lazy (struct value
*value
)
183 set_value_lazy (struct value
*value
, int val
)
189 value_contents (struct value
*value
)
191 return value_contents_writeable (value
);
195 value_contents_writeable (struct value
*value
)
198 value_fetch_lazy (value
);
199 return value
->aligner
.contents
;
203 value_optimized_out (struct value
*value
)
205 return value
->optimized_out
;
209 set_value_optimized_out (struct value
*value
, int val
)
211 value
->optimized_out
= val
;
215 value_embedded_offset (struct value
*value
)
217 return value
->embedded_offset
;
221 set_value_embedded_offset (struct value
*value
, int val
)
223 value
->embedded_offset
= val
;
226 /* Return a mark in the value chain. All values allocated after the
227 mark is obtained (except for those released) are subject to being freed
228 if a subsequent value_free_to_mark is passed the mark. */
235 /* Free all values allocated since MARK was obtained by value_mark
236 (except for those released). */
238 value_free_to_mark (struct value
*mark
)
243 for (val
= all_values
; val
&& val
!= mark
; val
= next
)
251 /* Free all the values that have been allocated (except for those released).
252 Called after each command, successful or not. */
255 free_all_values (void)
260 for (val
= all_values
; val
; val
= next
)
269 /* Remove VAL from the chain all_values
270 so it will not be freed automatically. */
273 release_value (struct value
*val
)
277 if (all_values
== val
)
279 all_values
= val
->next
;
283 for (v
= all_values
; v
; v
= v
->next
)
293 /* Release all values up to mark */
295 value_release_to_mark (struct value
*mark
)
300 for (val
= next
= all_values
; next
; next
= next
->next
)
301 if (next
->next
== mark
)
303 all_values
= next
->next
;
311 /* Return a copy of the value ARG.
312 It contains the same contents, for same memory address,
313 but it's a different block of storage. */
316 value_copy (struct value
*arg
)
318 struct type
*encl_type
= value_enclosing_type (arg
);
319 struct value
*val
= allocate_value (encl_type
);
320 val
->type
= arg
->type
;
321 VALUE_LVAL (val
) = VALUE_LVAL (arg
);
322 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg
);
323 val
->offset
= arg
->offset
;
324 val
->bitpos
= arg
->bitpos
;
325 val
->bitsize
= arg
->bitsize
;
326 VALUE_FRAME_ID (val
) = VALUE_FRAME_ID (arg
);
327 VALUE_REGNUM (val
) = VALUE_REGNUM (arg
);
328 val
->lazy
= arg
->lazy
;
329 val
->optimized_out
= arg
->optimized_out
;
330 val
->embedded_offset
= value_embedded_offset (arg
);
331 VALUE_POINTED_TO_OFFSET (val
) = VALUE_POINTED_TO_OFFSET (arg
);
332 val
->modifiable
= arg
->modifiable
;
333 if (!value_lazy (val
))
335 memcpy (value_contents_all_raw (val
), value_contents_all_raw (arg
),
336 TYPE_LENGTH (value_enclosing_type (arg
)));
342 /* Access to the value history. */
344 /* Record a new value in the value history.
345 Returns the absolute history index of the entry.
346 Result of -1 indicates the value was not saved; otherwise it is the
347 value history index of this new item. */
350 record_latest_value (struct value
*val
)
354 /* We don't want this value to have anything to do with the inferior anymore.
355 In particular, "set $1 = 50" should not affect the variable from which
356 the value was taken, and fast watchpoints should be able to assume that
357 a value on the value history never changes. */
358 if (value_lazy (val
))
359 value_fetch_lazy (val
);
360 /* We preserve VALUE_LVAL so that the user can find out where it was fetched
361 from. This is a bit dubious, because then *&$1 does not just return $1
362 but the current contents of that location. c'est la vie... */
366 /* Here we treat value_history_count as origin-zero
367 and applying to the value being stored now. */
369 i
= value_history_count
% VALUE_HISTORY_CHUNK
;
372 struct value_history_chunk
*new
373 = (struct value_history_chunk
*)
374 xmalloc (sizeof (struct value_history_chunk
));
375 memset (new->values
, 0, sizeof new->values
);
376 new->next
= value_history_chain
;
377 value_history_chain
= new;
380 value_history_chain
->values
[i
] = val
;
382 /* Now we regard value_history_count as origin-one
383 and applying to the value just stored. */
385 return ++value_history_count
;
388 /* Return a copy of the value in the history with sequence number NUM. */
391 access_value_history (int num
)
393 struct value_history_chunk
*chunk
;
398 absnum
+= value_history_count
;
403 error ("The history is empty.");
405 error ("There is only one value in the history.");
407 error ("History does not go back to $$%d.", -num
);
409 if (absnum
> value_history_count
)
410 error ("History has not yet reached $%d.", absnum
);
414 /* Now absnum is always absolute and origin zero. */
416 chunk
= value_history_chain
;
417 for (i
= (value_history_count
- 1) / VALUE_HISTORY_CHUNK
- absnum
/ VALUE_HISTORY_CHUNK
;
421 return value_copy (chunk
->values
[absnum
% VALUE_HISTORY_CHUNK
]);
424 /* Clear the value history entirely.
425 Must be done when new symbol tables are loaded,
426 because the type pointers become invalid. */
429 clear_value_history (void)
431 struct value_history_chunk
*next
;
435 while (value_history_chain
)
437 for (i
= 0; i
< VALUE_HISTORY_CHUNK
; i
++)
438 if ((val
= value_history_chain
->values
[i
]) != NULL
)
440 next
= value_history_chain
->next
;
441 xfree (value_history_chain
);
442 value_history_chain
= next
;
444 value_history_count
= 0;
448 show_values (char *num_exp
, int from_tty
)
456 /* "info history +" should print from the stored position.
457 "info history <exp>" should print around value number <exp>. */
458 if (num_exp
[0] != '+' || num_exp
[1] != '\0')
459 num
= parse_and_eval_long (num_exp
) - 5;
463 /* "info history" means print the last 10 values. */
464 num
= value_history_count
- 9;
470 for (i
= num
; i
< num
+ 10 && i
<= value_history_count
; i
++)
472 val
= access_value_history (i
);
473 printf_filtered ("$%d = ", i
);
474 value_print (val
, gdb_stdout
, 0, Val_pretty_default
);
475 printf_filtered ("\n");
478 /* The next "info history +" should start after what we just printed. */
481 /* Hitting just return after this command should do the same thing as
482 "info history +". If num_exp is null, this is unnecessary, since
483 "info history +" is not useful after "info history". */
484 if (from_tty
&& num_exp
)
491 /* Internal variables. These are variables within the debugger
492 that hold values assigned by debugger commands.
493 The user refers to them with a '$' prefix
494 that does not appear in the variable names stored internally. */
496 static struct internalvar
*internalvars
;
498 /* Look up an internal variable with name NAME. NAME should not
499 normally include a dollar sign.
501 If the specified internal variable does not exist,
502 one is created, with a void value. */
505 lookup_internalvar (char *name
)
507 struct internalvar
*var
;
509 for (var
= internalvars
; var
; var
= var
->next
)
510 if (strcmp (var
->name
, name
) == 0)
513 var
= (struct internalvar
*) xmalloc (sizeof (struct internalvar
));
514 var
->name
= concat (name
, NULL
);
515 var
->value
= allocate_value (builtin_type_void
);
516 release_value (var
->value
);
517 var
->next
= internalvars
;
523 value_of_internalvar (struct internalvar
*var
)
527 val
= value_copy (var
->value
);
528 if (value_lazy (val
))
529 value_fetch_lazy (val
);
530 VALUE_LVAL (val
) = lval_internalvar
;
531 VALUE_INTERNALVAR (val
) = var
;
536 set_internalvar_component (struct internalvar
*var
, int offset
, int bitpos
,
537 int bitsize
, struct value
*newval
)
539 bfd_byte
*addr
= value_contents_writeable (var
->value
) + offset
;
542 modify_field (addr
, value_as_long (newval
),
545 memcpy (addr
, value_contents (newval
), TYPE_LENGTH (value_type (newval
)));
549 set_internalvar (struct internalvar
*var
, struct value
*val
)
551 struct value
*newval
;
553 newval
= value_copy (val
);
554 newval
->modifiable
= 1;
556 /* Force the value to be fetched from the target now, to avoid problems
557 later when this internalvar is referenced and the target is gone or
559 if (value_lazy (newval
))
560 value_fetch_lazy (newval
);
562 /* Begin code which must not call error(). If var->value points to
563 something free'd, an error() obviously leaves a dangling pointer.
564 But we also get a danling pointer if var->value points to
565 something in the value chain (i.e., before release_value is
566 called), because after the error free_all_values will get called before
570 release_value (newval
);
571 /* End code which must not call error(). */
575 internalvar_name (struct internalvar
*var
)
580 /* Free all internalvars. Done when new symtabs are loaded,
581 because that makes the values invalid. */
584 clear_internalvars (void)
586 struct internalvar
*var
;
591 internalvars
= var
->next
;
599 show_convenience (char *ignore
, int from_tty
)
601 struct internalvar
*var
;
604 for (var
= internalvars
; var
; var
= var
->next
)
610 printf_filtered ("$%s = ", var
->name
);
611 value_print (var
->value
, gdb_stdout
, 0, Val_pretty_default
);
612 printf_filtered ("\n");
615 printf_unfiltered ("No debugger convenience variables now defined.\n\
616 Convenience variables have names starting with \"$\";\n\
617 use \"set\" as in \"set $foo = 5\" to define them.\n");
620 /* Extract a value as a C number (either long or double).
621 Knows how to convert fixed values to double, or
622 floating values to long.
623 Does not deallocate the value. */
626 value_as_long (struct value
*val
)
628 /* This coerces arrays and functions, which is necessary (e.g.
629 in disassemble_command). It also dereferences references, which
630 I suspect is the most logical thing to do. */
631 val
= coerce_array (val
);
632 return unpack_long (value_type (val
), value_contents (val
));
636 value_as_double (struct value
*val
)
641 foo
= unpack_double (value_type (val
), value_contents (val
), &inv
);
643 error ("Invalid floating value found in program.");
646 /* Extract a value as a C pointer. Does not deallocate the value.
647 Note that val's type may not actually be a pointer; value_as_long
648 handles all the cases. */
650 value_as_address (struct value
*val
)
652 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
653 whether we want this to be true eventually. */
655 /* ADDR_BITS_REMOVE is wrong if we are being called for a
656 non-address (e.g. argument to "signal", "info break", etc.), or
657 for pointers to char, in which the low bits *are* significant. */
658 return ADDR_BITS_REMOVE (value_as_long (val
));
661 /* There are several targets (IA-64, PowerPC, and others) which
662 don't represent pointers to functions as simply the address of
663 the function's entry point. For example, on the IA-64, a
664 function pointer points to a two-word descriptor, generated by
665 the linker, which contains the function's entry point, and the
666 value the IA-64 "global pointer" register should have --- to
667 support position-independent code. The linker generates
668 descriptors only for those functions whose addresses are taken.
670 On such targets, it's difficult for GDB to convert an arbitrary
671 function address into a function pointer; it has to either find
672 an existing descriptor for that function, or call malloc and
673 build its own. On some targets, it is impossible for GDB to
674 build a descriptor at all: the descriptor must contain a jump
675 instruction; data memory cannot be executed; and code memory
678 Upon entry to this function, if VAL is a value of type `function'
679 (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
680 VALUE_ADDRESS (val) is the address of the function. This is what
681 you'll get if you evaluate an expression like `main'. The call
682 to COERCE_ARRAY below actually does all the usual unary
683 conversions, which includes converting values of type `function'
684 to `pointer to function'. This is the challenging conversion
685 discussed above. Then, `unpack_long' will convert that pointer
686 back into an address.
688 So, suppose the user types `disassemble foo' on an architecture
689 with a strange function pointer representation, on which GDB
690 cannot build its own descriptors, and suppose further that `foo'
691 has no linker-built descriptor. The address->pointer conversion
692 will signal an error and prevent the command from running, even
693 though the next step would have been to convert the pointer
694 directly back into the same address.
696 The following shortcut avoids this whole mess. If VAL is a
697 function, just return its address directly. */
698 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_FUNC
699 || TYPE_CODE (value_type (val
)) == TYPE_CODE_METHOD
)
700 return VALUE_ADDRESS (val
);
702 val
= coerce_array (val
);
704 /* Some architectures (e.g. Harvard), map instruction and data
705 addresses onto a single large unified address space. For
706 instance: An architecture may consider a large integer in the
707 range 0x10000000 .. 0x1000ffff to already represent a data
708 addresses (hence not need a pointer to address conversion) while
709 a small integer would still need to be converted integer to
710 pointer to address. Just assume such architectures handle all
711 integer conversions in a single function. */
715 I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we
716 must admonish GDB hackers to make sure its behavior matches the
717 compiler's, whenever possible.
719 In general, I think GDB should evaluate expressions the same way
720 the compiler does. When the user copies an expression out of
721 their source code and hands it to a `print' command, they should
722 get the same value the compiler would have computed. Any
723 deviation from this rule can cause major confusion and annoyance,
724 and needs to be justified carefully. In other words, GDB doesn't
725 really have the freedom to do these conversions in clever and
728 AndrewC pointed out that users aren't complaining about how GDB
729 casts integers to pointers; they are complaining that they can't
730 take an address from a disassembly listing and give it to `x/i'.
731 This is certainly important.
733 Adding an architecture method like integer_to_address() certainly
734 makes it possible for GDB to "get it right" in all circumstances
735 --- the target has complete control over how things get done, so
736 people can Do The Right Thing for their target without breaking
737 anyone else. The standard doesn't specify how integers get
738 converted to pointers; usually, the ABI doesn't either, but
739 ABI-specific code is a more reasonable place to handle it. */
741 if (TYPE_CODE (value_type (val
)) != TYPE_CODE_PTR
742 && TYPE_CODE (value_type (val
)) != TYPE_CODE_REF
743 && gdbarch_integer_to_address_p (current_gdbarch
))
744 return gdbarch_integer_to_address (current_gdbarch
, value_type (val
),
745 value_contents (val
));
747 return unpack_long (value_type (val
), value_contents (val
));
751 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
752 as a long, or as a double, assuming the raw data is described
753 by type TYPE. Knows how to convert different sizes of values
754 and can convert between fixed and floating point. We don't assume
755 any alignment for the raw data. Return value is in host byte order.
757 If you want functions and arrays to be coerced to pointers, and
758 references to be dereferenced, call value_as_long() instead.
760 C++: It is assumed that the front-end has taken care of
761 all matters concerning pointers to members. A pointer
762 to member which reaches here is considered to be equivalent
763 to an INT (or some size). After all, it is only an offset. */
766 unpack_long (struct type
*type
, const char *valaddr
)
768 enum type_code code
= TYPE_CODE (type
);
769 int len
= TYPE_LENGTH (type
);
770 int nosign
= TYPE_UNSIGNED (type
);
772 if (current_language
->la_language
== language_scm
773 && is_scmvalue_type (type
))
774 return scm_unpack (type
, valaddr
, TYPE_CODE_INT
);
778 case TYPE_CODE_TYPEDEF
:
779 return unpack_long (check_typedef (type
), valaddr
);
784 case TYPE_CODE_RANGE
:
786 return extract_unsigned_integer (valaddr
, len
);
788 return extract_signed_integer (valaddr
, len
);
791 return extract_typed_floating (valaddr
, type
);
795 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
796 whether we want this to be true eventually. */
797 return extract_typed_address (valaddr
, type
);
799 case TYPE_CODE_MEMBER
:
800 error ("not implemented: member types in unpack_long");
803 error ("Value can't be converted to integer.");
805 return 0; /* Placate lint. */
808 /* Return a double value from the specified type and address.
809 INVP points to an int which is set to 0 for valid value,
810 1 for invalid value (bad float format). In either case,
811 the returned double is OK to use. Argument is in target
812 format, result is in host format. */
815 unpack_double (struct type
*type
, const char *valaddr
, int *invp
)
821 *invp
= 0; /* Assume valid. */
822 CHECK_TYPEDEF (type
);
823 code
= TYPE_CODE (type
);
824 len
= TYPE_LENGTH (type
);
825 nosign
= TYPE_UNSIGNED (type
);
826 if (code
== TYPE_CODE_FLT
)
828 /* NOTE: cagney/2002-02-19: There was a test here to see if the
829 floating-point value was valid (using the macro
830 INVALID_FLOAT). That test/macro have been removed.
832 It turns out that only the VAX defined this macro and then
833 only in a non-portable way. Fixing the portability problem
834 wouldn't help since the VAX floating-point code is also badly
835 bit-rotten. The target needs to add definitions for the
836 methods TARGET_FLOAT_FORMAT and TARGET_DOUBLE_FORMAT - these
837 exactly describe the target floating-point format. The
838 problem here is that the corresponding floatformat_vax_f and
839 floatformat_vax_d values these methods should be set to are
840 also not defined either. Oops!
842 Hopefully someone will add both the missing floatformat
843 definitions and the new cases for floatformat_is_valid (). */
845 if (!floatformat_is_valid (floatformat_from_type (type
), valaddr
))
851 return extract_typed_floating (valaddr
, type
);
855 /* Unsigned -- be sure we compensate for signed LONGEST. */
856 return (ULONGEST
) unpack_long (type
, valaddr
);
860 /* Signed -- we are OK with unpack_long. */
861 return unpack_long (type
, valaddr
);
865 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
866 as a CORE_ADDR, assuming the raw data is described by type TYPE.
867 We don't assume any alignment for the raw data. Return value is in
870 If you want functions and arrays to be coerced to pointers, and
871 references to be dereferenced, call value_as_address() instead.
873 C++: It is assumed that the front-end has taken care of
874 all matters concerning pointers to members. A pointer
875 to member which reaches here is considered to be equivalent
876 to an INT (or some size). After all, it is only an offset. */
879 unpack_pointer (struct type
*type
, const char *valaddr
)
881 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
882 whether we want this to be true eventually. */
883 return unpack_long (type
, valaddr
);
887 /* Get the value of the FIELDN'th field (which must be static) of
888 TYPE. Return NULL if the field doesn't exist or has been
892 value_static_field (struct type
*type
, int fieldno
)
894 struct value
*retval
;
896 if (TYPE_FIELD_STATIC_HAS_ADDR (type
, fieldno
))
898 retval
= value_at (TYPE_FIELD_TYPE (type
, fieldno
),
899 TYPE_FIELD_STATIC_PHYSADDR (type
, fieldno
));
903 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
904 struct symbol
*sym
= lookup_symbol (phys_name
, 0, VAR_DOMAIN
, 0, NULL
);
907 /* With some compilers, e.g. HP aCC, static data members are reported
908 as non-debuggable symbols */
909 struct minimal_symbol
*msym
= lookup_minimal_symbol (phys_name
, NULL
, NULL
);
914 retval
= value_at (TYPE_FIELD_TYPE (type
, fieldno
),
915 SYMBOL_VALUE_ADDRESS (msym
));
920 /* SYM should never have a SYMBOL_CLASS which will require
921 read_var_value to use the FRAME parameter. */
922 if (symbol_read_needs_frame (sym
))
923 warning ("static field's value depends on the current "
924 "frame - bad debug info?");
925 retval
= read_var_value (sym
, NULL
);
927 if (retval
&& VALUE_LVAL (retval
) == lval_memory
)
928 SET_FIELD_PHYSADDR (TYPE_FIELD (type
, fieldno
),
929 VALUE_ADDRESS (retval
));
934 /* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.
935 You have to be careful here, since the size of the data area for the value
936 is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger
937 than the old enclosing type, you have to allocate more space for the data.
938 The return value is a pointer to the new version of this value structure. */
941 value_change_enclosing_type (struct value
*val
, struct type
*new_encl_type
)
943 if (TYPE_LENGTH (new_encl_type
) <= TYPE_LENGTH (value_enclosing_type (val
)))
945 val
->enclosing_type
= new_encl_type
;
950 struct value
*new_val
;
953 new_val
= (struct value
*) xrealloc (val
, sizeof (struct value
) + TYPE_LENGTH (new_encl_type
));
955 new_val
->enclosing_type
= new_encl_type
;
957 /* We have to make sure this ends up in the same place in the value
958 chain as the original copy, so it's clean-up behavior is the same.
959 If the value has been released, this is a waste of time, but there
960 is no way to tell that in advance, so... */
962 if (val
!= all_values
)
964 for (prev
= all_values
; prev
!= NULL
; prev
= prev
->next
)
966 if (prev
->next
== val
)
968 prev
->next
= new_val
;
978 /* Given a value ARG1 (offset by OFFSET bytes)
979 of a struct or union type ARG_TYPE,
980 extract and return the value of one of its (non-static) fields.
981 FIELDNO says which field. */
984 value_primitive_field (struct value
*arg1
, int offset
,
985 int fieldno
, struct type
*arg_type
)
990 CHECK_TYPEDEF (arg_type
);
991 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
993 /* Handle packed fields */
995 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
997 v
= value_from_longest (type
,
998 unpack_field_as_long (arg_type
,
999 value_contents (arg1
)
1002 v
->bitpos
= TYPE_FIELD_BITPOS (arg_type
, fieldno
) % 8;
1003 v
->bitsize
= TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
1004 v
->offset
= value_offset (arg1
) + offset
1005 + TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
1007 else if (fieldno
< TYPE_N_BASECLASSES (arg_type
))
1009 /* This field is actually a base subobject, so preserve the
1010 entire object's contents for later references to virtual
1012 v
= allocate_value (value_enclosing_type (arg1
));
1014 if (value_lazy (arg1
))
1015 set_value_lazy (v
, 1);
1017 memcpy (value_contents_all_raw (v
), value_contents_all_raw (arg1
),
1018 TYPE_LENGTH (value_enclosing_type (arg1
)));
1019 v
->offset
= value_offset (arg1
);
1020 v
->embedded_offset
= (offset
+ value_embedded_offset (arg1
)
1021 + TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8);
1025 /* Plain old data member */
1026 offset
+= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
1027 v
= allocate_value (type
);
1028 if (value_lazy (arg1
))
1029 set_value_lazy (v
, 1);
1031 memcpy (value_contents_raw (v
),
1032 value_contents_raw (arg1
) + offset
,
1033 TYPE_LENGTH (type
));
1034 v
->offset
= (value_offset (arg1
) + offset
1035 + value_embedded_offset (arg1
));
1037 VALUE_LVAL (v
) = VALUE_LVAL (arg1
);
1038 if (VALUE_LVAL (arg1
) == lval_internalvar
)
1039 VALUE_LVAL (v
) = lval_internalvar_component
;
1040 VALUE_ADDRESS (v
) = VALUE_ADDRESS (arg1
);
1041 VALUE_REGNUM (v
) = VALUE_REGNUM (arg1
);
1042 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (arg1
);
1043 /* VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
1044 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; */
1048 /* Given a value ARG1 of a struct or union type,
1049 extract and return the value of one of its (non-static) fields.
1050 FIELDNO says which field. */
1053 value_field (struct value
*arg1
, int fieldno
)
1055 return value_primitive_field (arg1
, 0, fieldno
, value_type (arg1
));
1058 /* Return a non-virtual function as a value.
1059 F is the list of member functions which contains the desired method.
1060 J is an index into F which provides the desired method.
1062 We only use the symbol for its address, so be happy with either a
1063 full symbol or a minimal symbol.
1067 value_fn_field (struct value
**arg1p
, struct fn_field
*f
, int j
, struct type
*type
,
1071 struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
1072 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1074 struct minimal_symbol
*msym
;
1076 sym
= lookup_symbol (physname
, 0, VAR_DOMAIN
, 0, NULL
);
1083 gdb_assert (sym
== NULL
);
1084 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
1089 v
= allocate_value (ftype
);
1092 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1096 VALUE_ADDRESS (v
) = SYMBOL_VALUE_ADDRESS (msym
);
1101 if (type
!= value_type (*arg1p
))
1102 *arg1p
= value_ind (value_cast (lookup_pointer_type (type
),
1103 value_addr (*arg1p
)));
1105 /* Move the `this' pointer according to the offset.
1106 VALUE_OFFSET (*arg1p) += offset;
1114 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1117 Extracting bits depends on endianness of the machine. Compute the
1118 number of least significant bits to discard. For big endian machines,
1119 we compute the total number of bits in the anonymous object, subtract
1120 off the bit count from the MSB of the object to the MSB of the
1121 bitfield, then the size of the bitfield, which leaves the LSB discard
1122 count. For little endian machines, the discard count is simply the
1123 number of bits from the LSB of the anonymous object to the LSB of the
1126 If the field is signed, we also do sign extension. */
1129 unpack_field_as_long (struct type
*type
, const char *valaddr
, int fieldno
)
1133 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
1134 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
1136 struct type
*field_type
;
1138 val
= extract_unsigned_integer (valaddr
+ bitpos
/ 8, sizeof (val
));
1139 field_type
= TYPE_FIELD_TYPE (type
, fieldno
);
1140 CHECK_TYPEDEF (field_type
);
1142 /* Extract bits. See comment above. */
1144 if (BITS_BIG_ENDIAN
)
1145 lsbcount
= (sizeof val
* 8 - bitpos
% 8 - bitsize
);
1147 lsbcount
= (bitpos
% 8);
1150 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1151 If the field is signed, and is negative, then sign extend. */
1153 if ((bitsize
> 0) && (bitsize
< 8 * (int) sizeof (val
)))
1155 valmask
= (((ULONGEST
) 1) << bitsize
) - 1;
1157 if (!TYPE_UNSIGNED (field_type
))
1159 if (val
& (valmask
^ (valmask
>> 1)))
1168 /* Modify the value of a bitfield. ADDR points to a block of memory in
1169 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1170 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1171 indicate which bits (in target bit order) comprise the bitfield.
1172 Requires 0 < BITSIZE <= lbits, 0 <= BITPOS+BITSIZE <= lbits, and
1173 0 <= BITPOS, where lbits is the size of a LONGEST in bits. */
1176 modify_field (char *addr
, LONGEST fieldval
, int bitpos
, int bitsize
)
1179 ULONGEST mask
= (ULONGEST
) -1 >> (8 * sizeof (ULONGEST
) - bitsize
);
1181 /* If a negative fieldval fits in the field in question, chop
1182 off the sign extension bits. */
1183 if ((~fieldval
& ~(mask
>> 1)) == 0)
1186 /* Warn if value is too big to fit in the field in question. */
1187 if (0 != (fieldval
& ~mask
))
1189 /* FIXME: would like to include fieldval in the message, but
1190 we don't have a sprintf_longest. */
1191 warning ("Value does not fit in %d bits.", bitsize
);
1193 /* Truncate it, otherwise adjoining fields may be corrupted. */
1197 oword
= extract_unsigned_integer (addr
, sizeof oword
);
1199 /* Shifting for bit field depends on endianness of the target machine. */
1200 if (BITS_BIG_ENDIAN
)
1201 bitpos
= sizeof (oword
) * 8 - bitpos
- bitsize
;
1203 oword
&= ~(mask
<< bitpos
);
1204 oword
|= fieldval
<< bitpos
;
1206 store_unsigned_integer (addr
, sizeof oword
, oword
);
1209 /* Convert C numbers into newly allocated values */
1212 value_from_longest (struct type
*type
, LONGEST num
)
1214 struct value
*val
= allocate_value (type
);
1215 enum type_code code
;
1218 code
= TYPE_CODE (type
);
1219 len
= TYPE_LENGTH (type
);
1223 case TYPE_CODE_TYPEDEF
:
1224 type
= check_typedef (type
);
1227 case TYPE_CODE_CHAR
:
1228 case TYPE_CODE_ENUM
:
1229 case TYPE_CODE_BOOL
:
1230 case TYPE_CODE_RANGE
:
1231 store_signed_integer (value_contents_raw (val
), len
, num
);
1236 store_typed_address (value_contents_raw (val
), type
, (CORE_ADDR
) num
);
1240 error ("Unexpected type (%d) encountered for integer constant.", code
);
1246 /* Create a value representing a pointer of type TYPE to the address
1249 value_from_pointer (struct type
*type
, CORE_ADDR addr
)
1251 struct value
*val
= allocate_value (type
);
1252 store_typed_address (value_contents_raw (val
), type
, addr
);
1257 /* Create a value for a string constant to be stored locally
1258 (not in the inferior's memory space, but in GDB memory).
1259 This is analogous to value_from_longest, which also does not
1260 use inferior memory. String shall NOT contain embedded nulls. */
1263 value_from_string (char *ptr
)
1266 int len
= strlen (ptr
);
1267 int lowbound
= current_language
->string_lower_bound
;
1268 struct type
*string_char_type
;
1269 struct type
*rangetype
;
1270 struct type
*stringtype
;
1272 rangetype
= create_range_type ((struct type
*) NULL
,
1274 lowbound
, len
+ lowbound
- 1);
1275 string_char_type
= language_string_char_type (current_language
,
1277 stringtype
= create_array_type ((struct type
*) NULL
,
1280 val
= allocate_value (stringtype
);
1281 memcpy (value_contents_raw (val
), ptr
, len
);
1286 value_from_double (struct type
*type
, DOUBLEST num
)
1288 struct value
*val
= allocate_value (type
);
1289 struct type
*base_type
= check_typedef (type
);
1290 enum type_code code
= TYPE_CODE (base_type
);
1291 int len
= TYPE_LENGTH (base_type
);
1293 if (code
== TYPE_CODE_FLT
)
1295 store_typed_floating (value_contents_raw (val
), base_type
, num
);
1298 error ("Unexpected type encountered for floating constant.");
1304 coerce_ref (struct value
*arg
)
1306 struct type
*value_type_arg_tmp
= check_typedef (value_type (arg
));
1307 if (TYPE_CODE (value_type_arg_tmp
) == TYPE_CODE_REF
)
1308 arg
= value_at_lazy (TYPE_TARGET_TYPE (value_type_arg_tmp
),
1309 unpack_pointer (value_type (arg
),
1310 value_contents (arg
)));
1315 coerce_array (struct value
*arg
)
1317 arg
= coerce_ref (arg
);
1318 if (current_language
->c_style_arrays
1319 && TYPE_CODE (value_type (arg
)) == TYPE_CODE_ARRAY
)
1320 arg
= value_coerce_array (arg
);
1321 if (TYPE_CODE (value_type (arg
)) == TYPE_CODE_FUNC
)
1322 arg
= value_coerce_function (arg
);
1327 coerce_number (struct value
*arg
)
1329 arg
= coerce_array (arg
);
1330 arg
= coerce_enum (arg
);
1335 coerce_enum (struct value
*arg
)
1337 if (TYPE_CODE (check_typedef (value_type (arg
))) == TYPE_CODE_ENUM
)
1338 arg
= value_cast (builtin_type_unsigned_int
, arg
);
1343 /* Should we use DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS instead of
1344 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc and TYPE
1345 is the type (which is known to be struct, union or array).
1347 On most machines, the struct convention is used unless we are
1348 using gcc and the type is of a special size. */
1349 /* As of about 31 Mar 93, GCC was changed to be compatible with the
1350 native compiler. GCC 2.3.3 was the last release that did it the
1351 old way. Since gcc2_compiled was not changed, we have no
1352 way to correctly win in all cases, so we just do the right thing
1353 for gcc1 and for gcc2 after this change. Thus it loses for gcc
1354 2.0-2.3.3. This is somewhat unfortunate, but changing gcc2_compiled
1355 would cause more chaos than dealing with some struct returns being
1357 /* NOTE: cagney/2004-06-13: Deleted check for "gcc_p". GCC 1.x is
1361 generic_use_struct_convention (int gcc_p
, struct type
*value_type
)
1363 return !(TYPE_LENGTH (value_type
) == 1
1364 || TYPE_LENGTH (value_type
) == 2
1365 || TYPE_LENGTH (value_type
) == 4
1366 || TYPE_LENGTH (value_type
) == 8);
1369 /* Return true if the function returning the specified type is using
1370 the convention of returning structures in memory (passing in the
1371 address as a hidden first parameter). GCC_P is nonzero if compiled
1375 using_struct_return (struct type
*value_type
, int gcc_p
)
1377 enum type_code code
= TYPE_CODE (value_type
);
1379 if (code
== TYPE_CODE_ERROR
)
1380 error ("Function return type unknown.");
1382 if (code
== TYPE_CODE_VOID
)
1383 /* A void return value is never in memory. See also corresponding
1384 code in "print_return_value". */
1387 /* Probe the architecture for the return-value convention. */
1388 return (gdbarch_return_value (current_gdbarch
, value_type
,
1390 != RETURN_VALUE_REGISTER_CONVENTION
);
1394 _initialize_values (void)
1396 add_cmd ("convenience", no_class
, show_convenience
,
1397 "Debugger convenience (\"$foo\") variables.\n\
1398 These variables are created when you assign them values;\n\
1399 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\
1400 A few convenience variables are given values automatically:\n\
1401 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1402 \"$__\" holds the contents of the last address examined with \"x\".",
1405 add_cmd ("values", no_class
, show_values
,
1406 "Elements of value history around item number IDX (or last ten).",