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

/* Perform arithmetic and other operations on values, for GDB.
   Copyright (C) 1986, 1989 Free Software Foundation, Inc.

This file is part of GDB.

GDB 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 1, or (at your option)
any later version.

GDB is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GDB; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include "defs.h"
#include "param.h"
#include "symtab.h"
#include "value.h"
#include "expression.h"

\f
value value_x_binop ();
value value_subscripted_rvalue ();

value
value_add (arg1, arg2)
	value arg1, arg2;
{
  register value val, valint, valptr;
  register int len;

  COERCE_ARRAY (arg1);
  COERCE_ARRAY (arg2);

  if ((TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
       || TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_PTR)
      &&
      (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_INT
       || TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT))
    /* Exactly one argument is a pointer, and one is an integer.  */
    {
      if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
	{
	  valptr = arg1;
	  valint = arg2;
	}
      else
	{
	  valptr = arg2;
	  valint = arg1;
	}
      len = TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (valptr)));
      if (len == 0) len = 1;	/* For (void *) */
      val = value_from_long (builtin_type_long,
			     value_as_long (valptr)
			     + (len * value_as_long (valint)));
      VALUE_TYPE (val) = VALUE_TYPE (valptr);
      return val;
    }

  return value_binop (arg1, arg2, BINOP_ADD);
}

value
value_sub (arg1, arg2)
	value arg1, arg2;
{
  register value val;

  COERCE_ARRAY (arg1);
  COERCE_ARRAY (arg2);

  if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
      && 
      TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT)
    {
      val = value_from_long (builtin_type_long,
			     value_as_long (arg1)
			     - TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) * value_as_long (arg2));
      VALUE_TYPE (val) = VALUE_TYPE (arg1);
      return val;
    }

  if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
      && 
      VALUE_TYPE (arg1) == VALUE_TYPE (arg2))
    {
      val = value_from_long (builtin_type_long,
			     (value_as_long (arg1) - value_as_long (arg2))
			     / TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))));
      return val;
    }

  return value_binop (arg1, arg2, BINOP_SUB);
}

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

value
value_subscript (array, idx)
     value array, idx;
{
  if (TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_ARRAY
      && VALUE_LVAL (array) != lval_memory)
    return value_subscripted_rvalue (array, idx);
  else
    return value_ind (value_add (array, idx));
}

/* Return the value of EXPR[IDX], expr an aggregate rvalue
   (eg, a vector register) */

value
value_subscripted_rvalue (array, idx)
     value array, idx;
{
  struct type *elt_type = TYPE_TARGET_TYPE (VALUE_TYPE (array));
  int elt_size = TYPE_LENGTH (elt_type);
  int elt_offs = elt_size * value_as_long (idx);
  value v;

  if (elt_offs >= TYPE_LENGTH (VALUE_TYPE (array)))
    error ("no such vector element");

  if (TYPE_CODE (elt_type) == TYPE_CODE_FLT) 
    {
      if (elt_size == sizeof (float))
	v = value_from_double (elt_type, (double) *(float *)
			       (VALUE_CONTENTS (array) + elt_offs));
      else
	v = value_from_double (elt_type, *(double *)
			       (VALUE_CONTENTS (array) + elt_offs));
    }
  else
    {
      int offs;
      union {int i; char c;} test;
      test.i = 1;
      if (test.c == 1)
	offs = 0;
      else
	offs = sizeof (LONGEST) - elt_size;
      v = value_from_long (elt_type, *(LONGEST *)
			   (VALUE_CONTENTS (array) + elt_offs - offs));
    }

  if (VALUE_LVAL (array) == lval_internalvar)
    VALUE_LVAL (v) = lval_internalvar_component;
  else
    VALUE_LVAL (v) = not_lval;
  VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
  VALUE_OFFSET (v) = VALUE_OFFSET (array) + elt_offs;
  VALUE_BITSIZE (v) = elt_size * 8;
  return v;
}
\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.

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

int
binop_user_defined_p (op, arg1, arg2)
     enum exp_opcode op;
     value arg1, arg2;
{
  if (op == BINOP_ASSIGN)
    return 0;
  return (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_STRUCT
	  || TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_STRUCT
	  || (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_REF
	      && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_STRUCT)
	  || (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_REF
	      && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2))) == TYPE_CODE_STRUCT));
}

/* Check to see if argument is a structure.  This is called so
   we know whether to go ahead with the normal unop or look for a 
   user defined function instead.

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

int unop_user_defined_p (op, arg1)
     enum exp_opcode op;
     value arg1;
{
  if (op == UNOP_ADDR)
    return 0;
  return (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_STRUCT
	  || (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_REF
	      && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_STRUCT));
}

/* 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
   binary operator which is legal for GNU C++).  */

