gdb/valarith.c

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