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