value
value_x_binop (arg1, arg2, op, otherop)
     value arg1, arg2;
     int op, otherop;
{
  value * argvec;
  char *ptr;
  char tstr[13];
  int static_memfuncp;

  COERCE_ENUM (arg1);
  COERCE_ENUM (arg2);

  /* 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 (VALUE_TYPE (arg1)) != TYPE_CODE_STRUCT)
    error ("friend functions not implemented yet");

  argvec = (value *) alloca (sizeof (value) * 4);
  argvec[1] = value_addr (arg1);
  argvec[2] = arg2;
  argvec[3] = 0;

  /* make the right function name up */  
  strcpy(tstr, "operator __");
  ptr = tstr+9;
  switch (op)
    {
    case BINOP_ADD:	strcpy(ptr,"+"); break;
    case BINOP_SUB:	strcpy(ptr,"-"); break;
    case BINOP_MUL:	strcpy(ptr,"*"); break;
    case BINOP_DIV:	strcpy(ptr,"/"); break;
    case BINOP_REM:	strcpy(ptr,"%"); break;
    case BINOP_LSH:	strcpy(ptr,"<<"); break;
    case BINOP_RSH:	strcpy(ptr,">>"); break;
    case BINOP_LOGAND:	strcpy(ptr,"&"); break;
    case BINOP_LOGIOR:	strcpy(ptr,"|"); break;
    case BINOP_LOGXOR:	strcpy(ptr,"^"); break;
    case BINOP_AND:	strcpy(ptr,"&&"); break;
    case BINOP_OR:	strcpy(ptr,"||"); break;
    case BINOP_MIN:	strcpy(ptr,"<?"); break;
    case BINOP_MAX:	strcpy(ptr,">?"); break;
    case BINOP_ASSIGN:	strcpy(ptr,"="); break;
    case BINOP_ASSIGN_MODIFY:	
      switch (otherop)
	{
	case BINOP_ADD:      strcpy(ptr,"+="); break;
	case BINOP_SUB:      strcpy(ptr,"-="); break;
	case BINOP_MUL:      strcpy(ptr,"*="); break;
	case BINOP_DIV:      strcpy(ptr,"/="); break;
	case BINOP_REM:      strcpy(ptr,"%="); break;
	case BINOP_LOGAND:   strcpy(ptr,"&="); break;
	case BINOP_LOGIOR:   strcpy(ptr,"|="); break;
	case BINOP_LOGXOR:   strcpy(ptr,"^="); break;
	default:
	  error ("Invalid binary operation specified.");
	}
      break;
    case BINOP_SUBSCRIPT: strcpy(ptr,"[]"); break;
    case BINOP_EQUAL:	  strcpy(ptr,"=="); break;
    case BINOP_NOTEQUAL:  strcpy(ptr,"!="); break;
    case BINOP_LESS:      strcpy(ptr,"<"); break;
    case BINOP_GTR:       strcpy(ptr,">"); break;
    case BINOP_GEQ:       strcpy(ptr,">="); break;
    case BINOP_LEQ:       strcpy(ptr,"<="); break;
    default:
      error ("Invalid binary operation specified.");
    }
  argvec[0] = value_struct_elt (arg1, argvec+1, tstr, &static_memfuncp, "structure");
  if (argvec[0])
    {
      if (static_memfuncp)
	{
	  argvec[1] = argvec[0];
	  argvec++;
	}
      return call_function (argvec[0], 2 - static_memfuncp, argvec + 1);
    }
  error ("member function %s not found", tstr);
}

/* We know that arg1 is a structure, so try to find a unary user
   defined operator that matches the operator in question.  
   Create an argument vector that calls arg1.operator @ (arg1)
   and return that value (where '@' is (almost) any unary operator which
   is legal for GNU C++).  */

value
value_x_unop (arg1, op)
     value arg1;
     int op;
{
  value * argvec;
  char *ptr;
  char tstr[13];
  int static_memfuncp;

  COERCE_ENUM (arg1);

  /* 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 (VALUE_TYPE (arg1)) != TYPE_CODE_STRUCT)
    error ("friend functions not implemented yet");

  argvec = (value *) alloca (sizeof (value) * 3);
  argvec[1] = value_addr (arg1);
  argvec[2] = 0;

  /* make the right function name up */  
  strcpy(tstr,"operator __");
  ptr = tstr+9;
  switch (op)
    {
    case UNOP_PREINCREMENT:	strcpy(ptr,"++"); break;
    case UNOP_PREDECREMENT:	strcpy(ptr,"++"); break;
    case UNOP_POSTINCREMENT:	strcpy(ptr,"++"); break;
    case UNOP_POSTDECREMENT:	strcpy(ptr,"++"); break;
    case UNOP_ZEROP:	strcpy(ptr,"!"); break;
    case UNOP_LOGNOT:	strcpy(ptr,"~"); break;
    case UNOP_NEG:	strcpy(ptr,"-"); break;
    default:
      error ("Invalid binary operation specified.");
    }
  argvec[0] = value_struct_elt (arg1, argvec+1, tstr, static_memfuncp, "structure");
  if (argvec[0])
    {
      if (static_memfuncp)
	{
	  argvec[1] = argvec[0];
	  argvec++;
	}
      return call_function (argvec[0], 1 - static_memfuncp, argvec + 1);
    }
  error ("member function %s not found", tstr);
}
\f
/* Perform a binary operation on two integers or two floats.
   Does not support addition and subtraction on pointers;
   use value_add or value_sub if you want to handle those possibilities.  */

