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