1/* Perform arithmetic and other operations on values, for GDB. 2 3 Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007 5 Free Software Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22#include "defs.h" 23#include "value.h" 24#include "symtab.h" 25#include "gdbtypes.h" 26#include "expression.h" 27#include "target.h" 28#include "language.h" 29#include "gdb_string.h" 30#include "doublest.h" 31#include <math.h> 32#include "infcall.h" 33 34/* Define whether or not the C operator '/' truncates towards zero for 35 differently signed operands (truncation direction is undefined in C). */ 36 37#ifndef TRUNCATION_TOWARDS_ZERO 38#define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2) 39#endif 40 41static struct value *value_subscripted_rvalue (struct value *, struct value *, int); 42 43void _initialize_valarith (void); 44 45 46/* Given a pointer, return the size of its target. 47 If the pointer type is void *, then return 1. 48 If the target type is incomplete, then error out. 49 This isn't a general purpose function, but just a 50 helper for value_sub & value_add. 51*/ 52 53static LONGEST 54find_size_for_pointer_math (struct type *ptr_type) 55{ 56 LONGEST sz = -1; 57 struct type *ptr_target; 58 59 ptr_target = check_typedef (TYPE_TARGET_TYPE (ptr_type)); 60 61 sz = TYPE_LENGTH (ptr_target); 62 if (sz == 0) 63 { 64 if (TYPE_CODE (ptr_type) == TYPE_CODE_VOID) 65 sz = 1; 66 else 67 { 68 char *name; 69 70 name = TYPE_NAME (ptr_target); 71 if (name == NULL) 72 name = TYPE_TAG_NAME (ptr_target); 73 if (name == NULL) 74 error (_("Cannot perform pointer math on incomplete types, " 75 "try casting to a known type, or void *.")); 76 else 77 error (_("Cannot perform pointer math on incomplete type \"%s\", " 78 "try casting to a known type, or void *."), name); 79 } 80 } 81 return sz; 82} 83 84struct value * 85value_add (struct value *arg1, struct value *arg2) 86{ 87 struct value *valint; 88 struct value *valptr; 89 LONGEST sz; 90 struct type *type1, *type2, *valptrtype; 91 92 arg1 = coerce_array (arg1); 93 arg2 = coerce_array (arg2); 94 type1 = check_typedef (value_type (arg1)); 95 type2 = check_typedef (value_type (arg2)); 96 97 if ((TYPE_CODE (type1) == TYPE_CODE_PTR 98 || TYPE_CODE (type2) == TYPE_CODE_PTR) 99 && 100 (is_integral_type (type1) || is_integral_type (type2))) 101 /* Exactly one argument is a pointer, and one is an integer. */ 102 { 103 struct value *retval; 104 105 if (TYPE_CODE (type1) == TYPE_CODE_PTR) 106 { 107 valptr = arg1; 108 valint = arg2; 109 valptrtype = type1; 110 } 111 else 112 { 113 valptr = arg2; 114 valint = arg1; 115 valptrtype = type2; 116 } 117 118 sz = find_size_for_pointer_math (valptrtype); 119 120 retval = value_from_pointer (valptrtype, 121 value_as_address (valptr) 122 + (sz * value_as_long (valint))); 123 return retval; 124 } 125 126 return value_binop (arg1, arg2, BINOP_ADD); 127} 128 129struct value * 130value_sub (struct value *arg1, struct value *arg2) 131{ 132 struct type *type1, *type2; 133 arg1 = coerce_array (arg1); 134 arg2 = coerce_array (arg2); 135 type1 = check_typedef (value_type (arg1)); 136 type2 = check_typedef (value_type (arg2)); 137 138 if (TYPE_CODE (type1) == TYPE_CODE_PTR) 139 { 140 if (is_integral_type (type2)) 141 { 142 /* pointer - integer. */ 143 LONGEST sz = find_size_for_pointer_math (type1); 144 145 return value_from_pointer (type1, 146 (value_as_address (arg1) 147 - (sz * value_as_long (arg2)))); 148 } 149 else if (TYPE_CODE (type2) == TYPE_CODE_PTR 150 && TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1))) 151 == TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2)))) 152 { 153 /* pointer to <type x> - pointer to <type x>. */ 154 LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1))); 155 return value_from_longest 156 (builtin_type_long, /* FIXME -- should be ptrdiff_t */ 157 (value_as_long (arg1) - value_as_long (arg2)) / sz); 158 } 159 else 160 { 161 error (_("\ 162First argument of `-' is a pointer and second argument is neither\n\ 163an integer nor a pointer of the same type.")); 164 } 165 } 166 167 return value_binop (arg1, arg2, BINOP_SUB); 168} 169 170/* Return the value of ARRAY[IDX]. 171 See comments in value_coerce_array() for rationale for reason for 172 doing lower bounds adjustment here rather than there. 173 FIXME: Perhaps we should validate that the index is valid and if 174 verbosity is set, warn about invalid indices (but still use them). */ 175 176struct value * 177value_subscript (struct value *array, struct value *idx) 178{ 179 struct value *bound; 180 int c_style = current_language->c_style_arrays; 181 struct type *tarray; 182 183 array = coerce_ref (array); 184 tarray = check_typedef (value_type (array)); 185 186 if (TYPE_CODE (tarray) == TYPE_CODE_ARRAY 187 || TYPE_CODE (tarray) == TYPE_CODE_STRING) 188 { 189 struct type *range_type = TYPE_INDEX_TYPE (tarray); 190 LONGEST lowerbound, upperbound; 191 get_discrete_bounds (range_type, &lowerbound, &upperbound); 192 193 if (VALUE_LVAL (array) != lval_memory) 194 return value_subscripted_rvalue (array, idx, lowerbound); 195 196 if (c_style == 0) 197 { 198 LONGEST index = value_as_long (idx); 199 if (index >= lowerbound && index <= upperbound) 200 return value_subscripted_rvalue (array, idx, lowerbound); 201 /* Emit warning unless we have an array of unknown size. 202 An array of unknown size has lowerbound 0 and upperbound -1. */ 203 if (upperbound > -1) 204 warning (_("array or string index out of range")); 205 /* fall doing C stuff */ 206 c_style = 1; 207 } 208 209 if (lowerbound != 0) 210 { 211 bound = value_from_longest (builtin_type_int, (LONGEST) lowerbound); 212 idx = value_sub (idx, bound); 213 } 214 215 array = value_coerce_array (array); 216 } 217 218 if (TYPE_CODE (tarray) == TYPE_CODE_BITSTRING) 219 { 220 struct type *range_type = TYPE_INDEX_TYPE (tarray); 221 LONGEST index = value_as_long (idx); 222 struct value *v; 223 int offset, byte, bit_index; 224 LONGEST lowerbound, upperbound; 225 get_discrete_bounds (range_type, &lowerbound, &upperbound); 226 if (index < lowerbound || index > upperbound) 227 error (_("bitstring index out of range")); 228 index -= lowerbound; 229 offset = index / TARGET_CHAR_BIT; 230 byte = *((char *) value_contents (array) + offset); 231 bit_index = index % TARGET_CHAR_BIT; 232 byte >>= (BITS_BIG_ENDIAN ? TARGET_CHAR_BIT - 1 - bit_index : bit_index); 233 v = value_from_longest (LA_BOOL_TYPE, byte & 1); 234 set_value_bitpos (v, bit_index); 235 set_value_bitsize (v, 1); 236 VALUE_LVAL (v) = VALUE_LVAL (array); 237 if (VALUE_LVAL (array) == lval_internalvar) 238 VALUE_LVAL (v) = lval_internalvar_component; 239 VALUE_ADDRESS (v) = VALUE_ADDRESS (array); 240 VALUE_FRAME_ID (v) = VALUE_FRAME_ID (array); 241 set_value_offset (v, offset + value_offset (array)); 242 return v; 243 } 244 245 if (c_style) 246 return value_ind (value_add (array, idx)); 247 else 248 error (_("not an array or string")); 249} 250 251/* Return the value of EXPR[IDX], expr an aggregate rvalue 252 (eg, a vector register). This routine used to promote floats 253 to doubles, but no longer does. */ 254 255static struct value * 256value_subscripted_rvalue (struct value *array, struct value *idx, int lowerbound) 257{ 258 struct type *array_type = check_typedef (value_type (array)); 259 struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type)); 260 unsigned int elt_size = TYPE_LENGTH (elt_type); 261 LONGEST index = value_as_long (idx); 262 unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound); 263 struct value *v; 264 265 if (index < lowerbound || elt_offs >= TYPE_LENGTH (array_type)) 266 error (_("no such vector element")); 267 268 v = allocate_value (elt_type); 269 if (value_lazy (array)) 270 set_value_lazy (v, 1); 271 else 272 memcpy (value_contents_writeable (v), 273 value_contents (array) + elt_offs, elt_size); 274 275 if (VALUE_LVAL (array) == lval_internalvar) 276 VALUE_LVAL (v) = lval_internalvar_component; 277 else 278 VALUE_LVAL (v) = VALUE_LVAL (array); 279 VALUE_ADDRESS (v) = VALUE_ADDRESS (array); 280 VALUE_REGNUM (v) = VALUE_REGNUM (array); 281 VALUE_FRAME_ID (v) = VALUE_FRAME_ID (array); 282 set_value_offset (v, value_offset (array) + elt_offs); 283 return v; 284} 285 286/* Check to see if either argument is a structure, or a reference to 287 one. This is called so we know whether to go ahead with the normal 288 binop or look for a user defined function instead. 289 290 For now, we do not overload the `=' operator. */ 291 292int 293binop_user_defined_p (enum exp_opcode op, struct value *arg1, struct value *arg2) 294{ 295 struct type *type1, *type2; 296 if (op == BINOP_ASSIGN || op == BINOP_CONCAT) 297 return 0; 298 299 type1 = check_typedef (value_type (arg1)); 300 if (TYPE_CODE (type1) == TYPE_CODE_REF) 301 type1 = check_typedef (TYPE_TARGET_TYPE (type1)); 302 303 type2 = check_typedef (value_type (arg2)); 304 if (TYPE_CODE (type2) == TYPE_CODE_REF) 305 type2 = check_typedef (TYPE_TARGET_TYPE (type2)); 306 307 return (TYPE_CODE (type1) == TYPE_CODE_STRUCT 308 || TYPE_CODE (type2) == TYPE_CODE_STRUCT); 309} 310 311/* Check to see if argument is a structure. This is called so 312 we know whether to go ahead with the normal unop or look for a 313 user defined function instead. 314 315 For now, we do not overload the `&' operator. */ 316 317int 318unop_user_defined_p (enum exp_opcode op, struct value *arg1) 319{ 320 struct type *type1; 321 if (op == UNOP_ADDR) 322 return 0; 323 type1 = check_typedef (value_type (arg1)); 324 for (;;) 325 { 326 if (TYPE_CODE (type1) == TYPE_CODE_STRUCT) 327 return 1; 328 else if (TYPE_CODE (type1) == TYPE_CODE_REF) 329 type1 = TYPE_TARGET_TYPE (type1); 330 else 331 return 0; 332 } 333} 334 335/* We know either arg1 or arg2 is a structure, so try to find the right 336 user defined function. Create an argument vector that calls 337 arg1.operator @ (arg1,arg2) and return that value (where '@' is any 338 binary operator which is legal for GNU C++). 339 340 OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP 341 is the opcode saying how to modify it. Otherwise, OTHEROP is 342 unused. */ 343 344struct value * 345value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op, 346 enum exp_opcode otherop, enum noside noside) 347{ 348 struct value **argvec; 349 char *ptr; 350 char tstr[13]; 351 int static_memfuncp; 352 353 arg1 = coerce_ref (arg1); 354 arg2 = coerce_ref (arg2); 355 arg1 = coerce_enum (arg1); 356 arg2 = coerce_enum (arg2); 357 358 /* now we know that what we have to do is construct our 359 arg vector and find the right function to call it with. */ 360 361 if (TYPE_CODE (check_typedef (value_type (arg1))) != TYPE_CODE_STRUCT) 362 error (_("Can't do that binary op on that type")); /* FIXME be explicit */ 363 364 argvec = (struct value **) alloca (sizeof (struct value *) * 4); 365 argvec[1] = value_addr (arg1); 366 argvec[2] = arg2; 367 argvec[3] = 0; 368 369 /* make the right function name up */ 370 strcpy (tstr, "operator__"); 371 ptr = tstr + 8; 372 switch (op) 373 { 374 case BINOP_ADD: 375 strcpy (ptr, "+"); 376 break; 377 case BINOP_SUB: 378 strcpy (ptr, "-"); 379 break; 380 case BINOP_MUL: 381 strcpy (ptr, "*"); 382 break; 383 case BINOP_DIV: 384 strcpy (ptr, "/"); 385 break; 386 case BINOP_REM: 387 strcpy (ptr, "%"); 388 break; 389 case BINOP_LSH: 390 strcpy (ptr, "<<"); 391 break; 392 case BINOP_RSH: 393 strcpy (ptr, ">>"); 394 break; 395 case BINOP_BITWISE_AND: 396 strcpy (ptr, "&"); 397 break; 398 case BINOP_BITWISE_IOR: 399 strcpy (ptr, "|"); 400 break; 401 case BINOP_BITWISE_XOR: 402 strcpy (ptr, "^"); 403 break; 404 case BINOP_LOGICAL_AND: 405 strcpy (ptr, "&&"); 406 break; 407 case BINOP_LOGICAL_OR: 408 strcpy (ptr, "||"); 409 break; 410 case BINOP_MIN: 411 strcpy (ptr, "<?"); 412 break; 413 case BINOP_MAX: 414 strcpy (ptr, ">?"); 415 break; 416 case BINOP_ASSIGN: 417 strcpy (ptr, "="); 418 break; 419 case BINOP_ASSIGN_MODIFY: 420 switch (otherop) 421 { 422 case BINOP_ADD: 423 strcpy (ptr, "+="); 424 break; 425 case BINOP_SUB: 426 strcpy (ptr, "-="); 427 break; 428 case BINOP_MUL: 429 strcpy (ptr, "*="); 430 break; 431 case BINOP_DIV: 432 strcpy (ptr, "/="); 433 break; 434 case BINOP_REM: 435 strcpy (ptr, "%="); 436 break; 437 case BINOP_BITWISE_AND: 438 strcpy (ptr, "&="); 439 break; 440 case BINOP_BITWISE_IOR: 441 strcpy (ptr, "|="); 442 break; 443 case BINOP_BITWISE_XOR: 444 strcpy (ptr, "^="); 445 break; 446 case BINOP_MOD: /* invalid */ 447 default: 448 error (_("Invalid binary operation specified.")); 449 } 450 break; 451 case BINOP_SUBSCRIPT: 452 strcpy (ptr, "[]"); 453 break; 454 case BINOP_EQUAL: 455 strcpy (ptr, "=="); 456 break; 457 case BINOP_NOTEQUAL: 458 strcpy (ptr, "!="); 459 break; 460 case BINOP_LESS: 461 strcpy (ptr, "<"); 462 break; 463 case BINOP_GTR: 464 strcpy (ptr, ">"); 465 break; 466 case BINOP_GEQ: 467 strcpy (ptr, ">="); 468 break; 469 case BINOP_LEQ: 470 strcpy (ptr, "<="); 471 break; 472 case BINOP_MOD: /* invalid */ 473 default: 474 error (_("Invalid binary operation specified.")); 475 } 476 477 argvec[0] = value_struct_elt (&arg1, argvec + 1, tstr, &static_memfuncp, "structure"); 478 479 if (argvec[0]) 480 { 481 if (static_memfuncp) 482 { 483 argvec[1] = argvec[0]; 484 argvec++; 485 } 486 if (noside == EVAL_AVOID_SIDE_EFFECTS) 487 { 488 struct type *return_type; 489 return_type 490 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0]))); 491 return value_zero (return_type, VALUE_LVAL (arg1)); 492 } 493 return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1); 494 } 495 error (_("member function %s not found"), tstr); 496#ifdef lint 497 return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1); 498#endif 499} 500 501/* We know that arg1 is a structure, so try to find a unary user 502 defined operator that matches the operator in question. 503 Create an argument vector that calls arg1.operator @ (arg1) 504 and return that value (where '@' is (almost) any unary operator which 505 is legal for GNU C++). */ 506 507struct value * 508value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside) 509{ 510 struct value **argvec; 511 char *ptr, *mangle_ptr; 512 char tstr[13], mangle_tstr[13]; 513 int static_memfuncp, nargs; 514 515 arg1 = coerce_ref (arg1); 516 arg1 = coerce_enum (arg1); 517 518 /* now we know that what we have to do is construct our 519 arg vector and find the right function to call it with. */ 520 521 if (TYPE_CODE (check_typedef (value_type (arg1))) != TYPE_CODE_STRUCT) 522 error (_("Can't do that unary op on that type")); /* FIXME be explicit */ 523 524 argvec = (struct value **) alloca (sizeof (struct value *) * 4); 525 argvec[1] = value_addr (arg1); 526 argvec[2] = 0; 527 528 nargs = 1; 529 530 /* make the right function name up */ 531 strcpy (tstr, "operator__"); 532 ptr = tstr + 8; 533 strcpy (mangle_tstr, "__"); 534 mangle_ptr = mangle_tstr + 2; 535 switch (op) 536 { 537 case UNOP_PREINCREMENT: 538 strcpy (ptr, "++"); 539 break; 540 case UNOP_PREDECREMENT: 541 strcpy (ptr, "--"); 542 break; 543 case UNOP_POSTINCREMENT: 544 strcpy (ptr, "++"); 545 argvec[2] = value_from_longest (builtin_type_int, 0); 546 argvec[3] = 0; 547 nargs ++; 548 break; 549 case UNOP_POSTDECREMENT: 550 strcpy (ptr, "--"); 551 argvec[2] = value_from_longest (builtin_type_int, 0); 552 argvec[3] = 0; 553 nargs ++; 554 break; 555 case UNOP_LOGICAL_NOT: 556 strcpy (ptr, "!"); 557 break; 558 case UNOP_COMPLEMENT: 559 strcpy (ptr, "~"); 560 break; 561 case UNOP_NEG: 562 strcpy (ptr, "-"); 563 break; 564 case UNOP_PLUS: 565 strcpy (ptr, "+"); 566 break; 567 case UNOP_IND: 568 strcpy (ptr, "*"); 569 break; 570 default: 571 error (_("Invalid unary operation specified.")); 572 } 573 574 argvec[0] = value_struct_elt (&arg1, argvec + 1, tstr, &static_memfuncp, "structure"); 575 576 if (argvec[0]) 577 { 578 if (static_memfuncp) 579 { 580 argvec[1] = argvec[0]; 581 nargs --; 582 argvec++; 583 } 584 if (noside == EVAL_AVOID_SIDE_EFFECTS) 585 { 586 struct type *return_type; 587 return_type 588 = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0]))); 589 return value_zero (return_type, VALUE_LVAL (arg1)); 590 } 591 return call_function_by_hand (argvec[0], nargs, argvec + 1); 592 } 593 error (_("member function %s not found"), tstr); 594 return 0; /* For lint -- never reached */ 595} 596 597 598/* Concatenate two values with the following conditions: 599 600 (1) Both values must be either bitstring values or character string 601 values and the resulting value consists of the concatenation of 602 ARG1 followed by ARG2. 603 604 or 605 606 One value must be an integer value and the other value must be 607 either a bitstring value or character string value, which is 608 to be repeated by the number of times specified by the integer 609 value. 610 611 612 (2) Boolean values are also allowed and are treated as bit string 613 values of length 1. 614 615 (3) Character values are also allowed and are treated as character 616 string values of length 1. 617 */ 618 619struct value * 620value_concat (struct value *arg1, struct value *arg2) 621{ 622 struct value *inval1; 623 struct value *inval2; 624 struct value *outval = NULL; 625 int inval1len, inval2len; 626 int count, idx; 627 char *ptr; 628 char inchar; 629 struct type *type1 = check_typedef (value_type (arg1)); 630 struct type *type2 = check_typedef (value_type (arg2)); 631 632 /* First figure out if we are dealing with two values to be concatenated 633 or a repeat count and a value to be repeated. INVAL1 is set to the 634 first of two concatenated values, or the repeat count. INVAL2 is set 635 to the second of the two concatenated values or the value to be 636 repeated. */ 637 638 if (TYPE_CODE (type2) == TYPE_CODE_INT) 639 { 640 struct type *tmp = type1; 641 type1 = tmp; 642 tmp = type2; 643 inval1 = arg2; 644 inval2 = arg1; 645 } 646 else 647 { 648 inval1 = arg1; 649 inval2 = arg2; 650 } 651 652 /* Now process the input values. */ 653 654 if (TYPE_CODE (type1) == TYPE_CODE_INT) 655 { 656 /* We have a repeat count. Validate the second value and then 657 construct a value repeated that many times. */ 658 if (TYPE_CODE (type2) == TYPE_CODE_STRING 659 || TYPE_CODE (type2) == TYPE_CODE_CHAR) 660 { 661 count = longest_to_int (value_as_long (inval1)); 662 inval2len = TYPE_LENGTH (type2); 663 ptr = (char *) alloca (count * inval2len); 664 if (TYPE_CODE (type2) == TYPE_CODE_CHAR) 665 { 666 inchar = (char) unpack_long (type2, 667 value_contents (inval2)); 668 for (idx = 0; idx < count; idx++) 669 { 670 *(ptr + idx) = inchar; 671 } 672 } 673 else 674 { 675 for (idx = 0; idx < count; idx++) 676 { 677 memcpy (ptr + (idx * inval2len), value_contents (inval2), 678 inval2len); 679 } 680 } 681 outval = value_string (ptr, count * inval2len); 682 } 683 else if (TYPE_CODE (type2) == TYPE_CODE_BITSTRING 684 || TYPE_CODE (type2) == TYPE_CODE_BOOL) 685 { 686 error (_("unimplemented support for bitstring/boolean repeats")); 687 } 688 else 689 { 690 error (_("can't repeat values of that type")); 691 } 692 } 693 else if (TYPE_CODE (type1) == TYPE_CODE_STRING 694 || TYPE_CODE (type1) == TYPE_CODE_CHAR) 695 { 696 /* We have two character strings to concatenate. */ 697 if (TYPE_CODE (type2) != TYPE_CODE_STRING 698 && TYPE_CODE (type2) != TYPE_CODE_CHAR) 699 { 700 error (_("Strings can only be concatenated with other strings.")); 701 } 702 inval1len = TYPE_LENGTH (type1); 703 inval2len = TYPE_LENGTH (type2); 704 ptr = (char *) alloca (inval1len + inval2len); 705 if (TYPE_CODE (type1) == TYPE_CODE_CHAR) 706 { 707 *ptr = (char) unpack_long (type1, value_contents (inval1)); 708 } 709 else 710 { 711 memcpy (ptr, value_contents (inval1), inval1len); 712 } 713 if (TYPE_CODE (type2) == TYPE_CODE_CHAR) 714 { 715 *(ptr + inval1len) = 716 (char) unpack_long (type2, value_contents (inval2)); 717 } 718 else 719 { 720 memcpy (ptr + inval1len, value_contents (inval2), inval2len); 721 } 722 outval = value_string (ptr, inval1len + inval2len); 723 } 724 else if (TYPE_CODE (type1) == TYPE_CODE_BITSTRING 725 || TYPE_CODE (type1) == TYPE_CODE_BOOL) 726 { 727 /* We have two bitstrings to concatenate. */ 728 if (TYPE_CODE (type2) != TYPE_CODE_BITSTRING 729 && TYPE_CODE (type2) != TYPE_CODE_BOOL) 730 { 731 error (_("Bitstrings or booleans can only be concatenated with other bitstrings or booleans.")); 732 } 733 error (_("unimplemented support for bitstring/boolean concatenation.")); 734 } 735 else 736 { 737 /* We don't know how to concatenate these operands. */ 738 error (_("illegal operands for concatenation.")); 739 } 740 return (outval); 741} 742 743 744 745/* Perform a binary operation on two operands which have reasonable 746 representations as integers or floats. This includes booleans, 747 characters, integers, or floats. 748 Does not support addition and subtraction on pointers; 749 use value_add or value_sub if you want to handle those possibilities. */ 750 751struct value * 752value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) 753{ 754 struct value *val; 755 struct type *type1, *type2; 756 757 arg1 = coerce_ref (arg1); 758 arg2 = coerce_ref (arg2); 759 type1 = check_typedef (value_type (arg1)); 760 type2 = check_typedef (value_type (arg2)); 761 762 if ((TYPE_CODE (type1) != TYPE_CODE_FLT && !is_integral_type (type1)) 763 || 764 (TYPE_CODE (type2) != TYPE_CODE_FLT && !is_integral_type (type2))) 765 error (_("Argument to arithmetic operation not a number or boolean.")); 766 767 if (TYPE_CODE (type1) == TYPE_CODE_FLT 768 || 769 TYPE_CODE (type2) == TYPE_CODE_FLT) 770 { 771 /* FIXME-if-picky-about-floating-accuracy: Should be doing this 772 in target format. real.c in GCC probably has the necessary 773 code. */ 774 DOUBLEST v1, v2, v = 0; 775 v1 = value_as_double (arg1); 776 v2 = value_as_double (arg2); 777 switch (op) 778 { 779 case BINOP_ADD: 780 v = v1 + v2; 781 break; 782 783 case BINOP_SUB: 784 v = v1 - v2; 785 break; 786 787 case BINOP_MUL: 788 v = v1 * v2; 789 break; 790 791 case BINOP_DIV: 792 v = v1 / v2; 793 break; 794 795 case BINOP_EXP: 796 errno = 0; 797 v = pow (v1, v2); 798 if (errno) 799 error (_("Cannot perform exponentiation: %s"), safe_strerror (errno)); 800 break; 801 802 default: 803 error (_("Integer-only operation on floating point number.")); 804 } 805 806 /* If either arg was long double, make sure that value is also long 807 double. */ 808 809 if (TYPE_LENGTH (type1) * 8 > gdbarch_double_bit (current_gdbarch) 810 || TYPE_LENGTH (type2) * 8 > gdbarch_double_bit (current_gdbarch)) 811 val = allocate_value (builtin_type_long_double); 812 else 813 val = allocate_value (builtin_type_double); 814 815 store_typed_floating (value_contents_raw (val), value_type (val), v); 816 } 817 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL 818 && 819 TYPE_CODE (type2) == TYPE_CODE_BOOL) 820 { 821 LONGEST v1, v2, v = 0; 822 v1 = value_as_long (arg1); 823 v2 = value_as_long (arg2); 824 825 switch (op) 826 { 827 case BINOP_BITWISE_AND: 828 v = v1 & v2; 829 break; 830 831 case BINOP_BITWISE_IOR: 832 v = v1 | v2; 833 break; 834 835 case BINOP_BITWISE_XOR: 836 v = v1 ^ v2; 837 break; 838 839 case BINOP_EQUAL: 840 v = v1 == v2; 841 break; 842 843 case BINOP_NOTEQUAL: 844 v = v1 != v2; 845 break; 846 847 default: 848 error (_("Invalid operation on booleans.")); 849 } 850 851 val = allocate_value (type1); 852 store_signed_integer (value_contents_raw (val), 853 TYPE_LENGTH (type1), 854 v); 855 } 856 else 857 /* Integral operations here. */ 858 /* FIXME: Also mixed integral/booleans, with result an integer. */ 859 /* FIXME: This implements ANSI C rules (also correct for C++). 860 What about FORTRAN and (the deleted) chill ? */ 861 { 862 unsigned int promoted_len1 = TYPE_LENGTH (type1); 863 unsigned int promoted_len2 = TYPE_LENGTH (type2); 864 int is_unsigned1 = TYPE_UNSIGNED (type1); 865 int is_unsigned2 = TYPE_UNSIGNED (type2); 866 unsigned int result_len; 867 int unsigned_operation; 868 869 /* Determine type length and signedness after promotion for 870 both operands. */ 871 if (promoted_len1 < TYPE_LENGTH (builtin_type_int)) 872 { 873 is_unsigned1 = 0; 874 promoted_len1 = TYPE_LENGTH (builtin_type_int); 875 } 876 if (promoted_len2 < TYPE_LENGTH (builtin_type_int)) 877 { 878 is_unsigned2 = 0; 879 promoted_len2 = TYPE_LENGTH (builtin_type_int); 880 } 881 882 /* Determine type length of the result, and if the operation should 883 be done unsigned. 884 Use the signedness of the operand with the greater length. 885 If both operands are of equal length, use unsigned operation 886 if one of the operands is unsigned. */ 887 if (op == BINOP_RSH || op == BINOP_LSH) 888 { 889 /* In case of the shift operators the type of the result only 890 depends on the type of the left operand. */ 891 unsigned_operation = is_unsigned1; 892 result_len = promoted_len1; 893 } 894 else if (promoted_len1 > promoted_len2) 895 { 896 unsigned_operation = is_unsigned1; 897 result_len = promoted_len1; 898 } 899 else if (promoted_len2 > promoted_len1) 900 { 901 unsigned_operation = is_unsigned2; 902 result_len = promoted_len2; 903 } 904 else 905 { 906 unsigned_operation = is_unsigned1 || is_unsigned2; 907 result_len = promoted_len1; 908 } 909 910 if (unsigned_operation) 911 { 912 ULONGEST v1, v2, v = 0; 913 v1 = (ULONGEST) value_as_long (arg1); 914 v2 = (ULONGEST) value_as_long (arg2); 915 916 /* Truncate values to the type length of the result. */ 917 if (result_len < sizeof (ULONGEST)) 918 { 919 v1 &= ((LONGEST) 1 << HOST_CHAR_BIT * result_len) - 1; 920 v2 &= ((LONGEST) 1 << HOST_CHAR_BIT * result_len) - 1; 921 } 922 923 switch (op) 924 { 925 case BINOP_ADD: 926 v = v1 + v2; 927 break; 928 929 case BINOP_SUB: 930 v = v1 - v2; 931 break; 932 933 case BINOP_MUL: 934 v = v1 * v2; 935 break; 936 937 case BINOP_DIV: 938 v = v1 / v2; 939 break; 940 941 case BINOP_EXP: 942 errno = 0; 943 v = pow (v1, v2); 944 if (errno) 945 error (_("Cannot perform exponentiation: %s"), safe_strerror (errno)); 946 break; 947 948 case BINOP_REM: 949 v = v1 % v2; 950 break; 951 952 case BINOP_MOD: 953 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op, 954 v1 mod 0 has a defined value, v1. */ 955 if (v2 == 0) 956 { 957 v = v1; 958 } 959 else 960 { 961 v = v1 / v2; 962 /* Note floor(v1/v2) == v1/v2 for unsigned. */ 963 v = v1 - (v2 * v); 964 } 965 break; 966 967 case BINOP_LSH: 968 v = v1 << v2; 969 break; 970 971 case BINOP_RSH: 972 v = v1 >> v2; 973 break; 974 975 case BINOP_BITWISE_AND: 976 v = v1 & v2; 977 break; 978 979 case BINOP_BITWISE_IOR: 980 v = v1 | v2; 981 break; 982 983 case BINOP_BITWISE_XOR: 984 v = v1 ^ v2; 985 break; 986 987 case BINOP_LOGICAL_AND: 988 v = v1 && v2; 989 break; 990 991 case BINOP_LOGICAL_OR: 992 v = v1 || v2; 993 break; 994 995 case BINOP_MIN: 996 v = v1 < v2 ? v1 : v2; 997 break; 998 999 case BINOP_MAX: 1000 v = v1 > v2 ? v1 : v2; 1001 break; 1002 1003 case BINOP_EQUAL: 1004 v = v1 == v2; 1005 break; 1006 1007 case BINOP_NOTEQUAL: 1008 v = v1 != v2; 1009 break; 1010 1011 case BINOP_LESS: 1012 v = v1 < v2; 1013 break; 1014 1015 default: 1016 error (_("Invalid binary operation on numbers.")); 1017 } 1018 1019 /* This is a kludge to get around the fact that we don't 1020 know how to determine the result type from the types of 1021 the operands. (I'm not really sure how much we feel the 1022 need to duplicate the exact rules of the current 1023 language. They can get really hairy. But not to do so 1024 makes it hard to document just what we *do* do). */ 1025 1026 /* Can't just call init_type because we wouldn't know what 1027 name to give the type. */ 1028 val = allocate_value 1029 (result_len > gdbarch_long_bit (current_gdbarch) / HOST_CHAR_BIT 1030 ? builtin_type_unsigned_long_long 1031 : builtin_type_unsigned_long); 1032 store_unsigned_integer (value_contents_raw (val), 1033 TYPE_LENGTH (value_type (val)), 1034 v); 1035 } 1036 else 1037 { 1038 LONGEST v1, v2, v = 0; 1039 v1 = value_as_long (arg1); 1040 v2 = value_as_long (arg2); 1041 1042 switch (op) 1043 { 1044 case BINOP_ADD: 1045 v = v1 + v2; 1046 break; 1047 1048 case BINOP_SUB: 1049 v = v1 - v2; 1050 break; 1051 1052 case BINOP_MUL: 1053 v = v1 * v2; 1054 break; 1055 1056 case BINOP_DIV: 1057 if (v2 != 0) 1058 v = v1 / v2; 1059 else 1060 error (_("Division by zero")); 1061 break; 1062 1063 case BINOP_EXP: 1064 errno = 0; 1065 v = pow (v1, v2); 1066 if (errno) 1067 error (_("Cannot perform exponentiation: %s"), safe_strerror (errno)); 1068 break; 1069 1070 case BINOP_REM: 1071 if (v2 != 0) 1072 v = v1 % v2; 1073 else 1074 error (_("Division by zero")); 1075 break; 1076 1077 case BINOP_MOD: 1078 /* Knuth 1.2.4, integer only. Note that unlike the C '%' op, 1079 X mod 0 has a defined value, X. */ 1080 if (v2 == 0) 1081 { 1082 v = v1; 1083 } 1084 else 1085 { 1086 v = v1 / v2; 1087 /* Compute floor. */ 1088 if (TRUNCATION_TOWARDS_ZERO && (v < 0) && ((v1 % v2) != 0)) 1089 { 1090 v--; 1091 } 1092 v = v1 - (v2 * v); 1093 } 1094 break; 1095 1096 case BINOP_LSH: 1097 v = v1 << v2; 1098 break; 1099 1100 case BINOP_RSH: 1101 v = v1 >> v2; 1102 break; 1103 1104 case BINOP_BITWISE_AND: 1105 v = v1 & v2; 1106 break; 1107 1108 case BINOP_BITWISE_IOR: 1109 v = v1 | v2; 1110 break; 1111 1112 case BINOP_BITWISE_XOR: 1113 v = v1 ^ v2; 1114 break; 1115 1116 case BINOP_LOGICAL_AND: 1117 v = v1 && v2; 1118 break; 1119 1120 case BINOP_LOGICAL_OR: 1121 v = v1 || v2; 1122 break; 1123 1124 case BINOP_MIN: 1125 v = v1 < v2 ? v1 : v2; 1126 break; 1127 1128 case BINOP_MAX: 1129 v = v1 > v2 ? v1 : v2; 1130 break; 1131 1132 case BINOP_EQUAL: 1133 v = v1 == v2; 1134 break; 1135 1136 case BINOP_LESS: 1137 v = v1 < v2; 1138 break; 1139 1140 default: 1141 error (_("Invalid binary operation on numbers.")); 1142 } 1143 1144 /* This is a kludge to get around the fact that we don't 1145 know how to determine the result type from the types of 1146 the operands. (I'm not really sure how much we feel the 1147 need to duplicate the exact rules of the current 1148 language. They can get really hairy. But not to do so 1149 makes it hard to document just what we *do* do). */ 1150 1151 /* Can't just call init_type because we wouldn't know what 1152 name to give the type. */ 1153 val = allocate_value 1154 (result_len > gdbarch_long_bit (current_gdbarch) / HOST_CHAR_BIT 1155 ? builtin_type_long_long 1156 : builtin_type_long); 1157 store_signed_integer (value_contents_raw (val), 1158 TYPE_LENGTH (value_type (val)), 1159 v); 1160 } 1161 } 1162 1163 return val; 1164} 1165 1166/* Simulate the C operator ! -- return 1 if ARG1 contains zero. */ 1167 1168int 1169value_logical_not (struct value *arg1) 1170{ 1171 int len; 1172 const gdb_byte *p; 1173 struct type *type1; 1174 1175 arg1 = coerce_number (arg1); 1176 type1 = check_typedef (value_type (arg1)); 1177 1178 if (TYPE_CODE (type1) == TYPE_CODE_FLT) 1179 return 0 == value_as_double (arg1); 1180 1181 len = TYPE_LENGTH (type1); 1182 p = value_contents (arg1); 1183 1184 while (--len >= 0) 1185 { 1186 if (*p++) 1187 break; 1188 } 1189 1190 return len < 0; 1191} 1192 1193/* Perform a comparison on two string values (whose content are not 1194 necessarily null terminated) based on their length */ 1195 1196static int 1197value_strcmp (struct value *arg1, struct value *arg2) 1198{ 1199 int len1 = TYPE_LENGTH (value_type (arg1)); 1200 int len2 = TYPE_LENGTH (value_type (arg2)); 1201 const gdb_byte *s1 = value_contents (arg1); 1202 const gdb_byte *s2 = value_contents (arg2); 1203 int i, len = len1 < len2 ? len1 : len2; 1204 1205 for (i = 0; i < len; i++) 1206 { 1207 if (s1[i] < s2[i]) 1208 return -1; 1209 else if (s1[i] > s2[i]) 1210 return 1; 1211 else 1212 continue; 1213 } 1214 1215 if (len1 < len2) 1216 return -1; 1217 else if (len1 > len2) 1218 return 1; 1219 else 1220 return 0; 1221} 1222 1223/* Simulate the C operator == by returning a 1 1224 iff ARG1 and ARG2 have equal contents. */ 1225 1226int 1227value_equal (struct value *arg1, struct value *arg2) 1228{ 1229 int len; 1230 const gdb_byte *p1; 1231 const gdb_byte *p2; 1232 struct type *type1, *type2; 1233 enum type_code code1; 1234 enum type_code code2; 1235 int is_int1, is_int2; 1236 1237 arg1 = coerce_array (arg1); 1238 arg2 = coerce_array (arg2); 1239 1240 type1 = check_typedef (value_type (arg1)); 1241 type2 = check_typedef (value_type (arg2)); 1242 code1 = TYPE_CODE (type1); 1243 code2 = TYPE_CODE (type2); 1244 is_int1 = is_integral_type (type1); 1245 is_int2 = is_integral_type (type2); 1246 1247 if (is_int1 && is_int2) 1248 return longest_to_int (value_as_long (value_binop (arg1, arg2, 1249 BINOP_EQUAL))); 1250 else if ((code1 == TYPE_CODE_FLT || is_int1) 1251 && (code2 == TYPE_CODE_FLT || is_int2)) 1252 { 1253 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where 1254 `long double' values are returned in static storage (m68k). */ 1255 DOUBLEST d = value_as_double (arg1); 1256 return d == value_as_double (arg2); 1257 } 1258 1259 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever 1260 is bigger. */ 1261 else if (code1 == TYPE_CODE_PTR && is_int2) 1262 return value_as_address (arg1) == (CORE_ADDR) value_as_long (arg2); 1263 else if (code2 == TYPE_CODE_PTR && is_int1) 1264 return (CORE_ADDR) value_as_long (arg1) == value_as_address (arg2); 1265 1266 else if (code1 == code2 1267 && ((len = (int) TYPE_LENGTH (type1)) 1268 == (int) TYPE_LENGTH (type2))) 1269 { 1270 p1 = value_contents (arg1); 1271 p2 = value_contents (arg2); 1272 while (--len >= 0) 1273 { 1274 if (*p1++ != *p2++) 1275 break; 1276 } 1277 return len < 0; 1278 } 1279 else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING) 1280 { 1281 return value_strcmp (arg1, arg2) == 0; 1282 } 1283 else 1284 { 1285 error (_("Invalid type combination in equality test.")); 1286 return 0; /* For lint -- never reached */ 1287 } 1288} 1289 1290/* Simulate the C operator < by returning 1 1291 iff ARG1's contents are less than ARG2's. */ 1292 1293int 1294value_less (struct value *arg1, struct value *arg2) 1295{ 1296 enum type_code code1; 1297 enum type_code code2; 1298 struct type *type1, *type2; 1299 int is_int1, is_int2; 1300 1301 arg1 = coerce_array (arg1); 1302 arg2 = coerce_array (arg2); 1303 1304 type1 = check_typedef (value_type (arg1)); 1305 type2 = check_typedef (value_type (arg2)); 1306 code1 = TYPE_CODE (type1); 1307 code2 = TYPE_CODE (type2); 1308 is_int1 = is_integral_type (type1); 1309 is_int2 = is_integral_type (type2); 1310 1311 if (is_int1 && is_int2) 1312 return longest_to_int (value_as_long (value_binop (arg1, arg2, 1313 BINOP_LESS))); 1314 else if ((code1 == TYPE_CODE_FLT || is_int1) 1315 && (code2 == TYPE_CODE_FLT || is_int2)) 1316 { 1317 /* NOTE: kettenis/20050816: Avoid compiler bug on systems where 1318 `long double' values are returned in static storage (m68k). */ 1319 DOUBLEST d = value_as_double (arg1); 1320 return d < value_as_double (arg2); 1321 } 1322 else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR) 1323 return value_as_address (arg1) < value_as_address (arg2); 1324 1325 /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever 1326 is bigger. */ 1327 else if (code1 == TYPE_CODE_PTR && is_int2) 1328 return value_as_address (arg1) < (CORE_ADDR) value_as_long (arg2); 1329 else if (code2 == TYPE_CODE_PTR && is_int1) 1330 return (CORE_ADDR) value_as_long (arg1) < value_as_address (arg2); 1331 else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING) 1332 return value_strcmp (arg1, arg2) < 0; 1333 else 1334 { 1335 error (_("Invalid type combination in ordering comparison.")); 1336 return 0; 1337 } 1338} 1339 1340/* The unary operators +, - and ~. They free the argument ARG1. */ 1341 1342struct value * 1343value_pos (struct value *arg1) 1344{ 1345 struct type *type; 1346 1347 arg1 = coerce_ref (arg1); 1348 1349 type = check_typedef (value_type (arg1)); 1350 1351 if (TYPE_CODE (type) == TYPE_CODE_FLT) 1352 return value_from_double (type, value_as_double (arg1)); 1353 else if (is_integral_type (type)) 1354 { 1355 /* Perform integral promotion for ANSI C/C++. FIXME: What about 1356 FORTRAN and (the deleted) chill ? */ 1357 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int)) 1358 type = builtin_type_int; 1359 1360 return value_from_longest (type, value_as_long (arg1)); 1361 } 1362 else 1363 { 1364 error ("Argument to positive operation not a number."); 1365 return 0; /* For lint -- never reached */ 1366 } 1367} 1368 1369struct value * 1370value_neg (struct value *arg1) 1371{ 1372 struct type *type; 1373 struct type *result_type = value_type (arg1); 1374 1375 arg1 = coerce_ref (arg1); 1376 1377 type = check_typedef (value_type (arg1)); 1378 1379 if (TYPE_CODE (type) == TYPE_CODE_FLT) 1380 return value_from_double (result_type, -value_as_double (arg1)); 1381 else if (is_integral_type (type)) 1382 { 1383 /* Perform integral promotion for ANSI C/C++. FIXME: What about 1384 FORTRAN and (the deleted) chill ? */ 1385 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int)) 1386 result_type = builtin_type_int; 1387 1388 return value_from_longest (result_type, -value_as_long (arg1)); 1389 } 1390 else 1391 { 1392 error (_("Argument to negate operation not a number.")); 1393 return 0; /* For lint -- never reached */ 1394 } 1395} 1396 1397struct value * 1398value_complement (struct value *arg1) 1399{ 1400 struct type *type; 1401 struct type *result_type = value_type (arg1); 1402 1403 arg1 = coerce_ref (arg1); 1404 1405 type = check_typedef (value_type (arg1)); 1406 1407 if (!is_integral_type (type)) 1408 error (_("Argument to complement operation not an integer or boolean.")); 1409 1410 /* Perform integral promotion for ANSI C/C++. 1411 FIXME: What about FORTRAN ? */ 1412 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int)) 1413 result_type = builtin_type_int; 1414 1415 return value_from_longest (result_type, ~value_as_long (arg1)); 1416} 1417 1418/* The INDEX'th bit of SET value whose value_type is TYPE, 1419 and whose value_contents is valaddr. 1420 Return -1 if out of range, -2 other error. */ 1421 1422int 1423value_bit_index (struct type *type, const gdb_byte *valaddr, int index) 1424{ 1425 LONGEST low_bound, high_bound; 1426 LONGEST word; 1427 unsigned rel_index; 1428 struct type *range = TYPE_FIELD_TYPE (type, 0); 1429 if (get_discrete_bounds (range, &low_bound, &high_bound) < 0) 1430 return -2; 1431 if (index < low_bound || index > high_bound) 1432 return -1; 1433 rel_index = index - low_bound; 1434 word = unpack_long (builtin_type_unsigned_char, 1435 valaddr + (rel_index / TARGET_CHAR_BIT)); 1436 rel_index %= TARGET_CHAR_BIT; 1437 if (BITS_BIG_ENDIAN) 1438 rel_index = TARGET_CHAR_BIT - 1 - rel_index; 1439 return (word >> rel_index) & 1; 1440} 1441 1442struct value * 1443value_in (struct value *element, struct value *set) 1444{ 1445 int member; 1446 struct type *settype = check_typedef (value_type (set)); 1447 struct type *eltype = check_typedef (value_type (element)); 1448 if (TYPE_CODE (eltype) == TYPE_CODE_RANGE) 1449 eltype = TYPE_TARGET_TYPE (eltype); 1450 if (TYPE_CODE (settype) != TYPE_CODE_SET) 1451 error (_("Second argument of 'IN' has wrong type")); 1452 if (TYPE_CODE (eltype) != TYPE_CODE_INT 1453 && TYPE_CODE (eltype) != TYPE_CODE_CHAR 1454 && TYPE_CODE (eltype) != TYPE_CODE_ENUM 1455 && TYPE_CODE (eltype) != TYPE_CODE_BOOL) 1456 error (_("First argument of 'IN' has wrong type")); 1457 member = value_bit_index (settype, value_contents (set), 1458 value_as_long (element)); 1459 if (member < 0) 1460 error (_("First argument of 'IN' not in range")); 1461 return value_from_longest (LA_BOOL_TYPE, member); 1462} 1463 1464void 1465_initialize_valarith (void) 1466{ 1467} 1468