* stabsread.c (get_substring): Declare second arg as int.

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

diff --git a/gdb/values.c b/gdb/values.c
index 76062bb201c21a5d4a5c9fca987abe048af57cff..954f6205513da3746922e1356062a4f40cd21e94 100644 (file)
--- a/gdb/values.c
+++ b/gdb/values.c
@@ -1,5 +1,5 @@
 /* Low level packing and unpacking of values for GDB, the GNU Debugger.
-   Copyright 1986, 1987, 1989, 1991, 1993, 1994, 1995
+   Copyright 1986, 1987, 1989, 1991, 1993, 1994, 1995, 1996
    Free Software Foundation, Inc.
 
 This file is part of GDB.
@@ -29,6 +29,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "gdbcmd.h"
 #include "target.h"
 #include "language.h"
+#include "scm-lang.h"
 #include "demangle.h"
 
 /* Local function prototypes. */
@@ -40,6 +41,8 @@ static void show_values PARAMS ((char *, int));
 
 static void show_convenience PARAMS ((char *, int));
 
+static int vb_match PARAMS ((struct type *, int, struct type *));
+
 /* The value-history records all the values printed
    by print commands during this session.  Each chunk
    records 60 consecutive values.  The first chunk on
@@ -100,7 +103,6 @@ allocate_repeat_value (type, count)
      struct type *type;
      int count;
 {
-  struct type *element_type = type;
   int low_bound = current_language->string_lower_bound; /* ??? */
   /* FIXME-type-allocation: need a way to free this type when we are
      done with it.  */
@@ -239,14 +241,6 @@ record_latest_value (val)
 {
   int i;
 
-  /* Check error now if about to store an invalid float.  We return -1
-     to the caller, but allow them to continue, e.g. to print it as "Nan". */
-  if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT)
-    {
-      unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val), &i);
-      if (i) return -1;                /* Indicate value not saved in history */
-    }
-
   /* 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
@@ -556,16 +550,15 @@ value_as_long (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.  */
-  if (TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_ENUM)
-    COERCE_ARRAY (val);
+  COERCE_ARRAY (val);
   return unpack_long (VALUE_TYPE (val), VALUE_CONTENTS (val));
 }
 
-double
+DOUBLEST
 value_as_double (val)
      register value_ptr val;
 {
-  double foo;
+  DOUBLEST foo;
   int inv;
   
   foo = unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val), &inv);
@@ -656,7 +649,7 @@ unpack_long (type, valaddr)
    the returned double is OK to use.  Argument is in target
    format, result is in host format.  */
 
-double
+DOUBLEST
 unpack_double (type, valaddr, invp)
      struct type *type;
      char *valaddr;
@@ -1040,7 +1033,7 @@ vb_match (type, index, basetype)
   if (*name != '_')
     return 0;
   /* gcc 2.4 uses _vb$.  */
-  if (name[1] == 'v' && name[2] == 'b' && name[3] == CPLUS_MARKER)
+  if (name[1] == 'v' && name[2] == 'b' && is_cplus_marker (name[3]))
     field_class_name = name + 4;
   /* gcc 2.5 will use __vb_.  */
   if (name[1] == '_' && name[2] == 'v' && name[3] == 'b' && name[4] == '_')
@@ -1164,7 +1157,7 @@ unpack_field_as_long (type, valaddr, fieldno)
   /* 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 * sizeof (val)))
+  if ((bitsize > 0) && (bitsize < 8 * (int) sizeof (val)))
     {
       valmask = (((unsigned LONGEST) 1) << bitsize) - 1;
       val &= valmask;
@@ -1194,12 +1187,12 @@ modify_field (addr, fieldval, bitpos, bitsize)
 
   /* If a negative fieldval fits in the field in question, chop
      off the sign extension bits.  */
-  if (bitsize < (8 * sizeof (fieldval))
+  if (bitsize < (8 * (int) sizeof (fieldval))
       && (~fieldval & ~((1 << (bitsize - 1)) - 1)) == 0)
     fieldval = fieldval & ((1 << bitsize) - 1);
 
   /* Warn if value is too big to fit in the field in question.  */
-  if (bitsize < (8 * sizeof (fieldval))
+  if (bitsize < (8 * (int) sizeof (fieldval))
       && 0 != (fieldval & ~((1<<bitsize)-1)))
     {
       /* FIXME: would like to include fieldval in the message, but
@@ -1217,7 +1210,7 @@ modify_field (addr, fieldval, bitpos, bitsize)
     bitpos = sizeof (oword) * 8 - bitpos - bitsize;
 
   /* Mask out old value, while avoiding shifts >= size of oword */
-  if (bitsize < 8 * sizeof (oword))
+  if (bitsize < 8 * (int) sizeof (oword))
     oword &= ~(((((unsigned LONGEST)1) << bitsize) - 1) << bitpos);
   else
     oword &= ~((~(unsigned LONGEST)0) << bitpos);
@@ -1269,7 +1262,7 @@ value_from_longest (type, num)
 value_ptr
 value_from_double (type, num)
      struct type *type;
-     double num;
+     DOUBLEST num;
 {
   register value_ptr val = allocate_value (type);
   struct type *base_type = check_typedef (type);
@@ -1351,6 +1344,14 @@ value_being_returned (valtype, retbuf, struct_return)
      ))
 #endif
 
+/* Some fundamental types (such as long double) are returned on the stack for
+   certain architectures.  This macro should return true for any type besides
+   struct, union or array that gets returned on the stack.  */
+
+#ifndef RETURN_VALUE_ON_STACK
+#define RETURN_VALUE_ON_STACK(TYPE) 0
+#endif
+
 /* Return true if the function specified is using the structure returning
    convention on this machine to return arguments, or 0 if it is using
    the value returning convention.  FUNCTION is the value representing
@@ -1371,9 +1372,10 @@ using_struct_return (function, funcaddr, value_type, gcc_p)
   if (code == TYPE_CODE_ERROR)
     error ("Function return type unknown.");
 
-  if (code == TYPE_CODE_STRUCT ||
-      code == TYPE_CODE_UNION ||
-      code == TYPE_CODE_ARRAY)
+  if (code == TYPE_CODE_STRUCT
+      || code == TYPE_CODE_UNION
+      || code == TYPE_CODE_ARRAY
+      || RETURN_VALUE_ON_STACK (value_type))
     return USE_STRUCT_CONVENTION (gcc_p, value_type);
 
   return 0;