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