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