gdb/valarith.c

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