* ax-gdb.c (gen_expr) <OP_REGISTER>: Error out if trying to

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

diff --git a/gdb/valarith.c b/gdb/valarith.c
index 5f814331aa54149e72bbb6b6877bf4f586a146a7..6b212b29b0e94855238465422aa630c3a4b634dd 100644 (file)
--- a/gdb/valarith.c
+++ b/gdb/valarith.c
@@ -1,12 +1,14 @@
 /* Perform arithmetic and other operations on values, for GDB.
 /* Perform arithmetic and other operations on values, for GDB.

-   Copyright 1986, 89, 91, 92, 93, 94, 95, 96, 97, 1998
-   Free Software Foundation, Inc.
+
+   Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
+   1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009,
+   2010 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
 
    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,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -15,9 +17,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    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.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 #include "defs.h"
 #include "value.h"
 
 #include "defs.h"
 #include "value.h"


@@ -26,9 +26,12 @@
 #include "expression.h"
 #include "target.h"
 #include "language.h"
 #include "expression.h"
 #include "target.h"
 #include "language.h"

-#include "demangle.h"

 #include "gdb_string.h"
 #include "gdb_string.h"

+#include "doublest.h"
+#include "dfp.h"

 #include <math.h>
 #include <math.h>

+#include "infcall.h"
+#include "exceptions.h"

 
 /* Define whether or not the C operator '/' truncates towards zero for
    differently signed operands (truncation direction is undefined in C). */
 
 /* Define whether or not the C operator '/' truncates towards zero for
    differently signed operands (truncation direction is undefined in C). */


@@ -37,234 +40,263 @@
 #define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
 #endif
 
 #define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
 #endif
 

-static value_ptr value_subscripted_rvalue PARAMS ((value_ptr, value_ptr, int));
-
-void _initialize_valarith PARAMS ((void));
+void _initialize_valarith (void);

 \f
 
 \f
 

-value_ptr
-value_add (arg1, arg2)
-     value_ptr arg1, arg2;
+/* Given a pointer, return the size of its target.
+   If the pointer type is void *, then return 1.
+   If the target type is incomplete, then error out.
+   This isn't a general purpose function, but just a 
+   helper for value_ptradd.
+*/
+
+static LONGEST
+find_size_for_pointer_math (struct type *ptr_type)

 {
 {

-  register value_ptr valint, valptr;
-  register int len;
-  struct type *type1, *type2, *valptrtype;
-
-  COERCE_NUMBER (arg1);
-  COERCE_NUMBER (arg2);
-  type1 = check_typedef (VALUE_TYPE (arg1));
-  type2 = check_typedef (VALUE_TYPE (arg2));
-
-  if ((TYPE_CODE (type1) == TYPE_CODE_PTR
-       || TYPE_CODE (type2) == TYPE_CODE_PTR)
-      &&
-      (TYPE_CODE (type1) == TYPE_CODE_INT
-       || TYPE_CODE (type2) == TYPE_CODE_INT))
-    /* Exactly one argument is a pointer, and one is an integer.  */
-    {
-      value_ptr retval;
+  LONGEST sz = -1;
+  struct type *ptr_target;

 
 

-      if (TYPE_CODE (type1) == TYPE_CODE_PTR)
-       {
-         valptr = arg1;
-         valint = arg2;
-         valptrtype = type1;
-       }
+  gdb_assert (TYPE_CODE (ptr_type) == TYPE_CODE_PTR);
+  ptr_target = check_typedef (TYPE_TARGET_TYPE (ptr_type));
+
+  sz = TYPE_LENGTH (ptr_target);
+  if (sz == 0)
+    {
+      if (TYPE_CODE (ptr_type) == TYPE_CODE_VOID)
+       sz = 1;

       else
        {
       else
        {

-         valptr = arg2;
-         valint = arg1;
-         valptrtype = type2;
+         char *name;
+         
+         name = TYPE_NAME (ptr_target);
+         if (name == NULL)
+           name = TYPE_TAG_NAME (ptr_target);
+         if (name == NULL)
+           error (_("Cannot perform pointer math on incomplete types, "
+                  "try casting to a known type, or void *."));
+         else
+           error (_("Cannot perform pointer math on incomplete type \"%s\", "
+                  "try casting to a known type, or void *."), name);

        }
        }

-      len = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (valptrtype)));
-      if (len == 0)
-       len = 1;                /* For (void *) */
-      retval = value_from_pointer (valptrtype,
-                                  value_as_pointer (valptr)
-                                  + (len * value_as_long (valint)));
-      VALUE_BFD_SECTION (retval) = VALUE_BFD_SECTION (valptr);
-      return retval;

     }
     }

+  return sz;
+}
+
+/* Given a pointer ARG1 and an integral value ARG2, return the
+   result of C-style pointer arithmetic ARG1 + ARG2.  */

 
 

-  return value_binop (arg1, arg2, BINOP_ADD);
+struct value *
+value_ptradd (struct value *arg1, LONGEST arg2)
+{
+  struct type *valptrtype;
+  LONGEST sz;
+  struct value *result;
+
+  arg1 = coerce_array (arg1);
+  valptrtype = check_typedef (value_type (arg1));
+  sz = find_size_for_pointer_math (valptrtype);
+
+  result = value_from_pointer (valptrtype,
+                              value_as_address (arg1) + sz * arg2);
+  if (VALUE_LVAL (result) != lval_internalvar)
+    set_value_component_location (result, arg1);
+  return result;

 }
 
 }
 

-value_ptr
-value_sub (arg1, arg2)
-     value_ptr arg1, arg2;
+/* Given two compatible pointer values ARG1 and ARG2, return the
+   result of C-style pointer arithmetic ARG1 - ARG2.  */
+
+LONGEST
+value_ptrdiff (struct value *arg1, struct value *arg2)

 {
   struct type *type1, *type2;
 {
   struct type *type1, *type2;

-  COERCE_NUMBER (arg1);
-  COERCE_NUMBER (arg2);
-  type1 = check_typedef (VALUE_TYPE (arg1));
-  type2 = check_typedef (VALUE_TYPE (arg2));
+  LONGEST sz;

 
 

-  if (TYPE_CODE (type1) == TYPE_CODE_PTR)
-    {
-      if (TYPE_CODE (type2) == TYPE_CODE_INT)
-       {
-         /* pointer - integer.  */
-         LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
-         return value_from_pointer (VALUE_TYPE (arg1),
-                                    (value_as_pointer (arg1)
-                                     - (sz * value_as_long (arg2))));
-       }
-      else if (TYPE_CODE (type2) == TYPE_CODE_PTR
-              && TYPE_LENGTH (TYPE_TARGET_TYPE (type1))
-              == TYPE_LENGTH (TYPE_TARGET_TYPE (type2)))
-       {
-         /* pointer to <type x> - pointer to <type x>.  */
-         LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
-         return value_from_longest
-           (builtin_type_long, /* FIXME -- should be ptrdiff_t */
-            (value_as_long (arg1) - value_as_long (arg2)) / sz);
-       }
-      else
-       {
-         error ("\
+  arg1 = coerce_array (arg1);
+  arg2 = coerce_array (arg2);
+  type1 = check_typedef (value_type (arg1));
+  type2 = check_typedef (value_type (arg2));
+
+  gdb_assert (TYPE_CODE (type1) == TYPE_CODE_PTR);
+  gdb_assert (TYPE_CODE (type2) == TYPE_CODE_PTR);
+
+  if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)))
+      != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2))))
+    error (_("\

 First argument of `-' is a pointer and second argument is neither\n\
 First argument of `-' is a pointer and second argument is neither\n\

-an integer nor a pointer of the same type.");
-       }
+an integer nor a pointer of the same type."));
+
+  sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
+  if (sz == 0) 
+    {
+      warning (_("Type size unknown, assuming 1. "
+               "Try casting to a known type, or void *."));
+      sz = 1;

     }
 
     }
 

-  return value_binop (arg1, arg2, BINOP_SUB);
+  return (value_as_long (arg1) - value_as_long (arg2)) / sz;

 }
 
 /* Return the value of ARRAY[IDX].
 }
 
 /* Return the value of ARRAY[IDX].

+
+   ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING.  If the
+   current language supports C-style arrays, it may also be TYPE_CODE_PTR.
+   To access TYPE_CODE_BITSTRING values, use value_bitstring_subscript.
+

    See comments in value_coerce_array() for rationale for reason for
    doing lower bounds adjustment here rather than there.
    FIXME:  Perhaps we should validate that the index is valid and if
    verbosity is set, warn about invalid indices (but still use them). */
 
    See comments in value_coerce_array() for rationale for reason for
    doing lower bounds adjustment here rather than there.
    FIXME:  Perhaps we should validate that the index is valid and if
    verbosity is set, warn about invalid indices (but still use them). */
 

