1 /* Evaluate expressions for GDB. 2 3 Copyright (C) 1986-2015 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 "symtab.h" 22 #include "gdbtypes.h" 23 #include "value.h" 24 #include "expression.h" 25 #include "target.h" 26 #include "frame.h" 27 #include "gdbthread.h" 28 #include "language.h" /* For CAST_IS_CONVERSION. */ 29 #include "f-lang.h" /* For array bound stuff. */ 30 #include "cp-abi.h" 31 #include "infcall.h" 32 #include "objc-lang.h" 33 #include "block.h" 34 #include "parser-defs.h" 35 #include "cp-support.h" 36 #include "ui-out.h" 37 #include "regcache.h" 38 #include "user-regs.h" 39 #include "valprint.h" 40 #include "gdb_obstack.h" 41 #include "objfiles.h" 42 #include <ctype.h> 43 44 /* This is defined in valops.c */ 45 extern int overload_resolution; 46 47 /* Prototypes for local functions. */ 48 49 static struct value *evaluate_subexp_for_sizeof (struct expression *, int *, 50 enum noside); 51 52 static struct value *evaluate_subexp_for_address (struct expression *, 53 int *, enum noside); 54 55 static struct value *evaluate_struct_tuple (struct value *, 56 struct expression *, int *, 57 enum noside, int); 58 59 static LONGEST init_array_element (struct value *, struct value *, 60 struct expression *, int *, enum noside, 61 LONGEST, LONGEST); 62 63 struct value * 64 evaluate_subexp (struct type *expect_type, struct expression *exp, 65 int *pos, enum noside noside) 66 { 67 struct cleanup *cleanups; 68 struct value *retval; 69 int cleanup_temps = 0; 70 71 if (*pos == 0 && target_has_execution 72 && exp->language_defn->la_language == language_cplus 73 && !thread_stack_temporaries_enabled_p (inferior_ptid)) 74 { 75 cleanups = enable_thread_stack_temporaries (inferior_ptid); 76 cleanup_temps = 1; 77 } 78 79 retval = (*exp->language_defn->la_exp_desc->evaluate_exp) 80 (expect_type, exp, pos, noside); 81 82 if (cleanup_temps) 83 { 84 if (value_in_thread_stack_temporaries (retval, inferior_ptid)) 85 retval = value_non_lval (retval); 86 do_cleanups (cleanups); 87 } 88 89 return retval; 90 } 91 92 /* Parse the string EXP as a C expression, evaluate it, 93 and return the result as a number. */ 94 95 CORE_ADDR 96 parse_and_eval_address (const char *exp) 97 { 98 struct expression *expr = parse_expression (exp); 99 CORE_ADDR addr; 100 struct cleanup *old_chain = 101 make_cleanup (free_current_contents, &expr); 102 103 addr = value_as_address (evaluate_expression (expr)); 104 do_cleanups (old_chain); 105 return addr; 106 } 107 108 /* Like parse_and_eval_address, but treats the value of the expression 109 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */ 110 LONGEST 111 parse_and_eval_long (const char *exp) 112 { 113 struct expression *expr = parse_expression (exp); 114 LONGEST retval; 115 struct cleanup *old_chain = 116 make_cleanup (free_current_contents, &expr); 117 118 retval = value_as_long (evaluate_expression (expr)); 119 do_cleanups (old_chain); 120 return (retval); 121 } 122 123 struct value * 124 parse_and_eval (const char *exp) 125 { 126 struct expression *expr = parse_expression (exp); 127 struct value *val; 128 struct cleanup *old_chain = 129 make_cleanup (free_current_contents, &expr); 130 131 val = evaluate_expression (expr); 132 do_cleanups (old_chain); 133 return val; 134 } 135 136 /* Parse up to a comma (or to a closeparen) 137 in the string EXPP as an expression, evaluate it, and return the value. 138 EXPP is advanced to point to the comma. */ 139 140 struct value * 141 parse_to_comma_and_eval (const char **expp) 142 { 143 struct expression *expr = parse_exp_1 (expp, 0, (struct block *) 0, 1); 144 struct value *val; 145 struct cleanup *old_chain = 146 make_cleanup (free_current_contents, &expr); 147 148 val = evaluate_expression (expr); 149 do_cleanups (old_chain); 150 return val; 151 } 152 153 /* Evaluate an expression in internal prefix form 154 such as is constructed by parse.y. 155 156 See expression.h for info on the format of an expression. */ 157 158 struct value * 159 evaluate_expression (struct expression *exp) 160 { 161 int pc = 0; 162 163 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_NORMAL); 164 } 165 166 /* Evaluate an expression, avoiding all memory references 167 and getting a value whose type alone is correct. */ 168 169 struct value * 170 evaluate_type (struct expression *exp) 171 { 172 int pc = 0; 173 174 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS); 175 } 176 177 /* Evaluate a subexpression, avoiding all memory references and 178 getting a value whose type alone is correct. */ 179 180 struct value * 181 evaluate_subexpression_type (struct expression *exp, int subexp) 182 { 183 return evaluate_subexp (NULL_TYPE, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS); 184 } 185 186 /* Find the current value of a watchpoint on EXP. Return the value in 187 *VALP and *RESULTP and the chain of intermediate and final values 188 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does 189 not need them. 190 191 If PRESERVE_ERRORS is true, then exceptions are passed through. 192 Otherwise, if PRESERVE_ERRORS is false, then if a memory error 193 occurs while evaluating the expression, *RESULTP will be set to 194 NULL. *RESULTP may be a lazy value, if the result could not be 195 read from memory. It is used to determine whether a value is 196 user-specified (we should watch the whole value) or intermediate 197 (we should watch only the bit used to locate the final value). 198 199 If the final value, or any intermediate value, could not be read 200 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be 201 set to any referenced values. *VALP will never be a lazy value. 202 This is the value which we store in struct breakpoint. 203 204 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the 205 value chain. The caller must free the values individually. If 206 VAL_CHAIN is NULL, all generated values will be left on the value 207 chain. */ 208 209 void 210 fetch_subexp_value (struct expression *exp, int *pc, struct value **valp, 211 struct value **resultp, struct value **val_chain, 212 int preserve_errors) 213 { 214 struct value *mark, *new_mark, *result; 215 volatile struct gdb_exception ex; 216 217 *valp = NULL; 218 if (resultp) 219 *resultp = NULL; 220 if (val_chain) 221 *val_chain = NULL; 222 223 /* Evaluate the expression. */ 224 mark = value_mark (); 225 result = NULL; 226 227 TRY_CATCH (ex, RETURN_MASK_ALL) 228 { 229 result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL); 230 } 231 if (ex.reason < 0) 232 { 233 /* Ignore memory errors if we want watchpoints pointing at 234 inaccessible memory to still be created; otherwise, throw the 235 error to some higher catcher. */ 236 switch (ex.error) 237 { 238 case MEMORY_ERROR: 239 if (!preserve_errors) 240 break; 241 default: 242 throw_exception (ex); 243 break; 244 } 245 } 246 247 new_mark = value_mark (); 248 if (mark == new_mark) 249 return; 250 if (resultp) 251 *resultp = result; 252 253 /* Make sure it's not lazy, so that after the target stops again we 254 have a non-lazy previous value to compare with. */ 255 if (result != NULL) 256 { 257 if (!value_lazy (result)) 258 *valp = result; 259 else 260 { 261 volatile struct gdb_exception except; 262 263 TRY_CATCH (except, RETURN_MASK_ERROR) 264 { 265 value_fetch_lazy (result); 266 *valp = result; 267 } 268 } 269 } 270 271 if (val_chain) 272 { 273 /* Return the chain of intermediate values. We use this to 274 decide which addresses to watch. */ 275 *val_chain = new_mark; 276 value_release_to_mark (mark); 277 } 278 } 279 280 /* Extract a field operation from an expression. If the subexpression 281 of EXP starting at *SUBEXP is not a structure dereference 282 operation, return NULL. Otherwise, return the name of the 283 dereferenced field, and advance *SUBEXP to point to the 284 subexpression of the left-hand-side of the dereference. This is 285 used when completing field names. */ 286 287 char * 288 extract_field_op (struct expression *exp, int *subexp) 289 { 290 int tem; 291 char *result; 292 293 if (exp->elts[*subexp].opcode != STRUCTOP_STRUCT 294 && exp->elts[*subexp].opcode != STRUCTOP_PTR) 295 return NULL; 296 tem = longest_to_int (exp->elts[*subexp + 1].longconst); 297 result = &exp->elts[*subexp + 2].string; 298 (*subexp) += 1 + 3 + BYTES_TO_EXP_ELEM (tem + 1); 299 return result; 300 } 301 302 /* This function evaluates brace-initializers (in C/C++) for 303 structure types. */ 304 305 static struct value * 306 evaluate_struct_tuple (struct value *struct_val, 307 struct expression *exp, 308 int *pos, enum noside noside, int nargs) 309 { 310 struct type *struct_type = check_typedef (value_type (struct_val)); 311 struct type *field_type; 312 int fieldno = -1; 313 314 while (--nargs >= 0) 315 { 316 struct value *val = NULL; 317 int bitpos, bitsize; 318 bfd_byte *addr; 319 320 fieldno++; 321 /* Skip static fields. */ 322 while (fieldno < TYPE_NFIELDS (struct_type) 323 && field_is_static (&TYPE_FIELD (struct_type, 324 fieldno))) 325 fieldno++; 326 if (fieldno >= TYPE_NFIELDS (struct_type)) 327 error (_("too many initializers")); 328 field_type = TYPE_FIELD_TYPE (struct_type, fieldno); 329 if (TYPE_CODE (field_type) == TYPE_CODE_UNION 330 && TYPE_FIELD_NAME (struct_type, fieldno)[0] == '0') 331 error (_("don't know which variant you want to set")); 332 333 /* Here, struct_type is the type of the inner struct, 334 while substruct_type is the type of the inner struct. 335 These are the same for normal structures, but a variant struct 336 contains anonymous union fields that contain substruct fields. 337 The value fieldno is the index of the top-level (normal or 338 anonymous union) field in struct_field, while the value 339 subfieldno is the index of the actual real (named inner) field 340 in substruct_type. */ 341 342 field_type = TYPE_FIELD_TYPE (struct_type, fieldno); 343 if (val == 0) 344 val = evaluate_subexp (field_type, exp, pos, noside); 345 346 /* Now actually set the field in struct_val. */ 347 348 /* Assign val to field fieldno. */ 349 if (value_type (val) != field_type) 350 val = value_cast (field_type, val); 351 352 bitsize = TYPE_FIELD_BITSIZE (struct_type, fieldno); 353 bitpos = TYPE_FIELD_BITPOS (struct_type, fieldno); 354 addr = value_contents_writeable (struct_val) + bitpos / 8; 355 if (bitsize) 356 modify_field (struct_type, addr, 357 value_as_long (val), bitpos % 8, bitsize); 358 else 359 memcpy (addr, value_contents (val), 360 TYPE_LENGTH (value_type (val))); 361 362 } 363 return struct_val; 364 } 365 366 /* Recursive helper function for setting elements of array tuples. 367 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the 368 element value is ELEMENT; EXP, POS and NOSIDE are as usual. 369 Evaluates index expresions and sets the specified element(s) of 370 ARRAY to ELEMENT. Returns last index value. */ 371 372 static LONGEST 373 init_array_element (struct value *array, struct value *element, 374 struct expression *exp, int *pos, 375 enum noside noside, LONGEST low_bound, LONGEST high_bound) 376 { 377 LONGEST index; 378 int element_size = TYPE_LENGTH (value_type (element)); 379 380 if (exp->elts[*pos].opcode == BINOP_COMMA) 381 { 382 (*pos)++; 383 init_array_element (array, element, exp, pos, noside, 384 low_bound, high_bound); 385 return init_array_element (array, element, 386 exp, pos, noside, low_bound, high_bound); 387 } 388 else 389 { 390 index = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside)); 391 if (index < low_bound || index > high_bound) 392 error (_("tuple index out of range")); 393 memcpy (value_contents_raw (array) + (index - low_bound) * element_size, 394 value_contents (element), element_size); 395 } 396 return index; 397 } 398 399 static struct value * 400 value_f90_subarray (struct value *array, 401 struct expression *exp, int *pos, enum noside noside) 402 { 403 int pc = (*pos) + 1; 404 LONGEST low_bound, high_bound; 405 struct type *range = check_typedef (TYPE_INDEX_TYPE (value_type (array))); 406 enum f90_range_type range_type = longest_to_int (exp->elts[pc].longconst); 407 408 *pos += 3; 409 410 if (range_type == LOW_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT) 411 low_bound = TYPE_LOW_BOUND (range); 412 else 413 low_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside)); 414 415 if (range_type == HIGH_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT) 416 high_bound = TYPE_HIGH_BOUND (range); 417 else 418 high_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside)); 419 420 return value_slice (array, low_bound, high_bound - low_bound + 1); 421 } 422 423 424 /* Promote value ARG1 as appropriate before performing a unary operation 425 on this argument. 426 If the result is not appropriate for any particular language then it 427 needs to patch this function. */ 428 429 void 430 unop_promote (const struct language_defn *language, struct gdbarch *gdbarch, 431 struct value **arg1) 432 { 433 struct type *type1; 434 435 *arg1 = coerce_ref (*arg1); 436 type1 = check_typedef (value_type (*arg1)); 437 438 if (is_integral_type (type1)) 439 { 440 switch (language->la_language) 441 { 442 default: 443 /* Perform integral promotion for ANSI C/C++. 444 If not appropropriate for any particular language 445 it needs to modify this function. */ 446 { 447 struct type *builtin_int = builtin_type (gdbarch)->builtin_int; 448 449 if (TYPE_LENGTH (type1) < TYPE_LENGTH (builtin_int)) 450 *arg1 = value_cast (builtin_int, *arg1); 451 } 452 break; 453 } 454 } 455 } 456 457 /* Promote values ARG1 and ARG2 as appropriate before performing a binary 458 operation on those two operands. 459 If the result is not appropriate for any particular language then it 460 needs to patch this function. */ 461 462 void 463 binop_promote (const struct language_defn *language, struct gdbarch *gdbarch, 464 struct value **arg1, struct value **arg2) 465 { 466 struct type *promoted_type = NULL; 467 struct type *type1; 468 struct type *type2; 469 470 *arg1 = coerce_ref (*arg1); 471 *arg2 = coerce_ref (*arg2); 472 473 type1 = check_typedef (value_type (*arg1)); 474 type2 = check_typedef (value_type (*arg2)); 475 476 if ((TYPE_CODE (type1) != TYPE_CODE_FLT 477 && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT 478 && !is_integral_type (type1)) 479 || (TYPE_CODE (type2) != TYPE_CODE_FLT 480 && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT 481 && !is_integral_type (type2))) 482 return; 483 484 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT 485 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT) 486 { 487 /* No promotion required. */ 488 } 489 else if (TYPE_CODE (type1) == TYPE_CODE_FLT 490 || TYPE_CODE (type2) == TYPE_CODE_FLT) 491 { 492 switch (language->la_language) 493 { 494 case language_c: 495 case language_cplus: 496 case language_asm: 497 case language_objc: 498 case language_opencl: 499 /* No promotion required. */ 500 break; 501 502 default: 503 /* For other languages the result type is unchanged from gdb 504 version 6.7 for backward compatibility. 505 If either arg was long double, make sure that value is also long 506 double. Otherwise use double. */ 507 if (TYPE_LENGTH (type1) * 8 > gdbarch_double_bit (gdbarch) 508 || TYPE_LENGTH (type2) * 8 > gdbarch_double_bit (gdbarch)) 509 promoted_type = builtin_type (gdbarch)->builtin_long_double; 510 else 511 promoted_type = builtin_type (gdbarch)->builtin_double; 512 break; 513 } 514 } 515 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL 516 && TYPE_CODE (type2) == TYPE_CODE_BOOL) 517 { 518 /* No promotion required. */ 519 } 520 else 521 /* Integral operations here. */ 522 /* FIXME: Also mixed integral/booleans, with result an integer. */ 523 { 524 const struct builtin_type *builtin = builtin_type (gdbarch); 525 unsigned int promoted_len1 = TYPE_LENGTH (type1); 526 unsigned int promoted_len2 = TYPE_LENGTH (type2); 527 int is_unsigned1 = TYPE_UNSIGNED (type1); 528 int is_unsigned2 = TYPE_UNSIGNED (type2); 529 unsigned int result_len; 530 int unsigned_operation; 531 532 /* Determine type length and signedness after promotion for 533 both operands. */ 534 if (promoted_len1 < TYPE_LENGTH (builtin->builtin_int)) 535 { 536 is_unsigned1 = 0; 537 promoted_len1 = TYPE_LENGTH (builtin->builtin_int); 538 } 539 if (promoted_len2 < TYPE_LENGTH (builtin->builtin_int)) 540 { 541 is_unsigned2 = 0; 542 promoted_len2 = TYPE_LENGTH (builtin->builtin_int); 543 } 544 545 if (promoted_len1 > promoted_len2) 546 { 547 unsigned_operation = is_unsigned1; 548 result_len = promoted_len1; 549 } 550 else if (promoted_len2 > promoted_len1) 551 { 552 unsigned_operation = is_unsigned2; 553 result_len = promoted_len2; 554 } 555 else 556 { 557 unsigned_operation = is_unsigned1 || is_unsigned2; 558 result_len = promoted_len1; 559 } 560 561 switch (language->la_language) 562 { 563 case language_c: 564 case language_cplus: 565 case language_asm: 566 case language_objc: 567 if (result_len <= TYPE_LENGTH (builtin->builtin_int)) 568 { 569 promoted_type = (unsigned_operation 570 ? builtin->builtin_unsigned_int 571 : builtin->builtin_int); 572 } 573 else if (result_len <= TYPE_LENGTH (builtin->builtin_long)) 574 { 575 promoted_type = (unsigned_operation 576 ? builtin->builtin_unsigned_long 577 : builtin->builtin_long); 578 } 579 else 580 { 581 promoted_type = (unsigned_operation 582 ? builtin->builtin_unsigned_long_long 583 : builtin->builtin_long_long); 584 } 585 break; 586 case language_opencl: 587 if (result_len <= TYPE_LENGTH (lookup_signed_typename 588 (language, gdbarch, "int"))) 589 { 590 promoted_type = 591 (unsigned_operation 592 ? lookup_unsigned_typename (language, gdbarch, "int") 593 : lookup_signed_typename (language, gdbarch, "int")); 594 } 595 else if (result_len <= TYPE_LENGTH (lookup_signed_typename 596 (language, gdbarch, "long"))) 597 { 598 promoted_type = 599 (unsigned_operation 600 ? lookup_unsigned_typename (language, gdbarch, "long") 601 : lookup_signed_typename (language, gdbarch,"long")); 602 } 603 break; 604 default: 605 /* For other languages the result type is unchanged from gdb 606 version 6.7 for backward compatibility. 607 If either arg was long long, make sure that value is also long 608 long. Otherwise use long. */ 609 if (unsigned_operation) 610 { 611 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT) 612 promoted_type = builtin->builtin_unsigned_long_long; 613 else 614 promoted_type = builtin->builtin_unsigned_long; 615 } 616 else 617 { 618 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT) 619 promoted_type = builtin->builtin_long_long; 620 else 621 promoted_type = builtin->builtin_long; 622 } 623 break; 624 } 625 } 626 627 if (promoted_type) 628 { 629 /* Promote both operands to common type. */ 630 *arg1 = value_cast (promoted_type, *arg1); 631 *arg2 = value_cast (promoted_type, *arg2); 632 } 633 } 634 635 static int 636 ptrmath_type_p (const struct language_defn *lang, struct type *type) 637 { 638 type = check_typedef (type); 639 if (TYPE_CODE (type) == TYPE_CODE_REF) 640 type = TYPE_TARGET_TYPE (type); 641 642 switch (TYPE_CODE (type)) 643 { 644 case TYPE_CODE_PTR: 645 case TYPE_CODE_FUNC: 646 return 1; 647 648 case TYPE_CODE_ARRAY: 649 return TYPE_VECTOR (type) ? 0 : lang->c_style_arrays; 650 651 default: 652 return 0; 653 } 654 } 655 656 /* Constructs a fake method with the given parameter types. 657 This function is used by the parser to construct an "expected" 658 type for method overload resolution. */ 659 660 static struct type * 661 make_params (int num_types, struct type **param_types) 662 { 663 struct type *type = XCNEW (struct type); 664 TYPE_MAIN_TYPE (type) = XCNEW (struct main_type); 665 TYPE_LENGTH (type) = 1; 666 TYPE_CODE (type) = TYPE_CODE_METHOD; 667 TYPE_VPTR_FIELDNO (type) = -1; 668 TYPE_CHAIN (type) = type; 669 if (num_types > 0) 670 { 671 if (param_types[num_types - 1] == NULL) 672 { 673 --num_types; 674 TYPE_VARARGS (type) = 1; 675 } 676 else if (TYPE_CODE (check_typedef (param_types[num_types - 1])) 677 == TYPE_CODE_VOID) 678 { 679 --num_types; 680 /* Caller should have ensured this. */ 681 gdb_assert (num_types == 0); 682 TYPE_PROTOTYPED (type) = 1; 683 } 684 } 685 686 TYPE_NFIELDS (type) = num_types; 687 TYPE_FIELDS (type) = (struct field *) 688 TYPE_ZALLOC (type, sizeof (struct field) * num_types); 689 690 while (num_types-- > 0) 691 TYPE_FIELD_TYPE (type, num_types) = param_types[num_types]; 692 693 return type; 694 } 695 696 struct value * 697 evaluate_subexp_standard (struct type *expect_type, 698 struct expression *exp, int *pos, 699 enum noside noside) 700 { 701 enum exp_opcode op; 702 int tem, tem2, tem3; 703 int pc, pc2 = 0, oldpos; 704 struct value *arg1 = NULL; 705 struct value *arg2 = NULL; 706 struct value *arg3; 707 struct type *type; 708 int nargs; 709 struct value **argvec; 710 int code; 711 int ix; 712 long mem_offset; 713 struct type **arg_types; 714 int save_pos1; 715 struct symbol *function = NULL; 716 char *function_name = NULL; 717 718 pc = (*pos)++; 719 op = exp->elts[pc].opcode; 720 721 switch (op) 722 { 723 case OP_SCOPE: 724 tem = longest_to_int (exp->elts[pc + 2].longconst); 725 (*pos) += 4 + BYTES_TO_EXP_ELEM (tem + 1); 726 if (noside == EVAL_SKIP) 727 goto nosideret; 728 arg1 = value_aggregate_elt (exp->elts[pc + 1].type, 729 &exp->elts[pc + 3].string, 730 expect_type, 0, noside); 731 if (arg1 == NULL) 732 error (_("There is no field named %s"), &exp->elts[pc + 3].string); 733 return arg1; 734 735 case OP_LONG: 736 (*pos) += 3; 737 return value_from_longest (exp->elts[pc + 1].type, 738 exp->elts[pc + 2].longconst); 739 740 case OP_DOUBLE: 741 (*pos) += 3; 742 return value_from_double (exp->elts[pc + 1].type, 743 exp->elts[pc + 2].doubleconst); 744 745 case OP_DECFLOAT: 746 (*pos) += 3; 747 return value_from_decfloat (exp->elts[pc + 1].type, 748 exp->elts[pc + 2].decfloatconst); 749 750 case OP_ADL_FUNC: 751 case OP_VAR_VALUE: 752 (*pos) += 3; 753 if (noside == EVAL_SKIP) 754 goto nosideret; 755 756 /* JYG: We used to just return value_zero of the symbol type 757 if we're asked to avoid side effects. Otherwise we return 758 value_of_variable (...). However I'm not sure if 759 value_of_variable () has any side effect. 760 We need a full value object returned here for whatis_exp () 761 to call evaluate_type () and then pass the full value to 762 value_rtti_target_type () if we are dealing with a pointer 763 or reference to a base class and print object is on. */ 764 765 { 766 volatile struct gdb_exception except; 767 struct value *ret = NULL; 768 769 TRY_CATCH (except, RETURN_MASK_ERROR) 770 { 771 ret = value_of_variable (exp->elts[pc + 2].symbol, 772 exp->elts[pc + 1].block); 773 } 774 775 if (except.reason < 0) 776 { 777 if (noside == EVAL_AVOID_SIDE_EFFECTS) 778 ret = value_zero (SYMBOL_TYPE (exp->elts[pc + 2].symbol), 779 not_lval); 780 else 781 throw_exception (except); 782 } 783 784 return ret; 785 } 786 787 case OP_VAR_ENTRY_VALUE: 788 (*pos) += 2; 789 if (noside == EVAL_SKIP) 790 goto nosideret; 791 792 { 793 struct symbol *sym = exp->elts[pc + 1].symbol; 794 struct frame_info *frame; 795 796 if (noside == EVAL_AVOID_SIDE_EFFECTS) 797 return value_zero (SYMBOL_TYPE (sym), not_lval); 798 799 if (SYMBOL_COMPUTED_OPS (sym) == NULL 800 || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL) 801 error (_("Symbol \"%s\" does not have any specific entry value"), 802 SYMBOL_PRINT_NAME (sym)); 803 804 frame = get_selected_frame (NULL); 805 return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame); 806 } 807 808 case OP_LAST: 809 (*pos) += 2; 810 return 811 access_value_history (longest_to_int (exp->elts[pc + 1].longconst)); 812 813 case OP_REGISTER: 814 { 815 const char *name = &exp->elts[pc + 2].string; 816 int regno; 817 struct value *val; 818 819 (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1); 820 regno = user_reg_map_name_to_regnum (exp->gdbarch, 821 name, strlen (name)); 822 if (regno == -1) 823 error (_("Register $%s not available."), name); 824 825 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return 826 a value with the appropriate register type. Unfortunately, 827 we don't have easy access to the type of user registers. 828 So for these registers, we fetch the register value regardless 829 of the evaluation mode. */ 830 if (noside == EVAL_AVOID_SIDE_EFFECTS 831 && regno < gdbarch_num_regs (exp->gdbarch) 832 + gdbarch_num_pseudo_regs (exp->gdbarch)) 833 val = value_zero (register_type (exp->gdbarch, regno), not_lval); 834 else 835 val = value_of_register (regno, get_selected_frame (NULL)); 836 if (val == NULL) 837 error (_("Value of register %s not available."), name); 838 else 839 return val; 840 } 841 case OP_BOOL: 842 (*pos) += 2; 843 type = language_bool_type (exp->language_defn, exp->gdbarch); 844 return value_from_longest (type, exp->elts[pc + 1].longconst); 845 846 case OP_INTERNALVAR: 847 (*pos) += 2; 848 return value_of_internalvar (exp->gdbarch, 849 exp->elts[pc + 1].internalvar); 850 851 case OP_STRING: 852 tem = longest_to_int (exp->elts[pc + 1].longconst); 853 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1); 854 if (noside == EVAL_SKIP) 855 goto nosideret; 856 type = language_string_char_type (exp->language_defn, exp->gdbarch); 857 return value_string (&exp->elts[pc + 2].string, tem, type); 858 859 case OP_OBJC_NSSTRING: /* Objective C Foundation Class 860 NSString constant. */ 861 tem = longest_to_int (exp->elts[pc + 1].longconst); 862 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1); 863 if (noside == EVAL_SKIP) 864 { 865 goto nosideret; 866 } 867 return value_nsstring (exp->gdbarch, &exp->elts[pc + 2].string, tem + 1); 868 869 case OP_ARRAY: 870 (*pos) += 3; 871 tem2 = longest_to_int (exp->elts[pc + 1].longconst); 872 tem3 = longest_to_int (exp->elts[pc + 2].longconst); 873 nargs = tem3 - tem2 + 1; 874 type = expect_type ? check_typedef (expect_type) : NULL_TYPE; 875 876 if (expect_type != NULL_TYPE && noside != EVAL_SKIP 877 && TYPE_CODE (type) == TYPE_CODE_STRUCT) 878 { 879 struct value *rec = allocate_value (expect_type); 880 881 memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type)); 882 return evaluate_struct_tuple (rec, exp, pos, noside, nargs); 883 } 884 885 if (expect_type != NULL_TYPE && noside != EVAL_SKIP 886 && TYPE_CODE (type) == TYPE_CODE_ARRAY) 887 { 888 struct type *range_type = TYPE_INDEX_TYPE (type); 889 struct type *element_type = TYPE_TARGET_TYPE (type); 890 struct value *array = allocate_value (expect_type); 891 int element_size = TYPE_LENGTH (check_typedef (element_type)); 892 LONGEST low_bound, high_bound, index; 893 894 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0) 895 { 896 low_bound = 0; 897 high_bound = (TYPE_LENGTH (type) / element_size) - 1; 898 } 899 index = low_bound; 900 memset (value_contents_raw (array), 0, TYPE_LENGTH (expect_type)); 901 for (tem = nargs; --nargs >= 0;) 902 { 903 struct value *element; 904 int index_pc = 0; 905 906 element = evaluate_subexp (element_type, exp, pos, noside); 907 if (value_type (element) != element_type) 908 element = value_cast (element_type, element); 909 if (index_pc) 910 { 911 int continue_pc = *pos; 912 913 *pos = index_pc; 914 index = init_array_element (array, element, exp, pos, noside, 915 low_bound, high_bound); 916 *pos = continue_pc; 917 } 918 else 919 { 920 if (index > high_bound) 921 /* To avoid memory corruption. */ 922 error (_("Too many array elements")); 923 memcpy (value_contents_raw (array) 924 + (index - low_bound) * element_size, 925 value_contents (element), 926 element_size); 927 } 928 index++; 929 } 930 return array; 931 } 932 933 if (expect_type != NULL_TYPE && noside != EVAL_SKIP 934 && TYPE_CODE (type) == TYPE_CODE_SET) 935 { 936 struct value *set = allocate_value (expect_type); 937 gdb_byte *valaddr = value_contents_raw (set); 938 struct type *element_type = TYPE_INDEX_TYPE (type); 939 struct type *check_type = element_type; 940 LONGEST low_bound, high_bound; 941 942 /* Get targettype of elementtype. */ 943 while (TYPE_CODE (check_type) == TYPE_CODE_RANGE 944 || TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF) 945 check_type = TYPE_TARGET_TYPE (check_type); 946 947 if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0) 948 error (_("(power)set type with unknown size")); 949 memset (valaddr, '\0', TYPE_LENGTH (type)); 950 for (tem = 0; tem < nargs; tem++) 951 { 952 LONGEST range_low, range_high; 953 struct type *range_low_type, *range_high_type; 954 struct value *elem_val; 955 956 elem_val = evaluate_subexp (element_type, exp, pos, noside); 957 range_low_type = range_high_type = value_type (elem_val); 958 range_low = range_high = value_as_long (elem_val); 959 960 /* Check types of elements to avoid mixture of elements from 961 different types. Also check if type of element is "compatible" 962 with element type of powerset. */ 963 if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE) 964 range_low_type = TYPE_TARGET_TYPE (range_low_type); 965 if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE) 966 range_high_type = TYPE_TARGET_TYPE (range_high_type); 967 if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type)) 968 || (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM 969 && (range_low_type != range_high_type))) 970 /* different element modes. */ 971 error (_("POWERSET tuple elements of different mode")); 972 if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type)) 973 || (TYPE_CODE (check_type) == TYPE_CODE_ENUM 974 && range_low_type != check_type)) 975 error (_("incompatible POWERSET tuple elements")); 976 if (range_low > range_high) 977 { 978 warning (_("empty POWERSET tuple range")); 979 continue; 980 } 981 if (range_low < low_bound || range_high > high_bound) 982 error (_("POWERSET tuple element out of range")); 983 range_low -= low_bound; 984 range_high -= low_bound; 985 for (; range_low <= range_high; range_low++) 986 { 987 int bit_index = (unsigned) range_low % TARGET_CHAR_BIT; 988 989 if (gdbarch_bits_big_endian (exp->gdbarch)) 990 bit_index = TARGET_CHAR_BIT - 1 - bit_index; 991 valaddr[(unsigned) range_low / TARGET_CHAR_BIT] 992 |= 1 << bit_index; 993 } 994 } 995 return set; 996 } 997 998 argvec = (struct value **) alloca (sizeof (struct value *) * nargs); 999 for (tem = 0; tem < nargs; tem++) 1000 { 1001 /* Ensure that array expressions are coerced into pointer 1002 objects. */ 1003 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside); 1004 } 1005 if (noside == EVAL_SKIP) 1006 goto nosideret; 1007 return value_array (tem2, tem3, argvec); 1008 1009 case TERNOP_SLICE: 1010 { 1011 struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside); 1012 int lowbound 1013 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside)); 1014 int upper 1015 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside)); 1016 1017 if (noside == EVAL_SKIP) 1018 goto nosideret; 1019 return value_slice (array, lowbound, upper - lowbound + 1); 1020 } 1021 1022 case TERNOP_COND: 1023 /* Skip third and second args to evaluate the first one. */ 1024 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 1025 if (value_logical_not (arg1)) 1026 { 1027 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP); 1028 return evaluate_subexp (NULL_TYPE, exp, pos, noside); 1029 } 1030 else 1031 { 1032 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 1033 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP); 1034 return arg2; 1035 } 1036 1037 case OP_OBJC_SELECTOR: 1038 { /* Objective C @selector operator. */ 1039 char *sel = &exp->elts[pc + 2].string; 1040 int len = longest_to_int (exp->elts[pc + 1].longconst); 1041 struct type *selector_type; 1042 1043 (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1); 1044 if (noside == EVAL_SKIP) 1045 goto nosideret; 1046 1047 if (sel[len] != 0) 1048 sel[len] = 0; /* Make sure it's terminated. */ 1049 1050 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr; 1051 return value_from_longest (selector_type, 1052 lookup_child_selector (exp->gdbarch, sel)); 1053 } 1054 1055 case OP_OBJC_MSGCALL: 1056 { /* Objective C message (method) call. */ 1057 1058 CORE_ADDR responds_selector = 0; 1059 CORE_ADDR method_selector = 0; 1060 1061 CORE_ADDR selector = 0; 1062 1063 int struct_return = 0; 1064 int sub_no_side = 0; 1065 1066 struct value *msg_send = NULL; 1067 struct value *msg_send_stret = NULL; 1068 int gnu_runtime = 0; 1069 1070 struct value *target = NULL; 1071 struct value *method = NULL; 1072 struct value *called_method = NULL; 1073 1074 struct type *selector_type = NULL; 1075 struct type *long_type; 1076 1077 struct value *ret = NULL; 1078 CORE_ADDR addr = 0; 1079 1080 selector = exp->elts[pc + 1].longconst; 1081 nargs = exp->elts[pc + 2].longconst; 1082 argvec = (struct value **) alloca (sizeof (struct value *) 1083 * (nargs + 5)); 1084 1085 (*pos) += 3; 1086 1087 long_type = builtin_type (exp->gdbarch)->builtin_long; 1088 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr; 1089 1090 if (noside == EVAL_AVOID_SIDE_EFFECTS) 1091 sub_no_side = EVAL_NORMAL; 1092 else 1093 sub_no_side = noside; 1094 1095 target = evaluate_subexp (selector_type, exp, pos, sub_no_side); 1096 1097 if (value_as_long (target) == 0) 1098 return value_from_longest (long_type, 0); 1099 1100 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym) 1101 gnu_runtime = 1; 1102 1103 /* Find the method dispatch (Apple runtime) or method lookup 1104 (GNU runtime) function for Objective-C. These will be used 1105 to lookup the symbol information for the method. If we 1106 can't find any symbol information, then we'll use these to 1107 call the method, otherwise we can call the method 1108 directly. The msg_send_stret function is used in the special 1109 case of a method that returns a structure (Apple runtime 1110 only). */ 1111 if (gnu_runtime) 1112 { 1113 struct type *type = selector_type; 1114 1115 type = lookup_function_type (type); 1116 type = lookup_pointer_type (type); 1117 type = lookup_function_type (type); 1118 type = lookup_pointer_type (type); 1119 1120 msg_send = find_function_in_inferior ("objc_msg_lookup", NULL); 1121 msg_send_stret 1122 = find_function_in_inferior ("objc_msg_lookup", NULL); 1123 1124 msg_send = value_from_pointer (type, value_as_address (msg_send)); 1125 msg_send_stret = value_from_pointer (type, 1126 value_as_address (msg_send_stret)); 1127 } 1128 else 1129 { 1130 msg_send = find_function_in_inferior ("objc_msgSend", NULL); 1131 /* Special dispatcher for methods returning structs. */ 1132 msg_send_stret 1133 = find_function_in_inferior ("objc_msgSend_stret", NULL); 1134 } 1135 1136 /* Verify the target object responds to this method. The 1137 standard top-level 'Object' class uses a different name for 1138 the verification method than the non-standard, but more 1139 often used, 'NSObject' class. Make sure we check for both. */ 1140 1141 responds_selector 1142 = lookup_child_selector (exp->gdbarch, "respondsToSelector:"); 1143 if (responds_selector == 0) 1144 responds_selector 1145 = lookup_child_selector (exp->gdbarch, "respondsTo:"); 1146 1147 if (responds_selector == 0) 1148 error (_("no 'respondsTo:' or 'respondsToSelector:' method")); 1149 1150 method_selector 1151 = lookup_child_selector (exp->gdbarch, "methodForSelector:"); 1152 if (method_selector == 0) 1153 method_selector 1154 = lookup_child_selector (exp->gdbarch, "methodFor:"); 1155 1156 if (method_selector == 0) 1157 error (_("no 'methodFor:' or 'methodForSelector:' method")); 1158 1159 /* Call the verification method, to make sure that the target 1160 class implements the desired method. */ 1161 1162 argvec[0] = msg_send; 1163 argvec[1] = target; 1164 argvec[2] = value_from_longest (long_type, responds_selector); 1165 argvec[3] = value_from_longest (long_type, selector); 1166 argvec[4] = 0; 1167 1168 ret = call_function_by_hand (argvec[0], 3, argvec + 1); 1169 if (gnu_runtime) 1170 { 1171 /* Function objc_msg_lookup returns a pointer. */ 1172 argvec[0] = ret; 1173 ret = call_function_by_hand (argvec[0], 3, argvec + 1); 1174 } 1175 if (value_as_long (ret) == 0) 1176 error (_("Target does not respond to this message selector.")); 1177 1178 /* Call "methodForSelector:" method, to get the address of a 1179 function method that implements this selector for this 1180 class. If we can find a symbol at that address, then we 1181 know the return type, parameter types etc. (that's a good 1182 thing). */ 1183 1184 argvec[0] = msg_send; 1185 argvec[1] = target; 1186 argvec[2] = value_from_longest (long_type, method_selector); 1187 argvec[3] = value_from_longest (long_type, selector); 1188 argvec[4] = 0; 1189 1190 ret = call_function_by_hand (argvec[0], 3, argvec + 1); 1191 if (gnu_runtime) 1192 { 1193 argvec[0] = ret; 1194 ret = call_function_by_hand (argvec[0], 3, argvec + 1); 1195 } 1196 1197 /* ret should now be the selector. */ 1198 1199 addr = value_as_long (ret); 1200 if (addr) 1201 { 1202 struct symbol *sym = NULL; 1203 1204 /* The address might point to a function descriptor; 1205 resolve it to the actual code address instead. */ 1206 addr = gdbarch_convert_from_func_ptr_addr (exp->gdbarch, addr, 1207 ¤t_target); 1208 1209 /* Is it a high_level symbol? */ 1210 sym = find_pc_function (addr); 1211 if (sym != NULL) 1212 method = value_of_variable (sym, 0); 1213 } 1214 1215 /* If we found a method with symbol information, check to see 1216 if it returns a struct. Otherwise assume it doesn't. */ 1217 1218 if (method) 1219 { 1220 CORE_ADDR funaddr; 1221 struct type *val_type; 1222 1223 funaddr = find_function_addr (method, &val_type); 1224 1225 block_for_pc (funaddr); 1226 1227 CHECK_TYPEDEF (val_type); 1228 1229 if ((val_type == NULL) 1230 || (TYPE_CODE(val_type) == TYPE_CODE_ERROR)) 1231 { 1232 if (expect_type != NULL) 1233 val_type = expect_type; 1234 } 1235 1236 struct_return = using_struct_return (exp->gdbarch, method, 1237 val_type); 1238 } 1239 else if (expect_type != NULL) 1240 { 1241 struct_return = using_struct_return (exp->gdbarch, NULL, 1242 check_typedef (expect_type)); 1243 } 1244 1245 /* Found a function symbol. Now we will substitute its 1246 value in place of the message dispatcher (obj_msgSend), 1247 so that we call the method directly instead of thru 1248 the dispatcher. The main reason for doing this is that 1249 we can now evaluate the return value and parameter values 1250 according to their known data types, in case we need to 1251 do things like promotion, dereferencing, special handling 1252 of structs and doubles, etc. 1253 1254 We want to use the type signature of 'method', but still 1255 jump to objc_msgSend() or objc_msgSend_stret() to better 1256 mimic the behavior of the runtime. */ 1257 1258 if (method) 1259 { 1260 if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC) 1261 error (_("method address has symbol information " 1262 "with non-function type; skipping")); 1263 1264 /* Create a function pointer of the appropriate type, and 1265 replace its value with the value of msg_send or 1266 msg_send_stret. We must use a pointer here, as 1267 msg_send and msg_send_stret are of pointer type, and 1268 the representation may be different on systems that use 1269 function descriptors. */ 1270 if (struct_return) 1271 called_method 1272 = value_from_pointer (lookup_pointer_type (value_type (method)), 1273 value_as_address (msg_send_stret)); 1274 else 1275 called_method 1276 = value_from_pointer (lookup_pointer_type (value_type (method)), 1277 value_as_address (msg_send)); 1278 } 1279 else 1280 { 1281 if (struct_return) 1282 called_method = msg_send_stret; 1283 else 1284 called_method = msg_send; 1285 } 1286 1287 if (noside == EVAL_SKIP) 1288 goto nosideret; 1289 1290 if (noside == EVAL_AVOID_SIDE_EFFECTS) 1291 { 1292 /* If the return type doesn't look like a function type, 1293 call an error. This can happen if somebody tries to 1294 turn a variable into a function call. This is here 1295 because people often want to call, eg, strcmp, which 1296 gdb doesn't know is a function. If gdb isn't asked for 1297 it's opinion (ie. through "whatis"), it won't offer 1298 it. */ 1299 1300 struct type *type = value_type (called_method); 1301 1302 if (type && TYPE_CODE (type) == TYPE_CODE_PTR) 1303 type = TYPE_TARGET_TYPE (type); 1304 type = TYPE_TARGET_TYPE (type); 1305 1306 if (type) 1307 { 1308 if ((TYPE_CODE (type) == TYPE_CODE_ERROR) && expect_type) 1309 return allocate_value (expect_type); 1310 else 1311 return allocate_value (type); 1312 } 1313 else 1314 error (_("Expression of type other than " 1315 "\"method returning ...\" used as a method")); 1316 } 1317 1318 /* Now depending on whether we found a symbol for the method, 1319 we will either call the runtime dispatcher or the method 1320 directly. */ 1321 1322 argvec[0] = called_method; 1323 argvec[1] = target; 1324 argvec[2] = value_from_longest (long_type, selector); 1325 /* User-supplied arguments. */ 1326 for (tem = 0; tem < nargs; tem++) 1327 argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside); 1328 argvec[tem + 3] = 0; 1329 1330 if (gnu_runtime && (method != NULL)) 1331 { 1332 /* Function objc_msg_lookup returns a pointer. */ 1333 deprecated_set_value_type (argvec[0], 1334 lookup_pointer_type (lookup_function_type (value_type (argvec[0])))); 1335 argvec[0] 1336 = call_function_by_hand (argvec[0], nargs + 2, argvec + 1); 1337 } 1338 1339 ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1); 1340 return ret; 1341 } 1342 break; 1343 1344 case OP_FUNCALL: 1345 (*pos) += 2; 1346 op = exp->elts[*pos].opcode; 1347 nargs = longest_to_int (exp->elts[pc + 1].longconst); 1348 /* Allocate arg vector, including space for the function to be 1349 called in argvec[0], a potential `this', and a terminating NULL. */ 1350 argvec = (struct value **) 1351 alloca (sizeof (struct value *) * (nargs + 3)); 1352 if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR) 1353 { 1354 /* First, evaluate the structure into arg2. */ 1355 pc2 = (*pos)++; 1356 1357 if (op == STRUCTOP_MEMBER) 1358 { 1359 arg2 = evaluate_subexp_for_address (exp, pos, noside); 1360 } 1361 else 1362 { 1363 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 1364 } 1365 1366 /* If the function is a virtual function, then the 1367 aggregate value (providing the structure) plays 1368 its part by providing the vtable. Otherwise, 1369 it is just along for the ride: call the function 1370 directly. */ 1371 1372 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 1373 1374 type = check_typedef (value_type (arg1)); 1375 if (noside == EVAL_SKIP) 1376 tem = 1; /* Set it to the right arg index so that all arguments 1377 can also be skipped. */ 1378 else if (TYPE_CODE (type) == TYPE_CODE_METHODPTR) 1379 { 1380 if (noside == EVAL_AVOID_SIDE_EFFECTS) 1381 arg1 = value_zero (TYPE_TARGET_TYPE (type), not_lval); 1382 else 1383 arg1 = cplus_method_ptr_to_value (&arg2, arg1); 1384 1385 /* Now, say which argument to start evaluating from. */ 1386 nargs++; 1387 tem = 2; 1388 argvec[1] = arg2; 1389 } 1390 else if (TYPE_CODE (type) == TYPE_CODE_MEMBERPTR) 1391 { 1392 struct type *type_ptr 1393 = lookup_pointer_type (TYPE_DOMAIN_TYPE (type)); 1394 struct type *target_type_ptr 1395 = lookup_pointer_type (TYPE_TARGET_TYPE (type)); 1396 1397 /* Now, convert these values to an address. */ 1398 arg2 = value_cast (type_ptr, arg2); 1399 1400 mem_offset = value_as_long (arg1); 1401 1402 arg1 = value_from_pointer (target_type_ptr, 1403 value_as_long (arg2) + mem_offset); 1404 arg1 = value_ind (arg1); 1405 tem = 1; 1406 } 1407 else 1408 error (_("Non-pointer-to-member value used in pointer-to-member " 1409 "construct")); 1410 } 1411 else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR) 1412 { 1413 /* Hair for method invocations. */ 1414 int tem2; 1415 1416 nargs++; 1417 /* First, evaluate the structure into arg2. */ 1418 pc2 = (*pos)++; 1419 tem2 = longest_to_int (exp->elts[pc2 + 1].longconst); 1420 *pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1); 1421 1422 if (op == STRUCTOP_STRUCT) 1423 { 1424 /* If v is a variable in a register, and the user types 1425 v.method (), this will produce an error, because v has 1426 no address. 1427 1428 A possible way around this would be to allocate a 1429 copy of the variable on the stack, copy in the 1430 contents, call the function, and copy out the 1431 contents. I.e. convert this from call by reference 1432 to call by copy-return (or whatever it's called). 1433 However, this does not work because it is not the 1434 same: the method being called could stash a copy of 1435 the address, and then future uses through that address 1436 (after the method returns) would be expected to 1437 use the variable itself, not some copy of it. */ 1438 arg2 = evaluate_subexp_for_address (exp, pos, noside); 1439 } 1440 else 1441 { 1442 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 1443 1444 /* Check to see if the operator '->' has been 1445 overloaded. If the operator has been overloaded 1446 replace arg2 with the value returned by the custom 1447 operator and continue evaluation. */ 1448 while (unop_user_defined_p (op, arg2)) 1449 { 1450 volatile struct gdb_exception except; 1451 struct value *value = NULL; 1452 TRY_CATCH (except, RETURN_MASK_ERROR) 1453 { 1454 value = value_x_unop (arg2, op, noside); 1455 } 1456 1457 if (except.reason < 0) 1458 { 1459 if (except.error == NOT_FOUND_ERROR) 1460 break; 1461 else 1462 throw_exception (except); 1463 } 1464 arg2 = value; 1465 } 1466 } 1467 /* Now, say which argument to start evaluating from. */ 1468 tem = 2; 1469 } 1470 else if (op == OP_SCOPE 1471 && overload_resolution 1472 && (exp->language_defn->la_language == language_cplus)) 1473 { 1474 /* Unpack it locally so we can properly handle overload 1475 resolution. */ 1476 char *name; 1477 int local_tem; 1478 1479 pc2 = (*pos)++; 1480 local_tem = longest_to_int (exp->elts[pc2 + 2].longconst); 1481 (*pos) += 4 + BYTES_TO_EXP_ELEM (local_tem + 1); 1482 type = exp->elts[pc2 + 1].type; 1483 name = &exp->elts[pc2 + 3].string; 1484 1485 function = NULL; 1486 function_name = NULL; 1487 if (TYPE_CODE (type) == TYPE_CODE_NAMESPACE) 1488 { 1489 function = cp_lookup_symbol_namespace (TYPE_TAG_NAME (type), 1490 name, 1491 get_selected_block (0), 1492 VAR_DOMAIN); 1493 if (function == NULL) 1494 error (_("No symbol \"%s\" in namespace \"%s\"."), 1495 name, TYPE_TAG_NAME (type)); 1496 1497 tem = 1; 1498 /* arg2 is left as NULL on purpose. */ 1499 } 1500 else 1501 { 1502 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT 1503 || TYPE_CODE (type) == TYPE_CODE_UNION); 1504 function_name = name; 1505 1506 /* We need a properly typed value for method lookup. For 1507 static methods arg2 is otherwise unused. */ 1508 arg2 = value_zero (type, lval_memory); 1509 ++nargs; 1510 tem = 2; 1511 } 1512 } 1513 else if (op == OP_ADL_FUNC) 1514 { 1515 /* Save the function position and move pos so that the arguments 1516 can be evaluated. */ 1517 int func_name_len; 1518 1519 save_pos1 = *pos; 1520 tem = 1; 1521 1522 func_name_len = longest_to_int (exp->elts[save_pos1 + 3].longconst); 1523 (*pos) += 6 + BYTES_TO_EXP_ELEM (func_name_len + 1); 1524 } 1525 else 1526 { 1527 /* Non-method function call. */ 1528 save_pos1 = *pos; 1529 tem = 1; 1530 1531 /* If this is a C++ function wait until overload resolution. */ 1532 if (op == OP_VAR_VALUE 1533 && overload_resolution 1534 && (exp->language_defn->la_language == language_cplus)) 1535 { 1536 (*pos) += 4; /* Skip the evaluation of the symbol. */ 1537 argvec[0] = NULL; 1538 } 1539 else 1540 { 1541 argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside); 1542 type = value_type (argvec[0]); 1543 if (type && TYPE_CODE (type) == TYPE_CODE_PTR) 1544 type = TYPE_TARGET_TYPE (type); 1545 if (type && TYPE_CODE (type) == TYPE_CODE_FUNC) 1546 { 1547 for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++) 1548 { 1549 argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type, 1550 tem - 1), 1551 exp, pos, noside); 1552 } 1553 } 1554 } 1555 } 1556 1557 /* Evaluate arguments (if not already done, e.g., namespace::func() 1558 and overload-resolution is off). */ 1559 for (; tem <= nargs; tem++) 1560 { 1561 /* Ensure that array expressions are coerced into pointer 1562 objects. */ 1563 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside); 1564 } 1565 1566 /* Signal end of arglist. */ 1567 argvec[tem] = 0; 1568 1569 if (noside == EVAL_SKIP) 1570 goto nosideret; 1571 1572 if (op == OP_ADL_FUNC) 1573 { 1574 struct symbol *symp; 1575 char *func_name; 1576 int name_len; 1577 int string_pc = save_pos1 + 3; 1578 1579 /* Extract the function name. */ 1580 name_len = longest_to_int (exp->elts[string_pc].longconst); 1581 func_name = (char *) alloca (name_len + 1); 1582 strcpy (func_name, &exp->elts[string_pc + 1].string); 1583 1584 find_overload_match (&argvec[1], nargs, func_name, 1585 NON_METHOD, /* not method */ 1586 NULL, NULL, /* pass NULL symbol since 1587 symbol is unknown */ 1588 NULL, &symp, NULL, 0, noside); 1589 1590 /* Now fix the expression being evaluated. */ 1591 exp->elts[save_pos1 + 2].symbol = symp; 1592 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside); 1593 } 1594 1595 if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR 1596 || (op == OP_SCOPE && function_name != NULL)) 1597 { 1598 int static_memfuncp; 1599 char *tstr; 1600 1601 /* Method invocation: stuff "this" as first parameter. 1602 If the method turns out to be static we undo this below. */ 1603 argvec[1] = arg2; 1604 1605 if (op != OP_SCOPE) 1606 { 1607 /* Name of method from expression. */ 1608 tstr = &exp->elts[pc2 + 2].string; 1609 } 1610 else 1611 tstr = function_name; 1612 1613 if (overload_resolution && (exp->language_defn->la_language 1614 == language_cplus)) 1615 { 1616 /* Language is C++, do some overload resolution before 1617 evaluation. */ 1618 struct value *valp = NULL; 1619 1620 (void) find_overload_match (&argvec[1], nargs, tstr, 1621 METHOD, /* method */ 1622 &arg2, /* the object */ 1623 NULL, &valp, NULL, 1624 &static_memfuncp, 0, noside); 1625 1626 if (op == OP_SCOPE && !static_memfuncp) 1627 { 1628 /* For the time being, we don't handle this. */ 1629 error (_("Call to overloaded function %s requires " 1630 "`this' pointer"), 1631 function_name); 1632 } 1633 argvec[1] = arg2; /* the ``this'' pointer */ 1634 argvec[0] = valp; /* Use the method found after overload 1635 resolution. */ 1636 } 1637 else 1638 /* Non-C++ case -- or no overload resolution. */ 1639 { 1640 struct value *temp = arg2; 1641 1642 argvec[0] = value_struct_elt (&temp, argvec + 1, tstr, 1643 &static_memfuncp, 1644 op == STRUCTOP_STRUCT 1645 ? "structure" : "structure pointer"); 1646 /* value_struct_elt updates temp with the correct value 1647 of the ``this'' pointer if necessary, so modify argvec[1] to 1648 reflect any ``this'' changes. */ 1649 arg2 1650 = value_from_longest (lookup_pointer_type(value_type (temp)), 1651 value_address (temp) 1652 + value_embedded_offset (temp)); 1653 argvec[1] = arg2; /* the ``this'' pointer */ 1654 } 1655 1656 /* Take out `this' if needed. */ 1657 if (static_memfuncp) 1658 { 1659 argvec[1] = argvec[0]; 1660 nargs--; 1661 argvec++; 1662 } 1663 } 1664 else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR) 1665 { 1666 /* Pointer to member. argvec[1] is already set up. */ 1667 argvec[0] = arg1; 1668 } 1669 else if (op == OP_VAR_VALUE || (op == OP_SCOPE && function != NULL)) 1670 { 1671 /* Non-member function being called. */ 1672 /* fn: This can only be done for C++ functions. A C-style function 1673 in a C++ program, for instance, does not have the fields that 1674 are expected here. */ 1675 1676 if (overload_resolution && (exp->language_defn->la_language 1677 == language_cplus)) 1678 { 1679 /* Language is C++, do some overload resolution before 1680 evaluation. */ 1681 struct symbol *symp; 1682 int no_adl = 0; 1683 1684 /* If a scope has been specified disable ADL. */ 1685 if (op == OP_SCOPE) 1686 no_adl = 1; 1687 1688 if (op == OP_VAR_VALUE) 1689 function = exp->elts[save_pos1+2].symbol; 1690 1691 (void) find_overload_match (&argvec[1], nargs, 1692 NULL, /* no need for name */ 1693 NON_METHOD, /* not method */ 1694 NULL, function, /* the function */ 1695 NULL, &symp, NULL, no_adl, noside); 1696 1697 if (op == OP_VAR_VALUE) 1698 { 1699 /* Now fix the expression being evaluated. */ 1700 exp->elts[save_pos1+2].symbol = symp; 1701 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, 1702 noside); 1703 } 1704 else 1705 argvec[0] = value_of_variable (symp, get_selected_block (0)); 1706 } 1707 else 1708 { 1709 /* Not C++, or no overload resolution allowed. */ 1710 /* Nothing to be done; argvec already correctly set up. */ 1711 } 1712 } 1713 else 1714 { 1715 /* It is probably a C-style function. */ 1716 /* Nothing to be done; argvec already correctly set up. */ 1717 } 1718 1719 do_call_it: 1720 1721 if (argvec[0] == NULL) 1722 error (_("Cannot evaluate function -- may be inlined")); 1723 if (noside == EVAL_AVOID_SIDE_EFFECTS) 1724 { 1725 /* If the return type doesn't look like a function type, call an 1726 error. This can happen if somebody tries to turn a variable into 1727 a function call. This is here because people often want to 1728 call, eg, strcmp, which gdb doesn't know is a function. If 1729 gdb isn't asked for it's opinion (ie. through "whatis"), 1730 it won't offer it. */ 1731 1732 struct type *ftype = value_type (argvec[0]); 1733 1734 if (TYPE_CODE (ftype) == TYPE_CODE_INTERNAL_FUNCTION) 1735 { 1736 /* We don't know anything about what the internal 1737 function might return, but we have to return 1738 something. */ 1739 return value_zero (builtin_type (exp->gdbarch)->builtin_int, 1740 not_lval); 1741 } 1742 else if (TYPE_CODE (ftype) == TYPE_CODE_XMETHOD) 1743 { 1744 struct type *return_type 1745 = result_type_of_xmethod (argvec[0], nargs, argvec + 1); 1746 1747 if (return_type == NULL) 1748 error (_("Xmethod is missing return type.")); 1749 return value_zero (return_type, not_lval); 1750 } 1751 else if (TYPE_GNU_IFUNC (ftype)) 1752 return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype))); 1753 else if (TYPE_TARGET_TYPE (ftype)) 1754 return allocate_value (TYPE_TARGET_TYPE (ftype)); 1755 else 1756 error (_("Expression of type other than " 1757 "\"Function returning ...\" used as function")); 1758 } 1759 switch (TYPE_CODE (value_type (argvec[0]))) 1760 { 1761 case TYPE_CODE_INTERNAL_FUNCTION: 1762 return call_internal_function (exp->gdbarch, exp->language_defn, 1763 argvec[0], nargs, argvec + 1); 1764 case TYPE_CODE_XMETHOD: 1765 return call_xmethod (argvec[0], nargs, argvec + 1); 1766 default: 1767 return call_function_by_hand (argvec[0], nargs, argvec + 1); 1768 } 1769 /* pai: FIXME save value from call_function_by_hand, then adjust 1770 pc by adjust_fn_pc if +ve. */ 1771 1772 case OP_F77_UNDETERMINED_ARGLIST: 1773 1774 /* Remember that in F77, functions, substring ops and 1775 array subscript operations cannot be disambiguated 1776 at parse time. We have made all array subscript operations, 1777 substring operations as well as function calls come here 1778 and we now have to discover what the heck this thing actually was. 1779 If it is a function, we process just as if we got an OP_FUNCALL. */ 1780 1781 nargs = longest_to_int (exp->elts[pc + 1].longconst); 1782 (*pos) += 2; 1783 1784 /* First determine the type code we are dealing with. */ 1785 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 1786 type = check_typedef (value_type (arg1)); 1787 code = TYPE_CODE (type); 1788 1789 if (code == TYPE_CODE_PTR) 1790 { 1791 /* Fortran always passes variable to subroutines as pointer. 1792 So we need to look into its target type to see if it is 1793 array, string or function. If it is, we need to switch 1794 to the target value the original one points to. */ 1795 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type)); 1796 1797 if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY 1798 || TYPE_CODE (target_type) == TYPE_CODE_STRING 1799 || TYPE_CODE (target_type) == TYPE_CODE_FUNC) 1800 { 1801 arg1 = value_ind (arg1); 1802 type = check_typedef (value_type (arg1)); 1803 code = TYPE_CODE (type); 1804 } 1805 } 1806 1807 switch (code) 1808 { 1809 case TYPE_CODE_ARRAY: 1810 if (exp->elts[*pos].opcode == OP_F90_RANGE) 1811 return value_f90_subarray (arg1, exp, pos, noside); 1812 else 1813 goto multi_f77_subscript; 1814 1815 case TYPE_CODE_STRING: 1816 if (exp->elts[*pos].opcode == OP_F90_RANGE) 1817 return value_f90_subarray (arg1, exp, pos, noside); 1818 else 1819 { 1820 arg2 = evaluate_subexp_with_coercion (exp, pos, noside); 1821 return value_subscript (arg1, value_as_long (arg2)); 1822 } 1823 1824 case TYPE_CODE_PTR: 1825 case TYPE_CODE_FUNC: 1826 /* It's a function call. */ 1827 /* Allocate arg vector, including space for the function to be 1828 called in argvec[0] and a terminating NULL. */ 1829 argvec = (struct value **) 1830 alloca (sizeof (struct value *) * (nargs + 2)); 1831 argvec[0] = arg1; 1832 tem = 1; 1833 for (; tem <= nargs; tem++) 1834 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside); 1835 argvec[tem] = 0; /* signal end of arglist */ 1836 if (noside == EVAL_SKIP) 1837 goto nosideret; 1838 goto do_call_it; 1839 1840 default: 1841 error (_("Cannot perform substring on this type")); 1842 } 1843 1844 case OP_COMPLEX: 1845 /* We have a complex number, There should be 2 floating 1846 point numbers that compose it. */ 1847 (*pos) += 2; 1848 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 1849 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 1850 1851 return value_literal_complex (arg1, arg2, exp->elts[pc + 1].type); 1852 1853 case STRUCTOP_STRUCT: 1854 tem = longest_to_int (exp->elts[pc + 1].longconst); 1855 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1); 1856 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 1857 if (noside == EVAL_SKIP) 1858 goto nosideret; 1859 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string, 1860 NULL, "structure"); 1861 if (noside == EVAL_AVOID_SIDE_EFFECTS) 1862 arg3 = value_zero (value_type (arg3), not_lval); 1863 return arg3; 1864 1865 case STRUCTOP_PTR: 1866 tem = longest_to_int (exp->elts[pc + 1].longconst); 1867 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1); 1868 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 1869 if (noside == EVAL_SKIP) 1870 goto nosideret; 1871 1872 /* Check to see if operator '->' has been overloaded. If so replace 1873 arg1 with the value returned by evaluating operator->(). */ 1874 while (unop_user_defined_p (op, arg1)) 1875 { 1876 volatile struct gdb_exception except; 1877 struct value *value = NULL; 1878 TRY_CATCH (except, RETURN_MASK_ERROR) 1879 { 1880 value = value_x_unop (arg1, op, noside); 1881 } 1882 1883 if (except.reason < 0) 1884 { 1885 if (except.error == NOT_FOUND_ERROR) 1886 break; 1887 else 1888 throw_exception (except); 1889 } 1890 arg1 = value; 1891 } 1892 1893 /* JYG: if print object is on we need to replace the base type 1894 with rtti type in order to continue on with successful 1895 lookup of member / method only available in the rtti type. */ 1896 { 1897 struct type *type = value_type (arg1); 1898 struct type *real_type; 1899 int full, top, using_enc; 1900 struct value_print_options opts; 1901 1902 get_user_print_options (&opts); 1903 if (opts.objectprint && TYPE_TARGET_TYPE(type) 1904 && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT)) 1905 { 1906 real_type = value_rtti_indirect_type (arg1, &full, &top, 1907 &using_enc); 1908 if (real_type) 1909 arg1 = value_cast (real_type, arg1); 1910 } 1911 } 1912 1913 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string, 1914 NULL, "structure pointer"); 1915 if (noside == EVAL_AVOID_SIDE_EFFECTS) 1916 arg3 = value_zero (value_type (arg3), not_lval); 1917 return arg3; 1918 1919 case STRUCTOP_MEMBER: 1920 case STRUCTOP_MPTR: 1921 if (op == STRUCTOP_MEMBER) 1922 arg1 = evaluate_subexp_for_address (exp, pos, noside); 1923 else 1924 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 1925 1926 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 1927 1928 if (noside == EVAL_SKIP) 1929 goto nosideret; 1930 1931 type = check_typedef (value_type (arg2)); 1932 switch (TYPE_CODE (type)) 1933 { 1934 case TYPE_CODE_METHODPTR: 1935 if (noside == EVAL_AVOID_SIDE_EFFECTS) 1936 return value_zero (TYPE_TARGET_TYPE (type), not_lval); 1937 else 1938 { 1939 arg2 = cplus_method_ptr_to_value (&arg1, arg2); 1940 gdb_assert (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR); 1941 return value_ind (arg2); 1942 } 1943 1944 case TYPE_CODE_MEMBERPTR: 1945 /* Now, convert these values to an address. */ 1946 arg1 = value_cast_pointers (lookup_pointer_type (TYPE_DOMAIN_TYPE (type)), 1947 arg1, 1); 1948 1949 mem_offset = value_as_long (arg2); 1950 1951 arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)), 1952 value_as_long (arg1) + mem_offset); 1953 return value_ind (arg3); 1954 1955 default: 1956 error (_("non-pointer-to-member value used " 1957 "in pointer-to-member construct")); 1958 } 1959 1960 case TYPE_INSTANCE: 1961 nargs = longest_to_int (exp->elts[pc + 1].longconst); 1962 arg_types = (struct type **) alloca (nargs * sizeof (struct type *)); 1963 for (ix = 0; ix < nargs; ++ix) 1964 arg_types[ix] = exp->elts[pc + 1 + ix + 1].type; 1965 1966 expect_type = make_params (nargs, arg_types); 1967 *(pos) += 3 + nargs; 1968 arg1 = evaluate_subexp_standard (expect_type, exp, pos, noside); 1969 xfree (TYPE_FIELDS (expect_type)); 1970 xfree (TYPE_MAIN_TYPE (expect_type)); 1971 xfree (expect_type); 1972 return arg1; 1973 1974 case BINOP_CONCAT: 1975 arg1 = evaluate_subexp_with_coercion (exp, pos, noside); 1976 arg2 = evaluate_subexp_with_coercion (exp, pos, noside); 1977 if (noside == EVAL_SKIP) 1978 goto nosideret; 1979 if (binop_user_defined_p (op, arg1, arg2)) 1980 return value_x_binop (arg1, arg2, op, OP_NULL, noside); 1981 else 1982 return value_concat (arg1, arg2); 1983 1984 case BINOP_ASSIGN: 1985 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 1986 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside); 1987 1988 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS) 1989 return arg1; 1990 if (binop_user_defined_p (op, arg1, arg2)) 1991 return value_x_binop (arg1, arg2, op, OP_NULL, noside); 1992 else 1993 return value_assign (arg1, arg2); 1994 1995 case BINOP_ASSIGN_MODIFY: 1996 (*pos) += 2; 1997 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 1998 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside); 1999 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS) 2000 return arg1; 2001 op = exp->elts[pc + 1].opcode; 2002 if (binop_user_defined_p (op, arg1, arg2)) 2003 return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside); 2004 else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn, 2005 value_type (arg1)) 2006 && is_integral_type (value_type (arg2))) 2007 arg2 = value_ptradd (arg1, value_as_long (arg2)); 2008 else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn, 2009 value_type (arg1)) 2010 && is_integral_type (value_type (arg2))) 2011 arg2 = value_ptradd (arg1, - value_as_long (arg2)); 2012 else 2013 { 2014 struct value *tmp = arg1; 2015 2016 /* For shift and integer exponentiation operations, 2017 only promote the first argument. */ 2018 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP) 2019 && is_integral_type (value_type (arg2))) 2020 unop_promote (exp->language_defn, exp->gdbarch, &tmp); 2021 else 2022 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2); 2023 2024 arg2 = value_binop (tmp, arg2, op); 2025 } 2026 return value_assign (arg1, arg2); 2027 2028 case BINOP_ADD: 2029 arg1 = evaluate_subexp_with_coercion (exp, pos, noside); 2030 arg2 = evaluate_subexp_with_coercion (exp, pos, noside); 2031 if (noside == EVAL_SKIP) 2032 goto nosideret; 2033 if (binop_user_defined_p (op, arg1, arg2)) 2034 return value_x_binop (arg1, arg2, op, OP_NULL, noside); 2035 else if (ptrmath_type_p (exp->language_defn, value_type (arg1)) 2036 && is_integral_type (value_type (arg2))) 2037 return value_ptradd (arg1, value_as_long (arg2)); 2038 else if (ptrmath_type_p (exp->language_defn, value_type (arg2)) 2039 && is_integral_type (value_type (arg1))) 2040 return value_ptradd (arg2, value_as_long (arg1)); 2041 else 2042 { 2043 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); 2044 return value_binop (arg1, arg2, BINOP_ADD); 2045 } 2046 2047 case BINOP_SUB: 2048 arg1 = evaluate_subexp_with_coercion (exp, pos, noside); 2049 arg2 = evaluate_subexp_with_coercion (exp, pos, noside); 2050 if (noside == EVAL_SKIP) 2051 goto nosideret; 2052 if (binop_user_defined_p (op, arg1, arg2)) 2053 return value_x_binop (arg1, arg2, op, OP_NULL, noside); 2054 else if (ptrmath_type_p (exp->language_defn, value_type (arg1)) 2055 && ptrmath_type_p (exp->language_defn, value_type (arg2))) 2056 { 2057 /* FIXME -- should be ptrdiff_t */ 2058 type = builtin_type (exp->gdbarch)->builtin_long; 2059 return value_from_longest (type, value_ptrdiff (arg1, arg2)); 2060 } 2061 else if (ptrmath_type_p (exp->language_defn, value_type (arg1)) 2062 && is_integral_type (value_type (arg2))) 2063 return value_ptradd (arg1, - value_as_long (arg2)); 2064 else 2065 { 2066 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); 2067 return value_binop (arg1, arg2, BINOP_SUB); 2068 } 2069 2070 case BINOP_EXP: 2071 case BINOP_MUL: 2072 case BINOP_DIV: 2073 case BINOP_INTDIV: 2074 case BINOP_REM: 2075 case BINOP_MOD: 2076 case BINOP_LSH: 2077 case BINOP_RSH: 2078 case BINOP_BITWISE_AND: 2079 case BINOP_BITWISE_IOR: 2080 case BINOP_BITWISE_XOR: 2081 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2082 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2083 if (noside == EVAL_SKIP) 2084 goto nosideret; 2085 if (binop_user_defined_p (op, arg1, arg2)) 2086 return value_x_binop (arg1, arg2, op, OP_NULL, noside); 2087 else 2088 { 2089 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero, 2090 fudge arg2 to avoid division-by-zero, the caller is 2091 (theoretically) only looking for the type of the result. */ 2092 if (noside == EVAL_AVOID_SIDE_EFFECTS 2093 /* ??? Do we really want to test for BINOP_MOD here? 2094 The implementation of value_binop gives it a well-defined 2095 value. */ 2096 && (op == BINOP_DIV 2097 || op == BINOP_INTDIV 2098 || op == BINOP_REM 2099 || op == BINOP_MOD) 2100 && value_logical_not (arg2)) 2101 { 2102 struct value *v_one, *retval; 2103 2104 v_one = value_one (value_type (arg2)); 2105 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one); 2106 retval = value_binop (arg1, v_one, op); 2107 return retval; 2108 } 2109 else 2110 { 2111 /* For shift and integer exponentiation operations, 2112 only promote the first argument. */ 2113 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP) 2114 && is_integral_type (value_type (arg2))) 2115 unop_promote (exp->language_defn, exp->gdbarch, &arg1); 2116 else 2117 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); 2118 2119 return value_binop (arg1, arg2, op); 2120 } 2121 } 2122 2123 case BINOP_SUBSCRIPT: 2124 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2125 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2126 if (noside == EVAL_SKIP) 2127 goto nosideret; 2128 if (binop_user_defined_p (op, arg1, arg2)) 2129 return value_x_binop (arg1, arg2, op, OP_NULL, noside); 2130 else 2131 { 2132 /* If the user attempts to subscript something that is not an 2133 array or pointer type (like a plain int variable for example), 2134 then report this as an error. */ 2135 2136 arg1 = coerce_ref (arg1); 2137 type = check_typedef (value_type (arg1)); 2138 if (TYPE_CODE (type) != TYPE_CODE_ARRAY 2139 && TYPE_CODE (type) != TYPE_CODE_PTR) 2140 { 2141 if (TYPE_NAME (type)) 2142 error (_("cannot subscript something of type `%s'"), 2143 TYPE_NAME (type)); 2144 else 2145 error (_("cannot subscript requested type")); 2146 } 2147 2148 if (noside == EVAL_AVOID_SIDE_EFFECTS) 2149 return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1)); 2150 else 2151 return value_subscript (arg1, value_as_long (arg2)); 2152 } 2153 case MULTI_SUBSCRIPT: 2154 (*pos) += 2; 2155 nargs = longest_to_int (exp->elts[pc + 1].longconst); 2156 arg1 = evaluate_subexp_with_coercion (exp, pos, noside); 2157 while (nargs-- > 0) 2158 { 2159 arg2 = evaluate_subexp_with_coercion (exp, pos, noside); 2160 /* FIXME: EVAL_SKIP handling may not be correct. */ 2161 if (noside == EVAL_SKIP) 2162 { 2163 if (nargs > 0) 2164 { 2165 continue; 2166 } 2167 else 2168 { 2169 goto nosideret; 2170 } 2171 } 2172 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */ 2173 if (noside == EVAL_AVOID_SIDE_EFFECTS) 2174 { 2175 /* If the user attempts to subscript something that has no target 2176 type (like a plain int variable for example), then report this 2177 as an error. */ 2178 2179 type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1))); 2180 if (type != NULL) 2181 { 2182 arg1 = value_zero (type, VALUE_LVAL (arg1)); 2183 noside = EVAL_SKIP; 2184 continue; 2185 } 2186 else 2187 { 2188 error (_("cannot subscript something of type `%s'"), 2189 TYPE_NAME (value_type (arg1))); 2190 } 2191 } 2192 2193 if (binop_user_defined_p (op, arg1, arg2)) 2194 { 2195 arg1 = value_x_binop (arg1, arg2, op, OP_NULL, noside); 2196 } 2197 else 2198 { 2199 arg1 = coerce_ref (arg1); 2200 type = check_typedef (value_type (arg1)); 2201 2202 switch (TYPE_CODE (type)) 2203 { 2204 case TYPE_CODE_PTR: 2205 case TYPE_CODE_ARRAY: 2206 case TYPE_CODE_STRING: 2207 arg1 = value_subscript (arg1, value_as_long (arg2)); 2208 break; 2209 2210 default: 2211 if (TYPE_NAME (type)) 2212 error (_("cannot subscript something of type `%s'"), 2213 TYPE_NAME (type)); 2214 else 2215 error (_("cannot subscript requested type")); 2216 } 2217 } 2218 } 2219 return (arg1); 2220 2221 multi_f77_subscript: 2222 { 2223 LONGEST subscript_array[MAX_FORTRAN_DIMS]; 2224 int ndimensions = 1, i; 2225 struct value *array = arg1; 2226 2227 if (nargs > MAX_FORTRAN_DIMS) 2228 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS); 2229 2230 ndimensions = calc_f77_array_dims (type); 2231 2232 if (nargs != ndimensions) 2233 error (_("Wrong number of subscripts")); 2234 2235 gdb_assert (nargs > 0); 2236 2237 /* Now that we know we have a legal array subscript expression 2238 let us actually find out where this element exists in the array. */ 2239 2240 /* Take array indices left to right. */ 2241 for (i = 0; i < nargs; i++) 2242 { 2243 /* Evaluate each subscript; it must be a legal integer in F77. */ 2244 arg2 = evaluate_subexp_with_coercion (exp, pos, noside); 2245 2246 /* Fill in the subscript array. */ 2247 2248 subscript_array[i] = value_as_long (arg2); 2249 } 2250 2251 /* Internal type of array is arranged right to left. */ 2252 for (i = nargs; i > 0; i--) 2253 { 2254 struct type *array_type = check_typedef (value_type (array)); 2255 LONGEST index = subscript_array[i - 1]; 2256 2257 array = value_subscripted_rvalue (array, index, 2258 f77_get_lowerbound (array_type)); 2259 } 2260 2261 return array; 2262 } 2263 2264 case BINOP_LOGICAL_AND: 2265 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2266 if (noside == EVAL_SKIP) 2267 { 2268 evaluate_subexp (NULL_TYPE, exp, pos, noside); 2269 goto nosideret; 2270 } 2271 2272 oldpos = *pos; 2273 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS); 2274 *pos = oldpos; 2275 2276 if (binop_user_defined_p (op, arg1, arg2)) 2277 { 2278 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2279 return value_x_binop (arg1, arg2, op, OP_NULL, noside); 2280 } 2281 else 2282 { 2283 tem = value_logical_not (arg1); 2284 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, 2285 (tem ? EVAL_SKIP : noside)); 2286 type = language_bool_type (exp->language_defn, exp->gdbarch); 2287 return value_from_longest (type, 2288 (LONGEST) (!tem && !value_logical_not (arg2))); 2289 } 2290 2291 case BINOP_LOGICAL_OR: 2292 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2293 if (noside == EVAL_SKIP) 2294 { 2295 evaluate_subexp (NULL_TYPE, exp, pos, noside); 2296 goto nosideret; 2297 } 2298 2299 oldpos = *pos; 2300 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS); 2301 *pos = oldpos; 2302 2303 if (binop_user_defined_p (op, arg1, arg2)) 2304 { 2305 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2306 return value_x_binop (arg1, arg2, op, OP_NULL, noside); 2307 } 2308 else 2309 { 2310 tem = value_logical_not (arg1); 2311 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, 2312 (!tem ? EVAL_SKIP : noside)); 2313 type = language_bool_type (exp->language_defn, exp->gdbarch); 2314 return value_from_longest (type, 2315 (LONGEST) (!tem || !value_logical_not (arg2))); 2316 } 2317 2318 case BINOP_EQUAL: 2319 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2320 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside); 2321 if (noside == EVAL_SKIP) 2322 goto nosideret; 2323 if (binop_user_defined_p (op, arg1, arg2)) 2324 { 2325 return value_x_binop (arg1, arg2, op, OP_NULL, noside); 2326 } 2327 else 2328 { 2329 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); 2330 tem = value_equal (arg1, arg2); 2331 type = language_bool_type (exp->language_defn, exp->gdbarch); 2332 return value_from_longest (type, (LONGEST) tem); 2333 } 2334 2335 case BINOP_NOTEQUAL: 2336 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2337 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside); 2338 if (noside == EVAL_SKIP) 2339 goto nosideret; 2340 if (binop_user_defined_p (op, arg1, arg2)) 2341 { 2342 return value_x_binop (arg1, arg2, op, OP_NULL, noside); 2343 } 2344 else 2345 { 2346 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); 2347 tem = value_equal (arg1, arg2); 2348 type = language_bool_type (exp->language_defn, exp->gdbarch); 2349 return value_from_longest (type, (LONGEST) ! tem); 2350 } 2351 2352 case BINOP_LESS: 2353 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2354 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside); 2355 if (noside == EVAL_SKIP) 2356 goto nosideret; 2357 if (binop_user_defined_p (op, arg1, arg2)) 2358 { 2359 return value_x_binop (arg1, arg2, op, OP_NULL, noside); 2360 } 2361 else 2362 { 2363 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); 2364 tem = value_less (arg1, arg2); 2365 type = language_bool_type (exp->language_defn, exp->gdbarch); 2366 return value_from_longest (type, (LONGEST) tem); 2367 } 2368 2369 case BINOP_GTR: 2370 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2371 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside); 2372 if (noside == EVAL_SKIP) 2373 goto nosideret; 2374 if (binop_user_defined_p (op, arg1, arg2)) 2375 { 2376 return value_x_binop (arg1, arg2, op, OP_NULL, noside); 2377 } 2378 else 2379 { 2380 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); 2381 tem = value_less (arg2, arg1); 2382 type = language_bool_type (exp->language_defn, exp->gdbarch); 2383 return value_from_longest (type, (LONGEST) tem); 2384 } 2385 2386 case BINOP_GEQ: 2387 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2388 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside); 2389 if (noside == EVAL_SKIP) 2390 goto nosideret; 2391 if (binop_user_defined_p (op, arg1, arg2)) 2392 { 2393 return value_x_binop (arg1, arg2, op, OP_NULL, noside); 2394 } 2395 else 2396 { 2397 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); 2398 tem = value_less (arg2, arg1) || value_equal (arg1, arg2); 2399 type = language_bool_type (exp->language_defn, exp->gdbarch); 2400 return value_from_longest (type, (LONGEST) tem); 2401 } 2402 2403 case BINOP_LEQ: 2404 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2405 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside); 2406 if (noside == EVAL_SKIP) 2407 goto nosideret; 2408 if (binop_user_defined_p (op, arg1, arg2)) 2409 { 2410 return value_x_binop (arg1, arg2, op, OP_NULL, noside); 2411 } 2412 else 2413 { 2414 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); 2415 tem = value_less (arg1, arg2) || value_equal (arg1, arg2); 2416 type = language_bool_type (exp->language_defn, exp->gdbarch); 2417 return value_from_longest (type, (LONGEST) tem); 2418 } 2419 2420 case BINOP_REPEAT: 2421 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2422 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2423 if (noside == EVAL_SKIP) 2424 goto nosideret; 2425 type = check_typedef (value_type (arg2)); 2426 if (TYPE_CODE (type) != TYPE_CODE_INT) 2427 error (_("Non-integral right operand for \"@\" operator.")); 2428 if (noside == EVAL_AVOID_SIDE_EFFECTS) 2429 { 2430 return allocate_repeat_value (value_type (arg1), 2431 longest_to_int (value_as_long (arg2))); 2432 } 2433 else 2434 return value_repeat (arg1, longest_to_int (value_as_long (arg2))); 2435 2436 case BINOP_COMMA: 2437 evaluate_subexp (NULL_TYPE, exp, pos, noside); 2438 return evaluate_subexp (NULL_TYPE, exp, pos, noside); 2439 2440 case UNOP_PLUS: 2441 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2442 if (noside == EVAL_SKIP) 2443 goto nosideret; 2444 if (unop_user_defined_p (op, arg1)) 2445 return value_x_unop (arg1, op, noside); 2446 else 2447 { 2448 unop_promote (exp->language_defn, exp->gdbarch, &arg1); 2449 return value_pos (arg1); 2450 } 2451 2452 case UNOP_NEG: 2453 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2454 if (noside == EVAL_SKIP) 2455 goto nosideret; 2456 if (unop_user_defined_p (op, arg1)) 2457 return value_x_unop (arg1, op, noside); 2458 else 2459 { 2460 unop_promote (exp->language_defn, exp->gdbarch, &arg1); 2461 return value_neg (arg1); 2462 } 2463 2464 case UNOP_COMPLEMENT: 2465 /* C++: check for and handle destructor names. */ 2466 op = exp->elts[*pos].opcode; 2467 2468 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2469 if (noside == EVAL_SKIP) 2470 goto nosideret; 2471 if (unop_user_defined_p (UNOP_COMPLEMENT, arg1)) 2472 return value_x_unop (arg1, UNOP_COMPLEMENT, noside); 2473 else 2474 { 2475 unop_promote (exp->language_defn, exp->gdbarch, &arg1); 2476 return value_complement (arg1); 2477 } 2478 2479 case UNOP_LOGICAL_NOT: 2480 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2481 if (noside == EVAL_SKIP) 2482 goto nosideret; 2483 if (unop_user_defined_p (op, arg1)) 2484 return value_x_unop (arg1, op, noside); 2485 else 2486 { 2487 type = language_bool_type (exp->language_defn, exp->gdbarch); 2488 return value_from_longest (type, (LONGEST) value_logical_not (arg1)); 2489 } 2490 2491 case UNOP_IND: 2492 if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR) 2493 expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type)); 2494 arg1 = evaluate_subexp (expect_type, exp, pos, noside); 2495 type = check_typedef (value_type (arg1)); 2496 if (TYPE_CODE (type) == TYPE_CODE_METHODPTR 2497 || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR) 2498 error (_("Attempt to dereference pointer " 2499 "to member without an object")); 2500 if (noside == EVAL_SKIP) 2501 goto nosideret; 2502 if (unop_user_defined_p (op, arg1)) 2503 return value_x_unop (arg1, op, noside); 2504 else if (noside == EVAL_AVOID_SIDE_EFFECTS) 2505 { 2506 type = check_typedef (value_type (arg1)); 2507 if (TYPE_CODE (type) == TYPE_CODE_PTR 2508 || TYPE_CODE (type) == TYPE_CODE_REF 2509 /* In C you can dereference an array to get the 1st elt. */ 2510 || TYPE_CODE (type) == TYPE_CODE_ARRAY 2511 ) 2512 return value_zero (TYPE_TARGET_TYPE (type), 2513 lval_memory); 2514 else if (TYPE_CODE (type) == TYPE_CODE_INT) 2515 /* GDB allows dereferencing an int. */ 2516 return value_zero (builtin_type (exp->gdbarch)->builtin_int, 2517 lval_memory); 2518 else 2519 error (_("Attempt to take contents of a non-pointer value.")); 2520 } 2521 2522 /* Allow * on an integer so we can cast it to whatever we want. 2523 This returns an int, which seems like the most C-like thing to 2524 do. "long long" variables are rare enough that 2525 BUILTIN_TYPE_LONGEST would seem to be a mistake. */ 2526 if (TYPE_CODE (type) == TYPE_CODE_INT) 2527 return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int, 2528 (CORE_ADDR) value_as_address (arg1)); 2529 return value_ind (arg1); 2530 2531 case UNOP_ADDR: 2532 /* C++: check for and handle pointer to members. */ 2533 2534 op = exp->elts[*pos].opcode; 2535 2536 if (noside == EVAL_SKIP) 2537 { 2538 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP); 2539 goto nosideret; 2540 } 2541 else 2542 { 2543 struct value *retvalp = evaluate_subexp_for_address (exp, pos, 2544 noside); 2545 2546 return retvalp; 2547 } 2548 2549 case UNOP_SIZEOF: 2550 if (noside == EVAL_SKIP) 2551 { 2552 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP); 2553 goto nosideret; 2554 } 2555 return evaluate_subexp_for_sizeof (exp, pos, noside); 2556 2557 case UNOP_CAST: 2558 (*pos) += 2; 2559 type = exp->elts[pc + 1].type; 2560 arg1 = evaluate_subexp (type, exp, pos, noside); 2561 if (noside == EVAL_SKIP) 2562 goto nosideret; 2563 if (type != value_type (arg1)) 2564 arg1 = value_cast (type, arg1); 2565 return arg1; 2566 2567 case UNOP_CAST_TYPE: 2568 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS); 2569 type = value_type (arg1); 2570 arg1 = evaluate_subexp (type, exp, pos, noside); 2571 if (noside == EVAL_SKIP) 2572 goto nosideret; 2573 if (type != value_type (arg1)) 2574 arg1 = value_cast (type, arg1); 2575 return arg1; 2576 2577 case UNOP_DYNAMIC_CAST: 2578 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS); 2579 type = value_type (arg1); 2580 arg1 = evaluate_subexp (type, exp, pos, noside); 2581 if (noside == EVAL_SKIP) 2582 goto nosideret; 2583 return value_dynamic_cast (type, arg1); 2584 2585 case UNOP_REINTERPRET_CAST: 2586 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS); 2587 type = value_type (arg1); 2588 arg1 = evaluate_subexp (type, exp, pos, noside); 2589 if (noside == EVAL_SKIP) 2590 goto nosideret; 2591 return value_reinterpret_cast (type, arg1); 2592 2593 case UNOP_MEMVAL: 2594 (*pos) += 2; 2595 arg1 = evaluate_subexp (expect_type, exp, pos, noside); 2596 if (noside == EVAL_SKIP) 2597 goto nosideret; 2598 if (noside == EVAL_AVOID_SIDE_EFFECTS) 2599 return value_zero (exp->elts[pc + 1].type, lval_memory); 2600 else 2601 return value_at_lazy (exp->elts[pc + 1].type, 2602 value_as_address (arg1)); 2603 2604 case UNOP_MEMVAL_TYPE: 2605 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS); 2606 type = value_type (arg1); 2607 arg1 = evaluate_subexp (expect_type, exp, pos, noside); 2608 if (noside == EVAL_SKIP) 2609 goto nosideret; 2610 if (noside == EVAL_AVOID_SIDE_EFFECTS) 2611 return value_zero (type, lval_memory); 2612 else 2613 return value_at_lazy (type, value_as_address (arg1)); 2614 2615 case UNOP_MEMVAL_TLS: 2616 (*pos) += 3; 2617 arg1 = evaluate_subexp (expect_type, exp, pos, noside); 2618 if (noside == EVAL_SKIP) 2619 goto nosideret; 2620 if (noside == EVAL_AVOID_SIDE_EFFECTS) 2621 return value_zero (exp->elts[pc + 2].type, lval_memory); 2622 else 2623 { 2624 CORE_ADDR tls_addr; 2625 2626 tls_addr = target_translate_tls_address (exp->elts[pc + 1].objfile, 2627 value_as_address (arg1)); 2628 return value_at_lazy (exp->elts[pc + 2].type, tls_addr); 2629 } 2630 2631 case UNOP_PREINCREMENT: 2632 arg1 = evaluate_subexp (expect_type, exp, pos, noside); 2633 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS) 2634 return arg1; 2635 else if (unop_user_defined_p (op, arg1)) 2636 { 2637 return value_x_unop (arg1, op, noside); 2638 } 2639 else 2640 { 2641 if (ptrmath_type_p (exp->language_defn, value_type (arg1))) 2642 arg2 = value_ptradd (arg1, 1); 2643 else 2644 { 2645 struct value *tmp = arg1; 2646 2647 arg2 = value_one (value_type (arg1)); 2648 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2); 2649 arg2 = value_binop (tmp, arg2, BINOP_ADD); 2650 } 2651 2652 return value_assign (arg1, arg2); 2653 } 2654 2655 case UNOP_PREDECREMENT: 2656 arg1 = evaluate_subexp (expect_type, exp, pos, noside); 2657 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS) 2658 return arg1; 2659 else if (unop_user_defined_p (op, arg1)) 2660 { 2661 return value_x_unop (arg1, op, noside); 2662 } 2663 else 2664 { 2665 if (ptrmath_type_p (exp->language_defn, value_type (arg1))) 2666 arg2 = value_ptradd (arg1, -1); 2667 else 2668 { 2669 struct value *tmp = arg1; 2670 2671 arg2 = value_one (value_type (arg1)); 2672 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2); 2673 arg2 = value_binop (tmp, arg2, BINOP_SUB); 2674 } 2675 2676 return value_assign (arg1, arg2); 2677 } 2678 2679 case UNOP_POSTINCREMENT: 2680 arg1 = evaluate_subexp (expect_type, exp, pos, noside); 2681 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS) 2682 return arg1; 2683 else if (unop_user_defined_p (op, arg1)) 2684 { 2685 return value_x_unop (arg1, op, noside); 2686 } 2687 else 2688 { 2689 arg3 = value_non_lval (arg1); 2690 2691 if (ptrmath_type_p (exp->language_defn, value_type (arg1))) 2692 arg2 = value_ptradd (arg1, 1); 2693 else 2694 { 2695 struct value *tmp = arg1; 2696 2697 arg2 = value_one (value_type (arg1)); 2698 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2); 2699 arg2 = value_binop (tmp, arg2, BINOP_ADD); 2700 } 2701 2702 value_assign (arg1, arg2); 2703 return arg3; 2704 } 2705 2706 case UNOP_POSTDECREMENT: 2707 arg1 = evaluate_subexp (expect_type, exp, pos, noside); 2708 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS) 2709 return arg1; 2710 else if (unop_user_defined_p (op, arg1)) 2711 { 2712 return value_x_unop (arg1, op, noside); 2713 } 2714 else 2715 { 2716 arg3 = value_non_lval (arg1); 2717 2718 if (ptrmath_type_p (exp->language_defn, value_type (arg1))) 2719 arg2 = value_ptradd (arg1, -1); 2720 else 2721 { 2722 struct value *tmp = arg1; 2723 2724 arg2 = value_one (value_type (arg1)); 2725 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2); 2726 arg2 = value_binop (tmp, arg2, BINOP_SUB); 2727 } 2728 2729 value_assign (arg1, arg2); 2730 return arg3; 2731 } 2732 2733 case OP_THIS: 2734 (*pos) += 1; 2735 return value_of_this (exp->language_defn); 2736 2737 case OP_TYPE: 2738 /* The value is not supposed to be used. This is here to make it 2739 easier to accommodate expressions that contain types. */ 2740 (*pos) += 2; 2741 if (noside == EVAL_SKIP) 2742 goto nosideret; 2743 else if (noside == EVAL_AVOID_SIDE_EFFECTS) 2744 { 2745 struct type *type = exp->elts[pc + 1].type; 2746 2747 /* If this is a typedef, then find its immediate target. We 2748 use check_typedef to resolve stubs, but we ignore its 2749 result because we do not want to dig past all 2750 typedefs. */ 2751 check_typedef (type); 2752 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) 2753 type = TYPE_TARGET_TYPE (type); 2754 return allocate_value (type); 2755 } 2756 else 2757 error (_("Attempt to use a type name as an expression")); 2758 2759 case OP_TYPEOF: 2760 case OP_DECLTYPE: 2761 if (noside == EVAL_SKIP) 2762 { 2763 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP); 2764 goto nosideret; 2765 } 2766 else if (noside == EVAL_AVOID_SIDE_EFFECTS) 2767 { 2768 enum exp_opcode sub_op = exp->elts[*pos].opcode; 2769 struct value *result; 2770 2771 result = evaluate_subexp (NULL_TYPE, exp, pos, 2772 EVAL_AVOID_SIDE_EFFECTS); 2773 2774 /* 'decltype' has special semantics for lvalues. */ 2775 if (op == OP_DECLTYPE 2776 && (sub_op == BINOP_SUBSCRIPT 2777 || sub_op == STRUCTOP_MEMBER 2778 || sub_op == STRUCTOP_MPTR 2779 || sub_op == UNOP_IND 2780 || sub_op == STRUCTOP_STRUCT 2781 || sub_op == STRUCTOP_PTR 2782 || sub_op == OP_SCOPE)) 2783 { 2784 struct type *type = value_type (result); 2785 2786 if (TYPE_CODE (check_typedef (type)) != TYPE_CODE_REF) 2787 { 2788 type = lookup_reference_type (type); 2789 result = allocate_value (type); 2790 } 2791 } 2792 2793 return result; 2794 } 2795 else 2796 error (_("Attempt to use a type as an expression")); 2797 2798 case OP_TYPEID: 2799 { 2800 struct value *result; 2801 enum exp_opcode sub_op = exp->elts[*pos].opcode; 2802 2803 if (sub_op == OP_TYPE || sub_op == OP_DECLTYPE || sub_op == OP_TYPEOF) 2804 result = evaluate_subexp (NULL_TYPE, exp, pos, 2805 EVAL_AVOID_SIDE_EFFECTS); 2806 else 2807 result = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2808 2809 if (noside != EVAL_NORMAL) 2810 return allocate_value (cplus_typeid_type (exp->gdbarch)); 2811 2812 return cplus_typeid (result); 2813 } 2814 2815 default: 2816 /* Removing this case and compiling with gcc -Wall reveals that 2817 a lot of cases are hitting this case. Some of these should 2818 probably be removed from expression.h; others are legitimate 2819 expressions which are (apparently) not fully implemented. 2820 2821 If there are any cases landing here which mean a user error, 2822 then they should be separate cases, with more descriptive 2823 error messages. */ 2824 2825 error (_("GDB does not (yet) know how to " 2826 "evaluate that kind of expression")); 2827 } 2828 2829 nosideret: 2830 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1); 2831 } 2832 2833 /* Evaluate a subexpression of EXP, at index *POS, 2834 and return the address of that subexpression. 2835 Advance *POS over the subexpression. 2836 If the subexpression isn't an lvalue, get an error. 2837 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS; 2838 then only the type of the result need be correct. */ 2839 2840 static struct value * 2841 evaluate_subexp_for_address (struct expression *exp, int *pos, 2842 enum noside noside) 2843 { 2844 enum exp_opcode op; 2845 int pc; 2846 struct symbol *var; 2847 struct value *x; 2848 int tem; 2849 2850 pc = (*pos); 2851 op = exp->elts[pc].opcode; 2852 2853 switch (op) 2854 { 2855 case UNOP_IND: 2856 (*pos)++; 2857 x = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2858 2859 /* We can't optimize out "&*" if there's a user-defined operator*. */ 2860 if (unop_user_defined_p (op, x)) 2861 { 2862 x = value_x_unop (x, op, noside); 2863 goto default_case_after_eval; 2864 } 2865 2866 return coerce_array (x); 2867 2868 case UNOP_MEMVAL: 2869 (*pos) += 3; 2870 return value_cast (lookup_pointer_type (exp->elts[pc + 1].type), 2871 evaluate_subexp (NULL_TYPE, exp, pos, noside)); 2872 2873 case UNOP_MEMVAL_TYPE: 2874 { 2875 struct type *type; 2876 2877 (*pos) += 1; 2878 x = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS); 2879 type = value_type (x); 2880 return value_cast (lookup_pointer_type (type), 2881 evaluate_subexp (NULL_TYPE, exp, pos, noside)); 2882 } 2883 2884 case OP_VAR_VALUE: 2885 var = exp->elts[pc + 2].symbol; 2886 2887 /* C++: The "address" of a reference should yield the address 2888 * of the object pointed to. Let value_addr() deal with it. */ 2889 if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_REF) 2890 goto default_case; 2891 2892 (*pos) += 4; 2893 if (noside == EVAL_AVOID_SIDE_EFFECTS) 2894 { 2895 struct type *type = 2896 lookup_pointer_type (SYMBOL_TYPE (var)); 2897 enum address_class sym_class = SYMBOL_CLASS (var); 2898 2899 if (sym_class == LOC_CONST 2900 || sym_class == LOC_CONST_BYTES 2901 || sym_class == LOC_REGISTER) 2902 error (_("Attempt to take address of register or constant.")); 2903 2904 return 2905 value_zero (type, not_lval); 2906 } 2907 else 2908 return address_of_variable (var, exp->elts[pc + 1].block); 2909 2910 case OP_SCOPE: 2911 tem = longest_to_int (exp->elts[pc + 2].longconst); 2912 (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1); 2913 x = value_aggregate_elt (exp->elts[pc + 1].type, 2914 &exp->elts[pc + 3].string, 2915 NULL, 1, noside); 2916 if (x == NULL) 2917 error (_("There is no field named %s"), &exp->elts[pc + 3].string); 2918 return x; 2919 2920 default: 2921 default_case: 2922 x = evaluate_subexp (NULL_TYPE, exp, pos, noside); 2923 default_case_after_eval: 2924 if (noside == EVAL_AVOID_SIDE_EFFECTS) 2925 { 2926 struct type *type = check_typedef (value_type (x)); 2927 2928 if (TYPE_CODE (type) == TYPE_CODE_REF) 2929 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)), 2930 not_lval); 2931 else if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x)) 2932 return value_zero (lookup_pointer_type (value_type (x)), 2933 not_lval); 2934 else 2935 error (_("Attempt to take address of " 2936 "value not located in memory.")); 2937 } 2938 return value_addr (x); 2939 } 2940 } 2941 2942 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers. 2943 When used in contexts where arrays will be coerced anyway, this is 2944 equivalent to `evaluate_subexp' but much faster because it avoids 2945 actually fetching array contents (perhaps obsolete now that we have 2946 value_lazy()). 2947 2948 Note that we currently only do the coercion for C expressions, where 2949 arrays are zero based and the coercion is correct. For other languages, 2950 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION 2951 to decide if coercion is appropriate. */ 2952 2953 struct value * 2954 evaluate_subexp_with_coercion (struct expression *exp, 2955 int *pos, enum noside noside) 2956 { 2957 enum exp_opcode op; 2958 int pc; 2959 struct value *val; 2960 struct symbol *var; 2961 struct type *type; 2962 2963 pc = (*pos); 2964 op = exp->elts[pc].opcode; 2965 2966 switch (op) 2967 { 2968 case OP_VAR_VALUE: 2969 var = exp->elts[pc + 2].symbol; 2970 type = check_typedef (SYMBOL_TYPE (var)); 2971 if (TYPE_CODE (type) == TYPE_CODE_ARRAY 2972 && !TYPE_VECTOR (type) 2973 && CAST_IS_CONVERSION (exp->language_defn)) 2974 { 2975 (*pos) += 4; 2976 val = address_of_variable (var, exp->elts[pc + 1].block); 2977 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)), 2978 val); 2979 } 2980 /* FALLTHROUGH */ 2981 2982 default: 2983 return evaluate_subexp (NULL_TYPE, exp, pos, noside); 2984 } 2985 } 2986 2987 /* Evaluate a subexpression of EXP, at index *POS, 2988 and return a value for the size of that subexpression. 2989 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL 2990 we allow side-effects on the operand if its type is a variable 2991 length array. */ 2992 2993 static struct value * 2994 evaluate_subexp_for_sizeof (struct expression *exp, int *pos, 2995 enum noside noside) 2996 { 2997 /* FIXME: This should be size_t. */ 2998 struct type *size_type = builtin_type (exp->gdbarch)->builtin_int; 2999 enum exp_opcode op; 3000 int pc; 3001 struct type *type; 3002 struct value *val; 3003 3004 pc = (*pos); 3005 op = exp->elts[pc].opcode; 3006 3007 switch (op) 3008 { 3009 /* This case is handled specially 3010 so that we avoid creating a value for the result type. 3011 If the result type is very big, it's desirable not to 3012 create a value unnecessarily. */ 3013 case UNOP_IND: 3014 (*pos)++; 3015 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS); 3016 type = check_typedef (value_type (val)); 3017 if (TYPE_CODE (type) != TYPE_CODE_PTR 3018 && TYPE_CODE (type) != TYPE_CODE_REF 3019 && TYPE_CODE (type) != TYPE_CODE_ARRAY) 3020 error (_("Attempt to take contents of a non-pointer value.")); 3021 type = TYPE_TARGET_TYPE (type); 3022 if (is_dynamic_type (type)) 3023 type = value_type (value_ind (val)); 3024 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type)); 3025 3026 case UNOP_MEMVAL: 3027 (*pos) += 3; 3028 type = exp->elts[pc + 1].type; 3029 break; 3030 3031 case UNOP_MEMVAL_TYPE: 3032 (*pos) += 1; 3033 val = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS); 3034 type = value_type (val); 3035 break; 3036 3037 case OP_VAR_VALUE: 3038 type = SYMBOL_TYPE (exp->elts[pc + 2].symbol); 3039 if (is_dynamic_type (type)) 3040 { 3041 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL); 3042 type = value_type (val); 3043 } 3044 else 3045 (*pos) += 4; 3046 break; 3047 3048 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting 3049 type of the subscript is a variable length array type. In this case we 3050 must re-evaluate the right hand side of the subcription to allow 3051 side-effects. */ 3052 case BINOP_SUBSCRIPT: 3053 if (noside == EVAL_NORMAL) 3054 { 3055 int pc = (*pos) + 1; 3056 3057 val = evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS); 3058 type = check_typedef (value_type (val)); 3059 if (TYPE_CODE (type) == TYPE_CODE_ARRAY) 3060 { 3061 type = check_typedef (TYPE_TARGET_TYPE (type)); 3062 if (TYPE_CODE (type) == TYPE_CODE_ARRAY) 3063 { 3064 type = TYPE_INDEX_TYPE (type); 3065 /* Only re-evaluate the right hand side if the resulting type 3066 is a variable length type. */ 3067 if (TYPE_RANGE_DATA (type)->flag_bound_evaluated) 3068 { 3069 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL); 3070 return value_from_longest 3071 (size_type, (LONGEST) TYPE_LENGTH (value_type (val))); 3072 } 3073 } 3074 } 3075 } 3076 3077 /* Fall through. */ 3078 3079 default: 3080 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS); 3081 type = value_type (val); 3082 break; 3083 } 3084 3085 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof: 3086 "When applied to a reference or a reference type, the result is 3087 the size of the referenced type." */ 3088 CHECK_TYPEDEF (type); 3089 if (exp->language_defn->la_language == language_cplus 3090 && TYPE_CODE (type) == TYPE_CODE_REF) 3091 type = check_typedef (TYPE_TARGET_TYPE (type)); 3092 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type)); 3093 } 3094 3095 /* Parse a type expression in the string [P..P+LENGTH). */ 3096 3097 struct type * 3098 parse_and_eval_type (char *p, int length) 3099 { 3100 char *tmp = (char *) alloca (length + 4); 3101 struct expression *expr; 3102 3103 tmp[0] = '('; 3104 memcpy (tmp + 1, p, length); 3105 tmp[length + 1] = ')'; 3106 tmp[length + 2] = '0'; 3107 tmp[length + 3] = '\0'; 3108 expr = parse_expression (tmp); 3109 if (expr->elts[0].opcode != UNOP_CAST) 3110 error (_("Internal error in eval_type.")); 3111 return expr->elts[1].type; 3112 } 3113 3114 int 3115 calc_f77_array_dims (struct type *array_type) 3116 { 3117 int ndimen = 1; 3118 struct type *tmp_type; 3119 3120 if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY)) 3121 error (_("Can't get dimensions for a non-array type")); 3122 3123 tmp_type = array_type; 3124 3125 while ((tmp_type = TYPE_TARGET_TYPE (tmp_type))) 3126 { 3127 if (TYPE_CODE (tmp_type) == TYPE_CODE_ARRAY) 3128 ++ndimen; 3129 } 3130 return ndimen; 3131 } 3132