gdb/valarith.c

   1 /* Perform arithmetic and other operations on values, for GDB.
   2
   3    Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
   4    1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009,
   5    2010 Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "value.h"
  24 #include "symtab.h"
  25 #include "gdbtypes.h"
  26 #include "expression.h"
  27 #include "target.h"
  28 #include "language.h"
  29 #include "gdb_string.h"
  30 #include "doublest.h"
  31 #include "dfp.h"
  32 #include <math.h>
  33 #include "infcall.h"
  34
  35 /* Define whether or not the C operator '/' truncates towards zero for
  36    differently signed operands (truncation direction is undefined in C). */
  37
  38 #ifndef TRUNCATION_TOWARDS_ZERO
  39 #define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
  40 #endif
  41
  42 void _initialize_valarith (void);
  43 \f
  44
  45 /* Given a pointer, return the size of its target.
  46    If the pointer type is void *, then return 1.
  47    If the target type is incomplete, then error out.
  48    This isn't a general purpose function, but just a
  49    helper for value_ptradd.
  50 */
  51
  52 static LONGEST
  53 find_size_for_pointer_math (struct type *ptr_type)
  54 {
  55   LONGEST sz = -1;
  56   struct type *ptr_target;
  57
  58   gdb_assert (TYPE_CODE (ptr_type) == TYPE_CODE_PTR);
  59   ptr_target = check_typedef (TYPE_TARGET_TYPE (ptr_type));
  60
  61   sz = TYPE_LENGTH (ptr_target);
  62   if (sz == 0)
  63     {
  64       if (TYPE_CODE (ptr_type) == TYPE_CODE_VOID)
  65         sz = 1;
  66       else
  67         {
  68           char *name;
  69
  70           name = TYPE_NAME (ptr_target);
  71           if (name == NULL)
  72             name = TYPE_TAG_NAME (ptr_target);
  73           if (name == NULL)
  74             error (_("Cannot perform pointer math on incomplete types, "
  75                    "try casting to a known type, or void *."));
  76           else
  77             error (_("Cannot perform pointer math on incomplete type \"%s\", "
  78                    "try casting to a known type, or void *."), name);
  79         }
  80     }
  81   return sz;
  82 }
  83
  84 /* Given a pointer ARG1 and an integral value ARG2, return the
  85    result of C-style pointer arithmetic ARG1 + ARG2.  */
  86
  87 struct value *
  88 value_ptradd (struct value *arg1, LONGEST arg2)
  89 {
  90   struct type *valptrtype;
  91   LONGEST sz;
  92
  93   arg1 = coerce_array (arg1);
  94   valptrtype = check_typedef (value_type (arg1));
  95   sz = find_size_for_pointer_math (valptrtype);
  96
  97   return value_from_pointer (valptrtype,
  98                              value_as_address (arg1) + sz * arg2);
  99 }
 100
 101 /* Given two compatible pointer values ARG1 and ARG2, return the
 102    result of C-style pointer arithmetic ARG1 - ARG2.  */
 103
 104 LONGEST
 105 value_ptrdiff (struct value *arg1, struct value *arg2)
 106 {
 107   struct type *type1, *type2;
 108   LONGEST sz;
 109
 110   arg1 = coerce_array (arg1);
 111   arg2 = coerce_array (arg2);
 112   type1 = check_typedef (value_type (arg1));
 113   type2 = check_typedef (value_type (arg2));
 114
 115   gdb_assert (TYPE_CODE (type1) == TYPE_CODE_PTR);
 116   gdb_assert (TYPE_CODE (type2) == TYPE_CODE_PTR);
 117
 118   if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)))
 119       != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2))))
 120     error (_("\
 121 First argument of `-' is a pointer and second argument is neither\n\
 122 an integer nor a pointer of the same type."));
 123
 124   sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
 125   if (sz == 0)
 126     {
 127       warning (_("Type size unknown, assuming 1. "
 128                "Try casting to a known type, or void *."));
 129       sz = 1;
 130     }
 131
 132   return (value_as_long (arg1) - value_as_long (arg2)) / sz;
 133 }
 134
 135 /* Return the value of ARRAY[IDX].
 136
 137    ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING.  If the
 138    current language supports C-style arrays, it may also be TYPE_CODE_PTR.
 139    To access TYPE_CODE_BITSTRING values, use value_bitstring_subscript.
 140
 141    See comments in value_coerce_array() for rationale for reason for
 142    doing lower bounds adjustment here rather than there.
 143    FIXME:  Perhaps we should validate that the index is valid and if
 144    verbosity is set, warn about invalid indices (but still use them). */
 145
 146 struct value *
 147 value_subscript (struct value *array, LONGEST index)
 148 {
 149   int c_style = current_language->c_style_arrays;
 150   struct type *tarray;
 151
 152   array = coerce_ref (array);
 153   tarray = check_typedef (value_type (array));
 154
 155   if (TYPE_CODE (tarray) == TYPE_CODE_ARRAY
 156       || TYPE_CODE (tarray) == TYPE_CODE_STRING)
 157     {
 158       struct type *range_type = TYPE_INDEX_TYPE (tarray);
 159       LONGEST lowerbound, upperbound;
 160
 161       get_discrete_bounds (range_type, &lowerbound, &upperbound);
 162       if (VALUE_LVAL (array) != lval_memory)
 163         return value_subscripted_rvalue (array, index, lowerbound);
 164
 165       if (c_style == 0)
 166         {
 167           if (index >= lowerbound && index <= upperbound)
 168             return value_subscripted_rvalue (array, index, lowerbound);
 169           /* Emit warning unless we have an array of unknown size.
 170              An array of unknown size has lowerbound 0 and upperbound -1.  */
 171           if (upperbound > -1)
 172             warning (_("array or string index out of range"));
 173           /* fall doing C stuff */
 174           c_style = 1;
 175         }
 176
 177       index -= lowerbound;
 178       array = value_coerce_array (array);
 179     }
 180
 181   if (c_style)
 182     return value_ind (value_ptradd (array, index));
 183   else
 184     error (_("not an array or string"));
 185 }
 186
 187 /* Return the value of EXPR[IDX], expr an aggregate rvalue
 188    (eg, a vector register).  This routine used to promote floats
 189    to doubles, but no longer does.  */
 190
 191 struct value *
 192 value_subscripted_rvalue (struct value *array, LONGEST index, int lowerbound)
 193 {
 194   struct type *array_type = check_typedef (value_type (array));
 195   struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
 196   unsigned int elt_size = TYPE_LENGTH (elt_type);
 197   unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
 198   struct value *v;
 199
 200   if (index < lowerbound || (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type)
 201                              && elt_offs >= TYPE_LENGTH (array_type)))
 202     error (_("no such vector element"));
 203
 204   v = allocate_value (elt_type);
 205   if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
 206     set_value_lazy (v, 1);
 207   else
 208     memcpy (value_contents_writeable (v),
 209             value_contents (array) + elt_offs, elt_size);
 210
 211   set_value_component_location (v, array);
 212   VALUE_REGNUM (v) = VALUE_REGNUM (array);
 213   VALUE_FRAME_ID (v) = VALUE_FRAME_ID (array);
 214   set_value_offset (v, value_offset (array) + elt_offs);
 215   return v;
 216 }
 217
 218 /* Return the value of BITSTRING[IDX] as (boolean) type TYPE.  */
 219
 220 struct value *
 221 value_bitstring_subscript (struct type *type,
 222                            struct value *bitstring, LONGEST index)
 223 {
 224
 225   struct type *bitstring_type, *range_type;
 226   struct value *v;
 227   int offset, byte, bit_index;
 228   LONGEST lowerbound, upperbound;
 229
 230   bitstring_type = check_typedef (value_type (bitstring));
 231   gdb_assert (TYPE_CODE (bitstring_type) == TYPE_CODE_BITSTRING);
 232
 233   range_type = TYPE_INDEX_TYPE (bitstring_type);
 234   get_discrete_bounds (range_type, &lowerbound, &upperbound);
 235   if (index < lowerbound || index > upperbound)
 236     error (_("bitstring index out of range"));
 237
 238   index -= lowerbound;
 239   offset = index / TARGET_CHAR_BIT;
 240   byte = *((char *) value_contents (bitstring) + offset);
 241
 242   bit_index = index % TARGET_CHAR_BIT;
 243   byte >>= (gdbarch_bits_big_endian (get_type_arch (bitstring_type)) ?
 244             TARGET_CHAR_BIT - 1 - bit_index : bit_index);
 245
 246   v = value_from_longest (type, byte & 1);
 247
 248   set_value_bitpos (v, bit_index);
 249   set_value_bitsize (v, 1);
 250   set_value_component_location (v, bitstring);
 251   VALUE_FRAME_ID (v) = VALUE_FRAME_ID (bitstring);
 252
 253   set_value_offset (v, offset + value_offset (bitstring));
 254
 255   return v;
 256 }
 257
 258 \f
 259 /* Check to see if either argument is a structure, or a reference to
 260    one.  This is called so we know whether to go ahead with the normal
 261    binop or look for a user defined function instead.
 262
 263    For now, we do not overload the `=' operator.  */
 264
 265 int
 266 binop_types_user_defined_p (enum exp_opcode op,
 267                             struct type *type1, struct type *type2)
 268 {
 269   if (op == BINOP_ASSIGN || op == BINOP_CONCAT)
 270     return 0;
 271
 272   type1 = check_typedef (type1);
 273   if (TYPE_CODE (type1) == TYPE_CODE_REF)
 274     type1 = check_typedef (TYPE_TARGET_TYPE (type1));
 275
 276   type2 = check_typedef (type1);
 277   if (TYPE_CODE (type2) == TYPE_CODE_REF)
 278     type2 = check_typedef (TYPE_TARGET_TYPE (type2));
 279
 280   return (TYPE_CODE (type1) == TYPE_CODE_STRUCT
 281           || TYPE_CODE (type2) == TYPE_CODE_STRUCT);
 282 }
 283
 284 /* Check to see if either argument is a structure, or a reference to
 285    one.  This is called so we know whether to go ahead with the normal
 286    binop or look for a user defined function instead.
 287
 288    For now, we do not overload the `=' operator.  */
 289
 290 int
 291 binop_user_defined_p (enum exp_opcode op,
 292                       struct value *arg1, struct value *arg2)
 293 {
 294   return binop_types_user_defined_p (op, value_type (arg1), value_type (arg2));
 295 }
 296
 297 /* Check to see if argument is a structure.  This is called so
 298    we know whether to go ahead with the normal unop or look for a
 299    user defined function instead.
 300
 301    For now, we do not overload the `&' operator.  */
 302
 303 int
 304 unop_user_defined_p (enum exp_opcode op, struct value *arg1)
 305 {
 306   struct type *type1;
 307
 308   if (op == UNOP_ADDR)
 309     return 0;
 310   type1 = check_typedef (value_type (arg1));
 311   for (;;)
 312     {
 313       if (TYPE_CODE (type1) == TYPE_CODE_STRUCT)
 314         return 1;
 315       else if (TYPE_CODE (type1) == TYPE_CODE_REF)
 316         type1 = TYPE_TARGET_TYPE (type1);
 317       else
 318         return 0;
 319     }
 320 }
 321
 322 /* We know either arg1 or arg2 is a structure, so try to find the right
 323    user defined function.  Create an argument vector that calls
 324    arg1.operator @ (arg1,arg2) and return that value (where '@' is any
 325    binary operator which is legal for GNU C++).
 326
 327    OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
 328    is the opcode saying how to modify it.  Otherwise, OTHEROP is
 329    unused.  */
 330
 331 struct value *
 332 value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
 333                enum exp_opcode otherop, enum noside noside)
 334 {
 335   struct value **argvec;
 336   char *ptr;
 337   char tstr[13];
 338   int static_memfuncp;
 339
 340   arg1 = coerce_ref (arg1);
 341   arg2 = coerce_ref (arg2);
 342
 343   /* now we know that what we have to do is construct our
 344      arg vector and find the right function to call it with.  */
 345
 346   if (TYPE_CODE (check_typedef (value_type (arg1))) != TYPE_CODE_STRUCT)
 347     error (_("Can't do that binary op on that type"));  /* FIXME be explicit */
 348
 349   argvec = (struct value **) alloca (sizeof (struct value *) * 4);
 350   argvec[1] = value_addr (arg1);
 351   argvec[2] = arg2;
 352   argvec[3] = 0;
 353
 354   /* make the right function name up */
 355   strcpy (tstr, "operator__");
 356   ptr = tstr + 8;
 357   switch (op)
 358     {
 359     case BINOP_ADD:
 360       strcpy (ptr, "+");
 361       break;
 362     case BINOP_SUB:
 363       strcpy (ptr, "-");
 364       break;
 365     case BINOP_MUL:
 366       strcpy (ptr, "*");
 367       break;
 368     case BINOP_DIV:
 369       strcpy (ptr, "/");
 370       break;
 371     case BINOP_REM:
 372       strcpy (ptr, "%");
 373       break;
 374     case BINOP_LSH:
 375       strcpy (ptr, "<<");
 376       break;
 377     case BINOP_RSH:
 378       strcpy (ptr, ">>");
 379       break;
 380     case BINOP_BITWISE_AND:
 381       strcpy (ptr, "&");
 382       break;
 383     case BINOP_BITWISE_IOR:
 384       strcpy (ptr, "|");
 385       break;
 386     case BINOP_BITWISE_XOR:
 387       strcpy (ptr, "^");
 388       break;
 389     case BINOP_LOGICAL_AND:
 390       strcpy (ptr, "&&");
 391       break;
 392     case BINOP_LOGICAL_OR:
 393       strcpy (ptr, "||");
 394       break;
 395     case BINOP_MIN:
 396       strcpy (ptr, "<?");
 397       break;
 398     case BINOP_MAX:
 399       strcpy (ptr, ">?");
 400       break;
 401     case BINOP_ASSIGN:
 402       strcpy (ptr, "=");
 403       break;
 404     case BINOP_ASSIGN_MODIFY:
 405       switch (otherop)
 406         {
 407         case BINOP_ADD:
 408           strcpy (ptr, "+=");
 409           break;
 410         case BINOP_SUB:
 411           strcpy (ptr, "-=");
 412           break;
 413         case BINOP_MUL:
 414           strcpy (ptr, "*=");
 415           break;
 416         case BINOP_DIV:
 417           strcpy (ptr, "/=");
 418           break;
 419         case BINOP_REM:
 420           strcpy (ptr, "%=");
 421           break;
 422         case BINOP_BITWISE_AND:
 423           strcpy (ptr, "&=");
 424           break;
 425         case BINOP_BITWISE_IOR:
 426           strcpy (ptr, "|=");
 427           break;
 428         case BINOP_BITWISE_XOR:
 429           strcpy (ptr, "^=");
 430           break;
 431         case BINOP_MOD: /* invalid */
 432         default:
 433           error (_("Invalid binary operation specified."));
 434         }
 435       break;
 436     case BINOP_SUBSCRIPT:
 437       strcpy (ptr, "[]");
 438       break;
 439     case BINOP_EQUAL:
 440       strcpy (ptr, "==");
 441       break;
 442     case BINOP_NOTEQUAL:
 443       strcpy (ptr, "!=");
 444       break;
 445     case BINOP_LESS:
 446       strcpy (ptr, "<");
 447       break;
 448     case BINOP_GTR:
 449       strcpy (ptr, ">");
 450       break;
 451     case BINOP_GEQ:
 452       strcpy (ptr, ">=");
 453       break;
 454     case BINOP_LEQ:
 455       strcpy (ptr, "<=");
 456       break;
 457     case BINOP_MOD:             /* invalid */
 458     default:
 459       error (_("Invalid binary operation specified."));
 460     }
 461
 462   argvec[0] = value_struct_elt (&arg1, argvec + 1, tstr, &static_memfuncp, "structure");
 463
 464   if (argvec[0])
 465     {
 466       if (static_memfuncp)
 467         {
 468           argvec[1] = argvec[0];
 469           argvec++;
 470         }
 471       if (noside == EVAL_AVOID_SIDE_EFFECTS)
 472         {
 473           struct type *return_type;
 474
 475           return_type
 476             = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
 477           return value_zero (return_type, VALUE_LVAL (arg1));
 478         }
 479       return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
 480     }
 481   error (_("member function %s not found"), tstr);
 482 #ifdef lint
 483   return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
 484 #endif
 485 }
 486
 487 /* We know that arg1 is a structure, so try to find a unary user
 488    defined operator that matches the operator in question.
 489    Create an argument vector that calls arg1.operator @ (arg1)
 490    and return that value (where '@' is (almost) any unary operator which
 491    is legal for GNU C++).  */
 492
 493 struct value *
 494 value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
 495 {
 496   struct gdbarch *gdbarch = get_type_arch (value_type (arg1));
 497   struct value **argvec;
 498   char *ptr, *mangle_ptr;
 499   char tstr[13], mangle_tstr[13];
 500   int static_memfuncp, nargs;
 501
 502   arg1 = coerce_ref (arg1);
 503
 504   /* now we know that what we have to do is construct our
 505      arg vector and find the right function to call it with.  */
 506
 507   if (TYPE_CODE (check_typedef (value_type (arg1))) != TYPE_CODE_STRUCT)
 508     error (_("Can't do that unary op on that type"));   /* FIXME be explicit */
 509
 510   argvec = (struct value **) alloca (sizeof (struct value *) * 4);
 511   argvec[1] = value_addr (arg1);
 512   argvec[2] = 0;
 513
 514   nargs = 1;
 515
 516   /* make the right function name up */
 517   strcpy (tstr, "operator__");
 518   ptr = tstr + 8;
 519   strcpy (mangle_tstr, "__");
 520   mangle_ptr = mangle_tstr + 2;
 521   switch (op)
 522     {
 523     case UNOP_PREINCREMENT:
 524       strcpy (ptr, "++");
 525       break;
 526     case UNOP_PREDECREMENT:
 527       strcpy (ptr, "--");
 528       break;
 529     case UNOP_POSTINCREMENT:
 530       strcpy (ptr, "++");
 531       argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
 532       argvec[3] = 0;
 533       nargs ++;
 534       break;
 535     case UNOP_POSTDECREMENT:
 536       strcpy (ptr, "--");
 537       argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
 538       argvec[3] = 0;
 539       nargs ++;
 540       break;
 541     case UNOP_LOGICAL_NOT:
 542       strcpy (ptr, "!");
 543       break;
 544     case UNOP_COMPLEMENT:
 545       strcpy (ptr, "~");
 546       break;
 547     case UNOP_NEG:
 548       strcpy (ptr, "-");
 549       break;
 550     case UNOP_PLUS:
 551       strcpy (ptr, "+");
 552       break;
 553     case UNOP_IND:
 554       strcpy (ptr, "*");
 555       break;
 556     default:
 557       error (_("Invalid unary operation specified."));
 558     }
 559
 560   argvec[0] = value_struct_elt (&arg1, argvec + 1, tstr, &static_memfuncp, "structure");
 561
 562   if (argvec[0])
 563     {
 564       if (static_memfuncp)
 565         {
 566           argvec[1] = argvec[0];
 567           nargs --;
 568           argvec++;
 569         }
 570       if (noside == EVAL_AVOID_SIDE_EFFECTS)
 571         {
 572           struct type *return_type;
 573
 574           return_type
 575             = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
 576           return value_zero (return_type, VALUE_LVAL (arg1));
 577         }
 578       return call_function_by_hand (argvec[0], nargs, argvec + 1);
 579     }
 580   error (_("member function %s not found"), tstr);
 581   return 0;                     /* For lint -- never reached */
 582 }
 583 \f
 584
 585 /* Concatenate two values with the following conditions:
 586
 587    (1)  Both values must be either bitstring values or character string
 588    values and the resulting value consists of the concatenation of
 589    ARG1 followed by ARG2.
 590
 591    or
 592
 593    One value must be an integer value and the other value must be
 594    either a bitstring value or character string value, which is
 595    to be repeated by the number of times specified by the integer
 596    value.
 597
 598
 599    (2)  Boolean values are also allowed and are treated as bit string
 600    values of length 1.
 601
 602    (3)  Character values are also allowed and are treated as character
 603    string values of length 1.
 604  */
 605
 606 struct value *
 607 value_concat (struct value *arg1, struct value *arg2)
 608 {
 609   struct value *inval1;
 610   struct value *inval2;
 611   struct value *outval = NULL;
 612   int inval1len, inval2len;
 613   int count, idx;
 614   char *ptr;
 615   char inchar;
 616   struct type *type1 = check_typedef (value_type (arg1));
 617   struct type *type2 = check_typedef (value_type (arg2));
 618   struct type *char_type;
 619
 620   /* First figure out if we are dealing with two values to be concatenated
 621      or a repeat count and a value to be repeated.  INVAL1 is set to the
 622      first of two concatenated values, or the repeat count.  INVAL2 is set
 623      to the second of the two concatenated values or the value to be
 624      repeated. */
 625
 626   if (TYPE_CODE (type2) == TYPE_CODE_INT)
 627     {
 628       struct type *tmp = type1;
 629
 630       type1 = tmp;
 631       tmp = type2;
 632       inval1 = arg2;
 633       inval2 = arg1;
 634     }
 635   else
 636     {
 637       inval1 = arg1;
 638       inval2 = arg2;
 639     }
 640
 641   /* Now process the input values. */
 642
 643   if (TYPE_CODE (type1) == TYPE_CODE_INT)
 644     {
 645       /* We have a repeat count.  Validate the second value and then
 646          construct a value repeated that many times. */
 647       if (TYPE_CODE (type2) == TYPE_CODE_STRING
 648           || TYPE_CODE (type2) == TYPE_CODE_CHAR)
 649         {
 650           count = longest_to_int (value_as_long (inval1));
 651           inval2len = TYPE_LENGTH (type2);
 652           ptr = (char *) alloca (count * inval2len);
 653           if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
 654             {
 655               char_type = type2;
 656
 657               inchar = (char) unpack_long (type2,
 658                                            value_contents (inval2));
 659               for (idx = 0; idx < count; idx++)
 660                 {
 661                   *(ptr + idx) = inchar;
 662                 }
 663             }
 664           else
 665             {
 666               char_type = TYPE_TARGET_TYPE (type2);
 667
 668               for (idx = 0; idx < count; idx++)
 669                 {
 670                   memcpy (ptr + (idx * inval2len), value_contents (inval2),
 671                           inval2len);
 672                 }
 673             }
 674           outval = value_string (ptr, count * inval2len, char_type);
 675         }
 676       else if (TYPE_CODE (type2) == TYPE_CODE_BITSTRING
 677                || TYPE_CODE (type2) == TYPE_CODE_BOOL)
 678         {
 679           error (_("unimplemented support for bitstring/boolean repeats"));
 680         }
 681       else
 682         {
 683           error (_("can't repeat values of that type"));
 684         }
 685     }
 686   else if (TYPE_CODE (type1) == TYPE_CODE_STRING
 687            || TYPE_CODE (type1) == TYPE_CODE_CHAR)
 688     {
 689       /* We have two character strings to concatenate. */
 690       if (TYPE_CODE (type2) != TYPE_CODE_STRING
 691           && TYPE_CODE (type2) != TYPE_CODE_CHAR)
 692         {
 693           error (_("Strings can only be concatenated with other strings."));
 694         }
 695       inval1len = TYPE_LENGTH (type1);
 696       inval2len = TYPE_LENGTH (type2);
 697       ptr = (char *) alloca (inval1len + inval2len);
 698       if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
 699         {
 700           char_type = type1;
 701
 702           *ptr = (char) unpack_long (type1, value_contents (inval1));
 703         }
 704       else
 705         {
 706           char_type = TYPE_TARGET_TYPE (type1);
 707
 708           memcpy (ptr, value_contents (inval1), inval1len);
 709         }
 710       if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
 711         {
 712           *(ptr + inval1len) =
 713             (char) unpack_long (type2, value_contents (inval2));
 714         }
 715       else
 716         {
 717           memcpy (ptr + inval1len, value_contents (inval2), inval2len);
 718         }
 719       outval = value_string (ptr, inval1len + inval2len, char_type);
 720     }
 721   else if (TYPE_CODE (type1) == TYPE_CODE_BITSTRING
 722            || TYPE_CODE (type1) == TYPE_CODE_BOOL)
 723     {
 724       /* We have two bitstrings to concatenate. */
 725       if (TYPE_CODE (type2) != TYPE_CODE_BITSTRING
 726           && TYPE_CODE (type2) != TYPE_CODE_BOOL)
 727         {
 728           error (_("Bitstrings or booleans can only be concatenated with other bitstrings or booleans."));
 729         }
 730       error (_("unimplemented support for bitstring/boolean concatenation."));
 731     }
 732   else
 733     {
 734       /* We don't know how to concatenate these operands. */
 735       error (_("illegal operands for concatenation."));
 736     }
 737   return (outval);
 738 }
 739 \f
 740 /* Integer exponentiation: V1**V2, where both arguments are
 741    integers.  Requires V1 != 0 if V2 < 0.  Returns 1 for 0 ** 0.  */
 742 static LONGEST
 743 integer_pow (LONGEST v1, LONGEST v2)
 744 {
 745   if (v2 < 0)
 746     {
 747       if (v1 == 0)
 748         error (_("Attempt to raise 0 to negative power."));
 749       else
 750         return 0;
 751     }
 752   else
 753     {
 754       /* The Russian Peasant's Algorithm */
 755       LONGEST v;
 756
 757       v = 1;
 758       for (;;)
 759         {
 760           if (v2 & 1L)
 761             v *= v1;
 762           v2 >>= 1;
 763           if (v2 == 0)
 764             return v;
 765           v1 *= v1;
 766         }
 767     }
 768 }
 769
 770 /* Integer exponentiation: V1**V2, where both arguments are
 771    integers.  Requires V1 != 0 if V2 < 0.  Returns 1 for 0 ** 0.  */
 772 static ULONGEST
 773 uinteger_pow (ULONGEST v1, LONGEST v2)
 774 {
 775   if (v2 < 0)
 776     {
 777       if (v1 == 0)
 778         error (_("Attempt to raise 0 to negative power."));
 779       else
 780         return 0;
 781     }
 782   else
 783     {
 784       /* The Russian Peasant's Algorithm */
 785       ULONGEST v;
 786
 787       v = 1;
 788       for (;;)
 789         {
 790           if (v2 & 1L)
 791             v *= v1;
 792           v2 >>= 1;
 793           if (v2 == 0)
 794             return v;
 795           v1 *= v1;
 796         }
 797     }
 798 }
 799
 800 /* Obtain decimal value of arguments for binary operation, converting from
 801    other types if one of them is not decimal floating point.  */
 802 static void
 803 value_args_as_decimal (struct value *arg1, struct value *arg2,
 804                        gdb_byte *x, int *len_x, enum bfd_endian *byte_order_x,
 805                        gdb_byte *y, int *len_y, enum bfd_endian *byte_order_y)
 806 {
 807   struct type *type1, *type2;
 808
 809   type1 = check_typedef (value_type (arg1));
 810   type2 = check_typedef (value_type (arg2));
 811
 812   /* At least one of the arguments must be of decimal float type.  */
 813   gdb_assert (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
 814               || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT);
 815
 816   if (TYPE_CODE (type1) == TYPE_CODE_FLT
 817       || TYPE_CODE (type2) == TYPE_CODE_FLT)
 818     /* The DFP extension to the C language does not allow mixing of
 819      * decimal float types with other float types in expressions
 820      * (see WDTR 24732, page 12).  */
 821     error (_("Mixing decimal floating types with other floating types is not allowed."));
 822
 823   /* Obtain decimal value of arg1, converting from other types
 824      if necessary.  */
 825
 826   if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
 827     {
 828       *byte_order_x = gdbarch_byte_order (get_type_arch (type1));
 829       *len_x = TYPE_LENGTH (type1);
 830       memcpy (x, value_contents (arg1), *len_x);
 831     }
 832   else if (is_integral_type (type1))
 833     {
 834       *byte_order_x = gdbarch_byte_order (get_type_arch (type2));
 835       *len_x = TYPE_LENGTH (type2);
 836       decimal_from_integral (arg1, x, *len_x, *byte_order_x);
 837     }
 838   else
 839     error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1),
 840              TYPE_NAME (type2));
 841
 842   /* Obtain decimal value of arg2, converting from other types
 843      if necessary.  */
 844
 845   if (TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
 846     {
 847       *byte_order_y = gdbarch_byte_order (get_type_arch (type2));
 848       *len_y = TYPE_LENGTH (type2);
 849       memcpy (y, value_contents (arg2), *len_y);
 850     }
 851   else if (is_integral_type (type2))
 852     {
 853       *byte_order_y = gdbarch_byte_order (get_type_arch (type1));
 854       *len_y = TYPE_LENGTH (type1);
 855       decimal_from_integral (arg2, y, *len_y, *byte_order_y);
 856     }
 857   else
 858     error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1),
 859              TYPE_NAME (type2));
 860 }
 861
 862 /* Perform a binary operation on two operands which have reasonable
 863    representations as integers or floats.  This includes booleans,
 864    characters, integers, or floats.
 865    Does not support addition and subtraction on pointers;
 866    use value_ptradd, value_ptrsub or value_ptrdiff for those operations.  */
 867
 868 struct value *
 869 value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
 870 {
 871   struct value *val;
 872   struct type *type1, *type2, *result_type;
 873
 874   arg1 = coerce_ref (arg1);
 875   arg2 = coerce_ref (arg2);
 876
 877   type1 = check_typedef (value_type (arg1));
 878   type2 = check_typedef (value_type (arg2));
 879
 880   if ((TYPE_CODE (type1) != TYPE_CODE_FLT
 881        && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
 882        && !is_integral_type (type1))
 883       || (TYPE_CODE (type2) != TYPE_CODE_FLT
 884           && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
 885           && !is_integral_type (type2)))
 886     error (_("Argument to arithmetic operation not a number or boolean."));
 887
 888   if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
 889       || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
 890     {
 891       int len_v1, len_v2, len_v;
 892       enum bfd_endian byte_order_v1, byte_order_v2, byte_order_v;
 893       gdb_byte v1[16], v2[16];
 894       gdb_byte v[16];
 895
 896       /* If only one type is decimal float, use its type.
 897          Otherwise use the bigger type.  */
 898       if (TYPE_CODE (type1) != TYPE_CODE_DECFLOAT)
 899         result_type = type2;
 900       else if (TYPE_CODE (type2) != TYPE_CODE_DECFLOAT)
 901         result_type = type1;
 902       else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
 903         result_type = type2;
 904       else
 905         result_type = type1;
 906
 907       len_v = TYPE_LENGTH (result_type);
 908       byte_order_v = gdbarch_byte_order (get_type_arch (result_type));
 909
 910       value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
 911                                          v2, &len_v2, &byte_order_v2);
 912
 913       switch (op)
 914         {
 915         case BINOP_ADD:
 916         case BINOP_SUB:
 917         case BINOP_MUL:
 918         case BINOP_DIV:
 919         case BINOP_EXP:
 920           decimal_binop (op, v1, len_v1, byte_order_v1,
 921                              v2, len_v2, byte_order_v2,
 922                              v, len_v, byte_order_v);
 923           break;
 924
 925         default:
 926           error (_("Operation not valid for decimal floating point number."));
 927         }
 928
 929       val = value_from_decfloat (result_type, v);
 930     }
 931   else if (TYPE_CODE (type1) == TYPE_CODE_FLT
 932            || TYPE_CODE (type2) == TYPE_CODE_FLT)
 933     {
 934       /* FIXME-if-picky-about-floating-accuracy: Should be doing this
 935          in target format.  real.c in GCC probably has the necessary
 936          code.  */
 937       DOUBLEST v1, v2, v = 0;
 938
 939       v1 = value_as_double (arg1);
 940       v2 = value_as_double (arg2);
 941
 942       switch (op)
 943         {
 944         case BINOP_ADD:
 945           v = v1 + v2;
 946           break;
 947
 948         case BINOP_SUB:
 949           v = v1 - v2;
 950           break;
 951
 952         case BINOP_MUL:
 953           v = v1 * v2;
 954           break;
 955
 956         case BINOP_DIV:
 957           v = v1 / v2;
 958           break;
 959
 960         case BINOP_EXP:
 961           errno = 0;
 962           v = pow (v1, v2);
 963           if (errno)
 964             error (_("Cannot perform exponentiation: %s"), safe_strerror (errno));
 965           break;
 966
 967         case BINOP_MIN:
 968           v = v1 < v2 ? v1 : v2;
 969           break;
 970
 971         case BINOP_MAX:
 972           v = v1 > v2 ? v1 : v2;
 973           break;
 974
 975         default:
 976           error (_("Integer-only operation on floating point number."));
 977         }
 978
 979       /* If only one type is float, use its type.
 980          Otherwise use the bigger type.  */
 981       if (TYPE_CODE (type1) != TYPE_CODE_FLT)
 982         result_type = type2;
 983       else if (TYPE_CODE (type2) != TYPE_CODE_FLT)
 984         result_type = type1;
 985       else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
 986         result_type = type2;
 987       else
 988         result_type = type1;
 989
 990       val = allocate_value (result_type);
 991       store_typed_floating (value_contents_raw (val), value_type (val), v);
 992     }
 993   else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
 994            || TYPE_CODE (type2) == TYPE_CODE_BOOL)
 995     {
 996       LONGEST v1, v2, v = 0;
 997
 998       v1 = value_as_long (arg1);
 999       v2 = value_as_long (arg2);
1000
1001       switch (op)
1002         {
1003         case BINOP_BITWISE_AND:
1004           v = v1 & v2;
1005           break;
1006
1007         case BINOP_BITWISE_IOR:
1008           v = v1 | v2;
1009           break;
1010
1011         case BINOP_BITWISE_XOR:
1012           v = v1 ^ v2;
1013           break;
1014
1015         case BINOP_EQUAL:
1016           v = v1 == v2;
1017           break;
1018
1019         case BINOP_NOTEQUAL:
1020           v = v1 != v2;
1021           break;
1022
1023         default:
1024           error (_("Invalid operation on booleans."));
1025         }
1026
1027       result_type = type1;
1028
1029       val = allocate_value (result_type);
1030       store_signed_integer (value_contents_raw (val),
1031                             TYPE_LENGTH (result_type),
1032                             gdbarch_byte_order (get_type_arch (result_type)),
1033                             v);
1034     }
1035   else
1036     /* Integral operations here.  */
1037     {
1038       /* Determine type length of the result, and if the operation should
1039          be done unsigned.  For exponentiation and shift operators,
1040          use the length and type of the left operand.  Otherwise,
1041          use the signedness of the operand with the greater length.
1042          If both operands are of equal length, use unsigned operation
1043          if one of the operands is unsigned.  */
1044       if (op == BINOP_RSH || op == BINOP_LSH || op == BINOP_EXP)
1045         result_type = type1;
1046       else if (TYPE_LENGTH (type1) > TYPE_LENGTH (type2))
1047         result_type = type1;
1048       else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
1049         result_type = type2;
1050       else if (TYPE_UNSIGNED (type1))
1051         result_type = type1;
1052       else if (TYPE_UNSIGNED (type2))
1053         result_type = type2;
1054       else
1055         result_type = type1;
1056
1057       if (TYPE_UNSIGNED (result_type))
1058         {
1059           LONGEST v2_signed = value_as_long (arg2);
1060           ULONGEST v1, v2, v = 0;
1061
1062           v1 = (ULONGEST) value_as_long (arg1);
1063           v2 = (ULONGEST) v2_signed;
1064
1065           switch (op)
1066             {
1067             case BINOP_ADD:
1068               v = v1 + v2;
1069               break;
1070
1071             case BINOP_SUB:
1072               v = v1 - v2;
1073               break;
1074
1075             case BINOP_MUL:
1076               v = v1 * v2;
1077               break;
1078
1079             case BINOP_DIV:
1080             case BINOP_INTDIV:
1081               if (v2 != 0)
1082                 v = v1 / v2;
1083               else
1084                 error (_("Division by zero"));
1085               break;
1086
1087             case BINOP_EXP:
1088               v = uinteger_pow (v1, v2_signed);
1089               break;
1090
1091             case BINOP_REM:
1092               if (v2 != 0)
1093                 v = v1 % v2;
1094               else
1095                 error (_("Division by zero"));
1096               break;
1097
1098             case BINOP_MOD:
1099               /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
1100                  v1 mod 0 has a defined value, v1. */
1101               if (v2 == 0)
1102                 {
1103                   v = v1;
1104                 }
1105               else
1106                 {
1107                   v = v1 / v2;
1108                   /* Note floor(v1/v2) == v1/v2 for unsigned. */
1109                   v = v1 - (v2 * v);
1110                 }
1111               break;
1112
1113             case BINOP_LSH:
1114               v = v1 << v2;
1115               break;
1116
1117             case BINOP_RSH:
1118               v = v1 >> v2;
1119               break;
1120
1121             case BINOP_BITWISE_AND:
1122               v = v1 & v2;
1123               break;
1124
1125             case BINOP_BITWISE_IOR:
1126               v = v1 | v2;
1127               break;
1128
1129             case BINOP_BITWISE_XOR:
1130               v = v1 ^ v2;
1131               break;
1132
1133             case BINOP_LOGICAL_AND:
1134               v = v1 && v2;
1135               break;
1136
1137             case BINOP_LOGICAL_OR:
1138               v = v1 || v2;
1139               break;
1140
1141             case BINOP_MIN:
1142               v = v1 < v2 ? v1 : v2;
1143               break;
1144
1145             case BINOP_MAX:
1146               v = v1 > v2 ? v1 : v2;
1147               break;
1148
1149             case BINOP_EQUAL:
1150               v = v1 == v2;
1151               break;
1152
1153             case BINOP_NOTEQUAL:
1154               v = v1 != v2;
1155               break;
1156
1157             case BINOP_LESS:
1158               v = v1 < v2;
1159               break;
1160
1161             case BINOP_GTR:
1162               v = v1 > v2;
1163               break;
1164
1165             case BINOP_LEQ:
1166               v = v1 <= v2;
1167               break;
1168
1169             case BINOP_GEQ:
1170               v = v1 >= v2;
1171               break;
1172
1173             default:
1174               error (_("Invalid binary operation on numbers."));
1175             }
1176
1177           val = allocate_value (result_type);
1178           store_unsigned_integer (value_contents_raw (val),
1179                                   TYPE_LENGTH (value_type (val)),
1180                                   gdbarch_byte_order
1181                                     (get_type_arch (result_type)),
1182                                   v);
1183         }
1184       else
1185         {
1186           LONGEST v1, v2, v = 0;
1187
1188           v1 = value_as_long (arg1);
1189           v2 = value_as_long (arg2);
1190
1191           switch (op)
1192             {
1193             case BINOP_ADD:
1194               v = v1 + v2;
1195               break;
1196
1197             case BINOP_SUB:
1198               v = v1 - v2;
1199               break;
1200
1201             case BINOP_MUL:
1202               v = v1 * v2;
1203               break;
1204
1205             case BINOP_DIV:
1206             case BINOP_INTDIV:
1207               if (v2 != 0)
1208                 v = v1 / v2;
1209               else
1210                 error (_("Division by zero"));
1211               break;
1212
1213             case BINOP_EXP:
1214               v = integer_pow (v1, v2);
1215               break;
1216
1217             case BINOP_REM:
1218               if (v2 != 0)
1219                 v = v1 % v2;
1220               else
1221                 error (_("Division by zero"));
1222               break;
1223
1224             case BINOP_MOD:
1225               /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
1226                  X mod 0 has a defined value, X. */
1227               if (v2 == 0)
1228                 {
1229                   v = v1;
1230                 }
1231               else
1232                 {
1233                   v = v1 / v2;
1234                   /* Compute floor. */
1235                   if (TRUNCATION_TOWARDS_ZERO && (v < 0) && ((v1 % v2) != 0))
1236                     {
1237                       v--;
1238                     }
1239                   v = v1 - (v2 * v);
1240                 }
1241               break;
1242
1243             case BINOP_LSH:
1244               v = v1 << v2;
1245               break;
1246
1247             case BINOP_RSH:
1248               v = v1 >> v2;
1249               break;
1250
1251             case BINOP_BITWISE_AND:
1252               v = v1 & v2;
1253               break;
1254
1255             case BINOP_BITWISE_IOR:
1256               v = v1 | v2;
1257               break;
1258
1259             case BINOP_BITWISE_XOR:
1260               v = v1 ^ v2;
1261               break;
1262
1263             case BINOP_LOGICAL_AND:
1264               v = v1 && v2;
1265               break;
1266
1267             case BINOP_LOGICAL_OR:
1268               v = v1 || v2;
1269               break;
1270
1271             case BINOP_MIN:
1272               v = v1 < v2 ? v1 : v2;
1273               break;
1274
1275             case BINOP_MAX:
1276               v = v1 > v2 ? v1 : v2;
1277               break;
1278
1279             case BINOP_EQUAL:
1280               v = v1 == v2;
1281               break;
1282
1283             case BINOP_NOTEQUAL:
1284               v = v1 != v2;
1285               break;
1286
1287             case BINOP_LESS:
1288               v = v1 < v2;
1289               break;
1290
1291             case BINOP_GTR:
1292               v = v1 > v2;
1293               break;
1294
1295             case BINOP_LEQ:
1296               v = v1 <= v2;
1297               break;
1298
1299             case BINOP_GEQ:
1300               v = v1 >= v2;
1301               break;
1302
1303             default:
1304               error (_("Invalid binary operation on numbers."));
1305             }
1306
1307           val = allocate_value (result_type);
1308           store_signed_integer (value_contents_raw (val),
1309                                 TYPE_LENGTH (value_type (val)),
1310                                 gdbarch_byte_order
1311                                   (get_type_arch (result_type)),
1312                                 v);
1313         }
1314     }
1315
1316   return val;
1317 }
1318 \f
1319 /* Simulate the C operator ! -- return 1 if ARG1 contains zero.  */
1320
1321 int
1322 value_logical_not (struct value *arg1)
1323 {
1324   int len;
1325   const gdb_byte *p;
1326   struct type *type1;
1327
1328   arg1 = coerce_array (arg1);
1329   type1 = check_typedef (value_type (arg1));
1330
1331   if (TYPE_CODE (type1) == TYPE_CODE_FLT)
1332     return 0 == value_as_double (arg1);
1333   else if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
1334     return decimal_is_zero (value_contents (arg1), TYPE_LENGTH (type1),
1335                             gdbarch_byte_order (get_type_arch (type1)));
1336
1337   len = TYPE_LENGTH (type1);
1338   p = value_contents (arg1);
1339
1340   while (--len >= 0)
1341     {
1342       if (*p++)
1343         break;
1344     }
1345
1346   return len < 0;
1347 }
1348
1349 /* Perform a comparison on two string values (whose content are not
1350    necessarily null terminated) based on their length */
1351
1352 static int
1353 value_strcmp (struct value *arg1, struct value *arg2)
1354 {
1355   int len1 = TYPE_LENGTH (value_type (arg1));
1356   int len2 = TYPE_LENGTH (value_type (arg2));
1357   const gdb_byte *s1 = value_contents (arg1);
1358   const gdb_byte *s2 = value_contents (arg2);
1359   int i, len = len1 < len2 ? len1 : len2;
1360
1361   for (i = 0; i < len; i++)
1362     {
1363       if (s1[i] < s2[i])
1364         return -1;
1365       else if (s1[i] > s2[i])
1366         return 1;
1367       else
1368         continue;
1369     }
1370
1371   if (len1 < len2)
1372     return -1;
1373   else if (len1 > len2)
1374     return 1;
1375   else
1376     return 0;
1377 }
1378
1379 /* Simulate the C operator == by returning a 1
1380    iff ARG1 and ARG2 have equal contents.  */
1381
1382 int
1383 value_equal (struct value *arg1, struct value *arg2)
1384 {
1385   int len;
1386   const gdb_byte *p1;
1387   const gdb_byte *p2;
1388   struct type *type1, *type2;
1389   enum type_code code1;
1390   enum type_code code2;
1391   int is_int1, is_int2;
1392
1393   arg1 = coerce_array (arg1);
1394   arg2 = coerce_array (arg2);
1395
1396   type1 = check_typedef (value_type (arg1));
1397   type2 = check_typedef (value_type (arg2));
1398   code1 = TYPE_CODE (type1);
1399   code2 = TYPE_CODE (type2);
1400   is_int1 = is_integral_type (type1);
1401   is_int2 = is_integral_type (type2);
1402
1403   if (is_int1 && is_int2)
1404     return longest_to_int (value_as_long (value_binop (arg1, arg2,
1405                                                        BINOP_EQUAL)));
1406   else if ((code1 == TYPE_CODE_FLT || is_int1)
1407            && (code2 == TYPE_CODE_FLT || is_int2))
1408     {
1409       /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1410          `long double' values are returned in static storage (m68k).  */
1411       DOUBLEST d = value_as_double (arg1);
1412
1413       return d == value_as_double (arg2);
1414     }
1415   else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
1416            && (code2 == TYPE_CODE_DECFLOAT || is_int2))
1417     {
1418       gdb_byte v1[16], v2[16];
1419       int len_v1, len_v2;
1420       enum bfd_endian byte_order_v1, byte_order_v2;
1421
1422       value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
1423                                          v2, &len_v2, &byte_order_v2);
1424
1425       return decimal_compare (v1, len_v1, byte_order_v1,
1426                               v2, len_v2, byte_order_v2) == 0;
1427     }
1428
1429   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1430      is bigger.  */
1431   else if (code1 == TYPE_CODE_PTR && is_int2)
1432     return value_as_address (arg1) == (CORE_ADDR) value_as_long (arg2);
1433   else if (code2 == TYPE_CODE_PTR && is_int1)
1434     return (CORE_ADDR) value_as_long (arg1) == value_as_address (arg2);
1435
1436   else if (code1 == code2
1437            && ((len = (int) TYPE_LENGTH (type1))
1438                == (int) TYPE_LENGTH (type2)))
1439     {
1440       p1 = value_contents (arg1);
1441       p2 = value_contents (arg2);
1442       while (--len >= 0)
1443         {
1444           if (*p1++ != *p2++)
1445             break;
1446         }
1447       return len < 0;
1448     }
1449   else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1450     {
1451       return value_strcmp (arg1, arg2) == 0;
1452     }
1453   else
1454     {
1455       error (_("Invalid type combination in equality test."));
1456       return 0;                 /* For lint -- never reached */
1457     }
1458 }
1459
1460 /* Compare values based on their raw contents.  Useful for arrays since
1461    value_equal coerces them to pointers, thus comparing just the address
1462    of the array instead of its contents.  */
1463
1464 int
1465 value_equal_contents (struct value *arg1, struct value *arg2)
1466 {
1467   struct type *type1, *type2;
1468
1469   type1 = check_typedef (value_type (arg1));
1470   type2 = check_typedef (value_type (arg2));
1471
1472   return (TYPE_CODE (type1) == TYPE_CODE (type2)
1473           && TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
1474           && memcmp (value_contents (arg1), value_contents (arg2),
1475                      TYPE_LENGTH (type1)) == 0);
1476 }
1477
1478 /* Simulate the C operator < by returning 1
1479    iff ARG1's contents are less than ARG2's.  */
1480
1481 int
1482 value_less (struct value *arg1, struct value *arg2)
1483 {
1484   enum type_code code1;
1485   enum type_code code2;
1486   struct type *type1, *type2;
1487   int is_int1, is_int2;
1488
1489   arg1 = coerce_array (arg1);
1490   arg2 = coerce_array (arg2);
1491
1492   type1 = check_typedef (value_type (arg1));
1493   type2 = check_typedef (value_type (arg2));
1494   code1 = TYPE_CODE (type1);
1495   code2 = TYPE_CODE (type2);
1496   is_int1 = is_integral_type (type1);
1497   is_int2 = is_integral_type (type2);
1498
1499   if (is_int1 && is_int2)
1500     return longest_to_int (value_as_long (value_binop (arg1, arg2,
1501                                                        BINOP_LESS)));
1502   else if ((code1 == TYPE_CODE_FLT || is_int1)
1503            && (code2 == TYPE_CODE_FLT || is_int2))
1504     {
1505       /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1506          `long double' values are returned in static storage (m68k).  */
1507       DOUBLEST d = value_as_double (arg1);
1508
1509       return d < value_as_double (arg2);
1510     }
1511   else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
1512            && (code2 == TYPE_CODE_DECFLOAT || is_int2))
1513     {
1514       gdb_byte v1[16], v2[16];
1515       int len_v1, len_v2;
1516       enum bfd_endian byte_order_v1, byte_order_v2;
1517
1518       value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
1519                                          v2, &len_v2, &byte_order_v2);
1520
1521       return decimal_compare (v1, len_v1, byte_order_v1,
1522                               v2, len_v2, byte_order_v2) == -1;
1523     }
1524   else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
1525     return value_as_address (arg1) < value_as_address (arg2);
1526
1527   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1528      is bigger.  */
1529   else if (code1 == TYPE_CODE_PTR && is_int2)
1530     return value_as_address (arg1) < (CORE_ADDR) value_as_long (arg2);
1531   else if (code2 == TYPE_CODE_PTR && is_int1)
1532     return (CORE_ADDR) value_as_long (arg1) < value_as_address (arg2);
1533   else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1534     return value_strcmp (arg1, arg2) < 0;
1535   else
1536     {
1537       error (_("Invalid type combination in ordering comparison."));
1538       return 0;
1539     }
1540 }
1541 \f
1542 /* The unary operators +, - and ~.  They free the argument ARG1.  */
1543
1544 struct value *
1545 value_pos (struct value *arg1)
1546 {
1547   struct type *type;
1548
1549   arg1 = coerce_ref (arg1);
1550   type = check_typedef (value_type (arg1));
1551
1552   if (TYPE_CODE (type) == TYPE_CODE_FLT)
1553     return value_from_double (type, value_as_double (arg1));
1554   else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
1555     return value_from_decfloat (type, value_contents (arg1));
1556   else if (is_integral_type (type))
1557     {
1558       return value_from_longest (type, value_as_long (arg1));
1559     }
1560   else
1561     {
1562       error ("Argument to positive operation not a number.");
1563       return 0;                 /* For lint -- never reached */
1564     }
1565 }
1566
1567 struct value *
1568 value_neg (struct value *arg1)
1569 {
1570   struct type *type;
1571
1572   arg1 = coerce_ref (arg1);
1573   type = check_typedef (value_type (arg1));
1574
1575   if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
1576     {
1577       struct value *val = allocate_value (type);
1578       int len = TYPE_LENGTH (type);
1579       gdb_byte decbytes[16];  /* a decfloat is at most 128 bits long */
1580
1581       memcpy (decbytes, value_contents (arg1), len);
1582
1583       if (gdbarch_byte_order (get_type_arch (type)) == BFD_ENDIAN_LITTLE)
1584         decbytes[len-1] = decbytes[len - 1] | 0x80;
1585       else
1586         decbytes[0] = decbytes[0] | 0x80;
1587
1588       memcpy (value_contents_raw (val), decbytes, len);
1589       return val;
1590     }
1591   else if (TYPE_CODE (type) == TYPE_CODE_FLT)
1592     return value_from_double (type, -value_as_double (arg1));
1593   else if (is_integral_type (type))
1594     {
1595       return value_from_longest (type, -value_as_long (arg1));
1596     }
1597   else
1598     {
1599       error (_("Argument to negate operation not a number."));
1600       return 0;                 /* For lint -- never reached */
1601     }
1602 }
1603
1604 struct value *
1605 value_complement (struct value *arg1)
1606 {
1607   struct type *type;
1608
1609   arg1 = coerce_ref (arg1);
1610   type = check_typedef (value_type (arg1));
1611
1612   if (!is_integral_type (type))
1613     error (_("Argument to complement operation not an integer or boolean."));
1614
1615   return value_from_longest (type, ~value_as_long (arg1));
1616 }
1617 \f
1618 /* The INDEX'th bit of SET value whose value_type is TYPE,
1619    and whose value_contents is valaddr.
1620    Return -1 if out of range, -2 other error. */
1621
1622 int
1623 value_bit_index (struct type *type, const gdb_byte *valaddr, int index)
1624 {
1625   struct gdbarch *gdbarch = get_type_arch (type);
1626   LONGEST low_bound, high_bound;
1627   LONGEST word;
1628   unsigned rel_index;
1629   struct type *range = TYPE_INDEX_TYPE (type);
1630
1631   if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
1632     return -2;
1633   if (index < low_bound || index > high_bound)
1634     return -1;
1635   rel_index = index - low_bound;
1636   word = extract_unsigned_integer (valaddr + (rel_index / TARGET_CHAR_BIT), 1,
1637                                    gdbarch_byte_order (gdbarch));
1638   rel_index %= TARGET_CHAR_BIT;
1639   if (gdbarch_bits_big_endian (gdbarch))
1640     rel_index = TARGET_CHAR_BIT - 1 - rel_index;
1641   return (word >> rel_index) & 1;
1642 }
1643
1644 int
1645 value_in (struct value *element, struct value *set)
1646 {
1647   int member;
1648   struct type *settype = check_typedef (value_type (set));
1649   struct type *eltype = check_typedef (value_type (element));
1650
1651   if (TYPE_CODE (eltype) == TYPE_CODE_RANGE)
1652     eltype = TYPE_TARGET_TYPE (eltype);
1653   if (TYPE_CODE (settype) != TYPE_CODE_SET)
1654     error (_("Second argument of 'IN' has wrong type"));
1655   if (TYPE_CODE (eltype) != TYPE_CODE_INT
1656       && TYPE_CODE (eltype) != TYPE_CODE_CHAR
1657       && TYPE_CODE (eltype) != TYPE_CODE_ENUM
1658       && TYPE_CODE (eltype) != TYPE_CODE_BOOL)
1659     error (_("First argument of 'IN' has wrong type"));
1660   member = value_bit_index (settype, value_contents (set),
1661                             value_as_long (element));
1662   if (member < 0)
1663     error (_("First argument of 'IN' not in range"));
1664   return member;
1665 }
1666
1667 void
1668 _initialize_valarith (void)
1669 {
1670 }