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