gdb/valarith.c

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