gdb/valarith.c

   1 /* Perform arithmetic and other operations on values, for GDB.
   2    Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
   3    1997, 1998, 1999, 2000
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "value.h"
  25 #include "symtab.h"
  26 #include "gdbtypes.h"
  27 #include "expression.h"
  28 #include "target.h"
  29 #include "language.h"
  30 #include "gdb_string.h"
  31 #include "doublest.h"
  32 #include <math.h>
  33
  34 /* Define whether or not the C operator '/' truncates towards zero for
  35    differently signed operands (truncation direction is undefined in C). */
  36
  37 #ifndef TRUNCATION_TOWARDS_ZERO
  38 #define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
  39 #endif
  40
  41 static value_ptr value_subscripted_rvalue (value_ptr, value_ptr, int);
  42
  43 void _initialize_valarith (void);
  44 \f
  45
  46 value_ptr
  47 value_add (value_ptr arg1, value_ptr arg2)
  48 {
  49   register value_ptr valint, valptr;
  50   register int len;
  51   struct type *type1, *type2, *valptrtype;
  52
  53   COERCE_NUMBER (arg1);
  54   COERCE_NUMBER (arg2);
  55   type1 = check_typedef (VALUE_TYPE (arg1));
  56   type2 = check_typedef (VALUE_TYPE (arg2));
  57
  58   if ((TYPE_CODE (type1) == TYPE_CODE_PTR
  59        || TYPE_CODE (type2) == TYPE_CODE_PTR)
  60       &&
  61       (TYPE_CODE (type1) == TYPE_CODE_INT
  62        || TYPE_CODE (type2) == TYPE_CODE_INT))
  63     /* Exactly one argument is a pointer, and one is an integer.  */
  64     {
  65       value_ptr retval;
  66
  67       if (TYPE_CODE (type1) == TYPE_CODE_PTR)
  68         {
  69           valptr = arg1;
  70           valint = arg2;
  71           valptrtype = type1;
  72         }
  73       else
  74         {
  75           valptr = arg2;
  76           valint = arg1;
  77           valptrtype = type2;
  78         }
  79       len = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (valptrtype)));
  80       if (len == 0)
  81         len = 1;                /* For (void *) */
  82       retval = value_from_pointer (valptrtype,
  83                                    value_as_address (valptr)
  84                                    + (len * value_as_long (valint)));
  85       VALUE_BFD_SECTION (retval) = VALUE_BFD_SECTION (valptr);
  86       return retval;
  87     }
  88
  89   return value_binop (arg1, arg2, BINOP_ADD);
  90 }
  91
  92 value_ptr
  93 value_sub (value_ptr arg1, value_ptr arg2)
  94 {
  95   struct type *type1, *type2;
  96   COERCE_NUMBER (arg1);
  97   COERCE_NUMBER (arg2);
  98   type1 = check_typedef (VALUE_TYPE (arg1));
  99   type2 = check_typedef (VALUE_TYPE (arg2));
 100
 101   if (TYPE_CODE (type1) == TYPE_CODE_PTR)
 102     {
 103       if (TYPE_CODE (type2) == TYPE_CODE_INT)
 104         {
 105           /* pointer - integer.  */
 106           LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
 107           return value_from_pointer (type1,
 108                                      (value_as_address (arg1)
 109                                       - (sz * value_as_long (arg2))));
 110         }
 111       else if (TYPE_CODE (type2) == TYPE_CODE_PTR
 112                && TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)))
 113                == TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2))))
 114         {
 115           /* pointer to <type x> - pointer to <type x>.  */
 116           LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
 117           return value_from_longest
 118             (builtin_type_long, /* FIXME -- should be ptrdiff_t */
 119              (value_as_long (arg1) - value_as_long (arg2)) / sz);
 120         }
 121       else
 122         {
 123           error ("\
 124 First argument of `-' is a pointer and second argument is neither\n\
 125 an integer nor a pointer of the same type.");
 126         }
 127     }
 128
 129   return value_binop (arg1, arg2, BINOP_SUB);
 130 }
 131
 132 /* Return the value of ARRAY[IDX].
 133    See comments in value_coerce_array() for rationale for reason for
 134    doing lower bounds adjustment here rather than there.
 135    FIXME:  Perhaps we should validate that the index is valid and if
 136    verbosity is set, warn about invalid indices (but still use them). */
 137
 138 value_ptr
 139 value_subscript (value_ptr array, value_ptr idx)
 140 {
 141   value_ptr bound;
 142   int c_style = current_language->c_style_arrays;
 143   struct type *tarray;
 144
 145   COERCE_REF (array);
 146   tarray = check_typedef (VALUE_TYPE (array));
 147   COERCE_VARYING_ARRAY (array, tarray);
 148
 149   if (TYPE_CODE (tarray) == TYPE_CODE_ARRAY
 150       || TYPE_CODE (tarray) == TYPE_CODE_STRING)
 151     {
 152       struct type *range_type = TYPE_INDEX_TYPE (tarray);
 153       LONGEST lowerbound, upperbound;
 154       get_discrete_bounds (range_type, &lowerbound, &upperbound);
 155
 156       if (VALUE_LVAL (array) != lval_memory)
 157         return value_subscripted_rvalue (array, idx, lowerbound);
 158
 159       if (c_style == 0)
 160         {
 161           LONGEST index = value_as_long (idx);
 162           if (index >= lowerbound && index <= upperbound)
 163             return value_subscripted_rvalue (array, idx, lowerbound);
 164           warning ("array or string index out of range");
 165           /* fall doing C stuff */
 166           c_style = 1;
 167         }
 168
 169       if (lowerbound != 0)
 170         {
 171           bound = value_from_longest (builtin_type_int, (LONGEST) lowerbound);
 172           idx = value_sub (idx, bound);
 173         }
 174
 175       array = value_coerce_array (array);
 176     }
 177
 178   if (TYPE_CODE (tarray) == TYPE_CODE_BITSTRING)
 179     {
 180       struct type *range_type = TYPE_INDEX_TYPE (tarray);
 181       LONGEST index = value_as_long (idx);
 182       value_ptr v;
 183       int offset, byte, bit_index;
 184       LONGEST lowerbound, upperbound;
 185       get_discrete_bounds (range_type, &lowerbound, &upperbound);
 186       if (index < lowerbound || index > upperbound)
 187         error ("bitstring index out of range");
 188       index -= lowerbound;
 189       offset = index / TARGET_CHAR_BIT;
 190       byte = *((char *) VALUE_CONTENTS (array) + offset);
 191       bit_index = index % TARGET_CHAR_BIT;
 192       byte >>= (BITS_BIG_ENDIAN ? TARGET_CHAR_BIT - 1 - bit_index : bit_index);
 193       v = value_from_longest (LA_BOOL_TYPE, byte & 1);
 194       VALUE_BITPOS (v) = bit_index;
 195       VALUE_BITSIZE (v) = 1;
 196       VALUE_LVAL (v) = VALUE_LVAL (array);
 197       if (VALUE_LVAL (array) == lval_internalvar)
 198         VALUE_LVAL (v) = lval_internalvar_component;
 199       VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
 200       VALUE_OFFSET (v) = offset + VALUE_OFFSET (array);
 201       return v;
 202     }
 203
 204   if (c_style)
 205     return value_ind (value_add (array, idx));
 206   else
 207     error ("not an array or string");
 208 }
 209
 210 /* Return the value of EXPR[IDX], expr an aggregate rvalue
 211    (eg, a vector register).  This routine used to promote floats
 212    to doubles, but no longer does.  */
 213
 214 static value_ptr
 215 value_subscripted_rvalue (value_ptr array, value_ptr idx, int lowerbound)
 216 {
 217   struct type *array_type = check_typedef (VALUE_TYPE (array));
 218   struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
 219   unsigned int elt_size = TYPE_LENGTH (elt_type);
 220   LONGEST index = value_as_long (idx);
 221   unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
 222   value_ptr v;
 223
 224   if (index < lowerbound || elt_offs >= TYPE_LENGTH (array_type))
 225     error ("no such vector element");
 226
 227   v = allocate_value (elt_type);
 228   if (VALUE_LAZY (array))
 229     VALUE_LAZY (v) = 1;
 230   else
 231     memcpy (VALUE_CONTENTS (v), VALUE_CONTENTS (array) + elt_offs, elt_size);
 232
 233   if (VALUE_LVAL (array) == lval_internalvar)
 234     VALUE_LVAL (v) = lval_internalvar_component;
 235   else
 236     VALUE_LVAL (v) = VALUE_LVAL (array);
 237   VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
 238   VALUE_OFFSET (v) = VALUE_OFFSET (array) + elt_offs;
 239   return v;
 240 }
 241 \f
 242 /* Check to see if either argument is a structure.  This is called so
 243    we know whether to go ahead with the normal binop or look for a
 244    user defined function instead.
 245
 246    For now, we do not overload the `=' operator.  */
 247
 248 int
 249 binop_user_defined_p (enum exp_opcode op, value_ptr arg1, value_ptr arg2)
 250 {
 251   struct type *type1, *type2;
 252   if (op == BINOP_ASSIGN || op == BINOP_CONCAT)
 253     return 0;
 254   type1 = check_typedef (VALUE_TYPE (arg1));
 255   type2 = check_typedef (VALUE_TYPE (arg2));
 256   return (TYPE_CODE (type1) == TYPE_CODE_STRUCT
 257           || TYPE_CODE (type2) == TYPE_CODE_STRUCT
 258           || (TYPE_CODE (type1) == TYPE_CODE_REF
 259               && TYPE_CODE (TYPE_TARGET_TYPE (type1)) == TYPE_CODE_STRUCT)
 260           || (TYPE_CODE (type2) == TYPE_CODE_REF
 261               && TYPE_CODE (TYPE_TARGET_TYPE (type2)) == TYPE_CODE_STRUCT));
 262 }
 263
 264 /* Check to see if argument is a structure.  This is called so
 265    we know whether to go ahead with the normal unop or look for a
 266    user defined function instead.
 267
 268    For now, we do not overload the `&' operator.  */
 269
 270 int
 271 unop_user_defined_p (enum exp_opcode op, value_ptr arg1)
 272 {
 273   struct type *type1;
 274   if (op == UNOP_ADDR)
 275     return 0;
 276   type1 = check_typedef (VALUE_TYPE (arg1));
 277   for (;;)
 278     {
 279       if (TYPE_CODE (type1) == TYPE_CODE_STRUCT)
 280         return 1;
 281       else if (TYPE_CODE (type1) == TYPE_CODE_REF)
 282         type1 = TYPE_TARGET_TYPE (type1);
 283       else
 284         return 0;
 285     }
 286 }
 287
 288 /* We know either arg1 or arg2 is a structure, so try to find the right
 289    user defined function.  Create an argument vector that calls
 290    arg1.operator @ (arg1,arg2) and return that value (where '@' is any
 291    binary operator which is legal for GNU C++).
 292
 293    OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
 294    is the opcode saying how to modify it.  Otherwise, OTHEROP is
 295    unused.  */
 296
 297 value_ptr
 298 value_x_binop (value_ptr arg1, value_ptr arg2, enum exp_opcode op,
 299                enum exp_opcode otherop, enum noside noside)
 300 {
 301   value_ptr *argvec;
 302   char *ptr;
 303   char tstr[13];
 304   int static_memfuncp;
 305
 306   COERCE_REF (arg1);
 307   COERCE_REF (arg2);
 308   COERCE_ENUM (arg1);
 309   COERCE_ENUM (arg2);
 310
 311   /* now we know that what we have to do is construct our
 312      arg vector and find the right function to call it with.  */
 313
 314   if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_STRUCT)
 315     error ("Can't do that binary op on that type");     /* FIXME be explicit */
 316
 317   argvec = (value_ptr *) alloca (sizeof (value_ptr) * 4);
 318   argvec[1] = value_addr (arg1);
 319   argvec[2] = arg2;
 320   argvec[3] = 0;
 321
 322   /* make the right function name up */
 323   strcpy (tstr, "operator__");
 324   ptr = tstr + 8;
 325   switch (op)
 326     {
 327     case BINOP_ADD:
 328       strcpy (ptr, "+");
 329       break;
 330     case BINOP_SUB:
 331       strcpy (ptr, "-");
 332       break;
 333     case BINOP_MUL:
 334       strcpy (ptr, "*");
 335       break;
 336     case BINOP_DIV:
 337       strcpy (ptr, "/");
 338       break;
 339     case BINOP_REM:
 340       strcpy (ptr, "%");
 341       break;
 342     case BINOP_LSH:
 343       strcpy (ptr, "<<");
 344       break;
 345     case BINOP_RSH:
 346       strcpy (ptr, ">>");
 347       break;
 348     case BINOP_BITWISE_AND:
 349       strcpy (ptr, "&");
 350       break;
 351     case BINOP_BITWISE_IOR:
 352       strcpy (ptr, "|");
 353       break;
 354     case BINOP_BITWISE_XOR:
 355       strcpy (ptr, "^");
 356       break;
 357     case BINOP_LOGICAL_AND:
 358       strcpy (ptr, "&&");
 359       break;
 360     case BINOP_LOGICAL_OR:
 361       strcpy (ptr, "||");
 362       break;
 363     case BINOP_MIN:
 364       strcpy (ptr, "<?");
 365       break;
 366     case BINOP_MAX:
 367       strcpy (ptr, ">?");
 368       break;
 369     case BINOP_ASSIGN:
 370       strcpy (ptr, "=");
 371       break;
 372     case BINOP_ASSIGN_MODIFY:
 373       switch (otherop)
 374         {
 375         case BINOP_ADD:
 376           strcpy (ptr, "+=");
 377           break;
 378         case BINOP_SUB:
 379           strcpy (ptr, "-=");
 380           break;
 381         case BINOP_MUL:
 382           strcpy (ptr, "*=");
 383           break;
 384         case BINOP_DIV:
 385           strcpy (ptr, "/=");
 386           break;
 387         case BINOP_REM:
 388           strcpy (ptr, "%=");
 389           break;
 390         case BINOP_BITWISE_AND:
 391           strcpy (ptr, "&=");
 392           break;
 393         case BINOP_BITWISE_IOR:
 394           strcpy (ptr, "|=");
 395           break;
 396         case BINOP_BITWISE_XOR:
 397           strcpy (ptr, "^=");
 398           break;
 399         case BINOP_MOD: /* invalid */
 400         default:
 401           error ("Invalid binary operation specified.");
 402         }
 403       break;
 404     case BINOP_SUBSCRIPT:
 405       strcpy (ptr, "[]");
 406       break;
 407     case BINOP_EQUAL:
 408       strcpy (ptr, "==");
 409       break;
 410     case BINOP_NOTEQUAL:
 411       strcpy (ptr, "!=");
 412       break;
 413     case BINOP_LESS:
 414       strcpy (ptr, "<");
 415       break;
 416     case BINOP_GTR:
 417       strcpy (ptr, ">");
 418       break;
 419     case BINOP_GEQ:
 420       strcpy (ptr, ">=");
 421       break;
 422     case BINOP_LEQ:
 423       strcpy (ptr, "<=");
 424       break;
 425     case BINOP_MOD:             /* invalid */
 426     default:
 427       error ("Invalid binary operation specified.");
 428     }
 429
 430   argvec[0] = value_struct_elt (&arg1, argvec + 1, tstr, &static_memfuncp, "structure");
 431
 432   if (argvec[0])
 433     {
 434       if (static_memfuncp)
 435         {
 436           argvec[1] = argvec[0];
 437           argvec++;
 438         }
 439       if (noside == EVAL_AVOID_SIDE_EFFECTS)
 440         {
 441           struct type *return_type;
 442           return_type
 443             = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (argvec[0])));
 444           return value_zero (return_type, VALUE_LVAL (arg1));
 445         }
 446       return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
 447     }
 448   error ("member function %s not found", tstr);
 449 #ifdef lint
 450   return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
 451 #endif
 452 }
 453
 454 /* We know that arg1 is a structure, so try to find a unary user
 455    defined operator that matches the operator in question.
 456    Create an argument vector that calls arg1.operator @ (arg1)
 457    and return that value (where '@' is (almost) any unary operator which
 458    is legal for GNU C++).  */
 459
 460 value_ptr
 461 value_x_unop (value_ptr arg1, enum exp_opcode op, enum noside noside)
 462 {
 463   value_ptr *argvec;
 464   char *ptr, *mangle_ptr;
 465   char tstr[13], mangle_tstr[13];
 466   int static_memfuncp;
 467
 468   COERCE_REF (arg1);
 469   COERCE_ENUM (arg1);
 470
 471   /* now we know that what we have to do is construct our
 472      arg vector and find the right function to call it with.  */
 473
 474   if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_STRUCT)
 475     error ("Can't do that unary op on that type");      /* FIXME be explicit */
 476
 477   argvec = (value_ptr *) alloca (sizeof (value_ptr) * 3);
 478   argvec[1] = value_addr (arg1);
 479   argvec[2] = 0;
 480
 481   /* make the right function name up */
 482   strcpy (tstr, "operator__");
 483   ptr = tstr + 8;
 484   strcpy (mangle_tstr, "__");
 485   mangle_ptr = mangle_tstr + 2;
 486   switch (op)
 487     {
 488     case UNOP_PREINCREMENT:
 489       strcpy (ptr, "++");
 490       break;
 491     case UNOP_PREDECREMENT:
 492       strcpy (ptr, "++");
 493       break;
 494     case UNOP_POSTINCREMENT:
 495       strcpy (ptr, "++");
 496       break;
 497     case UNOP_POSTDECREMENT:
 498       strcpy (ptr, "++");
 499       break;
 500     case UNOP_LOGICAL_NOT:
 501       strcpy (ptr, "!");
 502       break;
 503     case UNOP_COMPLEMENT:
 504       strcpy (ptr, "~");
 505       break;
 506     case UNOP_NEG:
 507       strcpy (ptr, "-");
 508       break;
 509     case UNOP_IND:
 510       strcpy (ptr, "*");
 511       break;
 512     default:
 513       error ("Invalid unary operation specified.");
 514     }
 515
 516   argvec[0] = value_struct_elt (&arg1, argvec + 1, tstr, &static_memfuncp, "structure");
 517
 518   if (argvec[0])
 519     {
 520       if (static_memfuncp)
 521         {
 522           argvec[1] = argvec[0];
 523           argvec++;
 524         }
 525       if (noside == EVAL_AVOID_SIDE_EFFECTS)
 526         {
 527           struct type *return_type;
 528           return_type
 529             = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (argvec[0])));
 530           return value_zero (return_type, VALUE_LVAL (arg1));
 531         }
 532       return call_function_by_hand (argvec[0], 1 - static_memfuncp, argvec + 1);
 533     }
 534   error ("member function %s not found", tstr);
 535   return 0;                     /* For lint -- never reached */
 536 }
 537 \f
 538
 539 /* Concatenate two values with the following conditions:
 540
 541    (1)  Both values must be either bitstring values or character string
 542    values and the resulting value consists of the concatenation of
 543    ARG1 followed by ARG2.
 544
 545    or
 546
 547    One value must be an integer value and the other value must be
 548    either a bitstring value or character string value, which is
 549    to be repeated by the number of times specified by the integer
 550    value.
 551
 552
 553    (2)  Boolean values are also allowed and are treated as bit string
 554    values of length 1.
 555
 556    (3)  Character values are also allowed and are treated as character
 557    string values of length 1.
 558  */
 559
 560 value_ptr
 561 value_concat (value_ptr arg1, value_ptr arg2)
 562 {
 563   register value_ptr inval1, inval2, outval = NULL;
 564   int inval1len, inval2len;
 565   int count, idx;
 566   char *ptr;
 567   char inchar;
 568   struct type *type1 = check_typedef (VALUE_TYPE (arg1));
 569   struct type *type2 = check_typedef (VALUE_TYPE (arg2));
 570
 571   COERCE_VARYING_ARRAY (arg1, type1);
 572   COERCE_VARYING_ARRAY (arg2, type2);
 573
 574   /* First figure out if we are dealing with two values to be concatenated
 575      or a repeat count and a value to be repeated.  INVAL1 is set to the
 576      first of two concatenated values, or the repeat count.  INVAL2 is set
 577      to the second of the two concatenated values or the value to be
 578      repeated. */
 579
 580   if (TYPE_CODE (type2) == TYPE_CODE_INT)
 581     {
 582       struct type *tmp = type1;
 583       type1 = tmp;
 584       tmp = type2;
 585       inval1 = arg2;
 586       inval2 = arg1;
 587     }
 588   else
 589     {
 590       inval1 = arg1;
 591       inval2 = arg2;
 592     }
 593
 594   /* Now process the input values. */
 595
 596   if (TYPE_CODE (type1) == TYPE_CODE_INT)
 597     {
 598       /* We have a repeat count.  Validate the second value and then
 599          construct a value repeated that many times. */
 600       if (TYPE_CODE (type2) == TYPE_CODE_STRING
 601           || TYPE_CODE (type2) == TYPE_CODE_CHAR)
 602         {
 603           count = longest_to_int (value_as_long (inval1));
 604           inval2len = TYPE_LENGTH (type2);
 605           ptr = (char *) alloca (count * inval2len);
 606           if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
 607             {
 608               inchar = (char) unpack_long (type2,
 609                                            VALUE_CONTENTS (inval2));
 610               for (idx = 0; idx < count; idx++)
 611                 {
 612                   *(ptr + idx) = inchar;
 613                 }
 614             }
 615           else
 616             {
 617               for (idx = 0; idx < count; idx++)
 618                 {
 619                   memcpy (ptr + (idx * inval2len), VALUE_CONTENTS (inval2),
 620                           inval2len);
 621                 }
 622             }
 623           outval = value_string (ptr, count * inval2len);
 624         }
 625       else if (TYPE_CODE (type2) == TYPE_CODE_BITSTRING
 626                || TYPE_CODE (type2) == TYPE_CODE_BOOL)
 627         {
 628           error ("unimplemented support for bitstring/boolean repeats");
 629         }
 630       else
 631         {
 632           error ("can't repeat values of that type");
 633         }
 634     }
 635   else if (TYPE_CODE (type1) == TYPE_CODE_STRING
 636            || TYPE_CODE (type1) == TYPE_CODE_CHAR)
 637     {
 638       /* We have two character strings to concatenate. */
 639       if (TYPE_CODE (type2) != TYPE_CODE_STRING
 640           && TYPE_CODE (type2) != TYPE_CODE_CHAR)
 641         {
 642           error ("Strings can only be concatenated with other strings.");
 643         }
 644       inval1len = TYPE_LENGTH (type1);
 645       inval2len = TYPE_LENGTH (type2);
 646       ptr = (char *) alloca (inval1len + inval2len);
 647       if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
 648         {
 649           *ptr = (char) unpack_long (type1, VALUE_CONTENTS (inval1));
 650         }
 651       else
 652         {
 653           memcpy (ptr, VALUE_CONTENTS (inval1), inval1len);
 654         }
 655       if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
 656         {
 657           *(ptr + inval1len) =
 658             (char) unpack_long (type2, VALUE_CONTENTS (inval2));
 659         }
 660       else
 661         {
 662           memcpy (ptr + inval1len, VALUE_CONTENTS (inval2), inval2len);
 663         }
 664       outval = value_string (ptr, inval1len + inval2len);
 665     }
 666   else if (TYPE_CODE (type1) == TYPE_CODE_BITSTRING
 667            || TYPE_CODE (type1) == TYPE_CODE_BOOL)
 668     {
 669       /* We have two bitstrings to concatenate. */
 670       if (TYPE_CODE (type2) != TYPE_CODE_BITSTRING
 671           && TYPE_CODE (type2) != TYPE_CODE_BOOL)
 672         {
 673           error ("Bitstrings or booleans can only be concatenated with other bitstrings or booleans.");
 674         }
 675       error ("unimplemented support for bitstring/boolean concatenation.");
 676     }
 677   else
 678     {
 679       /* We don't know how to concatenate these operands. */
 680       error ("illegal operands for concatenation.");
 681     }
 682   return (outval);
 683 }
 684 \f
 685
 686
 687 /* Perform a binary operation on two operands which have reasonable
 688    representations as integers or floats.  This includes booleans,
 689    characters, integers, or floats.
 690    Does not support addition and subtraction on pointers;
 691    use value_add or value_sub if you want to handle those possibilities.  */
 692
 693 value_ptr
 694 value_binop (value_ptr arg1, value_ptr arg2, enum exp_opcode op)
 695 {
 696   register value_ptr val;
 697   struct type *type1, *type2;
 698
 699   COERCE_REF (arg1);
 700   COERCE_REF (arg2);
 701   COERCE_ENUM (arg1);
 702   COERCE_ENUM (arg2);
 703   type1 = check_typedef (VALUE_TYPE (arg1));
 704   type2 = check_typedef (VALUE_TYPE (arg2));
 705
 706   if ((TYPE_CODE (type1) != TYPE_CODE_FLT
 707        && TYPE_CODE (type1) != TYPE_CODE_CHAR
 708        && TYPE_CODE (type1) != TYPE_CODE_INT
 709        && TYPE_CODE (type1) != TYPE_CODE_BOOL
 710        && TYPE_CODE (type1) != TYPE_CODE_RANGE)
 711       ||
 712       (TYPE_CODE (type2) != TYPE_CODE_FLT
 713        && TYPE_CODE (type2) != TYPE_CODE_CHAR
 714        && TYPE_CODE (type2) != TYPE_CODE_INT
 715        && TYPE_CODE (type2) != TYPE_CODE_BOOL
 716        && TYPE_CODE (type2) != TYPE_CODE_RANGE))
 717     error ("Argument to arithmetic operation not a number or boolean.");
 718
 719   if (TYPE_CODE (type1) == TYPE_CODE_FLT
 720       ||
 721       TYPE_CODE (type2) == TYPE_CODE_FLT)
 722     {
 723       /* FIXME-if-picky-about-floating-accuracy: Should be doing this
 724          in target format.  real.c in GCC probably has the necessary
 725          code.  */
 726       DOUBLEST v1, v2, v = 0;
 727       v1 = value_as_double (arg1);
 728       v2 = value_as_double (arg2);
 729       switch (op)
 730         {
 731         case BINOP_ADD:
 732           v = v1 + v2;
 733           break;
 734
 735         case BINOP_SUB:
 736           v = v1 - v2;
 737           break;
 738
 739         case BINOP_MUL:
 740           v = v1 * v2;
 741           break;
 742
 743         case BINOP_DIV:
 744           v = v1 / v2;
 745           break;
 746
 747         case BINOP_EXP:
 748           v = pow (v1, v2);
 749           if (errno)
 750             error ("Cannot perform exponentiation: %s", strerror (errno));
 751           break;
 752
 753         default:
 754           error ("Integer-only operation on floating point number.");
 755         }
 756
 757       /* If either arg was long double, make sure that value is also long
 758          double.  */
 759
 760       if (TYPE_LENGTH (type1) * 8 > TARGET_DOUBLE_BIT
 761           || TYPE_LENGTH (type2) * 8 > TARGET_DOUBLE_BIT)
 762         val = allocate_value (builtin_type_long_double);
 763       else
 764         val = allocate_value (builtin_type_double);
 765
 766       store_typed_floating (VALUE_CONTENTS_RAW (val), VALUE_TYPE (val), v);
 767     }
 768   else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
 769            &&
 770            TYPE_CODE (type2) == TYPE_CODE_BOOL)
 771     {
 772       LONGEST v1, v2, v = 0;
 773       v1 = value_as_long (arg1);
 774       v2 = value_as_long (arg2);
 775
 776       switch (op)
 777         {
 778         case BINOP_BITWISE_AND:
 779           v = v1 & v2;
 780           break;
 781
 782         case BINOP_BITWISE_IOR:
 783           v = v1 | v2;
 784           break;
 785
 786         case BINOP_BITWISE_XOR:
 787           v = v1 ^ v2;
 788           break;
 789
 790         case BINOP_EQUAL:
 791           v = v1 == v2;
 792           break;
 793
 794         case BINOP_NOTEQUAL:
 795           v = v1 != v2;
 796           break;
 797
 798         default:
 799           error ("Invalid operation on booleans.");
 800         }
 801
 802       val = allocate_value (type1);
 803       store_signed_integer (VALUE_CONTENTS_RAW (val),
 804                             TYPE_LENGTH (type1),
 805                             v);
 806     }
 807   else
 808     /* Integral operations here.  */
 809     /* FIXME:  Also mixed integral/booleans, with result an integer. */
 810     /* FIXME: This implements ANSI C rules (also correct for C++).
 811        What about FORTRAN and chill?  */
 812     {
 813       unsigned int promoted_len1 = TYPE_LENGTH (type1);
 814       unsigned int promoted_len2 = TYPE_LENGTH (type2);
 815       int is_unsigned1 = TYPE_UNSIGNED (type1);
 816       int is_unsigned2 = TYPE_UNSIGNED (type2);
 817       unsigned int result_len;
 818       int unsigned_operation;
 819
 820       /* Determine type length and signedness after promotion for
 821          both operands.  */
 822       if (promoted_len1 < TYPE_LENGTH (builtin_type_int))
 823         {
 824           is_unsigned1 = 0;
 825           promoted_len1 = TYPE_LENGTH (builtin_type_int);
 826         }
 827       if (promoted_len2 < TYPE_LENGTH (builtin_type_int))
 828         {
 829           is_unsigned2 = 0;
 830           promoted_len2 = TYPE_LENGTH (builtin_type_int);
 831         }
 832
 833       /* Determine type length of the result, and if the operation should
 834          be done unsigned.
 835          Use the signedness of the operand with the greater length.
 836          If both operands are of equal length, use unsigned operation
 837          if one of the operands is unsigned.  */
 838       if (promoted_len1 > promoted_len2)
 839         {
 840           unsigned_operation = is_unsigned1;
 841           result_len = promoted_len1;
 842         }
 843       else if (promoted_len2 > promoted_len1)
 844         {
 845           unsigned_operation = is_unsigned2;
 846           result_len = promoted_len2;
 847         }
 848       else
 849         {
 850           unsigned_operation = is_unsigned1 || is_unsigned2;
 851           result_len = promoted_len1;
 852         }
 853
 854       if (unsigned_operation)
 855         {
 856           ULONGEST v1, v2, v = 0;
 857           v1 = (ULONGEST) value_as_long (arg1);
 858           v2 = (ULONGEST) value_as_long (arg2);
 859
 860           /* Truncate values to the type length of the result.  */
 861           if (result_len < sizeof (ULONGEST))
 862             {
 863               v1 &= ((LONGEST) 1 << HOST_CHAR_BIT * result_len) - 1;
 864               v2 &= ((LONGEST) 1 << HOST_CHAR_BIT * result_len) - 1;
 865             }
 866
 867           switch (op)
 868             {
 869             case BINOP_ADD:
 870               v = v1 + v2;
 871               break;
 872
 873             case BINOP_SUB:
 874               v = v1 - v2;
 875               break;
 876
 877             case BINOP_MUL:
 878               v = v1 * v2;
 879               break;
 880
 881             case BINOP_DIV:
 882               v = v1 / v2;
 883               break;
 884
 885             case BINOP_EXP:
 886               v = pow (v1, v2);
 887               if (errno)
 888                 error ("Cannot perform exponentiation: %s", strerror (errno));
 889               break;
 890
 891             case BINOP_REM:
 892               v = v1 % v2;
 893               break;
 894
 895             case BINOP_MOD:
 896               /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
 897                  v1 mod 0 has a defined value, v1. */
 898               /* Chill specifies that v2 must be > 0, so check for that. */
 899               if (current_language->la_language == language_chill
 900                   && value_as_long (arg2) <= 0)
 901                 {
 902                   error ("Second operand of MOD must be greater than zero.");
 903                 }
 904               if (v2 == 0)
 905                 {
 906                   v = v1;
 907                 }
 908               else
 909                 {
 910                   v = v1 / v2;
 911                   /* Note floor(v1/v2) == v1/v2 for unsigned. */
 912                   v = v1 - (v2 * v);
 913                 }
 914               break;
 915
 916             case BINOP_LSH:
 917               v = v1 << v2;
 918               break;
 919
 920             case BINOP_RSH:
 921               v = v1 >> v2;
 922               break;
 923
 924             case BINOP_BITWISE_AND:
 925               v = v1 & v2;
 926               break;
 927
 928             case BINOP_BITWISE_IOR:
 929               v = v1 | v2;
 930               break;
 931
 932             case BINOP_BITWISE_XOR:
 933               v = v1 ^ v2;
 934               break;
 935
 936             case BINOP_LOGICAL_AND:
 937               v = v1 && v2;
 938               break;
 939
 940             case BINOP_LOGICAL_OR:
 941               v = v1 || v2;
 942               break;
 943
 944             case BINOP_MIN:
 945               v = v1 < v2 ? v1 : v2;
 946               break;
 947
 948             case BINOP_MAX:
 949               v = v1 > v2 ? v1 : v2;
 950               break;
 951
 952             case BINOP_EQUAL:
 953               v = v1 == v2;
 954               break;
 955
 956             case BINOP_NOTEQUAL:
 957               v = v1 != v2;
 958               break;
 959
 960             case BINOP_LESS:
 961               v = v1 < v2;
 962               break;
 963
 964             default:
 965               error ("Invalid binary operation on numbers.");
 966             }
 967
 968           /* This is a kludge to get around the fact that we don't
 969              know how to determine the result type from the types of
 970              the operands.  (I'm not really sure how much we feel the
 971              need to duplicate the exact rules of the current
 972              language.  They can get really hairy.  But not to do so
 973              makes it hard to document just what we *do* do).  */
 974
 975           /* Can't just call init_type because we wouldn't know what
 976              name to give the type.  */
 977           val = allocate_value
 978             (result_len > TARGET_LONG_BIT / HOST_CHAR_BIT
 979              ? builtin_type_unsigned_long_long
 980              : builtin_type_unsigned_long);
 981           store_unsigned_integer (VALUE_CONTENTS_RAW (val),
 982                                   TYPE_LENGTH (VALUE_TYPE (val)),
 983                                   v);
 984         }
 985       else
 986         {
 987           LONGEST v1, v2, v = 0;
 988           v1 = value_as_long (arg1);
 989           v2 = value_as_long (arg2);
 990
 991           switch (op)
 992             {
 993             case BINOP_ADD:
 994               v = v1 + v2;
 995               break;
 996
 997             case BINOP_SUB:
 998               v = v1 - v2;
 999               break;
1000
1001             case BINOP_MUL:
1002               v = v1 * v2;
1003               break;
1004
1005             case BINOP_DIV:
1006               v = v1 / v2;
1007               break;
1008
1009             case BINOP_EXP:
1010               v = pow (v1, v2);
1011               if (errno)
1012                 error ("Cannot perform exponentiation: %s", strerror (errno));
1013               break;
1014
1015             case BINOP_REM:
1016               v = v1 % v2;
1017               break;
1018
1019             case BINOP_MOD:
1020               /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
1021                  X mod 0 has a defined value, X. */
1022               /* Chill specifies that v2 must be > 0, so check for that. */
1023               if (current_language->la_language == language_chill
1024                   && v2 <= 0)
1025                 {
1026                   error ("Second operand of MOD must be greater than zero.");
1027                 }
1028               if (v2 == 0)
1029                 {
1030                   v = v1;
1031                 }
1032               else
1033                 {
1034                   v = v1 / v2;
1035                   /* Compute floor. */
1036                   if (TRUNCATION_TOWARDS_ZERO && (v < 0) && ((v1 % v2) != 0))
1037                     {
1038                       v--;
1039                     }
1040                   v = v1 - (v2 * v);
1041                 }
1042               break;
1043
1044             case BINOP_LSH:
1045               v = v1 << v2;
1046               break;
1047
1048             case BINOP_RSH:
1049               v = v1 >> v2;
1050               break;
1051
1052             case BINOP_BITWISE_AND:
1053               v = v1 & v2;
1054               break;
1055
1056             case BINOP_BITWISE_IOR:
1057               v = v1 | v2;
1058               break;
1059
1060             case BINOP_BITWISE_XOR:
1061               v = v1 ^ v2;
1062               break;
1063
1064             case BINOP_LOGICAL_AND:
1065               v = v1 && v2;
1066               break;
1067
1068             case BINOP_LOGICAL_OR:
1069               v = v1 || v2;
1070               break;
1071
1072             case BINOP_MIN:
1073               v = v1 < v2 ? v1 : v2;
1074               break;
1075
1076             case BINOP_MAX:
1077               v = v1 > v2 ? v1 : v2;
1078               break;
1079
1080             case BINOP_EQUAL:
1081               v = v1 == v2;
1082               break;
1083
1084             case BINOP_LESS:
1085               v = v1 < v2;
1086               break;
1087
1088             default:
1089               error ("Invalid binary operation on numbers.");
1090             }
1091
1092           /* This is a kludge to get around the fact that we don't
1093              know how to determine the result type from the types of
1094              the operands.  (I'm not really sure how much we feel the
1095              need to duplicate the exact rules of the current
1096              language.  They can get really hairy.  But not to do so
1097              makes it hard to document just what we *do* do).  */
1098
1099           /* Can't just call init_type because we wouldn't know what
1100              name to give the type.  */
1101           val = allocate_value
1102             (result_len > TARGET_LONG_BIT / HOST_CHAR_BIT
1103              ? builtin_type_long_long
1104              : builtin_type_long);
1105           store_signed_integer (VALUE_CONTENTS_RAW (val),
1106                                 TYPE_LENGTH (VALUE_TYPE (val)),
1107                                 v);
1108         }
1109     }
1110
1111   return val;
1112 }
1113 \f
1114 /* Simulate the C operator ! -- return 1 if ARG1 contains zero.  */
1115
1116 int
1117 value_logical_not (value_ptr arg1)
1118 {
1119   register int len;
1120   register char *p;
1121   struct type *type1;
1122
1123   COERCE_NUMBER (arg1);
1124   type1 = check_typedef (VALUE_TYPE (arg1));
1125
1126   if (TYPE_CODE (type1) == TYPE_CODE_FLT)
1127     return 0 == value_as_double (arg1);
1128
1129   len = TYPE_LENGTH (type1);
1130   p = VALUE_CONTENTS (arg1);
1131
1132   while (--len >= 0)
1133     {
1134       if (*p++)
1135         break;
1136     }
1137
1138   return len < 0;
1139 }
1140
1141 /* Perform a comparison on two string values (whose content are not
1142    necessarily null terminated) based on their length */
1143
1144 static int
1145 value_strcmp (register value_ptr arg1, register value_ptr arg2)
1146 {
1147   int len1 = TYPE_LENGTH (VALUE_TYPE (arg1));
1148   int len2 = TYPE_LENGTH (VALUE_TYPE (arg2));
1149   char *s1 = VALUE_CONTENTS (arg1);
1150   char *s2 = VALUE_CONTENTS (arg2);
1151   int i, len = len1 < len2 ? len1 : len2;
1152
1153   for (i = 0; i < len; i++)
1154     {
1155       if (s1[i] < s2[i])
1156         return -1;
1157       else if (s1[i] > s2[i])
1158         return 1;
1159       else
1160         continue;
1161     }
1162
1163   if (len1 < len2)
1164     return -1;
1165   else if (len1 > len2)
1166     return 1;
1167   else
1168     return 0;
1169 }
1170
1171 /* Simulate the C operator == by returning a 1
1172    iff ARG1 and ARG2 have equal contents.  */
1173
1174 int
1175 value_equal (register value_ptr arg1, register value_ptr arg2)
1176 {
1177   register int len;
1178   register char *p1, *p2;
1179   struct type *type1, *type2;
1180   enum type_code code1;
1181   enum type_code code2;
1182
1183   COERCE_NUMBER (arg1);
1184   COERCE_NUMBER (arg2);
1185
1186   type1 = check_typedef (VALUE_TYPE (arg1));
1187   type2 = check_typedef (VALUE_TYPE (arg2));
1188   code1 = TYPE_CODE (type1);
1189   code2 = TYPE_CODE (type2);
1190
1191   if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL) &&
1192       (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
1193     return longest_to_int (value_as_long (value_binop (arg1, arg2,
1194                                                        BINOP_EQUAL)));
1195   else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL)
1196            && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
1197     return value_as_double (arg1) == value_as_double (arg2);
1198
1199   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1200      is bigger.  */
1201   else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
1202     return value_as_address (arg1) == (CORE_ADDR) value_as_long (arg2);
1203   else if (code2 == TYPE_CODE_PTR && (code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL))
1204     return (CORE_ADDR) value_as_long (arg1) == value_as_address (arg2);
1205
1206   else if (code1 == code2
1207            && ((len = (int) TYPE_LENGTH (type1))
1208                == (int) TYPE_LENGTH (type2)))
1209     {
1210       p1 = VALUE_CONTENTS (arg1);
1211       p2 = VALUE_CONTENTS (arg2);
1212       while (--len >= 0)
1213         {
1214           if (*p1++ != *p2++)
1215             break;
1216         }
1217       return len < 0;
1218     }
1219   else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1220     {
1221       return value_strcmp (arg1, arg2) == 0;
1222     }
1223   else
1224     {
1225       error ("Invalid type combination in equality test.");
1226       return 0;                 /* For lint -- never reached */
1227     }
1228 }
1229
1230 /* Simulate the C operator < by returning 1
1231    iff ARG1's contents are less than ARG2's.  */
1232
1233 int
1234 value_less (register value_ptr arg1, register value_ptr arg2)
1235 {
1236   register enum type_code code1;
1237   register enum type_code code2;
1238   struct type *type1, *type2;
1239
1240   COERCE_NUMBER (arg1);
1241   COERCE_NUMBER (arg2);
1242
1243   type1 = check_typedef (VALUE_TYPE (arg1));
1244   type2 = check_typedef (VALUE_TYPE (arg2));
1245   code1 = TYPE_CODE (type1);
1246   code2 = TYPE_CODE (type2);
1247
1248   if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL) &&
1249       (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
1250     return longest_to_int (value_as_long (value_binop (arg1, arg2,
1251                                                        BINOP_LESS)));
1252   else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL)
1253            && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
1254     return value_as_double (arg1) < value_as_double (arg2);
1255   else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
1256     return value_as_address (arg1) < value_as_address (arg2);
1257
1258   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1259      is bigger.  */
1260   else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
1261     return value_as_address (arg1) < (CORE_ADDR) value_as_long (arg2);
1262   else if (code2 == TYPE_CODE_PTR && (code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL))
1263     return (CORE_ADDR) value_as_long (arg1) < value_as_address (arg2);
1264   else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1265     return value_strcmp (arg1, arg2) < 0;
1266   else
1267     {
1268       error ("Invalid type combination in ordering comparison.");
1269       return 0;
1270     }
1271 }
1272 \f
1273 /* The unary operators - and ~.  Both free the argument ARG1.  */
1274
1275 value_ptr
1276 value_neg (register value_ptr arg1)
1277 {
1278   register struct type *type;
1279   register struct type *result_type = VALUE_TYPE (arg1);
1280
1281   COERCE_REF (arg1);
1282   COERCE_ENUM (arg1);
1283
1284   type = check_typedef (VALUE_TYPE (arg1));
1285
1286   if (TYPE_CODE (type) == TYPE_CODE_FLT)
1287     return value_from_double (result_type, -value_as_double (arg1));
1288   else if (TYPE_CODE (type) == TYPE_CODE_INT || TYPE_CODE (type) == TYPE_CODE_BOOL)
1289     {
1290       /* Perform integral promotion for ANSI C/C++.
1291          FIXME: What about FORTRAN and chill ?  */
1292       if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1293         result_type = builtin_type_int;
1294
1295       return value_from_longest (result_type, -value_as_long (arg1));
1296     }
1297   else
1298     {
1299       error ("Argument to negate operation not a number.");
1300       return 0;                 /* For lint -- never reached */
1301     }
1302 }
1303
1304 value_ptr
1305 value_complement (register value_ptr arg1)
1306 {
1307   register struct type *type;
1308   register struct type *result_type = VALUE_TYPE (arg1);
1309   int typecode;
1310
1311   COERCE_REF (arg1);
1312   COERCE_ENUM (arg1);
1313
1314   type = check_typedef (VALUE_TYPE (arg1));
1315
1316   typecode = TYPE_CODE (type);
1317   if ((typecode != TYPE_CODE_INT) && (typecode != TYPE_CODE_BOOL))
1318     error ("Argument to complement operation not an integer or boolean.");
1319
1320   /* Perform integral promotion for ANSI C/C++.
1321      FIXME: What about FORTRAN ?  */
1322   if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1323     result_type = builtin_type_int;
1324
1325   return value_from_longest (result_type, ~value_as_long (arg1));
1326 }
1327 \f
1328 /* The INDEX'th bit of SET value whose VALUE_TYPE is TYPE,
1329    and whose VALUE_CONTENTS is valaddr.
1330    Return -1 if out of range, -2 other error. */
1331
1332 int
1333 value_bit_index (struct type *type, char *valaddr, int index)
1334 {
1335   LONGEST low_bound, high_bound;
1336   LONGEST word;
1337   unsigned rel_index;
1338   struct type *range = TYPE_FIELD_TYPE (type, 0);
1339   if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
1340     return -2;
1341   if (index < low_bound || index > high_bound)
1342     return -1;
1343   rel_index = index - low_bound;
1344   word = unpack_long (builtin_type_unsigned_char,
1345                       valaddr + (rel_index / TARGET_CHAR_BIT));
1346   rel_index %= TARGET_CHAR_BIT;
1347   if (BITS_BIG_ENDIAN)
1348     rel_index = TARGET_CHAR_BIT - 1 - rel_index;
1349   return (word >> rel_index) & 1;
1350 }
1351
1352 value_ptr
1353 value_in (value_ptr element, value_ptr set)
1354 {
1355   int member;
1356   struct type *settype = check_typedef (VALUE_TYPE (set));
1357   struct type *eltype = check_typedef (VALUE_TYPE (element));
1358   if (TYPE_CODE (eltype) == TYPE_CODE_RANGE)
1359     eltype = TYPE_TARGET_TYPE (eltype);
1360   if (TYPE_CODE (settype) != TYPE_CODE_SET)
1361     error ("Second argument of 'IN' has wrong type");
1362   if (TYPE_CODE (eltype) != TYPE_CODE_INT
1363       && TYPE_CODE (eltype) != TYPE_CODE_CHAR
1364       && TYPE_CODE (eltype) != TYPE_CODE_ENUM
1365       && TYPE_CODE (eltype) != TYPE_CODE_BOOL)
1366     error ("First argument of 'IN' has wrong type");
1367   member = value_bit_index (settype, VALUE_CONTENTS (set),
1368                             value_as_long (element));
1369   if (member < 0)
1370     error ("First argument of 'IN' not in range");
1371   return value_from_longest (LA_BOOL_TYPE, member);
1372 }
1373
1374 void
1375 _initialize_valarith (void)
1376 {
1377 }