value
value_binop (arg1, arg2, op)
     value arg1, arg2;
     int op;
{
  register value val;

  COERCE_ENUM (arg1);
  COERCE_ENUM (arg2);

  if ((TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_FLT
       &&
       TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT)
      ||
      (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_FLT
       &&
       TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_INT))
    error ("Argument to arithmetic operation not a number.");

  if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_FLT
      ||
      TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_FLT)
    {
      double v1, v2, v;
      v1 = value_as_double (arg1);
      v2 = value_as_double (arg2);
      switch (op)
	{
	case BINOP_ADD:
	  v = v1 + v2;
	  break;

	case BINOP_SUB:
	  v = v1 - v2;
	  break;

	case BINOP_MUL:
	  v = v1 * v2;
	  break;

	case BINOP_DIV:
	  v = v1 / v2;
	  break;

	default:
	  error ("Integer-only operation on floating point number.");
	}

      val = allocate_value (builtin_type_double);
      *(double *) VALUE_CONTENTS (val) = v;
    }
  else
    /* Integral operations here.  */
    {
      /* Should we promote to unsigned longest?  */
      if ((TYPE_UNSIGNED (VALUE_TYPE (arg1))
	   || TYPE_UNSIGNED (VALUE_TYPE (arg2)))
	  && (TYPE_LENGTH (VALUE_TYPE (arg1)) >= sizeof (unsigned LONGEST)
	      || TYPE_LENGTH (VALUE_TYPE (arg1)) >= sizeof (unsigned LONGEST)))
	{
	  unsigned LONGEST v1, v2, v;
	  v1 = (unsigned LONGEST) value_as_long (arg1);
	  v2 = (unsigned LONGEST) value_as_long (arg2);
	  
	  switch (op)
	    {
	    case BINOP_ADD:
	      v = v1 + v2;
	      break;
	      
	    case BINOP_SUB:
	      v = v1 - v2;
	      break;
	      
	    case BINOP_MUL:
	      v = v1 * v2;
	      break;
	      
	    case BINOP_DIV:
	      v = v1 / v2;
	      break;
	      
	    case BINOP_REM:
	      v = v1 % v2;
	      break;
	      
	    case BINOP_LSH:
	      v = v1 << v2;
	      break;
	      
	    case BINOP_RSH:
	      v = v1 >> v2;
	      break;
	      
	    case BINOP_LOGAND:
	      v = v1 & v2;
	      break;
	      
	    case BINOP_LOGIOR:
	      v = v1 | v2;
	      break;
	      
	    case BINOP_LOGXOR:
	      v = v1 ^ v2;
	      break;
	      
	    case BINOP_AND:
	      v = v1 && v2;
	      break;
	      
	    case BINOP_OR:
	      v = v1 || v2;
	      break;
	      
	    case BINOP_MIN:
	      v = v1 < v2 ? v1 : v2;
	      break;
	      
	    case BINOP_MAX:
	      v = v1 > v2 ? v1 : v2;
	      break;
	      
	    default:
	      error ("Invalid binary operation on numbers.");
	    }

	  val = allocate_value (BUILTIN_TYPE_UNSIGNED_LONGEST);
	  *(unsigned LONGEST *) VALUE_CONTENTS (val) = v;
	}
      else
	{
	  LONGEST v1, v2, v;
	  v1 = value_as_long (arg1);
	  v2 = value_as_long (arg2);
	  
	  switch (op)
	    {
	    case BINOP_ADD:
	      v = v1 + v2;
	      break;
	      
	    case BINOP_SUB:
	      v = v1 - v2;
	      break;
	      
	    case BINOP_MUL:
	      v = v1 * v2;
	      break;
	      
	    case BINOP_DIV:
	      v = v1 / v2;
	      break;
	      
	    case BINOP_REM:
	      v = v1 % v2;
	      break;
	      
	    case BINOP_LSH:
	      v = v1 << v2;
	      break;
	      
	    case BINOP_RSH:
	      v = v1 >> v2;
	      break;
	      
	    case BINOP_LOGAND:
	      v = v1 & v2;
	      break;
	      
	    case BINOP_LOGIOR:
	      v = v1 | v2;
	      break;
	      
	    case BINOP_LOGXOR:
	      v = v1 ^ v2;
	      break;
	      
	    case BINOP_AND:
	      v = v1 && v2;
	      break;
	      
	    case BINOP_OR:
	      v = v1 || v2;
	      break;
	      
	    case BINOP_MIN:
	      v = v1 < v2 ? v1 : v2;
	      break;
	      
	    case BINOP_MAX:
	      v = v1 > v2 ? v1 : v2;
	      break;
	      
	    default:
	      error ("Invalid binary operation on numbers.");
	    }
	  
	  val = allocate_value (BUILTIN_TYPE_LONGEST);
	  *(LONGEST *) VALUE_CONTENTS (val) = v;
	}
    }

  return val;
}
\f
/* Simulate the C operator ! -- return 1 if ARG1 contains zeros.  */

int
value_zerop (arg1)
     value arg1;
{
  register int len;
  register char *p;

  COERCE_ARRAY (arg1);

  len = TYPE_LENGTH (VALUE_TYPE (arg1));
  p = VALUE_CONTENTS (arg1);

  while (--len >= 0)
    {
      if (*p++)
	break;
    }

  return len < 0;
}

/* Simulate the C operator == by returning a 1
   iff ARG1 and ARG2 have equal contents.  */

int
value_equal (arg1, arg2)
     register value arg1, arg2;

