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               v = v1 / v2;
1039               break;
1040
1041             case BINOP_EXP:
1042               errno = 0;
1043               v = pow (v1, v2);
1044               if (errno)
1045                 error (_("Cannot perform exponentiation: %s"), safe_strerror (errno));
1046               break;
1047
1048             case BINOP_REM:
1049               v = v1 % v2;
1050               break;
1051
1052             case BINOP_MOD:
1053               /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
1054                  v1 mod 0 has a defined value, v1. */
1055               if (v2 == 0)
1056                 {
1057                   v = v1;
1058                 }
1059               else
1060                 {
1061                   v = v1 / v2;
1062                   /* Note floor(v1/v2) == v1/v2 for unsigned. */
1063                   v = v1 - (v2 * v);
1064                 }
1065               break;
1066
1067             case BINOP_LSH:
1068               v = v1 << v2;
1069               break;
1070
1071             case BINOP_RSH:
1072               v = v1 >> v2;
1073               break;
1074
1075             case BINOP_BITWISE_AND:
1076               v = v1 & v2;
1077               break;
1078
1079             case BINOP_BITWISE_IOR:
1080               v = v1 | v2;
1081               break;
1082
1083             case BINOP_BITWISE_XOR:
1084               v = v1 ^ v2;
1085               break;
1086
1087             case BINOP_LOGICAL_AND:
1088               v = v1 && v2;
1089               break;
1090
1091             case BINOP_LOGICAL_OR:
1092               v = v1 || v2;
1093               break;
1094
1095             case BINOP_MIN:
1096               v = v1 < v2 ? v1 : v2;
1097               break;
1098
1099             case BINOP_MAX:
1100               v = v1 > v2 ? v1 : v2;
1101               break;
1102
1103             case BINOP_EQUAL:
1104               v = v1 == v2;
1105               break;
1106
1107             case BINOP_NOTEQUAL:
1108               v = v1 != v2;
1109               break;
1110
1111             case BINOP_LESS:
1112               v = v1 < v2;
1113               break;
1114
1115             default:
1116               error (_("Invalid binary operation on numbers."));
1117             }
1118
1119           /* This is a kludge to get around the fact that we don't
1120              know how to determine the result type from the types of
1121              the operands.  (I'm not really sure how much we feel the
1122              need to duplicate the exact rules of the current
1123              language.  They can get really hairy.  But not to do so
1124              makes it hard to document just what we *do* do).  */
1125
1126           /* Can't just call init_type because we wouldn't know what
1127              name to give the type.  */
1128           val = allocate_value
1129             (result_len > gdbarch_long_bit (current_gdbarch) / HOST_CHAR_BIT
1130              ? builtin_type_unsigned_long_long
1131              : builtin_type_unsigned_long);
1132           store_unsigned_integer (value_contents_raw (val),
1133                                   TYPE_LENGTH (value_type (val)),
1134                                   v);
1135         }
1136       else
1137         {
1138           LONGEST v1, v2, v = 0;
1139           v1 = value_as_long (arg1);
1140           v2 = value_as_long (arg2);
1141
1142           switch (op)
1143             {
1144             case BINOP_ADD:
1145               v = v1 + v2;
1146               break;
1147
1148             case BINOP_SUB:
1149               v = v1 - v2;
1150               break;
1151
1152             case BINOP_MUL:
1153               v = v1 * v2;
1154               break;
1155
1156             case BINOP_DIV:
1157             case BINOP_INTDIV:
1158               if (v2 != 0)
1159                 v = v1 / v2;
1160               else
1161                 error (_("Division by zero"));
1162               break;
1163
1164             case BINOP_EXP:
1165               errno = 0;
1166               v = pow (v1, v2);
1167               if (errno)
1168                 error (_("Cannot perform exponentiation: %s"), safe_strerror (errno));
1169               break;
1170
1171             case BINOP_REM:
1172               if (v2 != 0)
1173                 v = v1 % v2;
1174               else
1175                 error (_("Division by zero"));
1176               break;
1177
1178             case BINOP_MOD:
1179               /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
1180                  X mod 0 has a defined value, X. */
1181               if (v2 == 0)
1182                 {
1183                   v = v1;
1184                 }
1185               else
1186                 {
1187                   v = v1 / v2;
1188                   /* Compute floor. */
1189                   if (TRUNCATION_TOWARDS_ZERO && (v < 0) && ((v1 % v2) != 0))
1190                     {
1191                       v--;
1192                     }
1193                   v = v1 - (v2 * v);
1194                 }
1195               break;
1196
1197             case BINOP_LSH:
1198               v = v1 << v2;
1199               break;
1200
1201             case BINOP_RSH:
1202               v = v1 >> v2;
1203               break;
1204
1205             case BINOP_BITWISE_AND:
1206               v = v1 & v2;
1207               break;
1208
1209             case BINOP_BITWISE_IOR:
1210               v = v1 | v2;
1211               break;
1212
1213             case BINOP_BITWISE_XOR:
1214               v = v1 ^ v2;
1215               break;
1216
1217             case BINOP_LOGICAL_AND:
1218               v = v1 && v2;
1219               break;
1220
1221             case BINOP_LOGICAL_OR:
1222               v = v1 || v2;
1223               break;
1224
1225             case BINOP_MIN:
1226               v = v1 < v2 ? v1 : v2;
1227               break;
1228
1229             case BINOP_MAX:
1230               v = v1 > v2 ? v1 : v2;
1231               break;
1232
1233             case BINOP_EQUAL:
1234               v = v1 == v2;
1235               break;
1236
1237             case BINOP_LESS:
1238               v = v1 < v2;
1239               break;
1240
1241             default:
1242               error (_("Invalid binary operation on numbers."));
1243             }
1244
1245           /* This is a kludge to get around the fact that we don't
1246              know how to determine the result type from the types of
1247              the operands.  (I'm not really sure how much we feel the
1248              need to duplicate the exact rules of the current
1249              language.  They can get really hairy.  But not to do so
1250              makes it hard to document just what we *do* do).  */
1251
1252           /* Can't just call init_type because we wouldn't know what
1253              name to give the type.  */
1254           val = allocate_value
1255             (result_len > gdbarch_long_bit (current_gdbarch) / HOST_CHAR_BIT
1256              ? builtin_type_long_long
1257              : builtin_type_long);
1258           store_signed_integer (value_contents_raw (val),
1259                                 TYPE_LENGTH (value_type (val)),
1260                                 v);
1261         }
1262     }
1263
1264   return val;
1265 }
1266 \f
1267 /* Simulate the C operator ! -- return 1 if ARG1 contains zero.  */
1268
1269 int
1270 value_logical_not (struct value *arg1)
1271 {
1272   int len;
1273   const gdb_byte *p;
1274   struct type *type1;
1275
1276   arg1 = coerce_number (arg1);
1277   type1 = check_typedef (value_type (arg1));
1278
1279   if (TYPE_CODE (type1) == TYPE_CODE_FLT)
1280     return 0 == value_as_double (arg1);
1281   else if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
1282     return decimal_is_zero (value_contents (arg1), TYPE_LENGTH (type1));
1283
1284   len = TYPE_LENGTH (type1);
1285   p = value_contents (arg1);
1286
1287   while (--len >= 0)
1288     {
1289       if (*p++)
1290         break;
1291     }
1292
1293   return len < 0;
1294 }
1295
1296 /* Perform a comparison on two string values (whose content are not
1297    necessarily null terminated) based on their length */
1298
1299 static int
1300 value_strcmp (struct value *arg1, struct value *arg2)
1301 {
1302   int len1 = TYPE_LENGTH (value_type (arg1));
1303   int len2 = TYPE_LENGTH (value_type (arg2));
1304   const gdb_byte *s1 = value_contents (arg1);
1305   const gdb_byte *s2 = value_contents (arg2);
1306   int i, len = len1 < len2 ? len1 : len2;
1307
1308   for (i = 0; i < len; i++)
1309     {
1310       if (s1[i] < s2[i])
1311         return -1;
1312       else if (s1[i] > s2[i])
1313         return 1;
1314       else
1315         continue;
1316     }
1317
1318   if (len1 < len2)
1319     return -1;
1320   else if (len1 > len2)
1321     return 1;
1322   else
1323     return 0;
1324 }
1325
1326 /* Simulate the C operator == by returning a 1
1327    iff ARG1 and ARG2 have equal contents.  */
1328
1329 int
1330 value_equal (struct value *arg1, struct value *arg2)
1331 {
1332   int len;
1333   const gdb_byte *p1;
1334   const gdb_byte *p2;
1335   struct type *type1, *type2;
1336   enum type_code code1;
1337   enum type_code code2;
1338   int is_int1, is_int2;
1339
1340   arg1 = coerce_array (arg1);
1341   arg2 = coerce_array (arg2);
1342
1343   type1 = check_typedef (value_type (arg1));
1344   type2 = check_typedef (value_type (arg2));
1345   code1 = TYPE_CODE (type1);
1346   code2 = TYPE_CODE (type2);
1347   is_int1 = is_integral_type (type1);
1348   is_int2 = is_integral_type (type2);
1349
1350   if (is_int1 && is_int2)
1351     return longest_to_int (value_as_long (value_binop (arg1, arg2,
1352                                                        BINOP_EQUAL)));
1353   else if ((code1 == TYPE_CODE_FLT || is_int1)
1354            && (code2 == TYPE_CODE_FLT || is_int2))
1355     {
1356       /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1357          `long double' values are returned in static storage (m68k).  */
1358       DOUBLEST d = value_as_double (arg1);
1359       return d == value_as_double (arg2);
1360     }
1361   else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
1362            && (code2 == TYPE_CODE_DECFLOAT || is_int2))
1363     {
1364       gdb_byte v1[16], v2[16];
1365       int len_v1, len_v2;
1366
1367       value_args_as_decimal (arg1, arg2, v1, &len_v1, v2, &len_v2);
1368
1369       return decimal_compare (v1, len_v1, v2, len_v2) == 0;
1370     }
1371
1372   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1373      is bigger.  */
1374   else if (code1 == TYPE_CODE_PTR && is_int2)
1375     return value_as_address (arg1) == (CORE_ADDR) value_as_long (arg2);
1376   else if (code2 == TYPE_CODE_PTR && is_int1)
1377     return (CORE_ADDR) value_as_long (arg1) == value_as_address (arg2);
1378
1379   else if (code1 == code2
1380            && ((len = (int) TYPE_LENGTH (type1))
1381                == (int) TYPE_LENGTH (type2)))
1382     {
1383       p1 = value_contents (arg1);
1384       p2 = value_contents (arg2);
1385       while (--len >= 0)
1386         {
1387           if (*p1++ != *p2++)
1388             break;
1389         }
1390       return len < 0;
1391     }
1392   else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1393     {
1394       return value_strcmp (arg1, arg2) == 0;
1395     }
1396   else
1397     {
1398       error (_("Invalid type combination in equality test."));
1399       return 0;                 /* For lint -- never reached */
1400     }
1401 }
1402
1403 /* Simulate the C operator < by returning 1
1404    iff ARG1's contents are less than ARG2's.  */
1405
1406 int
1407 value_less (struct value *arg1, struct value *arg2)
1408 {
1409   enum type_code code1;
1410   enum type_code code2;
1411   struct type *type1, *type2;
1412   int is_int1, is_int2;
1413
1414   arg1 = coerce_array (arg1);
1415   arg2 = coerce_array (arg2);
1416
1417   type1 = check_typedef (value_type (arg1));
1418   type2 = check_typedef (value_type (arg2));
1419   code1 = TYPE_CODE (type1);
1420   code2 = TYPE_CODE (type2);
1421   is_int1 = is_integral_type (type1);
1422   is_int2 = is_integral_type (type2);
1423
1424   if (is_int1 && is_int2)
1425     return longest_to_int (value_as_long (value_binop (arg1, arg2,
1426                                                        BINOP_LESS)));
1427   else if ((code1 == TYPE_CODE_FLT || is_int1)
1428            && (code2 == TYPE_CODE_FLT || is_int2))
1429     {
1430       /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1431          `long double' values are returned in static storage (m68k).  */
1432       DOUBLEST d = value_as_double (arg1);
1433       return d < value_as_double (arg2);
1434     }
1435   else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
1436            && (code2 == TYPE_CODE_DECFLOAT || is_int2))
1437     {
1438       gdb_byte v1[16], v2[16];
1439       int len_v1, len_v2;
1440
1441       value_args_as_decimal (arg1, arg2, v1, &len_v1, v2, &len_v2);
1442
1443       return decimal_compare (v1, len_v1, v2, len_v2) == -1;
1444     }
1445   else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
1446     return value_as_address (arg1) < value_as_address (arg2);
1447
1448   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1449      is bigger.  */
1450   else if (code1 == TYPE_CODE_PTR && is_int2)
1451     return value_as_address (arg1) < (CORE_ADDR) value_as_long (arg2);
1452   else if (code2 == TYPE_CODE_PTR && is_int1)
1453     return (CORE_ADDR) value_as_long (arg1) < value_as_address (arg2);
1454   else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1455     return value_strcmp (arg1, arg2) < 0;
1456   else
1457     {
1458       error (_("Invalid type combination in ordering comparison."));
1459       return 0;
1460     }
1461 }
1462 \f
1463 /* The unary operators +, - and ~.  They free the argument ARG1.  */
1464
1465 struct value *
1466 value_pos (struct value *arg1)
1467 {
1468   struct type *type;
1469
1470   arg1 = coerce_ref (arg1);
1471
1472   type = check_typedef (value_type (arg1));
1473
1474   if (TYPE_CODE (type) == TYPE_CODE_FLT)
1475     return value_from_double (type, value_as_double (arg1));
1476   else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
1477     return value_from_decfloat (type, value_contents (arg1));
1478   else if (is_integral_type (type))
1479     {
1480       /* Perform integral promotion for ANSI C/C++.  FIXME: What about
1481          FORTRAN and (the deleted) chill ?  */
1482       if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1483         type = builtin_type_int;
1484
1485       return value_from_longest (type, value_as_long (arg1));
1486     }
1487   else
1488     {
1489       error ("Argument to positive operation not a number.");
1490       return 0;                 /* For lint -- never reached */
1491     }
1492 }
1493
1494 struct value *
1495 value_neg (struct value *arg1)
1496 {
1497   struct type *type;
1498   struct type *result_type = value_type (arg1);
1499
1500   arg1 = coerce_ref (arg1);
1501
1502   type = check_typedef (value_type (arg1));
1503
1504   if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
1505     {
1506       struct value *val = allocate_value (result_type);
1507       int len = TYPE_LENGTH (type);
1508       gdb_byte decbytes[16];  /* a decfloat is at most 128 bits long */
1509
1510       memcpy (decbytes, value_contents (arg1), len);
1511
1512       if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
1513         decbytes[len-1] = decbytes[len - 1] | 0x80;
1514       else
1515         decbytes[0] = decbytes[0] | 0x80;
1516
1517       memcpy (value_contents_raw (val), decbytes, len);
1518       return val;
1519     }
1520
1521   if (TYPE_CODE (type) == TYPE_CODE_FLT)
1522     return value_from_double (result_type, -value_as_double (arg1));
1523   else if (is_integral_type (type))
1524     {
1525       /* Perform integral promotion for ANSI C/C++.  FIXME: What about
1526          FORTRAN and (the deleted) chill ?  */
1527       if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1528         result_type = builtin_type_int;
1529
1530       return value_from_longest (result_type, -value_as_long (arg1));
1531     }
1532   else
1533     {
1534       error (_("Argument to negate operation not a number."));
1535       return 0;                 /* For lint -- never reached */
1536     }
1537 }
1538
1539 struct value *
1540 value_complement (struct value *arg1)
1541 {
1542   struct type *type;
1543   struct type *result_type = value_type (arg1);
1544
1545   arg1 = coerce_ref (arg1);
1546
1547   type = check_typedef (value_type (arg1));
1548
1549   if (!is_integral_type (type))
1550     error (_("Argument to complement operation not an integer or boolean."));
1551
1552   /* Perform integral promotion for ANSI C/C++.
1553      FIXME: What about FORTRAN ?  */
1554   if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1555     result_type = builtin_type_int;
1556
1557   return value_from_longest (result_type, ~value_as_long (arg1));
1558 }
1559 \f
1560 /* The INDEX'th bit of SET value whose value_type is TYPE,
1561    and whose value_contents is valaddr.
1562    Return -1 if out of range, -2 other error. */
1563
1564 int
1565 value_bit_index (struct type *type, const gdb_byte *valaddr, int index)
1566 {
1567   LONGEST low_bound, high_bound;
1568   LONGEST word;
1569   unsigned rel_index;
1570   struct type *range = TYPE_FIELD_TYPE (type, 0);
1571   if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
1572     return -2;
1573   if (index < low_bound || index > high_bound)
1574     return -1;
1575   rel_index = index - low_bound;
1576   word = unpack_long (builtin_type_unsigned_char,
1577                       valaddr + (rel_index / TARGET_CHAR_BIT));
1578   rel_index %= TARGET_CHAR_BIT;
1579   if (gdbarch_bits_big_endian (current_gdbarch))
1580     rel_index = TARGET_CHAR_BIT - 1 - rel_index;
1581   return (word >> rel_index) & 1;
1582 }
1583
1584 struct value *
1585 value_in (struct value *element, struct value *set)
1586 {
1587   int member;
1588   struct type *settype = check_typedef (value_type (set));
1589   struct type *eltype = check_typedef (value_type (element));
1590   if (TYPE_CODE (eltype) == TYPE_CODE_RANGE)
1591     eltype = TYPE_TARGET_TYPE (eltype);
1592   if (TYPE_CODE (settype) != TYPE_CODE_SET)
1593     error (_("Second argument of 'IN' has wrong type"));
1594   if (TYPE_CODE (eltype) != TYPE_CODE_INT
1595       && TYPE_CODE (eltype) != TYPE_CODE_CHAR
1596       && TYPE_CODE (eltype) != TYPE_CODE_ENUM
1597       && TYPE_CODE (eltype) != TYPE_CODE_BOOL)
1598     error (_("First argument of 'IN' has wrong type"));
1599   member = value_bit_index (settype, value_contents (set),
1600                             value_as_long (element));
1601   if (member < 0)
1602     error (_("First argument of 'IN' not in range"));
1603   return value_from_longest (LA_BOOL_TYPE, member);
1604 }
1605
1606 void
1607 _initialize_valarith (void)
1608 {
1609 }