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