2004-11-09 Andrew Cagney <cagney@gnu.org>

	* values.c: Rename to ...
	* value.c: ..., new file.
	* Makefile.in: Update.

1 files changed, 1267 insertions, 0 deletions

diff --git a/gdb/value.c b/gdb/value.c
new file mode 100644
index 0000000..0a82927
--- /dev/null
+++ b/gdb/value.c
@@ -0,0 +1,1267 @@
+/* Low level packing and unpacking of values for GDB, the GNU Debugger.
+
+   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
+   1995, 1996, 1997, 1998, 1999, 2000, 2002, 2003 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
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "gdb_string.h"
+#include "symtab.h"
+#include "gdbtypes.h"
+#include "value.h"
+#include "gdbcore.h"
+#include "command.h"
+#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"
+
+/* Prototypes for exported functions. */
+
+void _initialize_values (void);
+
+/* Prototypes for local functions. */
+
+static void show_values (char *, int);
+
+static void show_convenience (char *, int);
+
+
+/* The value-history records all the values printed
+   by print commands during this session.  Each chunk
+   records 60 consecutive values.  The first chunk on
+   the chain records the most recent values.
+   The total number of values is in value_history_count.  */
+
+#define VALUE_HISTORY_CHUNK 60
+
+struct value_history_chunk
+  {
+    struct value_history_chunk *next;
+    struct value *values[VALUE_HISTORY_CHUNK];
+  };
+
+/* Chain of chunks now in use.  */
+
+static struct value_history_chunk *value_history_chain;
+
+static int value_history_count;	/* Abs number of last entry stored */
+
+/* List of all value objects currently allocated
+   (except for those released by calls to release_value)
+   This is so they can be freed after each command.  */
+
+static struct value *all_values;
+
+/* Allocate a  value  that has the correct length for type TYPE.  */
+
+struct value *
+allocate_value (struct type *type)
+{
+  struct value *val;
+  struct type *atype = check_typedef (type);
+
+  val = (struct value *) xmalloc (sizeof (struct value) + TYPE_LENGTH (atype));
+  VALUE_NEXT (val) = all_values;
+  all_values = val;
+  VALUE_TYPE (val) = type;
+  VALUE_ENCLOSING_TYPE (val) = type;
+  VALUE_LVAL (val) = not_lval;
+  VALUE_ADDRESS (val) = 0;
+  VALUE_FRAME_ID (val) = null_frame_id;
+  VALUE_OFFSET (val) = 0;
+  VALUE_BITPOS (val) = 0;
+  VALUE_BITSIZE (val) = 0;
+  VALUE_REGNO (val) = -1;
+  VALUE_LAZY (val) = 0;
+  VALUE_OPTIMIZED_OUT (val) = 0;
+  VALUE_EMBEDDED_OFFSET (val) = 0;
+  VALUE_POINTED_TO_OFFSET (val) = 0;
+  val->modifiable = 1;
+  return val;
+}
+
+/* Allocate a  value  that has the correct length
+   for COUNT repetitions type TYPE.  */
+
+struct value *
+allocate_repeat_value (struct type *type, int count)
+{
+  int low_bound = current_language->string_lower_bound;		/* ??? */
+  /* FIXME-type-allocation: need a way to free this type when we are
+     done with it.  */
+  struct type *range_type
+  = create_range_type ((struct type *) NULL, builtin_type_int,
+		       low_bound, count + low_bound - 1);
+  /* FIXME-type-allocation: need a way to free this type when we are
+     done with it.  */
+  return allocate_value (create_array_type ((struct type *) NULL,
+					    type, range_type));
+}
+
+/* Return a mark in the value chain.  All values allocated after the
+   mark is obtained (except for those released) are subject to being freed
+   if a subsequent value_free_to_mark is passed the mark.  */
+struct value *
+value_mark (void)
+{
+  return all_values;
+}
+
+/* Free all values allocated since MARK was obtained by value_mark
+   (except for those released).  */
+void
+value_free_to_mark (struct value *mark)
+{
+  struct value *val;
+  struct value *next;
+
+  for (val = all_values; val && val != mark; val = next)
+    {
+      next = VALUE_NEXT (val);
+      value_free (val);
+    }
+  all_values = val;
+}
+
+/* Free all the values that have been allocated (except for those released).
+   Called after each command, successful or not.  */
+
+void
+free_all_values (void)
+{
+  struct value *val;
+  struct value *next;
+
+  for (val = all_values; val; val = next)
+    {
+      next = VALUE_NEXT (val);
+      value_free (val);
+    }
+
+  all_values = 0;
+}
+
+/* Remove VAL from the chain all_values
+   so it will not be freed automatically.  */
+
+void
+release_value (struct value *val)
+{
+  struct value *v;
+
+  if (all_values == val)
+    {
+      all_values = val->next;
+      return;
+    }
+
+  for (v = all_values; v; v = v->next)
+    {
+      if (v->next == val)
+	{
+	  v->next = val->next;
+	  break;
+	}
+    }
+}
+
+/* Release all values up to mark  */
+struct value *
+value_release_to_mark (struct value *mark)
+{
+  struct value *val;
+  struct value *next;
+
+  for (val = next = all_values; next; next = VALUE_NEXT (next))
+    if (VALUE_NEXT (next) == mark)
+      {
+	all_values = VALUE_NEXT (next);
+	VALUE_NEXT (next) = 0;
+	return val;
+      }
+  all_values = 0;
+  return val;
+}
+
+/* Return a copy of the value ARG.
+   It contains the same contents, for same memory address,
+   but it's a different block of storage.  */
+
+struct value *
+value_copy (struct value *arg)
+{
+  struct type *encl_type = VALUE_ENCLOSING_TYPE (arg);
+  struct value *val = allocate_value (encl_type);
+  VALUE_TYPE (val) = VALUE_TYPE (arg);
+  VALUE_LVAL (val) = VALUE_LVAL (arg);
+  VALUE_ADDRESS (val) = VALUE_ADDRESS (arg);
+  VALUE_OFFSET (val) = VALUE_OFFSET (arg);
+  VALUE_BITPOS (val) = VALUE_BITPOS (arg);
+  VALUE_BITSIZE (val) = VALUE_BITSIZE (arg);
+  VALUE_FRAME_ID (val) = VALUE_FRAME_ID (arg);
+  VALUE_REGNO (val) = VALUE_REGNO (arg);
+  VALUE_LAZY (val) = VALUE_LAZY (arg);
+  VALUE_OPTIMIZED_OUT (val) = VALUE_OPTIMIZED_OUT (arg);
+  VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (arg);
+  VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (arg);
+  val->modifiable = arg->modifiable;
+  if (!VALUE_LAZY (val))
+    {
+      memcpy (VALUE_CONTENTS_ALL_RAW (val), VALUE_CONTENTS_ALL_RAW (arg),
+	      TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg)));
+
+    }
+  return val;
+}
+
+/* Access to the value history.  */
+
+/* Record a new value in the value history.
+   Returns the absolute history index of the entry.
+   Result of -1 indicates the value was not saved; otherwise it is the
+   value history index of this new item.  */
+
+int
+record_latest_value (struct value *val)
+{
+  int i;
+
+  /* We don't want this value to have anything to do with the inferior anymore.
+     In particular, "set $1 = 50" should not affect the variable from which
+     the value was taken, and fast watchpoints should be able to assume that
+     a value on the value history never changes.  */
+  if (VALUE_LAZY (val))
+    value_fetch_lazy (val);
+  /* We preserve VALUE_LVAL so that the user can find out where it was fetched
+     from.  This is a bit dubious, because then *&$1 does not just return $1
+     but the current contents of that location.  c'est la vie...  */
+  val->modifiable = 0;
+  release_value (val);
+
+  /* Here we treat value_history_count as origin-zero
+     and applying to the value being stored now.  */
+
+  i = value_history_count % VALUE_HISTORY_CHUNK;
+  if (i == 0)
+    {
+      struct value_history_chunk *new
+      = (struct value_history_chunk *)
+      xmalloc (sizeof (struct value_history_chunk));
+      memset (new->values, 0, sizeof new->values);
+      new->next = value_history_chain;
+      value_history_chain = new;
+    }
+
+  value_history_chain->values[i] = val;
+
+  /* Now we regard value_history_count as origin-one
+     and applying to the value just stored.  */
+
+  return ++value_history_count;
+}
+
+/* Return a copy of the value in the history with sequence number NUM.  */
+
+struct value *
+access_value_history (int num)
+{
+  struct value_history_chunk *chunk;
+  int i;
+  int absnum = num;
+
+  if (absnum <= 0)
+    absnum += value_history_count;
+
+  if (absnum <= 0)
+    {
+      if (num == 0)
+	error ("The history is empty.");
+      else if (num == 1)
+	error ("There is only one value in the history.");
+      else
+	error ("History does not go back to $$%d.", -num);
+    }
+  if (absnum > value_history_count)
+    error ("History has not yet reached $%d.", absnum);
+
+  absnum--;
+
+  /* Now absnum is always absolute and origin zero.  */
+
+  chunk = value_history_chain;
+  for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK - absnum / VALUE_HISTORY_CHUNK;
+       i > 0; i--)
+    chunk = chunk->next;
+
+  return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]);
+}
+
+/* Clear the value history entirely.
+   Must be done when new symbol tables are loaded,
+   because the type pointers become invalid.  */
+
+void
+clear_value_history (void)
+{
+  struct value_history_chunk *next;
+  int i;
+  struct value *val;
+
+  while (value_history_chain)
+    {
+      for (i = 0; i < VALUE_HISTORY_CHUNK; i++)
+	if ((val = value_history_chain->values[i]) != NULL)
+	  xfree (val);
+      next = value_history_chain->next;
+      xfree (value_history_chain);
+      value_history_chain = next;
+    }
+  value_history_count = 0;
+}
+
+static void
+show_values (char *num_exp, int from_tty)
+{
+  int i;
+  struct value *val;
+  static int num = 1;
+
+  if (num_exp)
+    {
+      /* "info history +" should print from the stored position.
+         "info history <exp>" should print around value number <exp>.  */
+      if (num_exp[0] != '+' || num_exp[1] != '\0')
+	num = parse_and_eval_long (num_exp) - 5;
+    }
+  else
+    {
+      /* "info history" means print the last 10 values.  */
+      num = value_history_count - 9;
+    }
+
+  if (num <= 0)
+    num = 1;
+
+  for (i = num; i < num + 10 && i <= value_history_count; i++)
+    {
+      val = access_value_history (i);
+      printf_filtered ("$%d = ", i);
+      value_print (val, gdb_stdout, 0, Val_pretty_default);
+      printf_filtered ("\n");
+    }
+
+  /* The next "info history +" should start after what we just printed.  */
+  num += 10;
+
+  /* Hitting just return after this command should do the same thing as
+     "info history +".  If num_exp is null, this is unnecessary, since
+     "info history +" is not useful after "info history".  */
+  if (from_tty && num_exp)
+    {
+      num_exp[0] = '+';
+      num_exp[1] = '\0';
+    }
+}
+
+/* Internal variables.  These are variables within the debugger
+   that hold values assigned by debugger commands.
+   The user refers to them with a '$' prefix
+   that does not appear in the variable names stored internally.  */
+
+static struct internalvar *internalvars;
+
+/* 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;
+
+  for (var = internalvars; var; var = var->next)
+    if (strcmp (var->name, name) == 0)
+      return var;
+
+  var = (struct internalvar *) xmalloc (sizeof (struct internalvar));
+  var->name = concat (name, NULL);
+  var->value = allocate_value (builtin_type_void);
+  release_value (var->value);
+  var->next = internalvars;
+  internalvars = var;
+  return var;
+}
+
+struct value *
+value_of_internalvar (struct internalvar *var)
+{
+  struct value *val;
+
+  val = value_copy (var->value);
+  if (VALUE_LAZY (val))
+    value_fetch_lazy (val);
+  VALUE_LVAL (val) = lval_internalvar;
+  VALUE_INTERNALVAR (val) = var;
+  return val;
+}
+
+void
+set_internalvar_component (struct internalvar *var, int offset, int bitpos,
+			   int bitsize, struct value *newval)
+{
+  char *addr = VALUE_CONTENTS (var->value) + offset;
+
+  if (bitsize)
+    modify_field (addr, value_as_long (newval),
+		  bitpos, bitsize);
+  else
+    memcpy (addr, VALUE_CONTENTS (newval), TYPE_LENGTH (VALUE_TYPE (newval)));
+}
+
+void
+set_internalvar (struct internalvar *var, struct value *val)
+{
+  struct value *newval;
+
+  newval = value_copy (val);
+  newval->modifiable = 1;
+
+  /* Force the value to be fetched from the target now, to avoid problems
+     later when this internalvar is referenced and the target is gone or
+     has changed.  */
+  if (VALUE_LAZY (newval))
+    value_fetch_lazy (newval);
+
+  /* Begin code which must not call error().  If var->value points to
+     something free'd, an error() obviously leaves a dangling pointer.
+     But we also get a danling pointer if var->value points to
+     something in the value chain (i.e., before release_value is
+     called), because after the error free_all_values will get called before
+     long.  */
+  xfree (var->value);
+  var->value = newval;
+  release_value (newval);
+  /* End code which must not call error().  */
+}
+
+char *
+internalvar_name (struct internalvar *var)
+{
+  return var->name;
+}
+
+/* Free all internalvars.  Done when new symtabs are loaded,
+   because that makes the values invalid.  */
+
+void
+clear_internalvars (void)
+{
+  struct internalvar *var;
+
+  while (internalvars)
+    {
+      var = internalvars;
+      internalvars = var->next;
+      xfree (var->name);
+      xfree (var->value);
+      xfree (var);
+    }
+}
+
+static void
+show_convenience (char *ignore, int from_tty)
+{
+  struct internalvar *var;
+  int varseen = 0;
+
+  for (var = internalvars; var; var = var->next)
+    {
+      if (!varseen)
+	{
+	  varseen = 1;
+	}
+      printf_filtered ("$%s = ", var->name);
+      value_print (var->value, gdb_stdout, 0, Val_pretty_default);
+      printf_filtered ("\n");
+    }
+  if (!varseen)
+    printf_unfiltered ("No debugger convenience variables now defined.\n\
+Convenience variables have names starting with \"$\";\n\
+use \"set\" as in \"set $foo = 5\" to define them.\n");
+}
+
+/* Extract a value as a C number (either long or double).
+   Knows how to convert fixed values to double, or
+   floating values to long.
+   Does not deallocate the value.  */
+
+LONGEST
+value_as_long (struct value *val)
+{
+  /* This coerces arrays and functions, which is necessary (e.g.
+     in disassemble_command).  It also dereferences references, which
+     I suspect is the most logical thing to do.  */
+  COERCE_ARRAY (val);
+  return unpack_long (VALUE_TYPE (val), VALUE_CONTENTS (val));
+}
+
+DOUBLEST
+value_as_double (struct value *val)
+{
+  DOUBLEST foo;
+  int inv;
+
+  foo = unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val), &inv);
+  if (inv)
+    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.  */
+CORE_ADDR
+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
+     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));
+#else
+
+  /* There are several targets (IA-64, PowerPC, and others) which
+     don't represent pointers to functions as simply the address of
+     the function's entry point.  For example, on the IA-64, a
+     function pointer points to a two-word descriptor, generated by
+     the linker, which contains the function's entry point, and the
+     value the IA-64 "global pointer" register should have --- to
+     support position-independent code.  The linker generates
+     descriptors only for those functions whose addresses are taken.
+
+     On such targets, it's difficult for GDB to convert an arbitrary
+     function address into a function pointer; it has to either find
+     an existing descriptor for that function, or call malloc and
+     build its own.  On some targets, it is impossible for GDB to
+     build a descriptor at all: the descriptor must contain a jump
+     instruction; data memory cannot be executed; and code memory
+     cannot be modified.
+
+     Upon entry to this function, if VAL is a value of type `function'
+     (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
+     VALUE_ADDRESS (val) is the address of the function.  This is what
+     you'll get if you evaluate an expression like `main'.  The call
+     to COERCE_ARRAY below actually does all the usual unary
+     conversions, which includes converting values of type `function'
+     to `pointer to function'.  This is the challenging conversion
+     discussed above.  Then, `unpack_long' will convert that pointer
+     back into an address.
+
+     So, suppose the user types `disassemble foo' on an architecture
+     with a strange function pointer representation, on which GDB
+     cannot build its own descriptors, and suppose further that `foo'
+     has no linker-built descriptor.  The address->pointer conversion
+     will signal an error and prevent the command from running, even
+     though the next step would have been to convert the pointer
+     directly back into the same address.
+
+     The following shortcut avoids this whole mess.  If VAL is a
+     function, just return its address directly.  */
+  if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC
+      || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_METHOD)
+    return VALUE_ADDRESS (val);
+
+  COERCE_ARRAY (val);
+
+  /* Some architectures (e.g. Harvard), map instruction and data
+     addresses onto a single large unified address space.  For
+     instance: An architecture may consider a large integer in the
+     range 0x10000000 .. 0x1000ffff to already represent a data
+     addresses (hence not need a pointer to address conversion) while
+     a small integer would still need to be converted integer to
+     pointer to address.  Just assume such architectures handle all
+     integer conversions in a single function.  */
+
+  /* JimB writes:
+
+     I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we
+     must admonish GDB hackers to make sure its behavior matches the
+     compiler's, whenever possible.
+
+     In general, I think GDB should evaluate expressions the same way
+     the compiler does.  When the user copies an expression out of
+     their source code and hands it to a `print' command, they should
+     get the same value the compiler would have computed.  Any
+     deviation from this rule can cause major confusion and annoyance,
+     and needs to be justified carefully.  In other words, GDB doesn't
+     really have the freedom to do these conversions in clever and
+     useful ways.
+
+     AndrewC pointed out that users aren't complaining about how GDB
+     casts integers to pointers; they are complaining that they can't
+     take an address from a disassembly listing and give it to `x/i'.
+     This is certainly important.
+
+     Adding an architecture method like INTEGER_TO_ADDRESS certainly
+     makes it possible for GDB to "get it right" in all circumstances
+     --- the target has complete control over how things get done, so
+     people can Do The Right Thing for their target without breaking
+     anyone else.  The standard doesn't specify how integers get
+     converted to pointers; usually, the ABI doesn't either, but
+     ABI-specific code is a more reasonable place to handle it.  */
+
+  if (TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_PTR
+      && TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_REF
+      && INTEGER_TO_ADDRESS_P ())
+    return INTEGER_TO_ADDRESS (VALUE_TYPE (val), VALUE_CONTENTS (val));
+
+  return unpack_long (VALUE_TYPE (val), VALUE_CONTENTS (val));
+#endif
+}
+
+/* Unpack raw data (copied from debugee, target byte order) at VALADDR
+   as a long, or as a double, assuming the raw data is described
+   by type TYPE.  Knows how to convert different sizes of values
+   and can convert between fixed and floating point.  We don't assume
+   any alignment for the raw data.  Return value is in host byte order.
+
+   If you want functions and arrays to be coerced to pointers, and
+   references to be dereferenced, call value_as_long() instead.
+
+   C++: It is assumed that the front-end has taken care of
+   all matters concerning pointers to members.  A pointer
+   to member which reaches here is considered to be equivalent
+   to an INT (or some size).  After all, it is only an offset.  */
+
+LONGEST
+unpack_long (struct type *type, const char *valaddr)
+{
+  enum type_code code = TYPE_CODE (type);
+  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:
+      return unpack_long (check_typedef (type), valaddr);
+    case TYPE_CODE_ENUM:
+    case TYPE_CODE_BOOL:
+    case TYPE_CODE_INT:
+    case TYPE_CODE_CHAR:
+    case TYPE_CODE_RANGE:
+      if (nosign)
+	return extract_unsigned_integer (valaddr, len);
+      else
+	return extract_signed_integer (valaddr, len);
+
+    case TYPE_CODE_FLT:
+      return extract_typed_floating (valaddr, type);
+
+    case TYPE_CODE_PTR:
+    case TYPE_CODE_REF:
+      /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
+         whether we want this to be true eventually.  */
+      return extract_typed_address (valaddr, type);
+
+    case TYPE_CODE_MEMBER:
+      error ("not implemented: member types in unpack_long");
+
+    default:
+      error ("Value can't be converted to integer.");
+    }
+  return 0;			/* Placate lint.  */
+}
+
+/* Return a double value from the specified type and address.
+   INVP points to an int which is set to 0 for valid value,
+   1 for invalid value (bad float format).  In either case,
+   the returned double is OK to use.  Argument is in target
+   format, result is in host format.  */
+
+DOUBLEST
+unpack_double (struct type *type, const char *valaddr, int *invp)
+{
+  enum type_code code;
+  int len;
+  int nosign;
+
+  *invp = 0;			/* Assume valid.   */
+  CHECK_TYPEDEF (type);
+  code = TYPE_CODE (type);
+  len = TYPE_LENGTH (type);
+  nosign = TYPE_UNSIGNED (type);
+  if (code == TYPE_CODE_FLT)
+    {
+      /* NOTE: cagney/2002-02-19: There was a test here to see if the
+	 floating-point value was valid (using the macro
+	 INVALID_FLOAT).  That test/macro have been removed.
+
+	 It turns out that only the VAX defined this macro and then
+	 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
+	 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
+	 also not defined either.  Oops!
+
+         Hopefully someone will add both the missing floatformat
+         definitions and the new cases for floatformat_is_valid ().  */
+
+      if (!floatformat_is_valid (floatformat_from_type (type), valaddr))
+	{
+	  *invp = 1;
+	  return 0.0;
+	}
+
+      return extract_typed_floating (valaddr, type);
+    }
+  else if (nosign)
+    {
+      /* Unsigned -- be sure we compensate for signed LONGEST.  */
+      return (ULONGEST) unpack_long (type, valaddr);
+    }
+  else
+    {
+      /* Signed -- we are OK with unpack_long.  */
+      return unpack_long (type, valaddr);
+    }
+}
+
+/* Unpack raw data (copied from debugee, target byte order) at VALADDR
+   as a CORE_ADDR, assuming the raw data is described by type TYPE.
+   We don't assume any alignment for the raw data.  Return value is in
+   host byte order.
+
+   If you want functions and arrays to be coerced to pointers, and
+   references to be dereferenced, call value_as_address() instead.
+
+   C++: It is assumed that the front-end has taken care of
+   all matters concerning pointers to members.  A pointer
+   to member which reaches here is considered to be equivalent
+   to an INT (or some size).  After all, it is only an offset.  */
+
+CORE_ADDR
+unpack_pointer (struct type *type, const char *valaddr)
+{
+  /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
+     whether we want this to be true eventually.  */
+  return unpack_long (type, valaddr);
+}
+
+
+/* Get the value of the FIELDN'th field (which must be static) of
+   TYPE.  Return NULL if the field doesn't exist or has been
+   optimized out. */
+
+struct value *
+value_static_field (struct type *type, int fieldno)
+{
+  struct value *retval;
+
+  if (TYPE_FIELD_STATIC_HAS_ADDR (type, fieldno))
+    {
+      retval = value_at (TYPE_FIELD_TYPE (type, fieldno),
+			 TYPE_FIELD_STATIC_PHYSADDR (type, fieldno));
+    }
+  else
+    {
+      char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
+      struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0, NULL);
+      if (sym == NULL)
+	{
+	  /* With some compilers, e.g. HP aCC, static data members are reported
+	     as non-debuggable symbols */
+	  struct minimal_symbol *msym = lookup_minimal_symbol (phys_name, NULL, NULL);
+	  if (!msym)
+	    return NULL;
+	  else
+	    {
+	      retval = value_at (TYPE_FIELD_TYPE (type, fieldno),
+				 SYMBOL_VALUE_ADDRESS (msym));
+	    }
+	}
+      else
+	{
+	  /* SYM should never have a SYMBOL_CLASS which will require
+	     read_var_value to use the FRAME parameter.  */
+	  if (symbol_read_needs_frame (sym))
+	    warning ("static field's value depends on the current "
+		     "frame - bad debug info?");
+	  retval = read_var_value (sym, NULL);
+ 	}
+      if (retval && VALUE_LVAL (retval) == lval_memory)
+	SET_FIELD_PHYSADDR (TYPE_FIELD (type, fieldno),
+			    VALUE_ADDRESS (retval));
+    }
+  return retval;
+}
+
+/* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.  
+   You have to be careful here, since the size of the data area for the value 
+   is set by the length of the enclosing type.  So if NEW_ENCL_TYPE is bigger 
+   than the old enclosing type, you have to allocate more space for the data.  
+   The return value is a pointer to the new version of this value structure. */
+
+struct value *
+value_change_enclosing_type (struct value *val, struct type *new_encl_type)
+{
+  if (TYPE_LENGTH (new_encl_type) <= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val))) 
+    {
+      VALUE_ENCLOSING_TYPE (val) = new_encl_type;
+      return val;
+    }
+  else
+    {
+      struct value *new_val;
+      struct value *prev;
+      
+      new_val = (struct value *) xrealloc (val, sizeof (struct value) + TYPE_LENGTH (new_encl_type));
+
+      VALUE_ENCLOSING_TYPE (new_val) = new_encl_type;
+ 
+      /* We have to make sure this ends up in the same place in the value
+	 chain as the original copy, so it's clean-up behavior is the same. 
+	 If the value has been released, this is a waste of time, but there
+	 is no way to tell that in advance, so... */
+      
+      if (val != all_values) 
+	{
+	  for (prev = all_values; prev != NULL; prev = prev->next)
+	    {
+	      if (prev->next == val) 
+		{
+		  prev->next = new_val;
+		  break;
+		}
+	    }
+	}
+      
+      return new_val;
+    }
+}
+
+/* Given a value ARG1 (offset by OFFSET bytes)
+   of a struct or union type ARG_TYPE,
+   extract and return the value of one of its (non-static) fields.
+   FIELDNO says which field. */
+
+struct value *
+value_primitive_field (struct value *arg1, int offset,
+		       int fieldno, struct type *arg_type)
+{
+  struct value *v;
+  struct type *type;
+
+  CHECK_TYPEDEF (arg_type);
+  type = TYPE_FIELD_TYPE (arg_type, fieldno);
+
+  /* Handle packed fields */
+
+  if (TYPE_FIELD_BITSIZE (arg_type, fieldno))
+    {
+      v = value_from_longest (type,
+			      unpack_field_as_long (arg_type,
+						    VALUE_CONTENTS (arg1)
+						    + offset,
+						    fieldno));
+      VALUE_BITPOS (v) = TYPE_FIELD_BITPOS (arg_type, fieldno) % 8;
+      VALUE_BITSIZE (v) = TYPE_FIELD_BITSIZE (arg_type, fieldno);
+      VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
+	+ TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
+    }
+  else if (fieldno < TYPE_N_BASECLASSES (arg_type))
+    {
+      /* This field is actually a base subobject, so preserve the
+         entire object's contents for later references to virtual
+         bases, etc.  */
+      v = allocate_value (VALUE_ENCLOSING_TYPE (arg1));
+      VALUE_TYPE (v) = type;
+      if (VALUE_LAZY (arg1))
+	VALUE_LAZY (v) = 1;
+      else
+	memcpy (VALUE_CONTENTS_ALL_RAW (v), VALUE_CONTENTS_ALL_RAW (arg1),
+		TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg1)));
+      VALUE_OFFSET (v) = VALUE_OFFSET (arg1);
+      VALUE_EMBEDDED_OFFSET (v)
+	= offset +
+	VALUE_EMBEDDED_OFFSET (arg1) +
+	TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
+    }
+  else
+    {
+      /* Plain old data member */
+      offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
+      v = allocate_value (type);
+      if (VALUE_LAZY (arg1))
+	VALUE_LAZY (v) = 1;
+      else
+	memcpy (VALUE_CONTENTS_RAW (v),
+		VALUE_CONTENTS_RAW (arg1) + offset,
+		TYPE_LENGTH (type));
+      VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
+			 + VALUE_EMBEDDED_OFFSET (arg1);
+    }
+  VALUE_LVAL (v) = VALUE_LVAL (arg1);
+  if (VALUE_LVAL (arg1) == lval_internalvar)
+    VALUE_LVAL (v) = lval_internalvar_component;
+  VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1);
+  VALUE_REGNO (v) = VALUE_REGNO (arg1);
+/*  VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
+   + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; */
+  return v;
+}
+
+/* Given a value ARG1 of a struct or union type,
+   extract and return the value of one of its (non-static) fields.
+   FIELDNO says which field. */
+
+struct value *
+value_field (struct value *arg1, int fieldno)
+{
+  return value_primitive_field (arg1, 0, fieldno, VALUE_TYPE (arg1));
+}
+
+/* Return a non-virtual function as a value.
+   F is the list of member functions which contains the desired method.
+   J is an index into F which provides the desired method.
+
+   We only use the symbol for its address, so be happy with either a
+   full symbol or a minimal symbol.
+ */
+
+struct value *
+value_fn_field (struct value **arg1p, struct fn_field *f, int j, struct type *type,
+		int offset)
+{
+  struct value *v;
+  struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
+  char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
+  struct symbol *sym;
+  struct minimal_symbol *msym;
+
+  sym = lookup_symbol (physname, 0, VAR_DOMAIN, 0, NULL);
+  if (sym != NULL)
+    {
+      msym = NULL;
+    }
+  else
+    {
+      gdb_assert (sym == NULL);
+      msym = lookup_minimal_symbol (physname, NULL, NULL);
+      if (msym == NULL)
+	return NULL;
+    }
+
+  v = allocate_value (ftype);
+  if (sym)
+    {
+      VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
+    }
+  else
+    {
+      VALUE_ADDRESS (v) = SYMBOL_VALUE_ADDRESS (msym);
+    }
+
+  if (arg1p)
+    {
+      if (type != VALUE_TYPE (*arg1p))
+	*arg1p = value_ind (value_cast (lookup_pointer_type (type),
+					value_addr (*arg1p)));
+
+      /* Move the `this' pointer according to the offset.
+         VALUE_OFFSET (*arg1p) += offset;
+       */
+    }
+
+  return v;
+}
+
+
+/* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
+   VALADDR.
+
+   Extracting bits depends on endianness of the machine.  Compute the
+   number of least significant bits to discard.  For big endian machines,
+   we compute the total number of bits in the anonymous object, subtract
+   off the bit count from the MSB of the object to the MSB of the
+   bitfield, then the size of the bitfield, which leaves the LSB discard
+   count.  For little endian machines, the discard count is simply the
+   number of bits from the LSB of the anonymous object to the LSB of the
+   bitfield.
+
+   If the field is signed, we also do sign extension. */
+
+LONGEST
+unpack_field_as_long (struct type *type, const char *valaddr, int fieldno)
+{
+  ULONGEST val;
+  ULONGEST valmask;
+  int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
+  int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
+  int lsbcount;
+  struct type *field_type;
+
+  val = extract_unsigned_integer (valaddr + bitpos / 8, sizeof (val));
+  field_type = TYPE_FIELD_TYPE (type, fieldno);
+  CHECK_TYPEDEF (field_type);
+
+  /* Extract bits.  See comment above. */
+
+  if (BITS_BIG_ENDIAN)
+    lsbcount = (sizeof val * 8 - bitpos % 8 - bitsize);
+  else
+    lsbcount = (bitpos % 8);
+  val >>= lsbcount;
+
+  /* If the field does not entirely fill a LONGEST, then zero the sign bits.
+     If the field is signed, and is negative, then sign extend. */
+
+  if ((bitsize > 0) && (bitsize < 8 * (int) sizeof (val)))
+    {
+      valmask = (((ULONGEST) 1) << bitsize) - 1;
+      val &= valmask;
+      if (!TYPE_UNSIGNED (field_type))
+	{
+	  if (val & (valmask ^ (valmask >> 1)))
+	    {
+	      val |= ~valmask;
+	    }
+	}
+    }
+  return (val);
+}
+
+/* Modify the value of a bitfield.  ADDR points to a block of memory in
+   target byte order; the bitfield starts in the byte pointed to.  FIELDVAL
+   is the desired value of the field, in host byte order.  BITPOS and BITSIZE
+   indicate which bits (in target bit order) comprise the bitfield.  
+   Requires 0 < BITSIZE <= lbits, 0 <= BITPOS+BITSIZE <= lbits, and
+   0 <= BITPOS, where lbits is the size of a LONGEST in bits.  */
+
+void
+modify_field (char *addr, LONGEST fieldval, int bitpos, int bitsize)
+{
+  ULONGEST oword;
+  ULONGEST mask = (ULONGEST) -1 >> (8 * sizeof (ULONGEST) - bitsize);
+
+  /* If a negative fieldval fits in the field in question, chop
+     off the sign extension bits.  */
+  if ((~fieldval & ~(mask >> 1)) == 0)
+    fieldval &= mask;
+
+  /* Warn if value is too big to fit in the field in question.  */
+  if (0 != (fieldval & ~mask))
+    {
+      /* FIXME: would like to include fieldval in the message, but
+         we don't have a sprintf_longest.  */
+      warning ("Value does not fit in %d bits.", bitsize);
+
+      /* Truncate it, otherwise adjoining fields may be corrupted.  */
+      fieldval &= mask;
+    }
+
+  oword = extract_unsigned_integer (addr, sizeof oword);
+
+  /* Shifting for bit field depends on endianness of the target machine.  */
+  if (BITS_BIG_ENDIAN)
+    bitpos = sizeof (oword) * 8 - bitpos - bitsize;
+
+  oword &= ~(mask << bitpos);
+  oword |= fieldval << bitpos;
+
+  store_unsigned_integer (addr, sizeof oword, oword);
+}
+
+/* Convert C numbers into newly allocated values */
+
+struct value *
+value_from_longest (struct type *type, LONGEST num)
+{
+  struct value *val = allocate_value (type);
+  enum type_code code;
+  int len;
+retry:
+  code = TYPE_CODE (type);
+  len = TYPE_LENGTH (type);
+
+  switch (code)
+    {
+    case TYPE_CODE_TYPEDEF:
+      type = check_typedef (type);
+      goto retry;
+    case TYPE_CODE_INT:
+    case TYPE_CODE_CHAR:
+    case TYPE_CODE_ENUM:
+    case TYPE_CODE_BOOL:
+    case TYPE_CODE_RANGE:
+      store_signed_integer (VALUE_CONTENTS_RAW (val), len, num);
+      break;
+
+    case TYPE_CODE_REF:
+    case TYPE_CODE_PTR:
+      store_typed_address (VALUE_CONTENTS_RAW (val), type, (CORE_ADDR) num);
+      break;
+
+    default:
+      error ("Unexpected type (%d) encountered for integer constant.", code);
+    }
+  return val;
+}
+
+
+/* Create a value representing a pointer of type TYPE to the address
+   ADDR.  */
+struct value *
+value_from_pointer (struct type *type, CORE_ADDR addr)
+{
+  struct value *val = allocate_value (type);
+  store_typed_address (VALUE_CONTENTS_RAW (val), type, addr);
+  return val;
+}
+
+
+/* Create a value for a string constant to be stored locally
+   (not in the inferior's memory space, but in GDB memory).
+   This is analogous to value_from_longest, which also does not
+   use inferior memory.  String shall NOT contain embedded nulls.  */
+
+struct value *
+value_from_string (char *ptr)
+{
+  struct value *val;
+  int len = strlen (ptr);
+  int lowbound = current_language->string_lower_bound;
+  struct type *string_char_type;
+  struct type *rangetype;
+  struct type *stringtype;
+
+  rangetype = create_range_type ((struct type *) NULL,
+				 builtin_type_int,
+				 lowbound, len + lowbound - 1);
+  string_char_type = language_string_char_type (current_language,
+						current_gdbarch);
+  stringtype = create_array_type ((struct type *) NULL,
+				  string_char_type,
+				  rangetype);
+  val = allocate_value (stringtype);
+  memcpy (VALUE_CONTENTS_RAW (val), ptr, len);
+  return val;
+}
+
+struct value *
+value_from_double (struct type *type, DOUBLEST num)
+{
+  struct value *val = allocate_value (type);
+  struct type *base_type = check_typedef (type);
+  enum type_code code = TYPE_CODE (base_type);
+  int len = TYPE_LENGTH (base_type);
+
+  if (code == TYPE_CODE_FLT)
+    {
+      store_typed_floating (VALUE_CONTENTS_RAW (val), base_type, num);
+    }
+  else
+    error ("Unexpected type encountered for floating constant.");
+
+  return val;
+}
+
+
+/* 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.  */
+
+int
+using_struct_return (struct type *value_type, int gcc_p)
+{
+  enum type_code code = TYPE_CODE (value_type);
+
+  if (code == TYPE_CODE_ERROR)
+    error ("Function return type unknown.");
+
+  if (code == TYPE_CODE_VOID)
+    /* A void return value is never in memory.  See also corresponding
+       code in "print_return_value".  */
+    return 0;
+
+  /* Probe the architecture for the return-value convention.  */
+  return (gdbarch_return_value (current_gdbarch, value_type,
+				NULL, NULL, NULL)
+	  != RETURN_VALUE_REGISTER_CONVENTION);
+}
+
+void
+_initialize_values (void)
+{
+  add_cmd ("convenience", no_class, show_convenience,
+	   "Debugger convenience (\"$foo\") variables.\n\
+These variables are created when you assign them values;\n\
+thus, \"print $foo=1\" gives \"$foo\" the value 1.  Values may be any type.\n\n\
+A few convenience variables are given values automatically:\n\
+\"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
+\"$__\" holds the contents of the last address examined with \"x\".",
+	   &showlist);
+
+  add_cmd ("values", no_class, show_values,
+	   "Elements of value history around item number IDX (or last ten).",
+	   &showlist);
+}