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 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
;
150 /* Return a mark in the value chain. All values allocated after the
151 mark is obtained (except for those released) are subject to being freed
152 if a subsequent value_free_to_mark is passed the mark. */
159 /* Free all values allocated since MARK was obtained by value_mark
160 (except for those released). */
162 value_free_to_mark (struct value
*mark
)
167 for (val
= all_values
; val
&& val
!= mark
; val
= next
)
175 /* Free all the values that have been allocated (except for those released).
176 Called after each command, successful or not. */
179 free_all_values (void)
184 for (val
= all_values
; val
; val
= next
)
193 /* Remove VAL from the chain all_values
194 so it will not be freed automatically. */
197 release_value (struct value
*val
)
201 if (all_values
== val
)
203 all_values
= val
->next
;
207 for (v
= all_values
; v
; v
= v
->next
)
217 /* Release all values up to mark */
219 value_release_to_mark (struct value
*mark
)
224 for (val
= next
= all_values
; next
; next
= next
->next
)
225 if (next
->next
== mark
)
227 all_values
= next
->next
;
235 /* Return a copy of the value ARG.
236 It contains the same contents, for same memory address,
237 but it's a different block of storage. */
240 value_copy (struct value
*arg
)
242 struct type
*encl_type
= VALUE_ENCLOSING_TYPE (arg
);
243 struct value
*val
= allocate_value (encl_type
);
244 val
->type
= arg
->type
;
245 VALUE_LVAL (val
) = VALUE_LVAL (arg
);
246 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg
);
247 val
->offset
= arg
->offset
;
248 val
->bitpos
= arg
->bitpos
;
249 val
->bitsize
= arg
->bitsize
;
250 VALUE_FRAME_ID (val
) = VALUE_FRAME_ID (arg
);
251 VALUE_REGNUM (val
) = VALUE_REGNUM (arg
);
252 VALUE_LAZY (val
) = VALUE_LAZY (arg
);
253 VALUE_OPTIMIZED_OUT (val
) = VALUE_OPTIMIZED_OUT (arg
);
254 VALUE_EMBEDDED_OFFSET (val
) = VALUE_EMBEDDED_OFFSET (arg
);
255 VALUE_POINTED_TO_OFFSET (val
) = VALUE_POINTED_TO_OFFSET (arg
);
256 val
->modifiable
= arg
->modifiable
;
257 if (!VALUE_LAZY (val
))
259 memcpy (VALUE_CONTENTS_ALL_RAW (val
), VALUE_CONTENTS_ALL_RAW (arg
),
260 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg
)));
266 /* Access to the value history. */
268 /* Record a new value in the value history.
269 Returns the absolute history index of the entry.
270 Result of -1 indicates the value was not saved; otherwise it is the
271 value history index of this new item. */
274 record_latest_value (struct value
*val
)
278 /* We don't want this value to have anything to do with the inferior anymore.
279 In particular, "set $1 = 50" should not affect the variable from which
280 the value was taken, and fast watchpoints should be able to assume that
281 a value on the value history never changes. */
282 if (VALUE_LAZY (val
))
283 value_fetch_lazy (val
);
284 /* We preserve VALUE_LVAL so that the user can find out where it was fetched
285 from. This is a bit dubious, because then *&$1 does not just return $1
286 but the current contents of that location. c'est la vie... */
290 /* Here we treat value_history_count as origin-zero
291 and applying to the value being stored now. */
293 i
= value_history_count
% VALUE_HISTORY_CHUNK
;
296 struct value_history_chunk
*new
297 = (struct value_history_chunk
*)
298 xmalloc (sizeof (struct value_history_chunk
));
299 memset (new->values
, 0, sizeof new->values
);
300 new->next
= value_history_chain
;
301 value_history_chain
= new;
304 value_history_chain
->values
[i
] = val
;
306 /* Now we regard value_history_count as origin-one
307 and applying to the value just stored. */
309 return ++value_history_count
;
312 /* Return a copy of the value in the history with sequence number NUM. */
315 access_value_history (int num
)
317 struct value_history_chunk
*chunk
;
322 absnum
+= value_history_count
;
327 error ("The history is empty.");
329 error ("There is only one value in the history.");
331 error ("History does not go back to $$%d.", -num
);
333 if (absnum
> value_history_count
)
334 error ("History has not yet reached $%d.", absnum
);
338 /* Now absnum is always absolute and origin zero. */
340 chunk
= value_history_chain
;
341 for (i
= (value_history_count
- 1) / VALUE_HISTORY_CHUNK
- absnum
/ VALUE_HISTORY_CHUNK
;
345 return value_copy (chunk
->values
[absnum
% VALUE_HISTORY_CHUNK
]);
348 /* Clear the value history entirely.
349 Must be done when new symbol tables are loaded,
350 because the type pointers become invalid. */
353 clear_value_history (void)
355 struct value_history_chunk
*next
;
359 while (value_history_chain
)
361 for (i
= 0; i
< VALUE_HISTORY_CHUNK
; i
++)
362 if ((val
= value_history_chain
->values
[i
]) != NULL
)
364 next
= value_history_chain
->next
;
365 xfree (value_history_chain
);
366 value_history_chain
= next
;
368 value_history_count
= 0;
372 show_values (char *num_exp
, int from_tty
)
380 /* "info history +" should print from the stored position.
381 "info history <exp>" should print around value number <exp>. */
382 if (num_exp
[0] != '+' || num_exp
[1] != '\0')
383 num
= parse_and_eval_long (num_exp
) - 5;
387 /* "info history" means print the last 10 values. */
388 num
= value_history_count
- 9;
394 for (i
= num
; i
< num
+ 10 && i
<= value_history_count
; i
++)
396 val
= access_value_history (i
);
397 printf_filtered ("$%d = ", i
);
398 value_print (val
, gdb_stdout
, 0, Val_pretty_default
);
399 printf_filtered ("\n");
402 /* The next "info history +" should start after what we just printed. */
405 /* Hitting just return after this command should do the same thing as
406 "info history +". If num_exp is null, this is unnecessary, since
407 "info history +" is not useful after "info history". */
408 if (from_tty
&& num_exp
)
415 /* Internal variables. These are variables within the debugger
416 that hold values assigned by debugger commands.
417 The user refers to them with a '$' prefix
418 that does not appear in the variable names stored internally. */
420 static struct internalvar
*internalvars
;
422 /* Look up an internal variable with name NAME. NAME should not
423 normally include a dollar sign.
425 If the specified internal variable does not exist,
426 one is created, with a void value. */
429 lookup_internalvar (char *name
)
431 struct internalvar
*var
;
433 for (var
= internalvars
; var
; var
= var
->next
)
434 if (strcmp (var
->name
, name
) == 0)
437 var
= (struct internalvar
*) xmalloc (sizeof (struct internalvar
));
438 var
->name
= concat (name
, NULL
);
439 var
->value
= allocate_value (builtin_type_void
);
440 release_value (var
->value
);
441 var
->next
= internalvars
;
447 value_of_internalvar (struct internalvar
*var
)
451 val
= value_copy (var
->value
);
452 if (VALUE_LAZY (val
))
453 value_fetch_lazy (val
);
454 VALUE_LVAL (val
) = lval_internalvar
;
455 VALUE_INTERNALVAR (val
) = var
;
460 set_internalvar_component (struct internalvar
*var
, int offset
, int bitpos
,
461 int bitsize
, struct value
*newval
)
463 char *addr
= VALUE_CONTENTS (var
->value
) + offset
;
466 modify_field (addr
, value_as_long (newval
),
469 memcpy (addr
, VALUE_CONTENTS (newval
), TYPE_LENGTH (value_type (newval
)));
473 set_internalvar (struct internalvar
*var
, struct value
*val
)
475 struct value
*newval
;
477 newval
= value_copy (val
);
478 newval
->modifiable
= 1;
480 /* Force the value to be fetched from the target now, to avoid problems
481 later when this internalvar is referenced and the target is gone or
483 if (VALUE_LAZY (newval
))
484 value_fetch_lazy (newval
);
486 /* Begin code which must not call error(). If var->value points to
487 something free'd, an error() obviously leaves a dangling pointer.
488 But we also get a danling pointer if var->value points to
489 something in the value chain (i.e., before release_value is
490 called), because after the error free_all_values will get called before
494 release_value (newval
);
495 /* End code which must not call error(). */
499 internalvar_name (struct internalvar
*var
)
504 /* Free all internalvars. Done when new symtabs are loaded,
505 because that makes the values invalid. */
508 clear_internalvars (void)
510 struct internalvar
*var
;
515 internalvars
= var
->next
;
523 show_convenience (char *ignore
, int from_tty
)
525 struct internalvar
*var
;
528 for (var
= internalvars
; var
; var
= var
->next
)
534 printf_filtered ("$%s = ", var
->name
);
535 value_print (var
->value
, gdb_stdout
, 0, Val_pretty_default
);
536 printf_filtered ("\n");
539 printf_unfiltered ("No debugger convenience variables now defined.\n\
540 Convenience variables have names starting with \"$\";\n\
541 use \"set\" as in \"set $foo = 5\" to define them.\n");
544 /* Extract a value as a C number (either long or double).
545 Knows how to convert fixed values to double, or
546 floating values to long.
547 Does not deallocate the value. */
550 value_as_long (struct value
*val
)
552 /* This coerces arrays and functions, which is necessary (e.g.
553 in disassemble_command). It also dereferences references, which
554 I suspect is the most logical thing to do. */
555 val
= coerce_array (val
);
556 return unpack_long (value_type (val
), VALUE_CONTENTS (val
));
560 value_as_double (struct value
*val
)
565 foo
= unpack_double (value_type (val
), VALUE_CONTENTS (val
), &inv
);
567 error ("Invalid floating value found in program.");
570 /* Extract a value as a C pointer. Does not deallocate the value.
571 Note that val's type may not actually be a pointer; value_as_long
572 handles all the cases. */
574 value_as_address (struct value
*val
)
576 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
577 whether we want this to be true eventually. */
579 /* ADDR_BITS_REMOVE is wrong if we are being called for a
580 non-address (e.g. argument to "signal", "info break", etc.), or
581 for pointers to char, in which the low bits *are* significant. */
582 return ADDR_BITS_REMOVE (value_as_long (val
));
585 /* There are several targets (IA-64, PowerPC, and others) which
586 don't represent pointers to functions as simply the address of
587 the function's entry point. For example, on the IA-64, a
588 function pointer points to a two-word descriptor, generated by
589 the linker, which contains the function's entry point, and the
590 value the IA-64 "global pointer" register should have --- to
591 support position-independent code. The linker generates
592 descriptors only for those functions whose addresses are taken.
594 On such targets, it's difficult for GDB to convert an arbitrary
595 function address into a function pointer; it has to either find
596 an existing descriptor for that function, or call malloc and
597 build its own. On some targets, it is impossible for GDB to
598 build a descriptor at all: the descriptor must contain a jump
599 instruction; data memory cannot be executed; and code memory
602 Upon entry to this function, if VAL is a value of type `function'
603 (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
604 VALUE_ADDRESS (val) is the address of the function. This is what
605 you'll get if you evaluate an expression like `main'. The call
606 to COERCE_ARRAY below actually does all the usual unary
607 conversions, which includes converting values of type `function'
608 to `pointer to function'. This is the challenging conversion
609 discussed above. Then, `unpack_long' will convert that pointer
610 back into an address.
612 So, suppose the user types `disassemble foo' on an architecture
613 with a strange function pointer representation, on which GDB
614 cannot build its own descriptors, and suppose further that `foo'
615 has no linker-built descriptor. The address->pointer conversion
616 will signal an error and prevent the command from running, even
617 though the next step would have been to convert the pointer
618 directly back into the same address.
620 The following shortcut avoids this whole mess. If VAL is a
621 function, just return its address directly. */
622 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_FUNC
623 || TYPE_CODE (value_type (val
)) == TYPE_CODE_METHOD
)
624 return VALUE_ADDRESS (val
);
626 val
= coerce_array (val
);
628 /* Some architectures (e.g. Harvard), map instruction and data
629 addresses onto a single large unified address space. For
630 instance: An architecture may consider a large integer in the
631 range 0x10000000 .. 0x1000ffff to already represent a data
632 addresses (hence not need a pointer to address conversion) while
633 a small integer would still need to be converted integer to
634 pointer to address. Just assume such architectures handle all
635 integer conversions in a single function. */
639 I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we
640 must admonish GDB hackers to make sure its behavior matches the
641 compiler's, whenever possible.
643 In general, I think GDB should evaluate expressions the same way
644 the compiler does. When the user copies an expression out of
645 their source code and hands it to a `print' command, they should
646 get the same value the compiler would have computed. Any
647 deviation from this rule can cause major confusion and annoyance,
648 and needs to be justified carefully. In other words, GDB doesn't
649 really have the freedom to do these conversions in clever and
652 AndrewC pointed out that users aren't complaining about how GDB
653 casts integers to pointers; they are complaining that they can't
654 take an address from a disassembly listing and give it to `x/i'.
655 This is certainly important.
657 Adding an architecture method like integer_to_address() certainly
658 makes it possible for GDB to "get it right" in all circumstances
659 --- the target has complete control over how things get done, so
660 people can Do The Right Thing for their target without breaking
661 anyone else. The standard doesn't specify how integers get
662 converted to pointers; usually, the ABI doesn't either, but
663 ABI-specific code is a more reasonable place to handle it. */
665 if (TYPE_CODE (value_type (val
)) != TYPE_CODE_PTR
666 && TYPE_CODE (value_type (val
)) != TYPE_CODE_REF
667 && gdbarch_integer_to_address_p (current_gdbarch
))
668 return gdbarch_integer_to_address (current_gdbarch
, value_type (val
),
669 VALUE_CONTENTS (val
));
671 return unpack_long (value_type (val
), VALUE_CONTENTS (val
));
675 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
676 as a long, or as a double, assuming the raw data is described
677 by type TYPE. Knows how to convert different sizes of values
678 and can convert between fixed and floating point. We don't assume
679 any alignment for the raw data. Return value is in host byte order.
681 If you want functions and arrays to be coerced to pointers, and
682 references to be dereferenced, call value_as_long() instead.
684 C++: It is assumed that the front-end has taken care of
685 all matters concerning pointers to members. A pointer
686 to member which reaches here is considered to be equivalent
687 to an INT (or some size). After all, it is only an offset. */
690 unpack_long (struct type
*type
, const char *valaddr
)
692 enum type_code code
= TYPE_CODE (type
);
693 int len
= TYPE_LENGTH (type
);
694 int nosign
= TYPE_UNSIGNED (type
);
696 if (current_language
->la_language
== language_scm
697 && is_scmvalue_type (type
))
698 return scm_unpack (type
, valaddr
, TYPE_CODE_INT
);
702 case TYPE_CODE_TYPEDEF
:
703 return unpack_long (check_typedef (type
), valaddr
);
708 case TYPE_CODE_RANGE
:
710 return extract_unsigned_integer (valaddr
, len
);
712 return extract_signed_integer (valaddr
, len
);
715 return extract_typed_floating (valaddr
, type
);
719 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
720 whether we want this to be true eventually. */
721 return extract_typed_address (valaddr
, type
);
723 case TYPE_CODE_MEMBER
:
724 error ("not implemented: member types in unpack_long");
727 error ("Value can't be converted to integer.");
729 return 0; /* Placate lint. */
732 /* Return a double value from the specified type and address.
733 INVP points to an int which is set to 0 for valid value,
734 1 for invalid value (bad float format). In either case,
735 the returned double is OK to use. Argument is in target
736 format, result is in host format. */
739 unpack_double (struct type
*type
, const char *valaddr
, int *invp
)
745 *invp
= 0; /* Assume valid. */
746 CHECK_TYPEDEF (type
);
747 code
= TYPE_CODE (type
);
748 len
= TYPE_LENGTH (type
);
749 nosign
= TYPE_UNSIGNED (type
);
750 if (code
== TYPE_CODE_FLT
)
752 /* NOTE: cagney/2002-02-19: There was a test here to see if the
753 floating-point value was valid (using the macro
754 INVALID_FLOAT). That test/macro have been removed.
756 It turns out that only the VAX defined this macro and then
757 only in a non-portable way. Fixing the portability problem
758 wouldn't help since the VAX floating-point code is also badly
759 bit-rotten. The target needs to add definitions for the
760 methods TARGET_FLOAT_FORMAT and TARGET_DOUBLE_FORMAT - these
761 exactly describe the target floating-point format. The
762 problem here is that the corresponding floatformat_vax_f and
763 floatformat_vax_d values these methods should be set to are
764 also not defined either. Oops!
766 Hopefully someone will add both the missing floatformat
767 definitions and the new cases for floatformat_is_valid (). */
769 if (!floatformat_is_valid (floatformat_from_type (type
), valaddr
))
775 return extract_typed_floating (valaddr
, type
);
779 /* Unsigned -- be sure we compensate for signed LONGEST. */
780 return (ULONGEST
) unpack_long (type
, valaddr
);
784 /* Signed -- we are OK with unpack_long. */
785 return unpack_long (type
, valaddr
);
789 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
790 as a CORE_ADDR, assuming the raw data is described by type TYPE.
791 We don't assume any alignment for the raw data. Return value is in
794 If you want functions and arrays to be coerced to pointers, and
795 references to be dereferenced, call value_as_address() instead.
797 C++: It is assumed that the front-end has taken care of
798 all matters concerning pointers to members. A pointer
799 to member which reaches here is considered to be equivalent
800 to an INT (or some size). After all, it is only an offset. */
803 unpack_pointer (struct type
*type
, const char *valaddr
)
805 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
806 whether we want this to be true eventually. */
807 return unpack_long (type
, valaddr
);
811 /* Get the value of the FIELDN'th field (which must be static) of
812 TYPE. Return NULL if the field doesn't exist or has been
816 value_static_field (struct type
*type
, int fieldno
)
818 struct value
*retval
;
820 if (TYPE_FIELD_STATIC_HAS_ADDR (type
, fieldno
))
822 retval
= value_at (TYPE_FIELD_TYPE (type
, fieldno
),
823 TYPE_FIELD_STATIC_PHYSADDR (type
, fieldno
));
827 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
828 struct symbol
*sym
= lookup_symbol (phys_name
, 0, VAR_DOMAIN
, 0, NULL
);
831 /* With some compilers, e.g. HP aCC, static data members are reported
832 as non-debuggable symbols */
833 struct minimal_symbol
*msym
= lookup_minimal_symbol (phys_name
, NULL
, NULL
);
838 retval
= value_at (TYPE_FIELD_TYPE (type
, fieldno
),
839 SYMBOL_VALUE_ADDRESS (msym
));
844 /* SYM should never have a SYMBOL_CLASS which will require
845 read_var_value to use the FRAME parameter. */
846 if (symbol_read_needs_frame (sym
))
847 warning ("static field's value depends on the current "
848 "frame - bad debug info?");
849 retval
= read_var_value (sym
, NULL
);
851 if (retval
&& VALUE_LVAL (retval
) == lval_memory
)
852 SET_FIELD_PHYSADDR (TYPE_FIELD (type
, fieldno
),
853 VALUE_ADDRESS (retval
));
858 /* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.
859 You have to be careful here, since the size of the data area for the value
860 is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger
861 than the old enclosing type, you have to allocate more space for the data.
862 The return value is a pointer to the new version of this value structure. */
865 value_change_enclosing_type (struct value
*val
, struct type
*new_encl_type
)
867 if (TYPE_LENGTH (new_encl_type
) <= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val
)))
869 VALUE_ENCLOSING_TYPE (val
) = new_encl_type
;
874 struct value
*new_val
;
877 new_val
= (struct value
*) xrealloc (val
, sizeof (struct value
) + TYPE_LENGTH (new_encl_type
));
879 VALUE_ENCLOSING_TYPE (new_val
) = new_encl_type
;
881 /* We have to make sure this ends up in the same place in the value
882 chain as the original copy, so it's clean-up behavior is the same.
883 If the value has been released, this is a waste of time, but there
884 is no way to tell that in advance, so... */
886 if (val
!= all_values
)
888 for (prev
= all_values
; prev
!= NULL
; prev
= prev
->next
)
890 if (prev
->next
== val
)
892 prev
->next
= new_val
;
902 /* Given a value ARG1 (offset by OFFSET bytes)
903 of a struct or union type ARG_TYPE,
904 extract and return the value of one of its (non-static) fields.
905 FIELDNO says which field. */
908 value_primitive_field (struct value
*arg1
, int offset
,
909 int fieldno
, struct type
*arg_type
)
914 CHECK_TYPEDEF (arg_type
);
915 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
917 /* Handle packed fields */
919 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
921 v
= value_from_longest (type
,
922 unpack_field_as_long (arg_type
,
923 VALUE_CONTENTS (arg1
)
926 v
->bitpos
= TYPE_FIELD_BITPOS (arg_type
, fieldno
) % 8;
927 v
->bitsize
= TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
928 v
->offset
= value_offset (arg1
) + offset
929 + TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
931 else if (fieldno
< TYPE_N_BASECLASSES (arg_type
))
933 /* This field is actually a base subobject, so preserve the
934 entire object's contents for later references to virtual
936 v
= allocate_value (VALUE_ENCLOSING_TYPE (arg1
));
938 if (VALUE_LAZY (arg1
))
941 memcpy (VALUE_CONTENTS_ALL_RAW (v
), VALUE_CONTENTS_ALL_RAW (arg1
),
942 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg1
)));
943 v
->offset
= value_offset (arg1
);
944 VALUE_EMBEDDED_OFFSET (v
)
946 VALUE_EMBEDDED_OFFSET (arg1
) +
947 TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
951 /* Plain old data member */
952 offset
+= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
953 v
= allocate_value (type
);
954 if (VALUE_LAZY (arg1
))
957 memcpy (VALUE_CONTENTS_RAW (v
),
958 VALUE_CONTENTS_RAW (arg1
) + offset
,
960 v
->offset
= (value_offset (arg1
) + offset
961 + VALUE_EMBEDDED_OFFSET (arg1
));
963 VALUE_LVAL (v
) = VALUE_LVAL (arg1
);
964 if (VALUE_LVAL (arg1
) == lval_internalvar
)
965 VALUE_LVAL (v
) = lval_internalvar_component
;
966 VALUE_ADDRESS (v
) = VALUE_ADDRESS (arg1
);
967 VALUE_REGNUM (v
) = VALUE_REGNUM (arg1
);
968 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (arg1
);
969 /* VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
970 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; */
974 /* Given a value ARG1 of a struct or union type,
975 extract and return the value of one of its (non-static) fields.
976 FIELDNO says which field. */
979 value_field (struct value
*arg1
, int fieldno
)
981 return value_primitive_field (arg1
, 0, fieldno
, value_type (arg1
));
984 /* Return a non-virtual function as a value.
985 F is the list of member functions which contains the desired method.
986 J is an index into F which provides the desired method.
988 We only use the symbol for its address, so be happy with either a
989 full symbol or a minimal symbol.
993 value_fn_field (struct value
**arg1p
, struct fn_field
*f
, int j
, struct type
*type
,
997 struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
998 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1000 struct minimal_symbol
*msym
;
1002 sym
= lookup_symbol (physname
, 0, VAR_DOMAIN
, 0, NULL
);
1009 gdb_assert (sym
== NULL
);
1010 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
1015 v
= allocate_value (ftype
);
1018 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1022 VALUE_ADDRESS (v
) = SYMBOL_VALUE_ADDRESS (msym
);
1027 if (type
!= value_type (*arg1p
))
1028 *arg1p
= value_ind (value_cast (lookup_pointer_type (type
),
1029 value_addr (*arg1p
)));
1031 /* Move the `this' pointer according to the offset.
1032 VALUE_OFFSET (*arg1p) += offset;
1040 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1043 Extracting bits depends on endianness of the machine. Compute the
1044 number of least significant bits to discard. For big endian machines,
1045 we compute the total number of bits in the anonymous object, subtract
1046 off the bit count from the MSB of the object to the MSB of the
1047 bitfield, then the size of the bitfield, which leaves the LSB discard
1048 count. For little endian machines, the discard count is simply the
1049 number of bits from the LSB of the anonymous object to the LSB of the
1052 If the field is signed, we also do sign extension. */
1055 unpack_field_as_long (struct type
*type
, const char *valaddr
, int fieldno
)
1059 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
1060 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
1062 struct type
*field_type
;
1064 val
= extract_unsigned_integer (valaddr
+ bitpos
/ 8, sizeof (val
));
1065 field_type
= TYPE_FIELD_TYPE (type
, fieldno
);
1066 CHECK_TYPEDEF (field_type
);
1068 /* Extract bits. See comment above. */
1070 if (BITS_BIG_ENDIAN
)
1071 lsbcount
= (sizeof val
* 8 - bitpos
% 8 - bitsize
);
1073 lsbcount
= (bitpos
% 8);
1076 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1077 If the field is signed, and is negative, then sign extend. */
1079 if ((bitsize
> 0) && (bitsize
< 8 * (int) sizeof (val
)))
1081 valmask
= (((ULONGEST
) 1) << bitsize
) - 1;
1083 if (!TYPE_UNSIGNED (field_type
))
1085 if (val
& (valmask
^ (valmask
>> 1)))
1094 /* Modify the value of a bitfield. ADDR points to a block of memory in
1095 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1096 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1097 indicate which bits (in target bit order) comprise the bitfield.
1098 Requires 0 < BITSIZE <= lbits, 0 <= BITPOS+BITSIZE <= lbits, and
1099 0 <= BITPOS, where lbits is the size of a LONGEST in bits. */
1102 modify_field (char *addr
, LONGEST fieldval
, int bitpos
, int bitsize
)
1105 ULONGEST mask
= (ULONGEST
) -1 >> (8 * sizeof (ULONGEST
) - bitsize
);
1107 /* If a negative fieldval fits in the field in question, chop
1108 off the sign extension bits. */
1109 if ((~fieldval
& ~(mask
>> 1)) == 0)
1112 /* Warn if value is too big to fit in the field in question. */
1113 if (0 != (fieldval
& ~mask
))
1115 /* FIXME: would like to include fieldval in the message, but
1116 we don't have a sprintf_longest. */
1117 warning ("Value does not fit in %d bits.", bitsize
);
1119 /* Truncate it, otherwise adjoining fields may be corrupted. */
1123 oword
= extract_unsigned_integer (addr
, sizeof oword
);
1125 /* Shifting for bit field depends on endianness of the target machine. */
1126 if (BITS_BIG_ENDIAN
)
1127 bitpos
= sizeof (oword
) * 8 - bitpos
- bitsize
;
1129 oword
&= ~(mask
<< bitpos
);
1130 oword
|= fieldval
<< bitpos
;
1132 store_unsigned_integer (addr
, sizeof oword
, oword
);
1135 /* Convert C numbers into newly allocated values */
1138 value_from_longest (struct type
*type
, LONGEST num
)
1140 struct value
*val
= allocate_value (type
);
1141 enum type_code code
;
1144 code
= TYPE_CODE (type
);
1145 len
= TYPE_LENGTH (type
);
1149 case TYPE_CODE_TYPEDEF
:
1150 type
= check_typedef (type
);
1153 case TYPE_CODE_CHAR
:
1154 case TYPE_CODE_ENUM
:
1155 case TYPE_CODE_BOOL
:
1156 case TYPE_CODE_RANGE
:
1157 store_signed_integer (VALUE_CONTENTS_RAW (val
), len
, num
);
1162 store_typed_address (VALUE_CONTENTS_RAW (val
), type
, (CORE_ADDR
) num
);
1166 error ("Unexpected type (%d) encountered for integer constant.", code
);
1172 /* Create a value representing a pointer of type TYPE to the address
1175 value_from_pointer (struct type
*type
, CORE_ADDR addr
)
1177 struct value
*val
= allocate_value (type
);
1178 store_typed_address (VALUE_CONTENTS_RAW (val
), type
, addr
);
1183 /* Create a value for a string constant to be stored locally
1184 (not in the inferior's memory space, but in GDB memory).
1185 This is analogous to value_from_longest, which also does not
1186 use inferior memory. String shall NOT contain embedded nulls. */
1189 value_from_string (char *ptr
)
1192 int len
= strlen (ptr
);
1193 int lowbound
= current_language
->string_lower_bound
;
1194 struct type
*string_char_type
;
1195 struct type
*rangetype
;
1196 struct type
*stringtype
;
1198 rangetype
= create_range_type ((struct type
*) NULL
,
1200 lowbound
, len
+ lowbound
- 1);
1201 string_char_type
= language_string_char_type (current_language
,
1203 stringtype
= create_array_type ((struct type
*) NULL
,
1206 val
= allocate_value (stringtype
);
1207 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, len
);
1212 value_from_double (struct type
*type
, DOUBLEST num
)
1214 struct value
*val
= allocate_value (type
);
1215 struct type
*base_type
= check_typedef (type
);
1216 enum type_code code
= TYPE_CODE (base_type
);
1217 int len
= TYPE_LENGTH (base_type
);
1219 if (code
== TYPE_CODE_FLT
)
1221 store_typed_floating (VALUE_CONTENTS_RAW (val
), base_type
, num
);
1224 error ("Unexpected type encountered for floating constant.");
1230 coerce_ref (struct value
*arg
)
1232 struct type
*value_type_arg_tmp
= check_typedef (value_type (arg
));
1233 if (TYPE_CODE (value_type_arg_tmp
) == TYPE_CODE_REF
)
1234 arg
= value_at_lazy (TYPE_TARGET_TYPE (value_type_arg_tmp
),
1235 unpack_pointer (value_type (arg
),
1236 VALUE_CONTENTS (arg
)));
1241 coerce_array (struct value
*arg
)
1243 arg
= coerce_ref (arg
);
1244 if (current_language
->c_style_arrays
1245 && TYPE_CODE (value_type (arg
)) == TYPE_CODE_ARRAY
)
1246 arg
= value_coerce_array (arg
);
1247 if (TYPE_CODE (value_type (arg
)) == TYPE_CODE_FUNC
)
1248 arg
= value_coerce_function (arg
);
1253 coerce_number (struct value
*arg
)
1255 arg
= coerce_array (arg
);
1256 arg
= coerce_enum (arg
);
1261 coerce_enum (struct value
*arg
)
1263 if (TYPE_CODE (check_typedef (value_type (arg
))) == TYPE_CODE_ENUM
)
1264 arg
= value_cast (builtin_type_unsigned_int
, arg
);
1269 /* Should we use DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS instead of
1270 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc and TYPE
1271 is the type (which is known to be struct, union or array).
1273 On most machines, the struct convention is used unless we are
1274 using gcc and the type is of a special size. */
1275 /* As of about 31 Mar 93, GCC was changed to be compatible with the
1276 native compiler. GCC 2.3.3 was the last release that did it the
1277 old way. Since gcc2_compiled was not changed, we have no
1278 way to correctly win in all cases, so we just do the right thing
1279 for gcc1 and for gcc2 after this change. Thus it loses for gcc
1280 2.0-2.3.3. This is somewhat unfortunate, but changing gcc2_compiled
1281 would cause more chaos than dealing with some struct returns being
1283 /* NOTE: cagney/2004-06-13: Deleted check for "gcc_p". GCC 1.x is
1287 generic_use_struct_convention (int gcc_p
, struct type
*value_type
)
1289 return !(TYPE_LENGTH (value_type
) == 1
1290 || TYPE_LENGTH (value_type
) == 2
1291 || TYPE_LENGTH (value_type
) == 4
1292 || TYPE_LENGTH (value_type
) == 8);
1295 /* Return true if the function returning the specified type is using
1296 the convention of returning structures in memory (passing in the
1297 address as a hidden first parameter). GCC_P is nonzero if compiled
1301 using_struct_return (struct type
*value_type
, int gcc_p
)
1303 enum type_code code
= TYPE_CODE (value_type
);
1305 if (code
== TYPE_CODE_ERROR
)
1306 error ("Function return type unknown.");
1308 if (code
== TYPE_CODE_VOID
)
1309 /* A void return value is never in memory. See also corresponding
1310 code in "print_return_value". */
1313 /* Probe the architecture for the return-value convention. */
1314 return (gdbarch_return_value (current_gdbarch
, value_type
,
1316 != RETURN_VALUE_REGISTER_CONVENTION
);
1320 _initialize_values (void)
1322 add_cmd ("convenience", no_class
, show_convenience
,
1323 "Debugger convenience (\"$foo\") variables.\n\
1324 These variables are created when you assign them values;\n\
1325 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\
1326 A few convenience variables are given values automatically:\n\
1327 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1328 \"$__\" holds the contents of the last address examined with \"x\".",
1331 add_cmd ("values", no_class
, show_values
,
1332 "Elements of value history around item number IDX (or last ten).",