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 VALUE_OPTIMIZED_OUT (val
) = 0;
100 VALUE_EMBEDDED_OFFSET (val
) = 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 value_contents (struct value
*value
)
185 return value_contents_writeable (value
);
189 value_contents_writeable (struct value
*value
)
192 value_fetch_lazy (value
);
193 return value
->aligner
.contents
;
197 /* Return a mark in the value chain. All values allocated after the
198 mark is obtained (except for those released) are subject to being freed
199 if a subsequent value_free_to_mark is passed the mark. */
206 /* Free all values allocated since MARK was obtained by value_mark
207 (except for those released). */
209 value_free_to_mark (struct value
*mark
)
214 for (val
= all_values
; val
&& val
!= mark
; val
= next
)
222 /* Free all the values that have been allocated (except for those released).
223 Called after each command, successful or not. */
226 free_all_values (void)
231 for (val
= all_values
; val
; val
= next
)
240 /* Remove VAL from the chain all_values
241 so it will not be freed automatically. */
244 release_value (struct value
*val
)
248 if (all_values
== val
)
250 all_values
= val
->next
;
254 for (v
= all_values
; v
; v
= v
->next
)
264 /* Release all values up to mark */
266 value_release_to_mark (struct value
*mark
)
271 for (val
= next
= all_values
; next
; next
= next
->next
)
272 if (next
->next
== mark
)
274 all_values
= next
->next
;
282 /* Return a copy of the value ARG.
283 It contains the same contents, for same memory address,
284 but it's a different block of storage. */
287 value_copy (struct value
*arg
)
289 struct type
*encl_type
= value_enclosing_type (arg
);
290 struct value
*val
= allocate_value (encl_type
);
291 val
->type
= arg
->type
;
292 VALUE_LVAL (val
) = VALUE_LVAL (arg
);
293 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg
);
294 val
->offset
= arg
->offset
;
295 val
->bitpos
= arg
->bitpos
;
296 val
->bitsize
= arg
->bitsize
;
297 VALUE_FRAME_ID (val
) = VALUE_FRAME_ID (arg
);
298 VALUE_REGNUM (val
) = VALUE_REGNUM (arg
);
299 val
->lazy
= arg
->lazy
;
300 VALUE_OPTIMIZED_OUT (val
) = VALUE_OPTIMIZED_OUT (arg
);
301 VALUE_EMBEDDED_OFFSET (val
) = VALUE_EMBEDDED_OFFSET (arg
);
302 VALUE_POINTED_TO_OFFSET (val
) = VALUE_POINTED_TO_OFFSET (arg
);
303 val
->modifiable
= arg
->modifiable
;
304 if (!value_lazy (val
))
306 memcpy (value_contents_all_raw (val
), value_contents_all_raw (arg
),
307 TYPE_LENGTH (value_enclosing_type (arg
)));
313 /* Access to the value history. */
315 /* Record a new value in the value history.
316 Returns the absolute history index of the entry.
317 Result of -1 indicates the value was not saved; otherwise it is the
318 value history index of this new item. */
321 record_latest_value (struct value
*val
)
325 /* We don't want this value to have anything to do with the inferior anymore.
326 In particular, "set $1 = 50" should not affect the variable from which
327 the value was taken, and fast watchpoints should be able to assume that
328 a value on the value history never changes. */
329 if (value_lazy (val
))
330 value_fetch_lazy (val
);
331 /* We preserve VALUE_LVAL so that the user can find out where it was fetched
332 from. This is a bit dubious, because then *&$1 does not just return $1
333 but the current contents of that location. c'est la vie... */
337 /* Here we treat value_history_count as origin-zero
338 and applying to the value being stored now. */
340 i
= value_history_count
% VALUE_HISTORY_CHUNK
;
343 struct value_history_chunk
*new
344 = (struct value_history_chunk
*)
345 xmalloc (sizeof (struct value_history_chunk
));
346 memset (new->values
, 0, sizeof new->values
);
347 new->next
= value_history_chain
;
348 value_history_chain
= new;
351 value_history_chain
->values
[i
] = val
;
353 /* Now we regard value_history_count as origin-one
354 and applying to the value just stored. */
356 return ++value_history_count
;
359 /* Return a copy of the value in the history with sequence number NUM. */
362 access_value_history (int num
)
364 struct value_history_chunk
*chunk
;
369 absnum
+= value_history_count
;
374 error ("The history is empty.");
376 error ("There is only one value in the history.");
378 error ("History does not go back to $$%d.", -num
);
380 if (absnum
> value_history_count
)
381 error ("History has not yet reached $%d.", absnum
);
385 /* Now absnum is always absolute and origin zero. */
387 chunk
= value_history_chain
;
388 for (i
= (value_history_count
- 1) / VALUE_HISTORY_CHUNK
- absnum
/ VALUE_HISTORY_CHUNK
;
392 return value_copy (chunk
->values
[absnum
% VALUE_HISTORY_CHUNK
]);
395 /* Clear the value history entirely.
396 Must be done when new symbol tables are loaded,
397 because the type pointers become invalid. */
400 clear_value_history (void)
402 struct value_history_chunk
*next
;
406 while (value_history_chain
)
408 for (i
= 0; i
< VALUE_HISTORY_CHUNK
; i
++)
409 if ((val
= value_history_chain
->values
[i
]) != NULL
)
411 next
= value_history_chain
->next
;
412 xfree (value_history_chain
);
413 value_history_chain
= next
;
415 value_history_count
= 0;
419 show_values (char *num_exp
, int from_tty
)
427 /* "info history +" should print from the stored position.
428 "info history <exp>" should print around value number <exp>. */
429 if (num_exp
[0] != '+' || num_exp
[1] != '\0')
430 num
= parse_and_eval_long (num_exp
) - 5;
434 /* "info history" means print the last 10 values. */
435 num
= value_history_count
- 9;
441 for (i
= num
; i
< num
+ 10 && i
<= value_history_count
; i
++)
443 val
= access_value_history (i
);
444 printf_filtered ("$%d = ", i
);
445 value_print (val
, gdb_stdout
, 0, Val_pretty_default
);
446 printf_filtered ("\n");
449 /* The next "info history +" should start after what we just printed. */
452 /* Hitting just return after this command should do the same thing as
453 "info history +". If num_exp is null, this is unnecessary, since
454 "info history +" is not useful after "info history". */
455 if (from_tty
&& num_exp
)
462 /* Internal variables. These are variables within the debugger
463 that hold values assigned by debugger commands.
464 The user refers to them with a '$' prefix
465 that does not appear in the variable names stored internally. */
467 static struct internalvar
*internalvars
;
469 /* Look up an internal variable with name NAME. NAME should not
470 normally include a dollar sign.
472 If the specified internal variable does not exist,
473 one is created, with a void value. */
476 lookup_internalvar (char *name
)
478 struct internalvar
*var
;
480 for (var
= internalvars
; var
; var
= var
->next
)
481 if (strcmp (var
->name
, name
) == 0)
484 var
= (struct internalvar
*) xmalloc (sizeof (struct internalvar
));
485 var
->name
= concat (name
, NULL
);
486 var
->value
= allocate_value (builtin_type_void
);
487 release_value (var
->value
);
488 var
->next
= internalvars
;
494 value_of_internalvar (struct internalvar
*var
)
498 val
= value_copy (var
->value
);
499 if (value_lazy (val
))
500 value_fetch_lazy (val
);
501 VALUE_LVAL (val
) = lval_internalvar
;
502 VALUE_INTERNALVAR (val
) = var
;
507 set_internalvar_component (struct internalvar
*var
, int offset
, int bitpos
,
508 int bitsize
, struct value
*newval
)
510 bfd_byte
*addr
= value_contents_writeable (var
->value
) + offset
;
513 modify_field (addr
, value_as_long (newval
),
516 memcpy (addr
, value_contents (newval
), TYPE_LENGTH (value_type (newval
)));
520 set_internalvar (struct internalvar
*var
, struct value
*val
)
522 struct value
*newval
;
524 newval
= value_copy (val
);
525 newval
->modifiable
= 1;
527 /* Force the value to be fetched from the target now, to avoid problems
528 later when this internalvar is referenced and the target is gone or
530 if (value_lazy (newval
))
531 value_fetch_lazy (newval
);
533 /* Begin code which must not call error(). If var->value points to
534 something free'd, an error() obviously leaves a dangling pointer.
535 But we also get a danling pointer if var->value points to
536 something in the value chain (i.e., before release_value is
537 called), because after the error free_all_values will get called before
541 release_value (newval
);
542 /* End code which must not call error(). */
546 internalvar_name (struct internalvar
*var
)
551 /* Free all internalvars. Done when new symtabs are loaded,
552 because that makes the values invalid. */
555 clear_internalvars (void)
557 struct internalvar
*var
;
562 internalvars
= var
->next
;
570 show_convenience (char *ignore
, int from_tty
)
572 struct internalvar
*var
;
575 for (var
= internalvars
; var
; var
= var
->next
)
581 printf_filtered ("$%s = ", var
->name
);
582 value_print (var
->value
, gdb_stdout
, 0, Val_pretty_default
);
583 printf_filtered ("\n");
586 printf_unfiltered ("No debugger convenience variables now defined.\n\
587 Convenience variables have names starting with \"$\";\n\
588 use \"set\" as in \"set $foo = 5\" to define them.\n");
591 /* Extract a value as a C number (either long or double).
592 Knows how to convert fixed values to double, or
593 floating values to long.
594 Does not deallocate the value. */
597 value_as_long (struct value
*val
)
599 /* This coerces arrays and functions, which is necessary (e.g.
600 in disassemble_command). It also dereferences references, which
601 I suspect is the most logical thing to do. */
602 val
= coerce_array (val
);
603 return unpack_long (value_type (val
), value_contents (val
));
607 value_as_double (struct value
*val
)
612 foo
= unpack_double (value_type (val
), value_contents (val
), &inv
);
614 error ("Invalid floating value found in program.");
617 /* Extract a value as a C pointer. Does not deallocate the value.
618 Note that val's type may not actually be a pointer; value_as_long
619 handles all the cases. */
621 value_as_address (struct value
*val
)
623 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
624 whether we want this to be true eventually. */
626 /* ADDR_BITS_REMOVE is wrong if we are being called for a
627 non-address (e.g. argument to "signal", "info break", etc.), or
628 for pointers to char, in which the low bits *are* significant. */
629 return ADDR_BITS_REMOVE (value_as_long (val
));
632 /* There are several targets (IA-64, PowerPC, and others) which
633 don't represent pointers to functions as simply the address of
634 the function's entry point. For example, on the IA-64, a
635 function pointer points to a two-word descriptor, generated by
636 the linker, which contains the function's entry point, and the
637 value the IA-64 "global pointer" register should have --- to
638 support position-independent code. The linker generates
639 descriptors only for those functions whose addresses are taken.
641 On such targets, it's difficult for GDB to convert an arbitrary
642 function address into a function pointer; it has to either find
643 an existing descriptor for that function, or call malloc and
644 build its own. On some targets, it is impossible for GDB to
645 build a descriptor at all: the descriptor must contain a jump
646 instruction; data memory cannot be executed; and code memory
649 Upon entry to this function, if VAL is a value of type `function'
650 (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
651 VALUE_ADDRESS (val) is the address of the function. This is what
652 you'll get if you evaluate an expression like `main'. The call
653 to COERCE_ARRAY below actually does all the usual unary
654 conversions, which includes converting values of type `function'
655 to `pointer to function'. This is the challenging conversion
656 discussed above. Then, `unpack_long' will convert that pointer
657 back into an address.
659 So, suppose the user types `disassemble foo' on an architecture
660 with a strange function pointer representation, on which GDB
661 cannot build its own descriptors, and suppose further that `foo'
662 has no linker-built descriptor. The address->pointer conversion
663 will signal an error and prevent the command from running, even
664 though the next step would have been to convert the pointer
665 directly back into the same address.
667 The following shortcut avoids this whole mess. If VAL is a
668 function, just return its address directly. */
669 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_FUNC
670 || TYPE_CODE (value_type (val
)) == TYPE_CODE_METHOD
)
671 return VALUE_ADDRESS (val
);
673 val
= coerce_array (val
);
675 /* Some architectures (e.g. Harvard), map instruction and data
676 addresses onto a single large unified address space. For
677 instance: An architecture may consider a large integer in the
678 range 0x10000000 .. 0x1000ffff to already represent a data
679 addresses (hence not need a pointer to address conversion) while
680 a small integer would still need to be converted integer to
681 pointer to address. Just assume such architectures handle all
682 integer conversions in a single function. */
686 I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we
687 must admonish GDB hackers to make sure its behavior matches the
688 compiler's, whenever possible.
690 In general, I think GDB should evaluate expressions the same way
691 the compiler does. When the user copies an expression out of
692 their source code and hands it to a `print' command, they should
693 get the same value the compiler would have computed. Any
694 deviation from this rule can cause major confusion and annoyance,
695 and needs to be justified carefully. In other words, GDB doesn't
696 really have the freedom to do these conversions in clever and
699 AndrewC pointed out that users aren't complaining about how GDB
700 casts integers to pointers; they are complaining that they can't
701 take an address from a disassembly listing and give it to `x/i'.
702 This is certainly important.
704 Adding an architecture method like integer_to_address() certainly
705 makes it possible for GDB to "get it right" in all circumstances
706 --- the target has complete control over how things get done, so
707 people can Do The Right Thing for their target without breaking
708 anyone else. The standard doesn't specify how integers get
709 converted to pointers; usually, the ABI doesn't either, but
710 ABI-specific code is a more reasonable place to handle it. */
712 if (TYPE_CODE (value_type (val
)) != TYPE_CODE_PTR
713 && TYPE_CODE (value_type (val
)) != TYPE_CODE_REF
714 && gdbarch_integer_to_address_p (current_gdbarch
))
715 return gdbarch_integer_to_address (current_gdbarch
, value_type (val
),
716 value_contents (val
));
718 return unpack_long (value_type (val
), value_contents (val
));
722 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
723 as a long, or as a double, assuming the raw data is described
724 by type TYPE. Knows how to convert different sizes of values
725 and can convert between fixed and floating point. We don't assume
726 any alignment for the raw data. Return value is in host byte order.
728 If you want functions and arrays to be coerced to pointers, and
729 references to be dereferenced, call value_as_long() instead.
731 C++: It is assumed that the front-end has taken care of
732 all matters concerning pointers to members. A pointer
733 to member which reaches here is considered to be equivalent
734 to an INT (or some size). After all, it is only an offset. */
737 unpack_long (struct type
*type
, const char *valaddr
)
739 enum type_code code
= TYPE_CODE (type
);
740 int len
= TYPE_LENGTH (type
);
741 int nosign
= TYPE_UNSIGNED (type
);
743 if (current_language
->la_language
== language_scm
744 && is_scmvalue_type (type
))
745 return scm_unpack (type
, valaddr
, TYPE_CODE_INT
);
749 case TYPE_CODE_TYPEDEF
:
750 return unpack_long (check_typedef (type
), valaddr
);
755 case TYPE_CODE_RANGE
:
757 return extract_unsigned_integer (valaddr
, len
);
759 return extract_signed_integer (valaddr
, len
);
762 return extract_typed_floating (valaddr
, type
);
766 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
767 whether we want this to be true eventually. */
768 return extract_typed_address (valaddr
, type
);
770 case TYPE_CODE_MEMBER
:
771 error ("not implemented: member types in unpack_long");
774 error ("Value can't be converted to integer.");
776 return 0; /* Placate lint. */
779 /* Return a double value from the specified type and address.
780 INVP points to an int which is set to 0 for valid value,
781 1 for invalid value (bad float format). In either case,
782 the returned double is OK to use. Argument is in target
783 format, result is in host format. */
786 unpack_double (struct type
*type
, const char *valaddr
, int *invp
)
792 *invp
= 0; /* Assume valid. */
793 CHECK_TYPEDEF (type
);
794 code
= TYPE_CODE (type
);
795 len
= TYPE_LENGTH (type
);
796 nosign
= TYPE_UNSIGNED (type
);
797 if (code
== TYPE_CODE_FLT
)
799 /* NOTE: cagney/2002-02-19: There was a test here to see if the
800 floating-point value was valid (using the macro
801 INVALID_FLOAT). That test/macro have been removed.
803 It turns out that only the VAX defined this macro and then
804 only in a non-portable way. Fixing the portability problem
805 wouldn't help since the VAX floating-point code is also badly
806 bit-rotten. The target needs to add definitions for the
807 methods TARGET_FLOAT_FORMAT and TARGET_DOUBLE_FORMAT - these
808 exactly describe the target floating-point format. The
809 problem here is that the corresponding floatformat_vax_f and
810 floatformat_vax_d values these methods should be set to are
811 also not defined either. Oops!
813 Hopefully someone will add both the missing floatformat
814 definitions and the new cases for floatformat_is_valid (). */
816 if (!floatformat_is_valid (floatformat_from_type (type
), valaddr
))
822 return extract_typed_floating (valaddr
, type
);
826 /* Unsigned -- be sure we compensate for signed LONGEST. */
827 return (ULONGEST
) unpack_long (type
, valaddr
);
831 /* Signed -- we are OK with unpack_long. */
832 return unpack_long (type
, valaddr
);
836 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
837 as a CORE_ADDR, assuming the raw data is described by type TYPE.
838 We don't assume any alignment for the raw data. Return value is in
841 If you want functions and arrays to be coerced to pointers, and
842 references to be dereferenced, call value_as_address() instead.
844 C++: It is assumed that the front-end has taken care of
845 all matters concerning pointers to members. A pointer
846 to member which reaches here is considered to be equivalent
847 to an INT (or some size). After all, it is only an offset. */
850 unpack_pointer (struct type
*type
, const char *valaddr
)
852 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
853 whether we want this to be true eventually. */
854 return unpack_long (type
, valaddr
);
858 /* Get the value of the FIELDN'th field (which must be static) of
859 TYPE. Return NULL if the field doesn't exist or has been
863 value_static_field (struct type
*type
, int fieldno
)
865 struct value
*retval
;
867 if (TYPE_FIELD_STATIC_HAS_ADDR (type
, fieldno
))
869 retval
= value_at (TYPE_FIELD_TYPE (type
, fieldno
),
870 TYPE_FIELD_STATIC_PHYSADDR (type
, fieldno
));
874 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
875 struct symbol
*sym
= lookup_symbol (phys_name
, 0, VAR_DOMAIN
, 0, NULL
);
878 /* With some compilers, e.g. HP aCC, static data members are reported
879 as non-debuggable symbols */
880 struct minimal_symbol
*msym
= lookup_minimal_symbol (phys_name
, NULL
, NULL
);
885 retval
= value_at (TYPE_FIELD_TYPE (type
, fieldno
),
886 SYMBOL_VALUE_ADDRESS (msym
));
891 /* SYM should never have a SYMBOL_CLASS which will require
892 read_var_value to use the FRAME parameter. */
893 if (symbol_read_needs_frame (sym
))
894 warning ("static field's value depends on the current "
895 "frame - bad debug info?");
896 retval
= read_var_value (sym
, NULL
);
898 if (retval
&& VALUE_LVAL (retval
) == lval_memory
)
899 SET_FIELD_PHYSADDR (TYPE_FIELD (type
, fieldno
),
900 VALUE_ADDRESS (retval
));
905 /* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.
906 You have to be careful here, since the size of the data area for the value
907 is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger
908 than the old enclosing type, you have to allocate more space for the data.
909 The return value is a pointer to the new version of this value structure. */
912 value_change_enclosing_type (struct value
*val
, struct type
*new_encl_type
)
914 if (TYPE_LENGTH (new_encl_type
) <= TYPE_LENGTH (value_enclosing_type (val
)))
916 val
->enclosing_type
= new_encl_type
;
921 struct value
*new_val
;
924 new_val
= (struct value
*) xrealloc (val
, sizeof (struct value
) + TYPE_LENGTH (new_encl_type
));
926 new_val
->enclosing_type
= new_encl_type
;
928 /* We have to make sure this ends up in the same place in the value
929 chain as the original copy, so it's clean-up behavior is the same.
930 If the value has been released, this is a waste of time, but there
931 is no way to tell that in advance, so... */
933 if (val
!= all_values
)
935 for (prev
= all_values
; prev
!= NULL
; prev
= prev
->next
)
937 if (prev
->next
== val
)
939 prev
->next
= new_val
;
949 /* Given a value ARG1 (offset by OFFSET bytes)
950 of a struct or union type ARG_TYPE,
951 extract and return the value of one of its (non-static) fields.
952 FIELDNO says which field. */
955 value_primitive_field (struct value
*arg1
, int offset
,
956 int fieldno
, struct type
*arg_type
)
961 CHECK_TYPEDEF (arg_type
);
962 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
964 /* Handle packed fields */
966 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
968 v
= value_from_longest (type
,
969 unpack_field_as_long (arg_type
,
970 value_contents (arg1
)
973 v
->bitpos
= TYPE_FIELD_BITPOS (arg_type
, fieldno
) % 8;
974 v
->bitsize
= TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
975 v
->offset
= value_offset (arg1
) + offset
976 + TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
978 else if (fieldno
< TYPE_N_BASECLASSES (arg_type
))
980 /* This field is actually a base subobject, so preserve the
981 entire object's contents for later references to virtual
983 v
= allocate_value (value_enclosing_type (arg1
));
985 if (value_lazy (arg1
))
988 memcpy (value_contents_all_raw (v
), value_contents_all_raw (arg1
),
989 TYPE_LENGTH (value_enclosing_type (arg1
)));
990 v
->offset
= value_offset (arg1
);
991 VALUE_EMBEDDED_OFFSET (v
)
993 VALUE_EMBEDDED_OFFSET (arg1
) +
994 TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
998 /* Plain old data member */
999 offset
+= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
1000 v
= allocate_value (type
);
1001 if (value_lazy (arg1
))
1004 memcpy (value_contents_raw (v
),
1005 value_contents_raw (arg1
) + offset
,
1006 TYPE_LENGTH (type
));
1007 v
->offset
= (value_offset (arg1
) + offset
1008 + VALUE_EMBEDDED_OFFSET (arg1
));
1010 VALUE_LVAL (v
) = VALUE_LVAL (arg1
);
1011 if (VALUE_LVAL (arg1
) == lval_internalvar
)
1012 VALUE_LVAL (v
) = lval_internalvar_component
;
1013 VALUE_ADDRESS (v
) = VALUE_ADDRESS (arg1
);
1014 VALUE_REGNUM (v
) = VALUE_REGNUM (arg1
);
1015 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (arg1
);
1016 /* VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
1017 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; */
1021 /* Given a value ARG1 of a struct or union type,
1022 extract and return the value of one of its (non-static) fields.
1023 FIELDNO says which field. */
1026 value_field (struct value
*arg1
, int fieldno
)
1028 return value_primitive_field (arg1
, 0, fieldno
, value_type (arg1
));
1031 /* Return a non-virtual function as a value.
1032 F is the list of member functions which contains the desired method.
1033 J is an index into F which provides the desired method.
1035 We only use the symbol for its address, so be happy with either a
1036 full symbol or a minimal symbol.
1040 value_fn_field (struct value
**arg1p
, struct fn_field
*f
, int j
, struct type
*type
,
1044 struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
1045 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1047 struct minimal_symbol
*msym
;
1049 sym
= lookup_symbol (physname
, 0, VAR_DOMAIN
, 0, NULL
);
1056 gdb_assert (sym
== NULL
);
1057 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
1062 v
= allocate_value (ftype
);
1065 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1069 VALUE_ADDRESS (v
) = SYMBOL_VALUE_ADDRESS (msym
);
1074 if (type
!= value_type (*arg1p
))
1075 *arg1p
= value_ind (value_cast (lookup_pointer_type (type
),
1076 value_addr (*arg1p
)));
1078 /* Move the `this' pointer according to the offset.
1079 VALUE_OFFSET (*arg1p) += offset;
1087 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1090 Extracting bits depends on endianness of the machine. Compute the
1091 number of least significant bits to discard. For big endian machines,
1092 we compute the total number of bits in the anonymous object, subtract
1093 off the bit count from the MSB of the object to the MSB of the
1094 bitfield, then the size of the bitfield, which leaves the LSB discard
1095 count. For little endian machines, the discard count is simply the
1096 number of bits from the LSB of the anonymous object to the LSB of the
1099 If the field is signed, we also do sign extension. */
1102 unpack_field_as_long (struct type
*type
, const char *valaddr
, int fieldno
)
1106 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
1107 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
1109 struct type
*field_type
;
1111 val
= extract_unsigned_integer (valaddr
+ bitpos
/ 8, sizeof (val
));
1112 field_type
= TYPE_FIELD_TYPE (type
, fieldno
);
1113 CHECK_TYPEDEF (field_type
);
1115 /* Extract bits. See comment above. */
1117 if (BITS_BIG_ENDIAN
)
1118 lsbcount
= (sizeof val
* 8 - bitpos
% 8 - bitsize
);
1120 lsbcount
= (bitpos
% 8);
1123 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1124 If the field is signed, and is negative, then sign extend. */
1126 if ((bitsize
> 0) && (bitsize
< 8 * (int) sizeof (val
)))
1128 valmask
= (((ULONGEST
) 1) << bitsize
) - 1;
1130 if (!TYPE_UNSIGNED (field_type
))
1132 if (val
& (valmask
^ (valmask
>> 1)))
1141 /* Modify the value of a bitfield. ADDR points to a block of memory in
1142 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1143 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1144 indicate which bits (in target bit order) comprise the bitfield.
1145 Requires 0 < BITSIZE <= lbits, 0 <= BITPOS+BITSIZE <= lbits, and
1146 0 <= BITPOS, where lbits is the size of a LONGEST in bits. */
1149 modify_field (char *addr
, LONGEST fieldval
, int bitpos
, int bitsize
)
1152 ULONGEST mask
= (ULONGEST
) -1 >> (8 * sizeof (ULONGEST
) - bitsize
);
1154 /* If a negative fieldval fits in the field in question, chop
1155 off the sign extension bits. */
1156 if ((~fieldval
& ~(mask
>> 1)) == 0)
1159 /* Warn if value is too big to fit in the field in question. */
1160 if (0 != (fieldval
& ~mask
))
1162 /* FIXME: would like to include fieldval in the message, but
1163 we don't have a sprintf_longest. */
1164 warning ("Value does not fit in %d bits.", bitsize
);
1166 /* Truncate it, otherwise adjoining fields may be corrupted. */
1170 oword
= extract_unsigned_integer (addr
, sizeof oword
);
1172 /* Shifting for bit field depends on endianness of the target machine. */
1173 if (BITS_BIG_ENDIAN
)
1174 bitpos
= sizeof (oword
) * 8 - bitpos
- bitsize
;
1176 oword
&= ~(mask
<< bitpos
);
1177 oword
|= fieldval
<< bitpos
;
1179 store_unsigned_integer (addr
, sizeof oword
, oword
);
1182 /* Convert C numbers into newly allocated values */
1185 value_from_longest (struct type
*type
, LONGEST num
)
1187 struct value
*val
= allocate_value (type
);
1188 enum type_code code
;
1191 code
= TYPE_CODE (type
);
1192 len
= TYPE_LENGTH (type
);
1196 case TYPE_CODE_TYPEDEF
:
1197 type
= check_typedef (type
);
1200 case TYPE_CODE_CHAR
:
1201 case TYPE_CODE_ENUM
:
1202 case TYPE_CODE_BOOL
:
1203 case TYPE_CODE_RANGE
:
1204 store_signed_integer (value_contents_raw (val
), len
, num
);
1209 store_typed_address (value_contents_raw (val
), type
, (CORE_ADDR
) num
);
1213 error ("Unexpected type (%d) encountered for integer constant.", code
);
1219 /* Create a value representing a pointer of type TYPE to the address
1222 value_from_pointer (struct type
*type
, CORE_ADDR addr
)
1224 struct value
*val
= allocate_value (type
);
1225 store_typed_address (value_contents_raw (val
), type
, addr
);
1230 /* Create a value for a string constant to be stored locally
1231 (not in the inferior's memory space, but in GDB memory).
1232 This is analogous to value_from_longest, which also does not
1233 use inferior memory. String shall NOT contain embedded nulls. */
1236 value_from_string (char *ptr
)
1239 int len
= strlen (ptr
);
1240 int lowbound
= current_language
->string_lower_bound
;
1241 struct type
*string_char_type
;
1242 struct type
*rangetype
;
1243 struct type
*stringtype
;
1245 rangetype
= create_range_type ((struct type
*) NULL
,
1247 lowbound
, len
+ lowbound
- 1);
1248 string_char_type
= language_string_char_type (current_language
,
1250 stringtype
= create_array_type ((struct type
*) NULL
,
1253 val
= allocate_value (stringtype
);
1254 memcpy (value_contents_raw (val
), ptr
, len
);
1259 value_from_double (struct type
*type
, DOUBLEST num
)
1261 struct value
*val
= allocate_value (type
);
1262 struct type
*base_type
= check_typedef (type
);
1263 enum type_code code
= TYPE_CODE (base_type
);
1264 int len
= TYPE_LENGTH (base_type
);
1266 if (code
== TYPE_CODE_FLT
)
1268 store_typed_floating (value_contents_raw (val
), base_type
, num
);
1271 error ("Unexpected type encountered for floating constant.");
1277 coerce_ref (struct value
*arg
)
1279 struct type
*value_type_arg_tmp
= check_typedef (value_type (arg
));
1280 if (TYPE_CODE (value_type_arg_tmp
) == TYPE_CODE_REF
)
1281 arg
= value_at_lazy (TYPE_TARGET_TYPE (value_type_arg_tmp
),
1282 unpack_pointer (value_type (arg
),
1283 value_contents (arg
)));
1288 coerce_array (struct value
*arg
)
1290 arg
= coerce_ref (arg
);
1291 if (current_language
->c_style_arrays
1292 && TYPE_CODE (value_type (arg
)) == TYPE_CODE_ARRAY
)
1293 arg
= value_coerce_array (arg
);
1294 if (TYPE_CODE (value_type (arg
)) == TYPE_CODE_FUNC
)
1295 arg
= value_coerce_function (arg
);
1300 coerce_number (struct value
*arg
)
1302 arg
= coerce_array (arg
);
1303 arg
= coerce_enum (arg
);
1308 coerce_enum (struct value
*arg
)
1310 if (TYPE_CODE (check_typedef (value_type (arg
))) == TYPE_CODE_ENUM
)
1311 arg
= value_cast (builtin_type_unsigned_int
, arg
);
1316 /* Should we use DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS instead of
1317 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc and TYPE
1318 is the type (which is known to be struct, union or array).
1320 On most machines, the struct convention is used unless we are
1321 using gcc and the type is of a special size. */
1322 /* As of about 31 Mar 93, GCC was changed to be compatible with the
1323 native compiler. GCC 2.3.3 was the last release that did it the
1324 old way. Since gcc2_compiled was not changed, we have no
1325 way to correctly win in all cases, so we just do the right thing
1326 for gcc1 and for gcc2 after this change. Thus it loses for gcc
1327 2.0-2.3.3. This is somewhat unfortunate, but changing gcc2_compiled
1328 would cause more chaos than dealing with some struct returns being
1330 /* NOTE: cagney/2004-06-13: Deleted check for "gcc_p". GCC 1.x is
1334 generic_use_struct_convention (int gcc_p
, struct type
*value_type
)
1336 return !(TYPE_LENGTH (value_type
) == 1
1337 || TYPE_LENGTH (value_type
) == 2
1338 || TYPE_LENGTH (value_type
) == 4
1339 || TYPE_LENGTH (value_type
) == 8);
1342 /* Return true if the function returning the specified type is using
1343 the convention of returning structures in memory (passing in the
1344 address as a hidden first parameter). GCC_P is nonzero if compiled
1348 using_struct_return (struct type
*value_type
, int gcc_p
)
1350 enum type_code code
= TYPE_CODE (value_type
);
1352 if (code
== TYPE_CODE_ERROR
)
1353 error ("Function return type unknown.");
1355 if (code
== TYPE_CODE_VOID
)
1356 /* A void return value is never in memory. See also corresponding
1357 code in "print_return_value". */
1360 /* Probe the architecture for the return-value convention. */
1361 return (gdbarch_return_value (current_gdbarch
, value_type
,
1363 != RETURN_VALUE_REGISTER_CONVENTION
);
1367 _initialize_values (void)
1369 add_cmd ("convenience", no_class
, show_convenience
,
1370 "Debugger convenience (\"$foo\") variables.\n\
1371 These variables are created when you assign them values;\n\
1372 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\
1373 A few convenience variables are given values automatically:\n\
1374 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1375 \"$__\" holds the contents of the last address examined with \"x\".",
1378 add_cmd ("values", no_class
, show_values
,
1379 "Elements of value history around item number IDX (or last ten).",