-value_ptr
-value_subscript (array, idx)
-     value_ptr array, idx;
+struct value *
+value_subscript (struct value *array, LONGEST index)

 {
 {

-  value_ptr bound;

   int c_style = current_language->c_style_arrays;
   struct type *tarray;
 
   int c_style = current_language->c_style_arrays;
   struct type *tarray;
 

-  COERCE_REF (array);
-  tarray = check_typedef (VALUE_TYPE (array));
-  COERCE_VARYING_ARRAY (array, tarray);
+  array = coerce_ref (array);
+  tarray = check_typedef (value_type (array));

 
   if (TYPE_CODE (tarray) == TYPE_CODE_ARRAY
       || TYPE_CODE (tarray) == TYPE_CODE_STRING)
     {
       struct type *range_type = TYPE_INDEX_TYPE (tarray);
       LONGEST lowerbound, upperbound;
 
   if (TYPE_CODE (tarray) == TYPE_CODE_ARRAY
       || TYPE_CODE (tarray) == TYPE_CODE_STRING)
     {
       struct type *range_type = TYPE_INDEX_TYPE (tarray);
       LONGEST lowerbound, upperbound;

-      get_discrete_bounds (range_type, &lowerbound, &upperbound);

 
 

+      get_discrete_bounds (range_type, &lowerbound, &upperbound);

       if (VALUE_LVAL (array) != lval_memory)
       if (VALUE_LVAL (array) != lval_memory)

-       return value_subscripted_rvalue (array, idx, lowerbound);
+       return value_subscripted_rvalue (array, index, lowerbound);

 
       if (c_style == 0)
        {
 
       if (c_style == 0)
        {

-         LONGEST index = value_as_long (idx);

          if (index >= lowerbound && index <= upperbound)
          if (index >= lowerbound && index <= upperbound)

-           return value_subscripted_rvalue (array, idx, lowerbound);
-         warning ("array or string index out of range");
+           return value_subscripted_rvalue (array, index, lowerbound);
+         /* Emit warning unless we have an array of unknown size.
+            An array of unknown size has lowerbound 0 and upperbound -1.  */
+         if (upperbound > -1)
+           warning (_("array or string index out of range"));

          /* fall doing C stuff */
          c_style = 1;
        }
 
          /* fall doing C stuff */
          c_style = 1;
        }
 

-      if (lowerbound != 0)
-       {
-         bound = value_from_longest (builtin_type_int, (LONGEST) lowerbound);
-         idx = value_sub (idx, bound);
-       }
-
-      array = value_coerce_array (array);
-    }
-
-  if (TYPE_CODE (tarray) == TYPE_CODE_BITSTRING)
-    {
-      struct type *range_type = TYPE_INDEX_TYPE (tarray);
-      LONGEST index = value_as_long (idx);
-      value_ptr v;
-      int offset, byte, bit_index;
-      LONGEST lowerbound, upperbound;
-      get_discrete_bounds (range_type, &lowerbound, &upperbound);
-      if (index < lowerbound || index > upperbound)
-       error ("bitstring index out of range");

       index -= lowerbound;
       index -= lowerbound;

-      offset = index / TARGET_CHAR_BIT;
-      byte = *((char *) VALUE_CONTENTS (array) + offset);
-      bit_index = index % TARGET_CHAR_BIT;
-      byte >>= (BITS_BIG_ENDIAN ? TARGET_CHAR_BIT - 1 - bit_index : bit_index);
-      v = value_from_longest (LA_BOOL_TYPE, byte & 1);
-      VALUE_BITPOS (v) = bit_index;
-      VALUE_BITSIZE (v) = 1;
-      VALUE_LVAL (v) = VALUE_LVAL (array);
-      if (VALUE_LVAL (array) == lval_internalvar)
-       VALUE_LVAL (v) = lval_internalvar_component;
-      VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
-      VALUE_OFFSET (v) = offset + VALUE_OFFSET (array);
-      return v;
+      array = value_coerce_array (array);

     }
 
   if (c_style)
     }
 
   if (c_style)

-    return value_ind (value_add (array, idx));
+    return value_ind (value_ptradd (array, index));

   else
   else

-    error ("not an array or string");
+    error (_("not an array or string"));

 }
 
 /* Return the value of EXPR[IDX], expr an aggregate rvalue
    (eg, a vector register).  This routine used to promote floats
    to doubles, but no longer does.  */
 
 }
 
 /* Return the value of EXPR[IDX], expr an aggregate rvalue
    (eg, a vector register).  This routine used to promote floats
    to doubles, but no longer does.  */
 

-static value_ptr
-value_subscripted_rvalue (array, idx, lowerbound)
-     value_ptr array, idx;
-     int lowerbound;
+struct value *
+value_subscripted_rvalue (struct value *array, LONGEST index, int lowerbound)

 {
 {

-  struct type *array_type = check_typedef (VALUE_TYPE (array));
+  struct type *array_type = check_typedef (value_type (array));

   struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
   unsigned int elt_size = TYPE_LENGTH (elt_type);
   struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
   unsigned int elt_size = TYPE_LENGTH (elt_type);

-  LONGEST index = value_as_long (idx);

   unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
   unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);

-  value_ptr v;
+  struct value *v;

 
 

-  if (index < lowerbound || elt_offs >= TYPE_LENGTH (array_type))
-    error ("no such vector element");
+  if (index < lowerbound || (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type)
+                            && elt_offs >= TYPE_LENGTH (array_type)))
+    error (_("no such vector element"));

 
   v = allocate_value (elt_type);
 
   v = allocate_value (elt_type);

-  if (VALUE_LAZY (array))
-    VALUE_LAZY (v) = 1;
+  if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
+    set_value_lazy (v, 1);

   else
   else

-    memcpy (VALUE_CONTENTS (v), VALUE_CONTENTS (array) + elt_offs, elt_size);
+    memcpy (value_contents_writeable (v),
+           value_contents (array) + elt_offs, elt_size);
+
+  set_value_component_location (v, array);
+  VALUE_REGNUM (v) = VALUE_REGNUM (array);
+  VALUE_FRAME_ID (v) = VALUE_FRAME_ID (array);
+  set_value_offset (v, value_offset (array) + elt_offs);
+  return v;
+}
+
+/* Return the value of BITSTRING[IDX] as (boolean) type TYPE.  */
+
+struct value *
+value_bitstring_subscript (struct type *type,
+                          struct value *bitstring, LONGEST index)
+{
+
+  struct type *bitstring_type, *range_type;
+  struct value *v;
+  int offset, byte, bit_index;
+  LONGEST lowerbound, upperbound;
+
+  bitstring_type = check_typedef (value_type (bitstring));
+  gdb_assert (TYPE_CODE (bitstring_type) == TYPE_CODE_BITSTRING);
+
+  range_type = TYPE_INDEX_TYPE (bitstring_type);
+  get_discrete_bounds (range_type, &lowerbound, &upperbound);
+  if (index < lowerbound || index > upperbound)
+    error (_("bitstring index out of range"));
+
+  index -= lowerbound;
+  offset = index / TARGET_CHAR_BIT;
+  byte = *((char *) value_contents (bitstring) + offset);
+
+  bit_index = index % TARGET_CHAR_BIT;
+  byte >>= (gdbarch_bits_big_endian (get_type_arch (bitstring_type)) ?
+           TARGET_CHAR_BIT - 1 - bit_index : bit_index);
+
+  v = value_from_longest (type, byte & 1);
+
+  set_value_bitpos (v, bit_index);
+  set_value_bitsize (v, 1);
+  set_value_component_location (v, bitstring);
+  VALUE_FRAME_ID (v) = VALUE_FRAME_ID (bitstring);
+
+  set_value_offset (v, offset + value_offset (bitstring));

 
 

-  if (VALUE_LVAL (array) == lval_internalvar)
-    VALUE_LVAL (v) = lval_internalvar_component;
-  else
-    VALUE_LVAL (v) = VALUE_LVAL (array);
-  VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
-  VALUE_OFFSET (v) = VALUE_OFFSET (array) + elt_offs;

   return v;
 }
   return v;
 }

+

 \f
 \f

