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