1 /* Low level packing and unpacking of values for GDB, the GNU Debugger.
2 Copyright 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
32 /* Local function prototypes. */
35 value_headof PARAMS ((value, struct type *, struct type *));
38 show_values PARAMS ((char *, int));
41 show_convenience PARAMS ((char *, int));
43 /* The value-history records all the values printed
44 by print commands during this session. Each chunk
45 records 60 consecutive values. The first chunk on
46 the chain records the most recent values.
47 The total number of values is in value_history_count. */
49 #define VALUE_HISTORY_CHUNK 60
51 struct value_history_chunk
53 struct value_history_chunk *next;
54 value values[VALUE_HISTORY_CHUNK];
57 /* Chain of chunks now in use. */
59 static struct value_history_chunk *value_history_chain;
61 static int value_history_count; /* Abs number of last entry stored */
63 /* List of all value objects currently allocated
64 (except for those released by calls to release_value)
65 This is so they can be freed after each command. */
67 static value all_values;
69 /* Allocate a value that has the correct length for type TYPE. */
77 check_stub_type (type);
79 val = (value) xmalloc (sizeof (struct value) + TYPE_LENGTH (type));
80 VALUE_NEXT (val) = all_values;
82 VALUE_TYPE (val) = type;
83 VALUE_LVAL (val) = not_lval;
84 VALUE_ADDRESS (val) = 0;
85 VALUE_FRAME (val) = 0;
86 VALUE_OFFSET (val) = 0;
87 VALUE_BITPOS (val) = 0;
88 VALUE_BITSIZE (val) = 0;
89 VALUE_REPEATED (val) = 0;
90 VALUE_REPETITIONS (val) = 0;
91 VALUE_REGNO (val) = -1;
93 VALUE_OPTIMIZED_OUT (val) = 0;
97 /* Allocate a value that has the correct length
98 for COUNT repetitions type TYPE. */
101 allocate_repeat_value (type, count)
107 val = (value) xmalloc (sizeof (struct value) + TYPE_LENGTH (type) * count);
108 VALUE_NEXT (val) = all_values;
110 VALUE_TYPE (val) = type;
111 VALUE_LVAL (val) = not_lval;
112 VALUE_ADDRESS (val) = 0;
113 VALUE_FRAME (val) = 0;
114 VALUE_OFFSET (val) = 0;
115 VALUE_BITPOS (val) = 0;
116 VALUE_BITSIZE (val) = 0;
117 VALUE_REPEATED (val) = 1;
118 VALUE_REPETITIONS (val) = count;
119 VALUE_REGNO (val) = -1;
120 VALUE_LAZY (val) = 0;
121 VALUE_OPTIMIZED_OUT (val) = 0;
125 /* Return a mark in the value chain. All values allocated after the
126 mark is obtained (except for those released) are subject to being freed
127 if a subsequent value_free_to_mark is passed the mark. */
134 /* Free all values allocated since MARK was obtained by value_mark
135 (except for those released). */
137 value_free_to_mark (mark)
142 for (val = all_values; val && val != mark; val = next)
144 next = VALUE_NEXT (val);
150 /* Free all the values that have been allocated (except for those released).
151 Called after each command, successful or not. */
156 register value val, next;
158 for (val = all_values; val; val = next)
160 next = VALUE_NEXT (val);
167 /* Remove VAL from the chain all_values
168 so it will not be freed automatically. */
176 if (all_values == val)
178 all_values = val->next;
182 for (v = all_values; v; v = v->next)
192 /* Return a copy of the value ARG.
193 It contains the same contents, for same memory address,
194 but it's a different block of storage. */
201 register struct type *type = VALUE_TYPE (arg);
202 if (VALUE_REPEATED (arg))
203 val = allocate_repeat_value (type, VALUE_REPETITIONS (arg));
205 val = allocate_value (type);
206 VALUE_LVAL (val) = VALUE_LVAL (arg);
207 VALUE_ADDRESS (val) = VALUE_ADDRESS (arg);
208 VALUE_OFFSET (val) = VALUE_OFFSET (arg);
209 VALUE_BITPOS (val) = VALUE_BITPOS (arg);
210 VALUE_BITSIZE (val) = VALUE_BITSIZE (arg);
211 VALUE_REGNO (val) = VALUE_REGNO (arg);
212 VALUE_LAZY (val) = VALUE_LAZY (arg);
213 if (!VALUE_LAZY (val))
215 memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS_RAW (arg),
216 TYPE_LENGTH (VALUE_TYPE (arg))
217 * (VALUE_REPEATED (arg) ? VALUE_REPETITIONS (arg) : 1));
222 /* Access to the value history. */
224 /* Record a new value in the value history.
225 Returns the absolute history index of the entry.
226 Result of -1 indicates the value was not saved; otherwise it is the
227 value history index of this new item. */
230 record_latest_value (val)
235 /* Check error now if about to store an invalid float. We return -1
236 to the caller, but allow them to continue, e.g. to print it as "Nan". */
237 if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT)
239 unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val), &i);
240 if (i) return -1; /* Indicate value not saved in history */
243 /* Here we treat value_history_count as origin-zero
244 and applying to the value being stored now. */
246 i = value_history_count % VALUE_HISTORY_CHUNK;
249 register struct value_history_chunk *new
250 = (struct value_history_chunk *)
251 xmalloc (sizeof (struct value_history_chunk));
252 memset (new->values, 0, sizeof new->values);
253 new->next = value_history_chain;
254 value_history_chain = new;
257 value_history_chain->values[i] = val;
260 /* Now we regard value_history_count as origin-one
261 and applying to the value just stored. */
263 return ++value_history_count;
266 /* Return a copy of the value in the history with sequence number NUM. */
269 access_value_history (num)
272 register struct value_history_chunk *chunk;
274 register int absnum = num;
277 absnum += value_history_count;
282 error ("The history is empty.");
284 error ("There is only one value in the history.");
286 error ("History does not go back to $$%d.", -num);
288 if (absnum > value_history_count)
289 error ("History has not yet reached $%d.", absnum);
293 /* Now absnum is always absolute and origin zero. */
295 chunk = value_history_chain;
296 for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK - absnum / VALUE_HISTORY_CHUNK;
300 return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]);
303 /* Clear the value history entirely.
304 Must be done when new symbol tables are loaded,
305 because the type pointers become invalid. */
308 clear_value_history ()
310 register struct value_history_chunk *next;
314 while (value_history_chain)
316 for (i = 0; i < VALUE_HISTORY_CHUNK; i++)
317 if ((val = value_history_chain->values[i]) != NULL)
319 next = value_history_chain->next;
320 free ((PTR)value_history_chain);
321 value_history_chain = next;
323 value_history_count = 0;
327 show_values (num_exp, from_tty)
337 if (num_exp[0] == '+' && num_exp[1] == '\0')
338 /* "info history +" should print from the stored position. */
341 /* "info history <exp>" should print around value number <exp>. */
342 num = parse_and_eval_address (num_exp) - 5;
346 /* "info history" means print the last 10 values. */
347 num = value_history_count - 9;
353 for (i = num; i < num + 10 && i <= value_history_count; i++)
355 val = access_value_history (i);
356 printf_filtered ("$%d = ", i);
357 value_print (val, stdout, 0, Val_pretty_default);
358 printf_filtered ("\n");
361 /* The next "info history +" should start after what we just printed. */
364 /* Hitting just return after this command should do the same thing as
365 "info history +". If num_exp is null, this is unnecessary, since
366 "info history +" is not useful after "info history". */
367 if (from_tty && num_exp)
374 /* Internal variables. These are variables within the debugger
375 that hold values assigned by debugger commands.
376 The user refers to them with a '$' prefix
377 that does not appear in the variable names stored internally. */
379 static struct internalvar *internalvars;
381 /* Look up an internal variable with name NAME. NAME should not
382 normally include a dollar sign.
384 If the specified internal variable does not exist,
385 one is created, with a void value. */
388 lookup_internalvar (name)
391 register struct internalvar *var;
393 for (var = internalvars; var; var = var->next)
394 if (!strcmp (var->name, name))
397 var = (struct internalvar *) xmalloc (sizeof (struct internalvar));
398 var->name = concat (name, NULL);
399 var->value = allocate_value (builtin_type_void);
400 release_value (var->value);
401 var->next = internalvars;
407 value_of_internalvar (var)
408 struct internalvar *var;
412 #ifdef IS_TRAPPED_INTERNALVAR
413 if (IS_TRAPPED_INTERNALVAR (var->name))
414 return VALUE_OF_TRAPPED_INTERNALVAR (var);
417 val = value_copy (var->value);
418 if (VALUE_LAZY (val))
419 value_fetch_lazy (val);
420 VALUE_LVAL (val) = lval_internalvar;
421 VALUE_INTERNALVAR (val) = var;
426 set_internalvar_component (var, offset, bitpos, bitsize, newval)
427 struct internalvar *var;
428 int offset, bitpos, bitsize;
431 register char *addr = VALUE_CONTENTS (var->value) + offset;
433 #ifdef IS_TRAPPED_INTERNALVAR
434 if (IS_TRAPPED_INTERNALVAR (var->name))
435 SET_TRAPPED_INTERNALVAR (var, newval, bitpos, bitsize, offset);
439 modify_field (addr, (int) value_as_long (newval),
442 memcpy (addr, VALUE_CONTENTS (newval), TYPE_LENGTH (VALUE_TYPE (newval)));
446 set_internalvar (var, val)
447 struct internalvar *var;
450 #ifdef IS_TRAPPED_INTERNALVAR
451 if (IS_TRAPPED_INTERNALVAR (var->name))
452 SET_TRAPPED_INTERNALVAR (var, val, 0, 0, 0);
455 free ((PTR)var->value);
456 var->value = value_copy (val);
457 /* Force the value to be fetched from the target now, to avoid problems
458 later when this internalvar is referenced and the target is gone or
460 if (VALUE_LAZY (var->value))
461 value_fetch_lazy (var->value);
462 release_value (var->value);
466 internalvar_name (var)
467 struct internalvar *var;
472 /* Free all internalvars. Done when new symtabs are loaded,
473 because that makes the values invalid. */
476 clear_internalvars ()
478 register struct internalvar *var;
483 internalvars = var->next;
484 free ((PTR)var->name);
485 free ((PTR)var->value);
491 show_convenience (ignore, from_tty)
495 register struct internalvar *var;
498 for (var = internalvars; var; var = var->next)
500 #ifdef IS_TRAPPED_INTERNALVAR
501 if (IS_TRAPPED_INTERNALVAR (var->name))
508 printf_filtered ("$%s = ", var->name);
509 value_print (var->value, stdout, 0, Val_pretty_default);
510 printf_filtered ("\n");
513 printf ("No debugger convenience variables now defined.\n\
514 Convenience variables have names starting with \"$\";\n\
515 use \"set\" as in \"set $foo = 5\" to define them.\n");
518 /* Extract a value as a C number (either long or double).
519 Knows how to convert fixed values to double, or
520 floating values to long.
521 Does not deallocate the value. */
527 /* This coerces arrays and functions, which is necessary (e.g.
528 in disassemble_command). It also dereferences references, which
529 I suspect is the most logical thing to do. */
530 if (TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_ENUM)
532 return unpack_long (VALUE_TYPE (val), VALUE_CONTENTS (val));
536 value_as_double (val)
542 foo = unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val), &inv);
544 error ("Invalid floating value found in program.");
547 /* Extract a value as a C pointer.
548 Does not deallocate the value. */
550 value_as_pointer (val)
553 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
554 whether we want this to be true eventually. */
555 return ADDR_BITS_REMOVE(value_as_long (val));
558 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
559 as a long, or as a double, assuming the raw data is described
560 by type TYPE. Knows how to convert different sizes of values
561 and can convert between fixed and floating point. We don't assume
562 any alignment for the raw data. Return value is in host byte order.
564 If you want functions and arrays to be coerced to pointers, and
565 references to be dereferenced, call value_as_long() instead.
567 C++: It is assumed that the front-end has taken care of
568 all matters concerning pointers to members. A pointer
569 to member which reaches here is considered to be equivalent
570 to an INT (or some size). After all, it is only an offset. */
572 /* FIXME: This should be rewritten as a switch statement for speed and
573 ease of comprehension. */
576 unpack_long (type, valaddr)
580 register enum type_code code = TYPE_CODE (type);
581 register int len = TYPE_LENGTH (type);
582 register int nosign = TYPE_UNSIGNED (type);
584 if (code == TYPE_CODE_ENUM || code == TYPE_CODE_BOOL)
585 code = TYPE_CODE_INT;
586 if (code == TYPE_CODE_FLT)
588 if (len == sizeof (float))
591 memcpy (&retval, valaddr, sizeof (retval));
592 SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
596 if (len == sizeof (double))
599 memcpy (&retval, valaddr, sizeof (retval));
600 SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
605 error ("Unexpected type of floating point number.");
608 else if (code == TYPE_CODE_INT && nosign)
610 if (len == sizeof (char))
612 unsigned char retval = * (unsigned char *) valaddr;
613 /* SWAP_TARGET_AND_HOST (&retval, sizeof (unsigned char)); */
617 if (len == sizeof (short))
619 unsigned short retval;
620 memcpy (&retval, valaddr, sizeof (retval));
621 SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
625 if (len == sizeof (int))
628 memcpy (&retval, valaddr, sizeof (retval));
629 SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
633 if (len == sizeof (long))
635 unsigned long retval;
636 memcpy (&retval, valaddr, sizeof (retval));
637 SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
641 if (len == sizeof (long long))
643 unsigned long long retval;
644 memcpy (&retval, valaddr, sizeof (retval));
645 SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
651 error ("That operation is not possible on an integer of that size.");
654 else if (code == TYPE_CODE_INT)
656 if (len == sizeof (char))
658 SIGNED char retval; /* plain chars might be unsigned on host */
659 memcpy (&retval, valaddr, sizeof (retval));
660 SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
664 if (len == sizeof (short))
667 memcpy (&retval, valaddr, sizeof (retval));
668 SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
672 if (len == sizeof (int))
675 memcpy (&retval, valaddr, sizeof (retval));
676 SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
680 if (len == sizeof (long))
683 memcpy (&retval, valaddr, sizeof (retval));
684 SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
689 if (len == sizeof (long long))
692 memcpy (&retval, valaddr, sizeof (retval));
693 SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
699 error ("That operation is not possible on an integer of that size.");
702 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
703 whether we want this to be true eventually. */
704 else if (code == TYPE_CODE_PTR
705 || code == TYPE_CODE_REF)
707 if (len == sizeof(long))
709 unsigned long retval;
710 memcpy (&retval, valaddr, sizeof(retval));
711 SWAP_TARGET_AND_HOST (&retval, sizeof(retval));
714 else if (len == sizeof(short))
716 unsigned short retval;
717 memcpy (&retval, valaddr, len);
718 SWAP_TARGET_AND_HOST (&retval, len);
722 else if (code == TYPE_CODE_MEMBER)
723 error ("not implemented: member types in unpack_long");
724 else if (code == TYPE_CODE_CHAR)
725 return *(unsigned char *)valaddr;
727 error ("Value not integer or pointer.");
728 return 0; /* For lint -- never reached */
731 /* Return a double value from the specified type and address.
732 INVP points to an int which is set to 0 for valid value,
733 1 for invalid value (bad float format). In either case,
734 the returned double is OK to use. Argument is in target
735 format, result is in host format. */
738 unpack_double (type, valaddr, invp)
743 register enum type_code code = TYPE_CODE (type);
744 register int len = TYPE_LENGTH (type);
745 register int nosign = TYPE_UNSIGNED (type);
747 *invp = 0; /* Assume valid. */
748 if (code == TYPE_CODE_FLT)
750 if (INVALID_FLOAT (valaddr, len))
753 return 1.234567891011121314;
756 if (len == sizeof (float))
759 memcpy (&retval, valaddr, sizeof (retval));
760 SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
764 if (len == sizeof (double))
767 memcpy (&retval, valaddr, sizeof (retval));
768 SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
773 error ("Unexpected type of floating point number.");
774 return 0; /* Placate lint. */
778 /* Unsigned -- be sure we compensate for signed LONGEST. */
780 return (unsigned long long) unpack_long (type, valaddr);
782 return (unsigned long ) unpack_long (type, valaddr);
785 /* Signed -- we are OK with unpack_long. */
786 return unpack_long (type, valaddr);
790 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
791 as a CORE_ADDR, assuming the raw data is described by type TYPE.
792 We don't assume any alignment for the raw data. Return value is in
795 If you want functions and arrays to be coerced to pointers, and
796 references to be dereferenced, call value_as_pointer() instead.
798 C++: It is assumed that the front-end has taken care of
799 all matters concerning pointers to members. A pointer
800 to member which reaches here is considered to be equivalent
801 to an INT (or some size). After all, it is only an offset. */
804 unpack_pointer (type, valaddr)
809 /* The user should be able to use an int (e.g. 0x7892) in contexts
810 where a pointer is expected. So this doesn't do enough. */
811 register enum type_code code = TYPE_CODE (type);
812 register int len = TYPE_LENGTH (type);
814 if (code == TYPE_CODE_PTR
815 || code == TYPE_CODE_REF)
817 if (len == sizeof (CORE_ADDR))
820 memcpy (&retval, valaddr, sizeof (retval));
821 SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
824 error ("Unrecognized pointer size.");
826 else if (code == TYPE_CODE_MEMBER)
827 error ("not implemented: member types in unpack_pointer");
829 error ("Value is not a pointer.");
830 return 0; /* For lint -- never reached */
832 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
833 whether we want this to be true eventually. */
834 return unpack_long (type, valaddr);
838 /* Given a value ARG1 (offset by OFFSET bytes)
839 of a struct or union type ARG_TYPE,
840 extract and return the value of one of its fields.
841 FIELDNO says which field.
843 For C++, must also be able to return values from static fields */
846 value_primitive_field (arg1, offset, fieldno, arg_type)
849 register int fieldno;
850 register struct type *arg_type;
853 register struct type *type;
855 check_stub_type (arg_type);
856 type = TYPE_FIELD_TYPE (arg_type, fieldno);
858 /* Handle packed fields */
860 offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
861 if (TYPE_FIELD_BITSIZE (arg_type, fieldno))
863 v = value_from_longest (type,
864 unpack_field_as_long (arg_type,
865 VALUE_CONTENTS (arg1),
867 VALUE_BITPOS (v) = TYPE_FIELD_BITPOS (arg_type, fieldno) % 8;
868 VALUE_BITSIZE (v) = TYPE_FIELD_BITSIZE (arg_type, fieldno);
872 v = allocate_value (type);
873 if (VALUE_LAZY (arg1))
876 memcpy (VALUE_CONTENTS_RAW (v), VALUE_CONTENTS_RAW (arg1) + offset,
879 VALUE_LVAL (v) = VALUE_LVAL (arg1);
880 if (VALUE_LVAL (arg1) == lval_internalvar)
881 VALUE_LVAL (v) = lval_internalvar_component;
882 VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1);
883 VALUE_OFFSET (v) = offset + VALUE_OFFSET (arg1);
887 /* Given a value ARG1 of a struct or union type,
888 extract and return the value of one of its fields.
889 FIELDNO says which field.
891 For C++, must also be able to return values from static fields */
894 value_field (arg1, fieldno)
896 register int fieldno;
898 return value_primitive_field (arg1, 0, fieldno, VALUE_TYPE (arg1));
901 /* Return a non-virtual function as a value.
902 F is the list of member functions which contains the desired method.
903 J is an index into F which provides the desired method. */
906 value_fn_field (arg1p, f, j, type, offset)
914 register struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
917 sym = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
918 0, VAR_NAMESPACE, 0, NULL);
919 if (! sym) error ("Internal error: could not find physical method named %s",
920 TYPE_FN_FIELD_PHYSNAME (f, j));
922 v = allocate_value (ftype);
923 VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
924 VALUE_TYPE (v) = ftype;
928 if (type != VALUE_TYPE (*arg1p))
929 *arg1p = value_ind (value_cast (lookup_pointer_type (type),
930 value_addr (*arg1p)));
932 /* Move the `this' pointer according to the offset. */
933 VALUE_OFFSET (*arg1p) += offset;
939 /* Return a virtual function as a value.
940 ARG1 is the object which provides the virtual function
941 table pointer. *ARG1P is side-effected in calling this function.
942 F is the list of member functions which contains the desired virtual
944 J is an index into F which provides the desired virtual function.
946 TYPE is the type in which F is located. */
948 value_virtual_fn_field (arg1p, f, j, type, offset)
956 /* First, get the virtual function table pointer. That comes
957 with a strange type, so cast it to type `pointer to long' (which
958 should serve just fine as a function type). Then, index into
959 the table, and convert final value to appropriate function type. */
960 value entry, vfn, vtbl;
961 value vi = value_from_longest (builtin_type_int,
962 (LONGEST) TYPE_FN_FIELD_VOFFSET (f, j));
963 struct type *fcontext = TYPE_FN_FIELD_FCONTEXT (f, j);
964 struct type *context;
965 if (fcontext == NULL)
966 /* We don't have an fcontext (e.g. the program was compiled with
967 g++ version 1). Try to get the vtbl from the TYPE_VPTR_BASETYPE.
968 This won't work right for multiple inheritance, but at least we
969 should do as well as GDB 3.x did. */
970 fcontext = TYPE_VPTR_BASETYPE (type);
971 context = lookup_pointer_type (fcontext);
972 /* Now context is a pointer to the basetype containing the vtbl. */
973 if (TYPE_TARGET_TYPE (context) != VALUE_TYPE (arg1))
974 arg1 = value_ind (value_cast (context, value_addr (arg1)));
976 context = VALUE_TYPE (arg1);
977 /* Now context is the basetype containing the vtbl. */
979 /* This type may have been defined before its virtual function table
980 was. If so, fill in the virtual function table entry for the
982 if (TYPE_VPTR_FIELDNO (context) < 0)
983 fill_in_vptr_fieldno (context);
985 /* The virtual function table is now an array of structures
986 which have the form { int16 offset, delta; void *pfn; }. */
987 vtbl = value_ind (value_primitive_field (arg1, 0,
988 TYPE_VPTR_FIELDNO (context),
989 TYPE_VPTR_BASETYPE (context)));
991 /* Index into the virtual function table. This is hard-coded because
992 looking up a field is not cheap, and it may be important to save
993 time, e.g. if the user has set a conditional breakpoint calling
994 a virtual function. */
995 entry = value_subscript (vtbl, vi);
997 /* Move the `this' pointer according to the virtual function table. */
998 VALUE_OFFSET (arg1) += value_as_long (value_field (entry, 0)) + offset;
999 if (! VALUE_LAZY (arg1))
1001 VALUE_LAZY (arg1) = 1;
1002 value_fetch_lazy (arg1);
1005 vfn = value_field (entry, 2);
1006 /* Reinstantiate the function pointer with the correct type. */
1007 VALUE_TYPE (vfn) = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j));
1013 /* ARG is a pointer to an object we know to be at least
1014 a DTYPE. BTYPE is the most derived basetype that has
1015 already been searched (and need not be searched again).
1016 After looking at the vtables between BTYPE and DTYPE,
1017 return the most derived type we find. The caller must
1018 be satisfied when the return value == DTYPE.
1020 FIXME-tiemann: should work with dossier entries as well. */
1023 value_headof (arg, btype, dtype)
1025 struct type *btype, *dtype;
1027 /* First collect the vtables we must look at for this object. */
1028 /* FIXME-tiemann: right now, just look at top-most vtable. */
1029 value vtbl, entry, best_entry = 0;
1031 int offset, best_offset = 0;
1033 CORE_ADDR pc_for_sym;
1034 char *demangled_name;
1035 struct minimal_symbol *msymbol;
1037 btype = TYPE_VPTR_BASETYPE (dtype);
1038 check_stub_type (btype);
1040 vtbl = value_cast (lookup_pointer_type (btype), arg);
1043 vtbl = value_ind (value_field (value_ind (vtbl), TYPE_VPTR_FIELDNO (btype)));
1045 /* Check that VTBL looks like it points to a virtual function table. */
1046 msymbol = lookup_minimal_symbol_by_pc (VALUE_ADDRESS (vtbl));
1048 || !VTBL_PREFIX_P (demangled_name = msymbol -> name))
1050 /* If we expected to find a vtable, but did not, let the user
1051 know that we aren't happy, but don't throw an error.
1052 FIXME: there has to be a better way to do this. */
1053 struct type *error_type = (struct type *)xmalloc (sizeof (struct type));
1054 memcpy (error_type, VALUE_TYPE (arg), sizeof (struct type));
1055 TYPE_NAME (error_type) = savestring ("suspicious *", sizeof ("suspicious *"));
1056 VALUE_TYPE (arg) = error_type;
1060 /* Now search through the virtual function table. */
1061 entry = value_ind (vtbl);
1062 nelems = longest_to_int (value_as_long (value_field (entry, 2)));
1063 for (i = 1; i <= nelems; i++)
1065 entry = value_subscript (vtbl, value_from_longest (builtin_type_int,
1067 offset = longest_to_int (value_as_long (value_field (entry, 0)));
1068 /* If we use '<=' we can handle single inheritance
1069 * where all offsets are zero - just use the first entry found. */
1070 if (offset <= best_offset)
1072 best_offset = offset;
1076 /* Move the pointer according to BEST_ENTRY's offset, and figure
1077 out what type we should return as the new pointer. */
1078 if (best_entry == 0)
1080 /* An alternative method (which should no longer be necessary).
1081 * But we leave it in for future use, when we will hopefully
1082 * have optimizes the vtable to use thunks instead of offsets. */
1083 /* Use the name of vtable itself to extract a base type. */
1084 demangled_name += 4; /* Skip _vt$ prefix. */
1088 pc_for_sym = value_as_pointer (value_field (best_entry, 2));
1089 sym = find_pc_function (pc_for_sym);
1090 demangled_name = cplus_demangle (SYMBOL_NAME (sym), DMGL_ANSI);
1091 *(strchr (demangled_name, ':')) = '\0';
1093 sym = lookup_symbol (demangled_name, 0, VAR_NAMESPACE, 0, 0);
1095 error ("could not find type declaration for `%s'", SYMBOL_NAME (sym));
1098 free (demangled_name);
1099 arg = value_add (value_cast (builtin_type_int, arg),
1100 value_field (best_entry, 0));
1102 VALUE_TYPE (arg) = lookup_pointer_type (SYMBOL_TYPE (sym));
1106 /* ARG is a pointer object of type TYPE. If TYPE has virtual
1107 function tables, probe ARG's tables (including the vtables
1108 of its baseclasses) to figure out the most derived type that ARG
1109 could actually be a pointer to. */
1112 value_from_vtable_info (arg, type)
1116 /* Take care of preliminaries. */
1117 if (TYPE_VPTR_FIELDNO (type) < 0)
1118 fill_in_vptr_fieldno (type);
1119 if (TYPE_VPTR_FIELDNO (type) < 0 || VALUE_REPEATED (arg))
1122 return value_headof (arg, 0, type);
1125 /* Compute the offset of the baseclass which is
1126 the INDEXth baseclass of class TYPE, for a value ARG,
1127 wih extra offset of OFFSET.
1128 The result is the offste of the baseclass value relative
1129 to (the address of)(ARG) + OFFSET.
1131 -1 is returned on error. */
1134 baseclass_offset (type, index, arg, offset)
1140 struct type *basetype = TYPE_BASECLASS (type, index);
1142 if (BASETYPE_VIA_VIRTUAL (type, index))
1144 /* Must hunt for the pointer to this virtual baseclass. */
1145 register int i, len = TYPE_NFIELDS (type);
1146 register int n_baseclasses = TYPE_N_BASECLASSES (type);
1147 char *vbase_name, *type_name = type_name_no_tag (basetype);
1149 vbase_name = (char *)alloca (strlen (type_name) + 8);
1150 sprintf (vbase_name, "_vb%c%s", CPLUS_MARKER, type_name);
1151 /* First look for the virtual baseclass pointer
1153 for (i = n_baseclasses; i < len; i++)
1155 if (! strcmp (vbase_name, TYPE_FIELD_NAME (type, i)))
1158 = unpack_pointer (TYPE_FIELD_TYPE (type, i),
1159 VALUE_CONTENTS (arg) + VALUE_OFFSET (arg)
1161 + (TYPE_FIELD_BITPOS (type, i) / 8));
1163 if (VALUE_LVAL (arg) != lval_memory)
1167 (LONGEST) (VALUE_ADDRESS (arg) + VALUE_OFFSET (arg) + offset);
1170 /* Not in the fields, so try looking through the baseclasses. */
1171 for (i = index+1; i < n_baseclasses; i++)
1174 baseclass_offset (type, i, arg, offset);
1182 /* Baseclass is easily computed. */
1183 return TYPE_BASECLASS_BITPOS (type, index) / 8;
1186 /* Compute the address of the baseclass which is
1187 the INDEXth baseclass of class TYPE. The TYPE base
1188 of the object is at VALADDR.
1190 If ERRP is non-NULL, set *ERRP to be the errno code of any error,
1191 or 0 if no error. In that case the return value is not the address
1192 of the baseclasss, but the address which could not be read
1195 /* FIXME Fix remaining uses of baseclass_addr to use baseclass_offset */
1198 baseclass_addr (type, index, valaddr, valuep, errp)
1205 struct type *basetype = TYPE_BASECLASS (type, index);
1210 if (BASETYPE_VIA_VIRTUAL (type, index))
1212 /* Must hunt for the pointer to this virtual baseclass. */
1213 register int i, len = TYPE_NFIELDS (type);
1214 register int n_baseclasses = TYPE_N_BASECLASSES (type);
1215 char *vbase_name, *type_name = type_name_no_tag (basetype);
1217 vbase_name = (char *)alloca (strlen (type_name) + 8);
1218 sprintf (vbase_name, "_vb%c%s", CPLUS_MARKER, type_name);
1219 /* First look for the virtual baseclass pointer
1221 for (i = n_baseclasses; i < len; i++)
1223 if (! strcmp (vbase_name, TYPE_FIELD_NAME (type, i)))
1225 value val = allocate_value (basetype);
1230 = unpack_pointer (TYPE_FIELD_TYPE (type, i),
1231 valaddr + (TYPE_FIELD_BITPOS (type, i) / 8));
1233 status = target_read_memory (addr,
1234 VALUE_CONTENTS_RAW (val),
1235 TYPE_LENGTH (basetype));
1236 VALUE_LVAL (val) = lval_memory;
1237 VALUE_ADDRESS (val) = addr;
1243 release_value (val);
1247 return (char *)addr;
1253 return (char *) VALUE_CONTENTS (val);
1257 /* Not in the fields, so try looking through the baseclasses. */
1258 for (i = index+1; i < n_baseclasses; i++)
1262 baddr = baseclass_addr (type, i, valaddr, valuep, errp);
1272 /* Baseclass is easily computed. */
1275 return valaddr + TYPE_BASECLASS_BITPOS (type, index) / 8;
1278 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1281 Extracting bits depends on endianness of the machine. Compute the
1282 number of least significant bits to discard. For big endian machines,
1283 we compute the total number of bits in the anonymous object, subtract
1284 off the bit count from the MSB of the object to the MSB of the
1285 bitfield, then the size of the bitfield, which leaves the LSB discard
1286 count. For little endian machines, the discard count is simply the
1287 number of bits from the LSB of the anonymous object to the LSB of the
1290 If the field is signed, we also do sign extension. */
1293 unpack_field_as_long (type, valaddr, fieldno)
1298 unsigned LONGEST val;
1299 unsigned LONGEST valmask;
1300 int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
1301 int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
1304 memcpy (&val, valaddr + bitpos / 8, sizeof (val));
1305 SWAP_TARGET_AND_HOST (&val, sizeof (val));
1307 /* Extract bits. See comment above. */
1310 lsbcount = (sizeof val * 8 - bitpos % 8 - bitsize);
1312 lsbcount = (bitpos % 8);
1316 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1317 If the field is signed, and is negative, then sign extend. */
1319 if ((bitsize > 0) && (bitsize < 8 * sizeof (val)))
1321 valmask = (((unsigned LONGEST) 1) << bitsize) - 1;
1323 if (!TYPE_UNSIGNED (TYPE_FIELD_TYPE (type, fieldno)))
1325 if (val & (valmask ^ (valmask >> 1)))
1334 /* Modify the value of a bitfield. ADDR points to a block of memory in
1335 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1336 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1337 indicate which bits (in target bit order) comprise the bitfield. */
1340 modify_field (addr, fieldval, bitpos, bitsize)
1343 int bitpos, bitsize;
1347 /* Reject values too big to fit in the field in question,
1348 otherwise adjoining fields may be corrupted. */
1349 if (bitsize < (8 * sizeof (fieldval))
1350 && 0 != (fieldval & ~((1<<bitsize)-1)))
1351 error ("Value %d does not fit in %d bits.", fieldval, bitsize);
1353 memcpy (&oword, addr, sizeof oword);
1354 SWAP_TARGET_AND_HOST (&oword, sizeof oword); /* To host format */
1356 /* Shifting for bit field depends on endianness of the target machine. */
1358 bitpos = sizeof (oword) * 8 - bitpos - bitsize;
1361 /* Mask out old value, while avoiding shifts >= longword size */
1362 if (bitsize < 8 * sizeof (oword))
1363 oword &= ~(((((unsigned long)1) << bitsize) - 1) << bitpos);
1365 oword &= ~((-1) << bitpos);
1366 oword |= fieldval << bitpos;
1368 SWAP_TARGET_AND_HOST (&oword, sizeof oword); /* To target format */
1369 memcpy (addr, &oword, sizeof oword);
1372 /* Convert C numbers into newly allocated values */
1375 value_from_longest (type, num)
1377 register LONGEST num;
1379 register value val = allocate_value (type);
1380 register enum type_code code = TYPE_CODE (type);
1381 register int len = TYPE_LENGTH (type);
1383 /* FIXME, we assume that pointers have the same form and byte order as
1384 integers, and that all pointers have the same form. */
1385 if (code == TYPE_CODE_INT || code == TYPE_CODE_ENUM ||
1386 code == TYPE_CODE_CHAR || code == TYPE_CODE_PTR ||
1387 code == TYPE_CODE_REF || code == TYPE_CODE_BOOL)
1389 if (len == sizeof (char))
1390 * (char *) VALUE_CONTENTS_RAW (val) = num;
1391 else if (len == sizeof (short))
1392 * (short *) VALUE_CONTENTS_RAW (val) = num;
1393 else if (len == sizeof (int))
1394 * (int *) VALUE_CONTENTS_RAW (val) = num;
1395 else if (len == sizeof (long))
1396 * (long *) VALUE_CONTENTS_RAW (val) = num;
1398 else if (len == sizeof (long long))
1399 * (long long *) VALUE_CONTENTS_RAW (val) = num;
1402 error ("Integer type encountered with unexpected data length.");
1405 error ("Unexpected type encountered for integer constant.");
1407 /* num was in host byte order. So now put the value's contents
1408 into target byte order. */
1409 SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (val), len);
1415 value_from_double (type, num)
1419 register value val = allocate_value (type);
1420 register enum type_code code = TYPE_CODE (type);
1421 register int len = TYPE_LENGTH (type);
1423 if (code == TYPE_CODE_FLT)
1425 if (len == sizeof (float))
1426 * (float *) VALUE_CONTENTS_RAW (val) = num;
1427 else if (len == sizeof (double))
1428 * (double *) VALUE_CONTENTS_RAW (val) = num;
1430 error ("Floating type encountered with unexpected data length.");
1433 error ("Unexpected type encountered for floating constant.");
1435 /* num was in host byte order. So now put the value's contents
1436 into target byte order. */
1437 SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (val), len);
1442 /* Deal with the value that is "about to be returned". */
1444 /* Return the value that a function returning now
1445 would be returning to its caller, assuming its type is VALTYPE.
1446 RETBUF is where we look for what ought to be the contents
1447 of the registers (in raw form). This is because it is often
1448 desirable to restore old values to those registers
1449 after saving the contents of interest, and then call
1450 this function using the saved values.
1451 struct_return is non-zero when the function in question is
1452 using the structure return conventions on the machine in question;
1453 0 when it is using the value returning conventions (this often
1454 means returning pointer to where structure is vs. returning value). */
1457 value_being_returned (valtype, retbuf, struct_return)
1458 register struct type *valtype;
1459 char retbuf[REGISTER_BYTES];
1466 #if defined (EXTRACT_STRUCT_VALUE_ADDRESS)
1467 /* If this is not defined, just use EXTRACT_RETURN_VALUE instead. */
1468 if (struct_return) {
1469 addr = EXTRACT_STRUCT_VALUE_ADDRESS (retbuf);
1471 error ("Function return value unknown");
1472 return value_at (valtype, addr);
1476 val = allocate_value (valtype);
1477 EXTRACT_RETURN_VALUE (valtype, retbuf, VALUE_CONTENTS_RAW (val));
1482 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1483 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
1484 and TYPE is the type (which is known to be struct, union or array).
1486 On most machines, the struct convention is used unless we are
1487 using gcc and the type is of a special size. */
1488 #if !defined (USE_STRUCT_CONVENTION)
1489 #define USE_STRUCT_CONVENTION(gcc_p, type)\
1490 (!((gcc_p) && (TYPE_LENGTH (value_type) == 1 \
1491 || TYPE_LENGTH (value_type) == 2 \
1492 || TYPE_LENGTH (value_type) == 4 \
1493 || TYPE_LENGTH (value_type) == 8 \
1498 /* Return true if the function specified is using the structure returning
1499 convention on this machine to return arguments, or 0 if it is using
1500 the value returning convention. FUNCTION is the value representing
1501 the function, FUNCADDR is the address of the function, and VALUE_TYPE
1502 is the type returned by the function. GCC_P is nonzero if compiled
1506 using_struct_return (function, funcaddr, value_type, gcc_p)
1509 struct type *value_type;
1513 register enum type_code code = TYPE_CODE (value_type);
1515 if (code == TYPE_CODE_ERROR)
1516 error ("Function return type unknown.");
1518 if (code == TYPE_CODE_STRUCT ||
1519 code == TYPE_CODE_UNION ||
1520 code == TYPE_CODE_ARRAY)
1521 return USE_STRUCT_CONVENTION (gcc_p, value_type);
1526 /* Store VAL so it will be returned if a function returns now.
1527 Does not verify that VAL's type matches what the current
1528 function wants to return. */
1531 set_return_value (val)
1534 register enum type_code code = TYPE_CODE (VALUE_TYPE (val));
1538 if (code == TYPE_CODE_ERROR)
1539 error ("Function return type unknown.");
1541 if ( code == TYPE_CODE_STRUCT
1542 || code == TYPE_CODE_UNION) /* FIXME, implement struct return. */
1543 error ("GDB does not support specifying a struct or union return value.");
1545 /* FIXME, this is bogus. We don't know what the return conventions
1546 are, or how values should be promoted.... */
1547 if (code == TYPE_CODE_FLT)
1549 dbuf = value_as_double (val);
1551 STORE_RETURN_VALUE (VALUE_TYPE (val), (char *)&dbuf);
1555 lbuf = value_as_long (val);
1556 STORE_RETURN_VALUE (VALUE_TYPE (val), (char *)&lbuf);
1561 _initialize_values ()
1563 add_cmd ("convenience", no_class, show_convenience,
1564 "Debugger convenience (\"$foo\") variables.\n\
1565 These variables are created when you assign them values;\n\
1566 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\
1567 A few convenience variables are given values automatically:\n\
1568 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1569 \"$__\" holds the contents of the last address examined with \"x\".",
1572 add_cmd ("values", no_class, show_values,
1573 "Elements of value history around item number IDX (or last ten).",