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, 2011 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 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   struct value *result;
  93
  94   arg1 = coerce_array (arg1);
  95   valptrtype = check_typedef (value_type (arg1));
  96   sz = find_size_for_pointer_math (valptrtype);
  97
  98   result = value_from_pointer (valptrtype,
  99                                value_as_address (arg1) + sz * arg2);
 100   if (VALUE_LVAL (result) != lval_internalvar)
 101     set_value_component_location (result, arg1);
 102   return result;
 103 }
 104
 105 /* Given two compatible pointer values ARG1 and ARG2, return the
 106    result of C-style pointer arithmetic ARG1 - ARG2.  */
 107
 108 LONGEST
 109 value_ptrdiff (struct value *arg1, struct value *arg2)
 110 {
 111   struct type *type1, *type2;
 112   LONGEST sz;
 113
 114   arg1 = coerce_array (arg1);
 115   arg2 = coerce_array (arg2);
 116   type1 = check_typedef (value_type (arg1));
 117   type2 = check_typedef (value_type (arg2));
 118
 119   gdb_assert (TYPE_CODE (type1) == TYPE_CODE_PTR);
 120   gdb_assert (TYPE_CODE (type2) == TYPE_CODE_PTR);
 121
 122   if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)))
 123       != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2))))
 124     error (_("First argument of `-' is a pointer and "
 125              "second argument is neither\n"
 126              "an integer nor a pointer of the same type."));
 127
 128   sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
 129   if (sz == 0)
 130     {
 131       warning (_("Type size unknown, assuming 1. "
 132                "Try casting to a known type, or void *."));
 133       sz = 1;
 134     }
 135
 136   return (value_as_long (arg1) - value_as_long (arg2)) / sz;
 137 }
 138
 139 /* Return the value of ARRAY[IDX].
 140
 141    ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING.  If the
 142    current language supports C-style arrays, it may also be TYPE_CODE_PTR.
 143    To access TYPE_CODE_BITSTRING values, use value_bitstring_subscript.
 144
 145    See comments in value_coerce_array() for rationale for reason for
 146    doing lower bounds adjustment here rather than there.
 147    FIXME:  Perhaps we should validate that the index is valid and if
 148    verbosity is set, warn about invalid indices (but still use them).  */
 149
 150 struct value *
 151 value_subscript (struct value *array, LONGEST index)
 152 {
 153   int c_style = current_language->c_style_arrays;
 154   struct type *tarray;
 155
 156   array = coerce_ref (array);
 157   tarray = check_typedef (value_type (array));
 158
 159   if (TYPE_CODE (tarray) == TYPE_CODE_ARRAY
 160       || TYPE_CODE (tarray) == TYPE_CODE_STRING)
 161     {
 162       struct type *range_type = TYPE_INDEX_TYPE (tarray);
 163       LONGEST lowerbound, upperbound;
 164
 165       get_discrete_bounds (range_type, &lowerbound, &upperbound);
 166       if (VALUE_LVAL (array) != lval_memory)
 167         return value_subscripted_rvalue (array, index, lowerbound);
 168
 169       if (c_style == 0)
 170         {
 171           if (index >= lowerbound && index <= upperbound)
 172             return value_subscripted_rvalue (array, index, lowerbound);
 173           /* Emit warning unless we have an array of unknown size.
 174              An array of unknown size has lowerbound 0 and upperbound -1.  */
 175           if (upperbound > -1)
 176             warning (_("array or string index out of range"));
 177           /* fall doing C stuff */
 178           c_style = 1;
 179         }
 180
 181       index -= lowerbound;
 182       array = value_coerce_array (array);
 183     }
 184
 185   if (c_style)
 186     return value_ind (value_ptradd (array, index));
 187   else
 188     error (_("not an array or string"));
 189 }
 190
 191 /* Return the value of EXPR[IDX], expr an aggregate rvalue
 192    (eg, a vector register).  This routine used to promote floats
 193    to doubles, but no longer does.  */
 194
 195 struct value *
 196 value_subscripted_rvalue (struct value *array, LONGEST index, int lowerbound)
 197 {
 198   struct type *array_type = check_typedef (value_type (array));
 199   struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
 200   unsigned int elt_size = TYPE_LENGTH (elt_type);
 201   unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
 202   struct value *v;
 203
 204   if (index < lowerbound || (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type)
 205                              && elt_offs >= TYPE_LENGTH (array_type)))
 206     error (_("no such vector element"));
 207
 208   if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
 209     v = allocate_value_lazy (elt_type);
 210   else
 211     {
 212       v = allocate_value (elt_type);
 213       value_contents_copy (v, value_embedded_offset (v),
 214                            array, value_embedded_offset (array) + elt_offs,
 215                            elt_size);
 216     }
 217
 218   set_value_component_location (v, array);
 219   VALUE_REGNUM (v) = VALUE_REGNUM (array);
 220   VALUE_FRAME_ID (v) = VALUE_FRAME_ID (array);
 221   set_value_offset (v, value_offset (array) + elt_offs);
 222   return v;
 223 }
 224
 225 /* Return the value of BITSTRING[IDX] as (boolean) type TYPE.  */
 226
 227 struct value *
 228 value_bitstring_subscript (struct type *type,
 229                            struct value *bitstring, LONGEST index)
 230 {
 231
 232   struct type *bitstring_type, *range_type;
 233   struct value *v;
 234   int offset, byte, bit_index;
 235   LONGEST lowerbound, upperbound;
 236
 237   bitstring_type = check_typedef (value_type (bitstring));
 238   gdb_assert (TYPE_CODE (bitstring_type) == TYPE_CODE_BITSTRING);
 239
 240   range_type = TYPE_INDEX_TYPE (bitstring_type);
 241   get_discrete_bounds (range_type, &lowerbound, &upperbound);
 242   if (index < lowerbound || index > upperbound)
 243     error (_("bitstring index out of range"));
 244
 245   index -= lowerbound;
 246   offset = index / TARGET_CHAR_BIT;
 247   byte = *((char *) value_contents (bitstring) + offset);
 248
 249   bit_index = index % TARGET_CHAR_BIT;
 250   byte >>= (gdbarch_bits_big_endian (get_type_arch (bitstring_type)) ?
 251             TARGET_CHAR_BIT - 1 - bit_index : bit_index);
 252
 253   v = value_from_longest (type, byte & 1);
 254
 255   set_value_bitpos (v, bit_index);
 256   set_value_bitsize (v, 1);
 257   set_value_component_location (v, bitstring);
 258   VALUE_FRAME_ID (v) = VALUE_FRAME_ID (bitstring);
 259
 260   set_value_offset (v, offset + value_offset (bitstring));
 261
 262   return v;
 263 }
 264
 265 \f
 266 /* Check to see if either argument is a structure, or a reference to
 267    one.  This is called so we know whether to go ahead with the normal
 268    binop or look for a user defined function instead.
 269
 270    For now, we do not overload the `=' operator.  */
 271
 272 int
 273 binop_types_user_defined_p (enum exp_opcode op,
 274                             struct type *type1, struct type *type2)
 275 {
 276   if (op == BINOP_ASSIGN || op == BINOP_CONCAT)
 277     return 0;
 278
 279   type1 = check_typedef (type1);
 280   if (TYPE_CODE (type1) == TYPE_CODE_REF)
 281     type1 = check_typedef (TYPE_TARGET_TYPE (type1));
 282
 283   type2 = check_typedef (type1);
 284   if (TYPE_CODE (type2) == TYPE_CODE_REF)
 285     type2 = check_typedef (TYPE_TARGET_TYPE (type2));
 286
 287   return (TYPE_CODE (type1) == TYPE_CODE_STRUCT
 288           || TYPE_CODE (type2) == TYPE_CODE_STRUCT);
 289 }
 290
 291 /* Check to see if either argument is a structure, or a reference to
 292    one.  This is called so we know whether to go ahead with the normal
 293    binop or look for a user defined function instead.
 294
 295    For now, we do not overload the `=' operator.  */
 296
 297 int
 298 binop_user_defined_p (enum exp_opcode op,
 299                       struct value *arg1, struct value *arg2)
 300 {
 301   return binop_types_user_defined_p (op, value_type (arg1), value_type (arg2));
 302 }
 303
 304 /* Check to see if argument is a structure.  This is called so
 305    we know whether to go ahead with the normal unop or look for a
 306    user defined function instead.
 307
 308    For now, we do not overload the `&' operator.  */
 309
 310 int
 311 unop_user_defined_p (enum exp_opcode op, struct value *arg1)
 312 {
 313   struct type *type1;
 314
 315   if (op == UNOP_ADDR)
 316     return 0;
 317   type1 = check_typedef (value_type (arg1));
 318   if (TYPE_CODE (type1) == TYPE_CODE_REF)
 319     type1 = check_typedef (TYPE_TARGET_TYPE (type1));
 320   return TYPE_CODE (type1) == TYPE_CODE_STRUCT;
 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,
 543                                     argvec + 1);
 544     }
 545   throw_error (NOT_FOUND_ERROR,
 546                _("member function %s not found"), tstr);
 547 #ifdef lint
 548   return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
 549 #endif
 550 }
 551
 552 /* We know that arg1 is a structure, so try to find a unary user
 553    defined operator that matches the operator in question.
 554    Create an argument vector that calls arg1.operator @ (arg1)
 555    and return that value (where '@' is (almost) any unary operator which
 556    is legal for GNU C++).  */
 557
 558 struct value *
 559 value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
 560 {
 561   struct gdbarch *gdbarch = get_type_arch (value_type (arg1));
 562   struct value **argvec;
 563   char *ptr, *mangle_ptr;
 564   char tstr[13], mangle_tstr[13];
 565   int static_memfuncp, nargs;
 566
 567   arg1 = coerce_ref (arg1);
 568
 569   /* now we know that what we have to do is construct our
 570      arg vector and find the right function to call it with.  */
 571
 572   if (TYPE_CODE (check_typedef (value_type (arg1))) != TYPE_CODE_STRUCT)
 573     error (_("Can't do that unary op on that type"));   /* FIXME be explicit */
 574
 575   argvec = (struct value **) alloca (sizeof (struct value *) * 4);
 576   argvec[1] = value_addr (arg1);
 577   argvec[2] = 0;
 578
 579   nargs = 1;
 580
 581   /* Make the right function name up.  */
 582   strcpy (tstr, "operator__");
 583   ptr = tstr + 8;
 584   strcpy (mangle_tstr, "__");
 585   mangle_ptr = mangle_tstr + 2;
 586   switch (op)
 587     {
 588     case UNOP_PREINCREMENT:
 589       strcpy (ptr, "++");
 590       break;
 591     case UNOP_PREDECREMENT:
 592       strcpy (ptr, "--");
 593       break;
 594     case UNOP_POSTINCREMENT:
 595       strcpy (ptr, "++");
 596       argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
 597       argvec[3] = 0;
 598       nargs ++;
 599       break;
 600     case UNOP_POSTDECREMENT:
 601       strcpy (ptr, "--");
 602       argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
 603       argvec[3] = 0;
 604       nargs ++;
 605       break;
 606     case UNOP_LOGICAL_NOT:
 607       strcpy (ptr, "!");
 608       break;
 609     case UNOP_COMPLEMENT:
 610       strcpy (ptr, "~");
 611       break;
 612     case UNOP_NEG:
 613       strcpy (ptr, "-");
 614       break;
 615     case UNOP_PLUS:
 616       strcpy (ptr, "+");
 617       break;
 618     case UNOP_IND:
 619       strcpy (ptr, "*");
 620       break;
 621     case STRUCTOP_PTR:
 622       strcpy (ptr, "->");
 623       break;
 624     default:
 625       error (_("Invalid unary operation specified."));
 626     }
 627
 628   argvec[0] = value_user_defined_op (&arg1, argvec + 1, tstr,
 629                                      &static_memfuncp, nargs);
 630
 631   if (argvec[0])
 632     {
 633       if (static_memfuncp)
 634         {
 635           argvec[1] = argvec[0];
 636           nargs --;
 637           argvec++;
 638         }
 639       if (noside == EVAL_AVOID_SIDE_EFFECTS)
 640         {
 641           struct type *return_type;
 642
 643           return_type
 644             = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
 645           return value_zero (return_type, VALUE_LVAL (arg1));
 646         }
 647       return call_function_by_hand (argvec[0], nargs, argvec + 1);
 648     }
 649   throw_error (NOT_FOUND_ERROR,
 650                _("member function %s not found"), tstr);
 651
 652   return 0;                     /* For lint -- never reached */
 653 }
 654 \f
 655
 656 /* Concatenate two values with the following conditions:
 657
 658    (1)  Both values must be either bitstring values or character string
 659    values and the resulting value consists of the concatenation of
 660    ARG1 followed by ARG2.
 661
 662    or
 663
 664    One value must be an integer value and the other value must be
 665    either a bitstring value or character string value, which is
 666    to be repeated by the number of times specified by the integer
 667    value.
 668
 669
 670    (2)  Boolean values are also allowed and are treated as bit string
 671    values of length 1.
 672
 673    (3)  Character values are also allowed and are treated as character
 674    string values of length 1.  */
 675
 676 struct value *
 677 value_concat (struct value *arg1, struct value *arg2)
 678 {
 679   struct value *inval1;
 680   struct value *inval2;
 681   struct value *outval = NULL;
 682   int inval1len, inval2len;
 683   int count, idx;
 684   char *ptr;
 685   char inchar;
 686   struct type *type1 = check_typedef (value_type (arg1));
 687   struct type *type2 = check_typedef (value_type (arg2));
 688   struct type *char_type;
 689
 690   /* First figure out if we are dealing with two values to be concatenated
 691      or a repeat count and a value to be repeated.  INVAL1 is set to the
 692      first of two concatenated values, or the repeat count.  INVAL2 is set
 693      to the second of the two concatenated values or the value to be
 694      repeated.  */
 695
 696   if (TYPE_CODE (type2) == TYPE_CODE_INT)
 697     {
 698       struct type *tmp = type1;
 699
 700       type1 = tmp;
 701       tmp = type2;
 702       inval1 = arg2;
 703       inval2 = arg1;
 704     }
 705   else
 706     {
 707       inval1 = arg1;
 708       inval2 = arg2;
 709     }
 710
 711   /* Now process the input values.  */
 712
 713   if (TYPE_CODE (type1) == TYPE_CODE_INT)
 714     {
 715       /* We have a repeat count.  Validate the second value and then
 716          construct a value repeated that many times.  */
 717       if (TYPE_CODE (type2) == TYPE_CODE_STRING
 718           || TYPE_CODE (type2) == TYPE_CODE_CHAR)
 719         {
 720           count = longest_to_int (value_as_long (inval1));
 721           inval2len = TYPE_LENGTH (type2);
 722           ptr = (char *) alloca (count * inval2len);
 723           if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
 724             {
 725               char_type = type2;
 726
 727               inchar = (char) unpack_long (type2,
 728                                            value_contents (inval2));
 729               for (idx = 0; idx < count; idx++)
 730                 {
 731                   *(ptr + idx) = inchar;
 732                 }
 733             }
 734           else
 735             {
 736               char_type = TYPE_TARGET_TYPE (type2);
 737
 738               for (idx = 0; idx < count; idx++)
 739                 {
 740                   memcpy (ptr + (idx * inval2len), value_contents (inval2),
 741                           inval2len);
 742                 }
 743             }
 744           outval = value_string (ptr, count * inval2len, char_type);
 745         }
 746       else if (TYPE_CODE (type2) == TYPE_CODE_BITSTRING
 747                || TYPE_CODE (type2) == TYPE_CODE_BOOL)
 748         {
 749           error (_("unimplemented support for bitstring/boolean repeats"));
 750         }
 751       else
 752         {
 753           error (_("can't repeat values of that type"));
 754         }
 755     }
 756   else if (TYPE_CODE (type1) == TYPE_CODE_STRING
 757            || TYPE_CODE (type1) == TYPE_CODE_CHAR)
 758     {
 759       /* We have two character strings to concatenate.  */
 760       if (TYPE_CODE (type2) != TYPE_CODE_STRING
 761           && TYPE_CODE (type2) != TYPE_CODE_CHAR)
 762         {
 763           error (_("Strings can only be concatenated with other strings."));
 764         }
 765       inval1len = TYPE_LENGTH (type1);
 766       inval2len = TYPE_LENGTH (type2);
 767       ptr = (char *) alloca (inval1len + inval2len);
 768       if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
 769         {
 770           char_type = type1;
 771
 772           *ptr = (char) unpack_long (type1, value_contents (inval1));
 773         }
 774       else
 775         {
 776           char_type = TYPE_TARGET_TYPE (type1);
 777
 778           memcpy (ptr, value_contents (inval1), inval1len);
 779         }
 780       if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
 781         {
 782           *(ptr + inval1len) =
 783             (char) unpack_long (type2, value_contents (inval2));
 784         }
 785       else
 786         {
 787           memcpy (ptr + inval1len, value_contents (inval2), inval2len);
 788         }
 789       outval = value_string (ptr, inval1len + inval2len, char_type);
 790     }
 791   else if (TYPE_CODE (type1) == TYPE_CODE_BITSTRING
 792            || TYPE_CODE (type1) == TYPE_CODE_BOOL)
 793     {
 794       /* We have two bitstrings to concatenate.  */
 795       if (TYPE_CODE (type2) != TYPE_CODE_BITSTRING
 796           && TYPE_CODE (type2) != TYPE_CODE_BOOL)
 797         {
 798           error (_("Bitstrings or booleans can only be concatenated "
 799                    "with other bitstrings or booleans."));
 800         }
 801       error (_("unimplemented support for bitstring/boolean concatenation."));
 802     }
 803   else
 804     {
 805       /* We don't know how to concatenate these operands.  */
 806       error (_("illegal operands for concatenation."));
 807     }
 808   return (outval);
 809 }
 810 \f
 811 /* Integer exponentiation: V1**V2, where both arguments are
 812    integers.  Requires V1 != 0 if V2 < 0.  Returns 1 for 0 ** 0.  */
 813
 814 static LONGEST
 815 integer_pow (LONGEST v1, LONGEST v2)
 816 {
 817   if (v2 < 0)
 818     {
 819       if (v1 == 0)
 820         error (_("Attempt to raise 0 to negative power."));
 821       else
 822         return 0;
 823     }
 824   else
 825     {
 826       /* The Russian Peasant's Algorithm.  */
 827       LONGEST v;
 828
 829       v = 1;
 830       for (;;)
 831         {
 832           if (v2 & 1L)
 833             v *= v1;
 834           v2 >>= 1;
 835           if (v2 == 0)
 836             return v;
 837           v1 *= v1;
 838         }
 839     }
 840 }
 841
 842 /* Integer exponentiation: V1**V2, where both arguments are
 843    integers.  Requires V1 != 0 if V2 < 0.  Returns 1 for 0 ** 0.  */
 844
 845 static ULONGEST
 846 uinteger_pow (ULONGEST v1, LONGEST v2)
 847 {
 848   if (v2 < 0)
 849     {
 850       if (v1 == 0)
 851         error (_("Attempt to raise 0 to negative power."));
 852       else
 853         return 0;
 854     }
 855   else
 856     {
 857       /* The Russian Peasant's Algorithm.  */
 858       ULONGEST v;
 859
 860       v = 1;
 861       for (;;)
 862         {
 863           if (v2 & 1L)
 864             v *= v1;
 865           v2 >>= 1;
 866           if (v2 == 0)
 867             return v;
 868           v1 *= v1;
 869         }
 870     }
 871 }
 872
 873 /* Obtain decimal value of arguments for binary operation, converting from
 874    other types if one of them is not decimal floating point.  */
 875 static void
 876 value_args_as_decimal (struct value *arg1, struct value *arg2,
 877                        gdb_byte *x, int *len_x, enum bfd_endian *byte_order_x,
 878                        gdb_byte *y, int *len_y, enum bfd_endian *byte_order_y)
 879 {
 880   struct type *type1, *type2;
 881
 882   type1 = check_typedef (value_type (arg1));
 883   type2 = check_typedef (value_type (arg2));
 884
 885   /* At least one of the arguments must be of decimal float type.  */
 886   gdb_assert (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
 887               || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT);
 888
 889   if (TYPE_CODE (type1) == TYPE_CODE_FLT
 890       || TYPE_CODE (type2) == TYPE_CODE_FLT)
 891     /* The DFP extension to the C language does not allow mixing of
 892      * decimal float types with other float types in expressions
 893      * (see WDTR 24732, page 12).  */
 894     error (_("Mixing decimal floating types with "
 895              "other floating types is not allowed."));
 896
 897   /* Obtain decimal value of arg1, converting from other types
 898      if necessary.  */
 899
 900   if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
 901     {
 902       *byte_order_x = gdbarch_byte_order (get_type_arch (type1));
 903       *len_x = TYPE_LENGTH (type1);
 904       memcpy (x, value_contents (arg1), *len_x);
 905     }
 906   else if (is_integral_type (type1))
 907     {
 908       *byte_order_x = gdbarch_byte_order (get_type_arch (type2));
 909       *len_x = TYPE_LENGTH (type2);
 910       decimal_from_integral (arg1, x, *len_x, *byte_order_x);
 911     }
 912   else
 913     error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1),
 914              TYPE_NAME (type2));
 915
 916   /* Obtain decimal value of arg2, converting from other types
 917      if necessary.  */
 918
 919   if (TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
 920     {
 921       *byte_order_y = gdbarch_byte_order (get_type_arch (type2));
 922       *len_y = TYPE_LENGTH (type2);
 923       memcpy (y, value_contents (arg2), *len_y);
 924     }
 925   else if (is_integral_type (type2))
 926     {
 927       *byte_order_y = gdbarch_byte_order (get_type_arch (type1));
 928       *len_y = TYPE_LENGTH (type1);
 929       decimal_from_integral (arg2, y, *len_y, *byte_order_y);
 930     }
 931   else
 932     error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1),
 933              TYPE_NAME (type2));
 934 }
 935
 936 /* Perform a binary operation on two operands which have reasonable
 937    representations as integers or floats.  This includes booleans,
 938    characters, integers, or floats.
 939    Does not support addition and subtraction on pointers;
 940    use value_ptradd, value_ptrsub or value_ptrdiff for those operations.  */
 941
 942 static struct value *
 943 scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
 944 {
 945   struct value *val;
 946   struct type *type1, *type2, *result_type;
 947
 948   arg1 = coerce_ref (arg1);
 949   arg2 = coerce_ref (arg2);
 950
 951   type1 = check_typedef (value_type (arg1));
 952   type2 = check_typedef (value_type (arg2));
 953
 954   if ((TYPE_CODE (type1) != TYPE_CODE_FLT
 955        && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
 956        && !is_integral_type (type1))
 957       || (TYPE_CODE (type2) != TYPE_CODE_FLT
 958           && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
 959           && !is_integral_type (type2)))
 960     error (_("Argument to arithmetic operation not a number or boolean."));
 961
 962   if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
 963       || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
 964     {
 965       int len_v1, len_v2, len_v;
 966       enum bfd_endian byte_order_v1, byte_order_v2, byte_order_v;
 967       gdb_byte v1[16], v2[16];
 968       gdb_byte v[16];
 969
 970       /* If only one type is decimal float, use its type.
 971          Otherwise use the bigger type.  */
 972       if (TYPE_CODE (type1) != TYPE_CODE_DECFLOAT)
 973         result_type = type2;
 974       else if (TYPE_CODE (type2) != TYPE_CODE_DECFLOAT)
 975         result_type = type1;
 976       else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
 977         result_type = type2;
 978       else
 979         result_type = type1;
 980
 981       len_v = TYPE_LENGTH (result_type);
 982       byte_order_v = gdbarch_byte_order (get_type_arch (result_type));
 983
 984       value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
 985                                          v2, &len_v2, &byte_order_v2);
 986
 987       switch (op)
 988         {
 989         case BINOP_ADD:
 990         case BINOP_SUB:
 991         case BINOP_MUL:
 992         case BINOP_DIV:
 993         case BINOP_EXP:
 994           decimal_binop (op, v1, len_v1, byte_order_v1,
 995                              v2, len_v2, byte_order_v2,
 996                              v, len_v, byte_order_v);
 997           break;
 998
 999         default:
1000           error (_("Operation not valid for decimal floating point number."));
1001         }
1002
1003       val = value_from_decfloat (result_type, v);
1004     }
1005   else if (TYPE_CODE (type1) == TYPE_CODE_FLT
1006            || TYPE_CODE (type2) == TYPE_CODE_FLT)
1007     {
1008       /* FIXME-if-picky-about-floating-accuracy: Should be doing this
1009          in target format.  real.c in GCC probably has the necessary
1010          code.  */
1011       DOUBLEST v1, v2, v = 0;
1012
1013       v1 = value_as_double (arg1);
1014       v2 = value_as_double (arg2);
1015
1016       switch (op)
1017         {
1018         case BINOP_ADD:
1019           v = v1 + v2;
1020           break;
1021
1022         case BINOP_SUB:
1023           v = v1 - v2;
1024           break;
1025
1026         case BINOP_MUL:
1027           v = v1 * v2;
1028           break;
1029
1030         case BINOP_DIV:
1031           v = v1 / v2;
1032           break;
1033
1034         case BINOP_EXP:
1035           errno = 0;
1036           v = pow (v1, v2);
1037           if (errno)
1038             error (_("Cannot perform exponentiation: %s"),
1039                    safe_strerror (errno));
1040           break;
1041
1042         case BINOP_MIN:
1043           v = v1 < v2 ? v1 : v2;
1044           break;
1045
1046         case BINOP_MAX:
1047           v = v1 > v2 ? v1 : v2;
1048           break;
1049
1050         default:
1051           error (_("Integer-only operation on floating point number."));
1052         }
1053
1054       /* If only one type is float, use its type.
1055          Otherwise use the bigger type.  */
1056       if (TYPE_CODE (type1) != TYPE_CODE_FLT)
1057         result_type = type2;
1058       else if (TYPE_CODE (type2) != TYPE_CODE_FLT)
1059         result_type = type1;
1060       else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
1061         result_type = type2;
1062       else
1063         result_type = type1;
1064
1065       val = allocate_value (result_type);
1066       store_typed_floating (value_contents_raw (val), value_type (val), v);
1067     }
1068   else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
1069            || TYPE_CODE (type2) == TYPE_CODE_BOOL)
1070     {
1071       LONGEST v1, v2, v = 0;
1072
1073       v1 = value_as_long (arg1);
1074       v2 = value_as_long (arg2);
1075
1076       switch (op)
1077         {
1078         case BINOP_BITWISE_AND:
1079           v = v1 & v2;
1080           break;
1081
1082         case BINOP_BITWISE_IOR:
1083           v = v1 | v2;
1084           break;
1085
1086         case BINOP_BITWISE_XOR:
1087           v = v1 ^ v2;
1088           break;
1089
1090         case BINOP_EQUAL:
1091           v = v1 == v2;
1092           break;
1093
1094         case BINOP_NOTEQUAL:
1095           v = v1 != v2;
1096           break;
1097
1098         default:
1099           error (_("Invalid operation on booleans."));
1100         }
1101
1102       result_type = type1;
1103
1104       val = allocate_value (result_type);
1105       store_signed_integer (value_contents_raw (val),
1106                             TYPE_LENGTH (result_type),
1107                             gdbarch_byte_order (get_type_arch (result_type)),
1108                             v);
1109     }
1110   else
1111     /* Integral operations here.  */
1112     {
1113       /* Determine type length of the result, and if the operation should
1114          be done unsigned.  For exponentiation and shift operators,
1115          use the length and type of the left operand.  Otherwise,
1116          use the signedness of the operand with the greater length.
1117          If both operands are of equal length, use unsigned operation
1118          if one of the operands is unsigned.  */
1119       if (op == BINOP_RSH || op == BINOP_LSH || op == BINOP_EXP)
1120         result_type = type1;
1121       else if (TYPE_LENGTH (type1) > TYPE_LENGTH (type2))
1122         result_type = type1;
1123       else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
1124         result_type = type2;
1125       else if (TYPE_UNSIGNED (type1))
1126         result_type = type1;
1127       else if (TYPE_UNSIGNED (type2))
1128         result_type = type2;
1129       else
1130         result_type = type1;
1131
1132       if (TYPE_UNSIGNED (result_type))
1133         {
1134           LONGEST v2_signed = value_as_long (arg2);
1135           ULONGEST v1, v2, v = 0;
1136
1137           v1 = (ULONGEST) value_as_long (arg1);
1138           v2 = (ULONGEST) v2_signed;
1139
1140           switch (op)
1141             {
1142             case BINOP_ADD:
1143               v = v1 + v2;
1144               break;
1145
1146             case BINOP_SUB:
1147               v = v1 - v2;
1148               break;
1149
1150             case BINOP_MUL:
1151               v = v1 * v2;
1152               break;
1153
1154             case BINOP_DIV:
1155             case BINOP_INTDIV:
1156               if (v2 != 0)
1157                 v = v1 / v2;
1158               else
1159                 error (_("Division by zero"));
1160               break;
1161
1162             case BINOP_EXP:
1163               v = uinteger_pow (v1, v2_signed);
1164               break;
1165
1166             case BINOP_REM:
1167               if (v2 != 0)
1168                 v = v1 % v2;
1169               else
1170                 error (_("Division by zero"));
1171               break;
1172
1173             case BINOP_MOD:
1174               /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
1175                  v1 mod 0 has a defined value, v1.  */
1176               if (v2 == 0)
1177                 {
1178                   v = v1;
1179                 }
1180               else
1181                 {
1182                   v = v1 / v2;
1183                   /* Note floor(v1/v2) == v1/v2 for unsigned.  */
1184                   v = v1 - (v2 * v);
1185                 }
1186               break;
1187
1188             case BINOP_LSH:
1189               v = v1 << v2;
1190               break;
1191
1192             case BINOP_RSH:
1193               v = v1 >> v2;
1194               break;
1195
1196             case BINOP_BITWISE_AND:
1197               v = v1 & v2;
1198               break;
1199
1200             case BINOP_BITWISE_IOR:
1201               v = v1 | v2;
1202               break;
1203
1204             case BINOP_BITWISE_XOR:
1205               v = v1 ^ v2;
1206               break;
1207
1208             case BINOP_LOGICAL_AND:
1209               v = v1 && v2;
1210               break;
1211
1212             case BINOP_LOGICAL_OR:
1213               v = v1 || v2;
1214               break;
1215
1216             case BINOP_MIN:
1217               v = v1 < v2 ? v1 : v2;
1218               break;
1219
1220             case BINOP_MAX:
1221               v = v1 > v2 ? v1 : v2;
1222               break;
1223
1224             case BINOP_EQUAL:
1225               v = v1 == v2;
1226               break;
1227
1228             case BINOP_NOTEQUAL:
1229               v = v1 != v2;
1230               break;
1231
1232             case BINOP_LESS:
1233               v = v1 < v2;
1234               break;
1235
1236             case BINOP_GTR:
1237               v = v1 > v2;
1238               break;
1239
1240             case BINOP_LEQ:
1241               v = v1 <= v2;
1242               break;
1243
1244             case BINOP_GEQ:
1245               v = v1 >= v2;
1246               break;
1247
1248             default:
1249               error (_("Invalid binary operation on numbers."));
1250             }
1251
1252           val = allocate_value (result_type);
1253           store_unsigned_integer (value_contents_raw (val),
1254                                   TYPE_LENGTH (value_type (val)),
1255                                   gdbarch_byte_order
1256                                     (get_type_arch (result_type)),
1257                                   v);
1258         }
1259       else
1260         {
1261           LONGEST v1, v2, v = 0;
1262
1263           v1 = value_as_long (arg1);
1264           v2 = value_as_long (arg2);
1265
1266           switch (op)
1267             {
1268             case BINOP_ADD:
1269               v = v1 + v2;
1270               break;
1271
1272             case BINOP_SUB:
1273               v = v1 - v2;
1274               break;
1275
1276             case BINOP_MUL:
1277               v = v1 * v2;
1278               break;
1279
1280             case BINOP_DIV:
1281             case BINOP_INTDIV:
1282               if (v2 != 0)
1283                 v = v1 / v2;
1284               else
1285                 error (_("Division by zero"));
1286               break;
1287
1288             case BINOP_EXP:
1289               v = integer_pow (v1, v2);
1290               break;
1291
1292             case BINOP_REM:
1293               if (v2 != 0)
1294                 v = v1 % v2;
1295               else
1296                 error (_("Division by zero"));
1297               break;
1298
1299             case BINOP_MOD:
1300               /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
1301                  X mod 0 has a defined value, X.  */
1302               if (v2 == 0)
1303                 {
1304                   v = v1;
1305                 }
1306               else
1307                 {
1308                   v = v1 / v2;
1309                   /* Compute floor.  */
1310                   if (TRUNCATION_TOWARDS_ZERO && (v < 0) && ((v1 % v2) != 0))
1311                     {
1312                       v--;
1313                     }
1314                   v = v1 - (v2 * v);
1315                 }
1316               break;
1317
1318             case BINOP_LSH:
1319               v = v1 << v2;
1320               break;
1321
1322             case BINOP_RSH:
1323               v = v1 >> v2;
1324               break;
1325
1326             case BINOP_BITWISE_AND:
1327               v = v1 & v2;
1328               break;
1329
1330             case BINOP_BITWISE_IOR:
1331               v = v1 | v2;
1332               break;
1333
1334             case BINOP_BITWISE_XOR:
1335               v = v1 ^ v2;
1336               break;
1337
1338             case BINOP_LOGICAL_AND:
1339               v = v1 && v2;
1340               break;
1341
1342             case BINOP_LOGICAL_OR:
1343               v = v1 || v2;
1344               break;
1345
1346             case BINOP_MIN:
1347               v = v1 < v2 ? v1 : v2;
1348               break;
1349
1350             case BINOP_MAX:
1351               v = v1 > v2 ? v1 : v2;
1352               break;
1353
1354             case BINOP_EQUAL:
1355               v = v1 == v2;
1356               break;
1357
1358             case BINOP_NOTEQUAL:
1359               v = v1 != v2;
1360               break;
1361
1362             case BINOP_LESS:
1363               v = v1 < v2;
1364               break;
1365
1366             case BINOP_GTR:
1367               v = v1 > v2;
1368               break;
1369
1370             case BINOP_LEQ:
1371               v = v1 <= v2;
1372               break;
1373
1374             case BINOP_GEQ:
1375               v = v1 >= v2;
1376               break;
1377
1378             default:
1379               error (_("Invalid binary operation on numbers."));
1380             }
1381
1382           val = allocate_value (result_type);
1383           store_signed_integer (value_contents_raw (val),
1384                                 TYPE_LENGTH (value_type (val)),
1385                                 gdbarch_byte_order
1386                                   (get_type_arch (result_type)),
1387                                 v);
1388         }
1389     }
1390
1391   return val;
1392 }
1393
1394 /* Performs a binary operation on two vector operands by calling scalar_binop
1395    for each pair of vector components.  */
1396
1397 static struct value *
1398 vector_binop (struct value *val1, struct value *val2, enum exp_opcode op)
1399 {
1400   struct value *val, *tmp, *mark;
1401   struct type *type1, *type2, *eltype1, *eltype2, *result_type;
1402   int t1_is_vec, t2_is_vec, elsize, i;
1403   LONGEST low_bound1, high_bound1, low_bound2, high_bound2;
1404
1405   type1 = check_typedef (value_type (val1));
1406   type2 = check_typedef (value_type (val2));
1407
1408   t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
1409                && TYPE_VECTOR (type1)) ? 1 : 0;
1410   t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
1411                && TYPE_VECTOR (type2)) ? 1 : 0;
1412
1413   if (!t1_is_vec || !t2_is_vec)
1414     error (_("Vector operations are only supported among vectors"));
1415
1416   if (!get_array_bounds (type1, &low_bound1, &high_bound1)
1417       || !get_array_bounds (type2, &low_bound2, &high_bound2))
1418     error (_("Could not determine the vector bounds"));
1419
1420   eltype1 = check_typedef (TYPE_TARGET_TYPE (type1));
1421   eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
1422   elsize = TYPE_LENGTH (eltype1);
1423
1424   if (TYPE_CODE (eltype1) != TYPE_CODE (eltype2)
1425       || elsize != TYPE_LENGTH (eltype2)
1426       || TYPE_UNSIGNED (eltype1) != TYPE_UNSIGNED (eltype2)
1427       || low_bound1 != low_bound2 || high_bound1 != high_bound2)
1428     error (_("Cannot perform operation on vectors with different types"));
1429
1430   val = allocate_value (type1);
1431   mark = value_mark ();
1432   for (i = 0; i < high_bound1 - low_bound1 + 1; i++)
1433     {
1434       tmp = value_binop (value_subscript (val1, i),
1435                          value_subscript (val2, i), op);
1436       memcpy (value_contents_writeable (val) + i * elsize,
1437               value_contents_all (tmp),
1438               elsize);
1439      }
1440   value_free_to_mark (mark);
1441
1442   return val;
1443 }
1444
1445 /* Perform a binary operation on two operands.  */
1446
1447 struct value *
1448 value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
1449 {
1450   struct value *val;
1451   struct type *type1 = check_typedef (value_type (arg1));
1452   struct type *type2 = check_typedef (value_type (arg2));
1453   int t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
1454                    && TYPE_VECTOR (type1));
1455   int t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
1456                    && TYPE_VECTOR (type2));
1457
1458   if (!t1_is_vec && !t2_is_vec)
1459     val = scalar_binop (arg1, arg2, op);
1460   else if (t1_is_vec && t2_is_vec)
1461     val = vector_binop (arg1, arg2, op);
1462   else
1463     {
1464       /* Widen the scalar operand to a vector.  */
1465       struct value **v = t1_is_vec ? &arg2 : &arg1;
1466       struct type *t = t1_is_vec ? type2 : type1;
1467
1468       if (TYPE_CODE (t) != TYPE_CODE_FLT
1469           && TYPE_CODE (t) != TYPE_CODE_DECFLOAT
1470           && !is_integral_type (t))
1471         error (_("Argument to operation not a number or boolean."));
1472
1473       *v = value_cast (t1_is_vec ? type1 : type2, *v);
1474       val = vector_binop (arg1, arg2, op);
1475     }
1476
1477   return val;
1478 }
1479 \f
1480 /* Simulate the C operator ! -- return 1 if ARG1 contains zero.  */
1481
1482 int
1483 value_logical_not (struct value *arg1)
1484 {
1485   int len;
1486   const gdb_byte *p;
1487   struct type *type1;
1488
1489   arg1 = coerce_array (arg1);
1490   type1 = check_typedef (value_type (arg1));
1491
1492   if (TYPE_CODE (type1) == TYPE_CODE_FLT)
1493     return 0 == value_as_double (arg1);
1494   else if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
1495     return decimal_is_zero (value_contents (arg1), TYPE_LENGTH (type1),
1496                             gdbarch_byte_order (get_type_arch (type1)));
1497
1498   len = TYPE_LENGTH (type1);
1499   p = value_contents (arg1);
1500
1501   while (--len >= 0)
1502     {
1503       if (*p++)
1504         break;
1505     }
1506
1507   return len < 0;
1508 }
1509
1510 /* Perform a comparison on two string values (whose content are not
1511    necessarily null terminated) based on their length.  */
1512
1513 static int
1514 value_strcmp (struct value *arg1, struct value *arg2)
1515 {
1516   int len1 = TYPE_LENGTH (value_type (arg1));
1517   int len2 = TYPE_LENGTH (value_type (arg2));
1518   const gdb_byte *s1 = value_contents (arg1);
1519   const gdb_byte *s2 = value_contents (arg2);
1520   int i, len = len1 < len2 ? len1 : len2;
1521
1522   for (i = 0; i < len; i++)
1523     {
1524       if (s1[i] < s2[i])
1525         return -1;
1526       else if (s1[i] > s2[i])
1527         return 1;
1528       else
1529         continue;
1530     }
1531
1532   if (len1 < len2)
1533     return -1;
1534   else if (len1 > len2)
1535     return 1;
1536   else
1537     return 0;
1538 }
1539
1540 /* Simulate the C operator == by returning a 1
1541    iff ARG1 and ARG2 have equal contents.  */
1542
1543 int
1544 value_equal (struct value *arg1, struct value *arg2)
1545 {
1546   int len;
1547   const gdb_byte *p1;
1548   const gdb_byte *p2;
1549   struct type *type1, *type2;
1550   enum type_code code1;
1551   enum type_code code2;
1552   int is_int1, is_int2;
1553
1554   arg1 = coerce_array (arg1);
1555   arg2 = coerce_array (arg2);
1556
1557   type1 = check_typedef (value_type (arg1));
1558   type2 = check_typedef (value_type (arg2));
1559   code1 = TYPE_CODE (type1);
1560   code2 = TYPE_CODE (type2);
1561   is_int1 = is_integral_type (type1);
1562   is_int2 = is_integral_type (type2);
1563
1564   if (is_int1 && is_int2)
1565     return longest_to_int (value_as_long (value_binop (arg1, arg2,
1566                                                        BINOP_EQUAL)));
1567   else if ((code1 == TYPE_CODE_FLT || is_int1)
1568            && (code2 == TYPE_CODE_FLT || is_int2))
1569     {
1570       /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1571          `long double' values are returned in static storage (m68k).  */
1572       DOUBLEST d = value_as_double (arg1);
1573
1574       return d == value_as_double (arg2);
1575     }
1576   else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
1577            && (code2 == TYPE_CODE_DECFLOAT || is_int2))
1578     {
1579       gdb_byte v1[16], v2[16];
1580       int len_v1, len_v2;
1581       enum bfd_endian byte_order_v1, byte_order_v2;
1582
1583       value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
1584                                          v2, &len_v2, &byte_order_v2);
1585
1586       return decimal_compare (v1, len_v1, byte_order_v1,
1587                               v2, len_v2, byte_order_v2) == 0;
1588     }
1589
1590   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1591      is bigger.  */
1592   else if (code1 == TYPE_CODE_PTR && is_int2)
1593     return value_as_address (arg1) == (CORE_ADDR) value_as_long (arg2);
1594   else if (code2 == TYPE_CODE_PTR && is_int1)
1595     return (CORE_ADDR) value_as_long (arg1) == value_as_address (arg2);
1596
1597   else if (code1 == code2
1598            && ((len = (int) TYPE_LENGTH (type1))
1599                == (int) TYPE_LENGTH (type2)))
1600     {
1601       p1 = value_contents (arg1);
1602       p2 = value_contents (arg2);
1603       while (--len >= 0)
1604         {
1605           if (*p1++ != *p2++)
1606             break;
1607         }
1608       return len < 0;
1609     }
1610   else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1611     {
1612       return value_strcmp (arg1, arg2) == 0;
1613     }
1614   else
1615     {
1616       error (_("Invalid type combination in equality test."));
1617       return 0;                 /* For lint -- never reached.  */
1618     }
1619 }
1620
1621 /* Compare values based on their raw contents.  Useful for arrays since
1622    value_equal coerces them to pointers, thus comparing just the address
1623    of the array instead of its contents.  */
1624
1625 int
1626 value_equal_contents (struct value *arg1, struct value *arg2)
1627 {
1628   struct type *type1, *type2;
1629
1630   type1 = check_typedef (value_type (arg1));
1631   type2 = check_typedef (value_type (arg2));
1632
1633   return (TYPE_CODE (type1) == TYPE_CODE (type2)
1634           && TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
1635           && memcmp (value_contents (arg1), value_contents (arg2),
1636                      TYPE_LENGTH (type1)) == 0);
1637 }
1638
1639 /* Simulate the C operator < by returning 1
1640    iff ARG1's contents are less than ARG2's.  */
1641
1642 int
1643 value_less (struct value *arg1, struct value *arg2)
1644 {
1645   enum type_code code1;
1646   enum type_code code2;
1647   struct type *type1, *type2;
1648   int is_int1, is_int2;
1649
1650   arg1 = coerce_array (arg1);
1651   arg2 = coerce_array (arg2);
1652
1653   type1 = check_typedef (value_type (arg1));
1654   type2 = check_typedef (value_type (arg2));
1655   code1 = TYPE_CODE (type1);
1656   code2 = TYPE_CODE (type2);
1657   is_int1 = is_integral_type (type1);
1658   is_int2 = is_integral_type (type2);
1659
1660   if (is_int1 && is_int2)
1661     return longest_to_int (value_as_long (value_binop (arg1, arg2,
1662                                                        BINOP_LESS)));
1663   else if ((code1 == TYPE_CODE_FLT || is_int1)
1664            && (code2 == TYPE_CODE_FLT || is_int2))
1665     {
1666       /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1667          `long double' values are returned in static storage (m68k).  */
1668       DOUBLEST d = value_as_double (arg1);
1669
1670       return d < value_as_double (arg2);
1671     }
1672   else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
1673            && (code2 == TYPE_CODE_DECFLOAT || is_int2))
1674     {
1675       gdb_byte v1[16], v2[16];
1676       int len_v1, len_v2;
1677       enum bfd_endian byte_order_v1, byte_order_v2;
1678
1679       value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
1680                                          v2, &len_v2, &byte_order_v2);
1681
1682       return decimal_compare (v1, len_v1, byte_order_v1,
1683                               v2, len_v2, byte_order_v2) == -1;
1684     }
1685   else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
1686     return value_as_address (arg1) < value_as_address (arg2);
1687
1688   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1689      is bigger.  */
1690   else if (code1 == TYPE_CODE_PTR && is_int2)
1691     return value_as_address (arg1) < (CORE_ADDR) value_as_long (arg2);
1692   else if (code2 == TYPE_CODE_PTR && is_int1)
1693     return (CORE_ADDR) value_as_long (arg1) < value_as_address (arg2);
1694   else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1695     return value_strcmp (arg1, arg2) < 0;
1696   else
1697     {
1698       error (_("Invalid type combination in ordering comparison."));
1699       return 0;
1700     }
1701 }
1702 \f
1703 /* The unary operators +, - and ~.  They free the argument ARG1.  */
1704
1705 struct value *
1706 value_pos (struct value *arg1)
1707 {
1708   struct type *type;
1709
1710   arg1 = coerce_ref (arg1);
1711   type = check_typedef (value_type (arg1));
1712
1713   if (TYPE_CODE (type) == TYPE_CODE_FLT)
1714     return value_from_double (type, value_as_double (arg1));
1715   else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
1716     return value_from_decfloat (type, value_contents (arg1));
1717   else if (is_integral_type (type))
1718     {
1719       return value_from_longest (type, value_as_long (arg1));
1720     }
1721   else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
1722     {
1723       struct value *val = allocate_value (type);
1724
1725       memcpy (value_contents_raw (val), value_contents (arg1),
1726               TYPE_LENGTH (type));
1727       return val;
1728     }
1729   else
1730     {
1731       error (_("Argument to positive operation not a number."));
1732       return 0;                 /* For lint -- never reached.  */
1733     }
1734 }
1735
1736 struct value *
1737 value_neg (struct value *arg1)
1738 {
1739   struct type *type;
1740
1741   arg1 = coerce_ref (arg1);
1742   type = check_typedef (value_type (arg1));
1743
1744   if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
1745     {
1746       struct value *val = allocate_value (type);
1747       int len = TYPE_LENGTH (type);
1748       gdb_byte decbytes[16];  /* a decfloat is at most 128 bits long.  */
1749
1750       memcpy (decbytes, value_contents (arg1), len);
1751
1752       if (gdbarch_byte_order (get_type_arch (type)) == BFD_ENDIAN_LITTLE)
1753         decbytes[len-1] = decbytes[len - 1] | 0x80;
1754       else
1755         decbytes[0] = decbytes[0] | 0x80;
1756
1757       memcpy (value_contents_raw (val), decbytes, len);
1758       return val;
1759     }
1760   else if (TYPE_CODE (type) == TYPE_CODE_FLT)
1761     return value_from_double (type, -value_as_double (arg1));
1762   else if (is_integral_type (type))
1763     {
1764       return value_from_longest (type, -value_as_long (arg1));
1765     }
1766   else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
1767     {
1768       struct value *tmp, *val = allocate_value (type);
1769       struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
1770       int i;
1771       LONGEST low_bound, high_bound;
1772
1773       if (!get_array_bounds (type, &low_bound, &high_bound))
1774         error (_("Could not determine the vector bounds"));
1775
1776       for (i = 0; i < high_bound - low_bound + 1; i++)
1777         {
1778           tmp = value_neg (value_subscript (arg1, i));
1779           memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
1780                   value_contents_all (tmp), TYPE_LENGTH (eltype));
1781         }
1782       return val;
1783     }
1784   else
1785     {
1786       error (_("Argument to negate operation not a number."));
1787       return 0;                 /* For lint -- never reached.  */
1788     }
1789 }
1790
1791 struct value *
1792 value_complement (struct value *arg1)
1793 {
1794   struct type *type;
1795   struct value *val;
1796
1797   arg1 = coerce_ref (arg1);
1798   type = check_typedef (value_type (arg1));
1799
1800   if (is_integral_type (type))
1801     val = value_from_longest (type, ~value_as_long (arg1));
1802   else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
1803     {
1804       struct value *tmp;
1805       struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
1806       int i;
1807       LONGEST low_bound, high_bound;
1808
1809       if (!get_array_bounds (type, &low_bound, &high_bound))
1810         error (_("Could not determine the vector bounds"));
1811
1812       val = allocate_value (type);
1813       for (i = 0; i < high_bound - low_bound + 1; i++)
1814         {
1815           tmp = value_complement (value_subscript (arg1, i));
1816           memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
1817                   value_contents_all (tmp), TYPE_LENGTH (eltype));
1818         }
1819     }
1820   else
1821     error (_("Argument to complement operation not an integer, boolean."));
1822
1823   return val;
1824 }
1825 \f
1826 /* The INDEX'th bit of SET value whose value_type is TYPE,
1827    and whose value_contents is valaddr.
1828    Return -1 if out of range, -2 other error.  */
1829
1830 int
1831 value_bit_index (struct type *type, const gdb_byte *valaddr, int index)
1832 {
1833   struct gdbarch *gdbarch = get_type_arch (type);
1834   LONGEST low_bound, high_bound;
1835   LONGEST word;
1836   unsigned rel_index;
1837   struct type *range = TYPE_INDEX_TYPE (type);
1838
1839   if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
1840     return -2;
1841   if (index < low_bound || index > high_bound)
1842     return -1;
1843   rel_index = index - low_bound;
1844   word = extract_unsigned_integer (valaddr + (rel_index / TARGET_CHAR_BIT), 1,
1845                                    gdbarch_byte_order (gdbarch));
1846   rel_index %= TARGET_CHAR_BIT;
1847   if (gdbarch_bits_big_endian (gdbarch))
1848     rel_index = TARGET_CHAR_BIT - 1 - rel_index;
1849   return (word >> rel_index) & 1;
1850 }
1851
1852 int
1853 value_in (struct value *element, struct value *set)
1854 {
1855   int member;
1856   struct type *settype = check_typedef (value_type (set));
1857   struct type *eltype = check_typedef (value_type (element));
1858
1859   if (TYPE_CODE (eltype) == TYPE_CODE_RANGE)
1860     eltype = TYPE_TARGET_TYPE (eltype);
1861   if (TYPE_CODE (settype) != TYPE_CODE_SET)
1862     error (_("Second argument of 'IN' has wrong type"));
1863   if (TYPE_CODE (eltype) != TYPE_CODE_INT
1864       && TYPE_CODE (eltype) != TYPE_CODE_CHAR
1865       && TYPE_CODE (eltype) != TYPE_CODE_ENUM
1866       && TYPE_CODE (eltype) != TYPE_CODE_BOOL)
1867     error (_("First argument of 'IN' has wrong type"));
1868   member = value_bit_index (settype, value_contents (set),
1869                             value_as_long (element));
1870   if (member < 0)
1871     error (_("First argument of 'IN' not in range"));
1872   return member;
1873 }
1874
1875 void
1876 _initialize_valarith (void)
1877 {
1878 }