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