1 /* Abstraction of GNU v3 abi. 2 Contributed by Jim Blandy <jimb@redhat.com> 3 4 Copyright (C) 2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009 5 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 "value.h" 24 #include "cp-abi.h" 25 #include "cp-support.h" 26 #include "demangle.h" 27 #include "objfiles.h" 28 #include "valprint.h" 29 30 #include "gdb_assert.h" 31 #include "gdb_string.h" 32 33 static struct cp_abi_ops gnu_v3_abi_ops; 34 35 static int 36 gnuv3_is_vtable_name (const char *name) 37 { 38 return strncmp (name, "_ZTV", 4) == 0; 39 } 40 41 static int 42 gnuv3_is_operator_name (const char *name) 43 { 44 return strncmp (name, "operator", 8) == 0; 45 } 46 47 48 /* To help us find the components of a vtable, we build ourselves a 49 GDB type object representing the vtable structure. Following the 50 V3 ABI, it goes something like this: 51 52 struct gdb_gnu_v3_abi_vtable { 53 54 / * An array of virtual call and virtual base offsets. The real 55 length of this array depends on the class hierarchy; we use 56 negative subscripts to access the elements. Yucky, but 57 better than the alternatives. * / 58 ptrdiff_t vcall_and_vbase_offsets[0]; 59 60 / * The offset from a virtual pointer referring to this table 61 to the top of the complete object. * / 62 ptrdiff_t offset_to_top; 63 64 / * The type_info pointer for this class. This is really a 65 std::type_info *, but GDB doesn't really look at the 66 type_info object itself, so we don't bother to get the type 67 exactly right. * / 68 void *type_info; 69 70 / * Virtual table pointers in objects point here. * / 71 72 / * Virtual function pointers. Like the vcall/vbase array, the 73 real length of this table depends on the class hierarchy. * / 74 void (*virtual_functions[0]) (); 75 76 }; 77 78 The catch, of course, is that the exact layout of this table 79 depends on the ABI --- word size, endianness, alignment, etc. So 80 the GDB type object is actually a per-architecture kind of thing. 81 82 vtable_type_gdbarch_data is a gdbarch per-architecture data pointer 83 which refers to the struct type * for this structure, laid out 84 appropriately for the architecture. */ 85 static struct gdbarch_data *vtable_type_gdbarch_data; 86 87 88 /* Human-readable names for the numbers of the fields above. */ 89 enum { 90 vtable_field_vcall_and_vbase_offsets, 91 vtable_field_offset_to_top, 92 vtable_field_type_info, 93 vtable_field_virtual_functions 94 }; 95 96 97 /* Return a GDB type representing `struct gdb_gnu_v3_abi_vtable', 98 described above, laid out appropriately for ARCH. 99 100 We use this function as the gdbarch per-architecture data 101 initialization function. */ 102 static void * 103 build_gdb_vtable_type (struct gdbarch *arch) 104 { 105 struct type *t; 106 struct field *field_list, *field; 107 int offset; 108 109 struct type *void_ptr_type 110 = builtin_type (arch)->builtin_data_ptr; 111 struct type *ptr_to_void_fn_type 112 = builtin_type (arch)->builtin_func_ptr; 113 114 /* ARCH can't give us the true ptrdiff_t type, so we guess. */ 115 struct type *ptrdiff_type 116 = arch_integer_type (arch, gdbarch_ptr_bit (arch), 0, "ptrdiff_t"); 117 118 /* We assume no padding is necessary, since GDB doesn't know 119 anything about alignment at the moment. If this assumption bites 120 us, we should add a gdbarch method which, given a type, returns 121 the alignment that type requires, and then use that here. */ 122 123 /* Build the field list. */ 124 field_list = xmalloc (sizeof (struct field [4])); 125 memset (field_list, 0, sizeof (struct field [4])); 126 field = &field_list[0]; 127 offset = 0; 128 129 /* ptrdiff_t vcall_and_vbase_offsets[0]; */ 130 FIELD_NAME (*field) = "vcall_and_vbase_offsets"; 131 FIELD_TYPE (*field) = lookup_array_range_type (ptrdiff_type, 0, -1); 132 FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT; 133 offset += TYPE_LENGTH (FIELD_TYPE (*field)); 134 field++; 135 136 /* ptrdiff_t offset_to_top; */ 137 FIELD_NAME (*field) = "offset_to_top"; 138 FIELD_TYPE (*field) = ptrdiff_type; 139 FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT; 140 offset += TYPE_LENGTH (FIELD_TYPE (*field)); 141 field++; 142 143 /* void *type_info; */ 144 FIELD_NAME (*field) = "type_info"; 145 FIELD_TYPE (*field) = void_ptr_type; 146 FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT; 147 offset += TYPE_LENGTH (FIELD_TYPE (*field)); 148 field++; 149 150 /* void (*virtual_functions[0]) (); */ 151 FIELD_NAME (*field) = "virtual_functions"; 152 FIELD_TYPE (*field) = lookup_array_range_type (ptr_to_void_fn_type, 0, -1); 153 FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT; 154 offset += TYPE_LENGTH (FIELD_TYPE (*field)); 155 field++; 156 157 /* We assumed in the allocation above that there were four fields. */ 158 gdb_assert (field == (field_list + 4)); 159 160 t = arch_type (arch, TYPE_CODE_STRUCT, offset, NULL); 161 TYPE_NFIELDS (t) = field - field_list; 162 TYPE_FIELDS (t) = field_list; 163 TYPE_TAG_NAME (t) = "gdb_gnu_v3_abi_vtable"; 164 INIT_CPLUS_SPECIFIC (t); 165 166 return t; 167 } 168 169 170 /* Return the ptrdiff_t type used in the vtable type. */ 171 static struct type * 172 vtable_ptrdiff_type (struct gdbarch *gdbarch) 173 { 174 struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data); 175 176 /* The "offset_to_top" field has the appropriate (ptrdiff_t) type. */ 177 return TYPE_FIELD_TYPE (vtable_type, vtable_field_offset_to_top); 178 } 179 180 /* Return the offset from the start of the imaginary `struct 181 gdb_gnu_v3_abi_vtable' object to the vtable's "address point" 182 (i.e., where objects' virtual table pointers point). */ 183 static int 184 vtable_address_point_offset (struct gdbarch *gdbarch) 185 { 186 struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data); 187 188 return (TYPE_FIELD_BITPOS (vtable_type, vtable_field_virtual_functions) 189 / TARGET_CHAR_BIT); 190 } 191 192 193 static struct type * 194 gnuv3_rtti_type (struct value *value, 195 int *full_p, int *top_p, int *using_enc_p) 196 { 197 struct gdbarch *gdbarch; 198 struct type *vtable_type; 199 struct type *values_type = check_typedef (value_type (value)); 200 CORE_ADDR vtable_address; 201 struct value *vtable; 202 struct minimal_symbol *vtable_symbol; 203 const char *vtable_symbol_name; 204 const char *class_name; 205 struct type *run_time_type; 206 struct type *base_type; 207 LONGEST offset_to_top; 208 struct type *values_type_vptr_basetype; 209 int values_type_vptr_fieldno; 210 211 /* We only have RTTI for class objects. */ 212 if (TYPE_CODE (values_type) != TYPE_CODE_CLASS) 213 return NULL; 214 215 /* Determine architecture. */ 216 gdbarch = get_type_arch (values_type); 217 vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data); 218 219 /* If we can't find the virtual table pointer for values_type, we 220 can't find the RTTI. */ 221 values_type_vptr_fieldno = get_vptr_fieldno (values_type, 222 &values_type_vptr_basetype); 223 if (values_type_vptr_fieldno == -1) 224 return NULL; 225 226 if (using_enc_p) 227 *using_enc_p = 0; 228 229 /* Fetch VALUE's virtual table pointer, and tweak it to point at 230 an instance of our imaginary gdb_gnu_v3_abi_vtable structure. */ 231 base_type = check_typedef (values_type_vptr_basetype); 232 if (values_type != base_type) 233 { 234 value = value_cast (base_type, value); 235 if (using_enc_p) 236 *using_enc_p = 1; 237 } 238 vtable_address 239 = value_as_address (value_field (value, values_type_vptr_fieldno)); 240 vtable 241 = value_at_lazy (vtable_type, 242 vtable_address - vtable_address_point_offset (gdbarch)); 243 244 /* Find the linker symbol for this vtable. */ 245 vtable_symbol 246 = lookup_minimal_symbol_by_pc (value_address (vtable) 247 + value_embedded_offset (vtable)); 248 if (! vtable_symbol) 249 return NULL; 250 251 /* The symbol's demangled name should be something like "vtable for 252 CLASS", where CLASS is the name of the run-time type of VALUE. 253 If we didn't like this approach, we could instead look in the 254 type_info object itself to get the class name. But this way 255 should work just as well, and doesn't read target memory. */ 256 vtable_symbol_name = SYMBOL_DEMANGLED_NAME (vtable_symbol); 257 if (vtable_symbol_name == NULL 258 || strncmp (vtable_symbol_name, "vtable for ", 11)) 259 { 260 warning (_("can't find linker symbol for virtual table for `%s' value"), 261 TYPE_NAME (values_type)); 262 if (vtable_symbol_name) 263 warning (_(" found `%s' instead"), vtable_symbol_name); 264 return NULL; 265 } 266 class_name = vtable_symbol_name + 11; 267 268 /* Try to look up the class name as a type name. */ 269 /* FIXME: chastain/2003-11-26: block=NULL is bogus. See pr gdb/1465. */ 270 run_time_type = cp_lookup_rtti_type (class_name, NULL); 271 if (run_time_type == NULL) 272 return NULL; 273 274 /* Get the offset from VALUE to the top of the complete object. 275 NOTE: this is the reverse of the meaning of *TOP_P. */ 276 offset_to_top 277 = value_as_long (value_field (vtable, vtable_field_offset_to_top)); 278 279 if (full_p) 280 *full_p = (- offset_to_top == value_embedded_offset (value) 281 && (TYPE_LENGTH (value_enclosing_type (value)) 282 >= TYPE_LENGTH (run_time_type))); 283 if (top_p) 284 *top_p = - offset_to_top; 285 286 return run_time_type; 287 } 288 289 /* Find the vtable for CONTAINER and return a value of the correct 290 vtable type for this architecture. */ 291 292 static struct value * 293 gnuv3_get_vtable (struct gdbarch *gdbarch, struct value *container) 294 { 295 struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data); 296 struct type *vtable_pointer_type; 297 struct value *vtable_pointer; 298 CORE_ADDR vtable_pointer_address, vtable_address; 299 300 /* We do not consult the debug information to find the virtual table. 301 The ABI specifies that it is always at offset zero in any class, 302 and debug information may not represent it. We won't issue an 303 error if there's a class with virtual functions but no virtual table 304 pointer, but something's already gone seriously wrong if that 305 happens. 306 307 We avoid using value_contents on principle, because the object might 308 be large. */ 309 310 /* Find the type "pointer to virtual table". */ 311 vtable_pointer_type = lookup_pointer_type (vtable_type); 312 313 /* Load it from the start of the class. */ 314 vtable_pointer_address = value_as_address (value_addr (container)); 315 vtable_pointer = value_at (vtable_pointer_type, vtable_pointer_address); 316 vtable_address = value_as_address (vtable_pointer); 317 318 /* Correct it to point at the start of the virtual table, rather 319 than the address point. */ 320 return value_at_lazy (vtable_type, 321 vtable_address - vtable_address_point_offset (gdbarch)); 322 } 323 324 /* Return a function pointer for CONTAINER's VTABLE_INDEX'th virtual 325 function, of type FNTYPE. */ 326 327 static struct value * 328 gnuv3_get_virtual_fn (struct gdbarch *gdbarch, struct value *container, 329 struct type *fntype, int vtable_index) 330 { 331 struct value *vtable = gnuv3_get_vtable (gdbarch, container); 332 struct value *vfn; 333 334 /* Fetch the appropriate function pointer from the vtable. */ 335 vfn = value_subscript (value_field (vtable, vtable_field_virtual_functions), 336 vtable_index); 337 338 /* If this architecture uses function descriptors directly in the vtable, 339 then the address of the vtable entry is actually a "function pointer" 340 (i.e. points to the descriptor). We don't need to scale the index 341 by the size of a function descriptor; GCC does that before outputing 342 debug information. */ 343 if (gdbarch_vtable_function_descriptors (gdbarch)) 344 vfn = value_addr (vfn); 345 346 /* Cast the function pointer to the appropriate type. */ 347 vfn = value_cast (lookup_pointer_type (fntype), vfn); 348 349 return vfn; 350 } 351 352 /* GNU v3 implementation of value_virtual_fn_field. See cp-abi.h 353 for a description of the arguments. */ 354 355 static struct value * 356 gnuv3_virtual_fn_field (struct value **value_p, 357 struct fn_field *f, int j, 358 struct type *vfn_base, int offset) 359 { 360 struct type *values_type = check_typedef (value_type (*value_p)); 361 struct gdbarch *gdbarch; 362 363 /* Some simple sanity checks. */ 364 if (TYPE_CODE (values_type) != TYPE_CODE_CLASS) 365 error (_("Only classes can have virtual functions.")); 366 367 /* Determine architecture. */ 368 gdbarch = get_type_arch (values_type); 369 370 /* Cast our value to the base class which defines this virtual 371 function. This takes care of any necessary `this' 372 adjustments. */ 373 if (vfn_base != values_type) 374 *value_p = value_cast (vfn_base, *value_p); 375 376 return gnuv3_get_virtual_fn (gdbarch, *value_p, TYPE_FN_FIELD_TYPE (f, j), 377 TYPE_FN_FIELD_VOFFSET (f, j)); 378 } 379 380 /* Compute the offset of the baseclass which is 381 the INDEXth baseclass of class TYPE, 382 for value at VALADDR (in host) at ADDRESS (in target). 383 The result is the offset of the baseclass value relative 384 to (the address of)(ARG) + OFFSET. 385 386 -1 is returned on error. */ 387 static int 388 gnuv3_baseclass_offset (struct type *type, int index, const bfd_byte *valaddr, 389 CORE_ADDR address) 390 { 391 struct gdbarch *gdbarch; 392 struct type *vtable_type; 393 struct type *ptr_type; 394 struct value *vtable; 395 struct type *vbasetype; 396 struct value *vbase_array; 397 CORE_ADDR vtable_address; 398 long int cur_base_offset, base_offset; 399 int vbasetype_vptr_fieldno; 400 401 /* Determine architecture. */ 402 gdbarch = get_type_arch (type); 403 vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data); 404 ptr_type = builtin_type (gdbarch)->builtin_data_ptr; 405 406 /* If it isn't a virtual base, this is easy. The offset is in the 407 type definition. */ 408 if (!BASETYPE_VIA_VIRTUAL (type, index)) 409 return TYPE_BASECLASS_BITPOS (type, index) / 8; 410 411 /* To access a virtual base, we need to use the vbase offset stored in 412 our vtable. Recent GCC versions provide this information. If it isn't 413 available, we could get what we needed from RTTI, or from drawing the 414 complete inheritance graph based on the debug info. Neither is 415 worthwhile. */ 416 cur_base_offset = TYPE_BASECLASS_BITPOS (type, index) / 8; 417 if (cur_base_offset >= - vtable_address_point_offset (gdbarch)) 418 error (_("Expected a negative vbase offset (old compiler?)")); 419 420 cur_base_offset = cur_base_offset + vtable_address_point_offset (gdbarch); 421 if ((- cur_base_offset) % TYPE_LENGTH (ptr_type) != 0) 422 error (_("Misaligned vbase offset.")); 423 cur_base_offset = cur_base_offset / ((int) TYPE_LENGTH (ptr_type)); 424 425 /* We're now looking for the cur_base_offset'th entry (negative index) 426 in the vcall_and_vbase_offsets array. We used to cast the object to 427 its TYPE_VPTR_BASETYPE, and reference the vtable as TYPE_VPTR_FIELDNO; 428 however, that cast can not be done without calling baseclass_offset again 429 if the TYPE_VPTR_BASETYPE is a virtual base class, as described in the 430 v3 C++ ABI Section 2.4.I.2.b. Fortunately the ABI guarantees that the 431 vtable pointer will be located at the beginning of the object, so we can 432 bypass the casting. Verify that the TYPE_VPTR_FIELDNO is in fact at the 433 start of whichever baseclass it resides in, as a sanity measure - iff 434 we have debugging information for that baseclass. */ 435 436 vbasetype = check_typedef (TYPE_VPTR_BASETYPE (type)); 437 vbasetype_vptr_fieldno = get_vptr_fieldno (vbasetype, NULL); 438 439 if (vbasetype_vptr_fieldno >= 0 440 && TYPE_FIELD_BITPOS (vbasetype, vbasetype_vptr_fieldno) != 0) 441 error (_("Illegal vptr offset in class %s"), 442 TYPE_NAME (vbasetype) ? TYPE_NAME (vbasetype) : "<unknown>"); 443 444 vtable_address = value_as_address (value_at_lazy (ptr_type, address)); 445 vtable 446 = value_at_lazy (vtable_type, 447 vtable_address - vtable_address_point_offset (gdbarch)); 448 vbase_array = value_field (vtable, vtable_field_vcall_and_vbase_offsets); 449 base_offset = value_as_long (value_subscript (vbase_array, cur_base_offset)); 450 return base_offset; 451 } 452 453 /* Locate a virtual method in DOMAIN or its non-virtual base classes 454 which has virtual table index VOFFSET. The method has an associated 455 "this" adjustment of ADJUSTMENT bytes. */ 456 457 static const char * 458 gnuv3_find_method_in (struct type *domain, CORE_ADDR voffset, 459 LONGEST adjustment) 460 { 461 int i; 462 const char *physname; 463 464 /* Search this class first. */ 465 physname = NULL; 466 if (adjustment == 0) 467 { 468 int len; 469 470 len = TYPE_NFN_FIELDS (domain); 471 for (i = 0; i < len; i++) 472 { 473 int len2, j; 474 struct fn_field *f; 475 476 f = TYPE_FN_FIELDLIST1 (domain, i); 477 len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i); 478 479 check_stub_method_group (domain, i); 480 for (j = 0; j < len2; j++) 481 if (TYPE_FN_FIELD_VOFFSET (f, j) == voffset) 482 return TYPE_FN_FIELD_PHYSNAME (f, j); 483 } 484 } 485 486 /* Next search non-virtual bases. If it's in a virtual base, 487 we're out of luck. */ 488 for (i = 0; i < TYPE_N_BASECLASSES (domain); i++) 489 { 490 int pos; 491 struct type *basetype; 492 493 if (BASETYPE_VIA_VIRTUAL (domain, i)) 494 continue; 495 496 pos = TYPE_BASECLASS_BITPOS (domain, i) / 8; 497 basetype = TYPE_FIELD_TYPE (domain, i); 498 /* Recurse with a modified adjustment. We don't need to adjust 499 voffset. */ 500 if (adjustment >= pos && adjustment < pos + TYPE_LENGTH (basetype)) 501 return gnuv3_find_method_in (basetype, voffset, adjustment - pos); 502 } 503 504 return NULL; 505 } 506 507 /* Decode GNU v3 method pointer. */ 508 509 static int 510 gnuv3_decode_method_ptr (struct gdbarch *gdbarch, 511 const gdb_byte *contents, 512 CORE_ADDR *value_p, 513 LONGEST *adjustment_p) 514 { 515 struct type *funcptr_type = builtin_type (gdbarch)->builtin_func_ptr; 516 struct type *offset_type = vtable_ptrdiff_type (gdbarch); 517 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 518 CORE_ADDR ptr_value; 519 LONGEST voffset, adjustment; 520 int vbit; 521 522 /* Extract the pointer to member. The first element is either a pointer 523 or a vtable offset. For pointers, we need to use extract_typed_address 524 to allow the back-end to convert the pointer to a GDB address -- but 525 vtable offsets we must handle as integers. At this point, we do not 526 yet know which case we have, so we extract the value under both 527 interpretations and choose the right one later on. */ 528 ptr_value = extract_typed_address (contents, funcptr_type); 529 voffset = extract_signed_integer (contents, 530 TYPE_LENGTH (funcptr_type), byte_order); 531 contents += TYPE_LENGTH (funcptr_type); 532 adjustment = extract_signed_integer (contents, 533 TYPE_LENGTH (offset_type), byte_order); 534 535 if (!gdbarch_vbit_in_delta (gdbarch)) 536 { 537 vbit = voffset & 1; 538 voffset = voffset ^ vbit; 539 } 540 else 541 { 542 vbit = adjustment & 1; 543 adjustment = adjustment >> 1; 544 } 545 546 *value_p = vbit? voffset : ptr_value; 547 *adjustment_p = adjustment; 548 return vbit; 549 } 550 551 /* GNU v3 implementation of cplus_print_method_ptr. */ 552 553 static void 554 gnuv3_print_method_ptr (const gdb_byte *contents, 555 struct type *type, 556 struct ui_file *stream) 557 { 558 struct type *domain = TYPE_DOMAIN_TYPE (type); 559 struct gdbarch *gdbarch = get_type_arch (domain); 560 CORE_ADDR ptr_value; 561 LONGEST adjustment; 562 int vbit; 563 564 /* Extract the pointer to member. */ 565 vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment); 566 567 /* Check for NULL. */ 568 if (ptr_value == 0 && vbit == 0) 569 { 570 fprintf_filtered (stream, "NULL"); 571 return; 572 } 573 574 /* Search for a virtual method. */ 575 if (vbit) 576 { 577 CORE_ADDR voffset; 578 const char *physname; 579 580 /* It's a virtual table offset, maybe in this class. Search 581 for a field with the correct vtable offset. First convert it 582 to an index, as used in TYPE_FN_FIELD_VOFFSET. */ 583 voffset = ptr_value / TYPE_LENGTH (vtable_ptrdiff_type (gdbarch)); 584 585 physname = gnuv3_find_method_in (domain, voffset, adjustment); 586 587 /* If we found a method, print that. We don't bother to disambiguate 588 possible paths to the method based on the adjustment. */ 589 if (physname) 590 { 591 char *demangled_name = cplus_demangle (physname, 592 DMGL_ANSI | DMGL_PARAMS); 593 if (demangled_name != NULL) 594 { 595 fprintf_filtered (stream, "&virtual "); 596 fputs_filtered (demangled_name, stream); 597 xfree (demangled_name); 598 return; 599 } 600 } 601 } 602 603 /* We didn't find it; print the raw data. */ 604 if (vbit) 605 { 606 fprintf_filtered (stream, "&virtual table offset "); 607 print_longest (stream, 'd', 1, ptr_value); 608 } 609 else 610 print_address_demangle (gdbarch, ptr_value, stream, demangle); 611 612 if (adjustment) 613 { 614 fprintf_filtered (stream, ", this adjustment "); 615 print_longest (stream, 'd', 1, adjustment); 616 } 617 } 618 619 /* GNU v3 implementation of cplus_method_ptr_size. */ 620 621 static int 622 gnuv3_method_ptr_size (struct type *type) 623 { 624 struct type *domain_type = check_typedef (TYPE_DOMAIN_TYPE (type)); 625 struct gdbarch *gdbarch = get_type_arch (domain_type); 626 return 2 * TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr); 627 } 628 629 /* GNU v3 implementation of cplus_make_method_ptr. */ 630 631 static void 632 gnuv3_make_method_ptr (struct type *type, gdb_byte *contents, 633 CORE_ADDR value, int is_virtual) 634 { 635 struct type *domain_type = check_typedef (TYPE_DOMAIN_TYPE (type)); 636 struct gdbarch *gdbarch = get_type_arch (domain_type); 637 int size = TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr); 638 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 639 640 /* FIXME drow/2006-12-24: The adjustment of "this" is currently 641 always zero, since the method pointer is of the correct type. 642 But if the method pointer came from a base class, this is 643 incorrect - it should be the offset to the base. The best 644 fix might be to create the pointer to member pointing at the 645 base class and cast it to the derived class, but that requires 646 support for adjusting pointers to members when casting them - 647 not currently supported by GDB. */ 648 649 if (!gdbarch_vbit_in_delta (gdbarch)) 650 { 651 store_unsigned_integer (contents, size, byte_order, value | is_virtual); 652 store_unsigned_integer (contents + size, size, byte_order, 0); 653 } 654 else 655 { 656 store_unsigned_integer (contents, size, byte_order, value); 657 store_unsigned_integer (contents + size, size, byte_order, is_virtual); 658 } 659 } 660 661 /* GNU v3 implementation of cplus_method_ptr_to_value. */ 662 663 static struct value * 664 gnuv3_method_ptr_to_value (struct value **this_p, struct value *method_ptr) 665 { 666 struct gdbarch *gdbarch; 667 const gdb_byte *contents = value_contents (method_ptr); 668 CORE_ADDR ptr_value; 669 struct type *domain_type, *final_type, *method_type; 670 LONGEST adjustment; 671 int vbit; 672 673 domain_type = TYPE_DOMAIN_TYPE (check_typedef (value_type (method_ptr))); 674 final_type = lookup_pointer_type (domain_type); 675 676 method_type = TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr))); 677 678 /* Extract the pointer to member. */ 679 gdbarch = get_type_arch (domain_type); 680 vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment); 681 682 /* First convert THIS to match the containing type of the pointer to 683 member. This cast may adjust the value of THIS. */ 684 *this_p = value_cast (final_type, *this_p); 685 686 /* Then apply whatever adjustment is necessary. This creates a somewhat 687 strange pointer: it claims to have type FINAL_TYPE, but in fact it 688 might not be a valid FINAL_TYPE. For instance, it might be a 689 base class of FINAL_TYPE. And if it's not the primary base class, 690 then printing it out as a FINAL_TYPE object would produce some pretty 691 garbage. 692 693 But we don't really know the type of the first argument in 694 METHOD_TYPE either, which is why this happens. We can't 695 dereference this later as a FINAL_TYPE, but once we arrive in the 696 called method we'll have debugging information for the type of 697 "this" - and that'll match the value we produce here. 698 699 You can provoke this case by casting a Base::* to a Derived::*, for 700 instance. */ 701 *this_p = value_cast (builtin_type (gdbarch)->builtin_data_ptr, *this_p); 702 *this_p = value_ptradd (*this_p, adjustment); 703 *this_p = value_cast (final_type, *this_p); 704 705 if (vbit) 706 { 707 LONGEST voffset; 708 voffset = ptr_value / TYPE_LENGTH (vtable_ptrdiff_type (gdbarch)); 709 return gnuv3_get_virtual_fn (gdbarch, value_ind (*this_p), 710 method_type, voffset); 711 } 712 else 713 return value_from_pointer (lookup_pointer_type (method_type), ptr_value); 714 } 715 716 /* Determine if we are currently in a C++ thunk. If so, get the address 717 of the routine we are thunking to and continue to there instead. */ 718 719 static CORE_ADDR 720 gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc) 721 { 722 CORE_ADDR real_stop_pc, method_stop_pc; 723 struct gdbarch *gdbarch = get_frame_arch (frame); 724 struct minimal_symbol *thunk_sym, *fn_sym; 725 struct obj_section *section; 726 char *thunk_name, *fn_name; 727 728 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc); 729 if (real_stop_pc == 0) 730 real_stop_pc = stop_pc; 731 732 /* Find the linker symbol for this potential thunk. */ 733 thunk_sym = lookup_minimal_symbol_by_pc (real_stop_pc); 734 section = find_pc_section (real_stop_pc); 735 if (thunk_sym == NULL || section == NULL) 736 return 0; 737 738 /* The symbol's demangled name should be something like "virtual 739 thunk to FUNCTION", where FUNCTION is the name of the function 740 being thunked to. */ 741 thunk_name = SYMBOL_DEMANGLED_NAME (thunk_sym); 742 if (thunk_name == NULL || strstr (thunk_name, " thunk to ") == NULL) 743 return 0; 744 745 fn_name = strstr (thunk_name, " thunk to ") + strlen (" thunk to "); 746 fn_sym = lookup_minimal_symbol (fn_name, NULL, section->objfile); 747 if (fn_sym == NULL) 748 return 0; 749 750 method_stop_pc = SYMBOL_VALUE_ADDRESS (fn_sym); 751 real_stop_pc = gdbarch_skip_trampoline_code 752 (gdbarch, frame, method_stop_pc); 753 if (real_stop_pc == 0) 754 real_stop_pc = method_stop_pc; 755 756 return real_stop_pc; 757 } 758 759 /* Return nonzero if a type should be passed by reference. 760 761 The rule in the v3 ABI document comes from section 3.1.1. If the 762 type has a non-trivial copy constructor or destructor, then the 763 caller must make a copy (by calling the copy constructor if there 764 is one or perform the copy itself otherwise), pass the address of 765 the copy, and then destroy the temporary (if necessary). 766 767 For return values with non-trivial copy constructors or 768 destructors, space will be allocated in the caller, and a pointer 769 will be passed as the first argument (preceding "this"). 770 771 We don't have a bulletproof mechanism for determining whether a 772 constructor or destructor is trivial. For GCC and DWARF2 debug 773 information, we can check the artificial flag. 774 775 We don't do anything with the constructors or destructors, 776 but we have to get the argument passing right anyway. */ 777 static int 778 gnuv3_pass_by_reference (struct type *type) 779 { 780 int fieldnum, fieldelem; 781 782 CHECK_TYPEDEF (type); 783 784 /* We're only interested in things that can have methods. */ 785 if (TYPE_CODE (type) != TYPE_CODE_STRUCT 786 && TYPE_CODE (type) != TYPE_CODE_CLASS 787 && TYPE_CODE (type) != TYPE_CODE_UNION) 788 return 0; 789 790 for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++) 791 for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum); 792 fieldelem++) 793 { 794 struct fn_field *fn = TYPE_FN_FIELDLIST1 (type, fieldnum); 795 char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum); 796 struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem); 797 798 /* If this function is marked as artificial, it is compiler-generated, 799 and we assume it is trivial. */ 800 if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem)) 801 continue; 802 803 /* If we've found a destructor, we must pass this by reference. */ 804 if (name[0] == '~') 805 return 1; 806 807 /* If the mangled name of this method doesn't indicate that it 808 is a constructor, we're not interested. 809 810 FIXME drow/2007-09-23: We could do this using the name of 811 the method and the name of the class instead of dealing 812 with the mangled name. We don't have a convenient function 813 to strip off both leading scope qualifiers and trailing 814 template arguments yet. */ 815 if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem))) 816 continue; 817 818 /* If this method takes two arguments, and the second argument is 819 a reference to this class, then it is a copy constructor. */ 820 if (TYPE_NFIELDS (fieldtype) == 2 821 && TYPE_CODE (TYPE_FIELD_TYPE (fieldtype, 1)) == TYPE_CODE_REF 822 && check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (fieldtype, 1))) == type) 823 return 1; 824 } 825 826 /* Even if all the constructors and destructors were artificial, one 827 of them may have invoked a non-artificial constructor or 828 destructor in a base class. If any base class needs to be passed 829 by reference, so does this class. Similarly for members, which 830 are constructed whenever this class is. We do not need to worry 831 about recursive loops here, since we are only looking at members 832 of complete class type. */ 833 for (fieldnum = 0; fieldnum < TYPE_NFIELDS (type); fieldnum++) 834 if (gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum))) 835 return 1; 836 837 return 0; 838 } 839 840 static void 841 init_gnuv3_ops (void) 842 { 843 vtable_type_gdbarch_data = gdbarch_data_register_post_init (build_gdb_vtable_type); 844 845 gnu_v3_abi_ops.shortname = "gnu-v3"; 846 gnu_v3_abi_ops.longname = "GNU G++ Version 3 ABI"; 847 gnu_v3_abi_ops.doc = "G++ Version 3 ABI"; 848 gnu_v3_abi_ops.is_destructor_name = 849 (enum dtor_kinds (*) (const char *))is_gnu_v3_mangled_dtor; 850 gnu_v3_abi_ops.is_constructor_name = 851 (enum ctor_kinds (*) (const char *))is_gnu_v3_mangled_ctor; 852 gnu_v3_abi_ops.is_vtable_name = gnuv3_is_vtable_name; 853 gnu_v3_abi_ops.is_operator_name = gnuv3_is_operator_name; 854 gnu_v3_abi_ops.rtti_type = gnuv3_rtti_type; 855 gnu_v3_abi_ops.virtual_fn_field = gnuv3_virtual_fn_field; 856 gnu_v3_abi_ops.baseclass_offset = gnuv3_baseclass_offset; 857 gnu_v3_abi_ops.print_method_ptr = gnuv3_print_method_ptr; 858 gnu_v3_abi_ops.method_ptr_size = gnuv3_method_ptr_size; 859 gnu_v3_abi_ops.make_method_ptr = gnuv3_make_method_ptr; 860 gnu_v3_abi_ops.method_ptr_to_value = gnuv3_method_ptr_to_value; 861 gnu_v3_abi_ops.skip_trampoline = gnuv3_skip_trampoline; 862 gnu_v3_abi_ops.pass_by_reference = gnuv3_pass_by_reference; 863 } 864 865 extern initialize_file_ftype _initialize_gnu_v3_abi; /* -Wmissing-prototypes */ 866 867 void 868 _initialize_gnu_v3_abi (void) 869 { 870 init_gnuv3_ops (); 871 872 register_cp_abi (&gnu_v3_abi_ops); 873 } 874