-/* Check to see if either argument is a structure.  This is called so
-   we know whether to go ahead with the normal binop or look for a 
-   user defined function instead.
+/* Check to see if either argument is a structure, or a reference to
+   one.  This is called so we know whether to go ahead with the normal
+   binop or look for a user defined function instead.

 
    For now, we do not overload the `=' operator.  */
 
 int
 
    For now, we do not overload the `=' operator.  */
 
 int

-binop_user_defined_p (op, arg1, arg2)
-     enum exp_opcode op;
-     value_ptr arg1, arg2;
+binop_types_user_defined_p (enum exp_opcode op,
+                           struct type *type1, struct type *type2)

 {
 {

-  struct type *type1, *type2;

   if (op == BINOP_ASSIGN || op == BINOP_CONCAT)
     return 0;
   if (op == BINOP_ASSIGN || op == BINOP_CONCAT)
     return 0;

-  type1 = check_typedef (VALUE_TYPE (arg1));
-  type2 = check_typedef (VALUE_TYPE (arg2));
+
+  type1 = check_typedef (type1);
+  if (TYPE_CODE (type1) == TYPE_CODE_REF)
+    type1 = check_typedef (TYPE_TARGET_TYPE (type1));
+
+  type2 = check_typedef (type1);
+  if (TYPE_CODE (type2) == TYPE_CODE_REF)
+    type2 = check_typedef (TYPE_TARGET_TYPE (type2));
+

   return (TYPE_CODE (type1) == TYPE_CODE_STRUCT
   return (TYPE_CODE (type1) == TYPE_CODE_STRUCT

-         || TYPE_CODE (type2) == TYPE_CODE_STRUCT
-         || (TYPE_CODE (type1) == TYPE_CODE_REF
-             && TYPE_CODE (TYPE_TARGET_TYPE (type1)) == TYPE_CODE_STRUCT)
-         || (TYPE_CODE (type2) == TYPE_CODE_REF
-             && TYPE_CODE (TYPE_TARGET_TYPE (type2)) == TYPE_CODE_STRUCT));
+         || TYPE_CODE (type2) == TYPE_CODE_STRUCT);
+}
+
+/* Check to see if either argument is a structure, or a reference to
+   one.  This is called so we know whether to go ahead with the normal
+   binop or look for a user defined function instead.
+
+   For now, we do not overload the `=' operator.  */
+
+int
+binop_user_defined_p (enum exp_opcode op,
+                     struct value *arg1, struct value *arg2)
+{
+  return binop_types_user_defined_p (op, value_type (arg1), value_type (arg2));

 }
 
 /* Check to see if argument is a structure.  This is called so
 }
 
 /* Check to see if argument is a structure.  This is called so


@@ -274,14 +306,13 @@ binop_user_defined_p (op, arg1, arg2)
    For now, we do not overload the `&' operator.  */
 
 int
    For now, we do not overload the `&' operator.  */
 
 int

-unop_user_defined_p (op, arg1)
-     enum exp_opcode op;
-     value_ptr arg1;
+unop_user_defined_p (enum exp_opcode op, struct value *arg1)

 {
   struct type *type1;
 {
   struct type *type1;

+

   if (op == UNOP_ADDR)
     return 0;
   if (op == UNOP_ADDR)
     return 0;

-  type1 = check_typedef (VALUE_TYPE (arg1));
+  type1 = check_typedef (value_type (arg1));

   for (;;)
     {
       if (TYPE_CODE (type1) == TYPE_CODE_STRUCT)
   for (;;)
     {
       if (TYPE_CODE (type1) == TYPE_CODE_STRUCT)


@@ -293,6 +324,67 @@ unop_user_defined_p (op, arg1)
     }
 }
 
     }
 }
 

+/* Try to find an operator named OPERATOR which takes NARGS arguments
+   specified in ARGS.  If the operator found is a static member operator
+   *STATIC_MEMFUNP will be set to 1, and otherwise 0.
+   The search if performed through find_overload_match which will handle
+   member operators, non member operators, operators imported implicitly or
+   explicitly, and perform correct overload resolution in all of the above
+   situations or combinations thereof.  */
+
+static struct value *
+value_user_defined_cpp_op (struct value **args, int nargs, char *operator,
+                           int *static_memfuncp)
+{
+
+  struct symbol *symp = NULL;
+  struct value *valp = NULL;
+  struct type **arg_types;
+  int i;
+
+  arg_types = (struct type **) alloca (nargs * (sizeof (struct type *)));
+  /* Prepare list of argument types for overload resolution */
+  for (i = 0; i < nargs; i++)
+    arg_types[i] = value_type (args[i]);
+
+  find_overload_match (arg_types, nargs, operator, BOTH /* could be method */,
+                       0 /* strict match */, &args[0], /* objp */
+                       NULL /* pass NULL symbol since symbol is unknown */,
+                       &valp, &symp, static_memfuncp, 0);
+
+  if (valp)
+    return valp;
+
+  if (symp)
+    {
+      /* This is a non member function and does not
+         expect a reference as its first argument
+         rather the explicit structure.  */
+      args[0] = value_ind (args[0]);
+      return value_of_variable (symp, 0);
+    }
+
+  error (_("Could not find %s."), operator);
+}
+
+/* Lookup user defined operator NAME.  Return a value representing the
+   function, otherwise return NULL.  */
+
+static struct value *
+value_user_defined_op (struct value **argp, struct value **args, char *name,
+                       int *static_memfuncp, int nargs)
+{
+  struct value *result = NULL;
+
+  if (current_language->la_language == language_cplus)
+    result = value_user_defined_cpp_op (args, nargs, name, static_memfuncp);
+  else
+    result = value_struct_elt (argp, args, name, static_memfuncp,
+                               "structure");
+
+  return result;
+}
+

 /* We know either arg1 or arg2 is a structure, so try to find the right
    user defined function.  Create an argument vector that calls 
    arg1.operator @ (arg1,arg2) and return that value (where '@' is any
 /* We know either arg1 or arg2 is a structure, so try to find the right
    user defined function.  Create an argument vector that calls 
    arg1.operator @ (arg1,arg2) and return that value (where '@' is any


@@ -302,29 +394,25 @@ unop_user_defined_p (op, arg1)
    is the opcode saying how to modify it.  Otherwise, OTHEROP is
    unused.  */
 
    is the opcode saying how to modify it.  Otherwise, OTHEROP is
    unused.  */
 

-value_ptr
-value_x_binop (arg1, arg2, op, otherop, noside)
-     value_ptr arg1, arg2;
-     enum exp_opcode op, otherop;
-     enum noside noside;
+struct value *
+value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
+              enum exp_opcode otherop, enum noside noside)

 {
 {

-  value_ptr *argvec;
+  struct value **argvec;

   char *ptr;
   char tstr[13];
   int static_memfuncp;
 
   char *ptr;
   char tstr[13];
   int static_memfuncp;
 

-  COERCE_REF (arg1);
-  COERCE_REF (arg2);
-  COERCE_ENUM (arg1);
-  COERCE_ENUM (arg2);
+  arg1 = coerce_ref (arg1);
+  arg2 = coerce_ref (arg2);

 
   /* now we know that what we have to do is construct our
      arg vector and find the right function to call it with.  */
 
 
   /* now we know that what we have to do is construct our
      arg vector and find the right function to call it with.  */
 

-  if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_STRUCT)
-    error ("Can't do that binary op on that type");    /* FIXME be explicit */
+  if (TYPE_CODE (check_typedef (value_type (arg1))) != TYPE_CODE_STRUCT)
+    error (_("Can't do that binary op on that type")); /* FIXME be explicit */

 
 

-  argvec = (value_ptr *) alloca (sizeof (value_ptr) * 4);
+  argvec = (struct value **) alloca (sizeof (struct value *) * 4);

   argvec[1] = value_addr (arg1);
   argvec[2] = arg2;
   argvec[3] = 0;
   argvec[1] = value_addr (arg1);
   argvec[2] = arg2;
   argvec[3] = 0;


@@ -408,7 +496,7 @@ value_x_binop (arg1, arg2, op, otherop, noside)
          break;
        case BINOP_MOD: /* invalid */
        default:
          break;
        case BINOP_MOD: /* invalid */
        default:

-         error ("Invalid binary operation specified.");
+         error (_("Invalid binary operation specified."));

        }
       break;
     case BINOP_SUBSCRIPT:
        }
       break;
     case BINOP_SUBSCRIPT:


@@ -434,10 +522,11 @@ value_x_binop (arg1, arg2, op, otherop, noside)
       break;
     case BINOP_MOD:            /* invalid */
     default:
       break;
     case BINOP_MOD:            /* invalid */
     default:

-      error ("Invalid binary operation specified.");
+      error (_("Invalid binary operation specified."));

     }
 
     }
 

-  argvec[0] = value_struct_elt (&arg1, argvec + 1, tstr, &static_memfuncp, "structure");
+  argvec[0] = value_user_defined_op (&arg1, argvec + 1, tstr,
+                                     &static_memfuncp, 2);

 
   if (argvec[0])
     {
 
   if (argvec[0])
     {


@@ -449,13 +538,15 @@ value_x_binop (arg1, arg2, op, otherop, noside)
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
        {
          struct type *return_type;
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
        {
          struct type *return_type;

+

          return_type
          return_type

-           = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (argvec[0])));
+           = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));

          return value_zero (return_type, VALUE_LVAL (arg1));
        }
       return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
     }
          return value_zero (return_type, VALUE_LVAL (arg1));
        }
       return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
     }

-  error ("member function %s not found", tstr);
+  throw_error (NOT_FOUND_ERROR,
+               _("member function %s not found"), tstr);

 #ifdef lint
   return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
 #endif
 #ifdef lint
   return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
 #endif


@@ -467,30 +558,29 @@ value_x_binop (arg1, arg2, op, otherop, noside)
    and return that value (where '@' is (almost) any unary operator which
    is legal for GNU C++).  */
 
    and return that value (where '@' is (almost) any unary operator which
    is legal for GNU C++).  */
 

-value_ptr
-value_x_unop (arg1, op, noside)
-     value_ptr arg1;
-     enum exp_opcode op;
-     enum noside noside;
+struct value *
+value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)

 {
 {

-  value_ptr *argvec;
+  struct gdbarch *gdbarch = get_type_arch (value_type (arg1));
+  struct value **argvec;

   char *ptr, *mangle_ptr;
   char tstr[13], mangle_tstr[13];
   char *ptr, *mangle_ptr;
   char tstr[13], mangle_tstr[13];

-  int static_memfuncp;
+  int static_memfuncp, nargs;

 
 

-  COERCE_REF (arg1);
-  COERCE_ENUM (arg1);
+  arg1 = coerce_ref (arg1);

 
   /* now we know that what we have to do is construct our
      arg vector and find the right function to call it with.  */
 
 
   /* now we know that what we have to do is construct our
      arg vector and find the right function to call it with.  */
 

-  if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_STRUCT)
-    error ("Can't do that unary op on that type");     /* FIXME be explicit */
+  if (TYPE_CODE (check_typedef (value_type (arg1))) != TYPE_CODE_STRUCT)
+    error (_("Can't do that unary op on that type"));  /* FIXME be explicit */

 
 

-  argvec = (value_ptr *) alloca (sizeof (value_ptr) * 3);
+  argvec = (struct value **) alloca (sizeof (struct value *) * 4);

   argvec[1] = value_addr (arg1);
   argvec[2] = 0;
 
   argvec[1] = value_addr (arg1);
   argvec[2] = 0;
 

+  nargs = 1;
+

   /* make the right function name up */
   strcpy (tstr, "operator__");
   ptr = tstr + 8;
   /* make the right function name up */
   strcpy (tstr, "operator__");
   ptr = tstr + 8;


@@ -502,13 +592,19 @@ value_x_unop (arg1, op, noside)
       strcpy (ptr, "++");
       break;
     case UNOP_PREDECREMENT:
       strcpy (ptr, "++");
       break;
     case UNOP_PREDECREMENT:

-      strcpy (ptr, "++");
+      strcpy (ptr, "--");

       break;
     case UNOP_POSTINCREMENT:
       strcpy (ptr, "++");
       break;
     case UNOP_POSTINCREMENT:
       strcpy (ptr, "++");

+      argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
+      argvec[3] = 0;
+      nargs ++;

       break;
     case UNOP_POSTDECREMENT:
       break;
     case UNOP_POSTDECREMENT:

-      strcpy (ptr, "++");
+      strcpy (ptr, "--");
+      argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
+      argvec[3] = 0;
+      nargs ++;

       break;
     case UNOP_LOGICAL_NOT:
       strcpy (ptr, "!");
       break;
     case UNOP_LOGICAL_NOT:
       strcpy (ptr, "!");


@@ -519,32 +615,43 @@ value_x_unop (arg1, op, noside)
     case UNOP_NEG:
       strcpy (ptr, "-");
       break;
     case UNOP_NEG:
       strcpy (ptr, "-");
       break;

+    case UNOP_PLUS:
+      strcpy (ptr, "+");
+      break;

     case UNOP_IND:
       strcpy (ptr, "*");
       break;
     case UNOP_IND:
       strcpy (ptr, "*");
       break;

+    case STRUCTOP_PTR:
+      strcpy (ptr, "->");
+      break;

     default:
     default:

-      error ("Invalid unary operation specified.");
+      error (_("Invalid unary operation specified."));

     }
 
     }
 

-  argvec[0] = value_struct_elt (&arg1, argvec + 1, tstr, &static_memfuncp, "structure");
+  argvec[0] = value_user_defined_op (&arg1, argvec + 1, tstr,
+                                     &static_memfuncp, nargs);

 
   if (argvec[0])
     {
       if (static_memfuncp)
        {
          argvec[1] = argvec[0];
 
   if (argvec[0])
     {
       if (static_memfuncp)
        {
          argvec[1] = argvec[0];

+         nargs --;

          argvec++;
        }
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
        {
          struct type *return_type;
          argvec++;
        }
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
        {
          struct type *return_type;

+

          return_type
          return_type

-           = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (argvec[0])));
+           = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));

          return value_zero (return_type, VALUE_LVAL (arg1));
        }
          return value_zero (return_type, VALUE_LVAL (arg1));
        }

-      return call_function_by_hand (argvec[0], 1 - static_memfuncp, argvec + 1);
+      return call_function_by_hand (argvec[0], nargs, argvec + 1);

     }
     }

-  error ("member function %s not found", tstr);
+  throw_error (NOT_FOUND_ERROR,
+               _("member function %s not found"), tstr);
+

   return 0;                    /* For lint -- never reached */
 }
 \f
   return 0;                    /* For lint -- never reached */
 }
 \f


@@ -570,20 +677,19 @@ value_x_unop (arg1, op, noside)
    string values of length 1.
  */
 
    string values of length 1.
  */
 

-value_ptr
-value_concat (arg1, arg2)
-     value_ptr arg1, arg2;
+struct value *
+value_concat (struct value *arg1, struct value *arg2)

 {
 {

-  register value_ptr inval1, inval2, outval = NULL;
+  struct value *inval1;
+  struct value *inval2;
+  struct value *outval = NULL;

   int inval1len, inval2len;
   int count, idx;
   char *ptr;
   char inchar;
   int inval1len, inval2len;
   int count, idx;
   char *ptr;
   char inchar;

-  struct type *type1 = check_typedef (VALUE_TYPE (arg1));
-  struct type *type2 = check_typedef (VALUE_TYPE (arg2));
-
-  COERCE_VARYING_ARRAY (arg1, type1);
-  COERCE_VARYING_ARRAY (arg2, type2);
+  struct type *type1 = check_typedef (value_type (arg1));
+  struct type *type2 = check_typedef (value_type (arg2));
+  struct type *char_type;

 
   /* First figure out if we are dealing with two values to be concatenated
      or a repeat count and a value to be repeated.  INVAL1 is set to the
 
   /* First figure out if we are dealing with two values to be concatenated
      or a repeat count and a value to be repeated.  INVAL1 is set to the


@@ -594,6 +700,7 @@ value_concat (arg1, arg2)
   if (TYPE_CODE (type2) == TYPE_CODE_INT)
     {
       struct type *tmp = type1;
   if (TYPE_CODE (type2) == TYPE_CODE_INT)
     {
       struct type *tmp = type1;

+

       type1 = tmp;
       tmp = type2;
       inval1 = arg2;
       type1 = tmp;
       tmp = type2;
       inval1 = arg2;


@@ -619,8 +726,10 @@ value_concat (arg1, arg2)
          ptr = (char *) alloca (count * inval2len);
          if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
            {
          ptr = (char *) alloca (count * inval2len);
          if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
            {

+             char_type = type2;
+

              inchar = (char) unpack_long (type2,
              inchar = (char) unpack_long (type2,

-                                          VALUE_CONTENTS (inval2));
+                                          value_contents (inval2));

              for (idx = 0; idx < count; idx++)
                {
                  *(ptr + idx) = inchar;
              for (idx = 0; idx < count; idx++)
                {
                  *(ptr + idx) = inchar;


@@ -628,22 +737,24 @@ value_concat (arg1, arg2)
            }
          else
            {
            }
          else
            {

+             char_type = TYPE_TARGET_TYPE (type2);
+

              for (idx = 0; idx < count; idx++)
                {
              for (idx = 0; idx < count; idx++)
                {

-                 memcpy (ptr + (idx * inval2len), VALUE_CONTENTS (inval2),
+                 memcpy (ptr + (idx * inval2len), value_contents (inval2),

                          inval2len);
                }
            }
                          inval2len);
                }
            }

-         outval = value_string (ptr, count * inval2len);
+         outval = value_string (ptr, count * inval2len, char_type);

        }
       else if (TYPE_CODE (type2) == TYPE_CODE_BITSTRING
               || TYPE_CODE (type2) == TYPE_CODE_BOOL)
        {
        }
       else if (TYPE_CODE (type2) == TYPE_CODE_BITSTRING
               || TYPE_CODE (type2) == TYPE_CODE_BOOL)
        {

-         error ("unimplemented support for bitstring/boolean repeats");
+         error (_("unimplemented support for bitstring/boolean repeats"));

        }
       else
        {
        }
       else
        {

-         error ("can't repeat values of that type");
+         error (_("can't repeat values of that type"));

        }
     }
   else if (TYPE_CODE (type1) == TYPE_CODE_STRING
        }
     }
   else if (TYPE_CODE (type1) == TYPE_CODE_STRING


@@ -653,29 +764,33 @@ value_concat (arg1, arg2)
       if (TYPE_CODE (type2) != TYPE_CODE_STRING
          && TYPE_CODE (type2) != TYPE_CODE_CHAR)
        {
       if (TYPE_CODE (type2) != TYPE_CODE_STRING
          && TYPE_CODE (type2) != TYPE_CODE_CHAR)
        {

-         error ("Strings can only be concatenated with other strings.");
+         error (_("Strings can only be concatenated with other strings."));

        }
       inval1len = TYPE_LENGTH (type1);
       inval2len = TYPE_LENGTH (type2);
       ptr = (char *) alloca (inval1len + inval2len);
       if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
        {
        }
       inval1len = TYPE_LENGTH (type1);
       inval2len = TYPE_LENGTH (type2);
       ptr = (char *) alloca (inval1len + inval2len);
       if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
        {

-         *ptr = (char) unpack_long (type1, VALUE_CONTENTS (inval1));
+         char_type = type1;
+
+         *ptr = (char) unpack_long (type1, value_contents (inval1));

        }
       else
        {
        }
       else
        {

-         memcpy (ptr, VALUE_CONTENTS (inval1), inval1len);
+         char_type = TYPE_TARGET_TYPE (type1);
+
+         memcpy (ptr, value_contents (inval1), inval1len);

        }
       if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
        {
          *(ptr + inval1len) =
        }
       if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
        {
          *(ptr + inval1len) =

-           (char) unpack_long (type2, VALUE_CONTENTS (inval2));
+           (char) unpack_long (type2, value_contents (inval2));

        }
       else
        {
        }
       else
        {

-         memcpy (ptr + inval1len, VALUE_CONTENTS (inval2), inval2len);
+         memcpy (ptr + inval1len, value_contents (inval2), inval2len);

        }
        }

-      outval = value_string (ptr, inval1len + inval2len);
+      outval = value_string (ptr, inval1len + inval2len, char_type);

     }
   else if (TYPE_CODE (type1) == TYPE_CODE_BITSTRING
           || TYPE_CODE (type1) == TYPE_CODE_BOOL)
     }
   else if (TYPE_CODE (type1) == TYPE_CODE_BITSTRING
           || TYPE_CODE (type1) == TYPE_CODE_BOOL)


@@ -684,64 +799,220 @@ value_concat (arg1, arg2)
       if (TYPE_CODE (type2) != TYPE_CODE_BITSTRING
          && TYPE_CODE (type2) != TYPE_CODE_BOOL)
        {
       if (TYPE_CODE (type2) != TYPE_CODE_BITSTRING
          && TYPE_CODE (type2) != TYPE_CODE_BOOL)
        {

-         error ("Bitstrings or booleans can only be concatenated with other bitstrings or booleans.");
+         error (_("Bitstrings or booleans can only be concatenated with other bitstrings or booleans."));

        }
        }

-      error ("unimplemented support for bitstring/boolean concatenation.");
+      error (_("unimplemented support for bitstring/boolean concatenation."));

     }
   else
     {
       /* We don't know how to concatenate these operands. */
     }
   else
     {
       /* We don't know how to concatenate these operands. */

-      error ("illegal operands for concatenation.");
+      error (_("illegal operands for concatenation."));

     }
   return (outval);
 }
 \f
     }
   return (outval);
 }
 \f

+/* Integer exponentiation: V1**V2, where both arguments are
+   integers.  Requires V1 != 0 if V2 < 0.  Returns 1 for 0 ** 0.  */
+static LONGEST
+integer_pow (LONGEST v1, LONGEST v2)
+{
+  if (v2 < 0)
+    {
+      if (v1 == 0)
+       error (_("Attempt to raise 0 to negative power."));
+      else
+       return 0;
+    }
+  else 
+    {
+      /* The Russian Peasant's Algorithm */
+      LONGEST v;
+      
+      v = 1;
+      for (;;)
+       {
+         if (v2 & 1L) 
+           v *= v1;
+         v2 >>= 1;
+         if (v2 == 0)
+           return v;
+         v1 *= v1;
+       }
+    }
+}
+
+/* Integer exponentiation: V1**V2, where both arguments are
+   integers.  Requires V1 != 0 if V2 < 0.  Returns 1 for 0 ** 0.  */
+static ULONGEST
+uinteger_pow (ULONGEST v1, LONGEST v2)
+{
+  if (v2 < 0)
+    {
+      if (v1 == 0)
+       error (_("Attempt to raise 0 to negative power."));
+      else
+       return 0;
+    }
+  else 
+    {
+      /* The Russian Peasant's Algorithm */
+      ULONGEST v;
+      
+      v = 1;
+      for (;;)
+       {
+         if (v2 & 1L) 
+           v *= v1;
+         v2 >>= 1;
+         if (v2 == 0)
+           return v;
+         v1 *= v1;
+       }
+    }
+}
+
+/* Obtain decimal value of arguments for binary operation, converting from
+   other types if one of them is not decimal floating point.  */
+static void
+value_args_as_decimal (struct value *arg1, struct value *arg2,
+                      gdb_byte *x, int *len_x, enum bfd_endian *byte_order_x,
+                      gdb_byte *y, int *len_y, enum bfd_endian *byte_order_y)
+{
+  struct type *type1, *type2;
+
+  type1 = check_typedef (value_type (arg1));
+  type2 = check_typedef (value_type (arg2));
+
+  /* At least one of the arguments must be of decimal float type.  */
+  gdb_assert (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
+             || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT);
+
+  if (TYPE_CODE (type1) == TYPE_CODE_FLT
+      || TYPE_CODE (type2) == TYPE_CODE_FLT)
+    /* The DFP extension to the C language does not allow mixing of
+     * decimal float types with other float types in expressions
+     * (see WDTR 24732, page 12).  */
+    error (_("Mixing decimal floating types with other floating types is not allowed."));
+
+  /* Obtain decimal value of arg1, converting from other types
+     if necessary.  */
+
+  if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
+    {
+      *byte_order_x = gdbarch_byte_order (get_type_arch (type1));
+      *len_x = TYPE_LENGTH (type1);
+      memcpy (x, value_contents (arg1), *len_x);
+    }
+  else if (is_integral_type (type1))
+    {
+      *byte_order_x = gdbarch_byte_order (get_type_arch (type2));
+      *len_x = TYPE_LENGTH (type2);
+      decimal_from_integral (arg1, x, *len_x, *byte_order_x);
+    }
+  else
+    error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1),
+            TYPE_NAME (type2));

 
 

+  /* Obtain decimal value of arg2, converting from other types
+     if necessary.  */
+
+  if (TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
+    {
+      *byte_order_y = gdbarch_byte_order (get_type_arch (type2));
+      *len_y = TYPE_LENGTH (type2);
+      memcpy (y, value_contents (arg2), *len_y);
+    }
+  else if (is_integral_type (type2))
+    {
+      *byte_order_y = gdbarch_byte_order (get_type_arch (type1));
+      *len_y = TYPE_LENGTH (type1);
+      decimal_from_integral (arg2, y, *len_y, *byte_order_y);
+    }
+  else
+    error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1),
+            TYPE_NAME (type2));
+}

 
 /* Perform a binary operation on two operands which have reasonable
    representations as integers or floats.  This includes booleans,
    characters, integers, or floats.
    Does not support addition and subtraction on pointers;
 
 /* Perform a binary operation on two operands which have reasonable
    representations as integers or floats.  This includes booleans,
    characters, integers, or floats.
    Does not support addition and subtraction on pointers;

-   use value_add or value_sub if you want to handle those possibilities.  */
+   use value_ptradd, value_ptrsub or value_ptrdiff for those operations.  */

 
 

-value_ptr
-value_binop (arg1, arg2, op)
-     value_ptr arg1, arg2;
-     enum exp_opcode op;
+static struct value *
+scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)

 {
 {

-  register value_ptr val;
-  struct type *type1, *type2;
+  struct value *val;
+  struct type *type1, *type2, *result_type;
+
+  arg1 = coerce_ref (arg1);
+  arg2 = coerce_ref (arg2);

 
 

-  COERCE_REF (arg1);
-  COERCE_REF (arg2);
-  COERCE_ENUM (arg1);
-  COERCE_ENUM (arg2);
-  type1 = check_typedef (VALUE_TYPE (arg1));
-  type2 = check_typedef (VALUE_TYPE (arg2));
+  type1 = check_typedef (value_type (arg1));
+  type2 = check_typedef (value_type (arg2));

 
   if ((TYPE_CODE (type1) != TYPE_CODE_FLT
 
   if ((TYPE_CODE (type1) != TYPE_CODE_FLT

-       && TYPE_CODE (type1) != TYPE_CODE_CHAR
-       && TYPE_CODE (type1) != TYPE_CODE_INT
-       && TYPE_CODE (type1) != TYPE_CODE_BOOL
-       && TYPE_CODE (type1) != TYPE_CODE_RANGE)
-      ||
-      (TYPE_CODE (type2) != TYPE_CODE_FLT
-       && TYPE_CODE (type2) != TYPE_CODE_CHAR
-       && TYPE_CODE (type2) != TYPE_CODE_INT
-       && TYPE_CODE (type2) != TYPE_CODE_BOOL
-       && TYPE_CODE (type2) != TYPE_CODE_RANGE))
-    error ("Argument to arithmetic operation not a number or boolean.");
+       && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
+       && !is_integral_type (type1))
+      || (TYPE_CODE (type2) != TYPE_CODE_FLT
+         && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
+         && !is_integral_type (type2)))
+    error (_("Argument to arithmetic operation not a number or boolean."));
+
+  if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
+      || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
+    {
+      int len_v1, len_v2, len_v;
+      enum bfd_endian byte_order_v1, byte_order_v2, byte_order_v;
+      gdb_byte v1[16], v2[16];
+      gdb_byte v[16];
+
+      /* If only one type is decimal float, use its type.
+        Otherwise use the bigger type.  */
+      if (TYPE_CODE (type1) != TYPE_CODE_DECFLOAT)
+       result_type = type2;
+      else if (TYPE_CODE (type2) != TYPE_CODE_DECFLOAT)
+       result_type = type1;
+      else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
+       result_type = type2;
+      else
+       result_type = type1;

 
 

-  if (TYPE_CODE (type1) == TYPE_CODE_FLT
-      ||
-      TYPE_CODE (type2) == TYPE_CODE_FLT)
+      len_v = TYPE_LENGTH (result_type);
+      byte_order_v = gdbarch_byte_order (get_type_arch (result_type));
+
+      value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
+                                        v2, &len_v2, &byte_order_v2);
+
+      switch (op)
+       {
+       case BINOP_ADD:
+       case BINOP_SUB:
+       case BINOP_MUL:
+       case BINOP_DIV:
+       case BINOP_EXP:
+         decimal_binop (op, v1, len_v1, byte_order_v1,
+                            v2, len_v2, byte_order_v2,
+                            v, len_v, byte_order_v);
+         break;
+
+       default:
+         error (_("Operation not valid for decimal floating point number."));
+       }
+
+      val = value_from_decfloat (result_type, v);
+    }
+  else if (TYPE_CODE (type1) == TYPE_CODE_FLT
+          || TYPE_CODE (type2) == TYPE_CODE_FLT)

     {
       /* FIXME-if-picky-about-floating-accuracy: Should be doing this
          in target format.  real.c in GCC probably has the necessary
          code.  */
       DOUBLEST v1, v2, v = 0;
     {
       /* FIXME-if-picky-about-floating-accuracy: Should be doing this
          in target format.  real.c in GCC probably has the necessary
          code.  */
       DOUBLEST v1, v2, v = 0;

+

       v1 = value_as_double (arg1);
       v2 = value_as_double (arg2);
       v1 = value_as_double (arg1);
       v2 = value_as_double (arg2);

+

       switch (op)
        {
        case BINOP_ADD:
       switch (op)
        {
        case BINOP_ADD:


@@ -760,33 +1031,44 @@ value_binop (arg1, arg2, op)
          v = v1 / v2;
          break;
 
          v = v1 / v2;
          break;
 

-        case BINOP_EXP:
-          v = pow (v1, v2);
-          if (errno)
-            error ("Cannot perform exponentiation: %s", strerror (errno));
-          break;
+       case BINOP_EXP:
+         errno = 0;
+         v = pow (v1, v2);
+         if (errno)
+           error (_("Cannot perform exponentiation: %s"), safe_strerror (errno));
+         break;
+
+       case BINOP_MIN:
+         v = v1 < v2 ? v1 : v2;
+         break;
+             
+       case BINOP_MAX:
+         v = v1 > v2 ? v1 : v2;
+         break;

 
        default:
 
        default:

-         error ("Integer-only operation on floating point number.");
+         error (_("Integer-only operation on floating point number."));

        }
 
        }
 

-      /* If either arg was long double, make sure that value is also long
-         double.  */
-
-      if (TYPE_LENGTH (type1) * 8 > TARGET_DOUBLE_BIT
-         || TYPE_LENGTH (type2) * 8 > TARGET_DOUBLE_BIT)
-       val = allocate_value (builtin_type_long_double);
+      /* If only one type is float, use its type.
+        Otherwise use the bigger type.  */
+      if (TYPE_CODE (type1) != TYPE_CODE_FLT)
+       result_type = type2;
+      else if (TYPE_CODE (type2) != TYPE_CODE_FLT)
+       result_type = type1;
+      else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
+       result_type = type2;

       else
       else

-       val = allocate_value (builtin_type_double);
+       result_type = type1;

 
 

-      store_floating (VALUE_CONTENTS_RAW (val), TYPE_LENGTH (VALUE_TYPE (val)),
-                     v);
+      val = allocate_value (result_type);
+      store_typed_floating (value_contents_raw (val), value_type (val), v);

     }
   else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
     }
   else if (TYPE_CODE (type1) == TYPE_CODE_BOOL

-          &&
-          TYPE_CODE (type2) == TYPE_CODE_BOOL)
+          || TYPE_CODE (type2) == TYPE_CODE_BOOL)

     {
       LONGEST v1, v2, v = 0;
     {
       LONGEST v1, v2, v = 0;

+

       v1 = value_as_long (arg1);
       v2 = value_as_long (arg2);
 
       v1 = value_as_long (arg1);
       v2 = value_as_long (arg2);
 


@@ -813,73 +1095,46 @@ value_binop (arg1, arg2, op)
          break;
 
        default:
          break;
 
        default:

-         error ("Invalid operation on booleans.");
+         error (_("Invalid operation on booleans."));

        }
 
        }
 

-      val = allocate_value (type1);
-      store_signed_integer (VALUE_CONTENTS_RAW (val),
-                           TYPE_LENGTH (type1),
+      result_type = type1;
+
+      val = allocate_value (result_type);
+      store_signed_integer (value_contents_raw (val),
+                           TYPE_LENGTH (result_type),
+                           gdbarch_byte_order (get_type_arch (result_type)),

                            v);
     }
   else
     /* Integral operations here.  */
                            v);
     }
   else
     /* Integral operations here.  */

-    /* FIXME:  Also mixed integral/booleans, with result an integer. */
-    /* FIXME: This implements ANSI C rules (also correct for C++).
-       What about FORTRAN and chill?  */

     {
     {

-      unsigned int promoted_len1 = TYPE_LENGTH (type1);
-      unsigned int promoted_len2 = TYPE_LENGTH (type2);
-      int is_unsigned1 = TYPE_UNSIGNED (type1);
-      int is_unsigned2 = TYPE_UNSIGNED (type2);
-      unsigned int result_len;
-      int unsigned_operation;
-
-      /* Determine type length and signedness after promotion for
-         both operands.  */
-      if (promoted_len1 < TYPE_LENGTH (builtin_type_int))
-       {
-         is_unsigned1 = 0;
-         promoted_len1 = TYPE_LENGTH (builtin_type_int);
-       }
-      if (promoted_len2 < TYPE_LENGTH (builtin_type_int))
-       {
-         is_unsigned2 = 0;
-         promoted_len2 = TYPE_LENGTH (builtin_type_int);
-       }
-

       /* Determine type length of the result, and if the operation should
       /* Determine type length of the result, and if the operation should

-         be done unsigned.
-         Use the signedness of the operand with the greater length.
-         If both operands are of equal length, use unsigned operation
-         if one of the operands is unsigned.  */
-      if (promoted_len1 > promoted_len2)
-       {
-         unsigned_operation = is_unsigned1;
-         result_len = promoted_len1;
-       }
-      else if (promoted_len2 > promoted_len1)
-       {
-         unsigned_operation = is_unsigned2;
-         result_len = promoted_len2;
-       }
+        be done unsigned.  For exponentiation and shift operators,
+        use the length and type of the left operand.  Otherwise,
+        use the signedness of the operand with the greater length.
+        If both operands are of equal length, use unsigned operation
+        if one of the operands is unsigned.  */
+      if (op == BINOP_RSH || op == BINOP_LSH || op == BINOP_EXP)
+       result_type = type1;
+      else if (TYPE_LENGTH (type1) > TYPE_LENGTH (type2))
+       result_type = type1;
+      else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
+       result_type = type2;
+      else if (TYPE_UNSIGNED (type1))
+       result_type = type1;
+      else if (TYPE_UNSIGNED (type2))
+       result_type = type2;

       else
       else

-       {
-         unsigned_operation = is_unsigned1 || is_unsigned2;
-         result_len = promoted_len1;
-       }
+       result_type = type1;

 
 

-      if (unsigned_operation)
+      if (TYPE_UNSIGNED (result_type))

        {
        {

+         LONGEST v2_signed = value_as_long (arg2);

          ULONGEST v1, v2, v = 0;
          ULONGEST v1, v2, v = 0;

-         v1 = (ULONGEST) value_as_long (arg1);
-         v2 = (ULONGEST) value_as_long (arg2);

 
 

-         /* Truncate values to the type length of the result.  */
-         if (result_len < sizeof (ULONGEST))
-           {
-             v1 &= ((LONGEST) 1 << HOST_CHAR_BIT * result_len) - 1;
-             v2 &= ((LONGEST) 1 << HOST_CHAR_BIT * result_len) - 1;
-           }
+         v1 = (ULONGEST) value_as_long (arg1);
+         v2 = (ULONGEST) v2_signed;

 
          switch (op)
            {
 
          switch (op)
            {


@@ -896,28 +1151,27 @@ value_binop (arg1, arg2, op)
              break;
 
            case BINOP_DIV:
              break;
 
            case BINOP_DIV:

-             v = v1 / v2;
+           case BINOP_INTDIV:
+             if (v2 != 0)
+               v = v1 / v2;
+             else
+               error (_("Division by zero"));

              break;
 
              break;
 

-            case BINOP_EXP:
-              v = pow (v1, v2);
-              if (errno)
-                error ("Cannot perform exponentiation: %s", strerror (errno));
-              break;
+           case BINOP_EXP:
+              v = uinteger_pow (v1, v2_signed);
+             break;

 
            case BINOP_REM:
 
            case BINOP_REM:

-             v = v1 % v2;
+             if (v2 != 0)
+               v = v1 % v2;
+             else
+               error (_("Division by zero"));

              break;
 
            case BINOP_MOD:
              /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
                 v1 mod 0 has a defined value, v1. */
              break;
 
            case BINOP_MOD:
              /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
                 v1 mod 0 has a defined value, v1. */

-             /* Chill specifies that v2 must be > 0, so check for that. */
-             if (current_language->la_language == language_chill
-                 && value_as_long (arg2) <= 0)
-               {
-                 error ("Second operand of MOD must be greater than zero.");
-               }

              if (v2 == 0)
                {
                  v = v1;
              if (v2 == 0)
                {
                  v = v1;


@@ -978,30 +1232,33 @@ value_binop (arg1, arg2, op)
              v = v1 < v2;
              break;
 
              v = v1 < v2;
              break;
 

+           case BINOP_GTR:
+             v = v1 > v2;
+             break;
+
+           case BINOP_LEQ:
+             v = v1 <= v2;
+             break;
+
+           case BINOP_GEQ:
+             v = v1 >= v2;
+             break;
+

            default:
            default:

-             error ("Invalid binary operation on numbers.");
+             error (_("Invalid binary operation on numbers."));

            }
 
            }
 

-         /* This is a kludge to get around the fact that we don't
-            know how to determine the result type from the types of
-            the operands.  (I'm not really sure how much we feel the
-            need to duplicate the exact rules of the current
-            language.  They can get really hairy.  But not to do so
-            makes it hard to document just what we *do* do).  */
-
-         /* Can't just call init_type because we wouldn't know what
-            name to give the type.  */
-         val = allocate_value
-           (result_len > TARGET_LONG_BIT / HOST_CHAR_BIT
-            ? builtin_type_unsigned_long_long
-            : builtin_type_unsigned_long);
-         store_unsigned_integer (VALUE_CONTENTS_RAW (val),
-                                 TYPE_LENGTH (VALUE_TYPE (val)),
+         val = allocate_value (result_type);
+         store_unsigned_integer (value_contents_raw (val),
+                                 TYPE_LENGTH (value_type (val)),
+                                 gdbarch_byte_order
+                                   (get_type_arch (result_type)),

                                  v);
        }
       else
        {
          LONGEST v1, v2, v = 0;
                                  v);
        }
       else
        {
          LONGEST v1, v2, v = 0;

+

          v1 = value_as_long (arg1);
          v2 = value_as_long (arg2);
 
          v1 = value_as_long (arg1);
          v2 = value_as_long (arg2);
 


@@ -1020,28 +1277,27 @@ value_binop (arg1, arg2, op)
              break;
 
            case BINOP_DIV:
              break;
 
            case BINOP_DIV:

-             v = v1 / v2;
+           case BINOP_INTDIV:
+             if (v2 != 0)
+               v = v1 / v2;
+             else
+               error (_("Division by zero"));

               break;
 
               break;
 

-            case BINOP_EXP:
-              v = pow (v1, v2);
-              if (errno)
-                error ("Cannot perform exponentiation: %s", strerror (errno));
+           case BINOP_EXP:
+              v = integer_pow (v1, v2);

              break;
 
            case BINOP_REM:
              break;
 
            case BINOP_REM:

-             v = v1 % v2;
+             if (v2 != 0)
+               v = v1 % v2;
+             else
+               error (_("Division by zero"));

              break;
 
            case BINOP_MOD:
              /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
                 X mod 0 has a defined value, X. */
              break;
 
            case BINOP_MOD:
              /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
                 X mod 0 has a defined value, X. */

-             /* Chill specifies that v2 must be > 0, so check for that. */
-             if (current_language->la_language == language_chill
-                 && v2 <= 0)
-               {
-                 error ("Second operand of MOD must be greater than zero.");
-               }

              if (v2 == 0)
                {
                  v = v1;
              if (v2 == 0)
                {
                  v = v1;


@@ -1098,54 +1354,148 @@ value_binop (arg1, arg2, op)
              v = v1 == v2;
              break;
 
              v = v1 == v2;
              break;
 

+            case BINOP_NOTEQUAL:
+              v = v1 != v2;
+              break;
+

            case BINOP_LESS:
              v = v1 < v2;
              break;
 
            case BINOP_LESS:
              v = v1 < v2;
              break;
 

+           case BINOP_GTR:
+             v = v1 > v2;
+             break;
+
+           case BINOP_LEQ:
+             v = v1 <= v2;
+             break;
+
+           case BINOP_GEQ:
+             v = v1 >= v2;
+             break;
+

            default:
            default:

-             error ("Invalid binary operation on numbers.");
+             error (_("Invalid binary operation on numbers."));

            }
 
            }
 

-         /* This is a kludge to get around the fact that we don't
-            know how to determine the result type from the types of
-            the operands.  (I'm not really sure how much we feel the
-            need to duplicate the exact rules of the current
-            language.  They can get really hairy.  But not to do so
-            makes it hard to document just what we *do* do).  */
-
-         /* Can't just call init_type because we wouldn't know what
-            name to give the type.  */
-         val = allocate_value
-           (result_len > TARGET_LONG_BIT / HOST_CHAR_BIT
-            ? builtin_type_long_long
-            : builtin_type_long);
-         store_signed_integer (VALUE_CONTENTS_RAW (val),
-                               TYPE_LENGTH (VALUE_TYPE (val)),
+         val = allocate_value (result_type);
+         store_signed_integer (value_contents_raw (val),
+                               TYPE_LENGTH (value_type (val)),
+                               gdbarch_byte_order
+                                 (get_type_arch (result_type)),

                                v);
        }
     }
 
   return val;
 }
                                v);
        }
     }
 
   return val;
 }

+
+/* Performs a binary operation on two vector operands by calling scalar_binop
+   for each pair of vector components.  */
+
+static struct value *
+vector_binop (struct value *val1, struct value *val2, enum exp_opcode op)
+{
+  struct value *val, *tmp, *mark;
+  struct type *type1, *type2, *eltype1, *eltype2, *result_type;
+  int t1_is_vec, t2_is_vec, elsize, i;
+  LONGEST low_bound1, high_bound1, low_bound2, high_bound2;
+
+  type1 = check_typedef (value_type (val1));
+  type2 = check_typedef (value_type (val2));
+
+  t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
+              && TYPE_VECTOR (type1)) ? 1 : 0;
+  t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
+              && TYPE_VECTOR (type2)) ? 1 : 0;
+
+  if (!t1_is_vec || !t2_is_vec)
+    error (_("Vector operations are only supported among vectors"));
+
+  if (!get_array_bounds (type1, &low_bound1, &high_bound1)
+      || !get_array_bounds (type2, &low_bound2, &high_bound2))
+    error (_("Could not determine the vector bounds"));
+
+  eltype1 = check_typedef (TYPE_TARGET_TYPE (type1));
+  eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
+  elsize = TYPE_LENGTH (eltype1);
+
+  if (TYPE_CODE (eltype1) != TYPE_CODE (eltype2)
+      || elsize != TYPE_LENGTH (eltype2)
+      || TYPE_UNSIGNED (eltype1) != TYPE_UNSIGNED (eltype2)
+      || low_bound1 != low_bound2 || high_bound1 != high_bound2)
+    error (_("Cannot perform operation on vectors with different types"));
+
+  val = allocate_value (type1);
+  mark = value_mark ();
+  for (i = 0; i < high_bound1 - low_bound1 + 1; i++)
+    {
+      tmp = value_binop (value_subscript (val1, i),
+                        value_subscript (val2, i), op);
+      memcpy (value_contents_writeable (val) + i * elsize,
+             value_contents_all (tmp),
+             elsize);
+     }
+  value_free_to_mark (mark);
+
+  return val;
+}
+
+/* Perform a binary operation on two operands.  */
+
+struct value *
+value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
+{
+  struct value *val;
+  struct type *type1 = check_typedef (value_type (arg1));
+  struct type *type2 = check_typedef (value_type (arg2));
+  int t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
+                  && TYPE_VECTOR (type1));
+  int t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
+                  && TYPE_VECTOR (type2));
+
+  if (!t1_is_vec && !t2_is_vec)
+    val = scalar_binop (arg1, arg2, op);
+  else if (t1_is_vec && t2_is_vec)
+    val = vector_binop (arg1, arg2, op);
+  else
+    {
+      /* Widen the scalar operand to a vector.  */
+      struct value **v = t1_is_vec ? &arg2 : &arg1;
+      struct type *t = t1_is_vec ? type2 : type1;
+      
+      if (TYPE_CODE (t) != TYPE_CODE_FLT
+         && TYPE_CODE (t) != TYPE_CODE_DECFLOAT
+         && !is_integral_type (t))
+       error (_("Argument to operation not a number or boolean."));
+
+      *v = value_cast (t1_is_vec ? type1 : type2, *v);
+      val = vector_binop (arg1, arg2, op);
+    }
+
+  return val;
+}

 \f
 /* Simulate the C operator ! -- return 1 if ARG1 contains zero.  */
 
 int
 \f
 /* Simulate the C operator ! -- return 1 if ARG1 contains zero.  */
 
 int

-value_logical_not (arg1)
-     value_ptr arg1;
+value_logical_not (struct value *arg1)

 {
 {

-  register int len;
-  register char *p;
+  int len;
+  const gdb_byte *p;

   struct type *type1;
 
   struct type *type1;
 

-  COERCE_NUMBER (arg1);
-  type1 = check_typedef (VALUE_TYPE (arg1));
+  arg1 = coerce_array (arg1);
+  type1 = check_typedef (value_type (arg1));

 
   if (TYPE_CODE (type1) == TYPE_CODE_FLT)
     return 0 == value_as_double (arg1);
 
   if (TYPE_CODE (type1) == TYPE_CODE_FLT)
     return 0 == value_as_double (arg1);

+  else if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
+    return decimal_is_zero (value_contents (arg1), TYPE_LENGTH (type1),
+                           gdbarch_byte_order (get_type_arch (type1)));

 
   len = TYPE_LENGTH (type1);
 
   len = TYPE_LENGTH (type1);

-  p = VALUE_CONTENTS (arg1);
+  p = value_contents (arg1);

 
   while (--len >= 0)
     {
 
   while (--len >= 0)
     {


@@ -1160,13 +1510,12 @@ value_logical_not (arg1)
    necessarily null terminated) based on their length */
 
 static int
    necessarily null terminated) based on their length */
 
 static int

-value_strcmp (arg1, arg2)
-     register value_ptr arg1, arg2;
+value_strcmp (struct value *arg1, struct value *arg2)

 {
 {

-  int len1 = TYPE_LENGTH (VALUE_TYPE (arg1));
-  int len2 = TYPE_LENGTH (VALUE_TYPE (arg2));
-  char *s1 = VALUE_CONTENTS (arg1);
-  char *s2 = VALUE_CONTENTS (arg2);
+  int len1 = TYPE_LENGTH (value_type (arg1));
+  int len2 = TYPE_LENGTH (value_type (arg2));
+  const gdb_byte *s1 = value_contents (arg1);
+  const gdb_byte *s2 = value_contents (arg2);

   int i, len = len1 < len2 ? len1 : len2;
 
   for (i = 0; i < len; i++)
   int i, len = len1 < len2 ? len1 : len2;
 
   for (i = 0; i < len; i++)


@@ -1191,45 +1540,65 @@ value_strcmp (arg1, arg2)
    iff ARG1 and ARG2 have equal contents.  */
 
 int
    iff ARG1 and ARG2 have equal contents.  */
 
 int

-value_equal (arg1, arg2)
-     register value_ptr arg1, arg2;
-
+value_equal (struct value *arg1, struct value *arg2)

 {
 {

-  register int len;
-  register char *p1, *p2;
+  int len;
+  const gdb_byte *p1;
+  const gdb_byte *p2;

   struct type *type1, *type2;
   enum type_code code1;
   enum type_code code2;
   struct type *type1, *type2;
   enum type_code code1;
   enum type_code code2;

+  int is_int1, is_int2;

 
 

-  COERCE_NUMBER (arg1);
-  COERCE_NUMBER (arg2);
+  arg1 = coerce_array (arg1);
+  arg2 = coerce_array (arg2);

 
 

-  type1 = check_typedef (VALUE_TYPE (arg1));
-  type2 = check_typedef (VALUE_TYPE (arg2));
+  type1 = check_typedef (value_type (arg1));
+  type2 = check_typedef (value_type (arg2));

   code1 = TYPE_CODE (type1);
   code2 = TYPE_CODE (type2);
   code1 = TYPE_CODE (type1);
   code2 = TYPE_CODE (type2);

+  is_int1 = is_integral_type (type1);
+  is_int2 = is_integral_type (type2);

 
 

-  if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL) &&
-      (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
+  if (is_int1 && is_int2)

     return longest_to_int (value_as_long (value_binop (arg1, arg2,
                                                       BINOP_EQUAL)));
     return longest_to_int (value_as_long (value_binop (arg1, arg2,
                                                       BINOP_EQUAL)));

-  else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL)
-          && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
-    return value_as_double (arg1) == value_as_double (arg2);
+  else if ((code1 == TYPE_CODE_FLT || is_int1)
+          && (code2 == TYPE_CODE_FLT || is_int2))
+    {
+      /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
+        `long double' values are returned in static storage (m68k).  */
+      DOUBLEST d = value_as_double (arg1);
+
+      return d == value_as_double (arg2);
+    }
+  else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
+          && (code2 == TYPE_CODE_DECFLOAT || is_int2))
+    {
+      gdb_byte v1[16], v2[16];
+      int len_v1, len_v2;
+      enum bfd_endian byte_order_v1, byte_order_v2;
+
+      value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
+                                        v2, &len_v2, &byte_order_v2);
+
+      return decimal_compare (v1, len_v1, byte_order_v1,
+                             v2, len_v2, byte_order_v2) == 0;
+    }

 
   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
      is bigger.  */
 
   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
      is bigger.  */

