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, n, i;
1398
1399   type1 = check_typedef (value_type (val1));
1400   type2 = check_typedef (value_type (val2));
1401
1402   t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
1403                && TYPE_VECTOR (type1)) ? 1 : 0;
1404   t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
1405                && TYPE_VECTOR (type2)) ? 1 : 0;
1406
1407   if (!t1_is_vec || !t2_is_vec)
1408     error (_("Vector operations are only supported among vectors"));
1409
1410   eltype1 = check_typedef (TYPE_TARGET_TYPE (type1));
1411   eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
1412
1413   if (TYPE_CODE (eltype1) != TYPE_CODE (eltype2)
1414       || TYPE_LENGTH (eltype1) != TYPE_LENGTH (eltype2)
1415       || TYPE_UNSIGNED (eltype1) != TYPE_UNSIGNED (eltype2))
1416     error (_("Cannot perform operation on vectors with different types"));
1417
1418   elsize = TYPE_LENGTH (eltype1);
1419   n = TYPE_LENGTH (type1) / elsize;
1420
1421   if (n != TYPE_LENGTH (type2) / TYPE_LENGTH (eltype2))
1422     error (_("Cannot perform operation on vectors with different sizes"));
1423
1424   val = allocate_value (type1);
1425   mark = value_mark ();
1426   for (i = 0; i < n; i++)
1427     {
1428       tmp = value_binop (value_subscript (val1, i),
1429                          value_subscript (val2, i), op);
1430       memcpy (value_contents_writeable (val) + i * elsize,
1431               value_contents_all (tmp),
1432               elsize);
1433      }
1434   value_free_to_mark (mark);
1435
1436   return val;
1437 }
1438
1439 /* Perform a binary operation on two operands.  */
1440
1441 struct value *
1442 value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
1443 {
1444   struct value *val;
1445   struct type *type1 = check_typedef (value_type (arg1));
1446   struct type *type2 = check_typedef (value_type (arg2));
1447   int t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
1448                    && TYPE_VECTOR (type1));
1449   int t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
1450                    && TYPE_VECTOR (type2));
1451
1452   if (!t1_is_vec && !t2_is_vec)
1453     val = scalar_binop (arg1, arg2, op);
1454   else if (t1_is_vec && t2_is_vec)
1455     val = vector_binop (arg1, arg2, op);
1456   else
1457     {
1458       /* Widen the scalar operand to a vector.  */
1459       struct value **v = t1_is_vec ? &arg2 : &arg1;
1460       struct type *t = t1_is_vec ? type2 : type1;
1461
1462       if (TYPE_CODE (t) != TYPE_CODE_FLT
1463           && TYPE_CODE (t) != TYPE_CODE_DECFLOAT
1464           && !is_integral_type (t))
1465         error (_("Argument to operation not a number or boolean."));
1466
1467       *v = value_cast (t1_is_vec ? type1 : type2, *v);
1468       val = vector_binop (arg1, arg2, op);
1469     }
1470
1471   return val;
1472 }
1473 \f
1474 /* Simulate the C operator ! -- return 1 if ARG1 contains zero.  */
1475
1476 int
1477 value_logical_not (struct value *arg1)
1478 {
1479   int len;
1480   const gdb_byte *p;
1481   struct type *type1;
1482
1483   arg1 = coerce_array (arg1);
1484   type1 = check_typedef (value_type (arg1));
1485
1486   if (TYPE_CODE (type1) == TYPE_CODE_FLT)
1487     return 0 == value_as_double (arg1);
1488   else if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
1489     return decimal_is_zero (value_contents (arg1), TYPE_LENGTH (type1),
1490                             gdbarch_byte_order (get_type_arch (type1)));
1491
1492   len = TYPE_LENGTH (type1);
1493   p = value_contents (arg1);
1494
1495   while (--len >= 0)
1496     {
1497       if (*p++)
1498         break;
1499     }
1500
1501   return len < 0;
1502 }
1503
1504 /* Perform a comparison on two string values (whose content are not
1505    necessarily null terminated) based on their length */
1506
1507 static int
1508 value_strcmp (struct value *arg1, struct value *arg2)
1509 {
1510   int len1 = TYPE_LENGTH (value_type (arg1));
1511   int len2 = TYPE_LENGTH (value_type (arg2));
1512   const gdb_byte *s1 = value_contents (arg1);
1513   const gdb_byte *s2 = value_contents (arg2);
1514   int i, len = len1 < len2 ? len1 : len2;
1515
1516   for (i = 0; i < len; i++)
1517     {
1518       if (s1[i] < s2[i])
1519         return -1;
1520       else if (s1[i] > s2[i])
1521         return 1;
1522       else
1523         continue;
1524     }
1525
1526   if (len1 < len2)
1527     return -1;
1528   else if (len1 > len2)
1529     return 1;
1530   else
1531     return 0;
1532 }
1533
1534 /* Simulate the C operator == by returning a 1
1535    iff ARG1 and ARG2 have equal contents.  */
1536
1537 int
1538 value_equal (struct value *arg1, struct value *arg2)
1539 {
1540   int len;
1541   const gdb_byte *p1;
1542   const gdb_byte *p2;
1543   struct type *type1, *type2;
1544   enum type_code code1;
1545   enum type_code code2;
1546   int is_int1, is_int2;
1547
1548   arg1 = coerce_array (arg1);
1549   arg2 = coerce_array (arg2);
1550
1551   type1 = check_typedef (value_type (arg1));
1552   type2 = check_typedef (value_type (arg2));
1553   code1 = TYPE_CODE (type1);
1554   code2 = TYPE_CODE (type2);
1555   is_int1 = is_integral_type (type1);
1556   is_int2 = is_integral_type (type2);
1557
1558   if (is_int1 && is_int2)
1559     return longest_to_int (value_as_long (value_binop (arg1, arg2,
1560                                                        BINOP_EQUAL)));
1561   else if ((code1 == TYPE_CODE_FLT || is_int1)
1562            && (code2 == TYPE_CODE_FLT || is_int2))
1563     {
1564       /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1565          `long double' values are returned in static storage (m68k).  */
1566       DOUBLEST d = value_as_double (arg1);
1567
1568       return d == value_as_double (arg2);
1569     }
1570   else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
1571            && (code2 == TYPE_CODE_DECFLOAT || is_int2))
1572     {
1573       gdb_byte v1[16], v2[16];
1574       int len_v1, len_v2;
1575       enum bfd_endian byte_order_v1, byte_order_v2;
1576
1577       value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
1578                                          v2, &len_v2, &byte_order_v2);
1579
1580       return decimal_compare (v1, len_v1, byte_order_v1,
1581                               v2, len_v2, byte_order_v2) == 0;
1582     }
1583
1584   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1585      is bigger.  */
1586   else if (code1 == TYPE_CODE_PTR && is_int2)
1587     return value_as_address (arg1) == (CORE_ADDR) value_as_long (arg2);
1588   else if (code2 == TYPE_CODE_PTR && is_int1)
1589     return (CORE_ADDR) value_as_long (arg1) == value_as_address (arg2);
1590
1591   else if (code1 == code2
1592            && ((len = (int) TYPE_LENGTH (type1))
1593                == (int) TYPE_LENGTH (type2)))
1594     {
1595       p1 = value_contents (arg1);
1596       p2 = value_contents (arg2);
1597       while (--len >= 0)
1598         {
1599           if (*p1++ != *p2++)
1600             break;
1601         }
1602       return len < 0;
1603     }
1604   else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1605     {
1606       return value_strcmp (arg1, arg2) == 0;
1607     }
1608   else
1609     {
1610       error (_("Invalid type combination in equality test."));
1611       return 0;                 /* For lint -- never reached */
1612     }
1613 }
1614
1615 /* Compare values based on their raw contents.  Useful for arrays since
1616    value_equal coerces them to pointers, thus comparing just the address
1617    of the array instead of its contents.  */
1618
1619 int
1620 value_equal_contents (struct value *arg1, struct value *arg2)
1621 {
1622   struct type *type1, *type2;
1623
1624   type1 = check_typedef (value_type (arg1));
1625   type2 = check_typedef (value_type (arg2));
1626
1627   return (TYPE_CODE (type1) == TYPE_CODE (type2)
1628           && TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
1629           && memcmp (value_contents (arg1), value_contents (arg2),
1630                      TYPE_LENGTH (type1)) == 0);
1631 }
1632
1633 /* Simulate the C operator < by returning 1
1634    iff ARG1's contents are less than ARG2's.  */
1635
1636 int
1637 value_less (struct value *arg1, struct value *arg2)
1638 {
1639   enum type_code code1;
1640   enum type_code code2;
1641   struct type *type1, *type2;
1642   int is_int1, is_int2;
1643
1644   arg1 = coerce_array (arg1);
1645   arg2 = coerce_array (arg2);
1646
1647   type1 = check_typedef (value_type (arg1));
1648   type2 = check_typedef (value_type (arg2));
1649   code1 = TYPE_CODE (type1);
1650   code2 = TYPE_CODE (type2);
1651   is_int1 = is_integral_type (type1);
1652   is_int2 = is_integral_type (type2);
1653
1654   if (is_int1 && is_int2)
1655     return longest_to_int (value_as_long (value_binop (arg1, arg2,
1656                                                        BINOP_LESS)));
1657   else if ((code1 == TYPE_CODE_FLT || is_int1)
1658            && (code2 == TYPE_CODE_FLT || is_int2))
1659     {
1660       /* NOTE: kettenis/20050816: Avoid compiler bug on systems where
1661          `long double' values are returned in static storage (m68k).  */
1662       DOUBLEST d = value_as_double (arg1);
1663
1664       return d < value_as_double (arg2);
1665     }
1666   else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
1667            && (code2 == TYPE_CODE_DECFLOAT || is_int2))
1668     {
1669       gdb_byte v1[16], v2[16];
1670       int len_v1, len_v2;
1671       enum bfd_endian byte_order_v1, byte_order_v2;
1672
1673       value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1,
1674                                          v2, &len_v2, &byte_order_v2);
1675
1676       return decimal_compare (v1, len_v1, byte_order_v1,
1677                               v2, len_v2, byte_order_v2) == -1;
1678     }
1679   else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
1680     return value_as_address (arg1) < value_as_address (arg2);
1681
1682   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1683      is bigger.  */
1684   else if (code1 == TYPE_CODE_PTR && is_int2)
1685     return value_as_address (arg1) < (CORE_ADDR) value_as_long (arg2);
1686   else if (code2 == TYPE_CODE_PTR && is_int1)
1687     return (CORE_ADDR) value_as_long (arg1) < value_as_address (arg2);
1688   else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1689     return value_strcmp (arg1, arg2) < 0;
1690   else
1691     {
1692       error (_("Invalid type combination in ordering comparison."));
1693       return 0;
1694     }
1695 }
1696 \f
1697 /* The unary operators +, - and ~.  They free the argument ARG1.  */
1698
1699 struct value *
1700 value_pos (struct value *arg1)
1701 {
1702   struct type *type;
1703
1704   arg1 = coerce_ref (arg1);
1705   type = check_typedef (value_type (arg1));
1706
1707   if (TYPE_CODE (type) == TYPE_CODE_FLT)
1708     return value_from_double (type, value_as_double (arg1));
1709   else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
1710     return value_from_decfloat (type, value_contents (arg1));
1711   else if (is_integral_type (type))
1712     {
1713       return value_from_longest (type, value_as_long (arg1));
1714     }
1715   else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
1716     {
1717       struct value *val = allocate_value (type);
1718
1719       memcpy (value_contents_raw (val), value_contents (arg1),
1720               TYPE_LENGTH (type));
1721       return val;
1722     }
1723   else
1724     {
1725       error ("Argument to positive operation not a number.");
1726       return 0;                 /* For lint -- never reached */
1727     }
1728 }
1729
1730 struct value *
1731 value_neg (struct value *arg1)
1732 {
1733   struct type *type;
1734
1735   arg1 = coerce_ref (arg1);
1736   type = check_typedef (value_type (arg1));
1737
1738   if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
1739     {
1740       struct value *val = allocate_value (type);
1741       int len = TYPE_LENGTH (type);
1742       gdb_byte decbytes[16];  /* a decfloat is at most 128 bits long */
1743
1744       memcpy (decbytes, value_contents (arg1), len);
1745
1746       if (gdbarch_byte_order (get_type_arch (type)) == BFD_ENDIAN_LITTLE)
1747         decbytes[len-1] = decbytes[len - 1] | 0x80;
1748       else
1749         decbytes[0] = decbytes[0] | 0x80;
1750
1751       memcpy (value_contents_raw (val), decbytes, len);
1752       return val;
1753     }
1754   else if (TYPE_CODE (type) == TYPE_CODE_FLT)
1755     return value_from_double (type, -value_as_double (arg1));
1756   else if (is_integral_type (type))
1757     {
1758       return value_from_longest (type, -value_as_long (arg1));
1759     }
1760   else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
1761     {
1762       struct value *tmp, *val = allocate_value (type);
1763       struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
1764       int i, n = TYPE_LENGTH (type) / TYPE_LENGTH (eltype);
1765
1766       for (i = 0; i < n; i++)
1767         {
1768           tmp = value_neg (value_subscript (arg1, i));
1769           memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
1770                   value_contents_all (tmp), TYPE_LENGTH (eltype));
1771         }
1772       return val;
1773     }
1774   else
1775     {
1776       error (_("Argument to negate operation not a number."));
1777       return 0;                 /* For lint -- never reached */
1778     }
1779 }
1780
1781 struct value *
1782 value_complement (struct value *arg1)
1783 {
1784   struct type *type;
1785   struct value *val;
1786
1787   arg1 = coerce_ref (arg1);
1788   type = check_typedef (value_type (arg1));
1789
1790   if (is_integral_type (type))
1791     val = value_from_longest (type, ~value_as_long (arg1));
1792   else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
1793     {
1794       struct value *tmp;
1795       struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
1796       int i, n = TYPE_LENGTH (type) / TYPE_LENGTH (eltype);
1797
1798       val = allocate_value (type);
1799       for (i = 0; i < n; i++)
1800         {
1801           tmp = value_complement (value_subscript (arg1, i));
1802           memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
1803                   value_contents_all (tmp), TYPE_LENGTH (eltype));
1804         }
1805     }
1806   else
1807     error (_("Argument to complement operation not an integer, boolean."));
1808
1809   return val;
1810 }
1811 \f
1812 /* The INDEX'th bit of SET value whose value_type is TYPE,
1813    and whose value_contents is valaddr.
1814    Return -1 if out of range, -2 other error. */
1815
1816 int
1817 value_bit_index (struct type *type, const gdb_byte *valaddr, int index)
1818 {
1819   struct gdbarch *gdbarch = get_type_arch (type);
1820   LONGEST low_bound, high_bound;
1821   LONGEST word;
1822   unsigned rel_index;
1823   struct type *range = TYPE_INDEX_TYPE (type);
1824
1825   if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
1826     return -2;
1827   if (index < low_bound || index > high_bound)
1828     return -1;
1829   rel_index = index - low_bound;
1830   word = extract_unsigned_integer (valaddr + (rel_index / TARGET_CHAR_BIT), 1,
1831                                    gdbarch_byte_order (gdbarch));
1832   rel_index %= TARGET_CHAR_BIT;
1833   if (gdbarch_bits_big_endian (gdbarch))
1834     rel_index = TARGET_CHAR_BIT - 1 - rel_index;
1835   return (word >> rel_index) & 1;
1836 }
1837
1838 int
1839 value_in (struct value *element, struct value *set)
1840 {
1841   int member;
1842   struct type *settype = check_typedef (value_type (set));
1843   struct type *eltype = check_typedef (value_type (element));
1844
1845   if (TYPE_CODE (eltype) == TYPE_CODE_RANGE)
1846     eltype = TYPE_TARGET_TYPE (eltype);
1847   if (TYPE_CODE (settype) != TYPE_CODE_SET)
1848     error (_("Second argument of 'IN' has wrong type"));
1849   if (TYPE_CODE (eltype) != TYPE_CODE_INT
1850       && TYPE_CODE (eltype) != TYPE_CODE_CHAR
1851       && TYPE_CODE (eltype) != TYPE_CODE_ENUM
1852       && TYPE_CODE (eltype) != TYPE_CODE_BOOL)
1853     error (_("First argument of 'IN' has wrong type"));
1854   member = value_bit_index (settype, value_contents (set),
1855                             value_as_long (element));
1856   if (member < 0)
1857     error (_("First argument of 'IN' not in range"));
1858   return member;
1859 }
1860
1861 void
1862 _initialize_valarith (void)
1863 {
1864 }