gdb/valarith.c

   1 /* Perform arithmetic and other operations on values, for GDB.
   2    Copyright 1986, 1989, 1991, 1992, 1993, 1994
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "value.h"
  23 #include "symtab.h"
  24 #include "gdbtypes.h"
  25 #include "expression.h"
  26 #include "target.h"
  27 #include "language.h"
  28 #include "demangle.h"
  29 #include "gdb_string.h"
  30
  31 /* Define whether or not the C operator '/' truncates towards zero for
  32    differently signed operands (truncation direction is undefined in C). */
  33
  34 #ifndef TRUNCATION_TOWARDS_ZERO
  35 #define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
  36 #endif
  37
  38 static value_ptr value_subscripted_rvalue PARAMS ((value_ptr, value_ptr, int));
  39
  40 \f
  41 value_ptr
  42 value_add (arg1, arg2)
  43      value_ptr arg1, arg2;
  44 {
  45   register value_ptr valint, valptr;
  46   register int len;
  47   struct type *type1, *type2, *valptrtype;
  48
  49   COERCE_NUMBER (arg1);
  50   COERCE_NUMBER (arg2);
  51   type1 = check_typedef (VALUE_TYPE (arg1));
  52   type2 = check_typedef (VALUE_TYPE (arg2));
  53
  54   if ((TYPE_CODE (type1) == TYPE_CODE_PTR
  55        || TYPE_CODE (type2) == TYPE_CODE_PTR)
  56       &&
  57       (TYPE_CODE (type1) == TYPE_CODE_INT
  58        || TYPE_CODE (type2) == TYPE_CODE_INT))
  59     /* Exactly one argument is a pointer, and one is an integer.  */
  60     {
  61       if (TYPE_CODE (type1) == TYPE_CODE_PTR)
  62         {
  63           valptr = arg1;
  64           valint = arg2;
  65           valptrtype = type1;
  66         }
  67       else
  68         {
  69           valptr = arg2;
  70           valint = arg1;
  71           valptrtype = type2;
  72         }
  73       len = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (valptrtype)));
  74       if (len == 0) len = 1;    /* For (void *) */
  75       return value_from_longest (valptrtype,
  76                               value_as_long (valptr)
  77                               + (len * value_as_long (valint)));
  78     }
  79
  80   return value_binop (arg1, arg2, BINOP_ADD);
  81 }
  82
  83 value_ptr
  84 value_sub (arg1, arg2)
  85      value_ptr arg1, arg2;
  86 {
  87   struct type *type1, *type2;
  88   COERCE_NUMBER (arg1);
  89   COERCE_NUMBER (arg2);
  90   type1 = check_typedef (VALUE_TYPE (arg1));
  91   type2 = check_typedef (VALUE_TYPE (arg2));
  92
  93   if (TYPE_CODE (type1) == TYPE_CODE_PTR)
  94     {
  95       if (TYPE_CODE (type2) == TYPE_CODE_INT)
  96         {
  97           /* pointer - integer.  */
  98           LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
  99           return value_from_longest
 100             (VALUE_TYPE (arg1),
 101              value_as_long (arg1) - (sz * value_as_long (arg2)));
 102         }
 103       else if (TYPE_CODE (type2) == TYPE_CODE_PTR
 104                && TYPE_LENGTH (TYPE_TARGET_TYPE (type1))
 105                   == TYPE_LENGTH (TYPE_TARGET_TYPE (type2)))
 106         {
 107           /* pointer to <type x> - pointer to <type x>.  */
 108           LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
 109           return value_from_longest
 110             (builtin_type_long,         /* FIXME -- should be ptrdiff_t */
 111              (value_as_long (arg1) - value_as_long (arg2)) / sz);
 112         }
 113       else
 114         {
 115           error ("\
 116 First argument of `-' is a pointer and second argument is neither\n\
 117 an integer nor a pointer of the same type.");
 118         }
 119     }
 120
 121   return value_binop (arg1, arg2, BINOP_SUB);
 122 }
 123
 124 /* Return the value of ARRAY[IDX].
 125    See comments in value_coerce_array() for rationale for reason for
 126    doing lower bounds adjustment here rather than there.
 127    FIXME:  Perhaps we should validate that the index is valid and if
 128    verbosity is set, warn about invalid indices (but still use them). */
 129
 130 value_ptr
 131 value_subscript (array, idx)
 132      value_ptr array, idx;
 133 {
 134   value_ptr bound;
 135   int c_style = current_language->c_style_arrays;
 136   struct type *tarray;
 137
 138   COERCE_REF (array);
 139   tarray = check_typedef (VALUE_TYPE (array));
 140   COERCE_VARYING_ARRAY (array, tarray);
 141
 142   if (TYPE_CODE (tarray) == TYPE_CODE_ARRAY
 143       || TYPE_CODE (tarray) == TYPE_CODE_STRING)
 144     {
 145       struct type *range_type = TYPE_INDEX_TYPE (tarray);
 146       LONGEST lowerbound, upperbound;
 147       get_discrete_bounds (range_type, &lowerbound, &upperbound);
 148
 149       if (VALUE_LVAL (array) != lval_memory)
 150         return value_subscripted_rvalue (array, idx, lowerbound);
 151
 152       if (c_style == 0)
 153         {
 154           LONGEST index = value_as_long (idx);
 155           if (index >= lowerbound && index <= upperbound)
 156             return value_subscripted_rvalue (array, idx, lowerbound);
 157           warning ("array or string index out of range");
 158           /* fall doing C stuff */
 159           c_style = 1;
 160         }
 161
 162       if (lowerbound != 0)
 163         {
 164           bound = value_from_longest (builtin_type_int, (LONGEST) lowerbound);
 165           idx = value_sub (idx, bound);
 166         }
 167
 168       array = value_coerce_array (array);
 169     }
 170
 171   if (TYPE_CODE (tarray) == TYPE_CODE_BITSTRING)
 172     {
 173       struct type *range_type = TYPE_INDEX_TYPE (tarray);
 174       LONGEST index = value_as_long (idx);
 175       value_ptr v;
 176       int offset, byte, bit_index;
 177       LONGEST lowerbound, upperbound;
 178       get_discrete_bounds (range_type, &lowerbound, &upperbound);
 179       if (index < lowerbound || index > upperbound)
 180         error ("bitstring index out of range");
 181       index -= lowerbound;
 182       offset = index / TARGET_CHAR_BIT;
 183       byte = *((char*)VALUE_CONTENTS (array) + offset);
 184       bit_index = index % TARGET_CHAR_BIT;
 185       byte >>= (BITS_BIG_ENDIAN ? TARGET_CHAR_BIT - 1 - bit_index : bit_index);
 186       v = value_from_longest (LA_BOOL_TYPE, byte & 1);
 187       VALUE_BITPOS (v) = bit_index;
 188       VALUE_BITSIZE (v) = 1;
 189       VALUE_LVAL (v) = VALUE_LVAL (array);
 190       if (VALUE_LVAL (array) == lval_internalvar)
 191         VALUE_LVAL (v) = lval_internalvar_component;
 192       VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
 193       VALUE_OFFSET (v) = offset + VALUE_OFFSET (array);
 194       return v;
 195     }
 196
 197   if (c_style)
 198     return value_ind (value_add (array, idx));
 199   else
 200     error ("not an array or string");
 201 }
 202
 203 /* Return the value of EXPR[IDX], expr an aggregate rvalue
 204    (eg, a vector register).  This routine used to promote floats
 205    to doubles, but no longer does.  */
 206
 207 static value_ptr
 208 value_subscripted_rvalue (array, idx, lowerbound)
 209      value_ptr array, idx;
 210      int lowerbound;
 211 {
 212   struct type *array_type = check_typedef (VALUE_TYPE (array));
 213   struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
 214   unsigned int elt_size = TYPE_LENGTH (elt_type);
 215   LONGEST index = value_as_long (idx);
 216   unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
 217   value_ptr v;
 218
 219   if (index < lowerbound || elt_offs >= TYPE_LENGTH (array_type))
 220     error ("no such vector element");
 221
 222   v = allocate_value (elt_type);
 223   if (VALUE_LAZY (array))
 224     VALUE_LAZY (v) = 1;
 225   else
 226     memcpy (VALUE_CONTENTS (v), VALUE_CONTENTS (array) + elt_offs, elt_size);
 227
 228   if (VALUE_LVAL (array) == lval_internalvar)
 229     VALUE_LVAL (v) = lval_internalvar_component;
 230   else
 231     VALUE_LVAL (v) = VALUE_LVAL (array);
 232   VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
 233   VALUE_OFFSET (v) = VALUE_OFFSET (array) + elt_offs;
 234   return v;
 235 }
 236 \f
 237 /* Check to see if either argument is a structure.  This is called so
 238    we know whether to go ahead with the normal binop or look for a
 239    user defined function instead.
 240
 241    For now, we do not overload the `=' operator.  */
 242
 243 int
 244 binop_user_defined_p (op, arg1, arg2)
 245      enum exp_opcode op;
 246      value_ptr arg1, arg2;
 247 {
 248   struct type *type1, *type2;
 249   if (op == BINOP_ASSIGN || op == BINOP_CONCAT)
 250     return 0;
 251   type1 = check_typedef (VALUE_TYPE (arg1));
 252   type2 = check_typedef (VALUE_TYPE (arg2));
 253   return (TYPE_CODE (type1) == TYPE_CODE_STRUCT
 254           || TYPE_CODE (type2) == TYPE_CODE_STRUCT
 255           || (TYPE_CODE (type1) == TYPE_CODE_REF
 256               && TYPE_CODE (TYPE_TARGET_TYPE (type1)) == TYPE_CODE_STRUCT)
 257           || (TYPE_CODE (type2) == TYPE_CODE_REF
 258               && TYPE_CODE (TYPE_TARGET_TYPE (type2)) == TYPE_CODE_STRUCT));
 259 }
 260
 261 /* Check to see if argument is a structure.  This is called so
 262    we know whether to go ahead with the normal unop or look for a
 263    user defined function instead.
 264
 265    For now, we do not overload the `&' operator.  */
 266
 267 int unop_user_defined_p (op, arg1)
 268      enum exp_opcode op;
 269      value_ptr arg1;
 270 {
 271   struct type *type1;
 272   if (op == UNOP_ADDR)
 273     return 0;
 274   type1 = check_typedef (VALUE_TYPE (arg1));
 275   for (;;)
 276     {
 277       if (TYPE_CODE (type1) == TYPE_CODE_STRUCT)
 278         return 1;
 279       else if (TYPE_CODE (type1) == TYPE_CODE_REF)
 280         type1 = TYPE_TARGET_TYPE (type1);
 281       else
 282         return 0;
 283     }
 284 }
 285
 286 /* We know either arg1 or arg2 is a structure, so try to find the right
 287    user defined function.  Create an argument vector that calls
 288    arg1.operator @ (arg1,arg2) and return that value (where '@' is any
 289    binary operator which is legal for GNU C++).
 290
 291    OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
 292    is the opcode saying how to modify it.  Otherwise, OTHEROP is
 293    unused.  */
 294
 295 value_ptr
 296 value_x_binop (arg1, arg2, op, otherop)
 297      value_ptr arg1, arg2;
 298      enum exp_opcode op, otherop;
 299 {
 300   value_ptr * argvec;
 301   char *ptr;
 302   char tstr[13];
 303   int static_memfuncp;
 304
 305   COERCE_REF (arg1);
 306   COERCE_REF (arg2);
 307   COERCE_ENUM (arg1);
 308   COERCE_ENUM (arg2);
 309
 310   /* now we know that what we have to do is construct our
 311      arg vector and find the right function to call it with.  */
 312
 313   if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_STRUCT)
 314     error ("Can't do that binary op on that type");  /* FIXME be explicit */
 315
 316   argvec = (value_ptr *) alloca (sizeof (value_ptr) * 4);
 317   argvec[1] = value_addr (arg1);
 318   argvec[2] = arg2;
 319   argvec[3] = 0;
 320
 321   /* make the right function name up */
 322   strcpy(tstr, "operator__");
 323   ptr = tstr+8;
 324   switch (op)
 325     {
 326     case BINOP_ADD:             strcpy(ptr,"+"); break;
 327     case BINOP_SUB:             strcpy(ptr,"-"); break;
 328     case BINOP_MUL:             strcpy(ptr,"*"); break;
 329     case BINOP_DIV:             strcpy(ptr,"/"); break;
 330     case BINOP_REM:             strcpy(ptr,"%"); break;
 331     case BINOP_LSH:             strcpy(ptr,"<<"); break;
 332     case BINOP_RSH:             strcpy(ptr,">>"); break;
 333     case BINOP_BITWISE_AND:     strcpy(ptr,"&"); break;
 334     case BINOP_BITWISE_IOR:     strcpy(ptr,"|"); break;
 335     case BINOP_BITWISE_XOR:     strcpy(ptr,"^"); break;
 336     case BINOP_LOGICAL_AND:     strcpy(ptr,"&&"); break;
 337     case BINOP_LOGICAL_OR:      strcpy(ptr,"||"); break;
 338     case BINOP_MIN:             strcpy(ptr,"<?"); break;
 339     case BINOP_MAX:             strcpy(ptr,">?"); break;
 340     case BINOP_ASSIGN:          strcpy(ptr,"="); break;
 341     case BINOP_ASSIGN_MODIFY:
 342       switch (otherop)
 343         {
 344         case BINOP_ADD:         strcpy(ptr,"+="); break;
 345         case BINOP_SUB:         strcpy(ptr,"-="); break;
 346         case BINOP_MUL:         strcpy(ptr,"*="); break;
 347         case BINOP_DIV:         strcpy(ptr,"/="); break;
 348         case BINOP_REM:         strcpy(ptr,"%="); break;
 349         case BINOP_BITWISE_AND: strcpy(ptr,"&="); break;
 350         case BINOP_BITWISE_IOR: strcpy(ptr,"|="); break;
 351         case BINOP_BITWISE_XOR: strcpy(ptr,"^="); break;
 352         case BINOP_MOD:         /* invalid */
 353         default:
 354           error ("Invalid binary operation specified.");
 355         }
 356       break;
 357     case BINOP_SUBSCRIPT: strcpy(ptr,"[]"); break;
 358     case BINOP_EQUAL:     strcpy(ptr,"=="); break;
 359     case BINOP_NOTEQUAL:  strcpy(ptr,"!="); break;
 360     case BINOP_LESS:      strcpy(ptr,"<"); break;
 361     case BINOP_GTR:       strcpy(ptr,">"); break;
 362     case BINOP_GEQ:       strcpy(ptr,">="); break;
 363     case BINOP_LEQ:       strcpy(ptr,"<="); break;
 364     case BINOP_MOD:       /* invalid */
 365     default:
 366       error ("Invalid binary operation specified.");
 367     }
 368
 369   argvec[0] = value_struct_elt (&arg1, argvec+1, tstr, &static_memfuncp, "structure");
 370
 371   if (argvec[0])
 372     {
 373       if (static_memfuncp)
 374         {
 375           argvec[1] = argvec[0];
 376           argvec++;
 377         }
 378       return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
 379     }
 380   error ("member function %s not found", tstr);
 381 #ifdef lint
 382   return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
 383 #endif
 384 }
 385
 386 /* We know that arg1 is a structure, so try to find a unary user
 387    defined operator that matches the operator in question.
 388    Create an argument vector that calls arg1.operator @ (arg1)
 389    and return that value (where '@' is (almost) any unary operator which
 390    is legal for GNU C++).  */
 391
 392 value_ptr
 393 value_x_unop (arg1, op)
 394      value_ptr arg1;
 395      enum exp_opcode op;
 396 {
 397   value_ptr * argvec;
 398   char *ptr, *mangle_ptr;
 399   char tstr[13], mangle_tstr[13];
 400   int static_memfuncp;
 401
 402   COERCE_REF (arg1);
 403   COERCE_ENUM (arg1);
 404
 405   /* now we know that what we have to do is construct our
 406      arg vector and find the right function to call it with.  */
 407
 408   if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_STRUCT)
 409     error ("Can't do that unary op on that type");  /* FIXME be explicit */
 410
 411   argvec = (value_ptr *) alloca (sizeof (value_ptr) * 3);
 412   argvec[1] = value_addr (arg1);
 413   argvec[2] = 0;
 414
 415   /* make the right function name up */
 416   strcpy(tstr,"operator__");
 417   ptr = tstr+8;
 418   strcpy(mangle_tstr, "__");
 419   mangle_ptr = mangle_tstr+2;
 420   switch (op)
 421     {
 422     case UNOP_PREINCREMENT:     strcpy(ptr,"++"); break;
 423     case UNOP_PREDECREMENT:     strcpy(ptr,"++"); break;
 424     case UNOP_POSTINCREMENT:    strcpy(ptr,"++"); break;
 425     case UNOP_POSTDECREMENT:    strcpy(ptr,"++"); break;
 426     case UNOP_LOGICAL_NOT:      strcpy(ptr,"!"); break;
 427     case UNOP_COMPLEMENT:       strcpy(ptr,"~"); break;
 428     case UNOP_NEG:              strcpy(ptr,"-"); break;
 429     default:
 430       error ("Invalid binary operation specified.");
 431     }
 432
 433   argvec[0] = value_struct_elt (&arg1, argvec+1, tstr, &static_memfuncp, "structure");
 434
 435   if (argvec[0])
 436     {
 437       if (static_memfuncp)
 438         {
 439           argvec[1] = argvec[0];
 440           argvec++;
 441         }
 442       return call_function_by_hand (argvec[0], 1 - static_memfuncp, argvec + 1);
 443     }
 444   error ("member function %s not found", tstr);
 445   return 0;  /* For lint -- never reached */
 446 }
 447
 448 \f
 449 /* Concatenate two values with the following conditions:
 450
 451    (1)  Both values must be either bitstring values or character string
 452         values and the resulting value consists of the concatenation of
 453         ARG1 followed by ARG2.
 454
 455         or
 456
 457         One value must be an integer value and the other value must be
 458         either a bitstring value or character string value, which is
 459         to be repeated by the number of times specified by the integer
 460         value.
 461
 462
 463     (2) Boolean values are also allowed and are treated as bit string
 464         values of length 1.
 465
 466     (3) Character values are also allowed and are treated as character
 467         string values of length 1.
 468 */
 469
 470 value_ptr
 471 value_concat (arg1, arg2)
 472      value_ptr arg1, arg2;
 473 {
 474   register value_ptr inval1, inval2, outval;
 475   int inval1len, inval2len;
 476   int count, idx;
 477   char *ptr;
 478   char inchar;
 479   struct type *type1 = check_typedef (VALUE_TYPE (arg1));
 480   struct type *type2 = check_typedef (VALUE_TYPE (arg2));
 481
 482   COERCE_VARYING_ARRAY (arg1, type1);
 483   COERCE_VARYING_ARRAY (arg2, type2);
 484
 485   /* First figure out if we are dealing with two values to be concatenated
 486      or a repeat count and a value to be repeated.  INVAL1 is set to the
 487      first of two concatenated values, or the repeat count.  INVAL2 is set
 488      to the second of the two concatenated values or the value to be
 489      repeated. */
 490
 491   if (TYPE_CODE (type2) == TYPE_CODE_INT)
 492     {
 493       struct type *tmp = type1;
 494       type1 = tmp;
 495       tmp = type2;
 496       inval1 = arg2;
 497       inval2 = arg1;
 498     }
 499   else
 500     {
 501       inval1 = arg1;
 502       inval2 = arg2;
 503     }
 504
 505   /* Now process the input values. */
 506
 507   if (TYPE_CODE (type1) == TYPE_CODE_INT)
 508     {
 509       /* We have a repeat count.  Validate the second value and then
 510          construct a value repeated that many times. */
 511       if (TYPE_CODE (type2) == TYPE_CODE_STRING
 512           || TYPE_CODE (type2) == TYPE_CODE_CHAR)
 513         {
 514           count = longest_to_int (value_as_long (inval1));
 515           inval2len = TYPE_LENGTH (type2);
 516           ptr = (char *) alloca (count * inval2len);
 517           if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
 518             {
 519               inchar = (char) unpack_long (type2,
 520                                            VALUE_CONTENTS (inval2));
 521               for (idx = 0; idx < count; idx++)
 522                 {
 523                   *(ptr + idx) = inchar;
 524                 }
 525             }
 526           else
 527             {
 528               for (idx = 0; idx < count; idx++)
 529                 {
 530                   memcpy (ptr + (idx * inval2len), VALUE_CONTENTS (inval2),
 531                           inval2len);
 532                 }
 533             }
 534           outval = value_string (ptr, count * inval2len);
 535         }
 536       else if (TYPE_CODE (type2) == TYPE_CODE_BITSTRING
 537                || TYPE_CODE (type2) == TYPE_CODE_BOOL)
 538         {
 539           error ("unimplemented support for bitstring/boolean repeats");
 540         }
 541       else
 542         {
 543           error ("can't repeat values of that type");
 544         }
 545     }
 546   else if (TYPE_CODE (type1) == TYPE_CODE_STRING
 547       || TYPE_CODE (type1) == TYPE_CODE_CHAR)
 548     {
 549       /* We have two character strings to concatenate. */
 550       if (TYPE_CODE (type2) != TYPE_CODE_STRING
 551           && TYPE_CODE (type2) != TYPE_CODE_CHAR)
 552         {
 553           error ("Strings can only be concatenated with other strings.");
 554         }
 555       inval1len = TYPE_LENGTH (type1);
 556       inval2len = TYPE_LENGTH (type2);
 557       ptr = (char *) alloca (inval1len + inval2len);
 558       if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
 559         {
 560           *ptr = (char) unpack_long (type1, VALUE_CONTENTS (inval1));
 561         }
 562       else
 563         {
 564           memcpy (ptr, VALUE_CONTENTS (inval1), inval1len);
 565         }
 566       if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
 567         {
 568           *(ptr + inval1len) =
 569             (char) unpack_long (type2, VALUE_CONTENTS (inval2));
 570         }
 571       else
 572         {
 573           memcpy (ptr + inval1len, VALUE_CONTENTS (inval2), inval2len);
 574         }
 575       outval = value_string (ptr, inval1len + inval2len);
 576     }
 577   else if (TYPE_CODE (type1) == TYPE_CODE_BITSTRING
 578            || TYPE_CODE (type1) == TYPE_CODE_BOOL)
 579     {
 580       /* We have two bitstrings to concatenate. */
 581       if (TYPE_CODE (type2) != TYPE_CODE_BITSTRING
 582           && TYPE_CODE (type2) != TYPE_CODE_BOOL)
 583         {
 584           error ("Bitstrings or booleans can only be concatenated with other bitstrings or booleans.");
 585         }
 586       error ("unimplemented support for bitstring/boolean concatenation.");
 587     }
 588   else
 589     {
 590       /* We don't know how to concatenate these operands. */
 591       error ("illegal operands for concatenation.");
 592     }
 593   return (outval);
 594 }
 595
 596 \f
 597
 598 /* Perform a binary operation on two operands which have reasonable
 599    representations as integers or floats.  This includes booleans,
 600    characters, integers, or floats.
 601    Does not support addition and subtraction on pointers;
 602    use value_add or value_sub if you want to handle those possibilities.  */
 603
 604 value_ptr
 605 value_binop (arg1, arg2, op)
 606      value_ptr arg1, arg2;
 607      enum exp_opcode op;
 608 {
 609   register value_ptr val;
 610   struct type *type1, *type2;
 611
 612   COERCE_REF (arg1);
 613   COERCE_REF (arg2);
 614   COERCE_ENUM (arg1);
 615   COERCE_ENUM (arg2);
 616   type1 = check_typedef (VALUE_TYPE (arg1));
 617   type2 = check_typedef (VALUE_TYPE (arg2));
 618
 619   if ((TYPE_CODE (type1) != TYPE_CODE_FLT
 620        && TYPE_CODE (type1) != TYPE_CODE_CHAR
 621        && TYPE_CODE (type1) != TYPE_CODE_INT
 622        && TYPE_CODE (type1) != TYPE_CODE_BOOL
 623        && TYPE_CODE (type1) != TYPE_CODE_RANGE)
 624       ||
 625       (TYPE_CODE (type2) != TYPE_CODE_FLT
 626        && TYPE_CODE (type2) != TYPE_CODE_CHAR
 627        && TYPE_CODE (type2) != TYPE_CODE_INT
 628        && TYPE_CODE (type2) != TYPE_CODE_BOOL
 629        && TYPE_CODE (type2) != TYPE_CODE_RANGE))
 630     error ("Argument to arithmetic operation not a number or boolean.");
 631
 632   if (TYPE_CODE (type1) == TYPE_CODE_FLT
 633       ||
 634       TYPE_CODE (type2) == TYPE_CODE_FLT)
 635     {
 636       /* FIXME-if-picky-about-floating-accuracy: Should be doing this
 637          in target format.  real.c in GCC probably has the necessary
 638          code.  */
 639       DOUBLEST v1, v2, v;
 640       v1 = value_as_double (arg1);
 641       v2 = value_as_double (arg2);
 642       switch (op)
 643         {
 644         case BINOP_ADD:
 645           v = v1 + v2;
 646           break;
 647
 648         case BINOP_SUB:
 649           v = v1 - v2;
 650           break;
 651
 652         case BINOP_MUL:
 653           v = v1 * v2;
 654           break;
 655
 656         case BINOP_DIV:
 657           v = v1 / v2;
 658           break;
 659
 660         default:
 661           error ("Integer-only operation on floating point number.");
 662         }
 663
 664       /* If either arg was long double, make sure that value is also long
 665          double.  */
 666
 667       if (TYPE_LENGTH(type1) * 8 > TARGET_DOUBLE_BIT
 668           || TYPE_LENGTH(type2) * 8 > TARGET_DOUBLE_BIT)
 669         val = allocate_value (builtin_type_long_double);
 670       else
 671         val = allocate_value (builtin_type_double);
 672
 673       store_floating (VALUE_CONTENTS_RAW (val), TYPE_LENGTH (VALUE_TYPE (val)),
 674                       v);
 675     }
 676   else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
 677            &&
 678            TYPE_CODE (type2) == TYPE_CODE_BOOL)
 679       {
 680           LONGEST v1, v2, v;
 681           v1 = value_as_long (arg1);
 682           v2 = value_as_long (arg2);
 683
 684           switch (op)
 685             {
 686             case BINOP_BITWISE_AND:
 687               v = v1 & v2;
 688               break;
 689
 690             case BINOP_BITWISE_IOR:
 691               v = v1 | v2;
 692               break;
 693
 694             case BINOP_BITWISE_XOR:
 695               v = v1 ^ v2;
 696               break;
 697
 698             default:
 699               error ("Invalid operation on booleans.");
 700             }
 701
 702           val = allocate_value (type1);
 703           store_signed_integer (VALUE_CONTENTS_RAW (val),
 704                                 TYPE_LENGTH (type1),
 705                                 v);
 706       }
 707   else
 708     /* Integral operations here.  */
 709     /* FIXME:  Also mixed integral/booleans, with result an integer. */
 710     /* FIXME: This implements ANSI C rules (also correct for C++).
 711        What about FORTRAN and chill?  */
 712     {
 713       unsigned int promoted_len1 = TYPE_LENGTH (type1);
 714       unsigned int promoted_len2 = TYPE_LENGTH (type2);
 715       int is_unsigned1 = TYPE_UNSIGNED (type1);
 716       int is_unsigned2 = TYPE_UNSIGNED (type2);
 717       unsigned int result_len;
 718       int unsigned_operation;
 719
 720       /* Determine type length and signedness after promotion for
 721          both operands.  */
 722       if (promoted_len1 < TYPE_LENGTH (builtin_type_int))
 723         {
 724           is_unsigned1 = 0;
 725           promoted_len1 = TYPE_LENGTH (builtin_type_int);
 726         }
 727       if (promoted_len2 < TYPE_LENGTH (builtin_type_int))
 728         {
 729           is_unsigned2 = 0;
 730           promoted_len2 = TYPE_LENGTH (builtin_type_int);
 731         }
 732
 733       /* Determine type length of the result, and if the operation should
 734          be done unsigned.
 735          Use the signedness of the operand with the greater length.
 736          If both operands are of equal length, use unsigned operation
 737          if one of the operands is unsigned.  */
 738       if (promoted_len1 > promoted_len2)
 739         {
 740           unsigned_operation = is_unsigned1;
 741           result_len = promoted_len1;
 742         }
 743       else if (promoted_len2 > promoted_len1)
 744         {
 745           unsigned_operation = is_unsigned2;
 746           result_len = promoted_len2;
 747         }
 748       else
 749         {
 750           unsigned_operation = is_unsigned1 || is_unsigned2;
 751           result_len = promoted_len1;
 752         }
 753
 754       if (unsigned_operation)
 755         {
 756           unsigned LONGEST v1, v2, v;
 757           v1 = (unsigned LONGEST) value_as_long (arg1);
 758           v2 = (unsigned LONGEST) value_as_long (arg2);
 759
 760           /* Truncate values to the type length of the result.  */
 761           if (result_len < sizeof (unsigned LONGEST))
 762             {
 763               v1 &= ((LONGEST) 1 << HOST_CHAR_BIT * result_len) - 1;
 764               v2 &= ((LONGEST) 1 << HOST_CHAR_BIT * result_len) - 1;
 765             }
 766
 767           switch (op)
 768             {
 769             case BINOP_ADD:
 770               v = v1 + v2;
 771               break;
 772
 773             case BINOP_SUB:
 774               v = v1 - v2;
 775               break;
 776
 777             case BINOP_MUL:
 778               v = v1 * v2;
 779               break;
 780
 781             case BINOP_DIV:
 782               v = v1 / v2;
 783               break;
 784
 785             case BINOP_REM:
 786               v = v1 % v2;
 787               break;
 788
 789             case BINOP_MOD:
 790               /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
 791                  v1 mod 0 has a defined value, v1. */
 792               /* Chill specifies that v2 must be > 0, so check for that. */
 793               if (current_language -> la_language == language_chill
 794                   && value_as_long (arg2) <= 0)
 795                 {
 796                   error ("Second operand of MOD must be greater than zero.");
 797                 }
 798               if (v2 == 0)
 799                 {
 800                   v = v1;
 801                 }
 802               else
 803                 {
 804                   v = v1/v2;
 805                   /* Note floor(v1/v2) == v1/v2 for unsigned. */
 806                   v = v1 - (v2 * v);
 807                 }
 808               break;
 809
 810             case BINOP_LSH:
 811               v = v1 << v2;
 812               break;
 813
 814             case BINOP_RSH:
 815               v = v1 >> v2;
 816               break;
 817
 818             case BINOP_BITWISE_AND:
 819               v = v1 & v2;
 820               break;
 821
 822             case BINOP_BITWISE_IOR:
 823               v = v1 | v2;
 824               break;
 825
 826             case BINOP_BITWISE_XOR:
 827               v = v1 ^ v2;
 828               break;
 829
 830             case BINOP_LOGICAL_AND:
 831               v = v1 && v2;
 832               break;
 833
 834             case BINOP_LOGICAL_OR:
 835               v = v1 || v2;
 836               break;
 837
 838             case BINOP_MIN:
 839               v = v1 < v2 ? v1 : v2;
 840               break;
 841
 842             case BINOP_MAX:
 843               v = v1 > v2 ? v1 : v2;
 844               break;
 845
 846             case BINOP_EQUAL:
 847               v = v1 == v2;
 848               break;
 849
 850             case BINOP_LESS:
 851               v = v1 < v2;
 852               break;
 853
 854             default:
 855               error ("Invalid binary operation on numbers.");
 856             }
 857
 858           /* This is a kludge to get around the fact that we don't
 859              know how to determine the result type from the types of
 860              the operands.  (I'm not really sure how much we feel the
 861              need to duplicate the exact rules of the current
 862              language.  They can get really hairy.  But not to do so
 863              makes it hard to document just what we *do* do).  */
 864
 865           /* Can't just call init_type because we wouldn't know what
 866              name to give the type.  */
 867           val = allocate_value
 868             (result_len > TARGET_LONG_BIT / HOST_CHAR_BIT
 869              ? builtin_type_unsigned_long_long
 870              : builtin_type_unsigned_long);
 871           store_unsigned_integer (VALUE_CONTENTS_RAW (val),
 872                                   TYPE_LENGTH (VALUE_TYPE (val)),
 873                                   v);
 874         }
 875       else
 876         {
 877           LONGEST v1, v2, v;
 878           v1 = value_as_long (arg1);
 879           v2 = value_as_long (arg2);
 880
 881           switch (op)
 882             {
 883             case BINOP_ADD:
 884               v = v1 + v2;
 885               break;
 886
 887             case BINOP_SUB:
 888               v = v1 - v2;
 889               break;
 890
 891             case BINOP_MUL:
 892               v = v1 * v2;
 893               break;
 894
 895             case BINOP_DIV:
 896               v = v1 / v2;
 897               break;
 898
 899             case BINOP_REM:
 900               v = v1 % v2;
 901               break;
 902
 903             case BINOP_MOD:
 904               /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
 905                  X mod 0 has a defined value, X. */
 906               /* Chill specifies that v2 must be > 0, so check for that. */
 907               if (current_language -> la_language == language_chill
 908                   && v2 <= 0)
 909                 {
 910                   error ("Second operand of MOD must be greater than zero.");
 911                 }
 912               if (v2 == 0)
 913                 {
 914                   v = v1;
 915                 }
 916               else
 917                 {
 918                   v = v1/v2;
 919                   /* Compute floor. */
 920                   if (TRUNCATION_TOWARDS_ZERO && (v < 0) && ((v1 % v2) != 0))
 921                     {
 922                       v--;
 923                     }
 924                   v = v1 - (v2 * v);
 925                 }
 926               break;
 927
 928             case BINOP_LSH:
 929               v = v1 << v2;
 930               break;
 931
 932             case BINOP_RSH:
 933               v = v1 >> v2;
 934               break;
 935
 936             case BINOP_BITWISE_AND:
 937               v = v1 & v2;
 938               break;
 939
 940             case BINOP_BITWISE_IOR:
 941               v = v1 | v2;
 942               break;
 943
 944             case BINOP_BITWISE_XOR:
 945               v = v1 ^ v2;
 946               break;
 947
 948             case BINOP_LOGICAL_AND:
 949               v = v1 && v2;
 950               break;
 951
 952             case BINOP_LOGICAL_OR:
 953               v = v1 || v2;
 954               break;
 955
 956             case BINOP_MIN:
 957               v = v1 < v2 ? v1 : v2;
 958               break;
 959
 960             case BINOP_MAX:
 961               v = v1 > v2 ? v1 : v2;
 962               break;
 963
 964             case BINOP_EQUAL:
 965               v = v1 == v2;
 966               break;
 967
 968             case BINOP_LESS:
 969               v = v1 < v2;
 970               break;
 971
 972             default:
 973               error ("Invalid binary operation on numbers.");
 974             }
 975
 976           /* This is a kludge to get around the fact that we don't
 977              know how to determine the result type from the types of
 978              the operands.  (I'm not really sure how much we feel the
 979              need to duplicate the exact rules of the current
 980              language.  They can get really hairy.  But not to do so
 981              makes it hard to document just what we *do* do).  */
 982
 983           /* Can't just call init_type because we wouldn't know what
 984              name to give the type.  */
 985           val = allocate_value
 986             (result_len > TARGET_LONG_BIT / HOST_CHAR_BIT
 987              ? builtin_type_long_long
 988              : builtin_type_long);
 989           store_signed_integer (VALUE_CONTENTS_RAW (val),
 990                                 TYPE_LENGTH (VALUE_TYPE (val)),
 991                                 v);
 992         }
 993     }
 994
 995   return val;
 996 }
 997 \f
 998 /* Simulate the C operator ! -- return 1 if ARG1 contains zero.  */
 999