-  else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
-    return value_as_pointer (arg1) == (CORE_ADDR) value_as_long (arg2);
-  else if (code2 == TYPE_CODE_PTR && (code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL))
-    return (CORE_ADDR) value_as_long (arg1) == value_as_pointer (arg2);
+  else if (code1 == TYPE_CODE_PTR && is_int2)
+    return value_as_address (arg1) == (CORE_ADDR) value_as_long (arg2);
+  else if (code2 == TYPE_CODE_PTR && is_int1)
+    return (CORE_ADDR) value_as_long (arg1) == value_as_address (arg2);

 
   else if (code1 == code2
           && ((len = (int) TYPE_LENGTH (type1))
               == (int) TYPE_LENGTH (type2)))
     {
 
   else if (code1 == code2
           && ((len = (int) TYPE_LENGTH (type1))
               == (int) TYPE_LENGTH (type2)))
     {

-      p1 = VALUE_CONTENTS (arg1);
-      p2 = VALUE_CONTENTS (arg2);
+      p1 = value_contents (arg1);
+      p2 = value_contents (arg2);

       while (--len >= 0)
        {
          if (*p1++ != *p2++)
       while (--len >= 0)
        {
          if (*p1++ != *p2++)


@@ -1243,163 +1612,266 @@ value_equal (arg1, arg2)
     }
   else
     {
     }
   else
     {

-      error ("Invalid type combination in equality test.");
+      error (_("Invalid type combination in equality test."));

       return 0;                        /* For lint -- never reached */
     }
 }
 
       return 0;                        /* For lint -- never reached */
     }
 }
 