{
  register int len;
  register char *p1, *p2;
  enum type_code code1;
  enum type_code code2;

  COERCE_ARRAY (arg1);
  COERCE_ARRAY (arg2);

  code1 = TYPE_CODE (VALUE_TYPE (arg1));
  code2 = TYPE_CODE (VALUE_TYPE (arg2));

  if (code1 == TYPE_CODE_INT && code2 == TYPE_CODE_INT)
    return value_as_long (arg1) == value_as_long (arg2);
  else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT)
	   && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT))
    return value_as_double (arg1) == value_as_double (arg2);
  else if ((code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_INT)
	   || (code2 == TYPE_CODE_PTR && code1 == TYPE_CODE_INT))
    return (char *) value_as_long (arg1) == (char *) value_as_long (arg2);
  else if (code1 == code2
	   && ((len = TYPE_LENGTH (VALUE_TYPE (arg1)))
	       == TYPE_LENGTH (VALUE_TYPE (arg2))))
    {
      p1 = VALUE_CONTENTS (arg1);
      p2 = VALUE_CONTENTS (arg2);
      while (--len >= 0)
	{
	  if (*p1++ != *p2++)
	    break;
	}
      return len < 0;
    }
  else
    error ("Invalid type combination in equality test.");
}

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

int
value_less (arg1, arg2)
     register value arg1, arg2;
{
  register enum type_code code1;
  register enum type_code code2;

  COERCE_ARRAY (arg1);
  COERCE_ARRAY (arg2);

  code1 = TYPE_CODE (VALUE_TYPE (arg1));
  code2 = TYPE_CODE (VALUE_TYPE (arg2));

  if (code1 == TYPE_CODE_INT && code2 == TYPE_CODE_INT)
    return value_as_long (arg1) < value_as_long (arg2);
  else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT)
	   && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT))
    return value_as_double (arg1) < value_as_double (arg2);
  else if ((code1 == TYPE_CODE_PTR || code1 == TYPE_CODE_INT)
	   && (code2 == TYPE_CODE_PTR || code2 == TYPE_CODE_INT))
    return (char *) value_as_long (arg1) < (char *) value_as_long (arg2);
  else
    error ("Invalid type combination in ordering comparison.");
}
\f
/* The unary operators - and ~.  Both free the argument ARG1.  */

value
value_neg (arg1)
     register value arg1;
{
  register struct type *type;

  COERCE_ENUM (arg1);

  type = VALUE_TYPE (arg1);

  if (TYPE_CODE (type) == TYPE_CODE_FLT)
    return value_from_double (type, - value_as_double (arg1));
  else if (TYPE_CODE (type) == TYPE_CODE_INT)
    return value_from_long (type, - value_as_long (arg1));
  else
    error ("Argument to negate operation not a number.");
}