1000 int
1001 value_logical_not (arg1)
1002      value_ptr arg1;
1003 {
1004   register int len;
1005   register char *p;
1006   struct type *type1;
1007
1008   COERCE_NUMBER (arg1);
1009   type1 = check_typedef (VALUE_TYPE (arg1));
1010
1011   if (TYPE_CODE (type1) == TYPE_CODE_FLT)
1012     return 0 == value_as_double (arg1);
1013
1014   len = TYPE_LENGTH (type1);
1015   p = VALUE_CONTENTS (arg1);
1016
1017   while (--len >= 0)
1018     {
1019       if (*p++)
1020         break;
1021     }
1022
1023   return len < 0;
1024 }
1025
1026 /* Simulate the C operator == by returning a 1
1027    iff ARG1 and ARG2 have equal contents.  */
1028
1029 int
1030 value_equal (arg1, arg2)
1031      register value_ptr arg1, arg2;
1032
1033 {
1034   register int len;
1035   register char *p1, *p2;
1036   struct type *type1, *type2;
1037   enum type_code code1;
1038   enum type_code code2;
1039
1040   COERCE_NUMBER (arg1);
1041   COERCE_NUMBER (arg2);
1042
1043   type1 = check_typedef (VALUE_TYPE (arg1));
1044   type2 = check_typedef (VALUE_TYPE (arg2));
1045   code1 = TYPE_CODE (type1);
1046   code2 = TYPE_CODE (type2);
1047
1048   if (code1 == TYPE_CODE_INT && code2 == TYPE_CODE_INT)
1049     return longest_to_int (value_as_long (value_binop (arg1, arg2,
1050                                                        BINOP_EQUAL)));
1051   else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT)
1052            && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT))
1053     return value_as_double (arg1) == value_as_double (arg2);
1054
1055   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1056      is bigger.  */
1057   else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_INT)
1058     return value_as_pointer (arg1) == (CORE_ADDR) value_as_long (arg2);
1059   else if (code2 == TYPE_CODE_PTR && code1 == TYPE_CODE_INT)
1060     return (CORE_ADDR) value_as_long (arg1) == value_as_pointer (arg2);
1061
1062   else if (code1 == code2
1063            && ((len = (int) TYPE_LENGTH (type1))
1064                == (int) TYPE_LENGTH (type2)))
1065     {
1066       p1 = VALUE_CONTENTS (arg1);
1067       p2 = VALUE_CONTENTS (arg2);
1068       while (--len >= 0)
1069         {
1070           if (*p1++ != *p2++)
1071             break;
1072         }
1073       return len < 0;
1074     }
1075   else
1076     {
1077       error ("Invalid type combination in equality test.");
1078       return 0;  /* For lint -- never reached */
1079     }
1080 }
1081
1082 /* Simulate the C operator < by returning 1
1083    iff ARG1's contents are less than ARG2's.  */
1084
1085 int
1086 value_less (arg1, arg2)
1087      register value_ptr arg1, arg2;
1088 {
1089   register enum type_code code1;
1090   register enum type_code code2;
1091   struct type *type1, *type2;
1092
1093   COERCE_NUMBER (arg1);
1094   COERCE_NUMBER (arg2);
1095
1096   type1 = check_typedef (VALUE_TYPE (arg1));
1097   type2 = check_typedef (VALUE_TYPE (arg2));
1098   code1 = TYPE_CODE (type1);
1099   code2 = TYPE_CODE (type2);
1100
1101   if (code1 == TYPE_CODE_INT && code2 == TYPE_CODE_INT)
1102     return longest_to_int (value_as_long (value_binop (arg1, arg2,
1103                                                        BINOP_LESS)));
1104   else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT)
1105            && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT))
1106     return value_as_double (arg1) < value_as_double (arg2);
1107   else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
1108     return value_as_pointer (arg1) < value_as_pointer (arg2);
1109
1110   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1111      is bigger.  */
1112   else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_INT)
1113     return value_as_pointer (arg1) < (CORE_ADDR) value_as_long (arg2);
1114   else if (code2 == TYPE_CODE_PTR && code1 == TYPE_CODE_INT)
1115     return (CORE_ADDR) value_as_long (arg1) < value_as_pointer (arg2);
1116
1117   else
1118     {
1119       error ("Invalid type combination in ordering comparison.");
1120       return 0;
1121     }
1122 }
1123 \f
1124 /* The unary operators - and ~.  Both free the argument ARG1.  */
1125
1126 value_ptr
1127 value_neg (arg1)
1128      register value_ptr arg1;
1129 {
1130   register struct type *type;
1131
1132   COERCE_REF (arg1);
1133   COERCE_ENUM (arg1);
1134
1135   type = check_typedef (VALUE_TYPE (arg1));
1136
1137   if (TYPE_CODE (type) == TYPE_CODE_FLT)
1138     return value_from_double (type, - value_as_double (arg1));
1139   else if (TYPE_CODE (type) == TYPE_CODE_INT)
1140     return value_from_longest (type, - value_as_long (arg1));
1141   else {
1142     error ("Argument to negate operation not a number.");
1143     return 0;  /* For lint -- never reached */
1144   }
1145 }
1146
1147 value_ptr
1148 value_complement (arg1)
1149      register value_ptr arg1;
1150 {
1151   COERCE_REF (arg1);
1152   COERCE_ENUM (arg1);
1153
1154   if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_INT)
1155     error ("Argument to complement operation not an integer.");
1156
1157   return value_from_longest (VALUE_TYPE (arg1), ~ value_as_long (arg1));
1158 }
1159 \f
1160 /* The INDEX'th bit of SET value whose VALUE_TYPE is TYPE,
1161    and whose VALUE_CONTENTS is valaddr.
1162    Return -1 if out of range, -2 other error. */
1163
1164 int
1165 value_bit_index (type, valaddr, index)
1166      struct type *type;
1167      char *valaddr;
1168      int index;
1169 {
1170   LONGEST low_bound, high_bound;
1171   LONGEST word;
1172   unsigned rel_index;
1173   struct type *range = TYPE_FIELD_TYPE (type, 0);
1174   if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
1175     return -2;
1176   if (index < low_bound || index > high_bound)
1177     return -1;
1178   rel_index = index - low_bound;
1179   word = unpack_long (builtin_type_unsigned_char,
1180                       valaddr + (rel_index / TARGET_CHAR_BIT));
1181   rel_index %= TARGET_CHAR_BIT;
1182   if (BITS_BIG_ENDIAN)
1183     rel_index = TARGET_CHAR_BIT - 1 - rel_index;
1184   return (word >> rel_index) & 1;
1185 }
1186
1187 value_ptr
1188 value_in (element, set)
1189      value_ptr element, set;
1190 {
1191   int member;
1192   struct type *settype = check_typedef (VALUE_TYPE (set));
1193   struct type *eltype = check_typedef (VALUE_TYPE (element));
1194   if (TYPE_CODE (eltype) == TYPE_CODE_RANGE)
1195     eltype = TYPE_TARGET_TYPE (eltype);
1196   if (TYPE_CODE (settype) != TYPE_CODE_SET)
1197     error ("Second argument of 'IN' has wrong type");
1198   if (TYPE_CODE (eltype) != TYPE_CODE_INT
1199       && TYPE_CODE (eltype) != TYPE_CODE_CHAR
1200       && TYPE_CODE (eltype) != TYPE_CODE_ENUM
1201       && TYPE_CODE (eltype) != TYPE_CODE_BOOL)
1202     error ("First argument of 'IN' has wrong type");
1203   member = value_bit_index (settype, VALUE_CONTENTS (set),
1204                             value_as_long (element));
1205   if (member < 0)
1206     error ("First argument of 'IN' not in range");
1207   return value_from_longest (LA_BOOL_TYPE, member);
1208 }
1209
1210 void
1211 _initialize_valarith ()
1212 {
1213 }