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