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