* gdbarch.sh (software_single_step): Replace REGCACHE argument by

[deliverable/binutils-gdb.git] / gdb / value.c

diff --git a/gdb/value.c b/gdb/value.c
index c6b9ca98243c220c99331dec3a52fbeabb5bb50a..74044088296793e5ab038b0d7c3d6905d52e44d4 100644 (file)
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -31,7 +31,6 @@
 #include "gdbcmd.h"
 #include "target.h"
 #include "language.h"
-#include "scm-lang.h"
 #include "demangle.h"
 #include "doublest.h"
 #include "gdb_assert.h"
@@ -158,6 +157,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 +235,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;
 }
 
@@ -755,7 +758,7 @@ lookup_internalvar (char *name)
   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;
@@ -787,7 +790,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 +847,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().  */
 }
@@ -959,10 +962,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 +1079,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:
@@ -1139,7 +1138,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
@@ -1343,11 +1342,9 @@ value_primitive_field (struct value *arg1, int offset,
   VALUE_LVAL (v) = VALUE_LVAL (arg1);
   if (VALUE_LVAL (arg1) == lval_internalvar)
     VALUE_LVAL (v) = lval_internalvar_component;
-  VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1);
+  v->location = arg1->location;
   VALUE_REGNUM (v) = VALUE_REGNUM (arg1);
   VALUE_FRAME_ID (v) = VALUE_FRAME_ID (arg1);
-/*  VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
-   + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; */
   return v;
 }
 
@@ -1512,23 +1509,18 @@ modify_field (gdb_byte *addr, LONGEST fieldval, int bitpos, int bitsize)
   store_unsigned_integer (addr, sizeof oword, oword);
 }
 \f
-/* 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:
@@ -1536,17 +1528,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;
 }
 
@@ -1698,6 +1703,22 @@ using_struct_return (struct type *value_type, int gcc_p)
          != 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)
 {