1 /* Low level packing and unpacking of values for GDB, the GNU Debugger.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
3 1996, 1997, 1998, 1999, 2000
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"
38 /* Prototypes for exported functions. */
40 void _initialize_values (void);
42 /* Prototypes for local functions. */
44 static value_ptr
value_headof (value_ptr
, struct type
*, struct type
*);
46 static void show_values (char *, int);
48 static void show_convenience (char *, int);
51 /* The value-history records all the values printed
52 by print commands during this session. Each chunk
53 records 60 consecutive values. The first chunk on
54 the chain records the most recent values.
55 The total number of values is in value_history_count. */
57 #define VALUE_HISTORY_CHUNK 60
59 struct value_history_chunk
61 struct value_history_chunk
*next
;
62 value_ptr values
[VALUE_HISTORY_CHUNK
];
65 /* Chain of chunks now in use. */
67 static struct value_history_chunk
*value_history_chain
;
69 static int value_history_count
; /* Abs number of last entry stored */
71 /* List of all value objects currently allocated
72 (except for those released by calls to release_value)
73 This is so they can be freed after each command. */
75 static value_ptr all_values
;
77 /* Allocate a value that has the correct length for type TYPE. */
80 allocate_value (struct type
*type
)
82 register value_ptr val
;
83 struct type
*atype
= check_typedef (type
);
85 val
= (struct value
*) xmalloc (sizeof (struct value
) + TYPE_LENGTH (atype
));
86 VALUE_NEXT (val
) = all_values
;
88 VALUE_TYPE (val
) = type
;
89 VALUE_ENCLOSING_TYPE (val
) = type
;
90 VALUE_LVAL (val
) = not_lval
;
91 VALUE_ADDRESS (val
) = 0;
92 VALUE_FRAME (val
) = 0;
93 VALUE_OFFSET (val
) = 0;
94 VALUE_BITPOS (val
) = 0;
95 VALUE_BITSIZE (val
) = 0;
96 VALUE_REGNO (val
) = -1;
98 VALUE_OPTIMIZED_OUT (val
) = 0;
99 VALUE_BFD_SECTION (val
) = NULL
;
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 /* Return a mark in the value chain. All values allocated after the
125 mark is obtained (except for those released) are subject to being freed
126 if a subsequent value_free_to_mark is passed the mark. */
133 /* Free all values allocated since MARK was obtained by value_mark
134 (except for those released). */
136 value_free_to_mark (value_ptr 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)
154 register value_ptr val
, next
;
156 for (val
= all_values
; val
; val
= next
)
158 next
= VALUE_NEXT (val
);
165 /* Remove VAL from the chain all_values
166 so it will not be freed automatically. */
169 release_value (register value_ptr val
)
171 register value_ptr v
;
173 if (all_values
== val
)
175 all_values
= val
->next
;
179 for (v
= all_values
; v
; v
= v
->next
)
189 /* Release all values up to mark */
191 value_release_to_mark (value_ptr mark
)
195 for (val
= next
= all_values
; next
; next
= VALUE_NEXT (next
))
196 if (VALUE_NEXT (next
) == mark
)
198 all_values
= VALUE_NEXT (next
);
199 VALUE_NEXT (next
) = 0;
206 /* Return a copy of the value ARG.
207 It contains the same contents, for same memory address,
208 but it's a different block of storage. */
211 value_copy (value_ptr arg
)
213 register struct type
*encl_type
= VALUE_ENCLOSING_TYPE (arg
);
214 register value_ptr val
= allocate_value (encl_type
);
215 VALUE_TYPE (val
) = VALUE_TYPE (arg
);
216 VALUE_LVAL (val
) = VALUE_LVAL (arg
);
217 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg
);
218 VALUE_OFFSET (val
) = VALUE_OFFSET (arg
);
219 VALUE_BITPOS (val
) = VALUE_BITPOS (arg
);
220 VALUE_BITSIZE (val
) = VALUE_BITSIZE (arg
);
221 VALUE_FRAME (val
) = VALUE_FRAME (arg
);
222 VALUE_REGNO (val
) = VALUE_REGNO (arg
);
223 VALUE_LAZY (val
) = VALUE_LAZY (arg
);
224 VALUE_OPTIMIZED_OUT (val
) = VALUE_OPTIMIZED_OUT (arg
);
225 VALUE_EMBEDDED_OFFSET (val
) = VALUE_EMBEDDED_OFFSET (arg
);
226 VALUE_POINTED_TO_OFFSET (val
) = VALUE_POINTED_TO_OFFSET (arg
);
227 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (arg
);
228 val
->modifiable
= arg
->modifiable
;
229 if (!VALUE_LAZY (val
))
231 memcpy (VALUE_CONTENTS_ALL_RAW (val
), VALUE_CONTENTS_ALL_RAW (arg
),
232 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg
)));
238 /* Access to the value history. */
240 /* Record a new value in the value history.
241 Returns the absolute history index of the entry.
242 Result of -1 indicates the value was not saved; otherwise it is the
243 value history index of this new item. */
246 record_latest_value (value_ptr val
)
250 /* We don't want this value to have anything to do with the inferior anymore.
251 In particular, "set $1 = 50" should not affect the variable from which
252 the value was taken, and fast watchpoints should be able to assume that
253 a value on the value history never changes. */
254 if (VALUE_LAZY (val
))
255 value_fetch_lazy (val
);
256 /* We preserve VALUE_LVAL so that the user can find out where it was fetched
257 from. This is a bit dubious, because then *&$1 does not just return $1
258 but the current contents of that location. c'est la vie... */
262 /* Here we treat value_history_count as origin-zero
263 and applying to the value being stored now. */
265 i
= value_history_count
% VALUE_HISTORY_CHUNK
;
268 register struct value_history_chunk
*new
269 = (struct value_history_chunk
*)
270 xmalloc (sizeof (struct value_history_chunk
));
271 memset (new->values
, 0, sizeof new->values
);
272 new->next
= value_history_chain
;
273 value_history_chain
= new;
276 value_history_chain
->values
[i
] = val
;
278 /* Now we regard value_history_count as origin-one
279 and applying to the value just stored. */
281 return ++value_history_count
;
284 /* Return a copy of the value in the history with sequence number NUM. */
287 access_value_history (int num
)
289 register struct value_history_chunk
*chunk
;
291 register int absnum
= num
;
294 absnum
+= value_history_count
;
299 error ("The history is empty.");
301 error ("There is only one value in the history.");
303 error ("History does not go back to $$%d.", -num
);
305 if (absnum
> value_history_count
)
306 error ("History has not yet reached $%d.", absnum
);
310 /* Now absnum is always absolute and origin zero. */
312 chunk
= value_history_chain
;
313 for (i
= (value_history_count
- 1) / VALUE_HISTORY_CHUNK
- absnum
/ VALUE_HISTORY_CHUNK
;
317 return value_copy (chunk
->values
[absnum
% VALUE_HISTORY_CHUNK
]);
320 /* Clear the value history entirely.
321 Must be done when new symbol tables are loaded,
322 because the type pointers become invalid. */
325 clear_value_history (void)
327 register struct value_history_chunk
*next
;
329 register value_ptr val
;
331 while (value_history_chain
)
333 for (i
= 0; i
< VALUE_HISTORY_CHUNK
; i
++)
334 if ((val
= value_history_chain
->values
[i
]) != NULL
)
336 next
= value_history_chain
->next
;
337 xfree (value_history_chain
);
338 value_history_chain
= next
;
340 value_history_count
= 0;
344 show_values (char *num_exp
, int from_tty
)
347 register value_ptr val
;
352 /* "info history +" should print from the stored position.
353 "info history <exp>" should print around value number <exp>. */
354 if (num_exp
[0] != '+' || num_exp
[1] != '\0')
355 num
= parse_and_eval_long (num_exp
) - 5;
359 /* "info history" means print the last 10 values. */
360 num
= value_history_count
- 9;
366 for (i
= num
; i
< num
+ 10 && i
<= value_history_count
; i
++)
368 val
= access_value_history (i
);
369 printf_filtered ("$%d = ", i
);
370 value_print (val
, gdb_stdout
, 0, Val_pretty_default
);
371 printf_filtered ("\n");
374 /* The next "info history +" should start after what we just printed. */
377 /* Hitting just return after this command should do the same thing as
378 "info history +". If num_exp is null, this is unnecessary, since
379 "info history +" is not useful after "info history". */
380 if (from_tty
&& num_exp
)
387 /* Internal variables. These are variables within the debugger
388 that hold values assigned by debugger commands.
389 The user refers to them with a '$' prefix
390 that does not appear in the variable names stored internally. */
392 static struct internalvar
*internalvars
;
394 /* Look up an internal variable with name NAME. NAME should not
395 normally include a dollar sign.
397 If the specified internal variable does not exist,
398 one is created, with a void value. */
401 lookup_internalvar (char *name
)
403 register struct internalvar
*var
;
405 for (var
= internalvars
; var
; var
= var
->next
)
406 if (STREQ (var
->name
, name
))
409 var
= (struct internalvar
*) xmalloc (sizeof (struct internalvar
));
410 var
->name
= concat (name
, NULL
);
411 var
->value
= allocate_value (builtin_type_void
);
412 release_value (var
->value
);
413 var
->next
= internalvars
;
419 value_of_internalvar (struct internalvar
*var
)
421 register value_ptr val
;
423 #ifdef IS_TRAPPED_INTERNALVAR
424 if (IS_TRAPPED_INTERNALVAR (var
->name
))
425 return VALUE_OF_TRAPPED_INTERNALVAR (var
);
428 val
= value_copy (var
->value
);
429 if (VALUE_LAZY (val
))
430 value_fetch_lazy (val
);
431 VALUE_LVAL (val
) = lval_internalvar
;
432 VALUE_INTERNALVAR (val
) = var
;
437 set_internalvar_component (struct internalvar
*var
, int offset
, int bitpos
,
438 int bitsize
, value_ptr newval
)
440 register char *addr
= VALUE_CONTENTS (var
->value
) + offset
;
442 #ifdef IS_TRAPPED_INTERNALVAR
443 if (IS_TRAPPED_INTERNALVAR (var
->name
))
444 SET_TRAPPED_INTERNALVAR (var
, newval
, bitpos
, bitsize
, offset
);
448 modify_field (addr
, value_as_long (newval
),
451 memcpy (addr
, VALUE_CONTENTS (newval
), TYPE_LENGTH (VALUE_TYPE (newval
)));
455 set_internalvar (struct internalvar
*var
, value_ptr val
)
459 #ifdef IS_TRAPPED_INTERNALVAR
460 if (IS_TRAPPED_INTERNALVAR (var
->name
))
461 SET_TRAPPED_INTERNALVAR (var
, val
, 0, 0, 0);
464 newval
= value_copy (val
);
465 newval
->modifiable
= 1;
467 /* Force the value to be fetched from the target now, to avoid problems
468 later when this internalvar is referenced and the target is gone or
470 if (VALUE_LAZY (newval
))
471 value_fetch_lazy (newval
);
473 /* Begin code which must not call error(). If var->value points to
474 something free'd, an error() obviously leaves a dangling pointer.
475 But we also get a danling pointer if var->value points to
476 something in the value chain (i.e., before release_value is
477 called), because after the error free_all_values will get called before
481 release_value (newval
);
482 /* End code which must not call error(). */
486 internalvar_name (struct internalvar
*var
)
491 /* Free all internalvars. Done when new symtabs are loaded,
492 because that makes the values invalid. */
495 clear_internalvars (void)
497 register struct internalvar
*var
;
502 internalvars
= var
->next
;
510 show_convenience (char *ignore
, int from_tty
)
512 register struct internalvar
*var
;
515 for (var
= internalvars
; var
; var
= var
->next
)
517 #ifdef IS_TRAPPED_INTERNALVAR
518 if (IS_TRAPPED_INTERNALVAR (var
->name
))
525 printf_filtered ("$%s = ", var
->name
);
526 value_print (var
->value
, gdb_stdout
, 0, Val_pretty_default
);
527 printf_filtered ("\n");
530 printf_unfiltered ("No debugger convenience variables now defined.\n\
531 Convenience variables have names starting with \"$\";\n\
532 use \"set\" as in \"set $foo = 5\" to define them.\n");
535 /* Extract a value as a C number (either long or double).
536 Knows how to convert fixed values to double, or
537 floating values to long.
538 Does not deallocate the value. */
541 value_as_long (register value_ptr val
)
543 /* This coerces arrays and functions, which is necessary (e.g.
544 in disassemble_command). It also dereferences references, which
545 I suspect is the most logical thing to do. */
547 return unpack_long (VALUE_TYPE (val
), VALUE_CONTENTS (val
));
551 value_as_double (register value_ptr val
)
556 foo
= unpack_double (VALUE_TYPE (val
), VALUE_CONTENTS (val
), &inv
);
558 error ("Invalid floating value found in program.");
561 /* Extract a value as a C pointer. Does not deallocate the value.
562 Note that val's type may not actually be a pointer; value_as_long
563 handles all the cases. */
565 value_as_address (value_ptr val
)
567 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
568 whether we want this to be true eventually. */
570 /* ADDR_BITS_REMOVE is wrong if we are being called for a
571 non-address (e.g. argument to "signal", "info break", etc.), or
572 for pointers to char, in which the low bits *are* significant. */
573 return ADDR_BITS_REMOVE (value_as_long (val
));
576 /* There are several targets (IA-64, PowerPC, and others) which
577 don't represent pointers to functions as simply the address of
578 the function's entry point. For example, on the IA-64, a
579 function pointer points to a two-word descriptor, generated by
580 the linker, which contains the function's entry point, and the
581 value the IA-64 "global pointer" register should have --- to
582 support position-independent code. The linker generates
583 descriptors only for those functions whose addresses are taken.
585 On such targets, it's difficult for GDB to convert an arbitrary
586 function address into a function pointer; it has to either find
587 an existing descriptor for that function, or call malloc and
588 build its own. On some targets, it is impossible for GDB to
589 build a descriptor at all: the descriptor must contain a jump
590 instruction; data memory cannot be executed; and code memory
593 Upon entry to this function, if VAL is a value of type `function'
594 (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
595 VALUE_ADDRESS (val) is the address of the function. This is what
596 you'll get if you evaluate an expression like `main'. The call
597 to COERCE_ARRAY below actually does all the usual unary
598 conversions, which includes converting values of type `function'
599 to `pointer to function'. This is the challenging conversion
600 discussed above. Then, `unpack_long' will convert that pointer
601 back into an address.
603 So, suppose the user types `disassemble foo' on an architecture
604 with a strange function pointer representation, on which GDB
605 cannot build its own descriptors, and suppose further that `foo'
606 has no linker-built descriptor. The address->pointer conversion
607 will signal an error and prevent the command from running, even
608 though the next step would have been to convert the pointer
609 directly back into the same address.
611 The following shortcut avoids this whole mess. If VAL is a
612 function, just return its address directly. */
613 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FUNC
614 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_METHOD
)
615 return VALUE_ADDRESS (val
);
619 /* Some architectures (e.g. Harvard), map instruction and data
620 addresses onto a single large unified address space. For
621 instance: An architecture may consider a large integer in the
622 range 0x10000000 .. 0x1000ffff to already represent a data
623 addresses (hence not need a pointer to address conversion) while
624 a small integer would still need to be converted integer to
625 pointer to address. Just assume such architectures handle all
626 integer conversions in a single function. */
630 I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we
631 must admonish GDB hackers to make sure its behavior matches the
632 compiler's, whenever possible.
634 In general, I think GDB should evaluate expressions the same way
635 the compiler does. When the user copies an expression out of
636 their source code and hands it to a `print' command, they should
637 get the same value the compiler would have computed. Any
638 deviation from this rule can cause major confusion and annoyance,
639 and needs to be justified carefully. In other words, GDB doesn't
640 really have the freedom to do these conversions in clever and
643 AndrewC pointed out that users aren't complaining about how GDB
644 casts integers to pointers; they are complaining that they can't
645 take an address from a disassembly listing and give it to `x/i'.
646 This is certainly important.
648 Adding an architecture method like INTEGER_TO_ADDRESS certainly
649 makes it possible for GDB to "get it right" in all circumstances
650 --- the target has complete control over how things get done, so
651 people can Do The Right Thing for their target without breaking
652 anyone else. The standard doesn't specify how integers get
653 converted to pointers; usually, the ABI doesn't either, but
654 ABI-specific code is a more reasonable place to handle it. */
656 if (TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_PTR
657 && TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_REF
658 && INTEGER_TO_ADDRESS_P ())
659 return INTEGER_TO_ADDRESS (VALUE_TYPE (val
), VALUE_CONTENTS (val
));
661 return unpack_long (VALUE_TYPE (val
), VALUE_CONTENTS (val
));
665 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
666 as a long, or as a double, assuming the raw data is described
667 by type TYPE. Knows how to convert different sizes of values
668 and can convert between fixed and floating point. We don't assume
669 any alignment for the raw data. Return value is in host byte order.
671 If you want functions and arrays to be coerced to pointers, and
672 references to be dereferenced, call value_as_long() instead.
674 C++: It is assumed that the front-end has taken care of
675 all matters concerning pointers to members. A pointer
676 to member which reaches here is considered to be equivalent
677 to an INT (or some size). After all, it is only an offset. */
680 unpack_long (struct type
*type
, char *valaddr
)
682 register enum type_code code
= TYPE_CODE (type
);
683 register int len
= TYPE_LENGTH (type
);
684 register int nosign
= TYPE_UNSIGNED (type
);
686 if (current_language
->la_language
== language_scm
687 && is_scmvalue_type (type
))
688 return scm_unpack (type
, valaddr
, TYPE_CODE_INT
);
692 case TYPE_CODE_TYPEDEF
:
693 return unpack_long (check_typedef (type
), valaddr
);
698 case TYPE_CODE_RANGE
:
700 return extract_unsigned_integer (valaddr
, len
);
702 return extract_signed_integer (valaddr
, len
);
705 return extract_typed_floating (valaddr
, type
);
709 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
710 whether we want this to be true eventually. */
711 return extract_typed_address (valaddr
, type
);
713 case TYPE_CODE_MEMBER
:
714 error ("not implemented: member types in unpack_long");
717 error ("Value can't be converted to integer.");
719 return 0; /* Placate lint. */
722 /* Return a double value from the specified type and address.
723 INVP points to an int which is set to 0 for valid value,
724 1 for invalid value (bad float format). In either case,
725 the returned double is OK to use. Argument is in target
726 format, result is in host format. */
729 unpack_double (struct type
*type
, char *valaddr
, int *invp
)
735 *invp
= 0; /* Assume valid. */
736 CHECK_TYPEDEF (type
);
737 code
= TYPE_CODE (type
);
738 len
= TYPE_LENGTH (type
);
739 nosign
= TYPE_UNSIGNED (type
);
740 if (code
== TYPE_CODE_FLT
)
743 if (INVALID_FLOAT (valaddr
, len
))
746 return 1.234567891011121314;
749 return extract_typed_floating (valaddr
, type
);
753 /* Unsigned -- be sure we compensate for signed LONGEST. */
754 return (ULONGEST
) unpack_long (type
, valaddr
);
758 /* Signed -- we are OK with unpack_long. */
759 return unpack_long (type
, valaddr
);
763 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
764 as a CORE_ADDR, assuming the raw data is described by type TYPE.
765 We don't assume any alignment for the raw data. Return value is in
768 If you want functions and arrays to be coerced to pointers, and
769 references to be dereferenced, call value_as_address() instead.
771 C++: It is assumed that the front-end has taken care of
772 all matters concerning pointers to members. A pointer
773 to member which reaches here is considered to be equivalent
774 to an INT (or some size). After all, it is only an offset. */
777 unpack_pointer (struct type
*type
, char *valaddr
)
779 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
780 whether we want this to be true eventually. */
781 return unpack_long (type
, valaddr
);
785 /* Get the value of the FIELDN'th field (which must be static) of TYPE. */
788 value_static_field (struct type
*type
, int fieldno
)
792 if (TYPE_FIELD_STATIC_HAS_ADDR (type
, fieldno
))
794 addr
= TYPE_FIELD_STATIC_PHYSADDR (type
, fieldno
);
799 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
800 struct symbol
*sym
= lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
803 /* With some compilers, e.g. HP aCC, static data members are reported
804 as non-debuggable symbols */
805 struct minimal_symbol
*msym
= lookup_minimal_symbol (phys_name
, NULL
, NULL
);
810 addr
= SYMBOL_VALUE_ADDRESS (msym
);
811 sect
= SYMBOL_BFD_SECTION (msym
);
816 /* Anything static that isn't a constant, has an address */
817 if (SYMBOL_CLASS (sym
) != LOC_CONST
)
819 addr
= SYMBOL_VALUE_ADDRESS (sym
);
820 sect
= SYMBOL_BFD_SECTION (sym
);
822 /* However, static const's do not, the value is already known. */
825 return value_from_longest (TYPE_FIELD_TYPE (type
, fieldno
), SYMBOL_VALUE (sym
));
828 SET_FIELD_PHYSADDR (TYPE_FIELD (type
, fieldno
), addr
);
830 return value_at (TYPE_FIELD_TYPE (type
, fieldno
), addr
, sect
);
833 /* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.
834 You have to be careful here, since the size of the data area for the value
835 is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger
836 than the old enclosing type, you have to allocate more space for the data.
837 The return value is a pointer to the new version of this value structure. */
840 value_change_enclosing_type (value_ptr val
, struct type
*new_encl_type
)
842 if (TYPE_LENGTH (new_encl_type
) <= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val
)))
844 VALUE_ENCLOSING_TYPE (val
) = new_encl_type
;
850 register value_ptr prev
;
852 new_val
= (value_ptr
) xrealloc (val
, sizeof (struct value
) + TYPE_LENGTH (new_encl_type
));
854 /* We have to make sure this ends up in the same place in the value
855 chain as the original copy, so it's clean-up behavior is the same.
856 If the value has been released, this is a waste of time, but there
857 is no way to tell that in advance, so... */
859 if (val
!= all_values
)
861 for (prev
= all_values
; prev
!= NULL
; prev
= prev
->next
)
863 if (prev
->next
== val
)
865 prev
->next
= new_val
;
875 /* Given a value ARG1 (offset by OFFSET bytes)
876 of a struct or union type ARG_TYPE,
877 extract and return the value of one of its (non-static) fields.
878 FIELDNO says which field. */
881 value_primitive_field (register value_ptr arg1
, int offset
,
882 register int fieldno
, register struct type
*arg_type
)
884 register value_ptr v
;
885 register struct type
*type
;
887 CHECK_TYPEDEF (arg_type
);
888 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
890 /* Handle packed fields */
892 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
894 v
= value_from_longest (type
,
895 unpack_field_as_long (arg_type
,
896 VALUE_CONTENTS (arg1
)
899 VALUE_BITPOS (v
) = TYPE_FIELD_BITPOS (arg_type
, fieldno
) % 8;
900 VALUE_BITSIZE (v
) = TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
901 VALUE_OFFSET (v
) = VALUE_OFFSET (arg1
) + offset
902 + TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
904 else if (fieldno
< TYPE_N_BASECLASSES (arg_type
))
906 /* This field is actually a base subobject, so preserve the
907 entire object's contents for later references to virtual
909 v
= allocate_value (VALUE_ENCLOSING_TYPE (arg1
));
910 VALUE_TYPE (v
) = type
;
911 if (VALUE_LAZY (arg1
))
914 memcpy (VALUE_CONTENTS_ALL_RAW (v
), VALUE_CONTENTS_ALL_RAW (arg1
),
915 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg1
)));
916 VALUE_OFFSET (v
) = VALUE_OFFSET (arg1
);
917 VALUE_EMBEDDED_OFFSET (v
)
919 VALUE_EMBEDDED_OFFSET (arg1
) +
920 TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
924 /* Plain old data member */
925 offset
+= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
926 v
= allocate_value (type
);
927 if (VALUE_LAZY (arg1
))
930 memcpy (VALUE_CONTENTS_RAW (v
),
931 VALUE_CONTENTS_RAW (arg1
) + offset
,
933 VALUE_OFFSET (v
) = VALUE_OFFSET (arg1
) + offset
934 + VALUE_EMBEDDED_OFFSET (arg1
);
936 VALUE_LVAL (v
) = VALUE_LVAL (arg1
);
937 if (VALUE_LVAL (arg1
) == lval_internalvar
)
938 VALUE_LVAL (v
) = lval_internalvar_component
;
939 VALUE_ADDRESS (v
) = VALUE_ADDRESS (arg1
);
940 VALUE_REGNO (v
) = VALUE_REGNO (arg1
);
941 /* VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
942 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; */
946 /* Given a value ARG1 of a struct or union type,
947 extract and return the value of one of its (non-static) fields.
948 FIELDNO says which field. */
951 value_field (register value_ptr arg1
, register int fieldno
)
953 return value_primitive_field (arg1
, 0, fieldno
, VALUE_TYPE (arg1
));
956 /* Return a non-virtual function as a value.
957 F is the list of member functions which contains the desired method.
958 J is an index into F which provides the desired method.
960 We only use the symbol for its address, so be happy with either a
961 full symbol or a minimal symbol.
965 value_fn_field (value_ptr
*arg1p
, struct fn_field
*f
, int j
, struct type
*type
,
968 register value_ptr v
;
969 register struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
970 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
972 struct minimal_symbol
*msym
;
974 sym
= lookup_symbol (physname
, 0, VAR_NAMESPACE
, 0, NULL
);
981 gdb_assert (sym
== NULL
);
982 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
987 v
= allocate_value (ftype
);
990 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
994 VALUE_ADDRESS (v
) = SYMBOL_VALUE_ADDRESS (msym
);
999 if (type
!= VALUE_TYPE (*arg1p
))
1000 *arg1p
= value_ind (value_cast (lookup_pointer_type (type
),
1001 value_addr (*arg1p
)));
1003 /* Move the `this' pointer according to the offset.
1004 VALUE_OFFSET (*arg1p) += offset;
1011 /* ARG is a pointer to an object we know to be at least
1012 a DTYPE. BTYPE is the most derived basetype that has
1013 already been searched (and need not be searched again).
1014 After looking at the vtables between BTYPE and DTYPE,
1015 return the most derived type we find. The caller must
1016 be satisfied when the return value == DTYPE.
1018 FIXME-tiemann: should work with dossier entries as well.
1019 NOTICE - djb: I see no good reason at all to keep this function now that
1020 we have RTTI support. It's used in literally one place, and it's
1021 hard to keep this function up to date when it's purpose is served
1022 by value_rtti_type efficiently.
1023 Consider it gone for 5.1. */
1026 value_headof (value_ptr in_arg
, struct type
*btype
, struct type
*dtype
)
1028 /* First collect the vtables we must look at for this object. */
1029 value_ptr arg
, vtbl
;
1031 char *demangled_name
;
1032 struct minimal_symbol
*msymbol
;
1034 btype
= TYPE_VPTR_BASETYPE (dtype
);
1035 CHECK_TYPEDEF (btype
);
1038 arg
= value_cast (lookup_pointer_type (btype
), arg
);
1039 if (TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_REF
)
1042 * Copy the value, but change the type from (T&) to (T*).
1043 * We keep the same location information, which is efficient,
1044 * and allows &(&X) to get the location containing the reference.
1046 arg
= value_copy (arg
);
1047 VALUE_TYPE (arg
) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg
)));
1049 if (VALUE_ADDRESS(value_field (value_ind(arg
), TYPE_VPTR_FIELDNO (btype
)))==0)
1052 vtbl
= value_ind (value_field (value_ind (arg
), TYPE_VPTR_FIELDNO (btype
)));
1053 /* Turn vtable into typeinfo function */
1054 VALUE_OFFSET(vtbl
)+=4;
1056 msymbol
= lookup_minimal_symbol_by_pc ( value_as_address(value_ind(vtbl
)) );
1058 || (demangled_name
= SYMBOL_NAME (msymbol
)) == NULL
)
1060 /* If we expected to find a vtable, but did not, let the user
1061 know that we aren't happy, but don't throw an error.
1062 FIXME: there has to be a better way to do this. */
1063 struct type
*error_type
= (struct type
*) xmalloc (sizeof (struct type
));
1064 memcpy (error_type
, VALUE_TYPE (in_arg
), sizeof (struct type
));
1065 TYPE_NAME (error_type
) = savestring ("suspicious *", sizeof ("suspicious *"));
1066 VALUE_TYPE (in_arg
) = error_type
;
1069 demangled_name
= cplus_demangle(demangled_name
,DMGL_ANSI
);
1070 *(strchr (demangled_name
, ' ')) = '\0';
1072 sym
= lookup_symbol (demangled_name
, 0, VAR_NAMESPACE
, 0, 0);
1074 error ("could not find type declaration for `%s'", demangled_name
);
1077 VALUE_TYPE (arg
) = lookup_pointer_type (SYMBOL_TYPE (sym
));
1081 /* ARG is a pointer object of type TYPE. If TYPE has virtual
1082 function tables, probe ARG's tables (including the vtables
1083 of its baseclasses) to figure out the most derived type that ARG
1084 could actually be a pointer to. */
1087 value_from_vtable_info (value_ptr arg
, struct type
*type
)
1089 /* Take care of preliminaries. */
1090 if (TYPE_VPTR_FIELDNO (type
) < 0)
1091 fill_in_vptr_fieldno (type
);
1092 if (TYPE_VPTR_FIELDNO (type
) < 0)
1095 return value_headof (arg
, 0, type
);
1098 /* Return true if the INDEXth field of TYPE is a virtual baseclass
1099 pointer which is for the base class whose type is BASECLASS. */
1102 vb_match (struct type
*type
, int index
, struct type
*basetype
)
1104 struct type
*fieldtype
;
1105 char *name
= TYPE_FIELD_NAME (type
, index
);
1106 char *field_class_name
= NULL
;
1110 /* gcc 2.4 uses _vb$. */
1111 if (name
[1] == 'v' && name
[2] == 'b' && is_cplus_marker (name
[3]))
1112 field_class_name
= name
+ 4;
1113 /* gcc 2.5 will use __vb_. */
1114 if (name
[1] == '_' && name
[2] == 'v' && name
[3] == 'b' && name
[4] == '_')
1115 field_class_name
= name
+ 5;
1117 if (field_class_name
== NULL
)
1118 /* This field is not a virtual base class pointer. */
1121 /* It's a virtual baseclass pointer, now we just need to find out whether
1122 it is for this baseclass. */
1123 fieldtype
= TYPE_FIELD_TYPE (type
, index
);
1124 if (fieldtype
== NULL
1125 || TYPE_CODE (fieldtype
) != TYPE_CODE_PTR
)
1126 /* "Can't happen". */
1129 /* What we check for is that either the types are equal (needed for
1130 nameless types) or have the same name. This is ugly, and a more
1131 elegant solution should be devised (which would probably just push
1132 the ugliness into symbol reading unless we change the stabs format). */
1133 if (TYPE_TARGET_TYPE (fieldtype
) == basetype
)
1136 if (TYPE_NAME (basetype
) != NULL
1137 && TYPE_NAME (TYPE_TARGET_TYPE (fieldtype
)) != NULL
1138 && STREQ (TYPE_NAME (basetype
),
1139 TYPE_NAME (TYPE_TARGET_TYPE (fieldtype
))))
1144 /* Compute the offset of the baseclass which is
1145 the INDEXth baseclass of class TYPE,
1146 for value at VALADDR (in host) at ADDRESS (in target).
1147 The result is the offset of the baseclass value relative
1148 to (the address of)(ARG) + OFFSET.
1150 -1 is returned on error. */
1153 baseclass_offset (struct type
*type
, int index
, char *valaddr
,
1156 struct type
*basetype
= TYPE_BASECLASS (type
, index
);
1158 if (BASETYPE_VIA_VIRTUAL (type
, index
))
1160 /* Must hunt for the pointer to this virtual baseclass. */
1161 register int i
, len
= TYPE_NFIELDS (type
);
1162 register int n_baseclasses
= TYPE_N_BASECLASSES (type
);
1164 /* First look for the virtual baseclass pointer
1166 for (i
= n_baseclasses
; i
< len
; i
++)
1168 if (vb_match (type
, i
, basetype
))
1171 = unpack_pointer (TYPE_FIELD_TYPE (type
, i
),
1172 valaddr
+ (TYPE_FIELD_BITPOS (type
, i
) / 8));
1174 return addr
- (LONGEST
) address
;
1177 /* Not in the fields, so try looking through the baseclasses. */
1178 for (i
= index
+ 1; i
< n_baseclasses
; i
++)
1181 baseclass_offset (type
, i
, valaddr
, address
);
1189 /* Baseclass is easily computed. */
1190 return TYPE_BASECLASS_BITPOS (type
, index
) / 8;
1193 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1196 Extracting bits depends on endianness of the machine. Compute the
1197 number of least significant bits to discard. For big endian machines,
1198 we compute the total number of bits in the anonymous object, subtract
1199 off the bit count from the MSB of the object to the MSB of the
1200 bitfield, then the size of the bitfield, which leaves the LSB discard
1201 count. For little endian machines, the discard count is simply the
1202 number of bits from the LSB of the anonymous object to the LSB of the
1205 If the field is signed, we also do sign extension. */
1208 unpack_field_as_long (struct type
*type
, char *valaddr
, int fieldno
)
1212 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
1213 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
1215 struct type
*field_type
;
1217 val
= extract_unsigned_integer (valaddr
+ bitpos
/ 8, sizeof (val
));
1218 field_type
= TYPE_FIELD_TYPE (type
, fieldno
);
1219 CHECK_TYPEDEF (field_type
);
1221 /* Extract bits. See comment above. */
1223 if (BITS_BIG_ENDIAN
)
1224 lsbcount
= (sizeof val
* 8 - bitpos
% 8 - bitsize
);
1226 lsbcount
= (bitpos
% 8);
1229 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1230 If the field is signed, and is negative, then sign extend. */
1232 if ((bitsize
> 0) && (bitsize
< 8 * (int) sizeof (val
)))
1234 valmask
= (((ULONGEST
) 1) << bitsize
) - 1;
1236 if (!TYPE_UNSIGNED (field_type
))
1238 if (val
& (valmask
^ (valmask
>> 1)))
1247 /* Modify the value of a bitfield. ADDR points to a block of memory in
1248 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1249 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1250 indicate which bits (in target bit order) comprise the bitfield. */
1253 modify_field (char *addr
, LONGEST fieldval
, int bitpos
, int bitsize
)
1257 /* If a negative fieldval fits in the field in question, chop
1258 off the sign extension bits. */
1259 if (bitsize
< (8 * (int) sizeof (fieldval
))
1260 && (~fieldval
& ~((1 << (bitsize
- 1)) - 1)) == 0)
1261 fieldval
= fieldval
& ((1 << bitsize
) - 1);
1263 /* Warn if value is too big to fit in the field in question. */
1264 if (bitsize
< (8 * (int) sizeof (fieldval
))
1265 && 0 != (fieldval
& ~((1 << bitsize
) - 1)))
1267 /* FIXME: would like to include fieldval in the message, but
1268 we don't have a sprintf_longest. */
1269 warning ("Value does not fit in %d bits.", bitsize
);
1271 /* Truncate it, otherwise adjoining fields may be corrupted. */
1272 fieldval
= fieldval
& ((1 << bitsize
) - 1);
1275 oword
= extract_signed_integer (addr
, sizeof oword
);
1277 /* Shifting for bit field depends on endianness of the target machine. */
1278 if (BITS_BIG_ENDIAN
)
1279 bitpos
= sizeof (oword
) * 8 - bitpos
- bitsize
;
1281 /* Mask out old value, while avoiding shifts >= size of oword */
1282 if (bitsize
< 8 * (int) sizeof (oword
))
1283 oword
&= ~(((((ULONGEST
) 1) << bitsize
) - 1) << bitpos
);
1285 oword
&= ~((~(ULONGEST
) 0) << bitpos
);
1286 oword
|= fieldval
<< bitpos
;
1288 store_signed_integer (addr
, sizeof oword
, oword
);
1291 /* Convert C numbers into newly allocated values */
1294 value_from_longest (struct type
*type
, register LONGEST num
)
1296 register value_ptr val
= allocate_value (type
);
1297 register enum type_code code
;
1300 code
= TYPE_CODE (type
);
1301 len
= TYPE_LENGTH (type
);
1305 case TYPE_CODE_TYPEDEF
:
1306 type
= check_typedef (type
);
1309 case TYPE_CODE_CHAR
:
1310 case TYPE_CODE_ENUM
:
1311 case TYPE_CODE_BOOL
:
1312 case TYPE_CODE_RANGE
:
1313 store_signed_integer (VALUE_CONTENTS_RAW (val
), len
, num
);
1318 store_typed_address (VALUE_CONTENTS_RAW (val
), type
, (CORE_ADDR
) num
);
1322 error ("Unexpected type (%d) encountered for integer constant.", code
);
1328 /* Create a value representing a pointer of type TYPE to the address
1331 value_from_pointer (struct type
*type
, CORE_ADDR addr
)
1333 value_ptr val
= allocate_value (type
);
1334 store_typed_address (VALUE_CONTENTS_RAW (val
), type
, addr
);
1339 /* Create a value for a string constant to be stored locally
1340 (not in the inferior's memory space, but in GDB memory).
1341 This is analogous to value_from_longest, which also does not
1342 use inferior memory. String shall NOT contain embedded nulls. */
1345 value_from_string (char *ptr
)
1348 int len
= strlen (ptr
);
1349 int lowbound
= current_language
->string_lower_bound
;
1350 struct type
*rangetype
=
1351 create_range_type ((struct type
*) NULL
,
1353 lowbound
, len
+ lowbound
- 1);
1354 struct type
*stringtype
=
1355 create_array_type ((struct type
*) NULL
,
1356 *current_language
->string_char_type
,
1359 val
= allocate_value (stringtype
);
1360 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, len
);
1365 value_from_double (struct type
*type
, DOUBLEST num
)
1367 register value_ptr val
= allocate_value (type
);
1368 struct type
*base_type
= check_typedef (type
);
1369 register enum type_code code
= TYPE_CODE (base_type
);
1370 register int len
= TYPE_LENGTH (base_type
);
1372 if (code
== TYPE_CODE_FLT
)
1374 store_typed_floating (VALUE_CONTENTS_RAW (val
), base_type
, num
);
1377 error ("Unexpected type encountered for floating constant.");
1382 /* Deal with the value that is "about to be returned". */
1384 /* Return the value that a function returning now
1385 would be returning to its caller, assuming its type is VALTYPE.
1386 RETBUF is where we look for what ought to be the contents
1387 of the registers (in raw form). This is because it is often
1388 desirable to restore old values to those registers
1389 after saving the contents of interest, and then call
1390 this function using the saved values.
1391 struct_return is non-zero when the function in question is
1392 using the structure return conventions on the machine in question;
1393 0 when it is using the value returning conventions (this often
1394 means returning pointer to where structure is vs. returning value). */
1398 value_being_returned (struct type
*valtype
, char *retbuf
, int struct_return
)
1400 register value_ptr val
;
1403 /* If this is not defined, just use EXTRACT_RETURN_VALUE instead. */
1404 if (EXTRACT_STRUCT_VALUE_ADDRESS_P ())
1407 addr
= EXTRACT_STRUCT_VALUE_ADDRESS (retbuf
);
1409 error ("Function return value unknown.");
1410 return value_at (valtype
, addr
, NULL
);
1413 val
= allocate_value (valtype
);
1414 CHECK_TYPEDEF (valtype
);
1415 EXTRACT_RETURN_VALUE (valtype
, retbuf
, VALUE_CONTENTS_RAW (val
));
1420 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1421 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
1422 and TYPE is the type (which is known to be struct, union or array).
1424 On most machines, the struct convention is used unless we are
1425 using gcc and the type is of a special size. */
1426 /* As of about 31 Mar 93, GCC was changed to be compatible with the
1427 native compiler. GCC 2.3.3 was the last release that did it the
1428 old way. Since gcc2_compiled was not changed, we have no
1429 way to correctly win in all cases, so we just do the right thing
1430 for gcc1 and for gcc2 after this change. Thus it loses for gcc
1431 2.0-2.3.3. This is somewhat unfortunate, but changing gcc2_compiled
1432 would cause more chaos than dealing with some struct returns being
1436 generic_use_struct_convention (int gcc_p
, struct type
*value_type
)
1438 return !((gcc_p
== 1)
1439 && (TYPE_LENGTH (value_type
) == 1
1440 || TYPE_LENGTH (value_type
) == 2
1441 || TYPE_LENGTH (value_type
) == 4
1442 || TYPE_LENGTH (value_type
) == 8));
1445 /* Return true if the function specified is using the structure returning
1446 convention on this machine to return arguments, or 0 if it is using
1447 the value returning convention. FUNCTION is the value representing
1448 the function, FUNCADDR is the address of the function, and VALUE_TYPE
1449 is the type returned by the function. GCC_P is nonzero if compiled
1454 using_struct_return (value_ptr function
, CORE_ADDR funcaddr
,
1455 struct type
*value_type
, int gcc_p
)
1457 register enum type_code code
= TYPE_CODE (value_type
);
1459 if (code
== TYPE_CODE_ERROR
)
1460 error ("Function return type unknown.");
1462 if (code
== TYPE_CODE_STRUCT
1463 || code
== TYPE_CODE_UNION
1464 || code
== TYPE_CODE_ARRAY
1465 || RETURN_VALUE_ON_STACK (value_type
))
1466 return USE_STRUCT_CONVENTION (gcc_p
, value_type
);
1471 /* Store VAL so it will be returned if a function returns now.
1472 Does not verify that VAL's type matches what the current
1473 function wants to return. */
1476 set_return_value (value_ptr val
)
1478 struct type
*type
= check_typedef (VALUE_TYPE (val
));
1479 register enum type_code code
= TYPE_CODE (type
);
1481 if (code
== TYPE_CODE_ERROR
)
1482 error ("Function return type unknown.");
1484 if (code
== TYPE_CODE_STRUCT
1485 || code
== TYPE_CODE_UNION
) /* FIXME, implement struct return. */
1486 error ("GDB does not support specifying a struct or union return value.");
1488 STORE_RETURN_VALUE (type
, VALUE_CONTENTS (val
));
1492 _initialize_values (void)
1494 add_cmd ("convenience", no_class
, show_convenience
,
1495 "Debugger convenience (\"$foo\") variables.\n\
1496 These variables are created when you assign them values;\n\
1497 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\
1498 A few convenience variables are given values automatically:\n\
1499 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1500 \"$__\" holds the contents of the last address examined with \"x\".",
1503 add_cmd ("values", no_class
, show_values
,
1504 "Elements of value history around item number IDX (or last ten).",