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