1 /* debug.c -- Handle generic debugging information. 2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2005, 2007, 3 2009 Free Software Foundation, Inc. 4 Written by Ian Lance Taylor <ian@cygnus.com>. 5 6 This file is part of GNU Binutils. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 21 02110-1301, USA. */ 22 23 24 /* This file implements a generic debugging format. We may eventually 25 have readers which convert different formats into this generic 26 format, and writers which write it out. The initial impetus for 27 this was writing a converter from stabs to HP IEEE-695 debugging 28 format. */ 29 30 #include "sysdep.h" 31 #include <assert.h> 32 #include "bfd.h" 33 #include "libiberty.h" 34 #include "filenames.h" 35 #include "debug.h" 36 37 /* Global information we keep for debugging. A pointer to this 38 structure is the debugging handle passed to all the routines. */ 39 40 struct debug_handle 41 { 42 /* A linked list of compilation units. */ 43 struct debug_unit *units; 44 /* The current compilation unit. */ 45 struct debug_unit *current_unit; 46 /* The current source file. */ 47 struct debug_file *current_file; 48 /* The current function. */ 49 struct debug_function *current_function; 50 /* The current block. */ 51 struct debug_block *current_block; 52 /* The current line number information for the current unit. */ 53 struct debug_lineno *current_lineno; 54 /* Mark. This is used by debug_write. */ 55 unsigned int mark; 56 /* A struct/class ID used by debug_write. */ 57 unsigned int class_id; 58 /* The base for class_id for this call to debug_write. */ 59 unsigned int base_id; 60 /* The current line number in debug_write. */ 61 struct debug_lineno *current_write_lineno; 62 unsigned int current_write_lineno_index; 63 /* A list of classes which have assigned ID's during debug_write. 64 This is linked through the next_id field of debug_class_type. */ 65 struct debug_class_id *id_list; 66 /* A list used to avoid recursion during debug_type_samep. */ 67 struct debug_type_compare_list *compare_list; 68 }; 69 70 /* Information we keep for a single compilation unit. */ 71 72 struct debug_unit 73 { 74 /* The next compilation unit. */ 75 struct debug_unit *next; 76 /* A list of files included in this compilation unit. The first 77 file is always the main one, and that is where the main file name 78 is stored. */ 79 struct debug_file *files; 80 /* Line number information for this compilation unit. This is not 81 stored by function, because assembler code may have line number 82 information without function information. */ 83 struct debug_lineno *linenos; 84 }; 85 86 /* Information kept for a single source file. */ 87 88 struct debug_file 89 { 90 /* The next source file in this compilation unit. */ 91 struct debug_file *next; 92 /* The name of the source file. */ 93 const char *filename; 94 /* Global functions, variables, types, etc. */ 95 struct debug_namespace *globals; 96 }; 97 98 /* A type. */ 99 100 struct debug_type_s 101 { 102 /* Kind of type. */ 103 enum debug_type_kind kind; 104 /* Size of type (0 if not known). */ 105 unsigned int size; 106 /* Type which is a pointer to this type. */ 107 debug_type pointer; 108 /* Tagged union with additional information about the type. */ 109 union 110 { 111 /* DEBUG_KIND_INDIRECT. */ 112 struct debug_indirect_type *kindirect; 113 /* DEBUG_KIND_INT. */ 114 /* Whether the integer is unsigned. */ 115 bfd_boolean kint; 116 /* DEBUG_KIND_STRUCT, DEBUG_KIND_UNION, DEBUG_KIND_CLASS, 117 DEBUG_KIND_UNION_CLASS. */ 118 struct debug_class_type *kclass; 119 /* DEBUG_KIND_ENUM. */ 120 struct debug_enum_type *kenum; 121 /* DEBUG_KIND_POINTER. */ 122 struct debug_type_s *kpointer; 123 /* DEBUG_KIND_FUNCTION. */ 124 struct debug_function_type *kfunction; 125 /* DEBUG_KIND_REFERENCE. */ 126 struct debug_type_s *kreference; 127 /* DEBUG_KIND_RANGE. */ 128 struct debug_range_type *krange; 129 /* DEBUG_KIND_ARRAY. */ 130 struct debug_array_type *karray; 131 /* DEBUG_KIND_SET. */ 132 struct debug_set_type *kset; 133 /* DEBUG_KIND_OFFSET. */ 134 struct debug_offset_type *koffset; 135 /* DEBUG_KIND_METHOD. */ 136 struct debug_method_type *kmethod; 137 /* DEBUG_KIND_CONST. */ 138 struct debug_type_s *kconst; 139 /* DEBUG_KIND_VOLATILE. */ 140 struct debug_type_s *kvolatile; 141 /* DEBUG_KIND_NAMED, DEBUG_KIND_TAGGED. */ 142 struct debug_named_type *knamed; 143 } u; 144 }; 145 146 /* Information kept for an indirect type. */ 147 148 struct debug_indirect_type 149 { 150 /* Slot where the final type will appear. */ 151 debug_type *slot; 152 /* Tag. */ 153 const char *tag; 154 }; 155 156 /* Information kept for a struct, union, or class. */ 157 158 struct debug_class_type 159 { 160 /* NULL terminated array of fields. */ 161 debug_field *fields; 162 /* A mark field which indicates whether the struct has already been 163 printed. */ 164 unsigned int mark; 165 /* This is used to uniquely identify unnamed structs when printing. */ 166 unsigned int id; 167 /* The remaining fields are only used for DEBUG_KIND_CLASS and 168 DEBUG_KIND_UNION_CLASS. */ 169 /* NULL terminated array of base classes. */ 170 debug_baseclass *baseclasses; 171 /* NULL terminated array of methods. */ 172 debug_method *methods; 173 /* The type of the class providing the virtual function table for 174 this class. This may point to the type itself. */ 175 debug_type vptrbase; 176 }; 177 178 /* Information kept for an enum. */ 179 180 struct debug_enum_type 181 { 182 /* NULL terminated array of names. */ 183 const char **names; 184 /* Array of corresponding values. */ 185 bfd_signed_vma *values; 186 }; 187 188 /* Information kept for a function. FIXME: We should be able to 189 record the parameter types. */ 190 191 struct debug_function_type 192 { 193 /* Return type. */ 194 debug_type return_type; 195 /* NULL terminated array of argument types. */ 196 debug_type *arg_types; 197 /* Whether the function takes a variable number of arguments. */ 198 bfd_boolean varargs; 199 }; 200 201 /* Information kept for a range. */ 202 203 struct debug_range_type 204 { 205 /* Range base type. */ 206 debug_type type; 207 /* Lower bound. */ 208 bfd_signed_vma lower; 209 /* Upper bound. */ 210 bfd_signed_vma upper; 211 }; 212 213 /* Information kept for an array. */ 214 215 struct debug_array_type 216 { 217 /* Element type. */ 218 debug_type element_type; 219 /* Range type. */ 220 debug_type range_type; 221 /* Lower bound. */ 222 bfd_signed_vma lower; 223 /* Upper bound. */ 224 bfd_signed_vma upper; 225 /* Whether this array is really a string. */ 226 bfd_boolean stringp; 227 }; 228 229 /* Information kept for a set. */ 230 231 struct debug_set_type 232 { 233 /* Base type. */ 234 debug_type type; 235 /* Whether this set is really a bitstring. */ 236 bfd_boolean bitstringp; 237 }; 238 239 /* Information kept for an offset type (a based pointer). */ 240 241 struct debug_offset_type 242 { 243 /* The type the pointer is an offset from. */ 244 debug_type base_type; 245 /* The type the pointer points to. */ 246 debug_type target_type; 247 }; 248 249 /* Information kept for a method type. */ 250 251 struct debug_method_type 252 { 253 /* The return type. */ 254 debug_type return_type; 255 /* The object type which this method is for. */ 256 debug_type domain_type; 257 /* A NULL terminated array of argument types. */ 258 debug_type *arg_types; 259 /* Whether the method takes a variable number of arguments. */ 260 bfd_boolean varargs; 261 }; 262 263 /* Information kept for a named type. */ 264 265 struct debug_named_type 266 { 267 /* Name. */ 268 struct debug_name *name; 269 /* Real type. */ 270 debug_type type; 271 }; 272 273 /* A field in a struct or union. */ 274 275 struct debug_field_s 276 { 277 /* Name of the field. */ 278 const char *name; 279 /* Type of the field. */ 280 struct debug_type_s *type; 281 /* Visibility of the field. */ 282 enum debug_visibility visibility; 283 /* Whether this is a static member. */ 284 bfd_boolean static_member; 285 union 286 { 287 /* If static_member is false. */ 288 struct 289 { 290 /* Bit position of the field in the struct. */ 291 unsigned int bitpos; 292 /* Size of the field in bits. */ 293 unsigned int bitsize; 294 } f; 295 /* If static_member is true. */ 296 struct 297 { 298 const char *physname; 299 } s; 300 } u; 301 }; 302 303 /* A base class for an object. */ 304 305 struct debug_baseclass_s 306 { 307 /* Type of the base class. */ 308 struct debug_type_s *type; 309 /* Bit position of the base class in the object. */ 310 unsigned int bitpos; 311 /* Whether the base class is virtual. */ 312 bfd_boolean is_virtual; 313 /* Visibility of the base class. */ 314 enum debug_visibility visibility; 315 }; 316 317 /* A method of an object. */ 318 319 struct debug_method_s 320 { 321 /* The name of the method. */ 322 const char *name; 323 /* A NULL terminated array of different types of variants. */ 324 struct debug_method_variant_s **variants; 325 }; 326 327 /* The variants of a method function of an object. These indicate 328 which method to run. */ 329 330 struct debug_method_variant_s 331 { 332 /* The physical name of the function. */ 333 const char *physname; 334 /* The type of the function. */ 335 struct debug_type_s *type; 336 /* The visibility of the function. */ 337 enum debug_visibility visibility; 338 /* Whether the function is const. */ 339 bfd_boolean constp; 340 /* Whether the function is volatile. */ 341 bfd_boolean volatilep; 342 /* The offset to the function in the virtual function table. */ 343 bfd_vma voffset; 344 /* If voffset is VOFFSET_STATIC_METHOD, this is a static method. */ 345 #define VOFFSET_STATIC_METHOD ((bfd_vma) -1) 346 /* Context of a virtual method function. */ 347 struct debug_type_s *context; 348 }; 349 350 /* A variable. This is the information we keep for a variable object. 351 This has no name; a name is associated with a variable in a 352 debug_name structure. */ 353 354 struct debug_variable 355 { 356 /* Kind of variable. */ 357 enum debug_var_kind kind; 358 /* Type. */ 359 debug_type type; 360 /* Value. The interpretation of the value depends upon kind. */ 361 bfd_vma val; 362 }; 363 364 /* A function. This has no name; a name is associated with a function 365 in a debug_name structure. */ 366 367 struct debug_function 368 { 369 /* Return type. */ 370 debug_type return_type; 371 /* Parameter information. */ 372 struct debug_parameter *parameters; 373 /* Block information. The first structure on the list is the main 374 block of the function, and describes function local variables. */ 375 struct debug_block *blocks; 376 }; 377 378 /* A function parameter. */ 379 380 struct debug_parameter 381 { 382 /* Next parameter. */ 383 struct debug_parameter *next; 384 /* Name. */ 385 const char *name; 386 /* Type. */ 387 debug_type type; 388 /* Kind. */ 389 enum debug_parm_kind kind; 390 /* Value (meaning depends upon kind). */ 391 bfd_vma val; 392 }; 393 394 /* A typed constant. */ 395 396 struct debug_typed_constant 397 { 398 /* Type. */ 399 debug_type type; 400 /* Value. FIXME: We may eventually need to support non-integral 401 values. */ 402 bfd_vma val; 403 }; 404 405 /* Information about a block within a function. */ 406 407 struct debug_block 408 { 409 /* Next block with the same parent. */ 410 struct debug_block *next; 411 /* Parent block. */ 412 struct debug_block *parent; 413 /* List of child blocks. */ 414 struct debug_block *children; 415 /* Start address of the block. */ 416 bfd_vma start; 417 /* End address of the block. */ 418 bfd_vma end; 419 /* Local variables. */ 420 struct debug_namespace *locals; 421 }; 422 423 /* Line number information we keep for a compilation unit. FIXME: 424 This structure is easy to create, but can be very space 425 inefficient. */ 426 427 struct debug_lineno 428 { 429 /* More line number information for this block. */ 430 struct debug_lineno *next; 431 /* Source file. */ 432 struct debug_file *file; 433 /* Line numbers, terminated by a -1 or the end of the array. */ 434 #define DEBUG_LINENO_COUNT 10 435 unsigned long linenos[DEBUG_LINENO_COUNT]; 436 /* Addresses for the line numbers. */ 437 bfd_vma addrs[DEBUG_LINENO_COUNT]; 438 }; 439 440 /* A namespace. This is a mapping from names to objects. FIXME: This 441 should be implemented as a hash table. */ 442 443 struct debug_namespace 444 { 445 /* List of items in this namespace. */ 446 struct debug_name *list; 447 /* Pointer to where the next item in this namespace should go. */ 448 struct debug_name **tail; 449 }; 450 451 /* Kinds of objects that appear in a namespace. */ 452 453 enum debug_object_kind 454 { 455 /* A type. */ 456 DEBUG_OBJECT_TYPE, 457 /* A tagged type (really a different sort of namespace). */ 458 DEBUG_OBJECT_TAG, 459 /* A variable. */ 460 DEBUG_OBJECT_VARIABLE, 461 /* A function. */ 462 DEBUG_OBJECT_FUNCTION, 463 /* An integer constant. */ 464 DEBUG_OBJECT_INT_CONSTANT, 465 /* A floating point constant. */ 466 DEBUG_OBJECT_FLOAT_CONSTANT, 467 /* A typed constant. */ 468 DEBUG_OBJECT_TYPED_CONSTANT 469 }; 470 471 /* Linkage of an object that appears in a namespace. */ 472 473 enum debug_object_linkage 474 { 475 /* Local variable. */ 476 DEBUG_LINKAGE_AUTOMATIC, 477 /* Static--either file static or function static, depending upon the 478 namespace is. */ 479 DEBUG_LINKAGE_STATIC, 480 /* Global. */ 481 DEBUG_LINKAGE_GLOBAL, 482 /* No linkage. */ 483 DEBUG_LINKAGE_NONE 484 }; 485 486 /* A name in a namespace. */ 487 488 struct debug_name 489 { 490 /* Next name in this namespace. */ 491 struct debug_name *next; 492 /* Name. */ 493 const char *name; 494 /* Mark. This is used by debug_write. */ 495 unsigned int mark; 496 /* Kind of object. */ 497 enum debug_object_kind kind; 498 /* Linkage of object. */ 499 enum debug_object_linkage linkage; 500 /* Tagged union with additional information about the object. */ 501 union 502 { 503 /* DEBUG_OBJECT_TYPE. */ 504 struct debug_type_s *type; 505 /* DEBUG_OBJECT_TAG. */ 506 struct debug_type_s *tag; 507 /* DEBUG_OBJECT_VARIABLE. */ 508 struct debug_variable *variable; 509 /* DEBUG_OBJECT_FUNCTION. */ 510 struct debug_function *function; 511 /* DEBUG_OBJECT_INT_CONSTANT. */ 512 bfd_vma int_constant; 513 /* DEBUG_OBJECT_FLOAT_CONSTANT. */ 514 double float_constant; 515 /* DEBUG_OBJECT_TYPED_CONSTANT. */ 516 struct debug_typed_constant *typed_constant; 517 } u; 518 }; 519 520 /* During debug_write, a linked list of these structures is used to 521 keep track of ID numbers that have been assigned to classes. */ 522 523 struct debug_class_id 524 { 525 /* Next ID number. */ 526 struct debug_class_id *next; 527 /* The type with the ID. */ 528 struct debug_type_s *type; 529 /* The tag; NULL if no tag. */ 530 const char *tag; 531 }; 532 533 /* During debug_type_samep, a linked list of these structures is kept 534 on the stack to avoid infinite recursion. */ 535 536 struct debug_type_compare_list 537 { 538 /* Next type on list. */ 539 struct debug_type_compare_list *next; 540 /* The types we are comparing. */ 541 struct debug_type_s *t1; 542 struct debug_type_s *t2; 543 }; 544 545 /* During debug_get_real_type, a linked list of these structures is 546 kept on the stack to avoid infinite recursion. */ 547 548 struct debug_type_real_list 549 { 550 /* Next type on list. */ 551 struct debug_type_real_list *next; 552 /* The type we are checking. */ 553 struct debug_type_s *t; 554 }; 555 556 /* Local functions. */ 557 558 static void debug_error (const char *); 559 static struct debug_name *debug_add_to_namespace 560 (struct debug_handle *, struct debug_namespace **, const char *, 561 enum debug_object_kind, enum debug_object_linkage); 562 static struct debug_name *debug_add_to_current_namespace 563 (struct debug_handle *, const char *, enum debug_object_kind, 564 enum debug_object_linkage); 565 static struct debug_type_s *debug_make_type 566 (struct debug_handle *, enum debug_type_kind, unsigned int); 567 static struct debug_type_s *debug_get_real_type 568 (void *, debug_type, struct debug_type_real_list *); 569 static bfd_boolean debug_write_name 570 (struct debug_handle *, const struct debug_write_fns *, void *, 571 struct debug_name *); 572 static bfd_boolean debug_write_type 573 (struct debug_handle *, const struct debug_write_fns *, void *, 574 struct debug_type_s *, struct debug_name *); 575 static bfd_boolean debug_write_class_type 576 (struct debug_handle *, const struct debug_write_fns *, void *, 577 struct debug_type_s *, const char *); 578 static bfd_boolean debug_write_function 579 (struct debug_handle *, const struct debug_write_fns *, void *, 580 const char *, enum debug_object_linkage, struct debug_function *); 581 static bfd_boolean debug_write_block 582 (struct debug_handle *, const struct debug_write_fns *, void *, 583 struct debug_block *); 584 static bfd_boolean debug_write_linenos 585 (struct debug_handle *, const struct debug_write_fns *, void *, bfd_vma); 586 static bfd_boolean debug_set_class_id 587 (struct debug_handle *, const char *, struct debug_type_s *); 588 static bfd_boolean debug_type_samep 589 (struct debug_handle *, struct debug_type_s *, struct debug_type_s *); 590 static bfd_boolean debug_class_type_samep 591 (struct debug_handle *, struct debug_type_s *, struct debug_type_s *); 592 593 /* Issue an error message. */ 594 595 static void 596 debug_error (const char *message) 597 { 598 fprintf (stderr, "%s\n", message); 599 } 600 601 /* Add an object to a namespace. */ 602 603 static struct debug_name * 604 debug_add_to_namespace (struct debug_handle *info ATTRIBUTE_UNUSED, 605 struct debug_namespace **nsp, const char *name, 606 enum debug_object_kind kind, 607 enum debug_object_linkage linkage) 608 { 609 struct debug_name *n; 610 struct debug_namespace *ns; 611 612 n = (struct debug_name *) xmalloc (sizeof *n); 613 memset (n, 0, sizeof *n); 614 615 n->name = name; 616 n->kind = kind; 617 n->linkage = linkage; 618 619 ns = *nsp; 620 if (ns == NULL) 621 { 622 ns = (struct debug_namespace *) xmalloc (sizeof *ns); 623 memset (ns, 0, sizeof *ns); 624 625 ns->tail = &ns->list; 626 627 *nsp = ns; 628 } 629 630 *ns->tail = n; 631 ns->tail = &n->next; 632 633 return n; 634 } 635 636 /* Add an object to the current namespace. */ 637 638 static struct debug_name * 639 debug_add_to_current_namespace (struct debug_handle *info, const char *name, 640 enum debug_object_kind kind, 641 enum debug_object_linkage linkage) 642 { 643 struct debug_namespace **nsp; 644 645 if (info->current_unit == NULL 646 || info->current_file == NULL) 647 { 648 debug_error (_("debug_add_to_current_namespace: no current file")); 649 return NULL; 650 } 651 652 if (info->current_block != NULL) 653 nsp = &info->current_block->locals; 654 else 655 nsp = &info->current_file->globals; 656 657 return debug_add_to_namespace (info, nsp, name, kind, linkage); 658 } 659 660 /* Return a handle for debugging information. */ 661 662 void * 663 debug_init (void) 664 { 665 struct debug_handle *ret; 666 667 ret = (struct debug_handle *) xmalloc (sizeof *ret); 668 memset (ret, 0, sizeof *ret); 669 return (void *) ret; 670 } 671 672 /* Set the source filename. This implicitly starts a new compilation 673 unit. */ 674 675 bfd_boolean 676 debug_set_filename (void *handle, const char *name) 677 { 678 struct debug_handle *info = (struct debug_handle *) handle; 679 struct debug_file *nfile; 680 struct debug_unit *nunit; 681 682 if (name == NULL) 683 name = ""; 684 685 nfile = (struct debug_file *) xmalloc (sizeof *nfile); 686 memset (nfile, 0, sizeof *nfile); 687 688 nfile->filename = name; 689 690 nunit = (struct debug_unit *) xmalloc (sizeof *nunit); 691 memset (nunit, 0, sizeof *nunit); 692 693 nunit->files = nfile; 694 info->current_file = nfile; 695 696 if (info->current_unit != NULL) 697 info->current_unit->next = nunit; 698 else 699 { 700 assert (info->units == NULL); 701 info->units = nunit; 702 } 703 704 info->current_unit = nunit; 705 706 info->current_function = NULL; 707 info->current_block = NULL; 708 info->current_lineno = NULL; 709 710 return TRUE; 711 } 712 713 /* Change source files to the given file name. This is used for 714 include files in a single compilation unit. */ 715 716 bfd_boolean 717 debug_start_source (void *handle, const char *name) 718 { 719 struct debug_handle *info = (struct debug_handle *) handle; 720 struct debug_file *f, **pf; 721 722 if (name == NULL) 723 name = ""; 724 725 if (info->current_unit == NULL) 726 { 727 debug_error (_("debug_start_source: no debug_set_filename call")); 728 return FALSE; 729 } 730 731 for (f = info->current_unit->files; f != NULL; f = f->next) 732 { 733 if (filename_cmp (f->filename, name) == 0) 734 { 735 info->current_file = f; 736 return TRUE; 737 } 738 } 739 740 f = (struct debug_file *) xmalloc (sizeof *f); 741 memset (f, 0, sizeof *f); 742 743 f->filename = name; 744 745 for (pf = &info->current_file->next; 746 *pf != NULL; 747 pf = &(*pf)->next) 748 ; 749 *pf = f; 750 751 info->current_file = f; 752 753 return TRUE; 754 } 755 756 /* Record a function definition. This implicitly starts a function 757 block. The debug_type argument is the type of the return value. 758 The boolean indicates whether the function is globally visible. 759 The bfd_vma is the address of the start of the function. Currently 760 the parameter types are specified by calls to 761 debug_record_parameter. FIXME: There is no way to specify nested 762 functions. */ 763 764 bfd_boolean 765 debug_record_function (void *handle, const char *name, 766 debug_type return_type, bfd_boolean global, 767 bfd_vma addr) 768 { 769 struct debug_handle *info = (struct debug_handle *) handle; 770 struct debug_function *f; 771 struct debug_block *b; 772 struct debug_name *n; 773 774 if (name == NULL) 775 name = ""; 776 if (return_type == NULL) 777 return FALSE; 778 779 if (info->current_unit == NULL) 780 { 781 debug_error (_("debug_record_function: no debug_set_filename call")); 782 return FALSE; 783 } 784 785 f = (struct debug_function *) xmalloc (sizeof *f); 786 memset (f, 0, sizeof *f); 787 788 f->return_type = return_type; 789 790 b = (struct debug_block *) xmalloc (sizeof *b); 791 memset (b, 0, sizeof *b); 792 793 b->start = addr; 794 b->end = (bfd_vma) -1; 795 796 f->blocks = b; 797 798 info->current_function = f; 799 info->current_block = b; 800 801 /* FIXME: If we could handle nested functions, this would be the 802 place: we would want to use a different namespace. */ 803 n = debug_add_to_namespace (info, 804 &info->current_file->globals, 805 name, 806 DEBUG_OBJECT_FUNCTION, 807 (global 808 ? DEBUG_LINKAGE_GLOBAL 809 : DEBUG_LINKAGE_STATIC)); 810 if (n == NULL) 811 return FALSE; 812 813 n->u.function = f; 814 815 return TRUE; 816 } 817 818 /* Record a parameter for the current function. */ 819 820 bfd_boolean 821 debug_record_parameter (void *handle, const char *name, debug_type type, 822 enum debug_parm_kind kind, bfd_vma val) 823 { 824 struct debug_handle *info = (struct debug_handle *) handle; 825 struct debug_parameter *p, **pp; 826 827 if (name == NULL || type == NULL) 828 return FALSE; 829 830 if (info->current_unit == NULL 831 || info->current_function == NULL) 832 { 833 debug_error (_("debug_record_parameter: no current function")); 834 return FALSE; 835 } 836 837 p = (struct debug_parameter *) xmalloc (sizeof *p); 838 memset (p, 0, sizeof *p); 839 840 p->name = name; 841 p->type = type; 842 p->kind = kind; 843 p->val = val; 844 845 for (pp = &info->current_function->parameters; 846 *pp != NULL; 847 pp = &(*pp)->next) 848 ; 849 *pp = p; 850 851 return TRUE; 852 } 853 854 /* End a function. FIXME: This should handle function nesting. */ 855 856 bfd_boolean 857 debug_end_function (void *handle, bfd_vma addr) 858 { 859 struct debug_handle *info = (struct debug_handle *) handle; 860 861 if (info->current_unit == NULL 862 || info->current_block == NULL 863 || info->current_function == NULL) 864 { 865 debug_error (_("debug_end_function: no current function")); 866 return FALSE; 867 } 868 869 if (info->current_block->parent != NULL) 870 { 871 debug_error (_("debug_end_function: some blocks were not closed")); 872 return FALSE; 873 } 874 875 info->current_block->end = addr; 876 877 info->current_function = NULL; 878 info->current_block = NULL; 879 880 return TRUE; 881 } 882 883 /* Start a block in a function. All local information will be 884 recorded in this block, until the matching call to debug_end_block. 885 debug_start_block and debug_end_block may be nested. The bfd_vma 886 argument is the address at which this block starts. */ 887 888 bfd_boolean 889 debug_start_block (void *handle, bfd_vma addr) 890 { 891 struct debug_handle *info = (struct debug_handle *) handle; 892 struct debug_block *b, **pb; 893 894 /* We must always have a current block: debug_record_function sets 895 one up. */ 896 if (info->current_unit == NULL 897 || info->current_block == NULL) 898 { 899 debug_error (_("debug_start_block: no current block")); 900 return FALSE; 901 } 902 903 b = (struct debug_block *) xmalloc (sizeof *b); 904 memset (b, 0, sizeof *b); 905 906 b->parent = info->current_block; 907 b->start = addr; 908 b->end = (bfd_vma) -1; 909 910 /* This new block is a child of the current block. */ 911 for (pb = &info->current_block->children; 912 *pb != NULL; 913 pb = &(*pb)->next) 914 ; 915 *pb = b; 916 917 info->current_block = b; 918 919 return TRUE; 920 } 921 922 /* Finish a block in a function. This matches the call to 923 debug_start_block. The argument is the address at which this block 924 ends. */ 925 926 bfd_boolean 927 debug_end_block (void *handle, bfd_vma addr) 928 { 929 struct debug_handle *info = (struct debug_handle *) handle; 930 struct debug_block *parent; 931 932 if (info->current_unit == NULL 933 || info->current_block == NULL) 934 { 935 debug_error (_("debug_end_block: no current block")); 936 return FALSE; 937 } 938 939 parent = info->current_block->parent; 940 if (parent == NULL) 941 { 942 debug_error (_("debug_end_block: attempt to close top level block")); 943 return FALSE; 944 } 945 946 info->current_block->end = addr; 947 948 info->current_block = parent; 949 950 return TRUE; 951 } 952 953 /* Associate a line number in the current source file and function 954 with a given address. */ 955 956 bfd_boolean 957 debug_record_line (void *handle, unsigned long lineno, bfd_vma addr) 958 { 959 struct debug_handle *info = (struct debug_handle *) handle; 960 struct debug_lineno *l; 961 unsigned int i; 962 963 if (info->current_unit == NULL) 964 { 965 debug_error (_("debug_record_line: no current unit")); 966 return FALSE; 967 } 968 969 l = info->current_lineno; 970 if (l != NULL && l->file == info->current_file) 971 { 972 for (i = 0; i < DEBUG_LINENO_COUNT; i++) 973 { 974 if (l->linenos[i] == (unsigned long) -1) 975 { 976 l->linenos[i] = lineno; 977 l->addrs[i] = addr; 978 return TRUE; 979 } 980 } 981 } 982 983 /* If we get here, then either 1) there is no current_lineno 984 structure, which means this is the first line number in this 985 compilation unit, 2) the current_lineno structure is for a 986 different file, or 3) the current_lineno structure is full. 987 Regardless, we want to allocate a new debug_lineno structure, put 988 it in the right place, and make it the new current_lineno 989 structure. */ 990 991 l = (struct debug_lineno *) xmalloc (sizeof *l); 992 memset (l, 0, sizeof *l); 993 994 l->file = info->current_file; 995 l->linenos[0] = lineno; 996 l->addrs[0] = addr; 997 for (i = 1; i < DEBUG_LINENO_COUNT; i++) 998 l->linenos[i] = (unsigned long) -1; 999 1000 if (info->current_lineno != NULL) 1001 info->current_lineno->next = l; 1002 else 1003 info->current_unit->linenos = l; 1004 1005 info->current_lineno = l; 1006 1007 return TRUE; 1008 } 1009 1010 /* Start a named common block. This is a block of variables that may 1011 move in memory. */ 1012 1013 bfd_boolean 1014 debug_start_common_block (void *handle ATTRIBUTE_UNUSED, 1015 const char *name ATTRIBUTE_UNUSED) 1016 { 1017 /* FIXME */ 1018 debug_error (_("debug_start_common_block: not implemented")); 1019 return FALSE; 1020 } 1021 1022 /* End a named common block. */ 1023 1024 bfd_boolean 1025 debug_end_common_block (void *handle ATTRIBUTE_UNUSED, 1026 const char *name ATTRIBUTE_UNUSED) 1027 { 1028 /* FIXME */ 1029 debug_error (_("debug_end_common_block: not implemented")); 1030 return FALSE; 1031 } 1032 1033 /* Record a named integer constant. */ 1034 1035 bfd_boolean 1036 debug_record_int_const (void *handle, const char *name, bfd_vma val) 1037 { 1038 struct debug_handle *info = (struct debug_handle *) handle; 1039 struct debug_name *n; 1040 1041 if (name == NULL) 1042 return FALSE; 1043 1044 n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_INT_CONSTANT, 1045 DEBUG_LINKAGE_NONE); 1046 if (n == NULL) 1047 return FALSE; 1048 1049 n->u.int_constant = val; 1050 1051 return TRUE; 1052 } 1053 1054 /* Record a named floating point constant. */ 1055 1056 bfd_boolean 1057 debug_record_float_const (void *handle, const char *name, double val) 1058 { 1059 struct debug_handle *info = (struct debug_handle *) handle; 1060 struct debug_name *n; 1061 1062 if (name == NULL) 1063 return FALSE; 1064 1065 n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_FLOAT_CONSTANT, 1066 DEBUG_LINKAGE_NONE); 1067 if (n == NULL) 1068 return FALSE; 1069 1070 n->u.float_constant = val; 1071 1072 return TRUE; 1073 } 1074 1075 /* Record a typed constant with an integral value. */ 1076 1077 bfd_boolean 1078 debug_record_typed_const (void *handle, const char *name, debug_type type, 1079 bfd_vma val) 1080 { 1081 struct debug_handle *info = (struct debug_handle *) handle; 1082 struct debug_name *n; 1083 struct debug_typed_constant *tc; 1084 1085 if (name == NULL || type == NULL) 1086 return FALSE; 1087 1088 n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_TYPED_CONSTANT, 1089 DEBUG_LINKAGE_NONE); 1090 if (n == NULL) 1091 return FALSE; 1092 1093 tc = (struct debug_typed_constant *) xmalloc (sizeof *tc); 1094 memset (tc, 0, sizeof *tc); 1095 1096 tc->type = type; 1097 tc->val = val; 1098 1099 n->u.typed_constant = tc; 1100 1101 return TRUE; 1102 } 1103 1104 /* Record a label. */ 1105 1106 bfd_boolean 1107 debug_record_label (void *handle ATTRIBUTE_UNUSED, 1108 const char *name ATTRIBUTE_UNUSED, 1109 debug_type type ATTRIBUTE_UNUSED, 1110 bfd_vma addr ATTRIBUTE_UNUSED) 1111 { 1112 /* FIXME. */ 1113 debug_error (_("debug_record_label: not implemented")); 1114 return FALSE; 1115 } 1116 1117 /* Record a variable. */ 1118 1119 bfd_boolean 1120 debug_record_variable (void *handle, const char *name, debug_type type, 1121 enum debug_var_kind kind, bfd_vma val) 1122 { 1123 struct debug_handle *info = (struct debug_handle *) handle; 1124 struct debug_namespace **nsp; 1125 enum debug_object_linkage linkage; 1126 struct debug_name *n; 1127 struct debug_variable *v; 1128 1129 if (name == NULL || type == NULL) 1130 return FALSE; 1131 1132 if (info->current_unit == NULL 1133 || info->current_file == NULL) 1134 { 1135 debug_error (_("debug_record_variable: no current file")); 1136 return FALSE; 1137 } 1138 1139 if (kind == DEBUG_GLOBAL || kind == DEBUG_STATIC) 1140 { 1141 nsp = &info->current_file->globals; 1142 if (kind == DEBUG_GLOBAL) 1143 linkage = DEBUG_LINKAGE_GLOBAL; 1144 else 1145 linkage = DEBUG_LINKAGE_STATIC; 1146 } 1147 else 1148 { 1149 if (info->current_block == NULL) 1150 nsp = &info->current_file->globals; 1151 else 1152 nsp = &info->current_block->locals; 1153 linkage = DEBUG_LINKAGE_AUTOMATIC; 1154 } 1155 1156 n = debug_add_to_namespace (info, nsp, name, DEBUG_OBJECT_VARIABLE, linkage); 1157 if (n == NULL) 1158 return FALSE; 1159 1160 v = (struct debug_variable *) xmalloc (sizeof *v); 1161 memset (v, 0, sizeof *v); 1162 1163 v->kind = kind; 1164 v->type = type; 1165 v->val = val; 1166 1167 n->u.variable = v; 1168 1169 return TRUE; 1170 } 1171 1172 /* Make a type with a given kind and size. */ 1173 1174 static struct debug_type_s * 1175 debug_make_type (struct debug_handle *info ATTRIBUTE_UNUSED, 1176 enum debug_type_kind kind, unsigned int size) 1177 { 1178 struct debug_type_s *t; 1179 1180 t = (struct debug_type_s *) xmalloc (sizeof *t); 1181 memset (t, 0, sizeof *t); 1182 1183 t->kind = kind; 1184 t->size = size; 1185 1186 return t; 1187 } 1188 1189 /* Make an indirect type which may be used as a placeholder for a type 1190 which is referenced before it is defined. */ 1191 1192 debug_type 1193 debug_make_indirect_type (void *handle, debug_type *slot, const char *tag) 1194 { 1195 struct debug_handle *info = (struct debug_handle *) handle; 1196 struct debug_type_s *t; 1197 struct debug_indirect_type *i; 1198 1199 t = debug_make_type (info, DEBUG_KIND_INDIRECT, 0); 1200 if (t == NULL) 1201 return DEBUG_TYPE_NULL; 1202 1203 i = (struct debug_indirect_type *) xmalloc (sizeof *i); 1204 memset (i, 0, sizeof *i); 1205 1206 i->slot = slot; 1207 i->tag = tag; 1208 1209 t->u.kindirect = i; 1210 1211 return t; 1212 } 1213 1214 /* Make a void type. There is only one of these. */ 1215 1216 debug_type 1217 debug_make_void_type (void *handle) 1218 { 1219 struct debug_handle *info = (struct debug_handle *) handle; 1220 1221 return debug_make_type (info, DEBUG_KIND_VOID, 0); 1222 } 1223 1224 /* Make an integer type of a given size. The boolean argument is true 1225 if the integer is unsigned. */ 1226 1227 debug_type 1228 debug_make_int_type (void *handle, unsigned int size, bfd_boolean unsignedp) 1229 { 1230 struct debug_handle *info = (struct debug_handle *) handle; 1231 struct debug_type_s *t; 1232 1233 t = debug_make_type (info, DEBUG_KIND_INT, size); 1234 if (t == NULL) 1235 return DEBUG_TYPE_NULL; 1236 1237 t->u.kint = unsignedp; 1238 1239 return t; 1240 } 1241 1242 /* Make a floating point type of a given size. FIXME: On some 1243 platforms, like an Alpha, you probably need to be able to specify 1244 the format. */ 1245 1246 debug_type 1247 debug_make_float_type (void *handle, unsigned int size) 1248 { 1249 struct debug_handle *info = (struct debug_handle *) handle; 1250 1251 return debug_make_type (info, DEBUG_KIND_FLOAT, size); 1252 } 1253 1254 /* Make a boolean type of a given size. */ 1255 1256 debug_type 1257 debug_make_bool_type (void *handle, unsigned int size) 1258 { 1259 struct debug_handle *info = (struct debug_handle *) handle; 1260 1261 return debug_make_type (info, DEBUG_KIND_BOOL, size); 1262 } 1263 1264 /* Make a complex type of a given size. */ 1265 1266 debug_type 1267 debug_make_complex_type (void *handle, unsigned int size) 1268 { 1269 struct debug_handle *info = (struct debug_handle *) handle; 1270 1271 return debug_make_type (info, DEBUG_KIND_COMPLEX, size); 1272 } 1273 1274 /* Make a structure type. The second argument is true for a struct, 1275 false for a union. The third argument is the size of the struct. 1276 The fourth argument is a NULL terminated array of fields. */ 1277 1278 debug_type 1279 debug_make_struct_type (void *handle, bfd_boolean structp, bfd_vma size, 1280 debug_field *fields) 1281 { 1282 struct debug_handle *info = (struct debug_handle *) handle; 1283 struct debug_type_s *t; 1284 struct debug_class_type *c; 1285 1286 t = debug_make_type (info, 1287 structp ? DEBUG_KIND_STRUCT : DEBUG_KIND_UNION, 1288 size); 1289 if (t == NULL) 1290 return DEBUG_TYPE_NULL; 1291 1292 c = (struct debug_class_type *) xmalloc (sizeof *c); 1293 memset (c, 0, sizeof *c); 1294 1295 c->fields = fields; 1296 1297 t->u.kclass = c; 1298 1299 return t; 1300 } 1301 1302 /* Make an object type. The first three arguments after the handle 1303 are the same as for debug_make_struct_type. The next arguments are 1304 a NULL terminated array of base classes, a NULL terminated array of 1305 methods, the type of the object holding the virtual function table 1306 if it is not this object, and a boolean which is true if this 1307 object has its own virtual function table. */ 1308 1309 debug_type 1310 debug_make_object_type (void *handle, bfd_boolean structp, bfd_vma size, 1311 debug_field *fields, debug_baseclass *baseclasses, 1312 debug_method *methods, debug_type vptrbase, 1313 bfd_boolean ownvptr) 1314 { 1315 struct debug_handle *info = (struct debug_handle *) handle; 1316 struct debug_type_s *t; 1317 struct debug_class_type *c; 1318 1319 t = debug_make_type (info, 1320 structp ? DEBUG_KIND_CLASS : DEBUG_KIND_UNION_CLASS, 1321 size); 1322 if (t == NULL) 1323 return DEBUG_TYPE_NULL; 1324 1325 c = (struct debug_class_type *) xmalloc (sizeof *c); 1326 memset (c, 0, sizeof *c); 1327 1328 c->fields = fields; 1329 c->baseclasses = baseclasses; 1330 c->methods = methods; 1331 if (ownvptr) 1332 c->vptrbase = t; 1333 else 1334 c->vptrbase = vptrbase; 1335 1336 t->u.kclass = c; 1337 1338 return t; 1339 } 1340 1341 /* Make an enumeration type. The arguments are a null terminated 1342 array of strings, and an array of corresponding values. */ 1343 1344 debug_type 1345 debug_make_enum_type (void *handle, const char **names, 1346 bfd_signed_vma *values) 1347 { 1348 struct debug_handle *info = (struct debug_handle *) handle; 1349 struct debug_type_s *t; 1350 struct debug_enum_type *e; 1351 1352 t = debug_make_type (info, DEBUG_KIND_ENUM, 0); 1353 if (t == NULL) 1354 return DEBUG_TYPE_NULL; 1355 1356 e = (struct debug_enum_type *) xmalloc (sizeof *e); 1357 memset (e, 0, sizeof *e); 1358 1359 e->names = names; 1360 e->values = values; 1361 1362 t->u.kenum = e; 1363 1364 return t; 1365 } 1366 1367 /* Make a pointer to a given type. */ 1368 1369 debug_type 1370 debug_make_pointer_type (void *handle, debug_type type) 1371 { 1372 struct debug_handle *info = (struct debug_handle *) handle; 1373 struct debug_type_s *t; 1374 1375 if (type == NULL) 1376 return DEBUG_TYPE_NULL; 1377 1378 if (type->pointer != DEBUG_TYPE_NULL) 1379 return type->pointer; 1380 1381 t = debug_make_type (info, DEBUG_KIND_POINTER, 0); 1382 if (t == NULL) 1383 return DEBUG_TYPE_NULL; 1384 1385 t->u.kpointer = type; 1386 1387 type->pointer = t; 1388 1389 return t; 1390 } 1391 1392 /* Make a function returning a given type. FIXME: We should be able 1393 to record the parameter types. */ 1394 1395 debug_type 1396 debug_make_function_type (void *handle, debug_type type, 1397 debug_type *arg_types, bfd_boolean varargs) 1398 { 1399 struct debug_handle *info = (struct debug_handle *) handle; 1400 struct debug_type_s *t; 1401 struct debug_function_type *f; 1402 1403 if (type == NULL) 1404 return DEBUG_TYPE_NULL; 1405 1406 t = debug_make_type (info, DEBUG_KIND_FUNCTION, 0); 1407 if (t == NULL) 1408 return DEBUG_TYPE_NULL; 1409 1410 f = (struct debug_function_type *) xmalloc (sizeof *f); 1411 memset (f, 0, sizeof *f); 1412 1413 f->return_type = type; 1414 f->arg_types = arg_types; 1415 f->varargs = varargs; 1416 1417 t->u.kfunction = f; 1418 1419 return t; 1420 } 1421 1422 /* Make a reference to a given type. */ 1423 1424 debug_type 1425 debug_make_reference_type (void *handle, debug_type type) 1426 { 1427 struct debug_handle *info = (struct debug_handle *) handle; 1428 struct debug_type_s *t; 1429 1430 if (type == NULL) 1431 return DEBUG_TYPE_NULL; 1432 1433 t = debug_make_type (info, DEBUG_KIND_REFERENCE, 0); 1434 if (t == NULL) 1435 return DEBUG_TYPE_NULL; 1436 1437 t->u.kreference = type; 1438 1439 return t; 1440 } 1441 1442 /* Make a range of a given type from a lower to an upper bound. */ 1443 1444 debug_type 1445 debug_make_range_type (void *handle, debug_type type, bfd_signed_vma lower, 1446 bfd_signed_vma upper) 1447 { 1448 struct debug_handle *info = (struct debug_handle *) handle; 1449 struct debug_type_s *t; 1450 struct debug_range_type *r; 1451 1452 if (type == NULL) 1453 return DEBUG_TYPE_NULL; 1454 1455 t = debug_make_type (info, DEBUG_KIND_RANGE, 0); 1456 if (t == NULL) 1457 return DEBUG_TYPE_NULL; 1458 1459 r = (struct debug_range_type *) xmalloc (sizeof *r); 1460 memset (r, 0, sizeof *r); 1461 1462 r->type = type; 1463 r->lower = lower; 1464 r->upper = upper; 1465 1466 t->u.krange = r; 1467 1468 return t; 1469 } 1470 1471 /* Make an array type. The second argument is the type of an element 1472 of the array. The third argument is the type of a range of the 1473 array. The fourth and fifth argument are the lower and upper 1474 bounds, respectively. The sixth argument is true if this array is 1475 actually a string, as in C. */ 1476 1477 debug_type 1478 debug_make_array_type (void *handle, debug_type element_type, 1479 debug_type range_type, bfd_signed_vma lower, 1480 bfd_signed_vma upper, bfd_boolean stringp) 1481 { 1482 struct debug_handle *info = (struct debug_handle *) handle; 1483 struct debug_type_s *t; 1484 struct debug_array_type *a; 1485 1486 if (element_type == NULL || range_type == NULL) 1487 return DEBUG_TYPE_NULL; 1488 1489 t = debug_make_type (info, DEBUG_KIND_ARRAY, 0); 1490 if (t == NULL) 1491 return DEBUG_TYPE_NULL; 1492 1493 a = (struct debug_array_type *) xmalloc (sizeof *a); 1494 memset (a, 0, sizeof *a); 1495 1496 a->element_type = element_type; 1497 a->range_type = range_type; 1498 a->lower = lower; 1499 a->upper = upper; 1500 a->stringp = stringp; 1501 1502 t->u.karray = a; 1503 1504 return t; 1505 } 1506 1507 /* Make a set of a given type. For example, a Pascal set type. The 1508 boolean argument is true if this set is actually a bitstring, as in 1509 CHILL. */ 1510 1511 debug_type 1512 debug_make_set_type (void *handle, debug_type type, bfd_boolean bitstringp) 1513 { 1514 struct debug_handle *info = (struct debug_handle *) handle; 1515 struct debug_type_s *t; 1516 struct debug_set_type *s; 1517 1518 if (type == NULL) 1519 return DEBUG_TYPE_NULL; 1520 1521 t = debug_make_type (info, DEBUG_KIND_SET, 0); 1522 if (t == NULL) 1523 return DEBUG_TYPE_NULL; 1524 1525 s = (struct debug_set_type *) xmalloc (sizeof *s); 1526 memset (s, 0, sizeof *s); 1527 1528 s->type = type; 1529 s->bitstringp = bitstringp; 1530 1531 t->u.kset = s; 1532 1533 return t; 1534 } 1535 1536 /* Make a type for a pointer which is relative to an object. The 1537 second argument is the type of the object to which the pointer is 1538 relative. The third argument is the type that the pointer points 1539 to. */ 1540 1541 debug_type 1542 debug_make_offset_type (void *handle, debug_type base_type, 1543 debug_type target_type) 1544 { 1545 struct debug_handle *info = (struct debug_handle *) handle; 1546 struct debug_type_s *t; 1547 struct debug_offset_type *o; 1548 1549 if (base_type == NULL || target_type == NULL) 1550 return DEBUG_TYPE_NULL; 1551 1552 t = debug_make_type (info, DEBUG_KIND_OFFSET, 0); 1553 if (t == NULL) 1554 return DEBUG_TYPE_NULL; 1555 1556 o = (struct debug_offset_type *) xmalloc (sizeof *o); 1557 memset (o, 0, sizeof *o); 1558 1559 o->base_type = base_type; 1560 o->target_type = target_type; 1561 1562 t->u.koffset = o; 1563 1564 return t; 1565 } 1566 1567 /* Make a type for a method function. The second argument is the 1568 return type, the third argument is the domain, and the fourth 1569 argument is a NULL terminated array of argument types. */ 1570 1571 debug_type 1572 debug_make_method_type (void *handle, debug_type return_type, 1573 debug_type domain_type, debug_type *arg_types, 1574 bfd_boolean varargs) 1575 { 1576 struct debug_handle *info = (struct debug_handle *) handle; 1577 struct debug_type_s *t; 1578 struct debug_method_type *m; 1579 1580 if (return_type == NULL) 1581 return DEBUG_TYPE_NULL; 1582 1583 t = debug_make_type (info, DEBUG_KIND_METHOD, 0); 1584 if (t == NULL) 1585 return DEBUG_TYPE_NULL; 1586 1587 m = (struct debug_method_type *) xmalloc (sizeof *m); 1588 memset (m, 0, sizeof *m); 1589 1590 m->return_type = return_type; 1591 m->domain_type = domain_type; 1592 m->arg_types = arg_types; 1593 m->varargs = varargs; 1594 1595 t->u.kmethod = m; 1596 1597 return t; 1598 } 1599 1600 /* Make a const qualified version of a given type. */ 1601 1602 debug_type 1603 debug_make_const_type (void *handle, debug_type type) 1604 { 1605 struct debug_handle *info = (struct debug_handle *) handle; 1606 struct debug_type_s *t; 1607 1608 if (type == NULL) 1609 return DEBUG_TYPE_NULL; 1610 1611 t = debug_make_type (info, DEBUG_KIND_CONST, 0); 1612 if (t == NULL) 1613 return DEBUG_TYPE_NULL; 1614 1615 t->u.kconst = type; 1616 1617 return t; 1618 } 1619 1620 /* Make a volatile qualified version of a given type. */ 1621 1622 debug_type 1623 debug_make_volatile_type (void *handle, debug_type type) 1624 { 1625 struct debug_handle *info = (struct debug_handle *) handle; 1626 struct debug_type_s *t; 1627 1628 if (type == NULL) 1629 return DEBUG_TYPE_NULL; 1630 1631 t = debug_make_type (info, DEBUG_KIND_VOLATILE, 0); 1632 if (t == NULL) 1633 return DEBUG_TYPE_NULL; 1634 1635 t->u.kvolatile = type; 1636 1637 return t; 1638 } 1639 1640 /* Make an undefined tagged type. For example, a struct which has 1641 been mentioned, but not defined. */ 1642 1643 debug_type 1644 debug_make_undefined_tagged_type (void *handle, const char *name, 1645 enum debug_type_kind kind) 1646 { 1647 struct debug_handle *info = (struct debug_handle *) handle; 1648 struct debug_type_s *t; 1649 1650 if (name == NULL) 1651 return DEBUG_TYPE_NULL; 1652 1653 switch (kind) 1654 { 1655 case DEBUG_KIND_STRUCT: 1656 case DEBUG_KIND_UNION: 1657 case DEBUG_KIND_CLASS: 1658 case DEBUG_KIND_UNION_CLASS: 1659 case DEBUG_KIND_ENUM: 1660 break; 1661 1662 default: 1663 debug_error (_("debug_make_undefined_type: unsupported kind")); 1664 return DEBUG_TYPE_NULL; 1665 } 1666 1667 t = debug_make_type (info, kind, 0); 1668 if (t == NULL) 1669 return DEBUG_TYPE_NULL; 1670 1671 return debug_tag_type (handle, name, t); 1672 } 1673 1674 /* Make a base class for an object. The second argument is the base 1675 class type. The third argument is the bit position of this base 1676 class in the object (always 0 unless doing multiple inheritance). 1677 The fourth argument is whether this is a virtual class. The fifth 1678 argument is the visibility of the base class. */ 1679 1680 debug_baseclass 1681 debug_make_baseclass (void *handle ATTRIBUTE_UNUSED, debug_type type, 1682 bfd_vma bitpos, bfd_boolean is_virtual, 1683 enum debug_visibility visibility) 1684 { 1685 struct debug_baseclass_s *b; 1686 1687 b = (struct debug_baseclass_s *) xmalloc (sizeof *b); 1688 memset (b, 0, sizeof *b); 1689 1690 b->type = type; 1691 b->bitpos = bitpos; 1692 b->is_virtual = is_virtual; 1693 b->visibility = visibility; 1694 1695 return b; 1696 } 1697 1698 /* Make a field for a struct. The second argument is the name. The 1699 third argument is the type of the field. The fourth argument is 1700 the bit position of the field. The fifth argument is the size of 1701 the field (it may be zero). The sixth argument is the visibility 1702 of the field. */ 1703 1704 debug_field 1705 debug_make_field (void *handle ATTRIBUTE_UNUSED, const char *name, 1706 debug_type type, bfd_vma bitpos, bfd_vma bitsize, 1707 enum debug_visibility visibility) 1708 { 1709 struct debug_field_s *f; 1710 1711 f = (struct debug_field_s *) xmalloc (sizeof *f); 1712 memset (f, 0, sizeof *f); 1713 1714 f->name = name; 1715 f->type = type; 1716 f->static_member = FALSE; 1717 f->u.f.bitpos = bitpos; 1718 f->u.f.bitsize = bitsize; 1719 f->visibility = visibility; 1720 1721 return f; 1722 } 1723 1724 /* Make a static member of an object. The second argument is the 1725 name. The third argument is the type of the member. The fourth 1726 argument is the physical name of the member (i.e., the name as a 1727 global variable). The fifth argument is the visibility of the 1728 member. */ 1729 1730 debug_field 1731 debug_make_static_member (void *handle ATTRIBUTE_UNUSED, const char *name, 1732 debug_type type, const char *physname, 1733 enum debug_visibility visibility) 1734 { 1735 struct debug_field_s *f; 1736 1737 f = (struct debug_field_s *) xmalloc (sizeof *f); 1738 memset (f, 0, sizeof *f); 1739 1740 f->name = name; 1741 f->type = type; 1742 f->static_member = TRUE; 1743 f->u.s.physname = physname; 1744 f->visibility = visibility; 1745 1746 return f; 1747 } 1748 1749 /* Make a method. The second argument is the name, and the third 1750 argument is a NULL terminated array of method variants. */ 1751 1752 debug_method 1753 debug_make_method (void *handle ATTRIBUTE_UNUSED, const char *name, 1754 debug_method_variant *variants) 1755 { 1756 struct debug_method_s *m; 1757 1758 m = (struct debug_method_s *) xmalloc (sizeof *m); 1759 memset (m, 0, sizeof *m); 1760 1761 m->name = name; 1762 m->variants = variants; 1763 1764 return m; 1765 } 1766 1767 /* Make a method argument. The second argument is the real name of 1768 the function. The third argument is the type of the function. The 1769 fourth argument is the visibility. The fifth argument is whether 1770 this is a const function. The sixth argument is whether this is a 1771 volatile function. The seventh argument is the offset in the 1772 virtual function table, if any. The eighth argument is the virtual 1773 function context. FIXME: Are the const and volatile arguments 1774 necessary? Could we just use debug_make_const_type? */ 1775 1776 debug_method_variant 1777 debug_make_method_variant (void *handle ATTRIBUTE_UNUSED, 1778 const char *physname, debug_type type, 1779 enum debug_visibility visibility, 1780 bfd_boolean constp, bfd_boolean volatilep, 1781 bfd_vma voffset, debug_type context) 1782 { 1783 struct debug_method_variant_s *m; 1784 1785 m = (struct debug_method_variant_s *) xmalloc (sizeof *m); 1786 memset (m, 0, sizeof *m); 1787 1788 m->physname = physname; 1789 m->type = type; 1790 m->visibility = visibility; 1791 m->constp = constp; 1792 m->volatilep = volatilep; 1793 m->voffset = voffset; 1794 m->context = context; 1795 1796 return m; 1797 } 1798 1799 /* Make a static method argument. The arguments are the same as for 1800 debug_make_method_variant, except that the last two are omitted 1801 since a static method can not also be virtual. */ 1802 1803 debug_method_variant 1804 debug_make_static_method_variant (void *handle ATTRIBUTE_UNUSED, 1805 const char *physname, debug_type type, 1806 enum debug_visibility visibility, 1807 bfd_boolean constp, bfd_boolean volatilep) 1808 { 1809 struct debug_method_variant_s *m; 1810 1811 m = (struct debug_method_variant_s *) xmalloc (sizeof *m); 1812 memset (m, 0, sizeof *m); 1813 1814 m->physname = physname; 1815 m->type = type; 1816 m->visibility = visibility; 1817 m->constp = constp; 1818 m->volatilep = volatilep; 1819 m->voffset = VOFFSET_STATIC_METHOD; 1820 1821 return m; 1822 } 1823 1824 /* Name a type. */ 1825 1826 debug_type 1827 debug_name_type (void *handle, const char *name, debug_type type) 1828 { 1829 struct debug_handle *info = (struct debug_handle *) handle; 1830 struct debug_type_s *t; 1831 struct debug_named_type *n; 1832 struct debug_name *nm; 1833 1834 if (name == NULL || type == NULL) 1835 return DEBUG_TYPE_NULL; 1836 1837 if (info->current_unit == NULL 1838 || info->current_file == NULL) 1839 { 1840 debug_error (_("debug_name_type: no current file")); 1841 return DEBUG_TYPE_NULL; 1842 } 1843 1844 t = debug_make_type (info, DEBUG_KIND_NAMED, 0); 1845 if (t == NULL) 1846 return DEBUG_TYPE_NULL; 1847 1848 n = (struct debug_named_type *) xmalloc (sizeof *n); 1849 memset (n, 0, sizeof *n); 1850 1851 n->type = type; 1852 1853 t->u.knamed = n; 1854 1855 /* We always add the name to the global namespace. This is probably 1856 wrong in some cases, but it seems to be right for stabs. FIXME. */ 1857 1858 nm = debug_add_to_namespace (info, &info->current_file->globals, name, 1859 DEBUG_OBJECT_TYPE, DEBUG_LINKAGE_NONE); 1860 if (nm == NULL) 1861 return DEBUG_TYPE_NULL; 1862 1863 nm->u.type = t; 1864 1865 n->name = nm; 1866 1867 return t; 1868 } 1869 1870 /* Tag a type. */ 1871 1872 debug_type 1873 debug_tag_type (void *handle, const char *name, debug_type type) 1874 { 1875 struct debug_handle *info = (struct debug_handle *) handle; 1876 struct debug_type_s *t; 1877 struct debug_named_type *n; 1878 struct debug_name *nm; 1879 1880 if (name == NULL || type == NULL) 1881 return DEBUG_TYPE_NULL; 1882 1883 if (info->current_file == NULL) 1884 { 1885 debug_error (_("debug_tag_type: no current file")); 1886 return DEBUG_TYPE_NULL; 1887 } 1888 1889 if (type->kind == DEBUG_KIND_TAGGED) 1890 { 1891 if (strcmp (type->u.knamed->name->name, name) == 0) 1892 return type; 1893 debug_error (_("debug_tag_type: extra tag attempted")); 1894 return DEBUG_TYPE_NULL; 1895 } 1896 1897 t = debug_make_type (info, DEBUG_KIND_TAGGED, 0); 1898 if (t == NULL) 1899 return DEBUG_TYPE_NULL; 1900 1901 n = (struct debug_named_type *) xmalloc (sizeof *n); 1902 memset (n, 0, sizeof *n); 1903 1904 n->type = type; 1905 1906 t->u.knamed = n; 1907 1908 /* We keep a global namespace of tags for each compilation unit. I 1909 don't know if that is the right thing to do. */ 1910 1911 nm = debug_add_to_namespace (info, &info->current_file->globals, name, 1912 DEBUG_OBJECT_TAG, DEBUG_LINKAGE_NONE); 1913 if (nm == NULL) 1914 return DEBUG_TYPE_NULL; 1915 1916 nm->u.tag = t; 1917 1918 n->name = nm; 1919 1920 return t; 1921 } 1922 1923 /* Record the size of a given type. */ 1924 1925 bfd_boolean 1926 debug_record_type_size (void *handle ATTRIBUTE_UNUSED, debug_type type, 1927 unsigned int size) 1928 { 1929 if (type->size != 0 && type->size != size) 1930 fprintf (stderr, _("Warning: changing type size from %d to %d\n"), 1931 type->size, size); 1932 1933 type->size = size; 1934 1935 return TRUE; 1936 } 1937 1938 /* Find a named type. */ 1939 1940 debug_type 1941 debug_find_named_type (void *handle, const char *name) 1942 { 1943 struct debug_handle *info = (struct debug_handle *) handle; 1944 struct debug_block *b; 1945 struct debug_file *f; 1946 1947 /* We only search the current compilation unit. I don't know if 1948 this is right or not. */ 1949 1950 if (info->current_unit == NULL) 1951 { 1952 debug_error (_("debug_find_named_type: no current compilation unit")); 1953 return DEBUG_TYPE_NULL; 1954 } 1955 1956 for (b = info->current_block; b != NULL; b = b->parent) 1957 { 1958 if (b->locals != NULL) 1959 { 1960 struct debug_name *n; 1961 1962 for (n = b->locals->list; n != NULL; n = n->next) 1963 { 1964 if (n->kind == DEBUG_OBJECT_TYPE 1965 && n->name[0] == name[0] 1966 && strcmp (n->name, name) == 0) 1967 return n->u.type; 1968 } 1969 } 1970 } 1971 1972 for (f = info->current_unit->files; f != NULL; f = f->next) 1973 { 1974 if (f->globals != NULL) 1975 { 1976 struct debug_name *n; 1977 1978 for (n = f->globals->list; n != NULL; n = n->next) 1979 { 1980 if (n->kind == DEBUG_OBJECT_TYPE 1981 && n->name[0] == name[0] 1982 && strcmp (n->name, name) == 0) 1983 return n->u.type; 1984 } 1985 } 1986 } 1987 1988 return DEBUG_TYPE_NULL; 1989 } 1990 1991 /* Find a tagged type. */ 1992 1993 debug_type 1994 debug_find_tagged_type (void *handle, const char *name, 1995 enum debug_type_kind kind) 1996 { 1997 struct debug_handle *info = (struct debug_handle *) handle; 1998 struct debug_unit *u; 1999 2000 /* We search the globals of all the compilation units. I don't know 2001 if this is correct or not. It would be easy to change. */ 2002 2003 for (u = info->units; u != NULL; u = u->next) 2004 { 2005 struct debug_file *f; 2006 2007 for (f = u->files; f != NULL; f = f->next) 2008 { 2009 struct debug_name *n; 2010 2011 if (f->globals != NULL) 2012 { 2013 for (n = f->globals->list; n != NULL; n = n->next) 2014 { 2015 if (n->kind == DEBUG_OBJECT_TAG 2016 && (kind == DEBUG_KIND_ILLEGAL 2017 || n->u.tag->kind == kind) 2018 && n->name[0] == name[0] 2019 && strcmp (n->name, name) == 0) 2020 return n->u.tag; 2021 } 2022 } 2023 } 2024 } 2025 2026 return DEBUG_TYPE_NULL; 2027 } 2028 2029 /* Get a base type. We build a linked list on the stack to avoid 2030 crashing if the type is defined circularly. */ 2031 2032 static struct debug_type_s * 2033 debug_get_real_type (void *handle, debug_type type, 2034 struct debug_type_real_list *list) 2035 { 2036 struct debug_type_real_list *l; 2037 struct debug_type_real_list rl; 2038 2039 switch (type->kind) 2040 { 2041 default: 2042 return type; 2043 2044 case DEBUG_KIND_INDIRECT: 2045 case DEBUG_KIND_NAMED: 2046 case DEBUG_KIND_TAGGED: 2047 break; 2048 } 2049 2050 for (l = list; l != NULL; l = l->next) 2051 { 2052 if (l->t == type || l == l->next) 2053 { 2054 fprintf (stderr, 2055 _("debug_get_real_type: circular debug information for %s\n"), 2056 debug_get_type_name (handle, type)); 2057 return NULL; 2058 } 2059 } 2060 2061 rl.next = list; 2062 rl.t = type; 2063 2064 switch (type->kind) 2065 { 2066 /* The default case is just here to avoid warnings. */ 2067 default: 2068 case DEBUG_KIND_INDIRECT: 2069 if (*type->u.kindirect->slot != NULL) 2070 return debug_get_real_type (handle, *type->u.kindirect->slot, &rl); 2071 return type; 2072 case DEBUG_KIND_NAMED: 2073 case DEBUG_KIND_TAGGED: 2074 return debug_get_real_type (handle, type->u.knamed->type, &rl); 2075 } 2076 /*NOTREACHED*/ 2077 } 2078 2079 /* Get the kind of a type. */ 2080 2081 enum debug_type_kind 2082 debug_get_type_kind (void *handle, debug_type type) 2083 { 2084 if (type == NULL) 2085 return DEBUG_KIND_ILLEGAL; 2086 type = debug_get_real_type (handle, type, NULL); 2087 if (type == NULL) 2088 return DEBUG_KIND_ILLEGAL; 2089 return type->kind; 2090 } 2091 2092 /* Get the name of a type. */ 2093 2094 const char * 2095 debug_get_type_name (void *handle, debug_type type) 2096 { 2097 if (type->kind == DEBUG_KIND_INDIRECT) 2098 { 2099 if (*type->u.kindirect->slot != NULL) 2100 return debug_get_type_name (handle, *type->u.kindirect->slot); 2101 return type->u.kindirect->tag; 2102 } 2103 if (type->kind == DEBUG_KIND_NAMED 2104 || type->kind == DEBUG_KIND_TAGGED) 2105 return type->u.knamed->name->name; 2106 return NULL; 2107 } 2108 2109 /* Get the size of a type. */ 2110 2111 bfd_vma 2112 debug_get_type_size (void *handle, debug_type type) 2113 { 2114 if (type == NULL) 2115 return 0; 2116 2117 /* We don't call debug_get_real_type, because somebody might have 2118 called debug_record_type_size on a named or indirect type. */ 2119 2120 if (type->size != 0) 2121 return type->size; 2122 2123 switch (type->kind) 2124 { 2125 default: 2126 return 0; 2127 case DEBUG_KIND_INDIRECT: 2128 if (*type->u.kindirect->slot != NULL) 2129 return debug_get_type_size (handle, *type->u.kindirect->slot); 2130 return 0; 2131 case DEBUG_KIND_NAMED: 2132 case DEBUG_KIND_TAGGED: 2133 return debug_get_type_size (handle, type->u.knamed->type); 2134 } 2135 /*NOTREACHED*/ 2136 } 2137 2138 /* Get the return type of a function or method type. */ 2139 2140 debug_type 2141 debug_get_return_type (void *handle, debug_type type) 2142 { 2143 if (type == NULL) 2144 return DEBUG_TYPE_NULL; 2145 2146 type = debug_get_real_type (handle, type, NULL); 2147 if (type == NULL) 2148 return DEBUG_TYPE_NULL; 2149 2150 switch (type->kind) 2151 { 2152 default: 2153 return DEBUG_TYPE_NULL; 2154 case DEBUG_KIND_FUNCTION: 2155 return type->u.kfunction->return_type; 2156 case DEBUG_KIND_METHOD: 2157 return type->u.kmethod->return_type; 2158 } 2159 /*NOTREACHED*/ 2160 } 2161 2162 /* Get the parameter types of a function or method type (except that 2163 we don't currently store the parameter types of a function). */ 2164 2165 const debug_type * 2166 debug_get_parameter_types (void *handle, debug_type type, 2167 bfd_boolean *pvarargs) 2168 { 2169 if (type == NULL) 2170 return NULL; 2171 2172 type = debug_get_real_type (handle, type, NULL); 2173 if (type == NULL) 2174 return NULL; 2175 2176 switch (type->kind) 2177 { 2178 default: 2179 return NULL; 2180 case DEBUG_KIND_FUNCTION: 2181 *pvarargs = type->u.kfunction->varargs; 2182 return type->u.kfunction->arg_types; 2183 case DEBUG_KIND_METHOD: 2184 *pvarargs = type->u.kmethod->varargs; 2185 return type->u.kmethod->arg_types; 2186 } 2187 /*NOTREACHED*/ 2188 } 2189 2190 /* Get the target type of a type. */ 2191 2192 debug_type 2193 debug_get_target_type (void *handle, debug_type type) 2194 { 2195 if (type == NULL) 2196 return NULL; 2197 2198 type = debug_get_real_type (handle, type, NULL); 2199 if (type == NULL) 2200 return NULL; 2201 2202 switch (type->kind) 2203 { 2204 default: 2205 return NULL; 2206 case DEBUG_KIND_POINTER: 2207 return type->u.kpointer; 2208 case DEBUG_KIND_REFERENCE: 2209 return type->u.kreference; 2210 case DEBUG_KIND_CONST: 2211 return type->u.kconst; 2212 case DEBUG_KIND_VOLATILE: 2213 return type->u.kvolatile; 2214 } 2215 /*NOTREACHED*/ 2216 } 2217 2218 /* Get the NULL terminated array of fields for a struct, union, or 2219 class. */ 2220 2221 const debug_field * 2222 debug_get_fields (void *handle, debug_type type) 2223 { 2224 if (type == NULL) 2225 return NULL; 2226 2227 type = debug_get_real_type (handle, type, NULL); 2228 if (type == NULL) 2229 return NULL; 2230 2231 switch (type->kind) 2232 { 2233 default: 2234 return NULL; 2235 case DEBUG_KIND_STRUCT: 2236 case DEBUG_KIND_UNION: 2237 case DEBUG_KIND_CLASS: 2238 case DEBUG_KIND_UNION_CLASS: 2239 return type->u.kclass->fields; 2240 } 2241 /*NOTREACHED*/ 2242 } 2243 2244 /* Get the type of a field. */ 2245 2246 debug_type 2247 debug_get_field_type (void *handle ATTRIBUTE_UNUSED, debug_field field) 2248 { 2249 if (field == NULL) 2250 return NULL; 2251 return field->type; 2252 } 2253 2254 /* Get the name of a field. */ 2255 2256 const char * 2257 debug_get_field_name (void *handle ATTRIBUTE_UNUSED, debug_field field) 2258 { 2259 if (field == NULL) 2260 return NULL; 2261 return field->name; 2262 } 2263 2264 /* Get the bit position of a field. */ 2265 2266 bfd_vma 2267 debug_get_field_bitpos (void *handle ATTRIBUTE_UNUSED, debug_field field) 2268 { 2269 if (field == NULL || field->static_member) 2270 return (bfd_vma) -1; 2271 return field->u.f.bitpos; 2272 } 2273 2274 /* Get the bit size of a field. */ 2275 2276 bfd_vma 2277 debug_get_field_bitsize (void *handle ATTRIBUTE_UNUSED, debug_field field) 2278 { 2279 if (field == NULL || field->static_member) 2280 return (bfd_vma) -1; 2281 return field->u.f.bitsize; 2282 } 2283 2284 /* Get the visibility of a field. */ 2285 2286 enum debug_visibility 2287 debug_get_field_visibility (void *handle ATTRIBUTE_UNUSED, debug_field field) 2288 { 2289 if (field == NULL) 2290 return DEBUG_VISIBILITY_IGNORE; 2291 return field->visibility; 2292 } 2293 2294 /* Get the physical name of a field. */ 2295 2296 const char * 2297 debug_get_field_physname (void *handle ATTRIBUTE_UNUSED, debug_field field) 2298 { 2299 if (field == NULL || ! field->static_member) 2300 return NULL; 2301 return field->u.s.physname; 2302 } 2303 2304 /* Write out the debugging information. This is given a handle to 2305 debugging information, and a set of function pointers to call. */ 2306 2307 bfd_boolean 2308 debug_write (void *handle, const struct debug_write_fns *fns, void *fhandle) 2309 { 2310 struct debug_handle *info = (struct debug_handle *) handle; 2311 struct debug_unit *u; 2312 2313 /* We use a mark to tell whether we have already written out a 2314 particular name. We use an integer, so that we don't have to 2315 clear the mark fields if we happen to write out the same 2316 information more than once. */ 2317 ++info->mark; 2318 2319 /* The base_id field holds an ID value which will never be used, so 2320 that we can tell whether we have assigned an ID during this call 2321 to debug_write. */ 2322 info->base_id = info->class_id; 2323 2324 /* We keep a linked list of classes for which was have assigned ID's 2325 during this call to debug_write. */ 2326 info->id_list = NULL; 2327 2328 for (u = info->units; u != NULL; u = u->next) 2329 { 2330 struct debug_file *f; 2331 bfd_boolean first_file; 2332 2333 info->current_write_lineno = u->linenos; 2334 info->current_write_lineno_index = 0; 2335 2336 if (! (*fns->start_compilation_unit) (fhandle, u->files->filename)) 2337 return FALSE; 2338 2339 first_file = TRUE; 2340 for (f = u->files; f != NULL; f = f->next) 2341 { 2342 struct debug_name *n; 2343 2344 if (first_file) 2345 first_file = FALSE; 2346 else if (! (*fns->start_source) (fhandle, f->filename)) 2347 return FALSE; 2348 2349 if (f->globals != NULL) 2350 for (n = f->globals->list; n != NULL; n = n->next) 2351 if (! debug_write_name (info, fns, fhandle, n)) 2352 return FALSE; 2353 } 2354 2355 /* Output any line number information which hasn't already been 2356 handled. */ 2357 if (! debug_write_linenos (info, fns, fhandle, (bfd_vma) -1)) 2358 return FALSE; 2359 } 2360 2361 return TRUE; 2362 } 2363 2364 /* Write out an element in a namespace. */ 2365 2366 static bfd_boolean 2367 debug_write_name (struct debug_handle *info, 2368 const struct debug_write_fns *fns, void *fhandle, 2369 struct debug_name *n) 2370 { 2371 switch (n->kind) 2372 { 2373 case DEBUG_OBJECT_TYPE: 2374 if (! debug_write_type (info, fns, fhandle, n->u.type, n) 2375 || ! (*fns->typdef) (fhandle, n->name)) 2376 return FALSE; 2377 return TRUE; 2378 case DEBUG_OBJECT_TAG: 2379 if (! debug_write_type (info, fns, fhandle, n->u.tag, n)) 2380 return FALSE; 2381 return (*fns->tag) (fhandle, n->name); 2382 case DEBUG_OBJECT_VARIABLE: 2383 if (! debug_write_type (info, fns, fhandle, n->u.variable->type, 2384 (struct debug_name *) NULL)) 2385 return FALSE; 2386 return (*fns->variable) (fhandle, n->name, n->u.variable->kind, 2387 n->u.variable->val); 2388 case DEBUG_OBJECT_FUNCTION: 2389 return debug_write_function (info, fns, fhandle, n->name, 2390 n->linkage, n->u.function); 2391 case DEBUG_OBJECT_INT_CONSTANT: 2392 return (*fns->int_constant) (fhandle, n->name, n->u.int_constant); 2393 case DEBUG_OBJECT_FLOAT_CONSTANT: 2394 return (*fns->float_constant) (fhandle, n->name, n->u.float_constant); 2395 case DEBUG_OBJECT_TYPED_CONSTANT: 2396 if (! debug_write_type (info, fns, fhandle, n->u.typed_constant->type, 2397 (struct debug_name *) NULL)) 2398 return FALSE; 2399 return (*fns->typed_constant) (fhandle, n->name, 2400 n->u.typed_constant->val); 2401 default: 2402 abort (); 2403 return FALSE; 2404 } 2405 /*NOTREACHED*/ 2406 } 2407 2408 /* Write out a type. If the type is DEBUG_KIND_NAMED or 2409 DEBUG_KIND_TAGGED, then the name argument is the name for which we 2410 are about to call typedef or tag. If the type is anything else, 2411 then the name argument is a tag from a DEBUG_KIND_TAGGED type which 2412 points to this one. */ 2413 2414 static bfd_boolean 2415 debug_write_type (struct debug_handle *info, 2416 const struct debug_write_fns *fns, void *fhandle, 2417 struct debug_type_s *type, struct debug_name *name) 2418 { 2419 unsigned int i; 2420 int is; 2421 const char *tag = NULL; 2422 2423 /* If we have a name for this type, just output it. We only output 2424 typedef names after they have been defined. We output type tags 2425 whenever we are not actually defining them. */ 2426 if ((type->kind == DEBUG_KIND_NAMED 2427 || type->kind == DEBUG_KIND_TAGGED) 2428 && (type->u.knamed->name->mark == info->mark 2429 || (type->kind == DEBUG_KIND_TAGGED 2430 && type->u.knamed->name != name))) 2431 { 2432 if (type->kind == DEBUG_KIND_NAMED) 2433 return (*fns->typedef_type) (fhandle, type->u.knamed->name->name); 2434 else 2435 { 2436 struct debug_type_s *real; 2437 unsigned int id; 2438 2439 real = debug_get_real_type ((void *) info, type, NULL); 2440 if (real == NULL) 2441 return (*fns->empty_type) (fhandle); 2442 id = 0; 2443 if ((real->kind == DEBUG_KIND_STRUCT 2444 || real->kind == DEBUG_KIND_UNION 2445 || real->kind == DEBUG_KIND_CLASS 2446 || real->kind == DEBUG_KIND_UNION_CLASS) 2447 && real->u.kclass != NULL) 2448 { 2449 if (real->u.kclass->id <= info->base_id) 2450 { 2451 if (! debug_set_class_id (info, 2452 type->u.knamed->name->name, 2453 real)) 2454 return FALSE; 2455 } 2456 id = real->u.kclass->id; 2457 } 2458 2459 return (*fns->tag_type) (fhandle, type->u.knamed->name->name, id, 2460 real->kind); 2461 } 2462 } 2463 2464 /* Mark the name after we have already looked for a known name, so 2465 that we don't just define a type in terms of itself. We need to 2466 mark the name here so that a struct containing a pointer to 2467 itself will work. */ 2468 if (name != NULL) 2469 name->mark = info->mark; 2470 2471 if (name != NULL 2472 && type->kind != DEBUG_KIND_NAMED 2473 && type->kind != DEBUG_KIND_TAGGED) 2474 { 2475 assert (name->kind == DEBUG_OBJECT_TAG); 2476 tag = name->name; 2477 } 2478 2479 switch (type->kind) 2480 { 2481 case DEBUG_KIND_ILLEGAL: 2482 debug_error (_("debug_write_type: illegal type encountered")); 2483 return FALSE; 2484 case DEBUG_KIND_INDIRECT: 2485 if (*type->u.kindirect->slot == DEBUG_TYPE_NULL) 2486 return (*fns->empty_type) (fhandle); 2487 return debug_write_type (info, fns, fhandle, *type->u.kindirect->slot, 2488 name); 2489 case DEBUG_KIND_VOID: 2490 return (*fns->void_type) (fhandle); 2491 case DEBUG_KIND_INT: 2492 return (*fns->int_type) (fhandle, type->size, type->u.kint); 2493 case DEBUG_KIND_FLOAT: 2494 return (*fns->float_type) (fhandle, type->size); 2495 case DEBUG_KIND_COMPLEX: 2496 return (*fns->complex_type) (fhandle, type->size); 2497 case DEBUG_KIND_BOOL: 2498 return (*fns->bool_type) (fhandle, type->size); 2499 case DEBUG_KIND_STRUCT: 2500 case DEBUG_KIND_UNION: 2501 if (type->u.kclass != NULL) 2502 { 2503 if (type->u.kclass->id <= info->base_id) 2504 { 2505 if (! debug_set_class_id (info, tag, type)) 2506 return FALSE; 2507 } 2508 2509 if (info->mark == type->u.kclass->mark) 2510 { 2511 /* We are currently outputting this struct, or we have 2512 already output it. I don't know if this can happen, 2513 but it can happen for a class. */ 2514 assert (type->u.kclass->id > info->base_id); 2515 return (*fns->tag_type) (fhandle, tag, type->u.kclass->id, 2516 type->kind); 2517 } 2518 type->u.kclass->mark = info->mark; 2519 } 2520 2521 if (! (*fns->start_struct_type) (fhandle, tag, 2522 (type->u.kclass != NULL 2523 ? type->u.kclass->id 2524 : 0), 2525 type->kind == DEBUG_KIND_STRUCT, 2526 type->size)) 2527 return FALSE; 2528 if (type->u.kclass != NULL 2529 && type->u.kclass->fields != NULL) 2530 { 2531 for (i = 0; type->u.kclass->fields[i] != NULL; i++) 2532 { 2533 struct debug_field_s *f; 2534 2535 f = type->u.kclass->fields[i]; 2536 if (! debug_write_type (info, fns, fhandle, f->type, 2537 (struct debug_name *) NULL) 2538 || ! (*fns->struct_field) (fhandle, f->name, f->u.f.bitpos, 2539 f->u.f.bitsize, f->visibility)) 2540 return FALSE; 2541 } 2542 } 2543 return (*fns->end_struct_type) (fhandle); 2544 case DEBUG_KIND_CLASS: 2545 case DEBUG_KIND_UNION_CLASS: 2546 return debug_write_class_type (info, fns, fhandle, type, tag); 2547 case DEBUG_KIND_ENUM: 2548 if (type->u.kenum == NULL) 2549 return (*fns->enum_type) (fhandle, tag, (const char **) NULL, 2550 (bfd_signed_vma *) NULL); 2551 return (*fns->enum_type) (fhandle, tag, type->u.kenum->names, 2552 type->u.kenum->values); 2553 case DEBUG_KIND_POINTER: 2554 if (! debug_write_type (info, fns, fhandle, type->u.kpointer, 2555 (struct debug_name *) NULL)) 2556 return FALSE; 2557 return (*fns->pointer_type) (fhandle); 2558 case DEBUG_KIND_FUNCTION: 2559 if (! debug_write_type (info, fns, fhandle, 2560 type->u.kfunction->return_type, 2561 (struct debug_name *) NULL)) 2562 return FALSE; 2563 if (type->u.kfunction->arg_types == NULL) 2564 is = -1; 2565 else 2566 { 2567 for (is = 0; type->u.kfunction->arg_types[is] != NULL; is++) 2568 if (! debug_write_type (info, fns, fhandle, 2569 type->u.kfunction->arg_types[is], 2570 (struct debug_name *) NULL)) 2571 return FALSE; 2572 } 2573 return (*fns->function_type) (fhandle, is, 2574 type->u.kfunction->varargs); 2575 case DEBUG_KIND_REFERENCE: 2576 if (! debug_write_type (info, fns, fhandle, type->u.kreference, 2577 (struct debug_name *) NULL)) 2578 return FALSE; 2579 return (*fns->reference_type) (fhandle); 2580 case DEBUG_KIND_RANGE: 2581 if (! debug_write_type (info, fns, fhandle, type->u.krange->type, 2582 (struct debug_name *) NULL)) 2583 return FALSE; 2584 return (*fns->range_type) (fhandle, type->u.krange->lower, 2585 type->u.krange->upper); 2586 case DEBUG_KIND_ARRAY: 2587 if (! debug_write_type (info, fns, fhandle, type->u.karray->element_type, 2588 (struct debug_name *) NULL) 2589 || ! debug_write_type (info, fns, fhandle, 2590 type->u.karray->range_type, 2591 (struct debug_name *) NULL)) 2592 return FALSE; 2593 return (*fns->array_type) (fhandle, type->u.karray->lower, 2594 type->u.karray->upper, 2595 type->u.karray->stringp); 2596 case DEBUG_KIND_SET: 2597 if (! debug_write_type (info, fns, fhandle, type->u.kset->type, 2598 (struct debug_name *) NULL)) 2599 return FALSE; 2600 return (*fns->set_type) (fhandle, type->u.kset->bitstringp); 2601 case DEBUG_KIND_OFFSET: 2602 if (! debug_write_type (info, fns, fhandle, type->u.koffset->base_type, 2603 (struct debug_name *) NULL) 2604 || ! debug_write_type (info, fns, fhandle, 2605 type->u.koffset->target_type, 2606 (struct debug_name *) NULL)) 2607 return FALSE; 2608 return (*fns->offset_type) (fhandle); 2609 case DEBUG_KIND_METHOD: 2610 if (! debug_write_type (info, fns, fhandle, 2611 type->u.kmethod->return_type, 2612 (struct debug_name *) NULL)) 2613 return FALSE; 2614 if (type->u.kmethod->arg_types == NULL) 2615 is = -1; 2616 else 2617 { 2618 for (is = 0; type->u.kmethod->arg_types[is] != NULL; is++) 2619 if (! debug_write_type (info, fns, fhandle, 2620 type->u.kmethod->arg_types[is], 2621 (struct debug_name *) NULL)) 2622 return FALSE; 2623 } 2624 if (type->u.kmethod->domain_type != NULL) 2625 { 2626 if (! debug_write_type (info, fns, fhandle, 2627 type->u.kmethod->domain_type, 2628 (struct debug_name *) NULL)) 2629 return FALSE; 2630 } 2631 return (*fns->method_type) (fhandle, 2632 type->u.kmethod->domain_type != NULL, 2633 is, 2634 type->u.kmethod->varargs); 2635 case DEBUG_KIND_CONST: 2636 if (! debug_write_type (info, fns, fhandle, type->u.kconst, 2637 (struct debug_name *) NULL)) 2638 return FALSE; 2639 return (*fns->const_type) (fhandle); 2640 case DEBUG_KIND_VOLATILE: 2641 if (! debug_write_type (info, fns, fhandle, type->u.kvolatile, 2642 (struct debug_name *) NULL)) 2643 return FALSE; 2644 return (*fns->volatile_type) (fhandle); 2645 case DEBUG_KIND_NAMED: 2646 return debug_write_type (info, fns, fhandle, type->u.knamed->type, 2647 (struct debug_name *) NULL); 2648 case DEBUG_KIND_TAGGED: 2649 return debug_write_type (info, fns, fhandle, type->u.knamed->type, 2650 type->u.knamed->name); 2651 default: 2652 abort (); 2653 return FALSE; 2654 } 2655 } 2656 2657 /* Write out a class type. */ 2658 2659 static bfd_boolean 2660 debug_write_class_type (struct debug_handle *info, 2661 const struct debug_write_fns *fns, void *fhandle, 2662 struct debug_type_s *type, const char *tag) 2663 { 2664 unsigned int i; 2665 unsigned int id; 2666 struct debug_type_s *vptrbase; 2667 2668 if (type->u.kclass == NULL) 2669 { 2670 id = 0; 2671 vptrbase = NULL; 2672 } 2673 else 2674 { 2675 if (type->u.kclass->id <= info->base_id) 2676 { 2677 if (! debug_set_class_id (info, tag, type)) 2678 return FALSE; 2679 } 2680 2681 if (info->mark == type->u.kclass->mark) 2682 { 2683 /* We are currently outputting this class, or we have 2684 already output it. This can happen when there are 2685 methods for an anonymous class. */ 2686 assert (type->u.kclass->id > info->base_id); 2687 return (*fns->tag_type) (fhandle, tag, type->u.kclass->id, 2688 type->kind); 2689 } 2690 type->u.kclass->mark = info->mark; 2691 id = type->u.kclass->id; 2692 2693 vptrbase = type->u.kclass->vptrbase; 2694 if (vptrbase != NULL && vptrbase != type) 2695 { 2696 if (! debug_write_type (info, fns, fhandle, vptrbase, 2697 (struct debug_name *) NULL)) 2698 return FALSE; 2699 } 2700 } 2701 2702 if (! (*fns->start_class_type) (fhandle, tag, id, 2703 type->kind == DEBUG_KIND_CLASS, 2704 type->size, 2705 vptrbase != NULL, 2706 vptrbase == type)) 2707 return FALSE; 2708 2709 if (type->u.kclass != NULL) 2710 { 2711 if (type->u.kclass->fields != NULL) 2712 { 2713 for (i = 0; type->u.kclass->fields[i] != NULL; i++) 2714 { 2715 struct debug_field_s *f; 2716 2717 f = type->u.kclass->fields[i]; 2718 if (! debug_write_type (info, fns, fhandle, f->type, 2719 (struct debug_name *) NULL)) 2720 return FALSE; 2721 if (f->static_member) 2722 { 2723 if (! (*fns->class_static_member) (fhandle, f->name, 2724 f->u.s.physname, 2725 f->visibility)) 2726 return FALSE; 2727 } 2728 else 2729 { 2730 if (! (*fns->struct_field) (fhandle, f->name, f->u.f.bitpos, 2731 f->u.f.bitsize, f->visibility)) 2732 return FALSE; 2733 } 2734 } 2735 } 2736 2737 if (type->u.kclass->baseclasses != NULL) 2738 { 2739 for (i = 0; type->u.kclass->baseclasses[i] != NULL; i++) 2740 { 2741 struct debug_baseclass_s *b; 2742 2743 b = type->u.kclass->baseclasses[i]; 2744 if (! debug_write_type (info, fns, fhandle, b->type, 2745 (struct debug_name *) NULL)) 2746 return FALSE; 2747 if (! (*fns->class_baseclass) (fhandle, b->bitpos, b->is_virtual, 2748 b->visibility)) 2749 return FALSE; 2750 } 2751 } 2752 2753 if (type->u.kclass->methods != NULL) 2754 { 2755 for (i = 0; type->u.kclass->methods[i] != NULL; i++) 2756 { 2757 struct debug_method_s *m; 2758 unsigned int j; 2759 2760 m = type->u.kclass->methods[i]; 2761 if (! (*fns->class_start_method) (fhandle, m->name)) 2762 return FALSE; 2763 for (j = 0; m->variants[j] != NULL; j++) 2764 { 2765 struct debug_method_variant_s *v; 2766 2767 v = m->variants[j]; 2768 if (v->context != NULL) 2769 { 2770 if (! debug_write_type (info, fns, fhandle, v->context, 2771 (struct debug_name *) NULL)) 2772 return FALSE; 2773 } 2774 if (! debug_write_type (info, fns, fhandle, v->type, 2775 (struct debug_name *) NULL)) 2776 return FALSE; 2777 if (v->voffset != VOFFSET_STATIC_METHOD) 2778 { 2779 if (! (*fns->class_method_variant) (fhandle, v->physname, 2780 v->visibility, 2781 v->constp, 2782 v->volatilep, 2783 v->voffset, 2784 v->context != NULL)) 2785 return FALSE; 2786 } 2787 else 2788 { 2789 if (! (*fns->class_static_method_variant) (fhandle, 2790 v->physname, 2791 v->visibility, 2792 v->constp, 2793 v->volatilep)) 2794 return FALSE; 2795 } 2796 } 2797 if (! (*fns->class_end_method) (fhandle)) 2798 return FALSE; 2799 } 2800 } 2801 } 2802 2803 return (*fns->end_class_type) (fhandle); 2804 } 2805 2806 /* Write out information for a function. */ 2807 2808 static bfd_boolean 2809 debug_write_function (struct debug_handle *info, 2810 const struct debug_write_fns *fns, void *fhandle, 2811 const char *name, enum debug_object_linkage linkage, 2812 struct debug_function *function) 2813 { 2814 struct debug_parameter *p; 2815 struct debug_block *b; 2816 2817 if (! debug_write_linenos (info, fns, fhandle, function->blocks->start)) 2818 return FALSE; 2819 2820 if (! debug_write_type (info, fns, fhandle, function->return_type, 2821 (struct debug_name *) NULL)) 2822 return FALSE; 2823 2824 if (! (*fns->start_function) (fhandle, name, 2825 linkage == DEBUG_LINKAGE_GLOBAL)) 2826 return FALSE; 2827 2828 for (p = function->parameters; p != NULL; p = p->next) 2829 { 2830 if (! debug_write_type (info, fns, fhandle, p->type, 2831 (struct debug_name *) NULL) 2832 || ! (*fns->function_parameter) (fhandle, p->name, p->kind, p->val)) 2833 return FALSE; 2834 } 2835 2836 for (b = function->blocks; b != NULL; b = b->next) 2837 { 2838 if (! debug_write_block (info, fns, fhandle, b)) 2839 return FALSE; 2840 } 2841 2842 return (*fns->end_function) (fhandle); 2843 } 2844 2845 /* Write out information for a block. */ 2846 2847 static bfd_boolean 2848 debug_write_block (struct debug_handle *info, 2849 const struct debug_write_fns *fns, void *fhandle, 2850 struct debug_block *block) 2851 { 2852 struct debug_name *n; 2853 struct debug_block *b; 2854 2855 if (! debug_write_linenos (info, fns, fhandle, block->start)) 2856 return FALSE; 2857 2858 /* I can't see any point to writing out a block with no local 2859 variables, so we don't bother, except for the top level block. */ 2860 if (block->locals != NULL || block->parent == NULL) 2861 { 2862 if (! (*fns->start_block) (fhandle, block->start)) 2863 return FALSE; 2864 } 2865 2866 if (block->locals != NULL) 2867 { 2868 for (n = block->locals->list; n != NULL; n = n->next) 2869 { 2870 if (! debug_write_name (info, fns, fhandle, n)) 2871 return FALSE; 2872 } 2873 } 2874 2875 for (b = block->children; b != NULL; b = b->next) 2876 { 2877 if (! debug_write_block (info, fns, fhandle, b)) 2878 return FALSE; 2879 } 2880 2881 if (! debug_write_linenos (info, fns, fhandle, block->end)) 2882 return FALSE; 2883 2884 if (block->locals != NULL || block->parent == NULL) 2885 { 2886 if (! (*fns->end_block) (fhandle, block->end)) 2887 return FALSE; 2888 } 2889 2890 return TRUE; 2891 } 2892 2893 /* Write out line number information up to ADDRESS. */ 2894 2895 static bfd_boolean 2896 debug_write_linenos (struct debug_handle *info, 2897 const struct debug_write_fns *fns, void *fhandle, 2898 bfd_vma address) 2899 { 2900 while (info->current_write_lineno != NULL) 2901 { 2902 struct debug_lineno *l; 2903 2904 l = info->current_write_lineno; 2905 2906 while (info->current_write_lineno_index < DEBUG_LINENO_COUNT) 2907 { 2908 if (l->linenos[info->current_write_lineno_index] 2909 == (unsigned long) -1) 2910 break; 2911 2912 if (l->addrs[info->current_write_lineno_index] >= address) 2913 return TRUE; 2914 2915 if (! (*fns->lineno) (fhandle, l->file->filename, 2916 l->linenos[info->current_write_lineno_index], 2917 l->addrs[info->current_write_lineno_index])) 2918 return FALSE; 2919 2920 ++info->current_write_lineno_index; 2921 } 2922 2923 info->current_write_lineno = l->next; 2924 info->current_write_lineno_index = 0; 2925 } 2926 2927 return TRUE; 2928 } 2929 2930 /* Get the ID number for a class. If during the same call to 2931 debug_write we find a struct with the same definition with the same 2932 name, we use the same ID. This type of things happens because the 2933 same struct will be defined by multiple compilation units. */ 2934 2935 static bfd_boolean 2936 debug_set_class_id (struct debug_handle *info, const char *tag, 2937 struct debug_type_s *type) 2938 { 2939 struct debug_class_type *c; 2940 struct debug_class_id *l; 2941 2942 assert (type->kind == DEBUG_KIND_STRUCT 2943 || type->kind == DEBUG_KIND_UNION 2944 || type->kind == DEBUG_KIND_CLASS 2945 || type->kind == DEBUG_KIND_UNION_CLASS); 2946 2947 c = type->u.kclass; 2948 2949 if (c->id > info->base_id) 2950 return TRUE; 2951 2952 for (l = info->id_list; l != NULL; l = l->next) 2953 { 2954 if (l->type->kind != type->kind) 2955 continue; 2956 2957 if (tag == NULL) 2958 { 2959 if (l->tag != NULL) 2960 continue; 2961 } 2962 else 2963 { 2964 if (l->tag == NULL 2965 || l->tag[0] != tag[0] 2966 || strcmp (l->tag, tag) != 0) 2967 continue; 2968 } 2969 2970 if (debug_type_samep (info, l->type, type)) 2971 { 2972 c->id = l->type->u.kclass->id; 2973 return TRUE; 2974 } 2975 } 2976 2977 /* There are no identical types. Use a new ID, and add it to the 2978 list. */ 2979 ++info->class_id; 2980 c->id = info->class_id; 2981 2982 l = (struct debug_class_id *) xmalloc (sizeof *l); 2983 memset (l, 0, sizeof *l); 2984 2985 l->type = type; 2986 l->tag = tag; 2987 2988 l->next = info->id_list; 2989 info->id_list = l; 2990 2991 return TRUE; 2992 } 2993 2994 /* See if two types are the same. At this point, we don't care about 2995 tags and the like. */ 2996 2997 static bfd_boolean 2998 debug_type_samep (struct debug_handle *info, struct debug_type_s *t1, 2999 struct debug_type_s *t2) 3000 { 3001 struct debug_type_compare_list *l; 3002 struct debug_type_compare_list top; 3003 bfd_boolean ret; 3004 3005 if (t1 == NULL) 3006 return t2 == NULL; 3007 if (t2 == NULL) 3008 return FALSE; 3009 3010 while (t1->kind == DEBUG_KIND_INDIRECT) 3011 { 3012 t1 = *t1->u.kindirect->slot; 3013 if (t1 == NULL) 3014 return FALSE; 3015 } 3016 while (t2->kind == DEBUG_KIND_INDIRECT) 3017 { 3018 t2 = *t2->u.kindirect->slot; 3019 if (t2 == NULL) 3020 return FALSE; 3021 } 3022 3023 if (t1 == t2) 3024 return TRUE; 3025 3026 /* As a special case, permit a typedef to match a tag, since C++ 3027 debugging output will sometimes add a typedef where C debugging 3028 output will not. */ 3029 if (t1->kind == DEBUG_KIND_NAMED 3030 && t2->kind == DEBUG_KIND_TAGGED) 3031 return debug_type_samep (info, t1->u.knamed->type, t2); 3032 else if (t1->kind == DEBUG_KIND_TAGGED 3033 && t2->kind == DEBUG_KIND_NAMED) 3034 return debug_type_samep (info, t1, t2->u.knamed->type); 3035 3036 if (t1->kind != t2->kind 3037 || t1->size != t2->size) 3038 return FALSE; 3039 3040 /* Get rid of the trivial cases first. */ 3041 switch (t1->kind) 3042 { 3043 default: 3044 break; 3045 case DEBUG_KIND_VOID: 3046 case DEBUG_KIND_FLOAT: 3047 case DEBUG_KIND_COMPLEX: 3048 case DEBUG_KIND_BOOL: 3049 return TRUE; 3050 case DEBUG_KIND_INT: 3051 return t1->u.kint == t2->u.kint; 3052 } 3053 3054 /* We have to avoid an infinite recursion. We do this by keeping a 3055 list of types which we are comparing. We just keep the list on 3056 the stack. If we encounter a pair of types we are currently 3057 comparing, we just assume that they are equal. */ 3058 for (l = info->compare_list; l != NULL; l = l->next) 3059 { 3060 if (l->t1 == t1 && l->t2 == t2) 3061 return TRUE; 3062 } 3063 3064 top.t1 = t1; 3065 top.t2 = t2; 3066 top.next = info->compare_list; 3067 info->compare_list = ⊤ 3068 3069 switch (t1->kind) 3070 { 3071 default: 3072 abort (); 3073 ret = FALSE; 3074 break; 3075 3076 case DEBUG_KIND_STRUCT: 3077 case DEBUG_KIND_UNION: 3078 case DEBUG_KIND_CLASS: 3079 case DEBUG_KIND_UNION_CLASS: 3080 if (t1->u.kclass == NULL) 3081 ret = t2->u.kclass == NULL; 3082 else if (t2->u.kclass == NULL) 3083 ret = FALSE; 3084 else if (t1->u.kclass->id > info->base_id 3085 && t1->u.kclass->id == t2->u.kclass->id) 3086 ret = TRUE; 3087 else 3088 ret = debug_class_type_samep (info, t1, t2); 3089 break; 3090 3091 case DEBUG_KIND_ENUM: 3092 if (t1->u.kenum == NULL) 3093 ret = t2->u.kenum == NULL; 3094 else if (t2->u.kenum == NULL) 3095 ret = FALSE; 3096 else 3097 { 3098 const char **pn1, **pn2; 3099 bfd_signed_vma *pv1, *pv2; 3100 3101 pn1 = t1->u.kenum->names; 3102 pn2 = t2->u.kenum->names; 3103 pv1 = t1->u.kenum->values; 3104 pv2 = t2->u.kenum->values; 3105 while (*pn1 != NULL && *pn2 != NULL) 3106 { 3107 if (**pn1 != **pn2 3108 || *pv1 != *pv2 3109 || strcmp (*pn1, *pn2) != 0) 3110 break; 3111 ++pn1; 3112 ++pn2; 3113 ++pv1; 3114 ++pv2; 3115 } 3116 ret = *pn1 == NULL && *pn2 == NULL; 3117 } 3118 break; 3119 3120 case DEBUG_KIND_POINTER: 3121 ret = debug_type_samep (info, t1->u.kpointer, t2->u.kpointer); 3122 break; 3123 3124 case DEBUG_KIND_FUNCTION: 3125 if (t1->u.kfunction->varargs != t2->u.kfunction->varargs 3126 || ! debug_type_samep (info, t1->u.kfunction->return_type, 3127 t2->u.kfunction->return_type) 3128 || ((t1->u.kfunction->arg_types == NULL) 3129 != (t2->u.kfunction->arg_types == NULL))) 3130 ret = FALSE; 3131 else if (t1->u.kfunction->arg_types == NULL) 3132 ret = TRUE; 3133 else 3134 { 3135 struct debug_type_s **a1, **a2; 3136 3137 a1 = t1->u.kfunction->arg_types; 3138 a2 = t2->u.kfunction->arg_types; 3139 while (*a1 != NULL && *a2 != NULL) 3140 { 3141 if (! debug_type_samep (info, *a1, *a2)) 3142 break; 3143 ++a1; 3144 ++a2; 3145 } 3146 ret = *a1 == NULL && *a2 == NULL; 3147 } 3148 break; 3149 3150 case DEBUG_KIND_REFERENCE: 3151 ret = debug_type_samep (info, t1->u.kreference, t2->u.kreference); 3152 break; 3153 3154 case DEBUG_KIND_RANGE: 3155 ret = (t1->u.krange->lower == t2->u.krange->lower 3156 && t1->u.krange->upper == t2->u.krange->upper 3157 && debug_type_samep (info, t1->u.krange->type, 3158 t2->u.krange->type)); 3159 3160 case DEBUG_KIND_ARRAY: 3161 ret = (t1->u.karray->lower == t2->u.karray->lower 3162 && t1->u.karray->upper == t2->u.karray->upper 3163 && t1->u.karray->stringp == t2->u.karray->stringp 3164 && debug_type_samep (info, t1->u.karray->element_type, 3165 t2->u.karray->element_type)); 3166 break; 3167 3168 case DEBUG_KIND_SET: 3169 ret = (t1->u.kset->bitstringp == t2->u.kset->bitstringp 3170 && debug_type_samep (info, t1->u.kset->type, t2->u.kset->type)); 3171 break; 3172 3173 case DEBUG_KIND_OFFSET: 3174 ret = (debug_type_samep (info, t1->u.koffset->base_type, 3175 t2->u.koffset->base_type) 3176 && debug_type_samep (info, t1->u.koffset->target_type, 3177 t2->u.koffset->target_type)); 3178 break; 3179 3180 case DEBUG_KIND_METHOD: 3181 if (t1->u.kmethod->varargs != t2->u.kmethod->varargs 3182 || ! debug_type_samep (info, t1->u.kmethod->return_type, 3183 t2->u.kmethod->return_type) 3184 || ! debug_type_samep (info, t1->u.kmethod->domain_type, 3185 t2->u.kmethod->domain_type) 3186 || ((t1->u.kmethod->arg_types == NULL) 3187 != (t2->u.kmethod->arg_types == NULL))) 3188 ret = FALSE; 3189 else if (t1->u.kmethod->arg_types == NULL) 3190 ret = TRUE; 3191 else 3192 { 3193 struct debug_type_s **a1, **a2; 3194 3195 a1 = t1->u.kmethod->arg_types; 3196 a2 = t2->u.kmethod->arg_types; 3197 while (*a1 != NULL && *a2 != NULL) 3198 { 3199 if (! debug_type_samep (info, *a1, *a2)) 3200 break; 3201 ++a1; 3202 ++a2; 3203 } 3204 ret = *a1 == NULL && *a2 == NULL; 3205 } 3206 break; 3207 3208 case DEBUG_KIND_CONST: 3209 ret = debug_type_samep (info, t1->u.kconst, t2->u.kconst); 3210 break; 3211 3212 case DEBUG_KIND_VOLATILE: 3213 ret = debug_type_samep (info, t1->u.kvolatile, t2->u.kvolatile); 3214 break; 3215 3216 case DEBUG_KIND_NAMED: 3217 case DEBUG_KIND_TAGGED: 3218 ret = (strcmp (t1->u.knamed->name->name, t2->u.knamed->name->name) == 0 3219 && debug_type_samep (info, t1->u.knamed->type, 3220 t2->u.knamed->type)); 3221 break; 3222 } 3223 3224 info->compare_list = top.next; 3225 3226 return ret; 3227 } 3228 3229 /* See if two classes are the same. This is a subroutine of 3230 debug_type_samep. */ 3231 3232 static bfd_boolean 3233 debug_class_type_samep (struct debug_handle *info, struct debug_type_s *t1, 3234 struct debug_type_s *t2) 3235 { 3236 struct debug_class_type *c1, *c2; 3237 3238 c1 = t1->u.kclass; 3239 c2 = t2->u.kclass; 3240 3241 if ((c1->fields == NULL) != (c2->fields == NULL) 3242 || (c1->baseclasses == NULL) != (c2->baseclasses == NULL) 3243 || (c1->methods == NULL) != (c2->methods == NULL) 3244 || (c1->vptrbase == NULL) != (c2->vptrbase == NULL)) 3245 return FALSE; 3246 3247 if (c1->fields != NULL) 3248 { 3249 struct debug_field_s **pf1, **pf2; 3250 3251 for (pf1 = c1->fields, pf2 = c2->fields; 3252 *pf1 != NULL && *pf2 != NULL; 3253 pf1++, pf2++) 3254 { 3255 struct debug_field_s *f1, *f2; 3256 3257 f1 = *pf1; 3258 f2 = *pf2; 3259 if (f1->name[0] != f2->name[0] 3260 || f1->visibility != f2->visibility 3261 || f1->static_member != f2->static_member) 3262 return FALSE; 3263 if (f1->static_member) 3264 { 3265 if (strcmp (f1->u.s.physname, f2->u.s.physname) != 0) 3266 return FALSE; 3267 } 3268 else 3269 { 3270 if (f1->u.f.bitpos != f2->u.f.bitpos 3271 || f1->u.f.bitsize != f2->u.f.bitsize) 3272 return FALSE; 3273 } 3274 /* We do the checks which require function calls last. We 3275 don't require that the types of fields have the same 3276 names, since that sometimes fails in the presence of 3277 typedefs and we really don't care. */ 3278 if (strcmp (f1->name, f2->name) != 0 3279 || ! debug_type_samep (info, 3280 debug_get_real_type ((void *) info, 3281 f1->type, NULL), 3282 debug_get_real_type ((void *) info, 3283 f2->type, NULL))) 3284 return FALSE; 3285 } 3286 if (*pf1 != NULL || *pf2 != NULL) 3287 return FALSE; 3288 } 3289 3290 if (c1->vptrbase != NULL) 3291 { 3292 if (! debug_type_samep (info, c1->vptrbase, c2->vptrbase)) 3293 return FALSE; 3294 } 3295 3296 if (c1->baseclasses != NULL) 3297 { 3298 struct debug_baseclass_s **pb1, **pb2; 3299 3300 for (pb1 = c1->baseclasses, pb2 = c2->baseclasses; 3301 *pb1 != NULL && *pb2 != NULL; 3302 ++pb1, ++pb2) 3303 { 3304 struct debug_baseclass_s *b1, *b2; 3305 3306 b1 = *pb1; 3307 b2 = *pb2; 3308 if (b1->bitpos != b2->bitpos 3309 || b1->is_virtual != b2->is_virtual 3310 || b1->visibility != b2->visibility 3311 || ! debug_type_samep (info, b1->type, b2->type)) 3312 return FALSE; 3313 } 3314 if (*pb1 != NULL || *pb2 != NULL) 3315 return FALSE; 3316 } 3317 3318 if (c1->methods != NULL) 3319 { 3320 struct debug_method_s **pm1, **pm2; 3321 3322 for (pm1 = c1->methods, pm2 = c2->methods; 3323 *pm1 != NULL && *pm2 != NULL; 3324 ++pm1, ++pm2) 3325 { 3326 struct debug_method_s *m1, *m2; 3327 3328 m1 = *pm1; 3329 m2 = *pm2; 3330 if (m1->name[0] != m2->name[0] 3331 || strcmp (m1->name, m2->name) != 0 3332 || (m1->variants == NULL) != (m2->variants == NULL)) 3333 return FALSE; 3334 if (m1->variants == NULL) 3335 { 3336 struct debug_method_variant_s **pv1, **pv2; 3337 3338 for (pv1 = m1->variants, pv2 = m2->variants; 3339 *pv1 != NULL && *pv2 != NULL; 3340 ++pv1, ++pv2) 3341 { 3342 struct debug_method_variant_s *v1, *v2; 3343 3344 v1 = *pv1; 3345 v2 = *pv2; 3346 if (v1->physname[0] != v2->physname[0] 3347 || v1->visibility != v2->visibility 3348 || v1->constp != v2->constp 3349 || v1->volatilep != v2->volatilep 3350 || v1->voffset != v2->voffset 3351 || (v1->context == NULL) != (v2->context == NULL) 3352 || strcmp (v1->physname, v2->physname) != 0 3353 || ! debug_type_samep (info, v1->type, v2->type)) 3354 return FALSE; 3355 if (v1->context != NULL) 3356 { 3357 if (! debug_type_samep (info, v1->context, 3358 v2->context)) 3359 return FALSE; 3360 } 3361 } 3362 if (*pv1 != NULL || *pv2 != NULL) 3363 return FALSE; 3364 } 3365 } 3366 if (*pm1 != NULL || *pm2 != NULL) 3367 return FALSE; 3368 } 3369 3370 return TRUE; 3371 } 3372