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