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