value
value_lognot (arg1)
     register value arg1;
{
  COERCE_ENUM (arg1);

  if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT)
    error ("Argument to complement operation not an integer.");

  return value_from_long (VALUE_TYPE (arg1), ~ value_as_long (arg1));
}
\f
Commit	Line	Data
7b4ac7e1	1	/* Perform arithmetic and other operations on values, for GDB.
4187119d	2	Copyright (C) 1986, 1989 Free Software Foundation, Inc.
7b4ac7e1	3
4187119d	4	This file is part of GDB.
7b4ac7e1	5
4187119d	6	GDB is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 1, or (at your option)
	9	any later version.
7b4ac7e1	10
4187119d	11	GDB is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GDB; see the file COPYING. If not, write to
	18	the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
7b4ac7e1	19
7b4ac7e1	20	#include "defs.h"
7b4ac7e1	21	#include "param.h"
	22	#include "symtab.h"
	23	#include "value.h"
	24	#include "expression.h"
	25
7b4ac7e1	26	\f
bb7592f0	27	value value_x_binop ();
4187119d	28	value value_subscripted_rvalue ();
bb7592f0	29
7b4ac7e1	30	value
	31	value_add (arg1, arg2)
	32	value arg1, arg2;
	33	{
	34	register value val, valint, valptr;
	35	register int len;
	36
	37	COERCE_ARRAY (arg1);
	38	COERCE_ARRAY (arg2);
	39
	40	if ((TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
	41	\|\| TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_PTR)
	42	&&
	43	(TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_INT
	44	\|\| TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT))
	45	/* Exactly one argument is a pointer, and one is an integer. */
	46	{
	47	if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
	48	{
	49	valptr = arg1;
	50	valint = arg2;
	51	}
	52	else
	53	{
	54	valptr = arg2;
	55	valint = arg1;
	56	}
	57	len = TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (valptr)));
	58	if (len == 0) len = 1; /* For (void ) /
	59	val = value_from_long (builtin_type_long,
	60	value_as_long (valptr)
	61	+ (len * value_as_long (valint)));
	62	VALUE_TYPE (val) = VALUE_TYPE (valptr);
	63	return val;
	64	}
	65
7c75bab3	66	return value_binop (arg1, arg2, BINOP_ADD);
7b4ac7e1	67	}
	68
	69	value
	70	value_sub (arg1, arg2)
	71	value arg1, arg2;
	72	{
	73	register value val;
	74
	75	COERCE_ARRAY (arg1);
	76	COERCE_ARRAY (arg2);
	77
	78	if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
	79	&&
	80	TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT)
	81	{
	82	val = value_from_long (builtin_type_long,
	83	value_as_long (arg1)
	84	- TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) * value_as_long (arg2));
	85	VALUE_TYPE (val) = VALUE_TYPE (arg1);
	86	return val;
	87	}
	88
	89	if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
	90	&&
	91	VALUE_TYPE (arg1) == VALUE_TYPE (arg2))
	92	{
	93	val = value_from_long (builtin_type_long,
	94	(value_as_long (arg1) - value_as_long (arg2))
	95	/ TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))));
	96	return val;
	97	}
	98
7c75bab3	99	return value_binop (arg1, arg2, BINOP_SUB);
7b4ac7e1	100	}
	101
	102	/* Return the value of ARRAY[IDX]. */
	103
	104	value
	105	value_subscript (array, idx)
	106	value array, idx;
	107	{
4187119d	108	if (TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_ARRAY
	109	&& VALUE_LVAL (array) != lval_memory)
	110	return value_subscripted_rvalue (array, idx);
	111	else
	112	return value_ind (value_add (array, idx));
	113	}
	114
	115	/* Return the value of EXPR[IDX], expr an aggregate rvalue
	116	(eg, a vector register) */
	117
	118	value
	119	value_subscripted_rvalue (array, idx)
	120	value array, idx;
	121	{
	122	struct type *elt_type = TYPE_TARGET_TYPE (VALUE_TYPE (array));
	123	int elt_size = TYPE_LENGTH (elt_type);
	124	int elt_offs = elt_size * value_as_long (idx);
	125	value v;
	126
	127	if (elt_offs >= TYPE_LENGTH (VALUE_TYPE (array)))
	128	error ("no such vector element");
	129
	130	if (TYPE_CODE (elt_type) == TYPE_CODE_FLT)
	131	{
	132	if (elt_size == sizeof (float))
	133	v = value_from_double (elt_type, (double) (float )
	134	(VALUE_CONTENTS (array) + elt_offs));
	135	else
	136	v = value_from_double (elt_type, (double )
	137	(VALUE_CONTENTS (array) + elt_offs));
	138	}
	139	else
	140	{
	141	int offs;
	142	union {int i; char c;} test;
	143	test.i = 1;
	144	if (test.c == 1)
	145	offs = 0;
	146	else
	147	offs = sizeof (LONGEST) - elt_size;
	148	v = value_from_long (elt_type, (LONGEST )
	149	(VALUE_CONTENTS (array) + elt_offs - offs));
	150	}
	151
	152	if (VALUE_LVAL (array) == lval_internalvar)
	153	VALUE_LVAL (v) = lval_internalvar_component;
	154	else
	155	VALUE_LVAL (v) = not_lval;
	156	VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
	157	VALUE_OFFSET (v) = VALUE_OFFSET (array) + elt_offs;
	158	VALUE_BITSIZE (v) = elt_size * 8;
	159	return v;
7b4ac7e1	160	}
bb7592f0	161	\f
	162	/* Check to see if either argument is a structure. This is called so
	163	we know whether to go ahead with the normal binop or look for a
	164	user defined function instead.
7c75bab3	165
bb7592f0	166	For now, we do not overload the `=' operator. */
	167
	168	int
	169	binop_user_defined_p (op, arg1, arg2)
	170	enum exp_opcode op;
	171	value arg1, arg2;
	172	{
	173	if (op == BINOP_ASSIGN)
	174	return 0;
	175	return (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_STRUCT
	176	\|\| TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_STRUCT
	177	\|\| (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_REF
	178	&& TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_STRUCT)
	179	\|\| (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_REF
	180	&& TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2))) == TYPE_CODE_STRUCT));
	181	}
	182
	183	/* Check to see if argument is a structure. This is called so
	184	we know whether to go ahead with the normal unop or look for a
	185	user defined function instead.
	186
	187	For now, we do not overload the `&' operator. */
	188
	189	int unop_user_defined_p (op, arg1)
	190	enum exp_opcode op;
	191	value arg1;
	192	{
	193	if (op == UNOP_ADDR)
	194	return 0;
	195	return (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_STRUCT
	196	\|\| (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_REF
	197	&& TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_STRUCT));
	198	}
	199
	200	/* We know either arg1 or arg2 is a structure, so try to find the right
	201	user defined function. Create an argument vector that calls
	202	arg1.operator @ (arg1,arg2) and return that value (where '@' is any
	203	binary operator which is legal for GNU C++). */
	204
	205	value
	206	value_x_binop (arg1, arg2, op, otherop)
	207	value arg1, arg2;
	208	int op, otherop;
	209	{
	210	value * argvec;
	211	char *ptr;
	212	char tstr[13];
4187119d	213	int static_memfuncp;
4187119d	214
bb7592f0	215	COERCE_ENUM (arg1);
	216	COERCE_ENUM (arg2);
	217
	218	/* now we know that what we have to do is construct our
	219	arg vector and find the right function to call it with. */
	220
	221	if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_STRUCT)
	222	error ("friend functions not implemented yet");
	223
	224	argvec = (value ) alloca (sizeof (value) 4);
	225	argvec[1] = value_addr (arg1);
	226	argvec[2] = arg2;
	227	argvec[3] = 0;
	228
	229	/* make the right function name up */
	230	strcpy(tstr, "operator __");
	231	ptr = tstr+9;
	232	switch (op)
	233	{
	234	case BINOP_ADD: strcpy(ptr,"+"); break;
	235	case BINOP_SUB: strcpy(ptr,"-"); break;
	236	case BINOP_MUL: strcpy(ptr,"*"); break;
	237	case BINOP_DIV: strcpy(ptr,"/"); break;
	238	case BINOP_REM: strcpy(ptr,"%"); break;
	239	case BINOP_LSH: strcpy(ptr,"<<"); break;
	240	case BINOP_RSH: strcpy(ptr,">>"); break;
	241	case BINOP_LOGAND: strcpy(ptr,"&"); break;
	242	case BINOP_LOGIOR: strcpy(ptr,"\|"); break;
	243	case BINOP_LOGXOR: strcpy(ptr,"^"); break;
	244	case BINOP_AND: strcpy(ptr,"&&"); break;
	245	case BINOP_OR: strcpy(ptr,"\|\|"); break;
	246	case BINOP_MIN: strcpy(ptr,"<?"); break;
	247	case BINOP_MAX: strcpy(ptr,">?"); break;
	248	case BINOP_ASSIGN: strcpy(ptr,"="); break;
	249	case BINOP_ASSIGN_MODIFY:
	250	switch (otherop)
	251	{
	252	case BINOP_ADD: strcpy(ptr,"+="); break;
	253	case BINOP_SUB: strcpy(ptr,"-="); break;
	254	case BINOP_MUL: strcpy(ptr,"*="); break;
	255	case BINOP_DIV: strcpy(ptr,"/="); break;
	256	case BINOP_REM: strcpy(ptr,"%="); break;
	257	case BINOP_LOGAND: strcpy(ptr,"&="); break;
	258	case BINOP_LOGIOR: strcpy(ptr,"\|="); break;
	259	case BINOP_LOGXOR: strcpy(ptr,"^="); break;
	260	default:
	261	error ("Invalid binary operation specified.");
	262	}
	263	break;
	264	case BINOP_SUBSCRIPT: strcpy(ptr,"[]"); break;
	265	case BINOP_EQUAL: strcpy(ptr,"=="); break;
	266	case BINOP_NOTEQUAL: strcpy(ptr,"!="); break;
	267	case BINOP_LESS: strcpy(ptr,"<"); break;
	268	case BINOP_GTR: strcpy(ptr,">"); break;
	269	case BINOP_GEQ: strcpy(ptr,">="); break;
	270	case BINOP_LEQ: strcpy(ptr,"<="); break;
	271	default:
	272	error ("Invalid binary operation specified.");
	273	}
