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