1 /* Low level packing and unpacking of values for GDB, the GNU Debugger.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
3 1995, 1996, 1997, 1998, 1999, 2000, 2002.
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 #include "gdb_string.h"
36 #include "gdb_assert.h"
39 /* Prototypes for exported functions. */
41 void _initialize_values (void);
43 /* Prototypes for local functions. */
45 static void show_values (char *, int);
47 static void show_convenience (char *, int);
50 /* The value-history records all the values printed
51 by print commands during this session. Each chunk
52 records 60 consecutive values. The first chunk on
53 the chain records the most recent values.
54 The total number of values is in value_history_count. */
56 #define VALUE_HISTORY_CHUNK 60
58 struct value_history_chunk
60 struct value_history_chunk
*next
;
61 struct value
*values
[VALUE_HISTORY_CHUNK
];
64 /* Chain of chunks now in use. */
66 static struct value_history_chunk
*value_history_chain
;
68 static int value_history_count
; /* Abs number of last entry stored */
70 /* List of all value objects currently allocated
71 (except for those released by calls to release_value)
72 This is so they can be freed after each command. */
74 static struct value
*all_values
;
76 /* Allocate a value that has the correct length for type TYPE. */
79 allocate_value (struct type
*type
)
82 struct type
*atype
= check_typedef (type
);
84 val
= (struct value
*) xmalloc (sizeof (struct value
) + TYPE_LENGTH (atype
));
85 VALUE_NEXT (val
) = all_values
;
87 VALUE_TYPE (val
) = type
;
88 VALUE_ENCLOSING_TYPE (val
) = type
;
89 VALUE_LVAL (val
) = not_lval
;
90 VALUE_ADDRESS (val
) = 0;
91 VALUE_FRAME (val
) = 0;
92 VALUE_OFFSET (val
) = 0;
93 VALUE_BITPOS (val
) = 0;
94 VALUE_BITSIZE (val
) = 0;
95 VALUE_REGNO (val
) = -1;
97 VALUE_OPTIMIZED_OUT (val
) = 0;
98 VALUE_BFD_SECTION (val
) = NULL
;
99 VALUE_EMBEDDED_OFFSET (val
) = 0;
100 VALUE_POINTED_TO_OFFSET (val
) = 0;
105 /* Allocate a value that has the correct length
106 for COUNT repetitions type TYPE. */
109 allocate_repeat_value (struct type
*type
, int count
)
111 int low_bound
= current_language
->string_lower_bound
; /* ??? */
112 /* FIXME-type-allocation: need a way to free this type when we are
114 struct type
*range_type
115 = create_range_type ((struct type
*) NULL
, builtin_type_int
,
116 low_bound
, count
+ low_bound
- 1);
117 /* FIXME-type-allocation: need a way to free this type when we are
119 return allocate_value (create_array_type ((struct type
*) NULL
,
123 /* Return a mark in the value chain. All values allocated after the
124 mark is obtained (except for those released) are subject to being freed
125 if a subsequent value_free_to_mark is passed the mark. */
132 /* Free all values allocated since MARK was obtained by value_mark
133 (except for those released). */
135 value_free_to_mark (struct value
*mark
)
140 for (val
= all_values
; val
&& val
!= mark
; val
= next
)
142 next
= VALUE_NEXT (val
);
148 /* Free all the values that have been allocated (except for those released).
149 Called after each command, successful or not. */
152 free_all_values (void)
157 for (val
= all_values
; val
; val
= next
)
159 next
= VALUE_NEXT (val
);
166 /* Remove VAL from the chain all_values
167 so it will not be freed automatically. */
170 release_value (struct value
*val
)
174 if (all_values
== val
)
176 all_values
= val
->next
;
180 for (v
= all_values
; v
; v
= v
->next
)
190 /* Release all values up to mark */
192 value_release_to_mark (struct value
*mark
)
197 for (val
= next
= all_values
; next
; next
= VALUE_NEXT (next
))
198 if (VALUE_NEXT (next
) == mark
)
200 all_values
= VALUE_NEXT (next
);
201 VALUE_NEXT (next
) = 0;
208 /* Return a copy of the value ARG.
209 It contains the same contents, for same memory address,
210 but it's a different block of storage. */
213 value_copy (struct value
*arg
)
215 register struct type
*encl_type
= VALUE_ENCLOSING_TYPE (arg
);
216 struct value
*val
= allocate_value (encl_type
);
217 VALUE_TYPE (val
) = VALUE_TYPE (arg
);
218 VALUE_LVAL (val
) = VALUE_LVAL (arg
);
219 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg
);
220 VALUE_OFFSET (val
) = VALUE_OFFSET (arg
);
221 VALUE_BITPOS (val
) = VALUE_BITPOS (arg
);
222 VALUE_BITSIZE (val
) = VALUE_BITSIZE (arg
);
223 VALUE_FRAME (val
) = VALUE_FRAME (arg
);
224 VALUE_REGNO (val
) = VALUE_REGNO (arg
);
225 VALUE_LAZY (val
) = VALUE_LAZY (arg
);
226 VALUE_OPTIMIZED_OUT (val
) = VALUE_OPTIMIZED_OUT (arg
);
227 VALUE_EMBEDDED_OFFSET (val
) = VALUE_EMBEDDED_OFFSET (arg
);
228 VALUE_POINTED_TO_OFFSET (val
) = VALUE_POINTED_TO_OFFSET (arg
);
229 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (arg
);
230 val
->modifiable
= arg
->modifiable
;
231 if (!VALUE_LAZY (val
))
233 memcpy (VALUE_CONTENTS_ALL_RAW (val
), VALUE_CONTENTS_ALL_RAW (arg
),
234 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg
)));
240 /* Access to the value history. */
242 /* Record a new value in the value history.
243 Returns the absolute history index of the entry.
244 Result of -1 indicates the value was not saved; otherwise it is the
245 value history index of this new item. */
248 record_latest_value (struct value
*val
)
252 /* We don't want this value to have anything to do with the inferior anymore.
253 In particular, "set $1 = 50" should not affect the variable from which
254 the value was taken, and fast watchpoints should be able to assume that
255 a value on the value history never changes. */
256 if (VALUE_LAZY (val
))
257 value_fetch_lazy (val
);
258 /* We preserve VALUE_LVAL so that the user can find out where it was fetched
259 from. This is a bit dubious, because then *&$1 does not just return $1
260 but the current contents of that location. c'est la vie... */
264 /* Here we treat value_history_count as origin-zero
265 and applying to the value being stored now. */
267 i
= value_history_count
% VALUE_HISTORY_CHUNK
;
270 struct value_history_chunk
*new
271 = (struct value_history_chunk
*)
272 xmalloc (sizeof (struct value_history_chunk
));
273 memset (new->values
, 0, sizeof new->values
);
274 new->next
= value_history_chain
;
275 value_history_chain
= new;
278 value_history_chain
->values
[i
] = val
;
280 /* Now we regard value_history_count as origin-one
281 and applying to the value just stored. */
283 return ++value_history_count
;
286 /* Return a copy of the value in the history with sequence number NUM. */
289 access_value_history (int num
)
291 struct value_history_chunk
*chunk
;
293 register int absnum
= num
;
296 absnum
+= value_history_count
;
301 error ("The history is empty.");
303 error ("There is only one value in the history.");
305 error ("History does not go back to $$%d.", -num
);
307 if (absnum
> value_history_count
)
308 error ("History has not yet reached $%d.", absnum
);
312 /* Now absnum is always absolute and origin zero. */
314 chunk
= value_history_chain
;
315 for (i
= (value_history_count
- 1) / VALUE_HISTORY_CHUNK
- absnum
/ VALUE_HISTORY_CHUNK
;
319 return value_copy (chunk
->values
[absnum
% VALUE_HISTORY_CHUNK
]);
322 /* Clear the value history entirely.
323 Must be done when new symbol tables are loaded,
324 because the type pointers become invalid. */
327 clear_value_history (void)
329 struct value_history_chunk
*next
;
333 while (value_history_chain
)
335 for (i
= 0; i
< VALUE_HISTORY_CHUNK
; i
++)
336 if ((val
= value_history_chain
->values
[i
]) != NULL
)
338 next
= value_history_chain
->next
;
339 xfree (value_history_chain
);
340 value_history_chain
= next
;
342 value_history_count
= 0;
346 show_values (char *num_exp
, int from_tty
)
354 /* "info history +" should print from the stored position.
355 "info history <exp>" should print around value number <exp>. */
356 if (num_exp
[0] != '+' || num_exp
[1] != '\0')
357 num
= parse_and_eval_long (num_exp
) - 5;
361 /* "info history" means print the last 10 values. */
362 num
= value_history_count
- 9;
368 for (i
= num
; i
< num
+ 10 && i
<= value_history_count
; i
++)
370 val
= access_value_history (i
);
371 printf_filtered ("$%d = ", i
);
372 value_print (val
, gdb_stdout
, 0, Val_pretty_default
);
373 printf_filtered ("\n");
376 /* The next "info history +" should start after what we just printed. */
379 /* Hitting just return after this command should do the same thing as
380 "info history +". If num_exp is null, this is unnecessary, since
381 "info history +" is not useful after "info history". */
382 if (from_tty
&& num_exp
)
389 /* Internal variables. These are variables within the debugger
390 that hold values assigned by debugger commands.
391 The user refers to them with a '$' prefix
392 that does not appear in the variable names stored internally. */
394 static struct internalvar
*internalvars
;
396 /* Look up an internal variable with name NAME. NAME should not
397 normally include a dollar sign.
399 If the specified internal variable does not exist,
400 one is created, with a void value. */
403 lookup_internalvar (char *name
)
405 register struct internalvar
*var
;
407 for (var
= internalvars
; var
; var
= var
->next
)
408 if (STREQ (var
->name
, name
))
411 var
= (struct internalvar
*) xmalloc (sizeof (struct internalvar
));
412 var
->name
= concat (name
, NULL
);
413 var
->value
= allocate_value (builtin_type_void
);
414 release_value (var
->value
);
415 var
->next
= internalvars
;
421 value_of_internalvar (struct internalvar
*var
)
425 #ifdef IS_TRAPPED_INTERNALVAR
426 if (IS_TRAPPED_INTERNALVAR (var
->name
))
427 return VALUE_OF_TRAPPED_INTERNALVAR (var
);
430 val
= value_copy (var
->value
);
431 if (VALUE_LAZY (val
))
432 value_fetch_lazy (val
);
433 VALUE_LVAL (val
) = lval_internalvar
;
434 VALUE_INTERNALVAR (val
) = var
;
439 set_internalvar_component (struct internalvar
*var
, int offset
, int bitpos
,
440 int bitsize
, struct value
*newval
)
442 register char *addr
= VALUE_CONTENTS (var
->value
) + offset
;
444 #ifdef IS_TRAPPED_INTERNALVAR
445 if (IS_TRAPPED_INTERNALVAR (var
->name
))
446 SET_TRAPPED_INTERNALVAR (var
, newval
, bitpos
, bitsize
, offset
);
450 modify_field (addr
, value_as_long (newval
),
453 memcpy (addr
, VALUE_CONTENTS (newval
), TYPE_LENGTH (VALUE_TYPE (newval
)));
457 set_internalvar (struct internalvar
*var
, struct value
*val
)
459 struct value
*newval
;
461 #ifdef IS_TRAPPED_INTERNALVAR
462 if (IS_TRAPPED_INTERNALVAR (var
->name
))
463 SET_TRAPPED_INTERNALVAR (var
, val
, 0, 0, 0);
466 newval
= value_copy (val
);
467 newval
->modifiable
= 1;
469 /* Force the value to be fetched from the target now, to avoid problems
470 later when this internalvar is referenced and the target is gone or
472 if (VALUE_LAZY (newval
))
473 value_fetch_lazy (newval
);
475 /* Begin code which must not call error(). If var->value points to
476 something free'd, an error() obviously leaves a dangling pointer.
477 But we also get a danling pointer if var->value points to
478 something in the value chain (i.e., before release_value is
479 called), because after the error free_all_values will get called before
483 release_value (newval
);
484 /* End code which must not call error(). */
488 internalvar_name (struct internalvar
*var
)
493 /* Free all internalvars. Done when new symtabs are loaded,
494 because that makes the values invalid. */
497 clear_internalvars (void)
499 register struct internalvar
*var
;
504 internalvars
= var
->next
;
512 show_convenience (char *ignore
, int from_tty
)
514 register struct internalvar
*var
;
517 for (var
= internalvars
; var
; var
= var
->next
)
519 #ifdef IS_TRAPPED_INTERNALVAR
520 if (IS_TRAPPED_INTERNALVAR (var
->name
))
527 printf_filtered ("$%s = ", var
->name
);
528 value_print (var
->value
, gdb_stdout
, 0, Val_pretty_default
);
529 printf_filtered ("\n");
532 printf_unfiltered ("No debugger convenience variables now defined.\n\
533 Convenience variables have names starting with \"$\";\n\
534 use \"set\" as in \"set $foo = 5\" to define them.\n");
537 /* Extract a value as a C number (either long or double).
538 Knows how to convert fixed values to double, or
539 floating values to long.
540 Does not deallocate the value. */
543 value_as_long (struct value
*val
)
545 /* This coerces arrays and functions, which is necessary (e.g.
546 in disassemble_command). It also dereferences references, which
547 I suspect is the most logical thing to do. */
549 return unpack_long (VALUE_TYPE (val
), VALUE_CONTENTS (val
));
553 value_as_double (struct value
*val
)
558 foo
= unpack_double (VALUE_TYPE (val
), VALUE_CONTENTS (val
), &inv
);
560 error ("Invalid floating value found in program.");
563 /* Extract a value as a C pointer. Does not deallocate the value.
564 Note that val's type may not actually be a pointer; value_as_long
565 handles all the cases. */
567 value_as_address (struct value
*val
)
569 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
570 whether we want this to be true eventually. */
572 /* ADDR_BITS_REMOVE is wrong if we are being called for a
573 non-address (e.g. argument to "signal", "info break", etc.), or
574 for pointers to char, in which the low bits *are* significant. */
575 return ADDR_BITS_REMOVE (value_as_long (val
));
578 /* There are several targets (IA-64, PowerPC, and others) which
579 don't represent pointers to functions as simply the address of
580 the function's entry point. For example, on the IA-64, a
581 function pointer points to a two-word descriptor, generated by
582 the linker, which contains the function's entry point, and the
583 value the IA-64 "global pointer" register should have --- to
584 support position-independent code. The linker generates
585 descriptors only for those functions whose addresses are taken.
587 On such targets, it's difficult for GDB to convert an arbitrary
588 function address into a function pointer; it has to either find
589 an existing descriptor for that function, or call malloc and
590 build its own. On some targets, it is impossible for GDB to
591 build a descriptor at all: the descriptor must contain a jump
592 instruction; data memory cannot be executed; and code memory
595 Upon entry to this function, if VAL is a value of type `function'
596 (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
597 VALUE_ADDRESS (val) is the address of the function. This is what
598 you'll get if you evaluate an expression like `main'. The call
599 to COERCE_ARRAY below actually does all the usual unary
600 conversions, which includes converting values of type `function'
601 to `pointer to function'. This is the challenging conversion
602 discussed above. Then, `unpack_long' will convert that pointer
603 back into an address.
605 So, suppose the user types `disassemble foo' on an architecture
606 with a strange function pointer representation, on which GDB
607 cannot build its own descriptors, and suppose further that `foo'
608 has no linker-built descriptor. The address->pointer conversion
609 will signal an error and prevent the command from running, even
610 though the next step would have been to convert the pointer
611 directly back into the same address.
613 The following shortcut avoids this whole mess. If VAL is a
614 function, just return its address directly. */
615 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FUNC
616 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_METHOD
)
617 return VALUE_ADDRESS (val
);
621 /* Some architectures (e.g. Harvard), map instruction and data
622 addresses onto a single large unified address space. For
623 instance: An architecture may consider a large integer in the
624 range 0x10000000 .. 0x1000ffff to already represent a data
625 addresses (hence not need a pointer to address conversion) while
626 a small integer would still need to be converted integer to
627 pointer to address. Just assume such architectures handle all
628 integer conversions in a single function. */
632 I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we
633 must admonish GDB hackers to make sure its behavior matches the
634 compiler's, whenever possible.
636 In general, I think GDB should evaluate expressions the same way
637 the compiler does. When the user copies an expression out of
638 their source code and hands it to a `print' command, they should
639 get the same value the compiler would have computed. Any
640 deviation from this rule can cause major confusion and annoyance,
641 and needs to be justified carefully. In other words, GDB doesn't
642 really have the freedom to do these conversions in clever and
645 AndrewC pointed out that users aren't complaining about how GDB
646 casts integers to pointers; they are complaining that they can't
647 take an address from a disassembly listing and give it to `x/i'.
648 This is certainly important.
650 Adding an architecture method like INTEGER_TO_ADDRESS certainly
651 makes it possible for GDB to "get it right" in all circumstances
652 --- the target has complete control over how things get done, so
653 people can Do The Right Thing for their target without breaking
654 anyone else. The standard doesn't specify how integers get
655 converted to pointers; usually, the ABI doesn't either, but
656 ABI-specific code is a more reasonable place to handle it. */
658 if (TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_PTR
659 && TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_REF
660 && INTEGER_TO_ADDRESS_P ())
661 return INTEGER_TO_ADDRESS (VALUE_TYPE (val
), VALUE_CONTENTS (val
));
663 return unpack_long (VALUE_TYPE (val
), VALUE_CONTENTS (val
));
667 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
668 as a long, or as a double, assuming the raw data is described
669 by type TYPE. Knows how to convert different sizes of values
670 and can convert between fixed and floating point. We don't assume
671 any alignment for the raw data. Return value is in host byte order.
673 If you want functions and arrays to be coerced to pointers, and
674 references to be dereferenced, call value_as_long() instead.
676 C++: It is assumed that the front-end has taken care of
677 all matters concerning pointers to members. A pointer
678 to member which reaches here is considered to be equivalent
679 to an INT (or some size). After all, it is only an offset. */
682 unpack_long (struct type
*type
, char *valaddr
)
684 register enum type_code code
= TYPE_CODE (type
);
685 register int len
= TYPE_LENGTH (type
);
686 register int nosign
= TYPE_UNSIGNED (type
);
688 if (current_language
->la_language
== language_scm
689 && is_scmvalue_type (type
))
690 return scm_unpack (type
, valaddr
, TYPE_CODE_INT
);
694 case TYPE_CODE_TYPEDEF
:
695 return unpack_long (check_typedef (type
), valaddr
);
700 case TYPE_CODE_RANGE
:
702 return extract_unsigned_integer (valaddr
, len
);
704 return extract_signed_integer (valaddr
, len
);
707 return extract_typed_floating (valaddr
, type
);
711 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
712 whether we want this to be true eventually. */
713 return extract_typed_address (valaddr
, type
);
715 case TYPE_CODE_MEMBER
:
716 error ("not implemented: member types in unpack_long");
719 error ("Value can't be converted to integer.");
721 return 0; /* Placate lint. */
724 /* Return a double value from the specified type and address.
725 INVP points to an int which is set to 0 for valid value,
726 1 for invalid value (bad float format). In either case,
727 the returned double is OK to use. Argument is in target
728 format, result is in host format. */
731 unpack_double (struct type
*type
, char *valaddr
, int *invp
)
737 *invp
= 0; /* Assume valid. */
738 CHECK_TYPEDEF (type
);
739 code
= TYPE_CODE (type
);
740 len
= TYPE_LENGTH (type
);
741 nosign
= TYPE_UNSIGNED (type
);
742 if (code
== TYPE_CODE_FLT
)
744 /* NOTE: cagney/2002-02-19: There was a test here to see if the
745 floating-point value was valid (using the macro
746 INVALID_FLOAT). That test/macro have been removed.
748 It turns out that only the VAX defined this macro and then
749 only in a non-portable way. Fixing the portability problem
750 wouldn't help since the VAX floating-point code is also badly
751 bit-rotten. The target needs to add definitions for the
752 methods TARGET_FLOAT_FORMAT and TARGET_DOUBLE_FORMAT - these
753 exactly describe the target floating-point format. The
754 problem here is that the corresponding floatformat_vax_f and
755 floatformat_vax_d values these methods should be set to are
756 also not defined either. Oops!
758 Hopefully someone will add both the missing floatformat
759 definitions and floatformat_is_invalid() function. */
760 return extract_typed_floating (valaddr
, type
);
764 /* Unsigned -- be sure we compensate for signed LONGEST. */
765 return (ULONGEST
) unpack_long (type
, valaddr
);
769 /* Signed -- we are OK with unpack_long. */
770 return unpack_long (type
, valaddr
);
774 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
775 as a CORE_ADDR, assuming the raw data is described by type TYPE.
776 We don't assume any alignment for the raw data. Return value is in
779 If you want functions and arrays to be coerced to pointers, and
780 references to be dereferenced, call value_as_address() instead.
782 C++: It is assumed that the front-end has taken care of
783 all matters concerning pointers to members. A pointer
784 to member which reaches here is considered to be equivalent
785 to an INT (or some size). After all, it is only an offset. */
788 unpack_pointer (struct type
*type
, char *valaddr
)
790 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
791 whether we want this to be true eventually. */
792 return unpack_long (type
, valaddr
);
796 /* Get the value of the FIELDN'th field (which must be static) of
797 TYPE. Return NULL if the field doesn't exist or has been
801 value_static_field (struct type
*type
, int fieldno
)
803 struct value
*retval
;
805 if (TYPE_FIELD_STATIC_HAS_ADDR (type
, fieldno
))
807 retval
= value_at (TYPE_FIELD_TYPE (type
, fieldno
),
808 TYPE_FIELD_STATIC_PHYSADDR (type
, fieldno
),
813 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
814 struct symbol
*sym
= lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
817 /* With some compilers, e.g. HP aCC, static data members are reported
818 as non-debuggable symbols */
819 struct minimal_symbol
*msym
= lookup_minimal_symbol (phys_name
, NULL
, NULL
);
824 retval
= value_at (TYPE_FIELD_TYPE (type
, fieldno
),
825 SYMBOL_VALUE_ADDRESS (msym
),
826 SYMBOL_BFD_SECTION (msym
));
831 /* SYM should never have a SYMBOL_CLASS which will require
832 read_var_value to use the FRAME parameter. */
833 if (symbol_read_needs_frame (sym
))
834 warning ("static field's value depends on the current "
835 "frame - bad debug info?");
836 retval
= read_var_value (sym
, NULL
);
838 if (retval
&& VALUE_LVAL (retval
) == lval_memory
)
839 SET_FIELD_PHYSADDR (TYPE_FIELD (type
, fieldno
),
840 VALUE_ADDRESS (retval
));
845 /* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.
846 You have to be careful here, since the size of the data area for the value
847 is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger
848 than the old enclosing type, you have to allocate more space for the data.
849 The return value is a pointer to the new version of this value structure. */
852 value_change_enclosing_type (struct value
*val
, struct type
*new_encl_type
)
854 if (TYPE_LENGTH (new_encl_type
) <= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val
)))
856 VALUE_ENCLOSING_TYPE (val
) = new_encl_type
;
861 struct value
*new_val
;
864 new_val
= (struct value
*) xrealloc (val
, sizeof (struct value
) + TYPE_LENGTH (new_encl_type
));
866 /* We have to make sure this ends up in the same place in the value
867 chain as the original copy, so it's clean-up behavior is the same.
868 If the value has been released, this is a waste of time, but there
869 is no way to tell that in advance, so... */
871 if (val
!= all_values
)
873 for (prev
= all_values
; prev
!= NULL
; prev
= prev
->next
)
875 if (prev
->next
== val
)
877 prev
->next
= new_val
;
887 /* Given a value ARG1 (offset by OFFSET bytes)
888 of a struct or union type ARG_TYPE,
889 extract and return the value of one of its (non-static) fields.
890 FIELDNO says which field. */
893 value_primitive_field (struct value
*arg1
, int offset
,
894 register int fieldno
, register struct type
*arg_type
)
897 register struct type
*type
;
899 CHECK_TYPEDEF (arg_type
);
900 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
902 /* Handle packed fields */
904 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
906 v
= value_from_longest (type
,
907 unpack_field_as_long (arg_type
,
908 VALUE_CONTENTS (arg1
)
911 VALUE_BITPOS (v
) = TYPE_FIELD_BITPOS (arg_type
, fieldno
) % 8;
912 VALUE_BITSIZE (v
) = TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
913 VALUE_OFFSET (v
) = VALUE_OFFSET (arg1
) + offset
914 + TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
916 else if (fieldno
< TYPE_N_BASECLASSES (arg_type
))
918 /* This field is actually a base subobject, so preserve the
919 entire object's contents for later references to virtual
921 v
= allocate_value (VALUE_ENCLOSING_TYPE (arg1
));
922 VALUE_TYPE (v
) = type
;
923 if (VALUE_LAZY (arg1
))
926 memcpy (VALUE_CONTENTS_ALL_RAW (v
), VALUE_CONTENTS_ALL_RAW (arg1
),
927 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg1
)));
928 VALUE_OFFSET (v
) = VALUE_OFFSET (arg1
);
929 VALUE_EMBEDDED_OFFSET (v
)
931 VALUE_EMBEDDED_OFFSET (arg1
) +
932 TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
936 /* Plain old data member */
937 offset
+= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
938 v
= allocate_value (type
);
939 if (VALUE_LAZY (arg1
))
942 memcpy (VALUE_CONTENTS_RAW (v
),
943 VALUE_CONTENTS_RAW (arg1
) + offset
,
945 VALUE_OFFSET (v
) = VALUE_OFFSET (arg1
) + offset
946 + VALUE_EMBEDDED_OFFSET (arg1
);
948 VALUE_LVAL (v
) = VALUE_LVAL (arg1
);
949 if (VALUE_LVAL (arg1
) == lval_internalvar
)
950 VALUE_LVAL (v
) = lval_internalvar_component
;
951 VALUE_ADDRESS (v
) = VALUE_ADDRESS (arg1
);
952 VALUE_REGNO (v
) = VALUE_REGNO (arg1
);
953 /* VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
954 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; */
958 /* Given a value ARG1 of a struct or union type,
959 extract and return the value of one of its (non-static) fields.
960 FIELDNO says which field. */
963 value_field (struct value
*arg1
, register int fieldno
)
965 return value_primitive_field (arg1
, 0, fieldno
, VALUE_TYPE (arg1
));
968 /* Return a non-virtual function as a value.
969 F is the list of member functions which contains the desired method.
970 J is an index into F which provides the desired method.
972 We only use the symbol for its address, so be happy with either a
973 full symbol or a minimal symbol.
977 value_fn_field (struct value
**arg1p
, struct fn_field
*f
, int j
, struct type
*type
,
981 register struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
982 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
984 struct minimal_symbol
*msym
;
986 sym
= lookup_symbol (physname
, 0, VAR_NAMESPACE
, 0, NULL
);
993 gdb_assert (sym
== NULL
);
994 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
999 v
= allocate_value (ftype
);
1002 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1006 VALUE_ADDRESS (v
) = SYMBOL_VALUE_ADDRESS (msym
);
1011 if (type
!= VALUE_TYPE (*arg1p
))
1012 *arg1p
= value_ind (value_cast (lookup_pointer_type (type
),
1013 value_addr (*arg1p
)));
1015 /* Move the `this' pointer according to the offset.
1016 VALUE_OFFSET (*arg1p) += offset;
1024 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1027 Extracting bits depends on endianness of the machine. Compute the
1028 number of least significant bits to discard. For big endian machines,
1029 we compute the total number of bits in the anonymous object, subtract
1030 off the bit count from the MSB of the object to the MSB of the
1031 bitfield, then the size of the bitfield, which leaves the LSB discard
1032 count. For little endian machines, the discard count is simply the
1033 number of bits from the LSB of the anonymous object to the LSB of the
1036 If the field is signed, we also do sign extension. */
1039 unpack_field_as_long (struct type
*type
, char *valaddr
, int fieldno
)
1043 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
1044 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
1046 struct type
*field_type
;
1048 val
= extract_unsigned_integer (valaddr
+ bitpos
/ 8, sizeof (val
));
1049 field_type
= TYPE_FIELD_TYPE (type
, fieldno
);
1050 CHECK_TYPEDEF (field_type
);
1052 /* Extract bits. See comment above. */
1054 if (BITS_BIG_ENDIAN
)
1055 lsbcount
= (sizeof val
* 8 - bitpos
% 8 - bitsize
);
1057 lsbcount
= (bitpos
% 8);
1060 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1061 If the field is signed, and is negative, then sign extend. */
1063 if ((bitsize
> 0) && (bitsize
< 8 * (int) sizeof (val
)))
1065 valmask
= (((ULONGEST
) 1) << bitsize
) - 1;
1067 if (!TYPE_UNSIGNED (field_type
))
1069 if (val
& (valmask
^ (valmask
>> 1)))
1078 /* Modify the value of a bitfield. ADDR points to a block of memory in
1079 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1080 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1081 indicate which bits (in target bit order) comprise the bitfield. */
1084 modify_field (char *addr
, LONGEST fieldval
, int bitpos
, int bitsize
)
1088 /* If a negative fieldval fits in the field in question, chop
1089 off the sign extension bits. */
1090 if (bitsize
< (8 * (int) sizeof (fieldval
))
1091 && (~fieldval
& ~((1 << (bitsize
- 1)) - 1)) == 0)
1092 fieldval
= fieldval
& ((1 << bitsize
) - 1);
1094 /* Warn if value is too big to fit in the field in question. */
1095 if (bitsize
< (8 * (int) sizeof (fieldval
))
1096 && 0 != (fieldval
& ~((1 << bitsize
) - 1)))
1098 /* FIXME: would like to include fieldval in the message, but
1099 we don't have a sprintf_longest. */
1100 warning ("Value does not fit in %d bits.", bitsize
);
1102 /* Truncate it, otherwise adjoining fields may be corrupted. */
1103 fieldval
= fieldval
& ((1 << bitsize
) - 1);
1106 oword
= extract_signed_integer (addr
, sizeof oword
);
1108 /* Shifting for bit field depends on endianness of the target machine. */
1109 if (BITS_BIG_ENDIAN
)
1110 bitpos
= sizeof (oword
) * 8 - bitpos
- bitsize
;
1112 /* Mask out old value, while avoiding shifts >= size of oword */
1113 if (bitsize
< 8 * (int) sizeof (oword
))
1114 oword
&= ~(((((ULONGEST
) 1) << bitsize
) - 1) << bitpos
);
1116 oword
&= ~((~(ULONGEST
) 0) << bitpos
);
1117 oword
|= fieldval
<< bitpos
;
1119 store_signed_integer (addr
, sizeof oword
, oword
);
1122 /* Convert C numbers into newly allocated values */
1125 value_from_longest (struct type
*type
, register LONGEST num
)
1127 struct value
*val
= allocate_value (type
);
1128 register enum type_code code
;
1131 code
= TYPE_CODE (type
);
1132 len
= TYPE_LENGTH (type
);
1136 case TYPE_CODE_TYPEDEF
:
1137 type
= check_typedef (type
);
1140 case TYPE_CODE_CHAR
:
1141 case TYPE_CODE_ENUM
:
1142 case TYPE_CODE_BOOL
:
1143 case TYPE_CODE_RANGE
:
1144 store_signed_integer (VALUE_CONTENTS_RAW (val
), len
, num
);
1149 store_typed_address (VALUE_CONTENTS_RAW (val
), type
, (CORE_ADDR
) num
);
1153 error ("Unexpected type (%d) encountered for integer constant.", code
);
1159 /* Create a value representing a pointer of type TYPE to the address
1162 value_from_pointer (struct type
*type
, CORE_ADDR addr
)
1164 struct value
*val
= allocate_value (type
);
1165 store_typed_address (VALUE_CONTENTS_RAW (val
), type
, addr
);
1170 /* Create a value for a string constant to be stored locally
1171 (not in the inferior's memory space, but in GDB memory).
1172 This is analogous to value_from_longest, which also does not
1173 use inferior memory. String shall NOT contain embedded nulls. */
1176 value_from_string (char *ptr
)
1179 int len
= strlen (ptr
);
1180 int lowbound
= current_language
->string_lower_bound
;
1181 struct type
*rangetype
=
1182 create_range_type ((struct type
*) NULL
,
1184 lowbound
, len
+ lowbound
- 1);
1185 struct type
*stringtype
=
1186 create_array_type ((struct type
*) NULL
,
1187 *current_language
->string_char_type
,
1190 val
= allocate_value (stringtype
);
1191 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, len
);
1196 value_from_double (struct type
*type
, DOUBLEST num
)
1198 struct value
*val
= allocate_value (type
);
1199 struct type
*base_type
= check_typedef (type
);
1200 register enum type_code code
= TYPE_CODE (base_type
);
1201 register int len
= TYPE_LENGTH (base_type
);
1203 if (code
== TYPE_CODE_FLT
)
1205 store_typed_floating (VALUE_CONTENTS_RAW (val
), base_type
, num
);
1208 error ("Unexpected type encountered for floating constant.");
1213 /* Deal with the value that is "about to be returned". */
1215 /* Return the value that a function returning now
1216 would be returning to its caller, assuming its type is VALTYPE.
1217 RETBUF is where we look for what ought to be the contents
1218 of the registers (in raw form). This is because it is often
1219 desirable to restore old values to those registers
1220 after saving the contents of interest, and then call
1221 this function using the saved values.
1222 struct_return is non-zero when the function in question is
1223 using the structure return conventions on the machine in question;
1224 0 when it is using the value returning conventions (this often
1225 means returning pointer to where structure is vs. returning value). */
1229 value_being_returned (struct type
*valtype
, struct regcache
*retbuf
,
1235 /* If this is not defined, just use EXTRACT_RETURN_VALUE instead. */
1236 if (EXTRACT_STRUCT_VALUE_ADDRESS_P ())
1239 addr
= EXTRACT_STRUCT_VALUE_ADDRESS (retbuf
);
1241 error ("Function return value unknown.");
1242 return value_at (valtype
, addr
, NULL
);
1245 /* If this is not defined, just use EXTRACT_RETURN_VALUE instead. */
1246 if (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ())
1249 char *buf
= deprecated_grub_regcache_for_registers (retbuf
);
1250 addr
= DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (buf
);
1252 error ("Function return value unknown.");
1253 return value_at (valtype
, addr
, NULL
);
1256 val
= allocate_value (valtype
);
1257 CHECK_TYPEDEF (valtype
);
1258 EXTRACT_RETURN_VALUE (valtype
, retbuf
, VALUE_CONTENTS_RAW (val
));
1263 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1264 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
1265 and TYPE is the type (which is known to be struct, union or array).
1267 On most machines, the struct convention is used unless we are
1268 using gcc and the type is of a special size. */
1269 /* As of about 31 Mar 93, GCC was changed to be compatible with the
1270 native compiler. GCC 2.3.3 was the last release that did it the
1271 old way. Since gcc2_compiled was not changed, we have no
1272 way to correctly win in all cases, so we just do the right thing
1273 for gcc1 and for gcc2 after this change. Thus it loses for gcc
1274 2.0-2.3.3. This is somewhat unfortunate, but changing gcc2_compiled
1275 would cause more chaos than dealing with some struct returns being
1279 generic_use_struct_convention (int gcc_p
, struct type
*value_type
)
1281 return !((gcc_p
== 1)
1282 && (TYPE_LENGTH (value_type
) == 1
1283 || TYPE_LENGTH (value_type
) == 2
1284 || TYPE_LENGTH (value_type
) == 4
1285 || TYPE_LENGTH (value_type
) == 8));
1288 /* Return true if the function specified is using the structure returning
1289 convention on this machine to return arguments, or 0 if it is using
1290 the value returning convention. FUNCTION is the value representing
1291 the function, FUNCADDR is the address of the function, and VALUE_TYPE
1292 is the type returned by the function. GCC_P is nonzero if compiled
1297 using_struct_return (struct value
*function
, CORE_ADDR funcaddr
,
1298 struct type
*value_type
, int gcc_p
)
1300 register enum type_code code
= TYPE_CODE (value_type
);
1302 if (code
== TYPE_CODE_ERROR
)
1303 error ("Function return type unknown.");
1305 if (code
== TYPE_CODE_STRUCT
1306 || code
== TYPE_CODE_UNION
1307 || code
== TYPE_CODE_ARRAY
1308 || RETURN_VALUE_ON_STACK (value_type
))
1309 return USE_STRUCT_CONVENTION (gcc_p
, value_type
);
1314 /* Store VAL so it will be returned if a function returns now.
1315 Does not verify that VAL's type matches what the current
1316 function wants to return. */
1319 set_return_value (struct value
*val
)
1321 struct type
*type
= check_typedef (VALUE_TYPE (val
));
1322 register enum type_code code
= TYPE_CODE (type
);
1324 if (code
== TYPE_CODE_ERROR
)
1325 error ("Function return type unknown.");
1327 if (code
== TYPE_CODE_STRUCT
1328 || code
== TYPE_CODE_UNION
) /* FIXME, implement struct return. */
1329 error ("GDB does not support specifying a struct or union return value.");
1331 STORE_RETURN_VALUE (type
, current_regcache
, VALUE_CONTENTS (val
));
1335 _initialize_values (void)
1337 add_cmd ("convenience", no_class
, show_convenience
,
1338 "Debugger convenience (\"$foo\") variables.\n\
1339 These variables are created when you assign them values;\n\
1340 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\
1341 A few convenience variables are given values automatically:\n\
1342 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1343 \"$__\" holds the contents of the last address examined with \"x\".",
1346 add_cmd ("values", no_class
, show_values
,
1347 "Elements of value history around item number IDX (or last ten).",