4187119d	274	argvec[0] = value_struct_elt (arg1, argvec+1, tstr, &static_memfuncp, "structure");
bb7592f0	275	if (argvec[0])
4187119d	276	{
	277	if (static_memfuncp)
	278	{
	279	argvec[1] = argvec[0];
	280	argvec++;
	281	}
	282	return call_function (argvec[0], 2 - static_memfuncp, argvec + 1);
	283	}
	284	error ("member function %s not found", tstr);
bb7592f0	285	}
	286
	287	/* We know that arg1 is a structure, so try to find a unary user
	288	defined operator that matches the operator in question.
	289	Create an argument vector that calls arg1.operator @ (arg1)
	290	and return that value (where '@' is (almost) any unary operator which
	291	is legal for GNU C++). */
	292
	293	value
	294	value_x_unop (arg1, op)
	295	value arg1;
	296	int op;
	297	{
	298	value * argvec;
	299	char *ptr;
	300	char tstr[13];
4187119d	301	int static_memfuncp;
4187119d	302
bb7592f0	303	COERCE_ENUM (arg1);
	304
	305	/* now we know that what we have to do is construct our
	306	arg vector and find the right function to call it with. */
	307
	308	if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_STRUCT)
	309	error ("friend functions not implemented yet");
	310
	311	argvec = (value ) alloca (sizeof (value) 3);
	312	argvec[1] = value_addr (arg1);
	313	argvec[2] = 0;
	314
	315	/* make the right function name up */
	316	strcpy(tstr,"operator __");
	317	ptr = tstr+9;
	318	switch (op)
	319	{
	320	case UNOP_PREINCREMENT: strcpy(ptr,"++"); break;
	321	case UNOP_PREDECREMENT: strcpy(ptr,"++"); break;
	322	case UNOP_POSTINCREMENT: strcpy(ptr,"++"); break;
	323	case UNOP_POSTDECREMENT: strcpy(ptr,"++"); break;
	324	case UNOP_ZEROP: strcpy(ptr,"!"); break;
	325	case UNOP_LOGNOT: strcpy(ptr,"~"); break;
	326	case UNOP_NEG: strcpy(ptr,"-"); break;
	327	default:
	328	error ("Invalid binary operation specified.");
	329	}
4187119d	330	argvec[0] = value_struct_elt (arg1, argvec+1, tstr, static_memfuncp, "structure");
bb7592f0	331	if (argvec[0])
4187119d	332	{
	333	if (static_memfuncp)
	334	{
	335	argvec[1] = argvec[0];
	336	argvec++;
	337	}
	338	return call_function (argvec[0], 1 - static_memfuncp, argvec + 1);
	339	}
	340	error ("member function %s not found", tstr);
