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