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