1 /* Low level packing and unpacking of values for GDB, the GNU Debugger.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2002, 2003 Free Software
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 #include "gdb_string.h"
37 #include "gdb_assert.h"
41 /* Prototypes for exported functions. */
43 void _initialize_values (void);
45 /* Prototypes for local functions. */
47 static void show_values (char *, int);
49 static void show_convenience (char *, int);
52 /* The value-history records all the values printed
53 by print commands during this session. Each chunk
54 records 60 consecutive values. The first chunk on
55 the chain records the most recent values.
56 The total number of values is in value_history_count. */
58 #define VALUE_HISTORY_CHUNK 60
60 struct value_history_chunk
62 struct value_history_chunk *next;
63 struct value *values[VALUE_HISTORY_CHUNK];
66 /* Chain of chunks now in use. */
68 static struct value_history_chunk *value_history_chain;
70 static int value_history_count; /* Abs number of last entry stored */
72 /* List of all value objects currently allocated
73 (except for those released by calls to release_value)
74 This is so they can be freed after each command. */
76 static struct value *all_values;
78 /* Allocate a value that has the correct length for type TYPE. */
81 allocate_value (struct type *type)
84 struct type *atype = check_typedef (type);
86 val = (struct value *) xmalloc (sizeof (struct value) + TYPE_LENGTH (atype));
87 VALUE_NEXT (val) = all_values;
89 VALUE_TYPE (val) = type;
90 VALUE_ENCLOSING_TYPE (val) = type;
91 VALUE_LVAL (val) = not_lval;
92 VALUE_ADDRESS (val) = 0;
93 VALUE_FRAME_ID (val) = null_frame_id;
94 VALUE_OFFSET (val) = 0;
95 VALUE_BITPOS (val) = 0;
96 VALUE_BITSIZE (val) = 0;
97 VALUE_REGNO (val) = -1;
99 VALUE_OPTIMIZED_OUT (val) = 0;
100 VALUE_BFD_SECTION (val) = NULL;
101 VALUE_EMBEDDED_OFFSET (val) = 0;
102 VALUE_POINTED_TO_OFFSET (val) = 0;
104 val->initialized = 1; /* Default to initialized. */
108 /* Allocate a value that has the correct length
109 for COUNT repetitions type TYPE. */
112 allocate_repeat_value (struct type *type, int count)
114 int low_bound = current_language->string_lower_bound; /* ??? */
115 /* FIXME-type-allocation: need a way to free this type when we are
117 struct type *range_type
118 = create_range_type ((struct type *) NULL, builtin_type_int,
119 low_bound, count + low_bound - 1);
120 /* FIXME-type-allocation: need a way to free this type when we are
122 return allocate_value (create_array_type ((struct type *) NULL,
126 /* Return a mark in the value chain. All values allocated after the
127 mark is obtained (except for those released) are subject to being freed
128 if a subsequent value_free_to_mark is passed the mark. */
135 /* Free all values allocated since MARK was obtained by value_mark
136 (except for those released). */
138 value_free_to_mark (struct value *mark)
143 for (val = all_values; val && val != mark; val = next)
145 next = VALUE_NEXT (val);
151 /* Free all the values that have been allocated (except for those released).
152 Called after each command, successful or not. */
155 free_all_values (void)
160 for (val = all_values; val; val = next)
162 next = VALUE_NEXT (val);
169 /* Remove VAL from the chain all_values
170 so it will not be freed automatically. */
173 release_value (struct value *val)
177 if (all_values == val)
179 all_values = val->next;
183 for (v = all_values; v; v = v->next)
193 /* Release all values up to mark */
195 value_release_to_mark (struct value *mark)
200 for (val = next = all_values; next; next = VALUE_NEXT (next))
201 if (VALUE_NEXT (next) == mark)
203 all_values = VALUE_NEXT (next);
204 VALUE_NEXT (next) = 0;
211 /* Return a copy of the value ARG.
212 It contains the same contents, for same memory address,
213 but it's a different block of storage. */
216 value_copy (struct value *arg)
218 struct type *encl_type = VALUE_ENCLOSING_TYPE (arg);
219 struct value *val = allocate_value (encl_type);
220 VALUE_TYPE (val) = VALUE_TYPE (arg);
221 VALUE_LVAL (val) = VALUE_LVAL (arg);
222 VALUE_ADDRESS (val) = VALUE_ADDRESS (arg);
223 VALUE_OFFSET (val) = VALUE_OFFSET (arg);
224 VALUE_BITPOS (val) = VALUE_BITPOS (arg);
225 VALUE_BITSIZE (val) = VALUE_BITSIZE (arg);
226 VALUE_FRAME_ID (val) = VALUE_FRAME_ID (arg);
227 VALUE_REGNO (val) = VALUE_REGNO (arg);
228 VALUE_LAZY (val) = VALUE_LAZY (arg);
229 VALUE_OPTIMIZED_OUT (val) = VALUE_OPTIMIZED_OUT (arg);
230 VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (arg);
231 VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (arg);
232 VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (arg);
233 val->modifiable = arg->modifiable;
234 if (!VALUE_LAZY (val))
236 memcpy (VALUE_CONTENTS_ALL_RAW (val), VALUE_CONTENTS_ALL_RAW (arg),
237 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg)));
243 /* Access to the value history. */
245 /* Record a new value in the value history.
246 Returns the absolute history index of the entry.
247 Result of -1 indicates the value was not saved; otherwise it is the
248 value history index of this new item. */
251 record_latest_value (struct value *val)
255 /* We don't want this value to have anything to do with the inferior anymore.
256 In particular, "set $1 = 50" should not affect the variable from which
257 the value was taken, and fast watchpoints should be able to assume that
258 a value on the value history never changes. */
259 if (VALUE_LAZY (val))
260 value_fetch_lazy (val);
261 /* We preserve VALUE_LVAL so that the user can find out where it was fetched
262 from. This is a bit dubious, because then *&$1 does not just return $1
263 but the current contents of that location. c'est la vie... */
267 /* Here we treat value_history_count as origin-zero
268 and applying to the value being stored now. */
270 i = value_history_count % VALUE_HISTORY_CHUNK;
273 struct value_history_chunk *new
274 = (struct value_history_chunk *)
275 xmalloc (sizeof (struct value_history_chunk));
276 memset (new->values, 0, sizeof new->values);
277 new->next = value_history_chain;
278 value_history_chain = new;
281 value_history_chain->values[i] = val;
283 /* Now we regard value_history_count as origin-one
284 and applying to the value just stored. */
286 return ++value_history_count;
289 /* Return a copy of the value in the history with sequence number NUM. */
292 access_value_history (int num)
294 struct value_history_chunk *chunk;
299 absnum += value_history_count;
304 error ("The history is empty.");
306 error ("There is only one value in the history.");
308 error ("History does not go back to $$%d.", -num);
310 if (absnum > value_history_count)
311 error ("History has not yet reached $%d.", absnum);
315 /* Now absnum is always absolute and origin zero. */
317 chunk = value_history_chain;
318 for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK - absnum / VALUE_HISTORY_CHUNK;
322 return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]);
325 /* Clear the value history entirely.
326 Must be done when new symbol tables are loaded,
327 because the type pointers become invalid. */
330 clear_value_history (void)
332 struct value_history_chunk *next;
336 while (value_history_chain)
338 for (i = 0; i < VALUE_HISTORY_CHUNK; i++)
339 if ((val = value_history_chain->values[i]) != NULL)
341 next = value_history_chain->next;
342 xfree (value_history_chain);
343 value_history_chain = next;
345 value_history_count = 0;
349 show_values (char *num_exp, int from_tty)
357 /* "info history +" should print from the stored position.
358 "info history <exp>" should print around value number <exp>. */
359 if (num_exp[0] != '+' || num_exp[1] != '\0')
360 num = parse_and_eval_long (num_exp) - 5;
364 /* "info history" means print the last 10 values. */
365 num = value_history_count - 9;
371 for (i = num; i < num + 10 && i <= value_history_count; i++)
373 val = access_value_history (i);
374 printf_filtered ("$%d = ", i);
375 value_print (val, gdb_stdout, 0, Val_pretty_default);
376 printf_filtered ("\n");
379 /* The next "info history +" should start after what we just printed. */
382 /* Hitting just return after this command should do the same thing as
383 "info history +". If num_exp is null, this is unnecessary, since
384 "info history +" is not useful after "info history". */
385 if (from_tty && num_exp)
392 /* Internal variables. These are variables within the debugger
393 that hold values assigned by debugger commands.
394 The user refers to them with a '$' prefix
395 that does not appear in the variable names stored internally. */
397 static struct internalvar *internalvars;
399 /* Look up an internal variable with name NAME. NAME should not
400 normally include a dollar sign.
402 If the specified internal variable does not exist,
403 one is created, with a void value. */
406 lookup_internalvar (char *name)
408 struct internalvar *var;
410 for (var = internalvars; var; var = var->next)
411 if (strcmp (var->name, name) == 0)
414 var = (struct internalvar *) xmalloc (sizeof (struct internalvar));
415 var->name = concat (name, NULL);
416 var->value = allocate_value (builtin_type_void);
417 release_value (var->value);
418 var->next = internalvars;
424 value_of_internalvar (struct 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, struct value *newval)
440 char *addr = VALUE_CONTENTS (var->value) + offset;
443 modify_field (addr, value_as_long (newval),
446 memcpy (addr, VALUE_CONTENTS (newval), TYPE_LENGTH (VALUE_TYPE (newval)));
450 set_internalvar (struct internalvar *var, struct value *val)
452 struct value *newval;
454 newval = value_copy (val);
455 newval->modifiable = 1;
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 (newval))
461 value_fetch_lazy (newval);
463 /* Begin code which must not call error(). If var->value points to
464 something free'd, an error() obviously leaves a dangling pointer.
465 But we also get a danling pointer if var->value points to
466 something in the value chain (i.e., before release_value is
467 called), because after the error free_all_values will get called before
471 release_value (newval);
472 /* End code which must not call error(). */
476 internalvar_name (struct internalvar *var)
481 /* Free all internalvars. Done when new symtabs are loaded,
482 because that makes the values invalid. */
485 clear_internalvars (void)
487 struct internalvar *var;
492 internalvars = var->next;
500 show_convenience (char *ignore, int from_tty)
502 struct internalvar *var;
505 for (var = internalvars; var; var = var->next)
511 printf_filtered ("$%s = ", var->name);
512 value_print (var->value, gdb_stdout, 0, Val_pretty_default);
513 printf_filtered ("\n");
516 printf_unfiltered ("No debugger convenience variables now defined.\n\
517 Convenience variables have names starting with \"$\";\n\
518 use \"set\" as in \"set $foo = 5\" to define them.\n");
521 /* Extract a value as a C number (either long or double).
522 Knows how to convert fixed values to double, or
523 floating values to long.
524 Does not deallocate the value. */
527 value_as_long (struct value *val)
529 /* This coerces arrays and functions, which is necessary (e.g.
530 in disassemble_command). It also dereferences references, which
531 I suspect is the most logical thing to do. */
533 return unpack_long (VALUE_TYPE (val), VALUE_CONTENTS (val));
537 value_as_double (struct value *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. Does not deallocate the value.
548 Note that val's type may not actually be a pointer; value_as_long
549 handles all the cases. */
551 value_as_address (struct value *val)
553 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
554 whether we want this to be true eventually. */
556 /* ADDR_BITS_REMOVE is wrong if we are being called for a
557 non-address (e.g. argument to "signal", "info break", etc.), or
558 for pointers to char, in which the low bits *are* significant. */
559 return ADDR_BITS_REMOVE (value_as_long (val));
562 /* There are several targets (IA-64, PowerPC, and others) which
563 don't represent pointers to functions as simply the address of
564 the function's entry point. For example, on the IA-64, a
565 function pointer points to a two-word descriptor, generated by
566 the linker, which contains the function's entry point, and the
567 value the IA-64 "global pointer" register should have --- to
568 support position-independent code. The linker generates
569 descriptors only for those functions whose addresses are taken.
571 On such targets, it's difficult for GDB to convert an arbitrary
572 function address into a function pointer; it has to either find
573 an existing descriptor for that function, or call malloc and
574 build its own. On some targets, it is impossible for GDB to
575 build a descriptor at all: the descriptor must contain a jump
576 instruction; data memory cannot be executed; and code memory
579 Upon entry to this function, if VAL is a value of type `function'
580 (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
581 VALUE_ADDRESS (val) is the address of the function. This is what
582 you'll get if you evaluate an expression like `main'. The call
583 to COERCE_ARRAY below actually does all the usual unary
584 conversions, which includes converting values of type `function'
585 to `pointer to function'. This is the challenging conversion
586 discussed above. Then, `unpack_long' will convert that pointer
587 back into an address.
589 So, suppose the user types `disassemble foo' on an architecture
590 with a strange function pointer representation, on which GDB
591 cannot build its own descriptors, and suppose further that `foo'
592 has no linker-built descriptor. The address->pointer conversion
593 will signal an error and prevent the command from running, even
594 though the next step would have been to convert the pointer
595 directly back into the same address.
597 The following shortcut avoids this whole mess. If VAL is a
598 function, just return its address directly. */
599 if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC
600 || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_METHOD)
601 return VALUE_ADDRESS (val);
605 /* Some architectures (e.g. Harvard), map instruction and data
606 addresses onto a single large unified address space. For
607 instance: An architecture may consider a large integer in the
608 range 0x10000000 .. 0x1000ffff to already represent a data
609 addresses (hence not need a pointer to address conversion) while
610 a small integer would still need to be converted integer to
611 pointer to address. Just assume such architectures handle all
612 integer conversions in a single function. */
616 I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we
617 must admonish GDB hackers to make sure its behavior matches the
618 compiler's, whenever possible.
620 In general, I think GDB should evaluate expressions the same way
621 the compiler does. When the user copies an expression out of
622 their source code and hands it to a `print' command, they should
623 get the same value the compiler would have computed. Any
624 deviation from this rule can cause major confusion and annoyance,
625 and needs to be justified carefully. In other words, GDB doesn't
626 really have the freedom to do these conversions in clever and
629 AndrewC pointed out that users aren't complaining about how GDB
630 casts integers to pointers; they are complaining that they can't
631 take an address from a disassembly listing and give it to `x/i'.
632 This is certainly important.
634 Adding an architecture method like INTEGER_TO_ADDRESS certainly
635 makes it possible for GDB to "get it right" in all circumstances
636 --- the target has complete control over how things get done, so
637 people can Do The Right Thing for their target without breaking
638 anyone else. The standard doesn't specify how integers get
639 converted to pointers; usually, the ABI doesn't either, but
640 ABI-specific code is a more reasonable place to handle it. */
642 if (TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_PTR
643 && TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_REF
644 && INTEGER_TO_ADDRESS_P ())
645 return INTEGER_TO_ADDRESS (VALUE_TYPE (val), VALUE_CONTENTS (val));
647 return unpack_long (VALUE_TYPE (val), VALUE_CONTENTS (val));
651 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
652 as a long, or as a double, assuming the raw data is described
653 by type TYPE. Knows how to convert different sizes of values
654 and can convert between fixed and floating point. We don't assume
655 any alignment for the raw data. Return value is in host byte order.
657 If you want functions and arrays to be coerced to pointers, and
658 references to be dereferenced, call value_as_long() instead.
660 C++: It is assumed that the front-end has taken care of
661 all matters concerning pointers to members. A pointer
662 to member which reaches here is considered to be equivalent
663 to an INT (or some size). After all, it is only an offset. */
666 unpack_long (struct type *type, const char *valaddr)
668 enum type_code code = TYPE_CODE (type);
669 int len = TYPE_LENGTH (type);
670 int nosign = TYPE_UNSIGNED (type);
672 if (current_language->la_language == language_scm
673 && is_scmvalue_type (type))
674 return scm_unpack (type, valaddr, TYPE_CODE_INT);
678 case TYPE_CODE_TYPEDEF:
679 return unpack_long (check_typedef (type), valaddr);
684 case TYPE_CODE_RANGE:
686 return extract_unsigned_integer (valaddr, len);
688 return extract_signed_integer (valaddr, len);
691 return extract_typed_floating (valaddr, type);
695 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
696 whether we want this to be true eventually. */
697 return extract_typed_address (valaddr, type);
699 case TYPE_CODE_MEMBER:
700 error ("not implemented: member types in unpack_long");
703 error ("Value can't be converted to integer.");
705 return 0; /* Placate lint. */
708 /* Return a double value from the specified type and address.
709 INVP points to an int which is set to 0 for valid value,
710 1 for invalid value (bad float format). In either case,
711 the returned double is OK to use. Argument is in target
712 format, result is in host format. */
715 unpack_double (struct type *type, const char *valaddr, int *invp)
721 *invp = 0; /* Assume valid. */
722 CHECK_TYPEDEF (type);
723 code = TYPE_CODE (type);
724 len = TYPE_LENGTH (type);
725 nosign = TYPE_UNSIGNED (type);
726 if (code == TYPE_CODE_FLT)
728 /* NOTE: cagney/2002-02-19: There was a test here to see if the
729 floating-point value was valid (using the macro
730 INVALID_FLOAT). That test/macro have been removed.
732 It turns out that only the VAX defined this macro and then
733 only in a non-portable way. Fixing the portability problem
734 wouldn't help since the VAX floating-point code is also badly
735 bit-rotten. The target needs to add definitions for the
736 methods TARGET_FLOAT_FORMAT and TARGET_DOUBLE_FORMAT - these
737 exactly describe the target floating-point format. The
738 problem here is that the corresponding floatformat_vax_f and
739 floatformat_vax_d values these methods should be set to are
740 also not defined either. Oops!
742 Hopefully someone will add both the missing floatformat
743 definitions and the new cases for floatformat_is_valid (). */
745 if (!floatformat_is_valid (floatformat_from_type (type), valaddr))
751 return extract_typed_floating (valaddr, type);
755 /* Unsigned -- be sure we compensate for signed LONGEST. */
756 return (ULONGEST) unpack_long (type, valaddr);
760 /* Signed -- we are OK with unpack_long. */
761 return unpack_long (type, valaddr);
765 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
766 as a CORE_ADDR, assuming the raw data is described by type TYPE.
767 We don't assume any alignment for the raw data. Return value is in
770 If you want functions and arrays to be coerced to pointers, and
771 references to be dereferenced, call value_as_address() instead.
773 C++: It is assumed that the front-end has taken care of
774 all matters concerning pointers to members. A pointer
775 to member which reaches here is considered to be equivalent
776 to an INT (or some size). After all, it is only an offset. */
779 unpack_pointer (struct type *type, const char *valaddr)
781 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
782 whether we want this to be true eventually. */
783 return unpack_long (type, valaddr);
787 /* Get the value of the FIELDN'th field (which must be static) of
788 TYPE. Return NULL if the field doesn't exist or has been
792 value_static_field (struct type *type, int fieldno)
794 struct value *retval;
796 if (TYPE_FIELD_STATIC_HAS_ADDR (type, fieldno))
798 retval = value_at (TYPE_FIELD_TYPE (type, fieldno),
799 TYPE_FIELD_STATIC_PHYSADDR (type, fieldno),
804 char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
805 struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0, NULL);
808 /* With some compilers, e.g. HP aCC, static data members are reported
809 as non-debuggable symbols */
810 struct minimal_symbol *msym = lookup_minimal_symbol (phys_name, NULL, NULL);
815 retval = value_at (TYPE_FIELD_TYPE (type, fieldno),
816 SYMBOL_VALUE_ADDRESS (msym),
817 SYMBOL_BFD_SECTION (msym));
822 /* SYM should never have a SYMBOL_CLASS which will require
823 read_var_value to use the FRAME parameter. */
824 if (symbol_read_needs_frame (sym))
825 warning ("static field's value depends on the current "
826 "frame - bad debug info?");
827 retval = read_var_value (sym, NULL);
829 if (retval && VALUE_LVAL (retval) == lval_memory)
830 SET_FIELD_PHYSADDR (TYPE_FIELD (type, fieldno),
831 VALUE_ADDRESS (retval));
836 /* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.
837 You have to be careful here, since the size of the data area for the value
838 is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger
839 than the old enclosing type, you have to allocate more space for the data.
840 The return value is a pointer to the new version of this value structure. */
843 value_change_enclosing_type (struct value *val, struct type *new_encl_type)
845 if (TYPE_LENGTH (new_encl_type) <= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val)))
847 VALUE_ENCLOSING_TYPE (val) = new_encl_type;
852 struct value *new_val;
855 new_val = (struct value *) xrealloc (val, sizeof (struct value) + TYPE_LENGTH (new_encl_type));
857 VALUE_ENCLOSING_TYPE (new_val) = new_encl_type;
859 /* We have to make sure this ends up in the same place in the value
860 chain as the original copy, so it's clean-up behavior is the same.
861 If the value has been released, this is a waste of time, but there
862 is no way to tell that in advance, so... */
864 if (val != all_values)
866 for (prev = all_values; prev != NULL; prev = prev->next)
868 if (prev->next == val)
870 prev->next = new_val;
880 /* Given a value ARG1 (offset by OFFSET bytes)
881 of a struct or union type ARG_TYPE,
882 extract and return the value of one of its (non-static) fields.
883 FIELDNO says which field. */
886 value_primitive_field (struct value *arg1, int offset,
887 int fieldno, struct type *arg_type)
892 CHECK_TYPEDEF (arg_type);
893 type = TYPE_FIELD_TYPE (arg_type, fieldno);
895 /* Handle packed fields */
897 if (TYPE_FIELD_BITSIZE (arg_type, fieldno))
899 v = value_from_longest (type,
900 unpack_field_as_long (arg_type,
901 VALUE_CONTENTS (arg1)
904 VALUE_BITPOS (v) = TYPE_FIELD_BITPOS (arg_type, fieldno) % 8;
905 VALUE_BITSIZE (v) = TYPE_FIELD_BITSIZE (arg_type, fieldno);
906 VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
907 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
909 else if (fieldno < TYPE_N_BASECLASSES (arg_type))
911 /* This field is actually a base subobject, so preserve the
912 entire object's contents for later references to virtual
914 v = allocate_value (VALUE_ENCLOSING_TYPE (arg1));
915 VALUE_TYPE (v) = type;
916 if (VALUE_LAZY (arg1))
919 memcpy (VALUE_CONTENTS_ALL_RAW (v), VALUE_CONTENTS_ALL_RAW (arg1),
920 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg1)));
921 VALUE_OFFSET (v) = VALUE_OFFSET (arg1);
922 VALUE_EMBEDDED_OFFSET (v)
924 VALUE_EMBEDDED_OFFSET (arg1) +
925 TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
929 /* Plain old data member */
930 offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
931 v = allocate_value (type);
932 if (VALUE_LAZY (arg1))
935 memcpy (VALUE_CONTENTS_RAW (v),
936 VALUE_CONTENTS_RAW (arg1) + offset,
938 VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
939 + VALUE_EMBEDDED_OFFSET (arg1);
941 VALUE_LVAL (v) = VALUE_LVAL (arg1);
942 if (VALUE_LVAL (arg1) == lval_internalvar)
943 VALUE_LVAL (v) = lval_internalvar_component;
944 VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1);
945 VALUE_REGNO (v) = VALUE_REGNO (arg1);
946 /* VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
947 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; */
951 /* Given a value ARG1 of a struct or union type,
952 extract and return the value of one of its (non-static) fields.
953 FIELDNO says which field. */
956 value_field (struct value *arg1, int fieldno)
958 return value_primitive_field (arg1, 0, fieldno, VALUE_TYPE (arg1));
961 /* Return a non-virtual function as a value.
962 F is the list of member functions which contains the desired method.
963 J is an index into F which provides the desired method.
965 We only use the symbol for its address, so be happy with either a
966 full symbol or a minimal symbol.
970 value_fn_field (struct value **arg1p, struct fn_field *f, int j, struct type *type,
974 struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
975 char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
977 struct minimal_symbol *msym;
979 sym = lookup_symbol (physname, 0, VAR_DOMAIN, 0, NULL);
986 gdb_assert (sym == NULL);
987 msym = lookup_minimal_symbol (physname, NULL, NULL);
992 v = allocate_value (ftype);
995 VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
999 VALUE_ADDRESS (v) = SYMBOL_VALUE_ADDRESS (msym);
1004 if (type != VALUE_TYPE (*arg1p))
1005 *arg1p = value_ind (value_cast (lookup_pointer_type (type),
1006 value_addr (*arg1p)));
1008 /* Move the `this' pointer according to the offset.
1009 VALUE_OFFSET (*arg1p) += offset;
1017 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1020 Extracting bits depends on endianness of the machine. Compute the
1021 number of least significant bits to discard. For big endian machines,
1022 we compute the total number of bits in the anonymous object, subtract
1023 off the bit count from the MSB of the object to the MSB of the
1024 bitfield, then the size of the bitfield, which leaves the LSB discard
1025 count. For little endian machines, the discard count is simply the
1026 number of bits from the LSB of the anonymous object to the LSB of the
1029 If the field is signed, we also do sign extension. */
1032 unpack_field_as_long (struct type *type, const char *valaddr, int fieldno)
1036 int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
1037 int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
1039 struct type *field_type;
1041 val = extract_unsigned_integer (valaddr + bitpos / 8, sizeof (val));
1042 field_type = TYPE_FIELD_TYPE (type, fieldno);
1043 CHECK_TYPEDEF (field_type);
1045 /* Extract bits. See comment above. */
1047 if (BITS_BIG_ENDIAN)
1048 lsbcount = (sizeof val * 8 - bitpos % 8 - bitsize);
1050 lsbcount = (bitpos % 8);
1053 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1054 If the field is signed, and is negative, then sign extend. */
1056 if ((bitsize > 0) && (bitsize < 8 * (int) sizeof (val)))
1058 valmask = (((ULONGEST) 1) << bitsize) - 1;
1060 if (!TYPE_UNSIGNED (field_type))
1062 if (val & (valmask ^ (valmask >> 1)))
1071 /* Modify the value of a bitfield. ADDR points to a block of memory in
1072 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1073 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1074 indicate which bits (in target bit order) comprise the bitfield. */
1077 modify_field (char *addr, LONGEST fieldval, int bitpos, int bitsize)
1081 /* If a negative fieldval fits in the field in question, chop
1082 off the sign extension bits. */
1083 if (bitsize < (8 * (int) sizeof (fieldval))
1084 && (~fieldval & ~((1 << (bitsize - 1)) - 1)) == 0)
1085 fieldval = fieldval & ((1 << bitsize) - 1);
1087 /* Warn if value is too big to fit in the field in question. */
1088 if (bitsize < (8 * (int) sizeof (fieldval))
1089 && 0 != (fieldval & ~((1 << bitsize) - 1)))
1091 /* FIXME: would like to include fieldval in the message, but
1092 we don't have a sprintf_longest. */
1093 warning ("Value does not fit in %d bits.", bitsize);
1095 /* Truncate it, otherwise adjoining fields may be corrupted. */
1096 fieldval = fieldval & ((1 << bitsize) - 1);
1099 oword = extract_signed_integer (addr, sizeof oword);
1101 /* Shifting for bit field depends on endianness of the target machine. */
1102 if (BITS_BIG_ENDIAN)
1103 bitpos = sizeof (oword) * 8 - bitpos - bitsize;
1105 /* Mask out old value, while avoiding shifts >= size of oword */
1106 if (bitsize < 8 * (int) sizeof (oword))
1107 oword &= ~(((((ULONGEST) 1) << bitsize) - 1) << bitpos);
1109 oword &= ~((~(ULONGEST) 0) << bitpos);
1110 oword |= fieldval << bitpos;
1112 store_signed_integer (addr, sizeof oword, oword);
1115 /* Convert C numbers into newly allocated values */
1118 value_from_longest (struct type *type, LONGEST num)
1120 struct value *val = allocate_value (type);
1121 enum type_code code;
1124 code = TYPE_CODE (type);
1125 len = TYPE_LENGTH (type);
1129 case TYPE_CODE_TYPEDEF:
1130 type = check_typedef (type);
1133 case TYPE_CODE_CHAR:
1134 case TYPE_CODE_ENUM:
1135 case TYPE_CODE_BOOL:
1136 case TYPE_CODE_RANGE:
1137 store_signed_integer (VALUE_CONTENTS_RAW (val), len, num);
1142 store_typed_address (VALUE_CONTENTS_RAW (val), type, (CORE_ADDR) num);
1146 error ("Unexpected type (%d) encountered for integer constant.", code);
1152 /* Create a value representing a pointer of type TYPE to the address
1155 value_from_pointer (struct type *type, CORE_ADDR addr)
1157 struct value *val = allocate_value (type);
1158 store_typed_address (VALUE_CONTENTS_RAW (val), type, addr);
1163 /* Create a value for a string constant to be stored locally
1164 (not in the inferior's memory space, but in GDB memory).
1165 This is analogous to value_from_longest, which also does not
1166 use inferior memory. String shall NOT contain embedded nulls. */
1169 value_from_string (char *ptr)
1172 int len = strlen (ptr);
1173 int lowbound = current_language->string_lower_bound;
1174 struct type *rangetype =
1175 create_range_type ((struct type *) NULL,
1177 lowbound, len + lowbound - 1);
1178 struct type *stringtype =
1179 create_array_type ((struct type *) NULL,
1180 *current_language->string_char_type,
1183 val = allocate_value (stringtype);
1184 memcpy (VALUE_CONTENTS_RAW (val), ptr, len);
1189 value_from_double (struct type *type, DOUBLEST num)
1191 struct value *val = allocate_value (type);
1192 struct type *base_type = check_typedef (type);
1193 enum type_code code = TYPE_CODE (base_type);
1194 int len = TYPE_LENGTH (base_type);
1196 if (code == TYPE_CODE_FLT)
1198 store_typed_floating (VALUE_CONTENTS_RAW (val), base_type, num);
1201 error ("Unexpected type encountered for floating constant.");
1206 /* Deal with the return-value of a function that has "just returned".
1208 Extract the return-value (as a "struct value") that a function,
1209 using register convention, has just returned to its caller. Assume
1210 that the type of the function is VALTYPE, and that the "just
1211 returned" register state is found in RETBUF.
1213 The function has "just returned" because GDB halts a returning
1214 function by setting a breakpoint at the return address (in the
1215 caller), and not the return instruction (in the callee).
1217 Because, in the case of a return from an inferior function call,
1218 GDB needs to restore the inferiors registers, RETBUF is normally a
1219 copy of the inferior's registers. */
1222 register_value_being_returned (struct type *valtype, struct regcache *retbuf)
1224 struct value *val = allocate_value (valtype);
1226 /* If the function returns void, don't bother fetching the return
1227 value. See also "using_struct_return". */
1228 if (TYPE_CODE (valtype) == TYPE_CODE_VOID)
1231 if (!gdbarch_return_value_p (current_gdbarch))
1233 /* NOTE: cagney/2003-10-20: Unlike "gdbarch_return_value", the
1234 EXTRACT_RETURN_VALUE and USE_STRUCT_CONVENTION methods do not
1235 handle the edge case of a function returning a small
1236 structure / union in registers. */
1237 CHECK_TYPEDEF (valtype);
1238 EXTRACT_RETURN_VALUE (valtype, retbuf, VALUE_CONTENTS_RAW (val));
1242 /* This function only handles "register convention". */
1243 gdb_assert (gdbarch_return_value (current_gdbarch, valtype,
1245 == RETURN_VALUE_REGISTER_CONVENTION);
1246 gdbarch_return_value (current_gdbarch, valtype, retbuf,
1247 VALUE_CONTENTS_RAW (val) /*read*/, NULL /*write*/);
1251 /* Should we use DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS instead of
1252 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc and TYPE
1253 is the type (which is known to be struct, union or array).
1255 On most machines, the struct convention is used unless we are
1256 using gcc and the type is of a special size. */
1257 /* As of about 31 Mar 93, GCC was changed to be compatible with the
1258 native compiler. GCC 2.3.3 was the last release that did it the
1259 old way. Since gcc2_compiled was not changed, we have no
1260 way to correctly win in all cases, so we just do the right thing
1261 for gcc1 and for gcc2 after this change. Thus it loses for gcc
1262 2.0-2.3.3. This is somewhat unfortunate, but changing gcc2_compiled
1263 would cause more chaos than dealing with some struct returns being
1267 generic_use_struct_convention (int gcc_p, struct type *value_type)
1269 return !((gcc_p == 1)
1270 && (TYPE_LENGTH (value_type) == 1
1271 || TYPE_LENGTH (value_type) == 2
1272 || TYPE_LENGTH (value_type) == 4
1273 || TYPE_LENGTH (value_type) == 8));
1276 /* Return true if the function returning the specified type is using
1277 the convention of returning structures in memory (passing in the
1278 address as a hidden first parameter). GCC_P is nonzero if compiled
1282 using_struct_return (struct type *value_type, int gcc_p)
1284 enum type_code code = TYPE_CODE (value_type);
1286 if (code == TYPE_CODE_ERROR)
1287 error ("Function return type unknown.");
1289 if (code == TYPE_CODE_VOID)
1290 /* A void return value is never in memory. See also corresponding
1291 code in "register_value_being_returned". */
1294 if (!gdbarch_return_value_p (current_gdbarch))
1296 /* FIXME: cagney/2003-10-01: The below is dead. Instead an
1297 architecture should implement "gdbarch_return_value". Using
1298 that new function it is possible to exactly specify the ABIs
1299 "struct return" vs "register return" conventions. */
1300 if (code == TYPE_CODE_STRUCT
1301 || code == TYPE_CODE_UNION
1302 || code == TYPE_CODE_ARRAY
1303 || RETURN_VALUE_ON_STACK (value_type))
1304 return USE_STRUCT_CONVENTION (gcc_p, value_type);
1309 /* Probe the architecture for the return-value convention. */
1310 return (gdbarch_return_value (current_gdbarch, value_type,
1312 == RETURN_VALUE_STRUCT_CONVENTION);
1315 /* Set the initialized field in a value struct. */
1318 set_value_initialized (struct value *val, int status)
1320 val->initialized = status;
1323 /* Return the initialized field in a value struct. */
1326 value_initialized (struct value *val)
1328 return val->initialized;
1332 _initialize_values (void)
1334 add_cmd ("convenience", no_class, show_convenience,
1335 "Debugger convenience (\"$foo\") variables.\n\
1336 These variables are created when you assign them values;\n\
1337 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\
1338 A few convenience variables are given values automatically:\n\
1339 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1340 \"$__\" holds the contents of the last address examined with \"x\".",
1343 add_cmd ("values", no_class, show_values,
1344 "Elements of value history around item number IDX (or last ten).",