gdb/valarith.c

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