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