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 && INTEGER_TO_ADDRESS_P ())
668 return INTEGER_TO_ADDRESS (value_type (val
), VALUE_CONTENTS (val
));
670 return unpack_long (value_type (val
), VALUE_CONTENTS (val
));
674 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
675 as a long, or as a double, assuming the raw data is described
676 by type TYPE. Knows how to convert different sizes of values
677 and can convert between fixed and floating point. We don't assume
678 any alignment for the raw data. Return value is in host byte order.
680 If you want functions and arrays to be coerced to pointers, and
681 references to be dereferenced, call value_as_long() instead.
683 C++: It is assumed that the front-end has taken care of
684 all matters concerning pointers to members. A pointer
685 to member which reaches here is considered to be equivalent
686 to an INT (or some size). After all, it is only an offset. */
689 unpack_long (struct type
*type
, const char *valaddr
)
691 enum type_code code
= TYPE_CODE (type
);
692 int len
= TYPE_LENGTH (type
);
693 int nosign
= TYPE_UNSIGNED (type
);
695 if (current_language
->la_language
== language_scm
696 && is_scmvalue_type (type
))
697 return scm_unpack (type
, valaddr
, TYPE_CODE_INT
);
701 case TYPE_CODE_TYPEDEF
:
702 return unpack_long (check_typedef (type
), valaddr
);
707 case TYPE_CODE_RANGE
:
709 return extract_unsigned_integer (valaddr
, len
);
711 return extract_signed_integer (valaddr
, len
);
714 return extract_typed_floating (valaddr
, type
);
718 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
719 whether we want this to be true eventually. */
720 return extract_typed_address (valaddr
, type
);
722 case TYPE_CODE_MEMBER
:
723 error ("not implemented: member types in unpack_long");
726 error ("Value can't be converted to integer.");
728 return 0; /* Placate lint. */
731 /* Return a double value from the specified type and address.
732 INVP points to an int which is set to 0 for valid value,
733 1 for invalid value (bad float format). In either case,
734 the returned double is OK to use. Argument is in target
735 format, result is in host format. */
738 unpack_double (struct type
*type
, const char *valaddr
, int *invp
)
744 *invp
= 0; /* Assume valid. */
745 CHECK_TYPEDEF (type
);
746 code
= TYPE_CODE (type
);
747 len
= TYPE_LENGTH (type
);
748 nosign
= TYPE_UNSIGNED (type
);
749 if (code
== TYPE_CODE_FLT
)
751 /* NOTE: cagney/2002-02-19: There was a test here to see if the
752 floating-point value was valid (using the macro
753 INVALID_FLOAT). That test/macro have been removed.
755 It turns out that only the VAX defined this macro and then
756 only in a non-portable way. Fixing the portability problem
757 wouldn't help since the VAX floating-point code is also badly
758 bit-rotten. The target needs to add definitions for the
759 methods TARGET_FLOAT_FORMAT and TARGET_DOUBLE_FORMAT - these
760 exactly describe the target floating-point format. The
761 problem here is that the corresponding floatformat_vax_f and
762 floatformat_vax_d values these methods should be set to are
763 also not defined either. Oops!
765 Hopefully someone will add both the missing floatformat
766 definitions and the new cases for floatformat_is_valid (). */
768 if (!floatformat_is_valid (floatformat_from_type (type
), valaddr
))
774 return extract_typed_floating (valaddr
, type
);
778 /* Unsigned -- be sure we compensate for signed LONGEST. */
779 return (ULONGEST
) unpack_long (type
, valaddr
);
783 /* Signed -- we are OK with unpack_long. */
784 return unpack_long (type
, valaddr
);
788 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
789 as a CORE_ADDR, assuming the raw data is described by type TYPE.
790 We don't assume any alignment for the raw data. Return value is in
793 If you want functions and arrays to be coerced to pointers, and
794 references to be dereferenced, call value_as_address() instead.
796 C++: It is assumed that the front-end has taken care of
797 all matters concerning pointers to members. A pointer
798 to member which reaches here is considered to be equivalent
799 to an INT (or some size). After all, it is only an offset. */
802 unpack_pointer (struct type
*type
, const char *valaddr
)
804 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
805 whether we want this to be true eventually. */
806 return unpack_long (type
, valaddr
);
810 /* Get the value of the FIELDN'th field (which must be static) of
811 TYPE. Return NULL if the field doesn't exist or has been
815 value_static_field (struct type
*type
, int fieldno
)
817 struct value
*retval
;
819 if (TYPE_FIELD_STATIC_HAS_ADDR (type
, fieldno
))
821 retval
= value_at (TYPE_FIELD_TYPE (type
, fieldno
),
822 TYPE_FIELD_STATIC_PHYSADDR (type
, fieldno
));
826 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
827 struct symbol
*sym
= lookup_symbol (phys_name
, 0, VAR_DOMAIN
, 0, NULL
);
830 /* With some compilers, e.g. HP aCC, static data members are reported
831 as non-debuggable symbols */
832 struct minimal_symbol
*msym
= lookup_minimal_symbol (phys_name
, NULL
, NULL
);
837 retval
= value_at (TYPE_FIELD_TYPE (type
, fieldno
),
838 SYMBOL_VALUE_ADDRESS (msym
));
843 /* SYM should never have a SYMBOL_CLASS which will require
844 read_var_value to use the FRAME parameter. */
845 if (symbol_read_needs_frame (sym
))
846 warning ("static field's value depends on the current "
847 "frame - bad debug info?");
848 retval
= read_var_value (sym
, NULL
);
850 if (retval
&& VALUE_LVAL (retval
) == lval_memory
)
851 SET_FIELD_PHYSADDR (TYPE_FIELD (type
, fieldno
),
852 VALUE_ADDRESS (retval
));
857 /* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.
858 You have to be careful here, since the size of the data area for the value
859 is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger
860 than the old enclosing type, you have to allocate more space for the data.
861 The return value is a pointer to the new version of this value structure. */
864 value_change_enclosing_type (struct value
*val
, struct type
*new_encl_type
)
866 if (TYPE_LENGTH (new_encl_type
) <= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val
)))
868 VALUE_ENCLOSING_TYPE (val
) = new_encl_type
;
873 struct value
*new_val
;
876 new_val
= (struct value
*) xrealloc (val
, sizeof (struct value
) + TYPE_LENGTH (new_encl_type
));
878 VALUE_ENCLOSING_TYPE (new_val
) = new_encl_type
;
880 /* We have to make sure this ends up in the same place in the value
881 chain as the original copy, so it's clean-up behavior is the same.
882 If the value has been released, this is a waste of time, but there
883 is no way to tell that in advance, so... */
885 if (val
!= all_values
)
887 for (prev
= all_values
; prev
!= NULL
; prev
= prev
->next
)
889 if (prev
->next
== val
)
891 prev
->next
= new_val
;
901 /* Given a value ARG1 (offset by OFFSET bytes)
902 of a struct or union type ARG_TYPE,
903 extract and return the value of one of its (non-static) fields.
904 FIELDNO says which field. */
907 value_primitive_field (struct value
*arg1
, int offset
,
908 int fieldno
, struct type
*arg_type
)
913 CHECK_TYPEDEF (arg_type
);
914 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
916 /* Handle packed fields */
918 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
920 v
= value_from_longest (type
,
921 unpack_field_as_long (arg_type
,
922 VALUE_CONTENTS (arg1
)
925 v
->bitpos
= TYPE_FIELD_BITPOS (arg_type
, fieldno
) % 8;
926 v
->bitsize
= TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
927 v
->offset
= value_offset (arg1
) + offset
928 + TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
930 else if (fieldno
< TYPE_N_BASECLASSES (arg_type
))
932 /* This field is actually a base subobject, so preserve the
933 entire object's contents for later references to virtual
935 v
= allocate_value (VALUE_ENCLOSING_TYPE (arg1
));
937 if (VALUE_LAZY (arg1
))
940 memcpy (VALUE_CONTENTS_ALL_RAW (v
), VALUE_CONTENTS_ALL_RAW (arg1
),
941 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg1
)));
942 v
->offset
= value_offset (arg1
);
943 VALUE_EMBEDDED_OFFSET (v
)
945 VALUE_EMBEDDED_OFFSET (arg1
) +
946 TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
950 /* Plain old data member */
951 offset
+= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
952 v
= allocate_value (type
);
953 if (VALUE_LAZY (arg1
))
956 memcpy (VALUE_CONTENTS_RAW (v
),
957 VALUE_CONTENTS_RAW (arg1
) + offset
,
959 v
->offset
= (value_offset (arg1
) + offset
960 + VALUE_EMBEDDED_OFFSET (arg1
));
962 VALUE_LVAL (v
) = VALUE_LVAL (arg1
);
963 if (VALUE_LVAL (arg1
) == lval_internalvar
)
964 VALUE_LVAL (v
) = lval_internalvar_component
;
965 VALUE_ADDRESS (v
) = VALUE_ADDRESS (arg1
);
966 VALUE_REGNUM (v
) = VALUE_REGNUM (arg1
);
967 /* VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
968 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; */
972 /* Given a value ARG1 of a struct or union type,
973 extract and return the value of one of its (non-static) fields.
974 FIELDNO says which field. */
977 value_field (struct value
*arg1
, int fieldno
)
979 return value_primitive_field (arg1
, 0, fieldno
, value_type (arg1
));
982 /* Return a non-virtual function as a value.
983 F is the list of member functions which contains the desired method.
984 J is an index into F which provides the desired method.
986 We only use the symbol for its address, so be happy with either a
987 full symbol or a minimal symbol.
991 value_fn_field (struct value
**arg1p
, struct fn_field
*f
, int j
, struct type
*type
,
995 struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
996 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
998 struct minimal_symbol
*msym
;
1000 sym
= lookup_symbol (physname
, 0, VAR_DOMAIN
, 0, NULL
);
1007 gdb_assert (sym
== NULL
);
1008 msym
= lookup_minimal_symbol (physname
, NULL
, NULL
);
1013 v
= allocate_value (ftype
);
1016 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1020 VALUE_ADDRESS (v
) = SYMBOL_VALUE_ADDRESS (msym
);
1025 if (type
!= value_type (*arg1p
))
1026 *arg1p
= value_ind (value_cast (lookup_pointer_type (type
),
1027 value_addr (*arg1p
)));
1029 /* Move the `this' pointer according to the offset.
1030 VALUE_OFFSET (*arg1p) += offset;
1038 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1041 Extracting bits depends on endianness of the machine. Compute the
1042 number of least significant bits to discard. For big endian machines,
1043 we compute the total number of bits in the anonymous object, subtract
1044 off the bit count from the MSB of the object to the MSB of the
1045 bitfield, then the size of the bitfield, which leaves the LSB discard
1046 count. For little endian machines, the discard count is simply the
1047 number of bits from the LSB of the anonymous object to the LSB of the
1050 If the field is signed, we also do sign extension. */
1053 unpack_field_as_long (struct type
*type
, const char *valaddr
, int fieldno
)
1057 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
1058 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
1060 struct type
*field_type
;
1062 val
= extract_unsigned_integer (valaddr
+ bitpos
/ 8, sizeof (val
));
1063 field_type
= TYPE_FIELD_TYPE (type
, fieldno
);
1064 CHECK_TYPEDEF (field_type
);
1066 /* Extract bits. See comment above. */
1068 if (BITS_BIG_ENDIAN
)
1069 lsbcount
= (sizeof val
* 8 - bitpos
% 8 - bitsize
);
1071 lsbcount
= (bitpos
% 8);
1074 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1075 If the field is signed, and is negative, then sign extend. */
1077 if ((bitsize
> 0) && (bitsize
< 8 * (int) sizeof (val
)))
1079 valmask
= (((ULONGEST
) 1) << bitsize
) - 1;
1081 if (!TYPE_UNSIGNED (field_type
))
1083 if (val
& (valmask
^ (valmask
>> 1)))
1092 /* Modify the value of a bitfield. ADDR points to a block of memory in
1093 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1094 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1095 indicate which bits (in target bit order) comprise the bitfield.
1096 Requires 0 < BITSIZE <= lbits, 0 <= BITPOS+BITSIZE <= lbits, and
1097 0 <= BITPOS, where lbits is the size of a LONGEST in bits. */
1100 modify_field (char *addr
, LONGEST fieldval
, int bitpos
, int bitsize
)
1103 ULONGEST mask
= (ULONGEST
) -1 >> (8 * sizeof (ULONGEST
) - bitsize
);
1105 /* If a negative fieldval fits in the field in question, chop
1106 off the sign extension bits. */
1107 if ((~fieldval
& ~(mask
>> 1)) == 0)
1110 /* Warn if value is too big to fit in the field in question. */
1111 if (0 != (fieldval
& ~mask
))
1113 /* FIXME: would like to include fieldval in the message, but
1114 we don't have a sprintf_longest. */
1115 warning ("Value does not fit in %d bits.", bitsize
);
1117 /* Truncate it, otherwise adjoining fields may be corrupted. */
1121 oword
= extract_unsigned_integer (addr
, sizeof oword
);
1123 /* Shifting for bit field depends on endianness of the target machine. */
1124 if (BITS_BIG_ENDIAN
)
1125 bitpos
= sizeof (oword
) * 8 - bitpos
- bitsize
;
1127 oword
&= ~(mask
<< bitpos
);
1128 oword
|= fieldval
<< bitpos
;
1130 store_unsigned_integer (addr
, sizeof oword
, oword
);
1133 /* Convert C numbers into newly allocated values */
1136 value_from_longest (struct type
*type
, LONGEST num
)
1138 struct value
*val
= allocate_value (type
);
1139 enum type_code code
;
1142 code
= TYPE_CODE (type
);
1143 len
= TYPE_LENGTH (type
);
1147 case TYPE_CODE_TYPEDEF
:
1148 type
= check_typedef (type
);
1151 case TYPE_CODE_CHAR
:
1152 case TYPE_CODE_ENUM
:
1153 case TYPE_CODE_BOOL
:
1154 case TYPE_CODE_RANGE
:
1155 store_signed_integer (VALUE_CONTENTS_RAW (val
), len
, num
);
1160 store_typed_address (VALUE_CONTENTS_RAW (val
), type
, (CORE_ADDR
) num
);
1164 error ("Unexpected type (%d) encountered for integer constant.", code
);
1170 /* Create a value representing a pointer of type TYPE to the address
1173 value_from_pointer (struct type
*type
, CORE_ADDR addr
)
1175 struct value
*val
= allocate_value (type
);
1176 store_typed_address (VALUE_CONTENTS_RAW (val
), type
, addr
);
1181 /* Create a value for a string constant to be stored locally
1182 (not in the inferior's memory space, but in GDB memory).
1183 This is analogous to value_from_longest, which also does not
1184 use inferior memory. String shall NOT contain embedded nulls. */
1187 value_from_string (char *ptr
)
1190 int len
= strlen (ptr
);
1191 int lowbound
= current_language
->string_lower_bound
;
1192 struct type
*string_char_type
;
1193 struct type
*rangetype
;
1194 struct type
*stringtype
;
1196 rangetype
= create_range_type ((struct type
*) NULL
,
1198 lowbound
, len
+ lowbound
- 1);
1199 string_char_type
= language_string_char_type (current_language
,
1201 stringtype
= create_array_type ((struct type
*) NULL
,
1204 val
= allocate_value (stringtype
);
1205 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, len
);
1210 value_from_double (struct type
*type
, DOUBLEST num
)
1212 struct value
*val
= allocate_value (type
);
1213 struct type
*base_type
= check_typedef (type
);
1214 enum type_code code
= TYPE_CODE (base_type
);
1215 int len
= TYPE_LENGTH (base_type
);
1217 if (code
== TYPE_CODE_FLT
)
1219 store_typed_floating (VALUE_CONTENTS_RAW (val
), base_type
, num
);
1222 error ("Unexpected type encountered for floating constant.");
1228 coerce_ref (struct value
*arg
)
1230 struct type
*value_type_arg_tmp
= check_typedef (value_type (arg
));
1231 if (TYPE_CODE (value_type_arg_tmp
) == TYPE_CODE_REF
)
1232 arg
= value_at_lazy (TYPE_TARGET_TYPE (value_type_arg_tmp
),
1233 unpack_pointer (value_type (arg
),
1234 VALUE_CONTENTS (arg
)));
1239 coerce_array (struct value
*arg
)
1241 arg
= coerce_ref (arg
);
1242 if (current_language
->c_style_arrays
1243 && TYPE_CODE (value_type (arg
)) == TYPE_CODE_ARRAY
)
1244 arg
= value_coerce_array (arg
);
1245 if (TYPE_CODE (value_type (arg
)) == TYPE_CODE_FUNC
)
1246 arg
= value_coerce_function (arg
);
1251 coerce_number (struct value
*arg
)
1253 arg
= coerce_array (arg
);
1254 arg
= coerce_enum (arg
);
1259 coerce_enum (struct value
*arg
)
1261 if (TYPE_CODE (check_typedef (value_type (arg
))) == TYPE_CODE_ENUM
)
1262 arg
= value_cast (builtin_type_unsigned_int
, arg
);
1267 /* Should we use DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS instead of
1268 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc and TYPE
1269 is the type (which is known to be struct, union or array).
1271 On most machines, the struct convention is used unless we are
1272 using gcc and the type is of a special size. */
1273 /* As of about 31 Mar 93, GCC was changed to be compatible with the
1274 native compiler. GCC 2.3.3 was the last release that did it the
1275 old way. Since gcc2_compiled was not changed, we have no
1276 way to correctly win in all cases, so we just do the right thing
1277 for gcc1 and for gcc2 after this change. Thus it loses for gcc
1278 2.0-2.3.3. This is somewhat unfortunate, but changing gcc2_compiled
1279 would cause more chaos than dealing with some struct returns being
1281 /* NOTE: cagney/2004-06-13: Deleted check for "gcc_p". GCC 1.x is
1285 generic_use_struct_convention (int gcc_p
, struct type
*value_type
)
1287 return !(TYPE_LENGTH (value_type
) == 1
1288 || TYPE_LENGTH (value_type
) == 2
1289 || TYPE_LENGTH (value_type
) == 4
1290 || TYPE_LENGTH (value_type
) == 8);
1293 /* Return true if the function returning the specified type is using
1294 the convention of returning structures in memory (passing in the
1295 address as a hidden first parameter). GCC_P is nonzero if compiled
1299 using_struct_return (struct type
*value_type
, int gcc_p
)
1301 enum type_code code
= TYPE_CODE (value_type
);
1303 if (code
== TYPE_CODE_ERROR
)
1304 error ("Function return type unknown.");
1306 if (code
== TYPE_CODE_VOID
)
1307 /* A void return value is never in memory. See also corresponding
1308 code in "print_return_value". */
1311 /* Probe the architecture for the return-value convention. */
1312 return (gdbarch_return_value (current_gdbarch
, value_type
,
1314 != RETURN_VALUE_REGISTER_CONVENTION
);
1318 _initialize_values (void)
1320 add_cmd ("convenience", no_class
, show_convenience
,
1321 "Debugger convenience (\"$foo\") variables.\n\
1322 These variables are created when you assign them values;\n\
1323 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\
1324 A few convenience variables are given values automatically:\n\
1325 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1326 \"$__\" holds the contents of the last address examined with \"x\".",
1329 add_cmd ("values", no_class
, show_values
,
1330 "Elements of value history around item number IDX (or last ten).",