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