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