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