X-Git-Url: https://repo.jachan.dev/binutils.git/blobdiff_plain/7d85ee0220e8d2c0164efc94057d8b01bb2d1111..8d4e307105edd5f21154824fd5839896ae6e6d84:/gdb/value.c diff --git a/gdb/value.c b/gdb/value.c index ffb70fbe42..2cb989d636 100644 --- a/gdb/value.c +++ b/gdb/value.c @@ -1,14 +1,14 @@ /* Low level packing and unpacking of values for GDB, the GNU Debugger. Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, - 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007 + 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -17,9 +17,7 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ + along with this program. If not, see . */ #include "defs.h" #include "gdb_string.h" @@ -31,12 +29,12 @@ #include "gdbcmd.h" #include "target.h" #include "language.h" -#include "scm-lang.h" #include "demangle.h" #include "doublest.h" #include "gdb_assert.h" #include "regcache.h" #include "block.h" +#include "dfp.h" /* Prototypes for exported functions. */ @@ -74,8 +72,8 @@ struct value int bitsize; /* Only used for bitfields; position of start of field. For - BITS_BIG_ENDIAN=0 targets, it is the position of the LSB. For - BITS_BIG_ENDIAN=1 targets, it is the position of the MSB. */ + gdbarch_bits_big_endian=0 targets, it is the position of the LSB. For + gdbarch_bits_big_endian=1 targets, it is the position of the MSB. */ int bitpos; /* Frame register value is relative to. This will be described in @@ -158,6 +156,9 @@ struct value actually exist in the program. */ char optimized_out; + /* If value is a variable, is it initialized or not. */ + int initialized; + /* Actual contents of the value. For use of this value; setting it uses the stuff above. Not valid if lazy is nonzero. Target byte-order. We force it to be aligned properly for any possible @@ -233,6 +234,7 @@ allocate_value (struct type *type) val->embedded_offset = 0; val->pointed_to_offset = 0; val->modifiable = 1; + val->initialized = 1; /* Default to initialized. */ return val; } @@ -741,10 +743,10 @@ init_if_undefined_command (char* args, int from_tty) normally include a dollar sign. If the specified internal variable does not exist, - one is created, with a void value. */ + the return value is NULL. */ struct internalvar * -lookup_internalvar (char *name) +lookup_only_internalvar (char *name) { struct internalvar *var; @@ -752,16 +754,46 @@ lookup_internalvar (char *name) if (strcmp (var->name, name) == 0) return var; + return NULL; +} + + +/* Create an internal variable with name NAME and with a void value. + NAME should not normally include a dollar sign. */ + +struct internalvar * +create_internalvar (char *name) +{ + struct internalvar *var; var = (struct internalvar *) xmalloc (sizeof (struct internalvar)); var->name = concat (name, (char *)NULL); var->value = allocate_value (builtin_type_void); - var->endian = TARGET_BYTE_ORDER; + var->endian = gdbarch_byte_order (current_gdbarch); release_value (var->value); var->next = internalvars; internalvars = var; return var; } + +/* Look up an internal variable with name NAME. NAME should not + normally include a dollar sign. + + If the specified internal variable does not exist, + one is created, with a void value. */ + +struct internalvar * +lookup_internalvar (char *name) +{ + struct internalvar *var; + + var = lookup_only_internalvar (name); + if (var) + return var; + + return create_internalvar (name); +} + struct value * value_of_internalvar (struct internalvar *var) { @@ -787,7 +819,7 @@ value_of_internalvar (struct internalvar *var) point types) are left alone, because they would be too complicated to correct. */ - if (var->endian != TARGET_BYTE_ORDER) + if (var->endian != gdbarch_byte_order (current_gdbarch)) { gdb_byte *array = value_contents_raw (val); struct type *type = check_typedef (value_enclosing_type (val)); @@ -844,7 +876,7 @@ set_internalvar (struct internalvar *var, struct value *val) long. */ xfree (var->value); var->value = newval; - var->endian = TARGET_BYTE_ORDER; + var->endian = gdbarch_byte_order (current_gdbarch); release_value (newval); /* End code which must not call error(). */ } @@ -950,6 +982,7 @@ value_as_double (struct value *val) error (_("Invalid floating value found in program.")); return foo; } + /* Extract a value as a C pointer. Does not deallocate the value. Note that val's type may not actually be a pointer; value_as_long handles all the cases. */ @@ -959,10 +992,10 @@ value_as_address (struct value *val) /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure whether we want this to be true eventually. */ #if 0 - /* ADDR_BITS_REMOVE is wrong if we are being called for a + /* gdbarch_addr_bits_remove is wrong if we are being called for a non-address (e.g. argument to "signal", "info break", etc.), or for pointers to char, in which the low bits *are* significant. */ - return ADDR_BITS_REMOVE (value_as_long (val)); + return gdbarch_addr_bits_remove (current_gdbarch, value_as_long (val)); #else /* There are several targets (IA-64, PowerPC, and others) which @@ -1076,10 +1109,6 @@ unpack_long (struct type *type, const gdb_byte *valaddr) int len = TYPE_LENGTH (type); int nosign = TYPE_UNSIGNED (type); - if (current_language->la_language == language_scm - && is_scmvalue_type (type)) - return scm_unpack (type, valaddr, TYPE_CODE_INT); - switch (code) { case TYPE_CODE_TYPEDEF: @@ -1099,6 +1128,11 @@ unpack_long (struct type *type, const gdb_byte *valaddr) case TYPE_CODE_FLT: return extract_typed_floating (valaddr, type); + case TYPE_CODE_DECFLOAT: + /* libdecnumber has a function to convert from decimal to integer, but + it doesn't work when the decimal number has a fractional part. */ + return decimal_to_doublest (valaddr, len); + case TYPE_CODE_PTR: case TYPE_CODE_REF: /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure @@ -1139,7 +1173,7 @@ unpack_double (struct type *type, const gdb_byte *valaddr, int *invp) only in a non-portable way. Fixing the portability problem wouldn't help since the VAX floating-point code is also badly bit-rotten. The target needs to add definitions for the - methods TARGET_FLOAT_FORMAT and TARGET_DOUBLE_FORMAT - these + methods gdbarch_float_format and gdbarch_double_format - these exactly describe the target floating-point format. The problem here is that the corresponding floatformat_vax_f and floatformat_vax_d values these methods should be set to are @@ -1156,6 +1190,8 @@ unpack_double (struct type *type, const gdb_byte *valaddr, int *invp) return extract_typed_floating (valaddr, type); } + else if (code == TYPE_CODE_DECFLOAT) + return decimal_to_doublest (valaddr, len); else if (nosign) { /* Unsigned -- be sure we compensate for signed LONGEST. */ @@ -1445,7 +1481,7 @@ unpack_field_as_long (struct type *type, const gdb_byte *valaddr, int fieldno) /* Extract bits. See comment above. */ - if (BITS_BIG_ENDIAN) + if (gdbarch_bits_big_endian (current_gdbarch)) lsbcount = (sizeof val * 8 - bitpos % 8 - bitsize); else lsbcount = (bitpos % 8); @@ -1501,7 +1537,7 @@ modify_field (gdb_byte *addr, LONGEST fieldval, int bitpos, int bitsize) oword = extract_unsigned_integer (addr, sizeof oword); /* Shifting for bit field depends on endianness of the target machine. */ - if (BITS_BIG_ENDIAN) + if (gdbarch_bits_big_endian (current_gdbarch)) bitpos = sizeof (oword) * 8 - bitpos - bitsize; oword &= ~(mask << bitpos); @@ -1510,23 +1546,18 @@ modify_field (gdb_byte *addr, LONGEST fieldval, int bitpos, int bitsize) store_unsigned_integer (addr, sizeof oword, oword); } -/* Convert C numbers into newly allocated values */ +/* Pack NUM into BUF using a target format of TYPE. */ -struct value * -value_from_longest (struct type *type, LONGEST num) +void +pack_long (gdb_byte *buf, struct type *type, LONGEST num) { - struct value *val = allocate_value (type); - enum type_code code; int len; -retry: - code = TYPE_CODE (type); + + type = check_typedef (type); len = TYPE_LENGTH (type); - switch (code) + switch (TYPE_CODE (type)) { - case TYPE_CODE_TYPEDEF: - type = check_typedef (type); - goto retry; case TYPE_CODE_INT: case TYPE_CODE_CHAR: case TYPE_CODE_ENUM: @@ -1534,17 +1565,30 @@ retry: case TYPE_CODE_BOOL: case TYPE_CODE_RANGE: case TYPE_CODE_MEMBERPTR: - store_signed_integer (value_contents_raw (val), len, num); + store_signed_integer (buf, len, num); break; case TYPE_CODE_REF: case TYPE_CODE_PTR: - store_typed_address (value_contents_raw (val), type, (CORE_ADDR) num); + store_typed_address (buf, type, (CORE_ADDR) num); break; default: - error (_("Unexpected type (%d) encountered for integer constant."), code); + error (_("Unexpected type (%d) encountered for integer constant."), + TYPE_CODE (type)); } +} + + +/* Convert C numbers into newly allocated values. */ + +struct value * +value_from_longest (struct type *type, LONGEST num) +{ + struct value *val = allocate_value (type); + + pack_long (value_contents_raw (val), type, num); + return val; } @@ -1606,6 +1650,16 @@ value_from_double (struct type *type, DOUBLEST num) return val; } +struct value * +value_from_decfloat (struct type *type, const gdb_byte *dec) +{ + struct value *val = allocate_value (type); + + memcpy (value_contents_raw (val), dec, TYPE_LENGTH (type)); + + return val; +} + struct value * coerce_ref (struct value *arg) { @@ -1646,39 +1700,12 @@ coerce_enum (struct value *arg) } -/* Should we use DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS instead of - EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc and TYPE - is the type (which is known to be struct, union or array). - - On most machines, the struct convention is used unless we are - using gcc and the type is of a special size. */ -/* As of about 31 Mar 93, GCC was changed to be compatible with the - native compiler. GCC 2.3.3 was the last release that did it the - old way. Since gcc2_compiled was not changed, we have no - way to correctly win in all cases, so we just do the right thing - for gcc1 and for gcc2 after this change. Thus it loses for gcc - 2.0-2.3.3. This is somewhat unfortunate, but changing gcc2_compiled - would cause more chaos than dealing with some struct returns being - handled wrong. */ -/* NOTE: cagney/2004-06-13: Deleted check for "gcc_p". GCC 1.x is - dead. */ - -int -generic_use_struct_convention (int gcc_p, struct type *value_type) -{ - return !(TYPE_LENGTH (value_type) == 1 - || TYPE_LENGTH (value_type) == 2 - || TYPE_LENGTH (value_type) == 4 - || TYPE_LENGTH (value_type) == 8); -} - /* Return true if the function returning the specified type is using the convention of returning structures in memory (passing in the - address as a hidden first parameter). GCC_P is nonzero if compiled - with GCC. */ + address as a hidden first parameter). */ int -using_struct_return (struct type *value_type, int gcc_p) +using_struct_return (struct type *func_type, struct type *value_type) { enum type_code code = TYPE_CODE (value_type); @@ -1691,11 +1718,27 @@ using_struct_return (struct type *value_type, int gcc_p) return 0; /* Probe the architecture for the return-value convention. */ - return (gdbarch_return_value (current_gdbarch, value_type, + return (gdbarch_return_value (current_gdbarch, func_type, value_type, NULL, NULL, NULL) != RETURN_VALUE_REGISTER_CONVENTION); } +/* Set the initialized field in a value struct. */ + +void +set_value_initialized (struct value *val, int status) +{ + val->initialized = status; +} + +/* Return the initialized field in a value struct. */ + +int +value_initialized (struct value *val) +{ + return val->initialized; +} + void _initialize_values (void) {