1 /* Low level packing and unpacking of values for GDB, the GNU Debugger.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005 Free
5 Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 #include "gdb_string.h"
37 #include "gdb_assert.h"
41 /* Prototypes for exported functions. */
43 void _initialize_values (void);
45 /* Prototypes for local functions. */
47 static void show_values (char *, int);
49 static void show_convenience (char *, int);
52 /* The value-history records all the values printed
53 by print commands during this session. Each chunk
54 records 60 consecutive values. The first chunk on
55 the chain records the most recent values.
56 The total number of values is in value_history_count. */
58 #define VALUE_HISTORY_CHUNK 60
60 struct value_history_chunk
62 struct value_history_chunk
*next
;
63 struct value
*values
[VALUE_HISTORY_CHUNK
];
66 /* Chain of chunks now in use. */
68 static struct value_history_chunk
*value_history_chain
;
70 static int value_history_count
; /* Abs number of last entry stored */
72 /* List of all value objects currently allocated
73 (except for those released by calls to release_value)
74 This is so they can be freed after each command. */
76 static struct value
*all_values
;
78 /* Allocate a value that has the correct length for type TYPE. */
81 allocate_value (struct type
*type
)
84 struct type
*atype
= check_typedef (type
);
86 val
= (struct value
*) xmalloc (sizeof (struct value
) + TYPE_LENGTH (atype
));
87 val
->next
= all_values
;
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
;
97 VALUE_REGNUM (val
) = -1;
99 VALUE_OPTIMIZED_OUT (val
) = 0;
100 VALUE_EMBEDDED_OFFSET (val
) = 0;
101 VALUE_POINTED_TO_OFFSET (val
) = 0;
106 /* Allocate a value that has the correct length
107 for COUNT repetitions type TYPE. */
110 allocate_repeat_value (struct type
*type
, int count
)
112 int low_bound
= current_language
->string_lower_bound
; /* ??? */
113 /* FIXME-type-allocation: need a way to free this type when we are
115 struct type
*range_type
116 = create_range_type ((struct type
*) NULL
, builtin_type_int
,
117 low_bound
, count
+ low_bound
- 1);
118 /* FIXME-type-allocation: need a way to free this type when we are
120 return allocate_value (create_array_type ((struct type
*) NULL
,
124 /* Accessor methods. */
127 value_type (struct value
*value
)
133 value_offset (struct value
*value
)
135 return value
->offset
;
139 value_bitpos (struct value
*value
)
141 return value
->bitpos
;
145 value_bitsize (struct value
*value
)
147 return value
->bitsize
;
151 value_contents_raw (struct value
*value
)
153 return value
->aligner
.contents
+ value
->embedded_offset
;
157 value_contents_all_raw (struct value
*value
)
159 return value
->aligner
.contents
;
163 /* Return a mark in the value chain. All values allocated after the
164 mark is obtained (except for those released) are subject to being freed
165 if a subsequent value_free_to_mark is passed the mark. */
172 /* Free all values allocated since MARK was obtained by value_mark
173 (except for those released). */
175 value_free_to_mark (struct value
*mark
)
180 for (val
= all_values
; val
&& val
!= mark
; val
= next
)
188 /* Free all the values that have been allocated (except for those released).
189 Called after each command, successful or not. */
192 free_all_values (void)
197 for (val
= all_values
; val
; val
= next
)
206 /* Remove VAL from the chain all_values
207 so it will not be freed automatically. */
210 release_value (struct value
*val
)
214 if (all_values
== val
)
216 all_values
= val
->next
;
220 for (v
= all_values
; v
; v
= v
->next
)
230 /* Release all values up to mark */
232 value_release_to_mark (struct value
*mark
)
237 for (val
= next
= all_values
; next
; next
= next
->next
)
238 if (next
->next
== mark
)
240 all_values
= next
->next
;
248 /* Return a copy of the value ARG.
249 It contains the same contents, for same memory address,
250 but it's a different block of storage. */
253 value_copy (struct value
*arg
)
255 struct type
*encl_type
= VALUE_ENCLOSING_TYPE (arg
);
256 struct value
*val
= allocate_value (encl_type
);
257 val
->type
= arg
->type
;
258 VALUE_LVAL (val
) = VALUE_LVAL (arg
);
259 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg
);
260 val
->offset
= arg
->offset
;
261 val
->bitpos
= arg
->bitpos
;
262 val
->bitsize
= arg
->bitsize
;
263 VALUE_FRAME_ID (val
) = VALUE_FRAME_ID (arg
);
264 VALUE_REGNUM (val
) = VALUE_REGNUM (arg
);
265 VALUE_LAZY (val
) = VALUE_LAZY (arg
);
266 VALUE_OPTIMIZED_OUT (val
) = VALUE_OPTIMIZED_OUT (arg
);
267 VALUE_EMBEDDED_OFFSET (val
) = VALUE_EMBEDDED_OFFSET (arg
);
268 VALUE_POINTED_TO_OFFSET (val
) = VALUE_POINTED_TO_OFFSET (arg
);
269 val
->modifiable
= arg
->modifiable
;
270 if (!VALUE_LAZY (val
))
272 memcpy (value_contents_all_raw (val
), value_contents_all_raw (arg
),
273 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg
)));
279 /* Access to the value history. */
281 /* Record a new value in the value history.
282 Returns the absolute history index of the entry.
283 Result of -1 indicates the value was not saved; otherwise it is the
284 value history index of this new item. */
287 record_latest_value (struct value
*val
)
291 /* We don't want this value to have anything to do with the inferior anymore.
292 In particular, "set $1 = 50" should not affect the variable from which
293 the value was taken, and fast watchpoints should be able to assume that
294 a value on the value history never changes. */
295 if (VALUE_LAZY (val
))
296 value_fetch_lazy (val
);
297 /* We preserve VALUE_LVAL so that the user can find out where it was fetched
298 from. This is a bit dubious, because then *&$1 does not just return $1
299 but the current contents of that location. c'est la vie... */
303 /* Here we treat value_history_count as origin-zero
304 and applying to the value being stored now. */
306 i
= value_history_count
% VALUE_HISTORY_CHUNK
;
309 struct value_history_chunk
*new
310 = (struct value_history_chunk
*)
311 xmalloc (sizeof (struct value_history_chunk
));
312 memset (new->values
, 0, sizeof new->values
);
313 new->next
= value_history_chain
;
314 value_history_chain
= new;
317 value_history_chain
->values
[i
] = val
;
319 /* Now we regard value_history_count as origin-one
320 and applying to the value just stored. */
322 return ++value_history_count
;
325 /* Return a copy of the value in the history with sequence number NUM. */
328 access_value_history (int num
)
330 struct value_history_chunk
*chunk
;
335 absnum
+= value_history_count
;
340 error ("The history is empty.");
342 error ("There is only one value in the history.");
344 error ("History does not go back to $$%d.", -num
);
346 if (absnum
> value_history_count
)
347 error ("History has not yet reached $%d.", absnum
);
351 /* Now absnum is always absolute and origin zero. */
353 chunk
= value_history_chain
;
354 for (i
= (value_history_count
- 1) / VALUE_HISTORY_CHUNK
- absnum
/ VALUE_HISTORY_CHUNK
;
358 return value_copy (chunk
->values
[absnum
% VALUE_HISTORY_CHUNK
]);
361 /* Clear the value history entirely.
362 Must be done when new symbol tables are loaded,
363 because the type pointers become invalid. */
366 clear_value_history (void)
368 struct value_history_chunk
*next
;
372 while (value_history_chain
)
374 for (i
= 0; i
< VALUE_HISTORY_CHUNK
; i
++)
375 if ((val
= value_history_chain
->values
[i
]) != NULL
)
377 next
= value_history_chain
->next
;
378 xfree (value_history_chain
);
379 value_history_chain
= next
;
381 value_history_count
= 0;
385 show_values (char *num_exp
, int from_tty
)
393 /* "info history +" should print from the stored position.
394 "info history <exp>" should print around value number <exp>. */
395 if (num_exp
[0] != '+' || num_exp
[1] != '\0')
396 num
= parse_and_eval_long (num_exp
) - 5;
400 /* "info history" means print the last 10 values. */
401 num
= value_history_count
- 9;
407 for (i
= num
; i
< num
+ 10 && i
<= value_history_count
; i
++)
409 val
= access_value_history (i
);
410 printf_filtered ("$%d = ", i
);
411 value_print (val
, gdb_stdout
, 0, Val_pretty_default
);
412 printf_filtered ("\n");
415 /* The next "info history +" should start after what we just printed. */
418 /* Hitting just return after this command should do the same thing as
419 "info history +". If num_exp is null, this is unnecessary, since
420 "info history +" is not useful after "info history". */
421 if (from_tty
&& num_exp
)
428 /* Internal variables. These are variables within the debugger
429 that hold values assigned by debugger commands.
430 The user refers to them with a '$' prefix
431 that does not appear in the variable names stored internally. */
433 static struct internalvar
*internalvars
;
435 /* Look up an internal variable with name NAME. NAME should not
436 normally include a dollar sign.
438 If the specified internal variable does not exist,
439 one is created, with a void value. */
442 lookup_internalvar (char *name
)
444 struct internalvar
*var
;
446 for (var
= internalvars
; var
; var
= var
->next
)
447 if (strcmp (var
->name
, name
) == 0)
450 var
= (struct internalvar
*) xmalloc (sizeof (struct internalvar
));
451 var
->name
= concat (name
, NULL
);
452 var
->value
= allocate_value (builtin_type_void
);
453 release_value (var
->value
);
454 var
->next
= internalvars
;
460 value_of_internalvar (struct internalvar
*var
)
464 val
= value_copy (var
->value
);
465 if (VALUE_LAZY (val
))
466 value_fetch_lazy (val
);
467 VALUE_LVAL (val
) = lval_internalvar
;
468 VALUE_INTERNALVAR (val
) = var
;
473 set_internalvar_component (struct internalvar
*var
, int offset
, int bitpos
,
474 int bitsize
, struct value
*newval
)
476 char *addr
= VALUE_CONTENTS (var
->value
) + offset
;
479 modify_field (addr
, value_as_long (newval
),
482 memcpy (addr
, VALUE_CONTENTS (newval
), TYPE_LENGTH (value_type (newval
)));
486 set_internalvar (struct internalvar
*var
, struct value
*val
)
488 struct value
*newval
;
490 newval
= value_copy (val
);
491 newval
->modifiable
= 1;
493 /* Force the value to be fetched from the target now, to avoid problems
494 later when this internalvar is referenced and the target is gone or
496 if (VALUE_LAZY (newval
))
497 value_fetch_lazy (newval
);
499 /* Begin code which must not call error(). If var->value points to
500 something free'd, an error() obviously leaves a dangling pointer.
501 But we also get a danling pointer if var->value points to
502 something in the value chain (i.e., before release_value is
503 called), because after the error free_all_values will get called before
507 release_value (newval
);
508 /* End code which must not call error(). */
512 internalvar_name (struct internalvar
*var
)
517 /* Free all internalvars. Done when new symtabs are loaded,
518 because that makes the values invalid. */
521 clear_internalvars (void)
523 struct internalvar
*var
;
528 internalvars
= var
->next
;
536 show_convenience (char *ignore
, int from_tty
)
538 struct internalvar
*var
;
541 for (var
= internalvars
; var
; var
= var
->next
)
547 printf_filtered ("$%s = ", var
->name
);
548 value_print (var
->value
, gdb_stdout
, 0, Val_pretty_default
);
549 printf_filtered ("\n");
552 printf_unfiltered ("No debugger convenience variables now defined.\n\
553 Convenience variables have names starting with \"$\";\n\
554 use \"set\" as in \"set $foo = 5\" to define them.\n");
557 /* Extract a value as a C number (either long or double).
558 Knows how to convert fixed values to double, or
559 floating values to long.
560 Does not deallocate the value. */
563 value_as_long (struct value
*val
)
565 /* This coerces arrays and functions, which is necessary (e.g.
566 in disassemble_command). It also dereferences references, which
567 I suspect is the most logical thing to do. */
568 val
= coerce_array (val
);
569 return unpack_long (value_type (val
), VALUE_CONTENTS (val
));
573 value_as_double (struct value
*val
)
578 foo
= unpack_double (value_type (val
), VALUE_CONTENTS (val
), &inv
);
580 error ("Invalid floating value found in program.");
583 /* Extract a value as a C pointer. Does not deallocate the value.
584 Note that val's type may not actually be a pointer; value_as_long
585 handles all the cases. */
587 value_as_address (struct value
*val
)
589 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
590 whether we want this to be true eventually. */
592 /* ADDR_BITS_REMOVE is wrong if we are being called for a
593 non-address (e.g. argument to "signal", "info break", etc.), or
594 for pointers to char, in which the low bits *are* significant. */
595 return ADDR_BITS_REMOVE (value_as_long (val
));
598 /* There are several targets (IA-64, PowerPC, and others) which
599 don't represent pointers to functions as simply the address of
600 the function's entry point. For example, on the IA-64, a
601 function pointer points to a two-word descriptor, generated by
602 the linker, which contains the function's entry point, and the
603 value the IA-64 "global pointer" register should have --- to
604 support position-independent code. The linker generates
605 descriptors only for those functions whose addresses are taken.
607 On such targets, it's difficult for GDB to convert an arbitrary
608 function address into a function pointer; it has to either find
609 an existing descriptor for that function, or call malloc and
610 build its own. On some targets, it is impossible for GDB to
611 build a descriptor at all: the descriptor must contain a jump
612 instruction; data memory cannot be executed; and code memory
615 Upon entry to this function, if VAL is a value of type `function'
616 (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
617 VALUE_ADDRESS (val) is the address of the function. This is what
618 you'll get if you evaluate an expression like `main'. The call
619 to COERCE_ARRAY below actually does all the usual unary
620 conversions, which includes converting values of type `function'
621 to `pointer to function'. This is the challenging conversion
622 discussed above. Then, `unpack_long' will convert that pointer
623 back into an address.
625 So, suppose the user types `disassemble foo' on an architecture
626 with a strange function pointer representation, on which GDB
627 cannot build its own descriptors, and suppose further that `foo'
628 has no linker-built descriptor. The address->pointer conversion
629 will signal an error and prevent the command from running, even
630 though the next step would have been to convert the pointer
631 directly back into the same address.
633 The following shortcut avoids this whole mess. If VAL is a
634 function, just return its address directly. */
635 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_FUNC
636 || TYPE_CODE (value_type (val
)) == TYPE_CODE_METHOD
)
637 return VALUE_ADDRESS (val
);
639 val
= coerce_array (val
);
641 /* Some architectures (e.g. Harvard), map instruction and data
642 addresses onto a single large unified address space. For
643 instance: An architecture may consider a large integer in the
644 range 0x10000000 .. 0x1000ffff to already represent a data
645 addresses (hence not need a pointer to address conversion) while
646 a small integer would still need to be converted integer to
647 pointer to address. Just assume such architectures handle all
648 integer conversions in a single function. */
652 I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we
653 must admonish GDB hackers to make sure its behavior matches the
654 compiler's, whenever possible.
656 In general, I think GDB should evaluate expressions the same way
657 the compiler does. When the user copies an expression out of
658 their source code and hands it to a `print' command, they should
659 get the same value the compiler would have computed. Any
660 deviation from this rule can cause major confusion and annoyance,
661 and needs to be justified carefully. In other words, GDB doesn't
662 really have the freedom to do these conversions in clever and
665 AndrewC pointed out that users aren't complaining about how GDB
666 casts integers to pointers; they are complaining that they can't
667 take an address from a disassembly listing and give it to `x/i'.
668 This is certainly important.
670 Adding an architecture method like integer_to_address() certainly
671 makes it possible for GDB to "get it right" in all circumstances
672 --- the target has complete control over how things get done, so
673 people can Do The Right Thing for their target without breaking
674 anyone else. The standard doesn't specify how integers get
675 converted to pointers; usually, the ABI doesn't either, but
676 ABI-specific code is a more reasonable place to handle it. */
678 if (TYPE_CODE (value_type (val
)) != TYPE_CODE_PTR
679 && TYPE_CODE (value_type (val
)) != TYPE_CODE_REF
680 && gdbarch_integer_to_address_p (current_gdbarch
))
681 return gdbarch_integer_to_address (current_gdbarch
, value_type (val
),
682 VALUE_CONTENTS (val
));
684 return unpack_long (value_type (val
), VALUE_CONTENTS (val
));
688 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
689 as a long, or as a double, assuming the raw data is described
690 by type TYPE. Knows how to convert different sizes of values
691 and can convert between fixed and floating point. We don't assume
692 any alignment for the raw data. Return value is in host byte order.
694 If you want functions and arrays to be coerced to pointers, and
695 references to be dereferenced, call value_as_long() instead.
697 C++: It is assumed that the front-end has taken care of
698 all matters concerning pointers to members. A pointer
699 to member which reaches here is considered to be equivalent
700 to an INT (or some size). After all, it is only an offset. */
703 unpack_long (struct type
*type
, const char *valaddr
)
705 enum type_code code
= TYPE_CODE (type
);
706 int len
= TYPE_LENGTH (type
);
707 int nosign
= TYPE_UNSIGNED (type
);
709 if (current_language
->la_language
== language_scm
710 && is_scmvalue_type (type
))
711 return scm_unpack (type
, valaddr
, TYPE_CODE_INT
);
715 case TYPE_CODE_TYPEDEF
:
716 return unpack_long (check_typedef (type
), valaddr
);
721 case TYPE_CODE_RANGE
:
723 return extract_unsigned_integer (valaddr
, len
);
725 return extract_signed_integer (valaddr
, len
);
728 return extract_typed_floating (valaddr
, type
);
732 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
733 whether we want this to be true eventually. */
734 return extract_typed_address (valaddr
, type
);
736 case TYPE_CODE_MEMBER
:
737 error ("not implemented: member types in unpack_long");
740 error ("Value can't be converted to integer.");
742 return 0; /* Placate lint. */
745 /* Return a double value from the specified type and address.
746 INVP points to an int which is set to 0 for valid value,
747 1 for invalid value (bad float format). In either case,
748 the returned double is OK to use. Argument is in target
749 format, result is in host format. */
752 unpack_double (struct type
*type
, const char *valaddr
, int *invp
)
758 *invp
= 0; /* Assume valid. */
759 CHECK_TYPEDEF (type
);
760 code
= TYPE_CODE (type
);
761 len
= TYPE_LENGTH (type
);
762 nosign
= TYPE_UNSIGNED (type
);
763 if (code
== TYPE_CODE_FLT
)
765 /* NOTE: cagney/2002-02-19: There was a test here to see if the
766 floating-point value was valid (using the macro
767 INVALID_FLOAT). That test/macro have been removed.
769 It turns out that only the VAX defined this macro and then
770 only in a non-portable way. Fixing the portability problem
771 wouldn't help since the VAX floating-point code is also badly
772 bit-rotten. The target needs to add definitions for the
773 methods TARGET_FLOAT_FORMAT and TARGET_DOUBLE_FORMAT - these
774 exactly describe the target floating-point format. The
775 problem here is that the corresponding floatformat_vax_f and
776 floatformat_vax_d values these methods should be set to are
777 also not defined either. Oops!
779 Hopefully someone will add both the missing floatformat
780 definitions and the new cases for floatformat_is_valid (). */
782 if (!floatformat_is_valid (floatformat_from_type (type
), valaddr
))
788 return extract_typed_floating (valaddr
, type
);
792 /* Unsigned -- be sure we compensate for signed LONGEST. */
793 return (ULONGEST
) unpack_long (type
, valaddr
);
797 /* Signed -- we are OK with unpack_long. */
798 return unpack_long (type
, valaddr
);
802 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
803 as a CORE_ADDR, assuming the raw data is described by type TYPE.
804 We don't assume any alignment for the raw data. Return value is in
807 If you want functions and arrays to be coerced to pointers, and
808 references to be dereferenced, call value_as_address() instead.
810 C++: It is assumed that the front-end has taken care of
811 all matters concerning pointers to members. A pointer
812 to member which reaches here is considered to be equivalent
813 to an INT (or some size). After all, it is only an offset. */
816 unpack_pointer (struct type
*type
, const char *valaddr
)
818 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
819 whether we want this to be true eventually. */
820 return unpack_long (type
, valaddr
);
824 /* Get the value of the FIELDN'th field (which must be static) of
825 TYPE. Return NULL if the field doesn't exist or has been
829 value_static_field (struct type
*type
, int fieldno
)
831 struct value
*retval
;
833 if (TYPE_FIELD_STATIC_HAS_ADDR (type
, fieldno
))
835 retval
= value_at (TYPE_FIELD_TYPE (type
, fieldno
),
836 TYPE_FIELD_STATIC_PHYSADDR (type
, fieldno
));
840 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
841 struct symbol
*sym
= lookup_symbol (phys_name
, 0, VAR_DOMAIN
, 0, NULL
);
844 /* With some compilers, e.g. HP aCC, static data members are reported
845 as non-debuggable symbols */
846 struct minimal_symbol
*msym
= lookup_minimal_symbol (phys_name
, NULL
, NULL
);
851 retval
= value_at (TYPE_FIELD_TYPE (type
, fieldno
),
852 SYMBOL_VALUE_ADDRESS (msym
));
857 /* SYM should never have a SYMBOL_CLASS which will require
858 read_var_value to use the FRAME parameter. */
859 if (symbol_read_needs_frame (sym
))
860 warning ("static field's value depends on the current "
861 "frame - bad debug info?");
862 retval
= read_var_value (sym
, NULL
);
864 if (retval
&& VALUE_LVAL (retval
) == lval_memory
)
865 SET_FIELD_PHYSADDR (TYPE_FIELD (type
, fieldno
),
866 VALUE_ADDRESS (retval
));
871 /* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.
872 You have to be careful here, since the size of the data area for the value
873 is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger
874 than the old enclosing type, you have to allocate more space for the data.
875 The return value is a pointer to the new version of this value structure. */
878 value_change_enclosing_type (struct value
*val
, struct type
*new_encl_type
)
880 if (TYPE_LENGTH (new_encl_type
) <= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val
)))
882 VALUE_ENCLOSING_TYPE (val
) = new_encl_type
;
887 struct value
*new_val
;
890 new_val
= (struct value
*) xrealloc (val
, sizeof (struct value
) + TYPE_LENGTH (new_encl_type
));
892 VALUE_ENCLOSING_TYPE (new_val
) = new_encl_type
;
894 /* We have to make sure this ends up in the same place in the value
895 chain as the original copy, so it's clean-up behavior is the same.
896 If the value has been released, this is a waste of time, but there
897 is no way to tell that in advance, so... */
899 if (val
!= all_values
)
901 for (prev
= all_values
; prev
!= NULL
; prev
= prev
->next
)
903 if (prev
->next
== val
)
905 prev
->next
= new_val
;
915 /* Given a value ARG1 (offset by OFFSET bytes)
916 of a struct or union type ARG_TYPE,
917 extract and return the value of one of its (non-static) fields.
918 FIELDNO says which field. */
921 value_primitive_field (struct value
*arg1
, int offset
,
922 int fieldno
, struct type
*arg_type
)
927 CHECK_TYPEDEF (arg_type
);
928 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
930 /* Handle packed fields */
932 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
934 v
= value_from_longest (type
,
935 unpack_field_as_long (arg_type
,
936 VALUE_CONTENTS (arg1
)
939 v
->bitpos
= TYPE_FIELD_BITPOS (arg_type
, fieldno
) % 8;
940 v
->bitsize
= TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
941 v
->offset
= value_offset (arg1
) + offset
942 + TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
944 else if (fieldno
< TYPE_N_BASECLASSES (arg_type
))
946 /* This field is actually a base subobject, so preserve the
947 entire object's contents for later references to virtual
949 v
= allocate_value (VALUE_ENCLOSING_TYPE (arg1
));
951 if (VALUE_LAZY (arg1
))
954 memcpy (value_contents_all_raw (v
), value_contents_all_raw (arg1
),
955 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg1
)));
956 v
->offset
= value_offset (arg1
);
957 VALUE_EMBEDDED_OFFSET (v
)
959 VALUE_EMBEDDED_OFFSET (arg1
) +
960 TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
964 /* Plain old data member */
965 offset
+= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
966 v
= allocate_value (type
);
967 if (VALUE_LAZY (arg1
))
970 memcpy (value_contents_raw (v
),
971 value_contents_raw (arg1
) + offset
,
973 v
->offset
= (value_offset (arg1
) + offset
974 + VALUE_EMBEDDED_OFFSET (arg1
));
976 VALUE_LVAL (v
) = VALUE_LVAL (arg1
);
977 if (VALUE_LVAL (arg1
) == lval_internalvar
)
978 VALUE_LVAL (v
) = lval_internalvar_component
;
979 VALUE_ADDRESS (v
) = VALUE_ADDRESS (arg1
);
980 VALUE_REGNUM (v
) = VALUE_REGNUM (arg1
);
981 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (arg1
);
982 /* VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
983 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; */
987 /* Given a value ARG1 of a struct or union type,
988 extract and return the value of one of its (non-static) fields.
989 FIELDNO says which field. */
992 value_field (struct value
*arg1
, int fieldno
)
994 return value_primitive_field (arg1
, 0, fieldno
, value_type (arg1
));
997 /* Return a non-virtual function as a value.
998 F is the list of member functions which contains the desired method.
999 J is an index into F which provides the desired method.
1001 We only use the symbol for its address, so be happy with either a
1002 full symbol or a minimal symbol.
1006 value_fn_field (struct value
**arg1p
, struct fn_field
*f
, int j
, struct type
*type
,
1010 struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
1011 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1013 struct minimal_symbol
*msym
;
1015 sym
= lookup_symbol (physname
, 0, VAR_DOMAIN
, 0, NULL
);
1022 gdb_assert (sym
== NULL
);
1023 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
1028 v
= allocate_value (ftype
);
1031 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1035 VALUE_ADDRESS (v
) = SYMBOL_VALUE_ADDRESS (msym
);
1040 if (type
!= value_type (*arg1p
))
1041 *arg1p
= value_ind (value_cast (lookup_pointer_type (type
),
1042 value_addr (*arg1p
)));
1044 /* Move the `this' pointer according to the offset.
1045 VALUE_OFFSET (*arg1p) += offset;
1053 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1056 Extracting bits depends on endianness of the machine. Compute the
1057 number of least significant bits to discard. For big endian machines,
1058 we compute the total number of bits in the anonymous object, subtract
1059 off the bit count from the MSB of the object to the MSB of the
1060 bitfield, then the size of the bitfield, which leaves the LSB discard
1061 count. For little endian machines, the discard count is simply the
1062 number of bits from the LSB of the anonymous object to the LSB of the
1065 If the field is signed, we also do sign extension. */
1068 unpack_field_as_long (struct type
*type
, const char *valaddr
, int fieldno
)
1072 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
1073 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
1075 struct type
*field_type
;
1077 val
= extract_unsigned_integer (valaddr
+ bitpos
/ 8, sizeof (val
));
1078 field_type
= TYPE_FIELD_TYPE (type
, fieldno
);
1079 CHECK_TYPEDEF (field_type
);
1081 /* Extract bits. See comment above. */
1083 if (BITS_BIG_ENDIAN
)
1084 lsbcount
= (sizeof val
* 8 - bitpos
% 8 - bitsize
);
1086 lsbcount
= (bitpos
% 8);
1089 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1090 If the field is signed, and is negative, then sign extend. */
1092 if ((bitsize
> 0) && (bitsize
< 8 * (int) sizeof (val
)))
1094 valmask
= (((ULONGEST
) 1) << bitsize
) - 1;
1096 if (!TYPE_UNSIGNED (field_type
))
1098 if (val
& (valmask
^ (valmask
>> 1)))
1107 /* Modify the value of a bitfield. ADDR points to a block of memory in
1108 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1109 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1110 indicate which bits (in target bit order) comprise the bitfield.
1111 Requires 0 < BITSIZE <= lbits, 0 <= BITPOS+BITSIZE <= lbits, and
1112 0 <= BITPOS, where lbits is the size of a LONGEST in bits. */
1115 modify_field (char *addr
, LONGEST fieldval
, int bitpos
, int bitsize
)
1118 ULONGEST mask
= (ULONGEST
) -1 >> (8 * sizeof (ULONGEST
) - bitsize
);
1120 /* If a negative fieldval fits in the field in question, chop
1121 off the sign extension bits. */
1122 if ((~fieldval
& ~(mask
>> 1)) == 0)
1125 /* Warn if value is too big to fit in the field in question. */
1126 if (0 != (fieldval
& ~mask
))
1128 /* FIXME: would like to include fieldval in the message, but
1129 we don't have a sprintf_longest. */
1130 warning ("Value does not fit in %d bits.", bitsize
);
1132 /* Truncate it, otherwise adjoining fields may be corrupted. */
1136 oword
= extract_unsigned_integer (addr
, sizeof oword
);
1138 /* Shifting for bit field depends on endianness of the target machine. */
1139 if (BITS_BIG_ENDIAN
)
1140 bitpos
= sizeof (oword
) * 8 - bitpos
- bitsize
;
1142 oword
&= ~(mask
<< bitpos
);
1143 oword
|= fieldval
<< bitpos
;
1145 store_unsigned_integer (addr
, sizeof oword
, oword
);
1148 /* Convert C numbers into newly allocated values */
1151 value_from_longest (struct type
*type
, LONGEST num
)
1153 struct value
*val
= allocate_value (type
);
1154 enum type_code code
;
1157 code
= TYPE_CODE (type
);
1158 len
= TYPE_LENGTH (type
);
1162 case TYPE_CODE_TYPEDEF
:
1163 type
= check_typedef (type
);
1166 case TYPE_CODE_CHAR
:
1167 case TYPE_CODE_ENUM
:
1168 case TYPE_CODE_BOOL
:
1169 case TYPE_CODE_RANGE
:
1170 store_signed_integer (value_contents_raw (val
), len
, num
);
1175 store_typed_address (value_contents_raw (val
), type
, (CORE_ADDR
) num
);
1179 error ("Unexpected type (%d) encountered for integer constant.", code
);
1185 /* Create a value representing a pointer of type TYPE to the address
1188 value_from_pointer (struct type
*type
, CORE_ADDR addr
)
1190 struct value
*val
= allocate_value (type
);
1191 store_typed_address (value_contents_raw (val
), type
, addr
);
1196 /* Create a value for a string constant to be stored locally
1197 (not in the inferior's memory space, but in GDB memory).
1198 This is analogous to value_from_longest, which also does not
1199 use inferior memory. String shall NOT contain embedded nulls. */
1202 value_from_string (char *ptr
)
1205 int len
= strlen (ptr
);
1206 int lowbound
= current_language
->string_lower_bound
;
1207 struct type
*string_char_type
;
1208 struct type
*rangetype
;
1209 struct type
*stringtype
;
1211 rangetype
= create_range_type ((struct type
*) NULL
,
1213 lowbound
, len
+ lowbound
- 1);
1214 string_char_type
= language_string_char_type (current_language
,
1216 stringtype
= create_array_type ((struct type
*) NULL
,
1219 val
= allocate_value (stringtype
);
1220 memcpy (value_contents_raw (val
), ptr
, len
);
1225 value_from_double (struct type
*type
, DOUBLEST num
)
1227 struct value
*val
= allocate_value (type
);
1228 struct type
*base_type
= check_typedef (type
);
1229 enum type_code code
= TYPE_CODE (base_type
);
1230 int len
= TYPE_LENGTH (base_type
);
1232 if (code
== TYPE_CODE_FLT
)
1234 store_typed_floating (value_contents_raw (val
), base_type
, num
);
1237 error ("Unexpected type encountered for floating constant.");
1243 coerce_ref (struct value
*arg
)
1245 struct type
*value_type_arg_tmp
= check_typedef (value_type (arg
));
1246 if (TYPE_CODE (value_type_arg_tmp
) == TYPE_CODE_REF
)
1247 arg
= value_at_lazy (TYPE_TARGET_TYPE (value_type_arg_tmp
),
1248 unpack_pointer (value_type (arg
),
1249 VALUE_CONTENTS (arg
)));
1254 coerce_array (struct value
*arg
)
1256 arg
= coerce_ref (arg
);
1257 if (current_language
->c_style_arrays
1258 && TYPE_CODE (value_type (arg
)) == TYPE_CODE_ARRAY
)
1259 arg
= value_coerce_array (arg
);
1260 if (TYPE_CODE (value_type (arg
)) == TYPE_CODE_FUNC
)
1261 arg
= value_coerce_function (arg
);
1266 coerce_number (struct value
*arg
)
1268 arg
= coerce_array (arg
);
1269 arg
= coerce_enum (arg
);
1274 coerce_enum (struct value
*arg
)
1276 if (TYPE_CODE (check_typedef (value_type (arg
))) == TYPE_CODE_ENUM
)
1277 arg
= value_cast (builtin_type_unsigned_int
, arg
);
1282 /* Should we use DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS instead of
1283 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc and TYPE
1284 is the type (which is known to be struct, union or array).
1286 On most machines, the struct convention is used unless we are
1287 using gcc and the type is of a special size. */
1288 /* As of about 31 Mar 93, GCC was changed to be compatible with the
1289 native compiler. GCC 2.3.3 was the last release that did it the
1290 old way. Since gcc2_compiled was not changed, we have no
1291 way to correctly win in all cases, so we just do the right thing
1292 for gcc1 and for gcc2 after this change. Thus it loses for gcc
1293 2.0-2.3.3. This is somewhat unfortunate, but changing gcc2_compiled
1294 would cause more chaos than dealing with some struct returns being
1296 /* NOTE: cagney/2004-06-13: Deleted check for "gcc_p". GCC 1.x is
1300 generic_use_struct_convention (int gcc_p
, struct type
*value_type
)
1302 return !(TYPE_LENGTH (value_type
) == 1
1303 || TYPE_LENGTH (value_type
) == 2
1304 || TYPE_LENGTH (value_type
) == 4
1305 || TYPE_LENGTH (value_type
) == 8);
1308 /* Return true if the function returning the specified type is using
1309 the convention of returning structures in memory (passing in the
1310 address as a hidden first parameter). GCC_P is nonzero if compiled
1314 using_struct_return (struct type
*value_type
, int gcc_p
)
1316 enum type_code code
= TYPE_CODE (value_type
);
1318 if (code
== TYPE_CODE_ERROR
)
1319 error ("Function return type unknown.");
1321 if (code
== TYPE_CODE_VOID
)
1322 /* A void return value is never in memory. See also corresponding
1323 code in "print_return_value". */
1326 /* Probe the architecture for the return-value convention. */
1327 return (gdbarch_return_value (current_gdbarch
, value_type
,
1329 != RETURN_VALUE_REGISTER_CONVENTION
);
1333 _initialize_values (void)
1335 add_cmd ("convenience", no_class
, show_convenience
,
1336 "Debugger convenience (\"$foo\") variables.\n\
1337 These variables are created when you assign them values;\n\
1338 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\
1339 A few convenience variables are given values automatically:\n\
1340 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1341 \"$__\" holds the contents of the last address examined with \"x\".",
1344 add_cmd ("values", no_class
, show_values
,
1345 "Elements of value history around item number IDX (or last ten).",