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