bb7592f0	341	}
bb7592f0	342	\f
7b4ac7e1	343	/* Perform a binary operation on two integers or two floats.
	344	Does not support addition and subtraction on pointers;
	345	use value_add or value_sub if you want to handle those possibilities. */
	346
	347	value
	348	value_binop (arg1, arg2, op)
	349	value arg1, arg2;
	350	int op;
	351	{
	352	register value val;
	353
	354	COERCE_ENUM (arg1);
	355	COERCE_ENUM (arg2);
	356
	357	if ((TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_FLT
	358	&&
	359	TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT)
	360	\|\|
	361	(TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_FLT
	362	&&
	363	TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_INT))
	364	error ("Argument to arithmetic operation not a number.");
	365
	366	if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_FLT
	367	\|\|
	368	TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_FLT)
	369	{
	370	double v1, v2, v;
	371	v1 = value_as_double (arg1);
	372	v2 = value_as_double (arg2);
	373	switch (op)
	374	{
	375	case BINOP_ADD:
	376	v = v1 + v2;
	377	break;
	378
	379	case BINOP_SUB:
	380	v = v1 - v2;
	381	break;
	382
	383	case BINOP_MUL:
	384	v = v1 * v2;
	385	break;
	386
	387	case BINOP_DIV:
	388	v = v1 / v2;
	389	break;
	390
	391	default:
	392	error ("Integer-only operation on floating point number.");
	393	}
	394
	395	val = allocate_value (builtin_type_double);
	396	(double ) VALUE_CONTENTS (val) = v;
	397	}
	398	else
