1 /* Perform non-arithmetic operations on values, 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 "frame.h" 25 #include "inferior.h" 26 #include "gdbcore.h" 27 #include "target.h" 28 #include "demangle.h" 29 #include "language.h" 30 #include "gdbcmd.h" 31 #include "regcache.h" 32 #include "cp-abi.h" 33 #include "block.h" 34 #include "infcall.h" 35 #include "dictionary.h" 36 #include "cp-support.h" 37 #include "dfp.h" 38 #include "tracepoint.h" 39 #include "observer.h" 40 #include "objfiles.h" 41 #include "extension.h" 42 43 extern unsigned int overload_debug; 44 /* Local functions. */ 45 46 static int typecmp (int staticp, int varargs, int nargs, 47 struct field t1[], struct value *t2[]); 48 49 static struct value *search_struct_field (const char *, struct value *, 50 struct type *, int); 51 52 static struct value *search_struct_method (const char *, struct value **, 53 struct value **, 54 LONGEST, int *, struct type *); 55 56 static int find_oload_champ_namespace (struct value **, int, 57 const char *, const char *, 58 struct symbol ***, 59 struct badness_vector **, 60 const int no_adl); 61 62 static 63 int find_oload_champ_namespace_loop (struct value **, int, 64 const char *, const char *, 65 int, struct symbol ***, 66 struct badness_vector **, int *, 67 const int no_adl); 68 69 static int find_oload_champ (struct value **, int, int, 70 struct fn_field *, VEC (xmethod_worker_ptr) *, 71 struct symbol **, struct badness_vector **); 72 73 static int oload_method_static_p (struct fn_field *, int); 74 75 enum oload_classification { STANDARD, NON_STANDARD, INCOMPATIBLE }; 76 77 static enum 78 oload_classification classify_oload_match (struct badness_vector *, 79 int, int); 80 81 static struct value *value_struct_elt_for_reference (struct type *, 82 int, struct type *, 83 const char *, 84 struct type *, 85 int, enum noside); 86 87 static struct value *value_namespace_elt (const struct type *, 88 const char *, int , enum noside); 89 90 static struct value *value_maybe_namespace_elt (const struct type *, 91 const char *, int, 92 enum noside); 93 94 static CORE_ADDR allocate_space_in_inferior (int); 95 96 static struct value *cast_into_complex (struct type *, struct value *); 97 98 static void find_method_list (struct value **, const char *, 99 LONGEST, struct type *, struct fn_field **, int *, 100 VEC (xmethod_worker_ptr) **, 101 struct type **, LONGEST *); 102 103 void _initialize_valops (void); 104 105 #if 0 106 /* Flag for whether we want to abandon failed expression evals by 107 default. */ 108 109 static int auto_abandon = 0; 110 #endif 111 112 int overload_resolution = 0; 113 static void 114 show_overload_resolution (struct ui_file *file, int from_tty, 115 struct cmd_list_element *c, 116 const char *value) 117 { 118 fprintf_filtered (file, _("Overload resolution in evaluating " 119 "C++ functions is %s.\n"), 120 value); 121 } 122 123 /* Find the address of function name NAME in the inferior. If OBJF_P 124 is non-NULL, *OBJF_P will be set to the OBJFILE where the function 125 is defined. */ 126 127 struct value * 128 find_function_in_inferior (const char *name, struct objfile **objf_p) 129 { 130 struct block_symbol sym; 131 132 sym = lookup_symbol (name, 0, VAR_DOMAIN, 0); 133 if (sym.symbol != NULL) 134 { 135 if (SYMBOL_CLASS (sym.symbol) != LOC_BLOCK) 136 { 137 error (_("\"%s\" exists in this program but is not a function."), 138 name); 139 } 140 141 if (objf_p) 142 *objf_p = symbol_objfile (sym.symbol); 143 144 return value_of_variable (sym.symbol, sym.block); 145 } 146 else 147 { 148 struct bound_minimal_symbol msymbol = 149 lookup_bound_minimal_symbol (name); 150 151 if (msymbol.minsym != NULL) 152 { 153 struct objfile *objfile = msymbol.objfile; 154 struct gdbarch *gdbarch = get_objfile_arch (objfile); 155 156 struct type *type; 157 CORE_ADDR maddr; 158 type = lookup_pointer_type (builtin_type (gdbarch)->builtin_char); 159 type = lookup_function_type (type); 160 type = lookup_pointer_type (type); 161 maddr = BMSYMBOL_VALUE_ADDRESS (msymbol); 162 163 if (objf_p) 164 *objf_p = objfile; 165 166 return value_from_pointer (type, maddr); 167 } 168 else 169 { 170 if (!target_has_execution) 171 error (_("evaluation of this expression " 172 "requires the target program to be active")); 173 else 174 error (_("evaluation of this expression requires the " 175 "program to have a function \"%s\"."), 176 name); 177 } 178 } 179 } 180 181 /* Allocate NBYTES of space in the inferior using the inferior's 182 malloc and return a value that is a pointer to the allocated 183 space. */ 184 185 struct value * 186 value_allocate_space_in_inferior (int len) 187 { 188 struct objfile *objf; 189 struct value *val = find_function_in_inferior ("malloc", &objf); 190 struct gdbarch *gdbarch = get_objfile_arch (objf); 191 struct value *blocklen; 192 193 blocklen = value_from_longest (builtin_type (gdbarch)->builtin_int, len); 194 val = call_function_by_hand (val, 1, &blocklen); 195 if (value_logical_not (val)) 196 { 197 if (!target_has_execution) 198 error (_("No memory available to program now: " 199 "you need to start the target first")); 200 else 201 error (_("No memory available to program: call to malloc failed")); 202 } 203 return val; 204 } 205 206 static CORE_ADDR 207 allocate_space_in_inferior (int len) 208 { 209 return value_as_long (value_allocate_space_in_inferior (len)); 210 } 211 212 /* Cast struct value VAL to type TYPE and return as a value. 213 Both type and val must be of TYPE_CODE_STRUCT or TYPE_CODE_UNION 214 for this to work. Typedef to one of the codes is permitted. 215 Returns NULL if the cast is neither an upcast nor a downcast. */ 216 217 static struct value * 218 value_cast_structs (struct type *type, struct value *v2) 219 { 220 struct type *t1; 221 struct type *t2; 222 struct value *v; 223 224 gdb_assert (type != NULL && v2 != NULL); 225 226 t1 = check_typedef (type); 227 t2 = check_typedef (value_type (v2)); 228 229 /* Check preconditions. */ 230 gdb_assert ((TYPE_CODE (t1) == TYPE_CODE_STRUCT 231 || TYPE_CODE (t1) == TYPE_CODE_UNION) 232 && !!"Precondition is that type is of STRUCT or UNION kind."); 233 gdb_assert ((TYPE_CODE (t2) == TYPE_CODE_STRUCT 234 || TYPE_CODE (t2) == TYPE_CODE_UNION) 235 && !!"Precondition is that value is of STRUCT or UNION kind"); 236 237 if (TYPE_NAME (t1) != NULL 238 && TYPE_NAME (t2) != NULL 239 && !strcmp (TYPE_NAME (t1), TYPE_NAME (t2))) 240 return NULL; 241 242 /* Upcasting: look in the type of the source to see if it contains the 243 type of the target as a superclass. If so, we'll need to 244 offset the pointer rather than just change its type. */ 245 if (TYPE_NAME (t1) != NULL) 246 { 247 v = search_struct_field (type_name_no_tag (t1), 248 v2, t2, 1); 249 if (v) 250 return v; 251 } 252 253 /* Downcasting: look in the type of the target to see if it contains the 254 type of the source as a superclass. If so, we'll need to 255 offset the pointer rather than just change its type. */ 256 if (TYPE_NAME (t2) != NULL) 257 { 258 /* Try downcasting using the run-time type of the value. */ 259 int full, using_enc; 260 LONGEST top; 261 struct type *real_type; 262 263 real_type = value_rtti_type (v2, &full, &top, &using_enc); 264 if (real_type) 265 { 266 v = value_full_object (v2, real_type, full, top, using_enc); 267 v = value_at_lazy (real_type, value_address (v)); 268 real_type = value_type (v); 269 270 /* We might be trying to cast to the outermost enclosing 271 type, in which case search_struct_field won't work. */ 272 if (TYPE_NAME (real_type) != NULL 273 && !strcmp (TYPE_NAME (real_type), TYPE_NAME (t1))) 274 return v; 275 276 v = search_struct_field (type_name_no_tag (t2), v, real_type, 1); 277 if (v) 278 return v; 279 } 280 281 /* Try downcasting using information from the destination type 282 T2. This wouldn't work properly for classes with virtual 283 bases, but those were handled above. */ 284 v = search_struct_field (type_name_no_tag (t2), 285 value_zero (t1, not_lval), t1, 1); 286 if (v) 287 { 288 /* Downcasting is possible (t1 is superclass of v2). */ 289 CORE_ADDR addr2 = value_address (v2); 290 291 addr2 -= value_address (v) + value_embedded_offset (v); 292 return value_at (type, addr2); 293 } 294 } 295 296 return NULL; 297 } 298 299 /* Cast one pointer or reference type to another. Both TYPE and 300 the type of ARG2 should be pointer types, or else both should be 301 reference types. If SUBCLASS_CHECK is non-zero, this will force a 302 check to see whether TYPE is a superclass of ARG2's type. If 303 SUBCLASS_CHECK is zero, then the subclass check is done only when 304 ARG2 is itself non-zero. Returns the new pointer or reference. */ 305 306 struct value * 307 value_cast_pointers (struct type *type, struct value *arg2, 308 int subclass_check) 309 { 310 struct type *type1 = check_typedef (type); 311 struct type *type2 = check_typedef (value_type (arg2)); 312 struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type1)); 313 struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2)); 314 315 if (TYPE_CODE (t1) == TYPE_CODE_STRUCT 316 && TYPE_CODE (t2) == TYPE_CODE_STRUCT 317 && (subclass_check || !value_logical_not (arg2))) 318 { 319 struct value *v2; 320 321 if (TYPE_CODE (type2) == TYPE_CODE_REF) 322 v2 = coerce_ref (arg2); 323 else 324 v2 = value_ind (arg2); 325 gdb_assert (TYPE_CODE (check_typedef (value_type (v2))) 326 == TYPE_CODE_STRUCT && !!"Why did coercion fail?"); 327 v2 = value_cast_structs (t1, v2); 328 /* At this point we have what we can have, un-dereference if needed. */ 329 if (v2) 330 { 331 struct value *v = value_addr (v2); 332 333 deprecated_set_value_type (v, type); 334 return v; 335 } 336 } 337 338 /* No superclass found, just change the pointer type. */ 339 arg2 = value_copy (arg2); 340 deprecated_set_value_type (arg2, type); 341 set_value_enclosing_type (arg2, type); 342 set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */ 343 return arg2; 344 } 345 346 /* Cast value ARG2 to type TYPE and return as a value. 347 More general than a C cast: accepts any two types of the same length, 348 and if ARG2 is an lvalue it can be cast into anything at all. */ 349 /* In C++, casts may change pointer or object representations. */ 350 351 struct value * 352 value_cast (struct type *type, struct value *arg2) 353 { 354 enum type_code code1; 355 enum type_code code2; 356 int scalar; 357 struct type *type2; 358 359 int convert_to_boolean = 0; 360 361 if (value_type (arg2) == type) 362 return arg2; 363 364 code1 = TYPE_CODE (check_typedef (type)); 365 366 /* Check if we are casting struct reference to struct reference. */ 367 if (code1 == TYPE_CODE_REF) 368 { 369 /* We dereference type; then we recurse and finally 370 we generate value of the given reference. Nothing wrong with 371 that. */ 372 struct type *t1 = check_typedef (type); 373 struct type *dereftype = check_typedef (TYPE_TARGET_TYPE (t1)); 374 struct value *val = value_cast (dereftype, arg2); 375 376 return value_ref (val); 377 } 378 379 code2 = TYPE_CODE (check_typedef (value_type (arg2))); 380 381 if (code2 == TYPE_CODE_REF) 382 /* We deref the value and then do the cast. */ 383 return value_cast (type, coerce_ref (arg2)); 384 385 type = check_typedef (type); 386 code1 = TYPE_CODE (type); 387 arg2 = coerce_ref (arg2); 388 type2 = check_typedef (value_type (arg2)); 389 390 /* You can't cast to a reference type. See value_cast_pointers 391 instead. */ 392 gdb_assert (code1 != TYPE_CODE_REF); 393 394 /* A cast to an undetermined-length array_type, such as 395 (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT, 396 where N is sizeof(OBJECT)/sizeof(TYPE). */ 397 if (code1 == TYPE_CODE_ARRAY) 398 { 399 struct type *element_type = TYPE_TARGET_TYPE (type); 400 unsigned element_length = TYPE_LENGTH (check_typedef (element_type)); 401 402 if (element_length > 0 && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type)) 403 { 404 struct type *range_type = TYPE_INDEX_TYPE (type); 405 int val_length = TYPE_LENGTH (type2); 406 LONGEST low_bound, high_bound, new_length; 407 408 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0) 409 low_bound = 0, high_bound = 0; 410 new_length = val_length / element_length; 411 if (val_length % element_length != 0) 412 warning (_("array element type size does not " 413 "divide object size in cast")); 414 /* FIXME-type-allocation: need a way to free this type when 415 we are done with it. */ 416 range_type = create_static_range_type ((struct type *) NULL, 417 TYPE_TARGET_TYPE (range_type), 418 low_bound, 419 new_length + low_bound - 1); 420 deprecated_set_value_type (arg2, 421 create_array_type ((struct type *) NULL, 422 element_type, 423 range_type)); 424 return arg2; 425 } 426 } 427 428 if (current_language->c_style_arrays 429 && TYPE_CODE (type2) == TYPE_CODE_ARRAY 430 && !TYPE_VECTOR (type2)) 431 arg2 = value_coerce_array (arg2); 432 433 if (TYPE_CODE (type2) == TYPE_CODE_FUNC) 434 arg2 = value_coerce_function (arg2); 435 436 type2 = check_typedef (value_type (arg2)); 437 code2 = TYPE_CODE (type2); 438 439 if (code1 == TYPE_CODE_COMPLEX) 440 return cast_into_complex (type, arg2); 441 if (code1 == TYPE_CODE_BOOL) 442 { 443 code1 = TYPE_CODE_INT; 444 convert_to_boolean = 1; 445 } 446 if (code1 == TYPE_CODE_CHAR) 447 code1 = TYPE_CODE_INT; 448 if (code2 == TYPE_CODE_BOOL || code2 == TYPE_CODE_CHAR) 449 code2 = TYPE_CODE_INT; 450 451 scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT 452 || code2 == TYPE_CODE_DECFLOAT || code2 == TYPE_CODE_ENUM 453 || code2 == TYPE_CODE_RANGE); 454 455 if ((code1 == TYPE_CODE_STRUCT || code1 == TYPE_CODE_UNION) 456 && (code2 == TYPE_CODE_STRUCT || code2 == TYPE_CODE_UNION) 457 && TYPE_NAME (type) != 0) 458 { 459 struct value *v = value_cast_structs (type, arg2); 460 461 if (v) 462 return v; 463 } 464 465 if (code1 == TYPE_CODE_FLT && scalar) 466 return value_from_double (type, value_as_double (arg2)); 467 else if (code1 == TYPE_CODE_DECFLOAT && scalar) 468 { 469 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); 470 int dec_len = TYPE_LENGTH (type); 471 gdb_byte dec[16]; 472 473 if (code2 == TYPE_CODE_FLT) 474 decimal_from_floating (arg2, dec, dec_len, byte_order); 475 else if (code2 == TYPE_CODE_DECFLOAT) 476 decimal_convert (value_contents (arg2), TYPE_LENGTH (type2), 477 byte_order, dec, dec_len, byte_order); 478 else 479 /* The only option left is an integral type. */ 480 decimal_from_integral (arg2, dec, dec_len, byte_order); 481 482 return value_from_decfloat (type, dec); 483 } 484 else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM 485 || code1 == TYPE_CODE_RANGE) 486 && (scalar || code2 == TYPE_CODE_PTR 487 || code2 == TYPE_CODE_MEMBERPTR)) 488 { 489 LONGEST longest; 490 491 /* When we cast pointers to integers, we mustn't use 492 gdbarch_pointer_to_address to find the address the pointer 493 represents, as value_as_long would. GDB should evaluate 494 expressions just as the compiler would --- and the compiler 495 sees a cast as a simple reinterpretation of the pointer's 496 bits. */ 497 if (code2 == TYPE_CODE_PTR) 498 longest = extract_unsigned_integer 499 (value_contents (arg2), TYPE_LENGTH (type2), 500 gdbarch_byte_order (get_type_arch (type2))); 501 else 502 longest = value_as_long (arg2); 503 return value_from_longest (type, convert_to_boolean ? 504 (LONGEST) (longest ? 1 : 0) : longest); 505 } 506 else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT 507 || code2 == TYPE_CODE_ENUM 508 || code2 == TYPE_CODE_RANGE)) 509 { 510 /* TYPE_LENGTH (type) is the length of a pointer, but we really 511 want the length of an address! -- we are really dealing with 512 addresses (i.e., gdb representations) not pointers (i.e., 513 target representations) here. 514 515 This allows things like "print *(int *)0x01000234" to work 516 without printing a misleading message -- which would 517 otherwise occur when dealing with a target having two byte 518 pointers and four byte addresses. */ 519 520 int addr_bit = gdbarch_addr_bit (get_type_arch (type2)); 521 LONGEST longest = value_as_long (arg2); 522 523 if (addr_bit < sizeof (LONGEST) * HOST_CHAR_BIT) 524 { 525 if (longest >= ((LONGEST) 1 << addr_bit) 526 || longest <= -((LONGEST) 1 << addr_bit)) 527 warning (_("value truncated")); 528 } 529 return value_from_longest (type, longest); 530 } 531 else if (code1 == TYPE_CODE_METHODPTR && code2 == TYPE_CODE_INT 532 && value_as_long (arg2) == 0) 533 { 534 struct value *result = allocate_value (type); 535 536 cplus_make_method_ptr (type, value_contents_writeable (result), 0, 0); 537 return result; 538 } 539 else if (code1 == TYPE_CODE_MEMBERPTR && code2 == TYPE_CODE_INT 540 && value_as_long (arg2) == 0) 541 { 542 /* The Itanium C++ ABI represents NULL pointers to members as 543 minus one, instead of biasing the normal case. */ 544 return value_from_longest (type, -1); 545 } 546 else if (code1 == TYPE_CODE_ARRAY && TYPE_VECTOR (type) 547 && code2 == TYPE_CODE_ARRAY && TYPE_VECTOR (type2) 548 && TYPE_LENGTH (type) != TYPE_LENGTH (type2)) 549 error (_("Cannot convert between vector values of different sizes")); 550 else if (code1 == TYPE_CODE_ARRAY && TYPE_VECTOR (type) && scalar 551 && TYPE_LENGTH (type) != TYPE_LENGTH (type2)) 552 error (_("can only cast scalar to vector of same size")); 553 else if (code1 == TYPE_CODE_VOID) 554 { 555 return value_zero (type, not_lval); 556 } 557 else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2)) 558 { 559 if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR) 560 return value_cast_pointers (type, arg2, 0); 561 562 arg2 = value_copy (arg2); 563 deprecated_set_value_type (arg2, type); 564 set_value_enclosing_type (arg2, type); 565 set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */ 566 return arg2; 567 } 568 else if (VALUE_LVAL (arg2) == lval_memory) 569 return value_at_lazy (type, value_address (arg2)); 570 else 571 { 572 error (_("Invalid cast.")); 573 return 0; 574 } 575 } 576 577 /* The C++ reinterpret_cast operator. */ 578 579 struct value * 580 value_reinterpret_cast (struct type *type, struct value *arg) 581 { 582 struct value *result; 583 struct type *real_type = check_typedef (type); 584 struct type *arg_type, *dest_type; 585 int is_ref = 0; 586 enum type_code dest_code, arg_code; 587 588 /* Do reference, function, and array conversion. */ 589 arg = coerce_array (arg); 590 591 /* Attempt to preserve the type the user asked for. */ 592 dest_type = type; 593 594 /* If we are casting to a reference type, transform 595 reinterpret_cast<T&>(V) to *reinterpret_cast<T*>(&V). */ 596 if (TYPE_CODE (real_type) == TYPE_CODE_REF) 597 { 598 is_ref = 1; 599 arg = value_addr (arg); 600 dest_type = lookup_pointer_type (TYPE_TARGET_TYPE (dest_type)); 601 real_type = lookup_pointer_type (real_type); 602 } 603 604 arg_type = value_type (arg); 605 606 dest_code = TYPE_CODE (real_type); 607 arg_code = TYPE_CODE (arg_type); 608 609 /* We can convert pointer types, or any pointer type to int, or int 610 type to pointer. */ 611 if ((dest_code == TYPE_CODE_PTR && arg_code == TYPE_CODE_INT) 612 || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_PTR) 613 || (dest_code == TYPE_CODE_METHODPTR && arg_code == TYPE_CODE_INT) 614 || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_METHODPTR) 615 || (dest_code == TYPE_CODE_MEMBERPTR && arg_code == TYPE_CODE_INT) 616 || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_MEMBERPTR) 617 || (dest_code == arg_code 618 && (dest_code == TYPE_CODE_PTR 619 || dest_code == TYPE_CODE_METHODPTR 620 || dest_code == TYPE_CODE_MEMBERPTR))) 621 result = value_cast (dest_type, arg); 622 else 623 error (_("Invalid reinterpret_cast")); 624 625 if (is_ref) 626 result = value_cast (type, value_ref (value_ind (result))); 627 628 return result; 629 } 630 631 /* A helper for value_dynamic_cast. This implements the first of two 632 runtime checks: we iterate over all the base classes of the value's 633 class which are equal to the desired class; if only one of these 634 holds the value, then it is the answer. */ 635 636 static int 637 dynamic_cast_check_1 (struct type *desired_type, 638 const gdb_byte *valaddr, 639 LONGEST embedded_offset, 640 CORE_ADDR address, 641 struct value *val, 642 struct type *search_type, 643 CORE_ADDR arg_addr, 644 struct type *arg_type, 645 struct value **result) 646 { 647 int i, result_count = 0; 648 649 for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i) 650 { 651 LONGEST offset = baseclass_offset (search_type, i, valaddr, 652 embedded_offset, 653 address, val); 654 655 if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i))) 656 { 657 if (address + embedded_offset + offset >= arg_addr 658 && address + embedded_offset + offset < arg_addr + TYPE_LENGTH (arg_type)) 659 { 660 ++result_count; 661 if (!*result) 662 *result = value_at_lazy (TYPE_BASECLASS (search_type, i), 663 address + embedded_offset + offset); 664 } 665 } 666 else 667 result_count += dynamic_cast_check_1 (desired_type, 668 valaddr, 669 embedded_offset + offset, 670 address, val, 671 TYPE_BASECLASS (search_type, i), 672 arg_addr, 673 arg_type, 674 result); 675 } 676 677 return result_count; 678 } 679 680 /* A helper for value_dynamic_cast. This implements the second of two 681 runtime checks: we look for a unique public sibling class of the 682 argument's declared class. */ 683 684 static int 685 dynamic_cast_check_2 (struct type *desired_type, 686 const gdb_byte *valaddr, 687 LONGEST embedded_offset, 688 CORE_ADDR address, 689 struct value *val, 690 struct type *search_type, 691 struct value **result) 692 { 693 int i, result_count = 0; 694 695 for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i) 696 { 697 LONGEST offset; 698 699 if (! BASETYPE_VIA_PUBLIC (search_type, i)) 700 continue; 701 702 offset = baseclass_offset (search_type, i, valaddr, embedded_offset, 703 address, val); 704 if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i))) 705 { 706 ++result_count; 707 if (*result == NULL) 708 *result = value_at_lazy (TYPE_BASECLASS (search_type, i), 709 address + embedded_offset + offset); 710 } 711 else 712 result_count += dynamic_cast_check_2 (desired_type, 713 valaddr, 714 embedded_offset + offset, 715 address, val, 716 TYPE_BASECLASS (search_type, i), 717 result); 718 } 719 720 return result_count; 721 } 722 723 /* The C++ dynamic_cast operator. */ 724 725 struct value * 726 value_dynamic_cast (struct type *type, struct value *arg) 727 { 728 int full, using_enc; 729 LONGEST top; 730 struct type *resolved_type = check_typedef (type); 731 struct type *arg_type = check_typedef (value_type (arg)); 732 struct type *class_type, *rtti_type; 733 struct value *result, *tem, *original_arg = arg; 734 CORE_ADDR addr; 735 int is_ref = TYPE_CODE (resolved_type) == TYPE_CODE_REF; 736 737 if (TYPE_CODE (resolved_type) != TYPE_CODE_PTR 738 && TYPE_CODE (resolved_type) != TYPE_CODE_REF) 739 error (_("Argument to dynamic_cast must be a pointer or reference type")); 740 if (TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_VOID 741 && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_STRUCT) 742 error (_("Argument to dynamic_cast must be pointer to class or `void *'")); 743 744 class_type = check_typedef (TYPE_TARGET_TYPE (resolved_type)); 745 if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR) 746 { 747 if (TYPE_CODE (arg_type) != TYPE_CODE_PTR 748 && ! (TYPE_CODE (arg_type) == TYPE_CODE_INT 749 && value_as_long (arg) == 0)) 750 error (_("Argument to dynamic_cast does not have pointer type")); 751 if (TYPE_CODE (arg_type) == TYPE_CODE_PTR) 752 { 753 arg_type = check_typedef (TYPE_TARGET_TYPE (arg_type)); 754 if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT) 755 error (_("Argument to dynamic_cast does " 756 "not have pointer to class type")); 757 } 758 759 /* Handle NULL pointers. */ 760 if (value_as_long (arg) == 0) 761 return value_zero (type, not_lval); 762 763 arg = value_ind (arg); 764 } 765 else 766 { 767 if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT) 768 error (_("Argument to dynamic_cast does not have class type")); 769 } 770 771 /* If the classes are the same, just return the argument. */ 772 if (class_types_same_p (class_type, arg_type)) 773 return value_cast (type, arg); 774 775 /* If the target type is a unique base class of the argument's 776 declared type, just cast it. */ 777 if (is_ancestor (class_type, arg_type)) 778 { 779 if (is_unique_ancestor (class_type, arg)) 780 return value_cast (type, original_arg); 781 error (_("Ambiguous dynamic_cast")); 782 } 783 784 rtti_type = value_rtti_type (arg, &full, &top, &using_enc); 785 if (! rtti_type) 786 error (_("Couldn't determine value's most derived type for dynamic_cast")); 787 788 /* Compute the most derived object's address. */ 789 addr = value_address (arg); 790 if (full) 791 { 792 /* Done. */ 793 } 794 else if (using_enc) 795 addr += top; 796 else 797 addr += top + value_embedded_offset (arg); 798 799 /* dynamic_cast<void *> means to return a pointer to the 800 most-derived object. */ 801 if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR 802 && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) == TYPE_CODE_VOID) 803 return value_at_lazy (type, addr); 804 805 tem = value_at (type, addr); 806 type = value_type (tem); 807 808 /* The first dynamic check specified in 5.2.7. */ 809 if (is_public_ancestor (arg_type, TYPE_TARGET_TYPE (resolved_type))) 810 { 811 if (class_types_same_p (rtti_type, TYPE_TARGET_TYPE (resolved_type))) 812 return tem; 813 result = NULL; 814 if (dynamic_cast_check_1 (TYPE_TARGET_TYPE (resolved_type), 815 value_contents_for_printing (tem), 816 value_embedded_offset (tem), 817 value_address (tem), tem, 818 rtti_type, addr, 819 arg_type, 820 &result) == 1) 821 return value_cast (type, 822 is_ref ? value_ref (result) : value_addr (result)); 823 } 824 825 /* The second dynamic check specified in 5.2.7. */ 826 result = NULL; 827 if (is_public_ancestor (arg_type, rtti_type) 828 && dynamic_cast_check_2 (TYPE_TARGET_TYPE (resolved_type), 829 value_contents_for_printing (tem), 830 value_embedded_offset (tem), 831 value_address (tem), tem, 832 rtti_type, &result) == 1) 833 return value_cast (type, 834 is_ref ? value_ref (result) : value_addr (result)); 835 836 if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR) 837 return value_zero (type, not_lval); 838 839 error (_("dynamic_cast failed")); 840 } 841 842 /* Create a value of type TYPE that is zero, and return it. */ 843 844 struct value * 845 value_zero (struct type *type, enum lval_type lv) 846 { 847 struct value *val = allocate_value (type); 848 849 VALUE_LVAL (val) = (lv == lval_computed ? not_lval : lv); 850 return val; 851 } 852 853 /* Create a not_lval value of numeric type TYPE that is one, and return it. */ 854 855 struct value * 856 value_one (struct type *type) 857 { 858 struct type *type1 = check_typedef (type); 859 struct value *val; 860 861 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT) 862 { 863 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); 864 gdb_byte v[16]; 865 866 decimal_from_string (v, TYPE_LENGTH (type), byte_order, "1"); 867 val = value_from_decfloat (type, v); 868 } 869 else if (TYPE_CODE (type1) == TYPE_CODE_FLT) 870 { 871 val = value_from_double (type, (DOUBLEST) 1); 872 } 873 else if (is_integral_type (type1)) 874 { 875 val = value_from_longest (type, (LONGEST) 1); 876 } 877 else if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1)) 878 { 879 struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type1)); 880 int i; 881 LONGEST low_bound, high_bound; 882 struct value *tmp; 883 884 if (!get_array_bounds (type1, &low_bound, &high_bound)) 885 error (_("Could not determine the vector bounds")); 886 887 val = allocate_value (type); 888 for (i = 0; i < high_bound - low_bound + 1; i++) 889 { 890 tmp = value_one (eltype); 891 memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype), 892 value_contents_all (tmp), TYPE_LENGTH (eltype)); 893 } 894 } 895 else 896 { 897 error (_("Not a numeric type.")); 898 } 899 900 /* value_one result is never used for assignments to. */ 901 gdb_assert (VALUE_LVAL (val) == not_lval); 902 903 return val; 904 } 905 906 /* Helper function for value_at, value_at_lazy, and value_at_lazy_stack. 907 The type of the created value may differ from the passed type TYPE. 908 Make sure to retrieve the returned values's new type after this call 909 e.g. in case the type is a variable length array. */ 910 911 static struct value * 912 get_value_at (struct type *type, CORE_ADDR addr, int lazy) 913 { 914 struct value *val; 915 916 if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID) 917 error (_("Attempt to dereference a generic pointer.")); 918 919 val = value_from_contents_and_address (type, NULL, addr); 920 921 if (!lazy) 922 value_fetch_lazy (val); 923 924 return val; 925 } 926 927 /* Return a value with type TYPE located at ADDR. 928 929 Call value_at only if the data needs to be fetched immediately; 930 if we can be 'lazy' and defer the fetch, perhaps indefinately, call 931 value_at_lazy instead. value_at_lazy simply records the address of 932 the data and sets the lazy-evaluation-required flag. The lazy flag 933 is tested in the value_contents macro, which is used if and when 934 the contents are actually required. The type of the created value 935 may differ from the passed type TYPE. Make sure to retrieve the 936 returned values's new type after this call e.g. in case the type 937 is a variable length array. 938 939 Note: value_at does *NOT* handle embedded offsets; perform such 940 adjustments before or after calling it. */ 941 942 struct value * 943 value_at (struct type *type, CORE_ADDR addr) 944 { 945 return get_value_at (type, addr, 0); 946 } 947 948 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). 949 The type of the created value may differ from the passed type TYPE. 950 Make sure to retrieve the returned values's new type after this call 951 e.g. in case the type is a variable length array. */ 952 953 struct value * 954 value_at_lazy (struct type *type, CORE_ADDR addr) 955 { 956 return get_value_at (type, addr, 1); 957 } 958 959 void 960 read_value_memory (struct value *val, LONGEST embedded_offset, 961 int stack, CORE_ADDR memaddr, 962 gdb_byte *buffer, size_t length) 963 { 964 ULONGEST xfered_total = 0; 965 struct gdbarch *arch = get_value_arch (val); 966 int unit_size = gdbarch_addressable_memory_unit_size (arch); 967 enum target_object object; 968 969 object = stack ? TARGET_OBJECT_STACK_MEMORY : TARGET_OBJECT_MEMORY; 970 971 while (xfered_total < length) 972 { 973 enum target_xfer_status status; 974 ULONGEST xfered_partial; 975 976 status = target_xfer_partial (current_target.beneath, 977 object, NULL, 978 buffer + xfered_total * unit_size, NULL, 979 memaddr + xfered_total, 980 length - xfered_total, 981 &xfered_partial); 982 983 if (status == TARGET_XFER_OK) 984 /* nothing */; 985 else if (status == TARGET_XFER_UNAVAILABLE) 986 mark_value_bytes_unavailable (val, embedded_offset + xfered_total, 987 xfered_partial); 988 else if (status == TARGET_XFER_EOF) 989 memory_error (TARGET_XFER_E_IO, memaddr + xfered_total); 990 else 991 memory_error (status, memaddr + xfered_total); 992 993 xfered_total += xfered_partial; 994 QUIT; 995 } 996 } 997 998 /* Store the contents of FROMVAL into the location of TOVAL. 999 Return a new value with the location of TOVAL and contents of FROMVAL. */ 1000 1001 struct value * 1002 value_assign (struct value *toval, struct value *fromval) 1003 { 1004 struct type *type; 1005 struct value *val; 1006 struct frame_id old_frame; 1007 1008 if (!deprecated_value_modifiable (toval)) 1009 error (_("Left operand of assignment is not a modifiable lvalue.")); 1010 1011 toval = coerce_ref (toval); 1012 1013 type = value_type (toval); 1014 if (VALUE_LVAL (toval) != lval_internalvar) 1015 fromval = value_cast (type, fromval); 1016 else 1017 { 1018 /* Coerce arrays and functions to pointers, except for arrays 1019 which only live in GDB's storage. */ 1020 if (!value_must_coerce_to_target (fromval)) 1021 fromval = coerce_array (fromval); 1022 } 1023 1024 type = check_typedef (type); 1025 1026 /* Since modifying a register can trash the frame chain, and 1027 modifying memory can trash the frame cache, we save the old frame 1028 and then restore the new frame afterwards. */ 1029 old_frame = get_frame_id (deprecated_safe_get_selected_frame ()); 1030 1031 switch (VALUE_LVAL (toval)) 1032 { 1033 case lval_internalvar: 1034 set_internalvar (VALUE_INTERNALVAR (toval), fromval); 1035 return value_of_internalvar (get_type_arch (type), 1036 VALUE_INTERNALVAR (toval)); 1037 1038 case lval_internalvar_component: 1039 { 1040 LONGEST offset = value_offset (toval); 1041 1042 /* Are we dealing with a bitfield? 1043 1044 It is important to mention that `value_parent (toval)' is 1045 non-NULL iff `value_bitsize (toval)' is non-zero. */ 1046 if (value_bitsize (toval)) 1047 { 1048 /* VALUE_INTERNALVAR below refers to the parent value, while 1049 the offset is relative to this parent value. */ 1050 gdb_assert (value_parent (value_parent (toval)) == NULL); 1051 offset += value_offset (value_parent (toval)); 1052 } 1053 1054 set_internalvar_component (VALUE_INTERNALVAR (toval), 1055 offset, 1056 value_bitpos (toval), 1057 value_bitsize (toval), 1058 fromval); 1059 } 1060 break; 1061 1062 case lval_memory: 1063 { 1064 const gdb_byte *dest_buffer; 1065 CORE_ADDR changed_addr; 1066 int changed_len; 1067 gdb_byte buffer[sizeof (LONGEST)]; 1068 1069 if (value_bitsize (toval)) 1070 { 1071 struct value *parent = value_parent (toval); 1072 1073 changed_addr = value_address (parent) + value_offset (toval); 1074 changed_len = (value_bitpos (toval) 1075 + value_bitsize (toval) 1076 + HOST_CHAR_BIT - 1) 1077 / HOST_CHAR_BIT; 1078 1079 /* If we can read-modify-write exactly the size of the 1080 containing type (e.g. short or int) then do so. This 1081 is safer for volatile bitfields mapped to hardware 1082 registers. */ 1083 if (changed_len < TYPE_LENGTH (type) 1084 && TYPE_LENGTH (type) <= (int) sizeof (LONGEST) 1085 && ((LONGEST) changed_addr % TYPE_LENGTH (type)) == 0) 1086 changed_len = TYPE_LENGTH (type); 1087 1088 if (changed_len > (int) sizeof (LONGEST)) 1089 error (_("Can't handle bitfields which " 1090 "don't fit in a %d bit word."), 1091 (int) sizeof (LONGEST) * HOST_CHAR_BIT); 1092 1093 read_memory (changed_addr, buffer, changed_len); 1094 modify_field (type, buffer, value_as_long (fromval), 1095 value_bitpos (toval), value_bitsize (toval)); 1096 dest_buffer = buffer; 1097 } 1098 else 1099 { 1100 changed_addr = value_address (toval); 1101 changed_len = type_length_units (type); 1102 dest_buffer = value_contents (fromval); 1103 } 1104 1105 write_memory_with_notification (changed_addr, dest_buffer, changed_len); 1106 } 1107 break; 1108 1109 case lval_register: 1110 { 1111 struct frame_info *frame; 1112 struct gdbarch *gdbarch; 1113 int value_reg; 1114 1115 /* Figure out which frame this is in currently. */ 1116 frame = frame_find_by_id (VALUE_FRAME_ID (toval)); 1117 value_reg = VALUE_REGNUM (toval); 1118 1119 if (!frame) 1120 error (_("Value being assigned to is no longer active.")); 1121 1122 gdbarch = get_frame_arch (frame); 1123 1124 if (value_bitsize (toval)) 1125 { 1126 struct value *parent = value_parent (toval); 1127 LONGEST offset = value_offset (parent) + value_offset (toval); 1128 int changed_len; 1129 gdb_byte buffer[sizeof (LONGEST)]; 1130 int optim, unavail; 1131 1132 changed_len = (value_bitpos (toval) 1133 + value_bitsize (toval) 1134 + HOST_CHAR_BIT - 1) 1135 / HOST_CHAR_BIT; 1136 1137 if (changed_len > (int) sizeof (LONGEST)) 1138 error (_("Can't handle bitfields which " 1139 "don't fit in a %d bit word."), 1140 (int) sizeof (LONGEST) * HOST_CHAR_BIT); 1141 1142 if (!get_frame_register_bytes (frame, value_reg, offset, 1143 changed_len, buffer, 1144 &optim, &unavail)) 1145 { 1146 if (optim) 1147 throw_error (OPTIMIZED_OUT_ERROR, 1148 _("value has been optimized out")); 1149 if (unavail) 1150 throw_error (NOT_AVAILABLE_ERROR, 1151 _("value is not available")); 1152 } 1153 1154 modify_field (type, buffer, value_as_long (fromval), 1155 value_bitpos (toval), value_bitsize (toval)); 1156 1157 put_frame_register_bytes (frame, value_reg, offset, 1158 changed_len, buffer); 1159 } 1160 else 1161 { 1162 if (gdbarch_convert_register_p (gdbarch, VALUE_REGNUM (toval), 1163 type)) 1164 { 1165 /* If TOVAL is a special machine register requiring 1166 conversion of program values to a special raw 1167 format. */ 1168 gdbarch_value_to_register (gdbarch, frame, 1169 VALUE_REGNUM (toval), type, 1170 value_contents (fromval)); 1171 } 1172 else 1173 { 1174 put_frame_register_bytes (frame, value_reg, 1175 value_offset (toval), 1176 TYPE_LENGTH (type), 1177 value_contents (fromval)); 1178 } 1179 } 1180 1181 observer_notify_register_changed (frame, value_reg); 1182 break; 1183 } 1184 1185 case lval_computed: 1186 { 1187 const struct lval_funcs *funcs = value_computed_funcs (toval); 1188 1189 if (funcs->write != NULL) 1190 { 1191 funcs->write (toval, fromval); 1192 break; 1193 } 1194 } 1195 /* Fall through. */ 1196 1197 default: 1198 error (_("Left operand of assignment is not an lvalue.")); 1199 } 1200 1201 /* Assigning to the stack pointer, frame pointer, and other 1202 (architecture and calling convention specific) registers may 1203 cause the frame cache and regcache to be out of date. Assigning to memory 1204 also can. We just do this on all assignments to registers or 1205 memory, for simplicity's sake; I doubt the slowdown matters. */ 1206 switch (VALUE_LVAL (toval)) 1207 { 1208 case lval_memory: 1209 case lval_register: 1210 case lval_computed: 1211 1212 observer_notify_target_changed (¤t_target); 1213 1214 /* Having destroyed the frame cache, restore the selected 1215 frame. */ 1216 1217 /* FIXME: cagney/2002-11-02: There has to be a better way of 1218 doing this. Instead of constantly saving/restoring the 1219 frame. Why not create a get_selected_frame() function that, 1220 having saved the selected frame's ID can automatically 1221 re-find the previously selected frame automatically. */ 1222 1223 { 1224 struct frame_info *fi = frame_find_by_id (old_frame); 1225 1226 if (fi != NULL) 1227 select_frame (fi); 1228 } 1229 1230 break; 1231 default: 1232 break; 1233 } 1234 1235 /* If the field does not entirely fill a LONGEST, then zero the sign 1236 bits. If the field is signed, and is negative, then sign 1237 extend. */ 1238 if ((value_bitsize (toval) > 0) 1239 && (value_bitsize (toval) < 8 * (int) sizeof (LONGEST))) 1240 { 1241 LONGEST fieldval = value_as_long (fromval); 1242 LONGEST valmask = (((ULONGEST) 1) << value_bitsize (toval)) - 1; 1243 1244 fieldval &= valmask; 1245 if (!TYPE_UNSIGNED (type) 1246 && (fieldval & (valmask ^ (valmask >> 1)))) 1247 fieldval |= ~valmask; 1248 1249 fromval = value_from_longest (type, fieldval); 1250 } 1251 1252 /* The return value is a copy of TOVAL so it shares its location 1253 information, but its contents are updated from FROMVAL. This 1254 implies the returned value is not lazy, even if TOVAL was. */ 1255 val = value_copy (toval); 1256 set_value_lazy (val, 0); 1257 memcpy (value_contents_raw (val), value_contents (fromval), 1258 TYPE_LENGTH (type)); 1259 1260 /* We copy over the enclosing type and pointed-to offset from FROMVAL 1261 in the case of pointer types. For object types, the enclosing type 1262 and embedded offset must *not* be copied: the target object refered 1263 to by TOVAL retains its original dynamic type after assignment. */ 1264 if (TYPE_CODE (type) == TYPE_CODE_PTR) 1265 { 1266 set_value_enclosing_type (val, value_enclosing_type (fromval)); 1267 set_value_pointed_to_offset (val, value_pointed_to_offset (fromval)); 1268 } 1269 1270 return val; 1271 } 1272 1273 /* Extend a value VAL to COUNT repetitions of its type. */ 1274 1275 struct value * 1276 value_repeat (struct value *arg1, int count) 1277 { 1278 struct value *val; 1279 1280 if (VALUE_LVAL (arg1) != lval_memory) 1281 error (_("Only values in memory can be extended with '@'.")); 1282 if (count < 1) 1283 error (_("Invalid number %d of repetitions."), count); 1284 1285 val = allocate_repeat_value (value_enclosing_type (arg1), count); 1286 1287 VALUE_LVAL (val) = lval_memory; 1288 set_value_address (val, value_address (arg1)); 1289 1290 read_value_memory (val, 0, value_stack (val), value_address (val), 1291 value_contents_all_raw (val), 1292 type_length_units (value_enclosing_type (val))); 1293 1294 return val; 1295 } 1296 1297 struct value * 1298 value_of_variable (struct symbol *var, const struct block *b) 1299 { 1300 struct frame_info *frame = NULL; 1301 1302 if (symbol_read_needs_frame (var)) 1303 frame = get_selected_frame (_("No frame selected.")); 1304 1305 return read_var_value (var, b, frame); 1306 } 1307 1308 struct value * 1309 address_of_variable (struct symbol *var, const struct block *b) 1310 { 1311 struct type *type = SYMBOL_TYPE (var); 1312 struct value *val; 1313 1314 /* Evaluate it first; if the result is a memory address, we're fine. 1315 Lazy evaluation pays off here. */ 1316 1317 val = value_of_variable (var, b); 1318 type = value_type (val); 1319 1320 if ((VALUE_LVAL (val) == lval_memory && value_lazy (val)) 1321 || TYPE_CODE (type) == TYPE_CODE_FUNC) 1322 { 1323 CORE_ADDR addr = value_address (val); 1324 1325 return value_from_pointer (lookup_pointer_type (type), addr); 1326 } 1327 1328 /* Not a memory address; check what the problem was. */ 1329 switch (VALUE_LVAL (val)) 1330 { 1331 case lval_register: 1332 { 1333 struct frame_info *frame; 1334 const char *regname; 1335 1336 frame = frame_find_by_id (VALUE_FRAME_ID (val)); 1337 gdb_assert (frame); 1338 1339 regname = gdbarch_register_name (get_frame_arch (frame), 1340 VALUE_REGNUM (val)); 1341 gdb_assert (regname && *regname); 1342 1343 error (_("Address requested for identifier " 1344 "\"%s\" which is in register $%s"), 1345 SYMBOL_PRINT_NAME (var), regname); 1346 break; 1347 } 1348 1349 default: 1350 error (_("Can't take address of \"%s\" which isn't an lvalue."), 1351 SYMBOL_PRINT_NAME (var)); 1352 break; 1353 } 1354 1355 return val; 1356 } 1357 1358 /* Return one if VAL does not live in target memory, but should in order 1359 to operate on it. Otherwise return zero. */ 1360 1361 int 1362 value_must_coerce_to_target (struct value *val) 1363 { 1364 struct type *valtype; 1365 1366 /* The only lval kinds which do not live in target memory. */ 1367 if (VALUE_LVAL (val) != not_lval 1368 && VALUE_LVAL (val) != lval_internalvar 1369 && VALUE_LVAL (val) != lval_xcallable) 1370 return 0; 1371 1372 valtype = check_typedef (value_type (val)); 1373 1374 switch (TYPE_CODE (valtype)) 1375 { 1376 case TYPE_CODE_ARRAY: 1377 return TYPE_VECTOR (valtype) ? 0 : 1; 1378 case TYPE_CODE_STRING: 1379 return 1; 1380 default: 1381 return 0; 1382 } 1383 } 1384 1385 /* Make sure that VAL lives in target memory if it's supposed to. For 1386 instance, strings are constructed as character arrays in GDB's 1387 storage, and this function copies them to the target. */ 1388 1389 struct value * 1390 value_coerce_to_target (struct value *val) 1391 { 1392 LONGEST length; 1393 CORE_ADDR addr; 1394 1395 if (!value_must_coerce_to_target (val)) 1396 return val; 1397 1398 length = TYPE_LENGTH (check_typedef (value_type (val))); 1399 addr = allocate_space_in_inferior (length); 1400 write_memory (addr, value_contents (val), length); 1401 return value_at_lazy (value_type (val), addr); 1402 } 1403 1404 /* Given a value which is an array, return a value which is a pointer 1405 to its first element, regardless of whether or not the array has a 1406 nonzero lower bound. 1407 1408 FIXME: A previous comment here indicated that this routine should 1409 be substracting the array's lower bound. It's not clear to me that 1410 this is correct. Given an array subscripting operation, it would 1411 certainly work to do the adjustment here, essentially computing: 1412 1413 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0]) 1414 1415 However I believe a more appropriate and logical place to account 1416 for the lower bound is to do so in value_subscript, essentially 1417 computing: 1418 1419 (&array[0] + ((index - lowerbound) * sizeof array[0])) 1420 1421 As further evidence consider what would happen with operations 1422 other than array subscripting, where the caller would get back a 1423 value that had an address somewhere before the actual first element 1424 of the array, and the information about the lower bound would be 1425 lost because of the coercion to pointer type. */ 1426 1427 struct value * 1428 value_coerce_array (struct value *arg1) 1429 { 1430 struct type *type = check_typedef (value_type (arg1)); 1431 1432 /* If the user tries to do something requiring a pointer with an 1433 array that has not yet been pushed to the target, then this would 1434 be a good time to do so. */ 1435 arg1 = value_coerce_to_target (arg1); 1436 1437 if (VALUE_LVAL (arg1) != lval_memory) 1438 error (_("Attempt to take address of value not located in memory.")); 1439 1440 return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)), 1441 value_address (arg1)); 1442 } 1443 1444 /* Given a value which is a function, return a value which is a pointer 1445 to it. */ 1446 1447 struct value * 1448 value_coerce_function (struct value *arg1) 1449 { 1450 struct value *retval; 1451 1452 if (VALUE_LVAL (arg1) != lval_memory) 1453 error (_("Attempt to take address of value not located in memory.")); 1454 1455 retval = value_from_pointer (lookup_pointer_type (value_type (arg1)), 1456 value_address (arg1)); 1457 return retval; 1458 } 1459 1460 /* Return a pointer value for the object for which ARG1 is the 1461 contents. */ 1462 1463 struct value * 1464 value_addr (struct value *arg1) 1465 { 1466 struct value *arg2; 1467 struct type *type = check_typedef (value_type (arg1)); 1468 1469 if (TYPE_CODE (type) == TYPE_CODE_REF) 1470 { 1471 if (value_bits_synthetic_pointer (arg1, value_embedded_offset (arg1), 1472 TARGET_CHAR_BIT * TYPE_LENGTH (type))) 1473 arg1 = coerce_ref (arg1); 1474 else 1475 { 1476 /* Copy the value, but change the type from (T&) to (T*). We 1477 keep the same location information, which is efficient, and 1478 allows &(&X) to get the location containing the reference. 1479 Do the same to its enclosing type for consistency. */ 1480 struct type *type_ptr 1481 = lookup_pointer_type (TYPE_TARGET_TYPE (type)); 1482 struct type *enclosing_type 1483 = check_typedef (value_enclosing_type (arg1)); 1484 struct type *enclosing_type_ptr 1485 = lookup_pointer_type (TYPE_TARGET_TYPE (enclosing_type)); 1486 1487 arg2 = value_copy (arg1); 1488 deprecated_set_value_type (arg2, type_ptr); 1489 set_value_enclosing_type (arg2, enclosing_type_ptr); 1490 1491 return arg2; 1492 } 1493 } 1494 if (TYPE_CODE (type) == TYPE_CODE_FUNC) 1495 return value_coerce_function (arg1); 1496 1497 /* If this is an array that has not yet been pushed to the target, 1498 then this would be a good time to force it to memory. */ 1499 arg1 = value_coerce_to_target (arg1); 1500 1501 if (VALUE_LVAL (arg1) != lval_memory) 1502 error (_("Attempt to take address of value not located in memory.")); 1503 1504 /* Get target memory address. */ 1505 arg2 = value_from_pointer (lookup_pointer_type (value_type (arg1)), 1506 (value_address (arg1) 1507 + value_embedded_offset (arg1))); 1508 1509 /* This may be a pointer to a base subobject; so remember the 1510 full derived object's type ... */ 1511 set_value_enclosing_type (arg2, 1512 lookup_pointer_type (value_enclosing_type (arg1))); 1513 /* ... and also the relative position of the subobject in the full 1514 object. */ 1515 set_value_pointed_to_offset (arg2, value_embedded_offset (arg1)); 1516 return arg2; 1517 } 1518 1519 /* Return a reference value for the object for which ARG1 is the 1520 contents. */ 1521 1522 struct value * 1523 value_ref (struct value *arg1) 1524 { 1525 struct value *arg2; 1526 struct type *type = check_typedef (value_type (arg1)); 1527 1528 if (TYPE_CODE (type) == TYPE_CODE_REF) 1529 return arg1; 1530 1531 arg2 = value_addr (arg1); 1532 deprecated_set_value_type (arg2, lookup_reference_type (type)); 1533 return arg2; 1534 } 1535 1536 /* Given a value of a pointer type, apply the C unary * operator to 1537 it. */ 1538 1539 struct value * 1540 value_ind (struct value *arg1) 1541 { 1542 struct type *base_type; 1543 struct value *arg2; 1544 1545 arg1 = coerce_array (arg1); 1546 1547 base_type = check_typedef (value_type (arg1)); 1548 1549 if (VALUE_LVAL (arg1) == lval_computed) 1550 { 1551 const struct lval_funcs *funcs = value_computed_funcs (arg1); 1552 1553 if (funcs->indirect) 1554 { 1555 struct value *result = funcs->indirect (arg1); 1556 1557 if (result) 1558 return result; 1559 } 1560 } 1561 1562 if (TYPE_CODE (base_type) == TYPE_CODE_PTR) 1563 { 1564 struct type *enc_type; 1565 1566 /* We may be pointing to something embedded in a larger object. 1567 Get the real type of the enclosing object. */ 1568 enc_type = check_typedef (value_enclosing_type (arg1)); 1569 enc_type = TYPE_TARGET_TYPE (enc_type); 1570 1571 if (TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_FUNC 1572 || TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_METHOD) 1573 /* For functions, go through find_function_addr, which knows 1574 how to handle function descriptors. */ 1575 arg2 = value_at_lazy (enc_type, 1576 find_function_addr (arg1, NULL)); 1577 else 1578 /* Retrieve the enclosing object pointed to. */ 1579 arg2 = value_at_lazy (enc_type, 1580 (value_as_address (arg1) 1581 - value_pointed_to_offset (arg1))); 1582 1583 enc_type = value_type (arg2); 1584 return readjust_indirect_value_type (arg2, enc_type, base_type, arg1); 1585 } 1586 1587 error (_("Attempt to take contents of a non-pointer value.")); 1588 return 0; /* For lint -- never reached. */ 1589 } 1590 1591 /* Create a value for an array by allocating space in GDB, copying the 1592 data into that space, and then setting up an array value. 1593 1594 The array bounds are set from LOWBOUND and HIGHBOUND, and the array 1595 is populated from the values passed in ELEMVEC. 1596 1597 The element type of the array is inherited from the type of the 1598 first element, and all elements must have the same size (though we 1599 don't currently enforce any restriction on their types). */ 1600 1601 struct value * 1602 value_array (int lowbound, int highbound, struct value **elemvec) 1603 { 1604 int nelem; 1605 int idx; 1606 ULONGEST typelength; 1607 struct value *val; 1608 struct type *arraytype; 1609 1610 /* Validate that the bounds are reasonable and that each of the 1611 elements have the same size. */ 1612 1613 nelem = highbound - lowbound + 1; 1614 if (nelem <= 0) 1615 { 1616 error (_("bad array bounds (%d, %d)"), lowbound, highbound); 1617 } 1618 typelength = type_length_units (value_enclosing_type (elemvec[0])); 1619 for (idx = 1; idx < nelem; idx++) 1620 { 1621 if (type_length_units (value_enclosing_type (elemvec[idx])) 1622 != typelength) 1623 { 1624 error (_("array elements must all be the same size")); 1625 } 1626 } 1627 1628 arraytype = lookup_array_range_type (value_enclosing_type (elemvec[0]), 1629 lowbound, highbound); 1630 1631 if (!current_language->c_style_arrays) 1632 { 1633 val = allocate_value (arraytype); 1634 for (idx = 0; idx < nelem; idx++) 1635 value_contents_copy (val, idx * typelength, elemvec[idx], 0, 1636 typelength); 1637 return val; 1638 } 1639 1640 /* Allocate space to store the array, and then initialize it by 1641 copying in each element. */ 1642 1643 val = allocate_value (arraytype); 1644 for (idx = 0; idx < nelem; idx++) 1645 value_contents_copy (val, idx * typelength, elemvec[idx], 0, typelength); 1646 return val; 1647 } 1648 1649 struct value * 1650 value_cstring (const char *ptr, ssize_t len, struct type *char_type) 1651 { 1652 struct value *val; 1653 int lowbound = current_language->string_lower_bound; 1654 ssize_t highbound = len / TYPE_LENGTH (char_type); 1655 struct type *stringtype 1656 = lookup_array_range_type (char_type, lowbound, highbound + lowbound - 1); 1657 1658 val = allocate_value (stringtype); 1659 memcpy (value_contents_raw (val), ptr, len); 1660 return val; 1661 } 1662 1663 /* Create a value for a string constant by allocating space in the 1664 inferior, copying the data into that space, and returning the 1665 address with type TYPE_CODE_STRING. PTR points to the string 1666 constant data; LEN is number of characters. 1667 1668 Note that string types are like array of char types with a lower 1669 bound of zero and an upper bound of LEN - 1. Also note that the 1670 string may contain embedded null bytes. */ 1671 1672 struct value * 1673 value_string (const char *ptr, ssize_t len, struct type *char_type) 1674 { 1675 struct value *val; 1676 int lowbound = current_language->string_lower_bound; 1677 ssize_t highbound = len / TYPE_LENGTH (char_type); 1678 struct type *stringtype 1679 = lookup_string_range_type (char_type, lowbound, highbound + lowbound - 1); 1680 1681 val = allocate_value (stringtype); 1682 memcpy (value_contents_raw (val), ptr, len); 1683 return val; 1684 } 1685 1686 1687 /* See if we can pass arguments in T2 to a function which takes 1688 arguments of types T1. T1 is a list of NARGS arguments, and T2 is 1689 a NULL-terminated vector. If some arguments need coercion of some 1690 sort, then the coerced values are written into T2. Return value is 1691 0 if the arguments could be matched, or the position at which they 1692 differ if not. 1693 1694 STATICP is nonzero if the T1 argument list came from a static 1695 member function. T2 will still include the ``this'' pointer, but 1696 it will be skipped. 1697 1698 For non-static member functions, we ignore the first argument, 1699 which is the type of the instance variable. This is because we 1700 want to handle calls with objects from derived classes. This is 1701 not entirely correct: we should actually check to make sure that a 1702 requested operation is type secure, shouldn't we? FIXME. */ 1703 1704 static int 1705 typecmp (int staticp, int varargs, int nargs, 1706 struct field t1[], struct value *t2[]) 1707 { 1708 int i; 1709 1710 if (t2 == 0) 1711 internal_error (__FILE__, __LINE__, 1712 _("typecmp: no argument list")); 1713 1714 /* Skip ``this'' argument if applicable. T2 will always include 1715 THIS. */ 1716 if (staticp) 1717 t2 ++; 1718 1719 for (i = 0; 1720 (i < nargs) && TYPE_CODE (t1[i].type) != TYPE_CODE_VOID; 1721 i++) 1722 { 1723 struct type *tt1, *tt2; 1724 1725 if (!t2[i]) 1726 return i + 1; 1727 1728 tt1 = check_typedef (t1[i].type); 1729 tt2 = check_typedef (value_type (t2[i])); 1730 1731 if (TYPE_CODE (tt1) == TYPE_CODE_REF 1732 /* We should be doing hairy argument matching, as below. */ 1733 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1))) 1734 == TYPE_CODE (tt2))) 1735 { 1736 if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY) 1737 t2[i] = value_coerce_array (t2[i]); 1738 else 1739 t2[i] = value_ref (t2[i]); 1740 continue; 1741 } 1742 1743 /* djb - 20000715 - Until the new type structure is in the 1744 place, and we can attempt things like implicit conversions, 1745 we need to do this so you can take something like a map<const 1746 char *>, and properly access map["hello"], because the 1747 argument to [] will be a reference to a pointer to a char, 1748 and the argument will be a pointer to a char. */ 1749 while (TYPE_CODE(tt1) == TYPE_CODE_REF 1750 || TYPE_CODE (tt1) == TYPE_CODE_PTR) 1751 { 1752 tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) ); 1753 } 1754 while (TYPE_CODE(tt2) == TYPE_CODE_ARRAY 1755 || TYPE_CODE(tt2) == TYPE_CODE_PTR 1756 || TYPE_CODE(tt2) == TYPE_CODE_REF) 1757 { 1758 tt2 = check_typedef (TYPE_TARGET_TYPE(tt2)); 1759 } 1760 if (TYPE_CODE (tt1) == TYPE_CODE (tt2)) 1761 continue; 1762 /* Array to pointer is a `trivial conversion' according to the 1763 ARM. */ 1764 1765 /* We should be doing much hairier argument matching (see 1766 section 13.2 of the ARM), but as a quick kludge, just check 1767 for the same type code. */ 1768 if (TYPE_CODE (t1[i].type) != TYPE_CODE (value_type (t2[i]))) 1769 return i + 1; 1770 } 1771 if (varargs || t2[i] == NULL) 1772 return 0; 1773 return i + 1; 1774 } 1775 1776 /* Helper class for do_search_struct_field that updates *RESULT_PTR 1777 and *LAST_BOFFSET, and possibly throws an exception if the field 1778 search has yielded ambiguous results. */ 1779 1780 static void 1781 update_search_result (struct value **result_ptr, struct value *v, 1782 LONGEST *last_boffset, LONGEST boffset, 1783 const char *name, struct type *type) 1784 { 1785 if (v != NULL) 1786 { 1787 if (*result_ptr != NULL 1788 /* The result is not ambiguous if all the classes that are 1789 found occupy the same space. */ 1790 && *last_boffset != boffset) 1791 error (_("base class '%s' is ambiguous in type '%s'"), 1792 name, TYPE_SAFE_NAME (type)); 1793 *result_ptr = v; 1794 *last_boffset = boffset; 1795 } 1796 } 1797 1798 /* A helper for search_struct_field. This does all the work; most 1799 arguments are as passed to search_struct_field. The result is 1800 stored in *RESULT_PTR, which must be initialized to NULL. 1801 OUTERMOST_TYPE is the type of the initial type passed to 1802 search_struct_field; this is used for error reporting when the 1803 lookup is ambiguous. */ 1804 1805 static void 1806 do_search_struct_field (const char *name, struct value *arg1, LONGEST offset, 1807 struct type *type, int looking_for_baseclass, 1808 struct value **result_ptr, 1809 LONGEST *last_boffset, 1810 struct type *outermost_type) 1811 { 1812 int i; 1813 int nbases; 1814 1815 type = check_typedef (type); 1816 nbases = TYPE_N_BASECLASSES (type); 1817 1818 if (!looking_for_baseclass) 1819 for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--) 1820 { 1821 const char *t_field_name = TYPE_FIELD_NAME (type, i); 1822 1823 if (t_field_name && (strcmp_iw (t_field_name, name) == 0)) 1824 { 1825 struct value *v; 1826 1827 if (field_is_static (&TYPE_FIELD (type, i))) 1828 v = value_static_field (type, i); 1829 else 1830 v = value_primitive_field (arg1, offset, i, type); 1831 *result_ptr = v; 1832 return; 1833 } 1834 1835 if (t_field_name 1836 && t_field_name[0] == '\0') 1837 { 1838 struct type *field_type = TYPE_FIELD_TYPE (type, i); 1839 1840 if (TYPE_CODE (field_type) == TYPE_CODE_UNION 1841 || TYPE_CODE (field_type) == TYPE_CODE_STRUCT) 1842 { 1843 /* Look for a match through the fields of an anonymous 1844 union, or anonymous struct. C++ provides anonymous 1845 unions. 1846 1847 In the GNU Chill (now deleted from GDB) 1848 implementation of variant record types, each 1849 <alternative field> has an (anonymous) union type, 1850 each member of the union represents a <variant 1851 alternative>. Each <variant alternative> is 1852 represented as a struct, with a member for each 1853 <variant field>. */ 1854 1855 struct value *v = NULL; 1856 LONGEST new_offset = offset; 1857 1858 /* This is pretty gross. In G++, the offset in an 1859 anonymous union is relative to the beginning of the 1860 enclosing struct. In the GNU Chill (now deleted 1861 from GDB) implementation of variant records, the 1862 bitpos is zero in an anonymous union field, so we 1863 have to add the offset of the union here. */ 1864 if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT 1865 || (TYPE_NFIELDS (field_type) > 0 1866 && TYPE_FIELD_BITPOS (field_type, 0) == 0)) 1867 new_offset += TYPE_FIELD_BITPOS (type, i) / 8; 1868 1869 do_search_struct_field (name, arg1, new_offset, 1870 field_type, 1871 looking_for_baseclass, &v, 1872 last_boffset, 1873 outermost_type); 1874 if (v) 1875 { 1876 *result_ptr = v; 1877 return; 1878 } 1879 } 1880 } 1881 } 1882 1883 for (i = 0; i < nbases; i++) 1884 { 1885 struct value *v = NULL; 1886 struct type *basetype = check_typedef (TYPE_BASECLASS (type, i)); 1887 /* If we are looking for baseclasses, this is what we get when 1888 we hit them. But it could happen that the base part's member 1889 name is not yet filled in. */ 1890 int found_baseclass = (looking_for_baseclass 1891 && TYPE_BASECLASS_NAME (type, i) != NULL 1892 && (strcmp_iw (name, 1893 TYPE_BASECLASS_NAME (type, 1894 i)) == 0)); 1895 LONGEST boffset = value_embedded_offset (arg1) + offset; 1896 1897 if (BASETYPE_VIA_VIRTUAL (type, i)) 1898 { 1899 struct value *v2; 1900 1901 boffset = baseclass_offset (type, i, 1902 value_contents_for_printing (arg1), 1903 value_embedded_offset (arg1) + offset, 1904 value_address (arg1), 1905 arg1); 1906 1907 /* The virtual base class pointer might have been clobbered 1908 by the user program. Make sure that it still points to a 1909 valid memory location. */ 1910 1911 boffset += value_embedded_offset (arg1) + offset; 1912 if (boffset < 0 1913 || boffset >= TYPE_LENGTH (value_enclosing_type (arg1))) 1914 { 1915 CORE_ADDR base_addr; 1916 1917 base_addr = value_address (arg1) + boffset; 1918 v2 = value_at_lazy (basetype, base_addr); 1919 if (target_read_memory (base_addr, 1920 value_contents_raw (v2), 1921 TYPE_LENGTH (value_type (v2))) != 0) 1922 error (_("virtual baseclass botch")); 1923 } 1924 else 1925 { 1926 v2 = value_copy (arg1); 1927 deprecated_set_value_type (v2, basetype); 1928 set_value_embedded_offset (v2, boffset); 1929 } 1930 1931 if (found_baseclass) 1932 v = v2; 1933 else 1934 { 1935 do_search_struct_field (name, v2, 0, 1936 TYPE_BASECLASS (type, i), 1937 looking_for_baseclass, 1938 result_ptr, last_boffset, 1939 outermost_type); 1940 } 1941 } 1942 else if (found_baseclass) 1943 v = value_primitive_field (arg1, offset, i, type); 1944 else 1945 { 1946 do_search_struct_field (name, arg1, 1947 offset + TYPE_BASECLASS_BITPOS (type, 1948 i) / 8, 1949 basetype, looking_for_baseclass, 1950 result_ptr, last_boffset, 1951 outermost_type); 1952 } 1953 1954 update_search_result (result_ptr, v, last_boffset, 1955 boffset, name, outermost_type); 1956 } 1957 } 1958 1959 /* Helper function used by value_struct_elt to recurse through 1960 baseclasses. Look for a field NAME in ARG1. Search in it assuming 1961 it has (class) type TYPE. If found, return value, else return NULL. 1962 1963 If LOOKING_FOR_BASECLASS, then instead of looking for struct 1964 fields, look for a baseclass named NAME. */ 1965 1966 static struct value * 1967 search_struct_field (const char *name, struct value *arg1, 1968 struct type *type, int looking_for_baseclass) 1969 { 1970 struct value *result = NULL; 1971 LONGEST boffset = 0; 1972 1973 do_search_struct_field (name, arg1, 0, type, looking_for_baseclass, 1974 &result, &boffset, type); 1975 return result; 1976 } 1977 1978 /* Helper function used by value_struct_elt to recurse through 1979 baseclasses. Look for a field NAME in ARG1. Adjust the address of 1980 ARG1 by OFFSET bytes, and search in it assuming it has (class) type 1981 TYPE. 1982 1983 If found, return value, else if name matched and args not return 1984 (value) -1, else return NULL. */ 1985 1986 static struct value * 1987 search_struct_method (const char *name, struct value **arg1p, 1988 struct value **args, LONGEST offset, 1989 int *static_memfuncp, struct type *type) 1990 { 1991 int i; 1992 struct value *v; 1993 int name_matched = 0; 1994 char dem_opname[64]; 1995 1996 type = check_typedef (type); 1997 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--) 1998 { 1999 const char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i); 2000 2001 /* FIXME! May need to check for ARM demangling here. */ 2002 if (startswith (t_field_name, "__") || 2003 startswith (t_field_name, "op") || 2004 startswith (t_field_name, "type")) 2005 { 2006 if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI)) 2007 t_field_name = dem_opname; 2008 else if (cplus_demangle_opname (t_field_name, dem_opname, 0)) 2009 t_field_name = dem_opname; 2010 } 2011 if (t_field_name && (strcmp_iw (t_field_name, name) == 0)) 2012 { 2013 int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1; 2014 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i); 2015 2016 name_matched = 1; 2017 check_stub_method_group (type, i); 2018 if (j > 0 && args == 0) 2019 error (_("cannot resolve overloaded method " 2020 "`%s': no arguments supplied"), name); 2021 else if (j == 0 && args == 0) 2022 { 2023 v = value_fn_field (arg1p, f, j, type, offset); 2024 if (v != NULL) 2025 return v; 2026 } 2027 else 2028 while (j >= 0) 2029 { 2030 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j), 2031 TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f, j)), 2032 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, j)), 2033 TYPE_FN_FIELD_ARGS (f, j), args)) 2034 { 2035 if (TYPE_FN_FIELD_VIRTUAL_P (f, j)) 2036 return value_virtual_fn_field (arg1p, f, j, 2037 type, offset); 2038 if (TYPE_FN_FIELD_STATIC_P (f, j) 2039 && static_memfuncp) 2040 *static_memfuncp = 1; 2041 v = value_fn_field (arg1p, f, j, type, offset); 2042 if (v != NULL) 2043 return v; 2044 } 2045 j--; 2046 } 2047 } 2048 } 2049 2050 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--) 2051 { 2052 LONGEST base_offset; 2053 LONGEST this_offset; 2054 2055 if (BASETYPE_VIA_VIRTUAL (type, i)) 2056 { 2057 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i)); 2058 struct value *base_val; 2059 const gdb_byte *base_valaddr; 2060 2061 /* The virtual base class pointer might have been 2062 clobbered by the user program. Make sure that it 2063 still points to a valid memory location. */ 2064 2065 if (offset < 0 || offset >= TYPE_LENGTH (type)) 2066 { 2067 gdb_byte *tmp; 2068 struct cleanup *back_to; 2069 CORE_ADDR address; 2070 2071 tmp = (gdb_byte *) xmalloc (TYPE_LENGTH (baseclass)); 2072 back_to = make_cleanup (xfree, tmp); 2073 address = value_address (*arg1p); 2074 2075 if (target_read_memory (address + offset, 2076 tmp, TYPE_LENGTH (baseclass)) != 0) 2077 error (_("virtual baseclass botch")); 2078 2079 base_val = value_from_contents_and_address (baseclass, 2080 tmp, 2081 address + offset); 2082 base_valaddr = value_contents_for_printing (base_val); 2083 this_offset = 0; 2084 do_cleanups (back_to); 2085 } 2086 else 2087 { 2088 base_val = *arg1p; 2089 base_valaddr = value_contents_for_printing (*arg1p); 2090 this_offset = offset; 2091 } 2092 2093 base_offset = baseclass_offset (type, i, base_valaddr, 2094 this_offset, value_address (base_val), 2095 base_val); 2096 } 2097 else 2098 { 2099 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8; 2100 } 2101 v = search_struct_method (name, arg1p, args, base_offset + offset, 2102 static_memfuncp, TYPE_BASECLASS (type, i)); 2103 if (v == (struct value *) - 1) 2104 { 2105 name_matched = 1; 2106 } 2107 else if (v) 2108 { 2109 /* FIXME-bothner: Why is this commented out? Why is it here? */ 2110 /* *arg1p = arg1_tmp; */ 2111 return v; 2112 } 2113 } 2114 if (name_matched) 2115 return (struct value *) - 1; 2116 else 2117 return NULL; 2118 } 2119 2120 /* Given *ARGP, a value of type (pointer to a)* structure/union, 2121 extract the component named NAME from the ultimate target 2122 structure/union and return it as a value with its appropriate type. 2123 ERR is used in the error message if *ARGP's type is wrong. 2124 2125 C++: ARGS is a list of argument types to aid in the selection of 2126 an appropriate method. Also, handle derived types. 2127 2128 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location 2129 where the truthvalue of whether the function that was resolved was 2130 a static member function or not is stored. 2131 2132 ERR is an error message to be printed in case the field is not 2133 found. */ 2134 2135 struct value * 2136 value_struct_elt (struct value **argp, struct value **args, 2137 const char *name, int *static_memfuncp, const char *err) 2138 { 2139 struct type *t; 2140 struct value *v; 2141 2142 *argp = coerce_array (*argp); 2143 2144 t = check_typedef (value_type (*argp)); 2145 2146 /* Follow pointers until we get to a non-pointer. */ 2147 2148 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF) 2149 { 2150 *argp = value_ind (*argp); 2151 /* Don't coerce fn pointer to fn and then back again! */ 2152 if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC) 2153 *argp = coerce_array (*argp); 2154 t = check_typedef (value_type (*argp)); 2155 } 2156 2157 if (TYPE_CODE (t) != TYPE_CODE_STRUCT 2158 && TYPE_CODE (t) != TYPE_CODE_UNION) 2159 error (_("Attempt to extract a component of a value that is not a %s."), 2160 err); 2161 2162 /* Assume it's not, unless we see that it is. */ 2163 if (static_memfuncp) 2164 *static_memfuncp = 0; 2165 2166 if (!args) 2167 { 2168 /* if there are no arguments ...do this... */ 2169 2170 /* Try as a field first, because if we succeed, there is less 2171 work to be done. */ 2172 v = search_struct_field (name, *argp, t, 0); 2173 if (v) 2174 return v; 2175 2176 /* C++: If it was not found as a data field, then try to 2177 return it as a pointer to a method. */ 2178 v = search_struct_method (name, argp, args, 0, 2179 static_memfuncp, t); 2180 2181 if (v == (struct value *) - 1) 2182 error (_("Cannot take address of method %s."), name); 2183 else if (v == 0) 2184 { 2185 if (TYPE_NFN_FIELDS (t)) 2186 error (_("There is no member or method named %s."), name); 2187 else 2188 error (_("There is no member named %s."), name); 2189 } 2190 return v; 2191 } 2192 2193 v = search_struct_method (name, argp, args, 0, 2194 static_memfuncp, t); 2195 2196 if (v == (struct value *) - 1) 2197 { 2198 error (_("One of the arguments you tried to pass to %s could not " 2199 "be converted to what the function wants."), name); 2200 } 2201 else if (v == 0) 2202 { 2203 /* See if user tried to invoke data as function. If so, hand it 2204 back. If it's not callable (i.e., a pointer to function), 2205 gdb should give an error. */ 2206 v = search_struct_field (name, *argp, t, 0); 2207 /* If we found an ordinary field, then it is not a method call. 2208 So, treat it as if it were a static member function. */ 2209 if (v && static_memfuncp) 2210 *static_memfuncp = 1; 2211 } 2212 2213 if (!v) 2214 throw_error (NOT_FOUND_ERROR, 2215 _("Structure has no component named %s."), name); 2216 return v; 2217 } 2218 2219 /* Given *ARGP, a value of type structure or union, or a pointer/reference 2220 to a structure or union, extract and return its component (field) of 2221 type FTYPE at the specified BITPOS. 2222 Throw an exception on error. */ 2223 2224 struct value * 2225 value_struct_elt_bitpos (struct value **argp, int bitpos, struct type *ftype, 2226 const char *err) 2227 { 2228 struct type *t; 2229 int i; 2230 2231 *argp = coerce_array (*argp); 2232 2233 t = check_typedef (value_type (*argp)); 2234 2235 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF) 2236 { 2237 *argp = value_ind (*argp); 2238 if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC) 2239 *argp = coerce_array (*argp); 2240 t = check_typedef (value_type (*argp)); 2241 } 2242 2243 if (TYPE_CODE (t) != TYPE_CODE_STRUCT 2244 && TYPE_CODE (t) != TYPE_CODE_UNION) 2245 error (_("Attempt to extract a component of a value that is not a %s."), 2246 err); 2247 2248 for (i = TYPE_N_BASECLASSES (t); i < TYPE_NFIELDS (t); i++) 2249 { 2250 if (!field_is_static (&TYPE_FIELD (t, i)) 2251 && bitpos == TYPE_FIELD_BITPOS (t, i) 2252 && types_equal (ftype, TYPE_FIELD_TYPE (t, i))) 2253 return value_primitive_field (*argp, 0, i, t); 2254 } 2255 2256 error (_("No field with matching bitpos and type.")); 2257 2258 /* Never hit. */ 2259 return NULL; 2260 } 2261 2262 /* Search through the methods of an object (and its bases) to find a 2263 specified method. Return the pointer to the fn_field list FN_LIST of 2264 overloaded instances defined in the source language. If available 2265 and matching, a vector of matching xmethods defined in extension 2266 languages are also returned in XM_WORKER_VEC 2267 2268 Helper function for value_find_oload_list. 2269 ARGP is a pointer to a pointer to a value (the object). 2270 METHOD is a string containing the method name. 2271 OFFSET is the offset within the value. 2272 TYPE is the assumed type of the object. 2273 FN_LIST is the pointer to matching overloaded instances defined in 2274 source language. Since this is a recursive function, *FN_LIST 2275 should be set to NULL when calling this function. 2276 NUM_FNS is the number of overloaded instances. *NUM_FNS should be set to 2277 0 when calling this function. 2278 XM_WORKER_VEC is the vector of matching xmethod workers. *XM_WORKER_VEC 2279 should also be set to NULL when calling this function. 2280 BASETYPE is set to the actual type of the subobject where the 2281 method is found. 2282 BOFFSET is the offset of the base subobject where the method is found. */ 2283 2284 static void 2285 find_method_list (struct value **argp, const char *method, 2286 LONGEST offset, struct type *type, 2287 struct fn_field **fn_list, int *num_fns, 2288 VEC (xmethod_worker_ptr) **xm_worker_vec, 2289 struct type **basetype, LONGEST *boffset) 2290 { 2291 int i; 2292 struct fn_field *f = NULL; 2293 VEC (xmethod_worker_ptr) *worker_vec = NULL, *new_vec = NULL; 2294 2295 gdb_assert (fn_list != NULL && xm_worker_vec != NULL); 2296 type = check_typedef (type); 2297 2298 /* First check in object itself. 2299 This function is called recursively to search through base classes. 2300 If there is a source method match found at some stage, then we need not 2301 look for source methods in consequent recursive calls. */ 2302 if ((*fn_list) == NULL) 2303 { 2304 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--) 2305 { 2306 /* pai: FIXME What about operators and type conversions? */ 2307 const char *fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i); 2308 2309 if (fn_field_name && (strcmp_iw (fn_field_name, method) == 0)) 2310 { 2311 int len = TYPE_FN_FIELDLIST_LENGTH (type, i); 2312 f = TYPE_FN_FIELDLIST1 (type, i); 2313 *fn_list = f; 2314 2315 *num_fns = len; 2316 *basetype = type; 2317 *boffset = offset; 2318 2319 /* Resolve any stub methods. */ 2320 check_stub_method_group (type, i); 2321 2322 break; 2323 } 2324 } 2325 } 2326 2327 /* Unlike source methods, xmethods can be accumulated over successive 2328 recursive calls. In other words, an xmethod named 'm' in a class 2329 will not hide an xmethod named 'm' in its base class(es). We want 2330 it to be this way because xmethods are after all convenience functions 2331 and hence there is no point restricting them with something like method 2332 hiding. Moreover, if hiding is done for xmethods as well, then we will 2333 have to provide a mechanism to un-hide (like the 'using' construct). */ 2334 worker_vec = get_matching_xmethod_workers (type, method); 2335 new_vec = VEC_merge (xmethod_worker_ptr, *xm_worker_vec, worker_vec); 2336 2337 VEC_free (xmethod_worker_ptr, *xm_worker_vec); 2338 VEC_free (xmethod_worker_ptr, worker_vec); 2339 *xm_worker_vec = new_vec; 2340 2341 /* If source methods are not found in current class, look for them in the 2342 base classes. We also have to go through the base classes to gather 2343 extension methods. */ 2344 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--) 2345 { 2346 LONGEST base_offset; 2347 2348 if (BASETYPE_VIA_VIRTUAL (type, i)) 2349 { 2350 base_offset = baseclass_offset (type, i, 2351 value_contents_for_printing (*argp), 2352 value_offset (*argp) + offset, 2353 value_address (*argp), *argp); 2354 } 2355 else /* Non-virtual base, simply use bit position from debug 2356 info. */ 2357 { 2358 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8; 2359 } 2360 2361 find_method_list (argp, method, base_offset + offset, 2362 TYPE_BASECLASS (type, i), fn_list, num_fns, 2363 xm_worker_vec, basetype, boffset); 2364 } 2365 } 2366 2367 /* Return the list of overloaded methods of a specified name. The methods 2368 could be those GDB finds in the binary, or xmethod. Methods found in 2369 the binary are returned in FN_LIST, and xmethods are returned in 2370 XM_WORKER_VEC. 2371 2372 ARGP is a pointer to a pointer to a value (the object). 2373 METHOD is the method name. 2374 OFFSET is the offset within the value contents. 2375 FN_LIST is the pointer to matching overloaded instances defined in 2376 source language. 2377 NUM_FNS is the number of overloaded instances. 2378 XM_WORKER_VEC is the vector of matching xmethod workers defined in 2379 extension languages. 2380 BASETYPE is set to the type of the base subobject that defines the 2381 method. 2382 BOFFSET is the offset of the base subobject which defines the method. */ 2383 2384 static void 2385 value_find_oload_method_list (struct value **argp, const char *method, 2386 LONGEST offset, struct fn_field **fn_list, 2387 int *num_fns, 2388 VEC (xmethod_worker_ptr) **xm_worker_vec, 2389 struct type **basetype, LONGEST *boffset) 2390 { 2391 struct type *t; 2392 2393 t = check_typedef (value_type (*argp)); 2394 2395 /* Code snarfed from value_struct_elt. */ 2396 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF) 2397 { 2398 *argp = value_ind (*argp); 2399 /* Don't coerce fn pointer to fn and then back again! */ 2400 if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC) 2401 *argp = coerce_array (*argp); 2402 t = check_typedef (value_type (*argp)); 2403 } 2404 2405 if (TYPE_CODE (t) != TYPE_CODE_STRUCT 2406 && TYPE_CODE (t) != TYPE_CODE_UNION) 2407 error (_("Attempt to extract a component of a " 2408 "value that is not a struct or union")); 2409 2410 gdb_assert (fn_list != NULL && xm_worker_vec != NULL); 2411 2412 /* Clear the lists. */ 2413 *fn_list = NULL; 2414 *num_fns = 0; 2415 *xm_worker_vec = NULL; 2416 2417 find_method_list (argp, method, 0, t, fn_list, num_fns, xm_worker_vec, 2418 basetype, boffset); 2419 } 2420 2421 /* Given an array of arguments (ARGS) (which includes an 2422 entry for "this" in the case of C++ methods), the number of 2423 arguments NARGS, the NAME of a function, and whether it's a method or 2424 not (METHOD), find the best function that matches on the argument types 2425 according to the overload resolution rules. 2426 2427 METHOD can be one of three values: 2428 NON_METHOD for non-member functions. 2429 METHOD: for member functions. 2430 BOTH: used for overload resolution of operators where the 2431 candidates are expected to be either member or non member 2432 functions. In this case the first argument ARGTYPES 2433 (representing 'this') is expected to be a reference to the 2434 target object, and will be dereferenced when attempting the 2435 non-member search. 2436 2437 In the case of class methods, the parameter OBJ is an object value 2438 in which to search for overloaded methods. 2439 2440 In the case of non-method functions, the parameter FSYM is a symbol 2441 corresponding to one of the overloaded functions. 2442 2443 Return value is an integer: 0 -> good match, 10 -> debugger applied 2444 non-standard coercions, 100 -> incompatible. 2445 2446 If a method is being searched for, VALP will hold the value. 2447 If a non-method is being searched for, SYMP will hold the symbol 2448 for it. 2449 2450 If a method is being searched for, and it is a static method, 2451 then STATICP will point to a non-zero value. 2452 2453 If NO_ADL argument dependent lookup is disabled. This is used to prevent 2454 ADL overload candidates when performing overload resolution for a fully 2455 qualified name. 2456 2457 If NOSIDE is EVAL_AVOID_SIDE_EFFECTS, then OBJP's memory cannot be 2458 read while picking the best overload match (it may be all zeroes and thus 2459 not have a vtable pointer), in which case skip virtual function lookup. 2460 This is ok as typically EVAL_AVOID_SIDE_EFFECTS is only used to determine 2461 the result type. 2462 2463 Note: This function does *not* check the value of 2464 overload_resolution. Caller must check it to see whether overload 2465 resolution is permitted. */ 2466 2467 int 2468 find_overload_match (struct value **args, int nargs, 2469 const char *name, enum oload_search_type method, 2470 struct value **objp, struct symbol *fsym, 2471 struct value **valp, struct symbol **symp, 2472 int *staticp, const int no_adl, 2473 const enum noside noside) 2474 { 2475 struct value *obj = (objp ? *objp : NULL); 2476 struct type *obj_type = obj ? value_type (obj) : NULL; 2477 /* Index of best overloaded function. */ 2478 int func_oload_champ = -1; 2479 int method_oload_champ = -1; 2480 int src_method_oload_champ = -1; 2481 int ext_method_oload_champ = -1; 2482 2483 /* The measure for the current best match. */ 2484 struct badness_vector *method_badness = NULL; 2485 struct badness_vector *func_badness = NULL; 2486 struct badness_vector *ext_method_badness = NULL; 2487 struct badness_vector *src_method_badness = NULL; 2488 2489 struct value *temp = obj; 2490 /* For methods, the list of overloaded methods. */ 2491 struct fn_field *fns_ptr = NULL; 2492 /* For non-methods, the list of overloaded function symbols. */ 2493 struct symbol **oload_syms = NULL; 2494 /* For xmethods, the VEC of xmethod workers. */ 2495 VEC (xmethod_worker_ptr) *xm_worker_vec = NULL; 2496 /* Number of overloaded instances being considered. */ 2497 int num_fns = 0; 2498 struct type *basetype = NULL; 2499 LONGEST boffset; 2500 2501 struct cleanup *all_cleanups = make_cleanup (null_cleanup, NULL); 2502 2503 const char *obj_type_name = NULL; 2504 const char *func_name = NULL; 2505 enum oload_classification match_quality; 2506 enum oload_classification method_match_quality = INCOMPATIBLE; 2507 enum oload_classification src_method_match_quality = INCOMPATIBLE; 2508 enum oload_classification ext_method_match_quality = INCOMPATIBLE; 2509 enum oload_classification func_match_quality = INCOMPATIBLE; 2510 2511 /* Get the list of overloaded methods or functions. */ 2512 if (method == METHOD || method == BOTH) 2513 { 2514 gdb_assert (obj); 2515 2516 /* OBJ may be a pointer value rather than the object itself. */ 2517 obj = coerce_ref (obj); 2518 while (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_PTR) 2519 obj = coerce_ref (value_ind (obj)); 2520 obj_type_name = TYPE_NAME (value_type (obj)); 2521 2522 /* First check whether this is a data member, e.g. a pointer to 2523 a function. */ 2524 if (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_STRUCT) 2525 { 2526 *valp = search_struct_field (name, obj, 2527 check_typedef (value_type (obj)), 0); 2528 if (*valp) 2529 { 2530 *staticp = 1; 2531 do_cleanups (all_cleanups); 2532 return 0; 2533 } 2534 } 2535 2536 /* Retrieve the list of methods with the name NAME. */ 2537 value_find_oload_method_list (&temp, name, 0, &fns_ptr, &num_fns, 2538 &xm_worker_vec, &basetype, &boffset); 2539 /* If this is a method only search, and no methods were found 2540 the search has faild. */ 2541 if (method == METHOD && (!fns_ptr || !num_fns) && !xm_worker_vec) 2542 error (_("Couldn't find method %s%s%s"), 2543 obj_type_name, 2544 (obj_type_name && *obj_type_name) ? "::" : "", 2545 name); 2546 /* If we are dealing with stub method types, they should have 2547 been resolved by find_method_list via 2548 value_find_oload_method_list above. */ 2549 if (fns_ptr) 2550 { 2551 gdb_assert (TYPE_SELF_TYPE (fns_ptr[0].type) != NULL); 2552 2553 src_method_oload_champ = find_oload_champ (args, nargs, 2554 num_fns, fns_ptr, NULL, 2555 NULL, &src_method_badness); 2556 2557 src_method_match_quality = classify_oload_match 2558 (src_method_badness, nargs, 2559 oload_method_static_p (fns_ptr, src_method_oload_champ)); 2560 2561 make_cleanup (xfree, src_method_badness); 2562 } 2563 2564 if (VEC_length (xmethod_worker_ptr, xm_worker_vec) > 0) 2565 { 2566 ext_method_oload_champ = find_oload_champ (args, nargs, 2567 0, NULL, xm_worker_vec, 2568 NULL, &ext_method_badness); 2569 ext_method_match_quality = classify_oload_match (ext_method_badness, 2570 nargs, 0); 2571 make_cleanup (xfree, ext_method_badness); 2572 make_cleanup (free_xmethod_worker_vec, xm_worker_vec); 2573 } 2574 2575 if (src_method_oload_champ >= 0 && ext_method_oload_champ >= 0) 2576 { 2577 switch (compare_badness (ext_method_badness, src_method_badness)) 2578 { 2579 case 0: /* Src method and xmethod are equally good. */ 2580 /* If src method and xmethod are equally good, then 2581 xmethod should be the winner. Hence, fall through to the 2582 case where a xmethod is better than the source 2583 method, except when the xmethod match quality is 2584 non-standard. */ 2585 /* FALLTHROUGH */ 2586 case 1: /* Src method and ext method are incompatible. */ 2587 /* If ext method match is not standard, then let source method 2588 win. Otherwise, fallthrough to let xmethod win. */ 2589 if (ext_method_match_quality != STANDARD) 2590 { 2591 method_oload_champ = src_method_oload_champ; 2592 method_badness = src_method_badness; 2593 ext_method_oload_champ = -1; 2594 method_match_quality = src_method_match_quality; 2595 break; 2596 } 2597 /* FALLTHROUGH */ 2598 case 2: /* Ext method is champion. */ 2599 method_oload_champ = ext_method_oload_champ; 2600 method_badness = ext_method_badness; 2601 src_method_oload_champ = -1; 2602 method_match_quality = ext_method_match_quality; 2603 break; 2604 case 3: /* Src method is champion. */ 2605 method_oload_champ = src_method_oload_champ; 2606 method_badness = src_method_badness; 2607 ext_method_oload_champ = -1; 2608 method_match_quality = src_method_match_quality; 2609 break; 2610 default: 2611 gdb_assert_not_reached ("Unexpected overload comparison " 2612 "result"); 2613 break; 2614 } 2615 } 2616 else if (src_method_oload_champ >= 0) 2617 { 2618 method_oload_champ = src_method_oload_champ; 2619 method_badness = src_method_badness; 2620 method_match_quality = src_method_match_quality; 2621 } 2622 else if (ext_method_oload_champ >= 0) 2623 { 2624 method_oload_champ = ext_method_oload_champ; 2625 method_badness = ext_method_badness; 2626 method_match_quality = ext_method_match_quality; 2627 } 2628 } 2629 2630 if (method == NON_METHOD || method == BOTH) 2631 { 2632 const char *qualified_name = NULL; 2633 2634 /* If the overload match is being search for both as a method 2635 and non member function, the first argument must now be 2636 dereferenced. */ 2637 if (method == BOTH) 2638 args[0] = value_ind (args[0]); 2639 2640 if (fsym) 2641 { 2642 qualified_name = SYMBOL_NATURAL_NAME (fsym); 2643 2644 /* If we have a function with a C++ name, try to extract just 2645 the function part. Do not try this for non-functions (e.g. 2646 function pointers). */ 2647 if (qualified_name 2648 && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym))) 2649 == TYPE_CODE_FUNC) 2650 { 2651 char *temp; 2652 2653 temp = cp_func_name (qualified_name); 2654 2655 /* If cp_func_name did not remove anything, the name of the 2656 symbol did not include scope or argument types - it was 2657 probably a C-style function. */ 2658 if (temp) 2659 { 2660 make_cleanup (xfree, temp); 2661 if (strcmp (temp, qualified_name) == 0) 2662 func_name = NULL; 2663 else 2664 func_name = temp; 2665 } 2666 } 2667 } 2668 else 2669 { 2670 func_name = name; 2671 qualified_name = name; 2672 } 2673 2674 /* If there was no C++ name, this must be a C-style function or 2675 not a function at all. Just return the same symbol. Do the 2676 same if cp_func_name fails for some reason. */ 2677 if (func_name == NULL) 2678 { 2679 *symp = fsym; 2680 do_cleanups (all_cleanups); 2681 return 0; 2682 } 2683 2684 func_oload_champ = find_oload_champ_namespace (args, nargs, 2685 func_name, 2686 qualified_name, 2687 &oload_syms, 2688 &func_badness, 2689 no_adl); 2690 2691 if (func_oload_champ >= 0) 2692 func_match_quality = classify_oload_match (func_badness, nargs, 0); 2693 2694 make_cleanup (xfree, oload_syms); 2695 make_cleanup (xfree, func_badness); 2696 } 2697 2698 /* Did we find a match ? */ 2699 if (method_oload_champ == -1 && func_oload_champ == -1) 2700 throw_error (NOT_FOUND_ERROR, 2701 _("No symbol \"%s\" in current context."), 2702 name); 2703 2704 /* If we have found both a method match and a function 2705 match, find out which one is better, and calculate match 2706 quality. */ 2707 if (method_oload_champ >= 0 && func_oload_champ >= 0) 2708 { 2709 switch (compare_badness (func_badness, method_badness)) 2710 { 2711 case 0: /* Top two contenders are equally good. */ 2712 /* FIXME: GDB does not support the general ambiguous case. 2713 All candidates should be collected and presented the 2714 user. */ 2715 error (_("Ambiguous overload resolution")); 2716 break; 2717 case 1: /* Incomparable top contenders. */ 2718 /* This is an error incompatible candidates 2719 should not have been proposed. */ 2720 error (_("Internal error: incompatible " 2721 "overload candidates proposed")); 2722 break; 2723 case 2: /* Function champion. */ 2724 method_oload_champ = -1; 2725 match_quality = func_match_quality; 2726 break; 2727 case 3: /* Method champion. */ 2728 func_oload_champ = -1; 2729 match_quality = method_match_quality; 2730 break; 2731 default: 2732 error (_("Internal error: unexpected overload comparison result")); 2733 break; 2734 } 2735 } 2736 else 2737 { 2738 /* We have either a method match or a function match. */ 2739 if (method_oload_champ >= 0) 2740 match_quality = method_match_quality; 2741 else 2742 match_quality = func_match_quality; 2743 } 2744 2745 if (match_quality == INCOMPATIBLE) 2746 { 2747 if (method == METHOD) 2748 error (_("Cannot resolve method %s%s%s to any overloaded instance"), 2749 obj_type_name, 2750 (obj_type_name && *obj_type_name) ? "::" : "", 2751 name); 2752 else 2753 error (_("Cannot resolve function %s to any overloaded instance"), 2754 func_name); 2755 } 2756 else if (match_quality == NON_STANDARD) 2757 { 2758 if (method == METHOD) 2759 warning (_("Using non-standard conversion to match " 2760 "method %s%s%s to supplied arguments"), 2761 obj_type_name, 2762 (obj_type_name && *obj_type_name) ? "::" : "", 2763 name); 2764 else 2765 warning (_("Using non-standard conversion to match " 2766 "function %s to supplied arguments"), 2767 func_name); 2768 } 2769 2770 if (staticp != NULL) 2771 *staticp = oload_method_static_p (fns_ptr, method_oload_champ); 2772 2773 if (method_oload_champ >= 0) 2774 { 2775 if (src_method_oload_champ >= 0) 2776 { 2777 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, method_oload_champ) 2778 && noside != EVAL_AVOID_SIDE_EFFECTS) 2779 { 2780 *valp = value_virtual_fn_field (&temp, fns_ptr, 2781 method_oload_champ, basetype, 2782 boffset); 2783 } 2784 else 2785 *valp = value_fn_field (&temp, fns_ptr, method_oload_champ, 2786 basetype, boffset); 2787 } 2788 else 2789 { 2790 *valp = value_of_xmethod (clone_xmethod_worker 2791 (VEC_index (xmethod_worker_ptr, xm_worker_vec, 2792 ext_method_oload_champ))); 2793 } 2794 } 2795 else 2796 *symp = oload_syms[func_oload_champ]; 2797 2798 if (objp) 2799 { 2800 struct type *temp_type = check_typedef (value_type (temp)); 2801 struct type *objtype = check_typedef (obj_type); 2802 2803 if (TYPE_CODE (temp_type) != TYPE_CODE_PTR 2804 && (TYPE_CODE (objtype) == TYPE_CODE_PTR 2805 || TYPE_CODE (objtype) == TYPE_CODE_REF)) 2806 { 2807 temp = value_addr (temp); 2808 } 2809 *objp = temp; 2810 } 2811 2812 do_cleanups (all_cleanups); 2813 2814 switch (match_quality) 2815 { 2816 case INCOMPATIBLE: 2817 return 100; 2818 case NON_STANDARD: 2819 return 10; 2820 default: /* STANDARD */ 2821 return 0; 2822 } 2823 } 2824 2825 /* Find the best overload match, searching for FUNC_NAME in namespaces 2826 contained in QUALIFIED_NAME until it either finds a good match or 2827 runs out of namespaces. It stores the overloaded functions in 2828 *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. The 2829 calling function is responsible for freeing *OLOAD_SYMS and 2830 *OLOAD_CHAMP_BV. If NO_ADL, argument dependent lookup is not 2831 performned. */ 2832 2833 static int 2834 find_oload_champ_namespace (struct value **args, int nargs, 2835 const char *func_name, 2836 const char *qualified_name, 2837 struct symbol ***oload_syms, 2838 struct badness_vector **oload_champ_bv, 2839 const int no_adl) 2840 { 2841 int oload_champ; 2842 2843 find_oload_champ_namespace_loop (args, nargs, 2844 func_name, 2845 qualified_name, 0, 2846 oload_syms, oload_champ_bv, 2847 &oload_champ, 2848 no_adl); 2849 2850 return oload_champ; 2851 } 2852 2853 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is 2854 how deep we've looked for namespaces, and the champ is stored in 2855 OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0 2856 if it isn't. Other arguments are the same as in 2857 find_oload_champ_namespace 2858 2859 It is the caller's responsibility to free *OLOAD_SYMS and 2860 *OLOAD_CHAMP_BV. */ 2861 2862 static int 2863 find_oload_champ_namespace_loop (struct value **args, int nargs, 2864 const char *func_name, 2865 const char *qualified_name, 2866 int namespace_len, 2867 struct symbol ***oload_syms, 2868 struct badness_vector **oload_champ_bv, 2869 int *oload_champ, 2870 const int no_adl) 2871 { 2872 int next_namespace_len = namespace_len; 2873 int searched_deeper = 0; 2874 int num_fns = 0; 2875 struct cleanup *old_cleanups; 2876 int new_oload_champ; 2877 struct symbol **new_oload_syms; 2878 struct badness_vector *new_oload_champ_bv; 2879 char *new_namespace; 2880 2881 if (next_namespace_len != 0) 2882 { 2883 gdb_assert (qualified_name[next_namespace_len] == ':'); 2884 next_namespace_len += 2; 2885 } 2886 next_namespace_len += 2887 cp_find_first_component (qualified_name + next_namespace_len); 2888 2889 /* Initialize these to values that can safely be xfree'd. */ 2890 *oload_syms = NULL; 2891 *oload_champ_bv = NULL; 2892 2893 /* First, see if we have a deeper namespace we can search in. 2894 If we get a good match there, use it. */ 2895 2896 if (qualified_name[next_namespace_len] == ':') 2897 { 2898 searched_deeper = 1; 2899 2900 if (find_oload_champ_namespace_loop (args, nargs, 2901 func_name, qualified_name, 2902 next_namespace_len, 2903 oload_syms, oload_champ_bv, 2904 oload_champ, no_adl)) 2905 { 2906 return 1; 2907 } 2908 }; 2909 2910 /* If we reach here, either we're in the deepest namespace or we 2911 didn't find a good match in a deeper namespace. But, in the 2912 latter case, we still have a bad match in a deeper namespace; 2913 note that we might not find any match at all in the current 2914 namespace. (There's always a match in the deepest namespace, 2915 because this overload mechanism only gets called if there's a 2916 function symbol to start off with.) */ 2917 2918 old_cleanups = make_cleanup (xfree, *oload_syms); 2919 make_cleanup (xfree, *oload_champ_bv); 2920 new_namespace = (char *) alloca (namespace_len + 1); 2921 strncpy (new_namespace, qualified_name, namespace_len); 2922 new_namespace[namespace_len] = '\0'; 2923 new_oload_syms = make_symbol_overload_list (func_name, 2924 new_namespace); 2925 2926 /* If we have reached the deepest level perform argument 2927 determined lookup. */ 2928 if (!searched_deeper && !no_adl) 2929 { 2930 int ix; 2931 struct type **arg_types; 2932 2933 /* Prepare list of argument types for overload resolution. */ 2934 arg_types = (struct type **) 2935 alloca (nargs * (sizeof (struct type *))); 2936 for (ix = 0; ix < nargs; ix++) 2937 arg_types[ix] = value_type (args[ix]); 2938 make_symbol_overload_list_adl (arg_types, nargs, func_name); 2939 } 2940 2941 while (new_oload_syms[num_fns]) 2942 ++num_fns; 2943 2944 new_oload_champ = find_oload_champ (args, nargs, num_fns, 2945 NULL, NULL, new_oload_syms, 2946 &new_oload_champ_bv); 2947 2948 /* Case 1: We found a good match. Free earlier matches (if any), 2949 and return it. Case 2: We didn't find a good match, but we're 2950 not the deepest function. Then go with the bad match that the 2951 deeper function found. Case 3: We found a bad match, and we're 2952 the deepest function. Then return what we found, even though 2953 it's a bad match. */ 2954 2955 if (new_oload_champ != -1 2956 && classify_oload_match (new_oload_champ_bv, nargs, 0) == STANDARD) 2957 { 2958 *oload_syms = new_oload_syms; 2959 *oload_champ = new_oload_champ; 2960 *oload_champ_bv = new_oload_champ_bv; 2961 do_cleanups (old_cleanups); 2962 return 1; 2963 } 2964 else if (searched_deeper) 2965 { 2966 xfree (new_oload_syms); 2967 xfree (new_oload_champ_bv); 2968 discard_cleanups (old_cleanups); 2969 return 0; 2970 } 2971 else 2972 { 2973 *oload_syms = new_oload_syms; 2974 *oload_champ = new_oload_champ; 2975 *oload_champ_bv = new_oload_champ_bv; 2976 do_cleanups (old_cleanups); 2977 return 0; 2978 } 2979 } 2980 2981 /* Look for a function to take NARGS args of ARGS. Find 2982 the best match from among the overloaded methods or functions 2983 given by FNS_PTR or OLOAD_SYMS or XM_WORKER_VEC, respectively. 2984 One, and only one of FNS_PTR, OLOAD_SYMS and XM_WORKER_VEC can be 2985 non-NULL. 2986 2987 If XM_WORKER_VEC is NULL, then the length of the arrays FNS_PTR 2988 or OLOAD_SYMS (whichever is non-NULL) is specified in NUM_FNS. 2989 2990 Return the index of the best match; store an indication of the 2991 quality of the match in OLOAD_CHAMP_BV. 2992 2993 It is the caller's responsibility to free *OLOAD_CHAMP_BV. */ 2994 2995 static int 2996 find_oload_champ (struct value **args, int nargs, 2997 int num_fns, struct fn_field *fns_ptr, 2998 VEC (xmethod_worker_ptr) *xm_worker_vec, 2999 struct symbol **oload_syms, 3000 struct badness_vector **oload_champ_bv) 3001 { 3002 int ix; 3003 int fn_count; 3004 /* A measure of how good an overloaded instance is. */ 3005 struct badness_vector *bv; 3006 /* Index of best overloaded function. */ 3007 int oload_champ = -1; 3008 /* Current ambiguity state for overload resolution. */ 3009 int oload_ambiguous = 0; 3010 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */ 3011 3012 /* A champion can be found among methods alone, or among functions 3013 alone, or in xmethods alone, but not in more than one of these 3014 groups. */ 3015 gdb_assert ((fns_ptr != NULL) + (oload_syms != NULL) + (xm_worker_vec != NULL) 3016 == 1); 3017 3018 *oload_champ_bv = NULL; 3019 3020 fn_count = (xm_worker_vec != NULL 3021 ? VEC_length (xmethod_worker_ptr, xm_worker_vec) 3022 : num_fns); 3023 /* Consider each candidate in turn. */ 3024 for (ix = 0; ix < fn_count; ix++) 3025 { 3026 int jj; 3027 int static_offset = 0; 3028 int nparms; 3029 struct type **parm_types; 3030 struct xmethod_worker *worker = NULL; 3031 3032 if (xm_worker_vec != NULL) 3033 { 3034 worker = VEC_index (xmethod_worker_ptr, xm_worker_vec, ix); 3035 parm_types = get_xmethod_arg_types (worker, &nparms); 3036 } 3037 else 3038 { 3039 if (fns_ptr != NULL) 3040 { 3041 nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr, ix)); 3042 static_offset = oload_method_static_p (fns_ptr, ix); 3043 } 3044 else 3045 nparms = TYPE_NFIELDS (SYMBOL_TYPE (oload_syms[ix])); 3046 3047 parm_types = XNEWVEC (struct type *, nparms); 3048 for (jj = 0; jj < nparms; jj++) 3049 parm_types[jj] = (fns_ptr != NULL 3050 ? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type) 3051 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]), 3052 jj)); 3053 } 3054 3055 /* Compare parameter types to supplied argument types. Skip 3056 THIS for static methods. */ 3057 bv = rank_function (parm_types, nparms, 3058 args + static_offset, 3059 nargs - static_offset); 3060 3061 if (!*oload_champ_bv) 3062 { 3063 *oload_champ_bv = bv; 3064 oload_champ = 0; 3065 } 3066 else /* See whether current candidate is better or worse than 3067 previous best. */ 3068 switch (compare_badness (bv, *oload_champ_bv)) 3069 { 3070 case 0: /* Top two contenders are equally good. */ 3071 oload_ambiguous = 1; 3072 break; 3073 case 1: /* Incomparable top contenders. */ 3074 oload_ambiguous = 2; 3075 break; 3076 case 2: /* New champion, record details. */ 3077 *oload_champ_bv = bv; 3078 oload_ambiguous = 0; 3079 oload_champ = ix; 3080 break; 3081 case 3: 3082 default: 3083 break; 3084 } 3085 xfree (parm_types); 3086 if (overload_debug) 3087 { 3088 if (fns_ptr != NULL) 3089 fprintf_filtered (gdb_stderr, 3090 "Overloaded method instance %s, # of parms %d\n", 3091 fns_ptr[ix].physname, nparms); 3092 else if (xm_worker_vec != NULL) 3093 fprintf_filtered (gdb_stderr, 3094 "Xmethod worker, # of parms %d\n", 3095 nparms); 3096 else 3097 fprintf_filtered (gdb_stderr, 3098 "Overloaded function instance " 3099 "%s # of parms %d\n", 3100 SYMBOL_DEMANGLED_NAME (oload_syms[ix]), 3101 nparms); 3102 for (jj = 0; jj < nargs - static_offset; jj++) 3103 fprintf_filtered (gdb_stderr, 3104 "...Badness @ %d : %d\n", 3105 jj, bv->rank[jj].rank); 3106 fprintf_filtered (gdb_stderr, "Overload resolution " 3107 "champion is %d, ambiguous? %d\n", 3108 oload_champ, oload_ambiguous); 3109 } 3110 } 3111 3112 return oload_champ; 3113 } 3114 3115 /* Return 1 if we're looking at a static method, 0 if we're looking at 3116 a non-static method or a function that isn't a method. */ 3117 3118 static int 3119 oload_method_static_p (struct fn_field *fns_ptr, int index) 3120 { 3121 if (fns_ptr && index >= 0 && TYPE_FN_FIELD_STATIC_P (fns_ptr, index)) 3122 return 1; 3123 else 3124 return 0; 3125 } 3126 3127 /* Check how good an overload match OLOAD_CHAMP_BV represents. */ 3128 3129 static enum oload_classification 3130 classify_oload_match (struct badness_vector *oload_champ_bv, 3131 int nargs, 3132 int static_offset) 3133 { 3134 int ix; 3135 enum oload_classification worst = STANDARD; 3136 3137 for (ix = 1; ix <= nargs - static_offset; ix++) 3138 { 3139 /* If this conversion is as bad as INCOMPATIBLE_TYPE_BADNESS 3140 or worse return INCOMPATIBLE. */ 3141 if (compare_ranks (oload_champ_bv->rank[ix], 3142 INCOMPATIBLE_TYPE_BADNESS) <= 0) 3143 return INCOMPATIBLE; /* Truly mismatched types. */ 3144 /* Otherwise If this conversion is as bad as 3145 NS_POINTER_CONVERSION_BADNESS or worse return NON_STANDARD. */ 3146 else if (compare_ranks (oload_champ_bv->rank[ix], 3147 NS_POINTER_CONVERSION_BADNESS) <= 0) 3148 worst = NON_STANDARD; /* Non-standard type conversions 3149 needed. */ 3150 } 3151 3152 /* If no INCOMPATIBLE classification was found, return the worst one 3153 that was found (if any). */ 3154 return worst; 3155 } 3156 3157 /* C++: return 1 is NAME is a legitimate name for the destructor of 3158 type TYPE. If TYPE does not have a destructor, or if NAME is 3159 inappropriate for TYPE, an error is signaled. Parameter TYPE should not yet 3160 have CHECK_TYPEDEF applied, this function will apply it itself. */ 3161 3162 int 3163 destructor_name_p (const char *name, struct type *type) 3164 { 3165 if (name[0] == '~') 3166 { 3167 const char *dname = type_name_no_tag_or_error (type); 3168 const char *cp = strchr (dname, '<'); 3169 unsigned int len; 3170 3171 /* Do not compare the template part for template classes. */ 3172 if (cp == NULL) 3173 len = strlen (dname); 3174 else 3175 len = cp - dname; 3176 if (strlen (name + 1) != len || strncmp (dname, name + 1, len) != 0) 3177 error (_("name of destructor must equal name of class")); 3178 else 3179 return 1; 3180 } 3181 return 0; 3182 } 3183 3184 /* Find an enum constant named NAME in TYPE. TYPE must be an "enum 3185 class". If the name is found, return a value representing it; 3186 otherwise throw an exception. */ 3187 3188 static struct value * 3189 enum_constant_from_type (struct type *type, const char *name) 3190 { 3191 int i; 3192 int name_len = strlen (name); 3193 3194 gdb_assert (TYPE_CODE (type) == TYPE_CODE_ENUM 3195 && TYPE_DECLARED_CLASS (type)); 3196 3197 for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); ++i) 3198 { 3199 const char *fname = TYPE_FIELD_NAME (type, i); 3200 int len; 3201 3202 if (TYPE_FIELD_LOC_KIND (type, i) != FIELD_LOC_KIND_ENUMVAL 3203 || fname == NULL) 3204 continue; 3205 3206 /* Look for the trailing "::NAME", since enum class constant 3207 names are qualified here. */ 3208 len = strlen (fname); 3209 if (len + 2 >= name_len 3210 && fname[len - name_len - 2] == ':' 3211 && fname[len - name_len - 1] == ':' 3212 && strcmp (&fname[len - name_len], name) == 0) 3213 return value_from_longest (type, TYPE_FIELD_ENUMVAL (type, i)); 3214 } 3215 3216 error (_("no constant named \"%s\" in enum \"%s\""), 3217 name, TYPE_TAG_NAME (type)); 3218 } 3219 3220 /* C++: Given an aggregate type CURTYPE, and a member name NAME, 3221 return the appropriate member (or the address of the member, if 3222 WANT_ADDRESS). This function is used to resolve user expressions 3223 of the form "DOMAIN::NAME". For more details on what happens, see 3224 the comment before value_struct_elt_for_reference. */ 3225 3226 struct value * 3227 value_aggregate_elt (struct type *curtype, const char *name, 3228 struct type *expect_type, int want_address, 3229 enum noside noside) 3230 { 3231 switch (TYPE_CODE (curtype)) 3232 { 3233 case TYPE_CODE_STRUCT: 3234 case TYPE_CODE_UNION: 3235 return value_struct_elt_for_reference (curtype, 0, curtype, 3236 name, expect_type, 3237 want_address, noside); 3238 case TYPE_CODE_NAMESPACE: 3239 return value_namespace_elt (curtype, name, 3240 want_address, noside); 3241 3242 case TYPE_CODE_ENUM: 3243 return enum_constant_from_type (curtype, name); 3244 3245 default: 3246 internal_error (__FILE__, __LINE__, 3247 _("non-aggregate type in value_aggregate_elt")); 3248 } 3249 } 3250 3251 /* Compares the two method/function types T1 and T2 for "equality" 3252 with respect to the methods' parameters. If the types of the 3253 two parameter lists are the same, returns 1; 0 otherwise. This 3254 comparison may ignore any artificial parameters in T1 if 3255 SKIP_ARTIFICIAL is non-zero. This function will ALWAYS skip 3256 the first artificial parameter in T1, assumed to be a 'this' pointer. 3257 3258 The type T2 is expected to have come from make_params (in eval.c). */ 3259 3260 static int 3261 compare_parameters (struct type *t1, struct type *t2, int skip_artificial) 3262 { 3263 int start = 0; 3264 3265 if (TYPE_NFIELDS (t1) > 0 && TYPE_FIELD_ARTIFICIAL (t1, 0)) 3266 ++start; 3267 3268 /* If skipping artificial fields, find the first real field 3269 in T1. */ 3270 if (skip_artificial) 3271 { 3272 while (start < TYPE_NFIELDS (t1) 3273 && TYPE_FIELD_ARTIFICIAL (t1, start)) 3274 ++start; 3275 } 3276 3277 /* Now compare parameters. */ 3278 3279 /* Special case: a method taking void. T1 will contain no 3280 non-artificial fields, and T2 will contain TYPE_CODE_VOID. */ 3281 if ((TYPE_NFIELDS (t1) - start) == 0 && TYPE_NFIELDS (t2) == 1 3282 && TYPE_CODE (TYPE_FIELD_TYPE (t2, 0)) == TYPE_CODE_VOID) 3283 return 1; 3284 3285 if ((TYPE_NFIELDS (t1) - start) == TYPE_NFIELDS (t2)) 3286 { 3287 int i; 3288 3289 for (i = 0; i < TYPE_NFIELDS (t2); ++i) 3290 { 3291 if (compare_ranks (rank_one_type (TYPE_FIELD_TYPE (t1, start + i), 3292 TYPE_FIELD_TYPE (t2, i), NULL), 3293 EXACT_MATCH_BADNESS) != 0) 3294 return 0; 3295 } 3296 3297 return 1; 3298 } 3299 3300 return 0; 3301 } 3302 3303 /* C++: Given an aggregate type CURTYPE, and a member name NAME, 3304 return the address of this member as a "pointer to member" type. 3305 If INTYPE is non-null, then it will be the type of the member we 3306 are looking for. This will help us resolve "pointers to member 3307 functions". This function is used to resolve user expressions of 3308 the form "DOMAIN::NAME". */ 3309 3310 static struct value * 3311 value_struct_elt_for_reference (struct type *domain, int offset, 3312 struct type *curtype, const char *name, 3313 struct type *intype, 3314 int want_address, 3315 enum noside noside) 3316 { 3317 struct type *t = curtype; 3318 int i; 3319 struct value *v, *result; 3320 3321 if (TYPE_CODE (t) != TYPE_CODE_STRUCT 3322 && TYPE_CODE (t) != TYPE_CODE_UNION) 3323 error (_("Internal error: non-aggregate type " 3324 "to value_struct_elt_for_reference")); 3325 3326 for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--) 3327 { 3328 const char *t_field_name = TYPE_FIELD_NAME (t, i); 3329 3330 if (t_field_name && strcmp (t_field_name, name) == 0) 3331 { 3332 if (field_is_static (&TYPE_FIELD (t, i))) 3333 { 3334 v = value_static_field (t, i); 3335 if (want_address) 3336 v = value_addr (v); 3337 return v; 3338 } 3339 if (TYPE_FIELD_PACKED (t, i)) 3340 error (_("pointers to bitfield members not allowed")); 3341 3342 if (want_address) 3343 return value_from_longest 3344 (lookup_memberptr_type (TYPE_FIELD_TYPE (t, i), domain), 3345 offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3)); 3346 else if (noside != EVAL_NORMAL) 3347 return allocate_value (TYPE_FIELD_TYPE (t, i)); 3348 else 3349 { 3350 /* Try to evaluate NAME as a qualified name with implicit 3351 this pointer. In this case, attempt to return the 3352 equivalent to `this->*(&TYPE::NAME)'. */ 3353 v = value_of_this_silent (current_language); 3354 if (v != NULL) 3355 { 3356 struct value *ptr; 3357 long mem_offset; 3358 struct type *type, *tmp; 3359 3360 ptr = value_aggregate_elt (domain, name, NULL, 1, noside); 3361 type = check_typedef (value_type (ptr)); 3362 gdb_assert (type != NULL 3363 && TYPE_CODE (type) == TYPE_CODE_MEMBERPTR); 3364 tmp = lookup_pointer_type (TYPE_SELF_TYPE (type)); 3365 v = value_cast_pointers (tmp, v, 1); 3366 mem_offset = value_as_long (ptr); 3367 tmp = lookup_pointer_type (TYPE_TARGET_TYPE (type)); 3368 result = value_from_pointer (tmp, 3369 value_as_long (v) + mem_offset); 3370 return value_ind (result); 3371 } 3372 3373 error (_("Cannot reference non-static field \"%s\""), name); 3374 } 3375 } 3376 } 3377 3378 /* C++: If it was not found as a data field, then try to return it 3379 as a pointer to a method. */ 3380 3381 /* Perform all necessary dereferencing. */ 3382 while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR) 3383 intype = TYPE_TARGET_TYPE (intype); 3384 3385 for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i) 3386 { 3387 const char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i); 3388 char dem_opname[64]; 3389 3390 if (startswith (t_field_name, "__") 3391 || startswith (t_field_name, "op") 3392 || startswith (t_field_name, "type")) 3393 { 3394 if (cplus_demangle_opname (t_field_name, 3395 dem_opname, DMGL_ANSI)) 3396 t_field_name = dem_opname; 3397 else if (cplus_demangle_opname (t_field_name, 3398 dem_opname, 0)) 3399 t_field_name = dem_opname; 3400 } 3401 if (t_field_name && strcmp (t_field_name, name) == 0) 3402 { 3403 int j; 3404 int len = TYPE_FN_FIELDLIST_LENGTH (t, i); 3405 struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i); 3406 3407 check_stub_method_group (t, i); 3408 3409 if (intype) 3410 { 3411 for (j = 0; j < len; ++j) 3412 { 3413 if (compare_parameters (TYPE_FN_FIELD_TYPE (f, j), intype, 0) 3414 || compare_parameters (TYPE_FN_FIELD_TYPE (f, j), 3415 intype, 1)) 3416 break; 3417 } 3418 3419 if (j == len) 3420 error (_("no member function matches " 3421 "that type instantiation")); 3422 } 3423 else 3424 { 3425 int ii; 3426 3427 j = -1; 3428 for (ii = 0; ii < len; ++ii) 3429 { 3430 /* Skip artificial methods. This is necessary if, 3431 for example, the user wants to "print 3432 subclass::subclass" with only one user-defined 3433 constructor. There is no ambiguity in this case. 3434 We are careful here to allow artificial methods 3435 if they are the unique result. */ 3436 if (TYPE_FN_FIELD_ARTIFICIAL (f, ii)) 3437 { 3438 if (j == -1) 3439 j = ii; 3440 continue; 3441 } 3442 3443 /* Desired method is ambiguous if more than one 3444 method is defined. */ 3445 if (j != -1 && !TYPE_FN_FIELD_ARTIFICIAL (f, j)) 3446 error (_("non-unique member `%s' requires " 3447 "type instantiation"), name); 3448 3449 j = ii; 3450 } 3451 3452 if (j == -1) 3453 error (_("no matching member function")); 3454 } 3455 3456 if (TYPE_FN_FIELD_STATIC_P (f, j)) 3457 { 3458 struct symbol *s = 3459 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j), 3460 0, VAR_DOMAIN, 0).symbol; 3461 3462 if (s == NULL) 3463 return NULL; 3464 3465 if (want_address) 3466 return value_addr (read_var_value (s, 0, 0)); 3467 else 3468 return read_var_value (s, 0, 0); 3469 } 3470 3471 if (TYPE_FN_FIELD_VIRTUAL_P (f, j)) 3472 { 3473 if (want_address) 3474 { 3475 result = allocate_value 3476 (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j))); 3477 cplus_make_method_ptr (value_type (result), 3478 value_contents_writeable (result), 3479 TYPE_FN_FIELD_VOFFSET (f, j), 1); 3480 } 3481 else if (noside == EVAL_AVOID_SIDE_EFFECTS) 3482 return allocate_value (TYPE_FN_FIELD_TYPE (f, j)); 3483 else 3484 error (_("Cannot reference virtual member function \"%s\""), 3485 name); 3486 } 3487 else 3488 { 3489 struct symbol *s = 3490 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j), 3491 0, VAR_DOMAIN, 0).symbol; 3492 3493 if (s == NULL) 3494 return NULL; 3495 3496 v = read_var_value (s, 0, 0); 3497 if (!want_address) 3498 result = v; 3499 else 3500 { 3501 result = allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j))); 3502 cplus_make_method_ptr (value_type (result), 3503 value_contents_writeable (result), 3504 value_address (v), 0); 3505 } 3506 } 3507 return result; 3508 } 3509 } 3510 for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--) 3511 { 3512 struct value *v; 3513 int base_offset; 3514 3515 if (BASETYPE_VIA_VIRTUAL (t, i)) 3516 base_offset = 0; 3517 else 3518 base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8; 3519 v = value_struct_elt_for_reference (domain, 3520 offset + base_offset, 3521 TYPE_BASECLASS (t, i), 3522 name, intype, 3523 want_address, noside); 3524 if (v) 3525 return v; 3526 } 3527 3528 /* As a last chance, pretend that CURTYPE is a namespace, and look 3529 it up that way; this (frequently) works for types nested inside 3530 classes. */ 3531 3532 return value_maybe_namespace_elt (curtype, name, 3533 want_address, noside); 3534 } 3535 3536 /* C++: Return the member NAME of the namespace given by the type 3537 CURTYPE. */ 3538 3539 static struct value * 3540 value_namespace_elt (const struct type *curtype, 3541 const char *name, int want_address, 3542 enum noside noside) 3543 { 3544 struct value *retval = value_maybe_namespace_elt (curtype, name, 3545 want_address, 3546 noside); 3547 3548 if (retval == NULL) 3549 error (_("No symbol \"%s\" in namespace \"%s\"."), 3550 name, TYPE_TAG_NAME (curtype)); 3551 3552 return retval; 3553 } 3554 3555 /* A helper function used by value_namespace_elt and 3556 value_struct_elt_for_reference. It looks up NAME inside the 3557 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE 3558 is a class and NAME refers to a type in CURTYPE itself (as opposed 3559 to, say, some base class of CURTYPE). */ 3560 3561 static struct value * 3562 value_maybe_namespace_elt (const struct type *curtype, 3563 const char *name, int want_address, 3564 enum noside noside) 3565 { 3566 const char *namespace_name = TYPE_TAG_NAME (curtype); 3567 struct block_symbol sym; 3568 struct value *result; 3569 3570 sym = cp_lookup_symbol_namespace (namespace_name, name, 3571 get_selected_block (0), VAR_DOMAIN); 3572 3573 if (sym.symbol == NULL) 3574 return NULL; 3575 else if ((noside == EVAL_AVOID_SIDE_EFFECTS) 3576 && (SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF)) 3577 result = allocate_value (SYMBOL_TYPE (sym.symbol)); 3578 else 3579 result = value_of_variable (sym.symbol, sym.block); 3580 3581 if (want_address) 3582 result = value_addr (result); 3583 3584 return result; 3585 } 3586 3587 /* Given a pointer or a reference value V, find its real (RTTI) type. 3588 3589 Other parameters FULL, TOP, USING_ENC as with value_rtti_type() 3590 and refer to the values computed for the object pointed to. */ 3591 3592 struct type * 3593 value_rtti_indirect_type (struct value *v, int *full, 3594 LONGEST *top, int *using_enc) 3595 { 3596 struct value *target = NULL; 3597 struct type *type, *real_type, *target_type; 3598 3599 type = value_type (v); 3600 type = check_typedef (type); 3601 if (TYPE_CODE (type) == TYPE_CODE_REF) 3602 target = coerce_ref (v); 3603 else if (TYPE_CODE (type) == TYPE_CODE_PTR) 3604 { 3605 3606 TRY 3607 { 3608 target = value_ind (v); 3609 } 3610 CATCH (except, RETURN_MASK_ERROR) 3611 { 3612 if (except.error == MEMORY_ERROR) 3613 { 3614 /* value_ind threw a memory error. The pointer is NULL or 3615 contains an uninitialized value: we can't determine any 3616 type. */ 3617 return NULL; 3618 } 3619 throw_exception (except); 3620 } 3621 END_CATCH 3622 } 3623 else 3624 return NULL; 3625 3626 real_type = value_rtti_type (target, full, top, using_enc); 3627 3628 if (real_type) 3629 { 3630 /* Copy qualifiers to the referenced object. */ 3631 target_type = value_type (target); 3632 real_type = make_cv_type (TYPE_CONST (target_type), 3633 TYPE_VOLATILE (target_type), real_type, NULL); 3634 if (TYPE_CODE (type) == TYPE_CODE_REF) 3635 real_type = lookup_reference_type (real_type); 3636 else if (TYPE_CODE (type) == TYPE_CODE_PTR) 3637 real_type = lookup_pointer_type (real_type); 3638 else 3639 internal_error (__FILE__, __LINE__, _("Unexpected value type.")); 3640 3641 /* Copy qualifiers to the pointer/reference. */ 3642 real_type = make_cv_type (TYPE_CONST (type), TYPE_VOLATILE (type), 3643 real_type, NULL); 3644 } 3645 3646 return real_type; 3647 } 3648 3649 /* Given a value pointed to by ARGP, check its real run-time type, and 3650 if that is different from the enclosing type, create a new value 3651 using the real run-time type as the enclosing type (and of the same 3652 type as ARGP) and return it, with the embedded offset adjusted to 3653 be the correct offset to the enclosed object. RTYPE is the type, 3654 and XFULL, XTOP, and XUSING_ENC are the other parameters, computed 3655 by value_rtti_type(). If these are available, they can be supplied 3656 and a second call to value_rtti_type() is avoided. (Pass RTYPE == 3657 NULL if they're not available. */ 3658 3659 struct value * 3660 value_full_object (struct value *argp, 3661 struct type *rtype, 3662 int xfull, int xtop, 3663 int xusing_enc) 3664 { 3665 struct type *real_type; 3666 int full = 0; 3667 LONGEST top = -1; 3668 int using_enc = 0; 3669 struct value *new_val; 3670 3671 if (rtype) 3672 { 3673 real_type = rtype; 3674 full = xfull; 3675 top = xtop; 3676 using_enc = xusing_enc; 3677 } 3678 else 3679 real_type = value_rtti_type (argp, &full, &top, &using_enc); 3680 3681 /* If no RTTI data, or if object is already complete, do nothing. */ 3682 if (!real_type || real_type == value_enclosing_type (argp)) 3683 return argp; 3684 3685 /* In a destructor we might see a real type that is a superclass of 3686 the object's type. In this case it is better to leave the object 3687 as-is. */ 3688 if (full 3689 && TYPE_LENGTH (real_type) < TYPE_LENGTH (value_enclosing_type (argp))) 3690 return argp; 3691 3692 /* If we have the full object, but for some reason the enclosing 3693 type is wrong, set it. */ 3694 /* pai: FIXME -- sounds iffy */ 3695 if (full) 3696 { 3697 argp = value_copy (argp); 3698 set_value_enclosing_type (argp, real_type); 3699 return argp; 3700 } 3701 3702 /* Check if object is in memory. */ 3703 if (VALUE_LVAL (argp) != lval_memory) 3704 { 3705 warning (_("Couldn't retrieve complete object of RTTI " 3706 "type %s; object may be in register(s)."), 3707 TYPE_NAME (real_type)); 3708 3709 return argp; 3710 } 3711 3712 /* All other cases -- retrieve the complete object. */ 3713 /* Go back by the computed top_offset from the beginning of the 3714 object, adjusting for the embedded offset of argp if that's what 3715 value_rtti_type used for its computation. */ 3716 new_val = value_at_lazy (real_type, value_address (argp) - top + 3717 (using_enc ? 0 : value_embedded_offset (argp))); 3718 deprecated_set_value_type (new_val, value_type (argp)); 3719 set_value_embedded_offset (new_val, (using_enc 3720 ? top + value_embedded_offset (argp) 3721 : top)); 3722 return new_val; 3723 } 3724 3725 3726 /* Return the value of the local variable, if one exists. Throw error 3727 otherwise, such as if the request is made in an inappropriate context. */ 3728 3729 struct value * 3730 value_of_this (const struct language_defn *lang) 3731 { 3732 struct block_symbol sym; 3733 const struct block *b; 3734 struct frame_info *frame; 3735 3736 if (!lang->la_name_of_this) 3737 error (_("no `this' in current language")); 3738 3739 frame = get_selected_frame (_("no frame selected")); 3740 3741 b = get_frame_block (frame, NULL); 3742 3743 sym = lookup_language_this (lang, b); 3744 if (sym.symbol == NULL) 3745 error (_("current stack frame does not contain a variable named `%s'"), 3746 lang->la_name_of_this); 3747 3748 return read_var_value (sym.symbol, sym.block, frame); 3749 } 3750 3751 /* Return the value of the local variable, if one exists. Return NULL 3752 otherwise. Never throw error. */ 3753 3754 struct value * 3755 value_of_this_silent (const struct language_defn *lang) 3756 { 3757 struct value *ret = NULL; 3758 3759 TRY 3760 { 3761 ret = value_of_this (lang); 3762 } 3763 CATCH (except, RETURN_MASK_ERROR) 3764 { 3765 } 3766 END_CATCH 3767 3768 return ret; 3769 } 3770 3771 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH 3772 elements long, starting at LOWBOUND. The result has the same lower 3773 bound as the original ARRAY. */ 3774 3775 struct value * 3776 value_slice (struct value *array, int lowbound, int length) 3777 { 3778 struct type *slice_range_type, *slice_type, *range_type; 3779 LONGEST lowerbound, upperbound; 3780 struct value *slice; 3781 struct type *array_type; 3782 3783 array_type = check_typedef (value_type (array)); 3784 if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY 3785 && TYPE_CODE (array_type) != TYPE_CODE_STRING) 3786 error (_("cannot take slice of non-array")); 3787 3788 range_type = TYPE_INDEX_TYPE (array_type); 3789 if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0) 3790 error (_("slice from bad array or bitstring")); 3791 3792 if (lowbound < lowerbound || length < 0 3793 || lowbound + length - 1 > upperbound) 3794 error (_("slice out of range")); 3795 3796 /* FIXME-type-allocation: need a way to free this type when we are 3797 done with it. */ 3798 slice_range_type = create_static_range_type ((struct type *) NULL, 3799 TYPE_TARGET_TYPE (range_type), 3800 lowbound, 3801 lowbound + length - 1); 3802 3803 { 3804 struct type *element_type = TYPE_TARGET_TYPE (array_type); 3805 LONGEST offset 3806 = (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type)); 3807 3808 slice_type = create_array_type ((struct type *) NULL, 3809 element_type, 3810 slice_range_type); 3811 TYPE_CODE (slice_type) = TYPE_CODE (array_type); 3812 3813 if (VALUE_LVAL (array) == lval_memory && value_lazy (array)) 3814 slice = allocate_value_lazy (slice_type); 3815 else 3816 { 3817 slice = allocate_value (slice_type); 3818 value_contents_copy (slice, 0, array, offset, 3819 type_length_units (slice_type)); 3820 } 3821 3822 set_value_component_location (slice, array); 3823 VALUE_FRAME_ID (slice) = VALUE_FRAME_ID (array); 3824 set_value_offset (slice, value_offset (array) + offset); 3825 } 3826 3827 return slice; 3828 } 3829 3830 /* Create a value for a FORTRAN complex number. Currently most of the 3831 time values are coerced to COMPLEX*16 (i.e. a complex number 3832 composed of 2 doubles. This really should be a smarter routine 3833 that figures out precision inteligently as opposed to assuming 3834 doubles. FIXME: fmb */ 3835 3836 struct value * 3837 value_literal_complex (struct value *arg1, 3838 struct value *arg2, 3839 struct type *type) 3840 { 3841 struct value *val; 3842 struct type *real_type = TYPE_TARGET_TYPE (type); 3843 3844 val = allocate_value (type); 3845 arg1 = value_cast (real_type, arg1); 3846 arg2 = value_cast (real_type, arg2); 3847 3848 memcpy (value_contents_raw (val), 3849 value_contents (arg1), TYPE_LENGTH (real_type)); 3850 memcpy (value_contents_raw (val) + TYPE_LENGTH (real_type), 3851 value_contents (arg2), TYPE_LENGTH (real_type)); 3852 return val; 3853 } 3854 3855 /* Cast a value into the appropriate complex data type. */ 3856 3857 static struct value * 3858 cast_into_complex (struct type *type, struct value *val) 3859 { 3860 struct type *real_type = TYPE_TARGET_TYPE (type); 3861 3862 if (TYPE_CODE (value_type (val)) == TYPE_CODE_COMPLEX) 3863 { 3864 struct type *val_real_type = TYPE_TARGET_TYPE (value_type (val)); 3865 struct value *re_val = allocate_value (val_real_type); 3866 struct value *im_val = allocate_value (val_real_type); 3867 3868 memcpy (value_contents_raw (re_val), 3869 value_contents (val), TYPE_LENGTH (val_real_type)); 3870 memcpy (value_contents_raw (im_val), 3871 value_contents (val) + TYPE_LENGTH (val_real_type), 3872 TYPE_LENGTH (val_real_type)); 3873 3874 return value_literal_complex (re_val, im_val, type); 3875 } 3876 else if (TYPE_CODE (value_type (val)) == TYPE_CODE_FLT 3877 || TYPE_CODE (value_type (val)) == TYPE_CODE_INT) 3878 return value_literal_complex (val, 3879 value_zero (real_type, not_lval), 3880 type); 3881 else 3882 error (_("cannot cast non-number to complex")); 3883 } 3884 3885 void 3886 _initialize_valops (void) 3887 { 3888 add_setshow_boolean_cmd ("overload-resolution", class_support, 3889 &overload_resolution, _("\ 3890 Set overload resolution in evaluating C++ functions."), _("\ 3891 Show overload resolution in evaluating C++ functions."), 3892 NULL, NULL, 3893 show_overload_resolution, 3894 &setlist, &showlist); 3895 overload_resolution = 1; 3896 } 3897