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 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 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 error (_("member function %s not found"), tstr); 545 #ifdef lint 546 return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1); 547 #endif 548 } 549 550 /* We know that arg1 is a structure, so try to find a unary user 551 defined operator that matches the operator in question. 552 Create an argument vector that calls arg1.operator @ (arg1) 553 and return that value (where '@' is (almost) any unary operator which 554 is legal for GNU C++). */ 555 556 struct value * 557 value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside) 558 { 559 struct gdbarch *gdbarch = get_type_arch (value_type (arg1)); 560 struct value **argvec; 561 char *ptr, *mangle_ptr; 562 char tstr[13], mangle_tstr[13]; 563 int static_memfuncp, nargs; 564 565 arg1 = coerce_ref (arg1); 566 567 /* now we know that what we have to do is construct our 568 arg vector and find the right function to call it with. */ 569 570 if (TYPE_CODE (check_typedef (value_type (arg1))) != TYPE_CODE_STRUCT) 571 error (_("Can't do that unary op on that type")); /* FIXME be explicit */ 572 573 argvec = (struct value **) alloca (sizeof (struct value *) * 4); 574 argvec[1] = value_addr (arg1); 575 argvec[2] = 0; 576 577 nargs = 1; 578 579 /* make the right function name up */ 580 strcpy (tstr, "operator__"); 581 ptr = tstr + 8; 582 strcpy (mangle_tstr, "__"); 583 mangle_ptr = mangle_tstr + 2; 584 switch (op) 585 { 586 case UNOP_PREINCREMENT: 587 strcpy (ptr, "++"); 588 break; 589 case UNOP_PREDECREMENT: 590 strcpy (ptr, "--"); 591 break; 592 case UNOP_POSTINCREMENT: 593 strcpy (ptr, "++"); 594 argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0); 595 argvec[3] = 0; 596 nargs ++; 597 break; 598 case UNOP_POSTDECREMENT: 599 strcpy (ptr, "--"); 600 argvec[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0); 601 argvec[3] = 0; 602 nargs ++; 603 break; 604 case UNOP_LOGICAL_NOT: 605 strcpy (ptr, "!"); 606 break; 607 case UNOP_COMPLEMENT: 608 strcpy (ptr, "~"); 609 break; 610 case UNOP_NEG: 611 strcpy (ptr, "-"); 612 break; 613 case UNOP_PLUS: 614 strcpy (ptr, "+"); 615 break; 616 case UNOP_IND: 617 strcpy (ptr, "*"); 618 break; 619 default: 620 error (_("Invalid unary operation specified.")); 621 } 622 623 argvec[0] = value_user_defined_op (&arg1, argvec + 1, tstr, 624 &static_memfuncp, nargs); 625 626 if (argvec[0]) 627 { 628 if (static_memfuncp) 629 { 630 argvec[1] = argvec[0]; 631 nargs --; 632 argvec++; 633 } 634 if (noside == EVAL_AVOID_SIDE_EFFECTS) 635 { 636 struct type *return_type; 637 638 return_type 639 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0]))); 640 return value_zero (return_type, VALUE_LVAL (arg1)); 641 } 642 return call_function_by_hand (argvec[0], nargs, argvec + 1); 643 } 644 error (_("member function %s not found"), tstr); 645 return 0; /* For lint -- never reached */ 646 } 647 648 649 /* Concatenate two values with the following conditions: 650 651 (1) Both values must be either bitstring values or character string 652 values and the resulting value consists of the concatenation of 653 ARG1 followed by ARG2. 654 655 or 656 657 One value must be an integer value and the other value must be 658 either a bitstring value or character string value, which is 659 to be repeated by the number of times specified by the integer 660 value. 661 662 663 (2) Boolean values are also allowed and are treated as bit string 664 values of length 1. 665 666 (3) Character values are also allowed and are treated as character 667 string values of length 1. 668 */ 669 670 struct value * 671 value_concat (struct value *arg1, struct value *arg2) 672 { 673 struct value *inval1; 674 struct value *inval2; 675 struct value *outval = NULL; 676 int inval1len, inval2len; 677 int count, idx; 678 char *ptr; 679 char inchar; 680 struct type *type1 = check_typedef (value_type (arg1)); 681 struct type *type2 = check_typedef (value_type (arg2)); 682 struct type *char_type; 683 684 /* First figure out if we are dealing with two values to be concatenated 685 or a repeat count and a value to be repeated. INVAL1 is set to the 686 first of two concatenated values, or the repeat count. INVAL2 is set 687 to the second of the two concatenated values or the value to be 688 repeated. */ 689 690 if (TYPE_CODE (type2) == TYPE_CODE_INT) 691 { 692 struct type *tmp = type1; 693 694 type1 = tmp; 695 tmp = type2; 696 inval1 = arg2; 697 inval2 = arg1; 698 } 699 else 700 { 701 inval1 = arg1; 702 inval2 = arg2; 703 } 704 705 /* Now process the input values. */ 706 707 if (TYPE_CODE (type1) == TYPE_CODE_INT) 708 { 709 /* We have a repeat count. Validate the second value and then 710 construct a value repeated that many times. */ 711 if (TYPE_CODE (type2) == TYPE_CODE_STRING 712 || TYPE_CODE (type2) == TYPE_CODE_CHAR) 713 { 714 count = longest_to_int (value_as_long (inval1)); 715 inval2len = TYPE_LENGTH (type2); 716 ptr = (char *) alloca (count * inval2len); 717 if (TYPE_CODE (type2) == TYPE_CODE_CHAR) 718 { 719 char_type = type2; 720 721 inchar = (char) unpack_long (type2, 722 value_contents (inval2)); 723 for (idx = 0; idx < count; idx++) 724 { 725 *(ptr + idx) = inchar; 726 } 727 } 728 else 729 { 730 char_type = TYPE_TARGET_TYPE (type2); 731 732 for (idx = 0; idx < count; idx++) 733 { 734 memcpy (ptr + (idx * inval2len), value_contents (inval2), 735 inval2len); 736 } 737 } 738 outval = value_string (ptr, count * inval2len, char_type); 739 } 740 else if (TYPE_CODE (type2) == TYPE_CODE_BITSTRING 741 || TYPE_CODE (type2) == TYPE_CODE_BOOL) 742 { 743 error (_("unimplemented support for bitstring/boolean repeats")); 744 } 745 else 746 { 747 error (_("can't repeat values of that type")); 748 } 749 } 750 else if (TYPE_CODE (type1) == TYPE_CODE_STRING 751 || TYPE_CODE (type1) == TYPE_CODE_CHAR) 752 { 753 /* We have two character strings to concatenate. */ 754 if (TYPE_CODE (type2) != TYPE_CODE_STRING 755 && TYPE_CODE (type2) != TYPE_CODE_CHAR) 756 { 757 error (_("Strings can only be concatenated with other strings.")); 758 } 759 inval1len = TYPE_LENGTH (type1); 760 inval2len = TYPE_LENGTH (type2); 761 ptr = (char *) alloca (inval1len + inval2len); 762 if (TYPE_CODE (type1) == TYPE_CODE_CHAR) 763 { 764 char_type = type1; 765 766 *ptr = (char) unpack_long (type1, value_contents (inval1)); 767 } 768 else 769 { 770 char_type = TYPE_TARGET_TYPE (type1); 771 772 memcpy (ptr, value_contents (inval1), inval1len); 773 } 774 if (TYPE_CODE (type2) == TYPE_CODE_CHAR) 775 { 776 *(ptr + inval1len) = 777 (char) unpack_long (type2, value_contents (inval2)); 778 } 779 else 780 { 781 memcpy (ptr + inval1len, value_contents (inval2), inval2len); 782 } 783 outval = value_string (ptr, inval1len + inval2len, char_type); 784 } 785 else if (TYPE_CODE (type1) == TYPE_CODE_BITSTRING 786 || TYPE_CODE (type1) == TYPE_CODE_BOOL) 787 { 788 /* We have two bitstrings to concatenate. */ 789 if (TYPE_CODE (type2) != TYPE_CODE_BITSTRING 790 && TYPE_CODE (type2) != TYPE_CODE_BOOL) 791 { 792 error (_("Bitstrings or booleans can only be concatenated with other bitstrings or booleans.")); 793 } 794 error (_("unimplemented support for bitstring/boolean concatenation.")); 795 } 796 else 797 { 798 /* We don't know how to concatenate these operands. */ 799 error (_("illegal operands for concatenation.")); 800 } 801 return (outval); 802 } 803 804 /* Integer exponentiation: V1**V2, where both arguments are 805 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */ 806 static LONGEST 807 integer_pow (LONGEST v1, LONGEST v2) 808 { 809 if (v2 < 0) 810 { 811 if (v1 == 0) 812 error (_("Attempt to raise 0 to negative power.")); 813 else 814 return 0; 815 } 816 else 817 { 818 /* The Russian Peasant's Algorithm */ 819 LONGEST v; 820 821 v = 1; 822 for (;;) 823 { 824 if (v2 & 1L) 825 v *= v1; 826 v2 >>= 1; 827 if (v2 == 0) 828 return v; 829 v1 *= v1; 830 } 831 } 832 } 833 834 /* Integer exponentiation: V1**V2, where both arguments are 835 integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */ 836 static ULONGEST 837 uinteger_pow (ULONGEST v1, LONGEST v2) 838 { 839 if (v2 < 0) 840 { 841 if (v1 == 0) 842 error (_("Attempt to raise 0 to negative power.")); 843 else 844 return 0; 845 } 846 else 847 { 848 /* The Russian Peasant's Algorithm */ 849 ULONGEST v; 850 851 v = 1; 852 for (;;) 853 { 854 if (v2 & 1L) 855 v *= v1; 856 v2 >>= 1; 857 if (v2 == 0) 858 return v; 859 v1 *= v1; 860 } 861 } 862 } 863 864 /* Obtain decimal value of arguments for binary operation, converting from 865 other types if one of them is not decimal floating point. */ 866 static void 867 value_args_as_decimal (struct value *arg1, struct value *arg2, 868 gdb_byte *x, int *len_x, enum bfd_endian *byte_order_x, 869 gdb_byte *y, int *len_y, enum bfd_endian *byte_order_y) 870 { 871 struct type *type1, *type2; 872 873 type1 = check_typedef (value_type (arg1)); 874 type2 = check_typedef (value_type (arg2)); 875 876 /* At least one of the arguments must be of decimal float type. */ 877 gdb_assert (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT 878 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT); 879 880 if (TYPE_CODE (type1) == TYPE_CODE_FLT 881 || TYPE_CODE (type2) == TYPE_CODE_FLT) 882 /* The DFP extension to the C language does not allow mixing of 883 * decimal float types with other float types in expressions 884 * (see WDTR 24732, page 12). */ 885 error (_("Mixing decimal floating types with other floating types is not allowed.")); 886 887 /* Obtain decimal value of arg1, converting from other types 888 if necessary. */ 889 890 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT) 891 { 892 *byte_order_x = gdbarch_byte_order (get_type_arch (type1)); 893 *len_x = TYPE_LENGTH (type1); 894 memcpy (x, value_contents (arg1), *len_x); 895 } 896 else if (is_integral_type (type1)) 897 { 898 *byte_order_x = gdbarch_byte_order (get_type_arch (type2)); 899 *len_x = TYPE_LENGTH (type2); 900 decimal_from_integral (arg1, x, *len_x, *byte_order_x); 901 } 902 else 903 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1), 904 TYPE_NAME (type2)); 905 906 /* Obtain decimal value of arg2, converting from other types 907 if necessary. */ 908 909 if (TYPE_CODE (type2) == TYPE_CODE_DECFLOAT) 910 { 911 *byte_order_y = gdbarch_byte_order (get_type_arch (type2)); 912 *len_y = TYPE_LENGTH (type2); 913 memcpy (y, value_contents (arg2), *len_y); 914 } 915 else if (is_integral_type (type2)) 916 { 917 *byte_order_y = gdbarch_byte_order (get_type_arch (type1)); 918 *len_y = TYPE_LENGTH (type1); 919 decimal_from_integral (arg2, y, *len_y, *byte_order_y); 920 } 921 else 922 error (_("Don't know how to convert from %s to %s."), TYPE_NAME (type1), 923 TYPE_NAME (type2)); 924 } 925 926 /* Perform a binary operation on two operands which have reasonable 927 representations as integers or floats. This includes booleans, 928 characters, integers, or floats. 929 Does not support addition and subtraction on pointers; 930 use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */ 931 932 struct value * 933 value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) 934 { 935 struct value *val; 936 struct type *type1, *type2, *result_type; 937 938 arg1 = coerce_ref (arg1); 939 arg2 = coerce_ref (arg2); 940 941 type1 = check_typedef (value_type (arg1)); 942 type2 = check_typedef (value_type (arg2)); 943 944 if ((TYPE_CODE (type1) != TYPE_CODE_FLT 945 && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT 946 && !is_integral_type (type1)) 947 || (TYPE_CODE (type2) != TYPE_CODE_FLT 948 && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT 949 && !is_integral_type (type2))) 950 error (_("Argument to arithmetic operation not a number or boolean.")); 951 952 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT 953 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT) 954 { 955 int len_v1, len_v2, len_v; 956 enum bfd_endian byte_order_v1, byte_order_v2, byte_order_v; 957 gdb_byte v1[16], v2[16]; 958 gdb_byte v[16]; 959 960 /* If only one type is decimal float, use its type. 961 Otherwise use the bigger type. */ 962 if (TYPE_CODE (type1) != TYPE_CODE_DECFLOAT) 963 result_type = type2; 964 else if (TYPE_CODE (type2) != TYPE_CODE_DECFLOAT) 965 result_type = type1; 966 else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1)) 967 result_type = type2; 968 else 969 result_type = type1; 970 971 len_v = TYPE_LENGTH (result_type); 972 byte_order_v = gdbarch_byte_order (get_type_arch (result_type)); 973 974 value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1, 975 v2, &len_v2, &byte_order_v2); 976 977 switch (op) 978 { 979 case BINOP_ADD: 980 case BINOP_SUB: 981 case BINOP_MUL: 982 case BINOP_DIV: 983 case BINOP_EXP: 984 decimal_binop (op, v1, len_v1, byte_order_v1, 985 v2, len_v2, byte_order_v2, 986 v, len_v, byte_order_v); 987 break; 988 989 default: 990 error (_("Operation not valid for decimal floating point number.")); 991 } 992 993 val = value_from_decfloat (result_type, v); 994 } 995 else if (TYPE_CODE (type1) == TYPE_CODE_FLT 996 || TYPE_CODE (type2) == TYPE_CODE_FLT) 997 { 998 /* FIXME-if-picky-about-floating-accuracy: Should be doing this 999 in target format. real.c in GCC probably has the necessary 1000 code. */ 1001 DOUBLEST v1, v2, v = 0; 1002 1003 v1 = value_as_double (arg1); 1004 v2 = value_as_double (arg2); 1005 1006 switch (op) 1007 { 1008 case BINOP_ADD: 1009 v = v1 + v2; 1010 break; 1011 1012 case BINOP_SUB: 1013 v = v1 - v2; 1014 break; 1015 1016 case BINOP_MUL: 1017 v = v1 * v2; 1018 break; 1019 1020 case BINOP_DIV: 1021 v = v1 / v2; 1022 break; 1023 1024 case BINOP_EXP: 1025 errno = 0; 1026 v = pow (v1, v2); 1027 if (errno) 1028 error (_("Cannot perform exponentiation: %s"), safe_strerror (errno)); 1029 break; 1030 1031 case BINOP_MIN: 1032 v = v1 < v2 ? v1 : v2; 1033 break; 1034 1035 case BINOP_MAX: 1036 v = v1 > v2 ? v1 : v2; 1037 break; 1038 1039 default: 1040 error (_("Integer-only operation on floating point number.")); 1041 } 1042 1043 /* If only one type is float, use its type. 1044 Otherwise use the bigger type. */ 1045 if (TYPE_CODE (type1) != TYPE_CODE_FLT) 1046 result_type = type2; 1047 else if (TYPE_CODE (type2) != TYPE_CODE_FLT) 1048 result_type = type1; 1049 else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1)) 1050 result_type = type2; 1051 else 1052 result_type = type1; 1053 1054 val = allocate_value (result_type); 1055 store_typed_floating (value_contents_raw (val), value_type (val), v); 1056 } 1057 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL 1058 || TYPE_CODE (type2) == TYPE_CODE_BOOL) 1059 { 1060 LONGEST v1, v2, v = 0; 1061 1062 v1 = value_as_long (arg1); 1063 v2 = value_as_long (arg2); 1064 1065 switch (op) 1066 { 1067 case BINOP_BITWISE_AND: 1068 v = v1 & v2; 1069 break; 1070 1071 case BINOP_BITWISE_IOR: 1072 v = v1 | v2; 1073 break; 1074 1075 case BINOP_BITWISE_XOR: 1076 v = v1 ^ v2; 1077 break; 1078 1079 case BINOP_EQUAL: 1080 v = v1 == v2; 1081 break; 1082 1083 case BINOP_NOTEQUAL: 1084 v = v1 != v2; 1085 break; 1086 1087 default: 1088 error (_("Invalid operation on booleans.")); 1089 } 1090 1091 result_type = type1; 1092 1093 val = allocate_value (result_type); 1094 store_signed_integer (value_contents_raw (val), 1095 TYPE_LENGTH (result_type), 1096 gdbarch_byte_order (get_type_arch (result_type)), 1097 v); 1098 } 1099 else 1100 /* Integral operations here. */ 1101 { 1102 /* Determine type length of the result, and if the operation should 1103 be done unsigned. For exponentiation and shift operators, 1104 use the length and type of the left operand. Otherwise, 1105 use the signedness of the operand with the greater length. 1106 If both operands are of equal length, use unsigned operation 1107 if one of the operands is unsigned. */ 1108 if (op == BINOP_RSH || op == BINOP_LSH || op == BINOP_EXP) 1109 result_type = type1; 1110 else if (TYPE_LENGTH (type1) > TYPE_LENGTH (type2)) 1111 result_type = type1; 1112 else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1)) 1113 result_type = type2; 1114 else if (TYPE_UNSIGNED (type1)) 1115 result_type = type1; 1116 else if (TYPE_UNSIGNED (type2)) 1117 result_type = type2; 1118 else 1119 result_type = type1; 1120 1121 if (TYPE_UNSIGNED (result_type)) 1122 { 1123 LONGEST v2_signed = value_as_long (arg2); 1124 ULONGEST v1, v2, v = 0; 1125 1126 v1 = (ULONGEST) value_as_long (arg1); 1127 v2 = (ULONGEST) v2_signed; 1128 1129 switch (op) 1130 { 1131 case BINOP_ADD: 1132 v = v1 + v2; 1133 break; 1134 1135 case BINOP_SUB: 1136 v = v1 - v2; 1137 break; 1138 1139 case BINOP_MUL: 1140 v = v1 * v2; 1141 break; 1142 1143 case BINOP_DIV: 1144 case BINOP_INTDIV: 1145 if (v2 != 0) 1146 v = v1 / v2; 1147 else 1148 error (_("Division by zero")); 1149 break; 1150 1151 case BINOP_EXP: 1152 v = uinteger_pow (v1, v2_signed); 1153 break; 1154 1155 case BINOP_REM: 1156 if (v2 != 0) 1157 v = v1 % v2; 1158 else 1159 error (_("Division by zero")); 1160 break; 1161 1162 case BINOP_MOD: 1163 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op, 1164 v1 mod 0 has a defined value, v1. */ 1165 if (v2 == 0) 1166 { 1167 v = v1; 1168 } 1169 else 1170 { 1171 v = v1 / v2; 1172 /* Note floor(v1/v2) == v1/v2 for unsigned. */ 1173 v = v1 - (v2 * v); 1174 } 1175 break; 1176 1177 case BINOP_LSH: 1178 v = v1 << v2; 1179 break; 1180 1181 case BINOP_RSH: 1182 v = v1 >> v2; 1183 break; 1184 1185 case BINOP_BITWISE_AND: 1186 v = v1 & v2; 1187 break; 1188 1189 case BINOP_BITWISE_IOR: 1190 v = v1 | v2; 1191 break; 1192 1193 case BINOP_BITWISE_XOR: 1194 v = v1 ^ v2; 1195 break; 1196 1197 case BINOP_LOGICAL_AND: 1198 v = v1 && v2; 1199 break; 1200 1201 case BINOP_LOGICAL_OR: 1202 v = v1 || v2; 1203 break; 1204 1205 case BINOP_MIN: 1206 v = v1 < v2 ? v1 : v2; 1207 break; 1208 1209 case BINOP_MAX: 1210 v = v1 > v2 ? v1 : v2; 1211 break; 1212 1213 case BINOP_EQUAL: 1214 v = v1 == v2; 1215 break; 1216 1217 case BINOP_NOTEQUAL: 1218 v = v1 != v2; 1219 break; 1220 1221 case BINOP_LESS: 1222 v = v1 < v2; 1223 break; 1224 1225 case BINOP_GTR: 1226 v = v1 > v2; 1227 break; 1228 1229 case BINOP_LEQ: 1230 v = v1 <= v2; 1231 break; 1232 1233 case BINOP_GEQ: 1234 v = v1 >= v2; 1235 break; 1236 1237 default: 1238 error (_("Invalid binary operation on numbers.")); 1239 } 1240 1241 val = allocate_value (result_type); 1242 store_unsigned_integer (value_contents_raw (val), 1243 TYPE_LENGTH (value_type (val)), 1244 gdbarch_byte_order 1245 (get_type_arch (result_type)), 1246 v); 1247 } 1248 else 1249 { 1250 LONGEST v1, v2, v = 0; 1251 1252 v1 = value_as_long (arg1); 1253 v2 = value_as_long (arg2); 1254 1255 switch (op) 1256 { 1257 case BINOP_ADD: 1258 v = v1 + v2; 1259 break; 1260 1261 case BINOP_SUB: 1262 v = v1 - v2; 1263 break; 1264 1265 case BINOP_MUL: 1266 v = v1 * v2; 1267 break; 1268 1269 case BINOP_DIV: 1270 case BINOP_INTDIV: 1271 if (v2 != 0) 1272 v = v1 / v2; 1273 else 1274 error (_("Division by zero")); 1275 break; 1276 1277 case BINOP_EXP: 1278 v = integer_pow (v1, v2); 1279 break; 1280 1281 case BINOP_REM: 1282 if (v2 != 0) 1283 v = v1 % v2; 1284 else 1285 error (_("Division by zero")); 1286 break; 1287 1288 case BINOP_MOD: 1289 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op, 1290 X mod 0 has a defined value, X. */ 1291 if (v2 == 0) 1292 { 1293 v = v1; 1294 } 1295 else 1296 { 1297 v = v1 / v2; 1298 /* Compute floor. */ 1299 if (TRUNCATION_TOWARDS_ZERO && (v < 0) && ((v1 % v2) != 0)) 1300 { 1301 v--; 1302 } 1303 v = v1 - (v2 * v); 1304 } 1305 break; 1306 1307 case BINOP_LSH: 1308 v = v1 << v2; 1309 break; 1310 1311 case BINOP_RSH: 1312 v = v1 >> v2; 1313 break; 1314 1315 case BINOP_BITWISE_AND: 1316 v = v1 & v2; 1317 break; 1318 1319 case BINOP_BITWISE_IOR: 1320 v = v1 | v2; 1321 break; 1322 1323 case BINOP_BITWISE_XOR: 1324 v = v1 ^ v2; 1325 break; 1326 1327 case BINOP_LOGICAL_AND: 1328 v = v1 && v2; 1329 break; 1330 1331 case BINOP_LOGICAL_OR: 1332 v = v1 || v2; 1333 break; 1334 1335 case BINOP_MIN: 1336 v = v1 < v2 ? v1 : v2; 1337 break; 1338 1339 case BINOP_MAX: 1340 v = v1 > v2 ? v1 : v2; 1341 break; 1342 1343 case BINOP_EQUAL: 1344 v = v1 == v2; 1345 break; 1346 1347 case BINOP_NOTEQUAL: 1348 v = v1 != v2; 1349 break; 1350 1351 case BINOP_LESS: 1352 v = v1 < v2; 1353 break; 1354 1355 case BINOP_GTR: 1356 v = v1 > v2; 1357 break; 1358 1359 case BINOP_LEQ: 1360 v = v1 <= v2; 1361 break; 1362 1363 case BINOP_GEQ: 1364 v = v1 >= v2; 1365 break; 1366 1367 default: 1368 error (_("Invalid binary operation on numbers.")); 1369 } 1370 1371 val = allocate_value (result_type); 1372 store_signed_integer (value_contents_raw (val), 1373 TYPE_LENGTH (value_type (val)), 1374 gdbarch_byte_order 1375 (get_type_arch (result_type)), 1376 v); 1377 } 1378 } 1379 1380 return val; 1381 } 1382 1383 /* Simulate the C operator ! -- return 1 if ARG1 contains zero. */ 1384 1385 int 1386 value_logical_not (struct value *arg1) 1387 { 1388 int len; 1389 const gdb_byte *p; 1390 struct type *type1; 1391 1392 arg1 = coerce_array (arg1); 1393 type1 = check_typedef (value_type (arg1)); 1394 1395 if (TYPE_CODE (type1) == TYPE_CODE_FLT) 1396 return 0 == value_as_double (arg1); 1397 else if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT) 1398 return decimal_is_zero (value_contents (arg1), TYPE_LENGTH (type1), 1399 gdbarch_byte_order (get_type_arch (type1))); 1400 1401 len = TYPE_LENGTH (type1); 1402 p = value_contents (arg1); 1403 1404 while (--len >= 0) 1405 { 1406 if (*p++) 1407 break; 1408 } 1409 1410 return len < 0; 1411 } 1412 1413 /* Perform a comparison on two string values (whose content are not 1414 necessarily null terminated) based on their length */ 1415 1416 static int 1417 value_strcmp (struct value *arg1, struct value *arg2) 1418 { 1419 int len1 = TYPE_LENGTH (value_type (arg1)); 1420 int len2 = TYPE_LENGTH (value_type (arg2)); 1421 const gdb_byte *s1 = value_contents (arg1); 1422 const gdb_byte *s2 = value_contents (arg2); 1423 int i, len = len1 < len2 ? len1 : len2; 1424 1425 for (i = 0; i < len; i++) 1426 { 1427 if (s1[i] < s2[i]) 1428 return -1; 1429 else if (s1[i] > s2[i]) 1430 return 1; 1431 else 1432 continue; 1433 } 1434 1435 if (len1 < len2) 1436 return -1; 1437 else if (len1 > len2) 1438 return 1; 1439 else 1440 return 0; 1441 } 1442 1443 /* Simulate the C operator == by returning a 1 1444 iff ARG1 and ARG2 have equal contents. */ 1445 1446 int 1447 value_equal (struct value *arg1, struct value *arg2) 1448 { 1449 int len; 1450 const gdb_byte *p1; 1451 const gdb_byte *p2; 1452 struct type *type1, *type2; 1453 enum type_code code1; 1454 enum type_code code2; 1455 int is_int1, is_int2; 1456 1457 arg1 = coerce_array (arg1); 1458 arg2 = coerce_array (arg2); 1459 1460 type1 = check_typedef (value_type (arg1)); 1461 type2 = check_typedef (value_type (arg2)); 1462 code1 = TYPE_CODE (type1); 1463 code2 = TYPE_CODE (type2); 1464 is_int1 = is_integral_type (type1); 1465 is_int2 = is_integral_type (type2); 1466 1467 if (is_int1 && is_int2) 1468 return longest_to_int (value_as_long (value_binop (arg1, arg2, 1469 BINOP_EQUAL))); 1470 else if ((code1 == TYPE_CODE_FLT || is_int1) 1471 && (code2 == TYPE_CODE_FLT || is_int2)) 1472 { 1473 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where 1474 `long double' values are returned in static storage (m68k). */ 1475 DOUBLEST d = value_as_double (arg1); 1476 1477 return d == value_as_double (arg2); 1478 } 1479 else if ((code1 == TYPE_CODE_DECFLOAT || is_int1) 1480 && (code2 == TYPE_CODE_DECFLOAT || is_int2)) 1481 { 1482 gdb_byte v1[16], v2[16]; 1483 int len_v1, len_v2; 1484 enum bfd_endian byte_order_v1, byte_order_v2; 1485 1486 value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1, 1487 v2, &len_v2, &byte_order_v2); 1488 1489 return decimal_compare (v1, len_v1, byte_order_v1, 1490 v2, len_v2, byte_order_v2) == 0; 1491 } 1492 1493 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever 1494 is bigger. */ 1495 else if (code1 == TYPE_CODE_PTR && is_int2) 1496 return value_as_address (arg1) == (CORE_ADDR) value_as_long (arg2); 1497 else if (code2 == TYPE_CODE_PTR && is_int1) 1498 return (CORE_ADDR) value_as_long (arg1) == value_as_address (arg2); 1499 1500 else if (code1 == code2 1501 && ((len = (int) TYPE_LENGTH (type1)) 1502 == (int) TYPE_LENGTH (type2))) 1503 { 1504 p1 = value_contents (arg1); 1505 p2 = value_contents (arg2); 1506 while (--len >= 0) 1507 { 1508 if (*p1++ != *p2++) 1509 break; 1510 } 1511 return len < 0; 1512 } 1513 else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING) 1514 { 1515 return value_strcmp (arg1, arg2) == 0; 1516 } 1517 else 1518 { 1519 error (_("Invalid type combination in equality test.")); 1520 return 0; /* For lint -- never reached */ 1521 } 1522 } 1523 1524 /* Compare values based on their raw contents. Useful for arrays since 1525 value_equal coerces them to pointers, thus comparing just the address 1526 of the array instead of its contents. */ 1527 1528 int 1529 value_equal_contents (struct value *arg1, struct value *arg2) 1530 { 1531 struct type *type1, *type2; 1532 1533 type1 = check_typedef (value_type (arg1)); 1534 type2 = check_typedef (value_type (arg2)); 1535 1536 return (TYPE_CODE (type1) == TYPE_CODE (type2) 1537 && TYPE_LENGTH (type1) == TYPE_LENGTH (type2) 1538 && memcmp (value_contents (arg1), value_contents (arg2), 1539 TYPE_LENGTH (type1)) == 0); 1540 } 1541 1542 /* Simulate the C operator < by returning 1 1543 iff ARG1's contents are less than ARG2's. */ 1544 1545 int 1546 value_less (struct value *arg1, struct value *arg2) 1547 { 1548 enum type_code code1; 1549 enum type_code code2; 1550 struct type *type1, *type2; 1551 int is_int1, is_int2; 1552 1553 arg1 = coerce_array (arg1); 1554 arg2 = coerce_array (arg2); 1555 1556 type1 = check_typedef (value_type (arg1)); 1557 type2 = check_typedef (value_type (arg2)); 1558 code1 = TYPE_CODE (type1); 1559 code2 = TYPE_CODE (type2); 1560 is_int1 = is_integral_type (type1); 1561 is_int2 = is_integral_type (type2); 1562 1563 if (is_int1 && is_int2) 1564 return longest_to_int (value_as_long (value_binop (arg1, arg2, 1565 BINOP_LESS))); 1566 else if ((code1 == TYPE_CODE_FLT || is_int1) 1567 && (code2 == TYPE_CODE_FLT || is_int2)) 1568 { 1569 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where 1570 `long double' values are returned in static storage (m68k). */ 1571 DOUBLEST d = value_as_double (arg1); 1572 1573 return d < value_as_double (arg2); 1574 } 1575 else if ((code1 == TYPE_CODE_DECFLOAT || is_int1) 1576 && (code2 == TYPE_CODE_DECFLOAT || is_int2)) 1577 { 1578 gdb_byte v1[16], v2[16]; 1579 int len_v1, len_v2; 1580 enum bfd_endian byte_order_v1, byte_order_v2; 1581 1582 value_args_as_decimal (arg1, arg2, v1, &len_v1, &byte_order_v1, 1583 v2, &len_v2, &byte_order_v2); 1584 1585 return decimal_compare (v1, len_v1, byte_order_v1, 1586 v2, len_v2, byte_order_v2) == -1; 1587 } 1588 else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR) 1589 return value_as_address (arg1) < value_as_address (arg2); 1590 1591 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever 1592 is bigger. */ 1593 else if (code1 == TYPE_CODE_PTR && is_int2) 1594 return value_as_address (arg1) < (CORE_ADDR) value_as_long (arg2); 1595 else if (code2 == TYPE_CODE_PTR && is_int1) 1596 return (CORE_ADDR) value_as_long (arg1) < value_as_address (arg2); 1597 else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING) 1598 return value_strcmp (arg1, arg2) < 0; 1599 else 1600 { 1601 error (_("Invalid type combination in ordering comparison.")); 1602 return 0; 1603 } 1604 } 1605 1606 /* The unary operators +, - and ~. They free the argument ARG1. */ 1607 1608 struct value * 1609 value_pos (struct value *arg1) 1610 { 1611 struct type *type; 1612 1613 arg1 = coerce_ref (arg1); 1614 type = check_typedef (value_type (arg1)); 1615 1616 if (TYPE_CODE (type) == TYPE_CODE_FLT) 1617 return value_from_double (type, value_as_double (arg1)); 1618 else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT) 1619 return value_from_decfloat (type, value_contents (arg1)); 1620 else if (is_integral_type (type)) 1621 { 1622 return value_from_longest (type, value_as_long (arg1)); 1623 } 1624 else 1625 { 1626 error ("Argument to positive operation not a number."); 1627 return 0; /* For lint -- never reached */ 1628 } 1629 } 1630 1631 struct value * 1632 value_neg (struct value *arg1) 1633 { 1634 struct type *type; 1635 1636 arg1 = coerce_ref (arg1); 1637 type = check_typedef (value_type (arg1)); 1638 1639 if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT) 1640 { 1641 struct value *val = allocate_value (type); 1642 int len = TYPE_LENGTH (type); 1643 gdb_byte decbytes[16]; /* a decfloat is at most 128 bits long */ 1644 1645 memcpy (decbytes, value_contents (arg1), len); 1646 1647 if (gdbarch_byte_order (get_type_arch (type)) == BFD_ENDIAN_LITTLE) 1648 decbytes[len-1] = decbytes[len - 1] | 0x80; 1649 else 1650 decbytes[0] = decbytes[0] | 0x80; 1651 1652 memcpy (value_contents_raw (val), decbytes, len); 1653 return val; 1654 } 1655 else if (TYPE_CODE (type) == TYPE_CODE_FLT) 1656 return value_from_double (type, -value_as_double (arg1)); 1657 else if (is_integral_type (type)) 1658 { 1659 return value_from_longest (type, -value_as_long (arg1)); 1660 } 1661 else 1662 { 1663 error (_("Argument to negate operation not a number.")); 1664 return 0; /* For lint -- never reached */ 1665 } 1666 } 1667 1668 struct value * 1669 value_complement (struct value *arg1) 1670 { 1671 struct type *type; 1672 1673 arg1 = coerce_ref (arg1); 1674 type = check_typedef (value_type (arg1)); 1675 1676 if (!is_integral_type (type)) 1677 error (_("Argument to complement operation not an integer or boolean.")); 1678 1679 return value_from_longest (type, ~value_as_long (arg1)); 1680 } 1681 1682 /* The INDEX'th bit of SET value whose value_type is TYPE, 1683 and whose value_contents is valaddr. 1684 Return -1 if out of range, -2 other error. */ 1685 1686 int 1687 value_bit_index (struct type *type, const gdb_byte *valaddr, int index) 1688 { 1689 struct gdbarch *gdbarch = get_type_arch (type); 1690 LONGEST low_bound, high_bound; 1691 LONGEST word; 1692 unsigned rel_index; 1693 struct type *range = TYPE_INDEX_TYPE (type); 1694 1695 if (get_discrete_bounds (range, &low_bound, &high_bound) < 0) 1696 return -2; 1697 if (index < low_bound || index > high_bound) 1698 return -1; 1699 rel_index = index - low_bound; 1700 word = extract_unsigned_integer (valaddr + (rel_index / TARGET_CHAR_BIT), 1, 1701 gdbarch_byte_order (gdbarch)); 1702 rel_index %= TARGET_CHAR_BIT; 1703 if (gdbarch_bits_big_endian (gdbarch)) 1704 rel_index = TARGET_CHAR_BIT - 1 - rel_index; 1705 return (word >> rel_index) & 1; 1706 } 1707 1708 int 1709 value_in (struct value *element, struct value *set) 1710 { 1711 int member; 1712 struct type *settype = check_typedef (value_type (set)); 1713 struct type *eltype = check_typedef (value_type (element)); 1714 1715 if (TYPE_CODE (eltype) == TYPE_CODE_RANGE) 1716 eltype = TYPE_TARGET_TYPE (eltype); 1717 if (TYPE_CODE (settype) != TYPE_CODE_SET) 1718 error (_("Second argument of 'IN' has wrong type")); 1719 if (TYPE_CODE (eltype) != TYPE_CODE_INT 1720 && TYPE_CODE (eltype) != TYPE_CODE_CHAR 1721 && TYPE_CODE (eltype) != TYPE_CODE_ENUM 1722 && TYPE_CODE (eltype) != TYPE_CODE_BOOL) 1723 error (_("First argument of 'IN' has wrong type")); 1724 member = value_bit_index (settype, value_contents (set), 1725 value_as_long (element)); 1726 if (member < 0) 1727 error (_("First argument of 'IN' not in range")); 1728 return member; 1729 } 1730 1731 void 1732 _initialize_valarith (void) 1733 { 1734 } 1735