4187119d	399	/* Integral operations here. */
7b4ac7e1	400	{
4187119d	401	/* Should we promote to unsigned longest? */
	402	if ((TYPE_UNSIGNED (VALUE_TYPE (arg1))
	403	\|\| TYPE_UNSIGNED (VALUE_TYPE (arg2)))
	404	&& (TYPE_LENGTH (VALUE_TYPE (arg1)) >= sizeof (unsigned LONGEST)
	405	\|\| TYPE_LENGTH (VALUE_TYPE (arg1)) >= sizeof (unsigned LONGEST)))
7b4ac7e1	406	{
4187119d	407	unsigned LONGEST v1, v2, v;
	408	v1 = (unsigned LONGEST) value_as_long (arg1);
	409	v2 = (unsigned LONGEST) value_as_long (arg2);
	410
	411	switch (op)
	412	{
	413	case BINOP_ADD:
	414	v = v1 + v2;
	415	break;
	416
	417	case BINOP_SUB:
	418	v = v1 - v2;
	419	break;
	420
	421	case BINOP_MUL:
	422	v = v1 * v2;
	423	break;
	424
	425	case BINOP_DIV:
	426	v = v1 / v2;
	427	break;
	428
	429	case BINOP_REM:
	430	v = v1 % v2;
	431	break;
	432
	433	case BINOP_LSH:
	434	v = v1 << v2;
	435	break;
	436
	437	case BINOP_RSH:
	438	v = v1 >> v2;
	439	break;
	440
	441	case BINOP_LOGAND:
	442	v = v1 & v2;
	443	break;
	444
	445	case BINOP_LOGIOR:
	446	v = v1 \| v2;
	447	break;
	448
	449	case BINOP_LOGXOR:
	450	v = v1 ^ v2;
	451	break;
	452
	453	case BINOP_AND:
	454	v = v1 && v2;
	455	break;
	456
	457	case BINOP_OR:
	458	v = v1 \|\| v2;
	459	break;
	460
	461	case BINOP_MIN:
	462	v = v1 < v2 ? v1 : v2;
	463	break;
	464
	465	case BINOP_MAX:
	466	v = v1 > v2 ? v1 : v2;
	467	break;
	468
	469	default:
	470	error ("Invalid binary operation on numbers.");
471	}
472
473	val = allocate_value (BUILTIN_TYPE_UNSIGNED_LONGEST);
474	(unsigned LONGEST ) VALUE_CONTENTS (val) = v;
475	}
476	else
477	{
478	LONGEST v1, v2, v;
479	v1 = value_as_long (arg1);
480	v2 = value_as_long (arg2);
481
482	switch (op)
483	{
484	case BINOP_ADD:
485	v = v1 + v2;
486	break;
487
488	case BINOP_SUB:
489	v = v1 - v2;
490	break;
491
492	case BINOP_MUL:
493	v = v1 * v2;
494	break;
495
496	case BINOP_DIV:
497	v = v1 / v2;
498	break;
499
500	case BINOP_REM:
501	v = v1 % v2;
502	break;
503
504	case BINOP_LSH:
505	v = v1 << v2;
506	break;
507
508	case BINOP_RSH:
509	v = v1 >> v2;
510	break;
511
512	case BINOP_LOGAND:
513	v = v1 & v2;
514	break;
515
516	case BINOP_LOGIOR:
517	v = v1 \| v2;
518	break;
519
520	case BINOP_LOGXOR:
521	v = v1 ^ v2;
522	break;
523
524	case BINOP_AND:
525	v = v1 && v2;
526	break;
527
528	case BINOP_OR:
529	v = v1 \|\| v2;
530	break;
531
532	case BINOP_MIN:
533	v = v1 < v2 ? v1 : v2;
534	break;
535
536	case BINOP_MAX:
537	v = v1 > v2 ? v1 : v2;
538	break;
539
540	default:
541	error ("Invalid binary operation on numbers.");
542	}
543
544	val = allocate_value (BUILTIN_TYPE_LONGEST);
545	(LONGEST ) VALUE_CONTENTS (val) = v;
7b4ac7e1	546	}
7b4ac7e1	547	}
	548
	549	return val;
	550	}
	551	\f
	552	/* Simulate the C operator ! -- return 1 if ARG1 contains zeros. */
	553
	554	int
	555	value_zerop (arg1)
	556	value arg1;
	557	{
	558	register int len;
	559	register char *p;
	560
	561	COERCE_ARRAY (arg1);
	562
	563	len = TYPE_LENGTH (VALUE_TYPE (arg1));
	564	p = VALUE_CONTENTS (arg1);
	565
	566	while (--len >= 0)
	567	{
	568	if (*p++)
	569	break;
	570	}
	571
	572	return len < 0;
	573	}
	574
	575	/* Simulate the C operator == by returning a 1
	576	iff ARG1 and ARG2 have equal contents. */
	577
	578	int
	579	value_equal (arg1, arg2)
	580	register value arg1, arg2;
	581
	582	{
	583	register int len;
	584	register char p1, p2;
	585	enum type_code code1;
	586	enum type_code code2;
	587
	588	COERCE_ARRAY (arg1);
	589	COERCE_ARRAY (arg2);
	590
	591	code1 = TYPE_CODE (VALUE_TYPE (arg1));
	592	code2 = TYPE_CODE (VALUE_TYPE (arg2));
	593
	594	if (code1 == TYPE_CODE_INT && code2 == TYPE_CODE_INT)
	595	return value_as_long (arg1) == value_as_long (arg2);
	596	else if ((code1 == TYPE_CODE_FLT \|\| code1 == TYPE_CODE_INT)
	597	&& (code2 == TYPE_CODE_FLT \|\| code2 == TYPE_CODE_INT))
	598	return value_as_double (arg1) == value_as_double (arg2);
	599	else if ((code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_INT)
	600	\|\| (code2 == TYPE_CODE_PTR && code1 == TYPE_CODE_INT))
4187119d	601	return (char ) value_as_long (arg1) == (char ) value_as_long (arg2);
7b4ac7e1	602	else if (code1 == code2
	603	&& ((len = TYPE_LENGTH (VALUE_TYPE (arg1)))
	604	== TYPE_LENGTH (VALUE_TYPE (arg2))))
	605	{
	606	p1 = VALUE_CONTENTS (arg1);
	607	p2 = VALUE_CONTENTS (arg2);
	608	while (--len >= 0)
	609	{
	610	if (p1++ != p2++)
	611	break;
	612	}
	613	return len < 0;
	614	}
	615	else
	616	error ("Invalid type combination in equality test.");
	617	}
	618
	619	/* Simulate the C operator < by returning 1
	620	iff ARG1's contents are less than ARG2's. */
	621
	622	int
	623	value_less (arg1, arg2)
	624	register value arg1, arg2;
	625	{
	626	register enum type_code code1;
	627	register enum type_code code2;
	628
	629	COERCE_ARRAY (arg1);
	630	COERCE_ARRAY (arg2);
	631
	632	code1 = TYPE_CODE (VALUE_TYPE (arg1));
	633	code2 = TYPE_CODE (VALUE_TYPE (arg2));
	634
	635	if (code1 == TYPE_CODE_INT && code2 == TYPE_CODE_INT)
	636	return value_as_long (arg1) < value_as_long (arg2);
	637	else if ((code1 == TYPE_CODE_FLT \|\| code1 == TYPE_CODE_INT)
	638	&& (code2 == TYPE_CODE_FLT \|\| code2 == TYPE_CODE_INT))
	639	return value_as_double (arg1) < value_as_double (arg2);
	640	else if ((code1 == TYPE_CODE_PTR \|\| code1 == TYPE_CODE_INT)
	641	&& (code2 == TYPE_CODE_PTR \|\| code2 == TYPE_CODE_INT))
4187119d	642	return (char ) value_as_long (arg1) < (char ) value_as_long (arg2);
7b4ac7e1	643	else
	644	error ("Invalid type combination in ordering comparison.");
	645	}
	646	\f
	647	/* The unary operators - and ~. Both free the argument ARG1. */
	648
	649	value
	650	value_neg (arg1)
	651	register value arg1;
	652	{
	653	register struct type *type;
	654
	655	COERCE_ENUM (arg1);
	656
	657	type = VALUE_TYPE (arg1);
	658
	659	if (TYPE_CODE (type) == TYPE_CODE_FLT)
	660	return value_from_double (type, - value_as_double (arg1));
	661	else if (TYPE_CODE (type) == TYPE_CODE_INT)
	662	return value_from_long (type, - value_as_long (arg1));
	663	else
	664	error ("Argument to negate operation not a number.");
	665	}
	666
	667	value
	668	value_lognot (arg1)
	669	register value arg1;
	670	{
	671	COERCE_ENUM (arg1);
	672
	673	if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT)
	674	error ("Argument to complement operation not an integer.");
	675
	676	return value_from_long (VALUE_TYPE (arg1), ~ value_as_long (arg1));
	677	}
	678	\f