+/* Compare values based on their raw contents.  Useful for arrays since
+   value_equal coerces them to pointers, thus comparing just the address
+   of the array instead of its contents.  */
+
+int
+value_equal_contents (struct value *arg1, struct value *arg2)
+{
+  struct type *type1, *type2;
+
+  type1 = check_typedef (value_type (arg1));
+  type2 = check_typedef (value_type (arg2));
+
+  return (TYPE_CODE (type1) == TYPE_CODE (type2)
+         && TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
+         && memcmp (value_contents (arg1), value_contents (arg2),
+                    TYPE_LENGTH (type1)) == 0);
+}
+

 /* Simulate the C operator < by returning 1
    iff ARG1's contents are less than ARG2's.  */
 
 int
 /* Simulate the C operator < by returning 1
    iff ARG1's contents are less than ARG2's.  */
 
 int

-value_less (arg1, arg2)
-     register value_ptr arg1, arg2;
+value_less (struct value *arg1, struct value *arg2)

 {
 {

-  register enum type_code code1;
-  register enum type_code code2;
+  enum type_code code1;
+  enum type_code code2;

   struct type *type1, *type2;
   struct type *type1, *type2;

+  int is_int1, is_int2;

 
 

-  COERCE_NUMBER (arg1);
-  COERCE_NUMBER (arg2);
+  arg1 = coerce_array (arg1);
+  arg2 = coerce_array (arg2);

 
 

-  type1 = check_typedef (VALUE_TYPE (arg1));
-  type2 = check_typedef (VALUE_TYPE (arg2));
+  type1 = check_typedef (value_type (arg1));
+  type2 = check_typedef (value_type (arg2));

   code1 = TYPE_CODE (type1);
   code2 = TYPE_CODE (type2);
   code1 = TYPE_CODE (type1);
   code2 = TYPE_CODE (type2);

+  is_int1 = is_integral_type (type1);
+  is_int2 = is_integral_type (type2);

 
 

-  if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL) &&
-      (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
+  if (is_int1 && is_int2)

     return longest_to_int (value_as_long (value_binop (arg1, arg2,
                                                       BINOP_LESS)));
     return longest_to_int (value_as_long (value_binop (arg1, arg2,
                                                       BINOP_LESS)));

-  else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL)
-          && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
-    return value_as_double (arg1) < value_as_double (arg2);
+  else if ((code1 == TYPE_CODE_FLT || is_int1)
+          && (code2 == TYPE_CODE_FLT || is_int2))
+    {
+      /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
+        `long double' values are returned in static storage (m68k).  */
+      DOUBLEST d = value_as_double (arg1);
+
+      return d < value_as_double (arg2);
+    }
+  else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
+          && (code2 == TYPE_CODE_DECFLOAT || is_int2))
+    {
+      gdb_byte v1[16], v2[16];
+      int len_v1, len_v2;
+      enum bfd_endian byte_order_v1, byte_order_v2;
+
+      value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
+                                        v2, &len_v2, &byte_order_v2);
+
+      return decimal_compare (v1, len_v1, byte_order_v1,
+                             v2, len_v2, byte_order_v2) == -1;
+    }

   else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
   else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)

-    return value_as_pointer (arg1) < value_as_pointer (arg2);
+    return value_as_address (arg1) < value_as_address (arg2);

 
   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
      is bigger.  */
 
   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
      is bigger.  */

-  else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
-    return value_as_pointer (arg1) < (CORE_ADDR) value_as_long (arg2);
-  else if (code2 == TYPE_CODE_PTR && (code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL))
-    return (CORE_ADDR) value_as_long (arg1) < value_as_pointer (arg2);
+  else if (code1 == TYPE_CODE_PTR && is_int2)
+    return value_as_address (arg1) < (CORE_ADDR) value_as_long (arg2);
+  else if (code2 == TYPE_CODE_PTR && is_int1)
+    return (CORE_ADDR) value_as_long (arg1) < value_as_address (arg2);

   else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
     return value_strcmp (arg1, arg2) < 0;
   else
     {
   else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
     return value_strcmp (arg1, arg2) < 0;
   else
     {

-      error ("Invalid type combination in ordering comparison.");
+      error (_("Invalid type combination in ordering comparison."));

       return 0;
     }
 }
 \f
       return 0;
     }
 }
 \f

-/* The unary operators - and ~.  Both free the argument ARG1.  */
+/* The unary operators +, - and ~.  They free the argument ARG1.  */

 
 

-value_ptr
-value_neg (arg1)
-     register value_ptr arg1;
+struct value *
+value_pos (struct value *arg1)

 {
 {

-  register struct type *type;
-  register struct type *result_type = VALUE_TYPE (arg1);
+  struct type *type;

 
 

-  COERCE_REF (arg1);
-  COERCE_ENUM (arg1);
-
-  type = check_typedef (VALUE_TYPE (arg1));
+  arg1 = coerce_ref (arg1);
+  type = check_typedef (value_type (arg1));

 
   if (TYPE_CODE (type) == TYPE_CODE_FLT)
 
   if (TYPE_CODE (type) == TYPE_CODE_FLT)

-    return value_from_double (result_type, -value_as_double (arg1));
-  else if (TYPE_CODE (type) == TYPE_CODE_INT || TYPE_CODE (type) == TYPE_CODE_BOOL)
+    return value_from_double (type, value_as_double (arg1));
+  else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
+    return value_from_decfloat (type, value_contents (arg1));
+  else if (is_integral_type (type))
+    {
+      return value_from_longest (type, value_as_long (arg1));
+    }
+  else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))

     {
     {

-      /* Perform integral promotion for ANSI C/C++.
-         FIXME: What about FORTRAN and chill ?  */
-      if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
-       result_type = builtin_type_int;
+      struct value *val = allocate_value (type);

 
 

-      return value_from_longest (result_type, -value_as_long (arg1));
+      memcpy (value_contents_raw (val), value_contents (arg1),
+              TYPE_LENGTH (type));
+      return val;

     }
   else
     {
     }
   else
     {

-      error ("Argument to negate operation not a number.");
+      error ("Argument to positive operation not a number.");

       return 0;                        /* For lint -- never reached */
     }
 }
 
       return 0;                        /* For lint -- never reached */
     }
 }
 

-value_ptr
-value_complement (arg1)
-     register value_ptr arg1;
+struct value *
+value_neg (struct value *arg1)

 {
 {

-  register struct type *type;
-  register struct type *result_type = VALUE_TYPE (arg1);
-  int typecode;
+  struct type *type;
+
+  arg1 = coerce_ref (arg1);
+  type = check_typedef (value_type (arg1));
+
+  if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
+    {
+      struct value *val = allocate_value (type);
+      int len = TYPE_LENGTH (type);
+      gdb_byte decbytes[16];  /* a decfloat is at most 128 bits long */
+
+      memcpy (decbytes, value_contents (arg1), len);
+
+      if (gdbarch_byte_order (get_type_arch (type)) == BFD_ENDIAN_LITTLE)
+       decbytes[len-1] = decbytes[len - 1] | 0x80;
+      else
+       decbytes[0] = decbytes[0] | 0x80;
+
+      memcpy (value_contents_raw (val), decbytes, len);
+      return val;
+    }
+  else if (TYPE_CODE (type) == TYPE_CODE_FLT)
+    return value_from_double (type, -value_as_double (arg1));
+  else if (is_integral_type (type))
+    {
+      return value_from_longest (type, -value_as_long (arg1));
+    }
+  else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
+    {
+      struct value *tmp, *val = allocate_value (type);
+      struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
+      int i;
+      LONGEST low_bound, high_bound;
+
+      if (!get_array_bounds (type, &low_bound, &high_bound))
+       error (_("Could not determine the vector bounds"));

 
 

-  COERCE_REF (arg1);
-  COERCE_ENUM (arg1);
+      for (i = 0; i < high_bound - low_bound + 1; i++)
+       {
+         tmp = value_neg (value_subscript (arg1, i));
+         memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
+                 value_contents_all (tmp), TYPE_LENGTH (eltype));
+       }
+      return val;
+    }
+  else
+    {
+      error (_("Argument to negate operation not a number."));
+      return 0;                        /* For lint -- never reached */
+    }
+}

 
 

-  type = check_typedef (VALUE_TYPE (arg1));
+struct value *
+value_complement (struct value *arg1)
+{
+  struct type *type;
+  struct value *val;

 
 

-  typecode = TYPE_CODE (type);
-  if ((typecode != TYPE_CODE_INT) && (typecode != TYPE_CODE_BOOL))
-    error ("Argument to complement operation not an integer or boolean.");
+  arg1 = coerce_ref (arg1);
+  type = check_typedef (value_type (arg1));

 
 

-  /* Perform integral promotion for ANSI C/C++.
-     FIXME: What about FORTRAN ?  */
-  if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
-    result_type = builtin_type_int;
+  if (is_integral_type (type))
+    val = value_from_longest (type, ~value_as_long (arg1));
+  else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
+    {
+      struct value *tmp;
+      struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
+      int i;
+      LONGEST low_bound, high_bound;
+
+      if (!get_array_bounds (type, &low_bound, &high_bound))
+       error (_("Could not determine the vector bounds"));
+
+      val = allocate_value (type);
+      for (i = 0; i < high_bound - low_bound + 1; i++)
+        {
+          tmp = value_complement (value_subscript (arg1, i));
+          memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
+                  value_contents_all (tmp), TYPE_LENGTH (eltype));
+        }
+    }
+  else
+    error (_("Argument to complement operation not an integer, boolean."));

 
 

-  return value_from_longest (result_type, ~value_as_long (arg1));
+  return val;

 }
 \f
 }
 \f

-/* The INDEX'th bit of SET value whose VALUE_TYPE is TYPE,
-   and whose VALUE_CONTENTS is valaddr.
+/* The INDEX'th bit of SET value whose value_type is TYPE,
+   and whose value_contents is valaddr.

    Return -1 if out of range, -2 other error. */
 
 int
    Return -1 if out of range, -2 other error. */
 
 int

-value_bit_index (type, valaddr, index)
-     struct type *type;
-     char *valaddr;
-     int index;
+value_bit_index (struct type *type, const gdb_byte *valaddr, int index)

 {
 {

+  struct gdbarch *gdbarch = get_type_arch (type);

   LONGEST low_bound, high_bound;
   LONGEST word;
   unsigned rel_index;
   LONGEST low_bound, high_bound;
   LONGEST word;
   unsigned rel_index;

-  struct type *range = TYPE_FIELD_TYPE (type, 0);
+  struct type *range = TYPE_INDEX_TYPE (type);
+

   if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
     return -2;
   if (index < low_bound || index > high_bound)
     return -1;
   rel_index = index - low_bound;
   if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
     return -2;
   if (index < low_bound || index > high_bound)
     return -1;
   rel_index = index - low_bound;

-  word = unpack_long (builtin_type_unsigned_char,
-                     valaddr + (rel_index / TARGET_CHAR_BIT));
+  word = extract_unsigned_integer (valaddr + (rel_index / TARGET_CHAR_BIT), 1,
+                                  gdbarch_byte_order (gdbarch));

   rel_index %= TARGET_CHAR_BIT;
   rel_index %= TARGET_CHAR_BIT;

-  if (BITS_BIG_ENDIAN)
+  if (gdbarch_bits_big_endian (gdbarch))

     rel_index = TARGET_CHAR_BIT - 1 - rel_index;
   return (word >> rel_index) & 1;
 }
 
     rel_index = TARGET_CHAR_BIT - 1 - rel_index;
   return (word >> rel_index) & 1;
 }
 

-value_ptr
-value_in (element, set)
-     value_ptr element, set;
+int
+value_in (struct value *element, struct value *set)

 {
   int member;
 {
   int member;

-  struct type *settype = check_typedef (VALUE_TYPE (set));
-  struct type *eltype = check_typedef (VALUE_TYPE (element));
+  struct type *settype = check_typedef (value_type (set));
+  struct type *eltype = check_typedef (value_type (element));
+

   if (TYPE_CODE (eltype) == TYPE_CODE_RANGE)
     eltype = TYPE_TARGET_TYPE (eltype);
   if (TYPE_CODE (settype) != TYPE_CODE_SET)
   if (TYPE_CODE (eltype) == TYPE_CODE_RANGE)
     eltype = TYPE_TARGET_TYPE (eltype);
   if (TYPE_CODE (settype) != TYPE_CODE_SET)

-    error ("Second argument of 'IN' has wrong type");
+    error (_("Second argument of 'IN' has wrong type"));

   if (TYPE_CODE (eltype) != TYPE_CODE_INT
       && TYPE_CODE (eltype) != TYPE_CODE_CHAR
       && TYPE_CODE (eltype) != TYPE_CODE_ENUM
       && TYPE_CODE (eltype) != TYPE_CODE_BOOL)
   if (TYPE_CODE (eltype) != TYPE_CODE_INT
       && TYPE_CODE (eltype) != TYPE_CODE_CHAR
       && TYPE_CODE (eltype) != TYPE_CODE_ENUM
       && TYPE_CODE (eltype) != TYPE_CODE_BOOL)

-    error ("First argument of 'IN' has wrong type");
-  member = value_bit_index (settype, VALUE_CONTENTS (set),
+    error (_("First argument of 'IN' has wrong type"));
+  member = value_bit_index (settype, value_contents (set),

                            value_as_long (element));
   if (member < 0)
                            value_as_long (element));
   if (member < 0)

-    error ("First argument of 'IN' not in range");
-  return value_from_longest (LA_BOOL_TYPE, member);
+    error (_("First argument of 'IN' not in range"));
+  return member;

 }
 
 void
 }
 
 void

-_initialize_valarith ()
+_initialize_valarith (void)

 {
 }
 {
 }