1/* ieee.c -- Read and write IEEE-695 debugging information. 2 Copyright 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 3 2008, 2009, 2010 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/* This file reads and writes IEEE-695 debugging information. */ 24 25#include "sysdep.h" 26#include <assert.h> 27#include "bfd.h" 28#include "ieee.h" 29#include "libiberty.h" 30#include "debug.h" 31#include "budbg.h" 32#include "filenames.h" 33 34/* This structure holds an entry on the block stack. */ 35 36struct ieee_block 37{ 38 /* The kind of block. */ 39 int kind; 40 /* The source file name, for a BB5 block. */ 41 const char *filename; 42 /* The index of the function type, for a BB4 or BB6 block. */ 43 unsigned int fnindx; 44 /* TRUE if this function is being skipped. */ 45 bfd_boolean skip; 46}; 47 48/* This structure is the block stack. */ 49 50#define BLOCKSTACK_SIZE (16) 51 52struct ieee_blockstack 53{ 54 /* The stack pointer. */ 55 struct ieee_block *bsp; 56 /* The stack. */ 57 struct ieee_block stack[BLOCKSTACK_SIZE]; 58}; 59 60/* This structure holds information for a variable. */ 61 62enum ieee_var_kind 63 { 64 IEEE_UNKNOWN, 65 IEEE_EXTERNAL, 66 IEEE_GLOBAL, 67 IEEE_STATIC, 68 IEEE_LOCAL, 69 IEEE_FUNCTION 70 }; 71 72struct ieee_var 73{ 74 /* Start of name. */ 75 const char *name; 76 /* Length of name. */ 77 unsigned long namlen; 78 /* Type. */ 79 debug_type type; 80 /* Slot if we make an indirect type. */ 81 debug_type *pslot; 82 /* Kind of variable or function. */ 83 enum ieee_var_kind kind; 84}; 85 86/* This structure holds all the variables. */ 87 88struct ieee_vars 89{ 90 /* Number of slots allocated. */ 91 unsigned int alloc; 92 /* Variables. */ 93 struct ieee_var *vars; 94}; 95 96/* This structure holds information for a type. We need this because 97 we don't want to represent bitfields as real types. */ 98 99struct ieee_type 100{ 101 /* Type. */ 102 debug_type type; 103 /* Slot if this is type is referenced before it is defined. */ 104 debug_type *pslot; 105 /* Slots for arguments if we make indirect types for them. */ 106 debug_type *arg_slots; 107 /* If this is a bitfield, this is the size in bits. If this is not 108 a bitfield, this is zero. */ 109 unsigned long bitsize; 110}; 111 112/* This structure holds all the type information. */ 113 114struct ieee_types 115{ 116 /* Number of slots allocated. */ 117 unsigned int alloc; 118 /* Types. */ 119 struct ieee_type *types; 120 /* Builtin types. */ 121#define BUILTIN_TYPE_COUNT (60) 122 debug_type builtins[BUILTIN_TYPE_COUNT]; 123}; 124 125/* This structure holds a linked last of structs with their tag names, 126 so that we can convert them to C++ classes if necessary. */ 127 128struct ieee_tag 129{ 130 /* Next tag. */ 131 struct ieee_tag *next; 132 /* This tag name. */ 133 const char *name; 134 /* The type of the tag. */ 135 debug_type type; 136 /* The tagged type is an indirect type pointing at this slot. */ 137 debug_type slot; 138 /* This is an array of slots used when a field type is converted 139 into a indirect type, in case it needs to be later converted into 140 a reference type. */ 141 debug_type *fslots; 142}; 143 144/* This structure holds the information we pass around to the parsing 145 functions. */ 146 147struct ieee_info 148{ 149 /* The debugging handle. */ 150 void *dhandle; 151 /* The BFD. */ 152 bfd *abfd; 153 /* The start of the bytes to be parsed. */ 154 const bfd_byte *bytes; 155 /* The end of the bytes to be parsed. */ 156 const bfd_byte *pend; 157 /* The block stack. */ 158 struct ieee_blockstack blockstack; 159 /* Whether we have seen a BB1 or BB2. */ 160 bfd_boolean saw_filename; 161 /* The variables. */ 162 struct ieee_vars vars; 163 /* The global variables, after a global typedef block. */ 164 struct ieee_vars *global_vars; 165 /* The types. */ 166 struct ieee_types types; 167 /* The global types, after a global typedef block. */ 168 struct ieee_types *global_types; 169 /* The list of tagged structs. */ 170 struct ieee_tag *tags; 171}; 172 173/* Basic builtin types, not including the pointers. */ 174 175enum builtin_types 176{ 177 builtin_unknown = 0, 178 builtin_void = 1, 179 builtin_signed_char = 2, 180 builtin_unsigned_char = 3, 181 builtin_signed_short_int = 4, 182 builtin_unsigned_short_int = 5, 183 builtin_signed_long = 6, 184 builtin_unsigned_long = 7, 185 builtin_signed_long_long = 8, 186 builtin_unsigned_long_long = 9, 187 builtin_float = 10, 188 builtin_double = 11, 189 builtin_long_double = 12, 190 builtin_long_long_double = 13, 191 builtin_quoted_string = 14, 192 builtin_instruction_address = 15, 193 builtin_int = 16, 194 builtin_unsigned = 17, 195 builtin_unsigned_int = 18, 196 builtin_char = 19, 197 builtin_long = 20, 198 builtin_short = 21, 199 builtin_unsigned_short = 22, 200 builtin_short_int = 23, 201 builtin_signed_short = 24, 202 builtin_bcd_float = 25 203}; 204 205/* These are the values found in the derivation flags of a 'b' 206 component record of a 'T' type extension record in a C++ pmisc 207 record. These are bitmasks. */ 208 209/* Set for a private base class, clear for a public base class. 210 Protected base classes are not supported. */ 211#define BASEFLAGS_PRIVATE (0x1) 212/* Set for a virtual base class. */ 213#define BASEFLAGS_VIRTUAL (0x2) 214/* Set for a friend class, clear for a base class. */ 215#define BASEFLAGS_FRIEND (0x10) 216 217/* These are the values found in the specs flags of a 'd', 'm', or 'v' 218 component record of a 'T' type extension record in a C++ pmisc 219 record. The same flags are used for a 'M' record in a C++ pmisc 220 record. */ 221 222/* The lower two bits hold visibility information. */ 223#define CXXFLAGS_VISIBILITY (0x3) 224/* This value in the lower two bits indicates a public member. */ 225#define CXXFLAGS_VISIBILITY_PUBLIC (0x0) 226/* This value in the lower two bits indicates a private member. */ 227#define CXXFLAGS_VISIBILITY_PRIVATE (0x1) 228/* This value in the lower two bits indicates a protected member. */ 229#define CXXFLAGS_VISIBILITY_PROTECTED (0x2) 230/* Set for a static member. */ 231#define CXXFLAGS_STATIC (0x4) 232/* Set for a virtual override. */ 233#define CXXFLAGS_OVERRIDE (0x8) 234/* Set for a friend function. */ 235#define CXXFLAGS_FRIEND (0x10) 236/* Set for a const function. */ 237#define CXXFLAGS_CONST (0x20) 238/* Set for a volatile function. */ 239#define CXXFLAGS_VOLATILE (0x40) 240/* Set for an overloaded function. */ 241#define CXXFLAGS_OVERLOADED (0x80) 242/* Set for an operator function. */ 243#define CXXFLAGS_OPERATOR (0x100) 244/* Set for a constructor or destructor. */ 245#define CXXFLAGS_CTORDTOR (0x400) 246/* Set for a constructor. */ 247#define CXXFLAGS_CTOR (0x200) 248/* Set for an inline function. */ 249#define CXXFLAGS_INLINE (0x800) 250 251/* Local functions. */ 252 253static void ieee_error (struct ieee_info *, const bfd_byte *, const char *); 254static void ieee_eof (struct ieee_info *); 255static char *savestring (const char *, unsigned long); 256static bfd_boolean ieee_read_number 257 (struct ieee_info *, const bfd_byte **, bfd_vma *); 258static bfd_boolean ieee_read_optional_number 259 (struct ieee_info *, const bfd_byte **, bfd_vma *, bfd_boolean *); 260static bfd_boolean ieee_read_id 261 (struct ieee_info *, const bfd_byte **, const char **, unsigned long *); 262static bfd_boolean ieee_read_optional_id 263 (struct ieee_info *, const bfd_byte **, const char **, unsigned long *, 264 bfd_boolean *); 265static bfd_boolean ieee_read_expression 266 (struct ieee_info *, const bfd_byte **, bfd_vma *); 267static debug_type ieee_builtin_type 268 (struct ieee_info *, const bfd_byte *, unsigned int); 269static bfd_boolean ieee_alloc_type 270 (struct ieee_info *, unsigned int, bfd_boolean); 271static bfd_boolean ieee_read_type_index 272 (struct ieee_info *, const bfd_byte **, debug_type *); 273static int ieee_regno_to_genreg (bfd *, int); 274static int ieee_genreg_to_regno (bfd *, int); 275static bfd_boolean parse_ieee_bb (struct ieee_info *, const bfd_byte **); 276static bfd_boolean parse_ieee_be (struct ieee_info *, const bfd_byte **); 277static bfd_boolean parse_ieee_nn (struct ieee_info *, const bfd_byte **); 278static bfd_boolean parse_ieee_ty (struct ieee_info *, const bfd_byte **); 279static bfd_boolean parse_ieee_atn (struct ieee_info *, const bfd_byte **); 280static bfd_boolean ieee_read_cxx_misc 281 (struct ieee_info *, const bfd_byte **, unsigned long); 282static bfd_boolean ieee_read_cxx_class 283 (struct ieee_info *, const bfd_byte **, unsigned long); 284static bfd_boolean ieee_read_cxx_defaults 285 (struct ieee_info *, const bfd_byte **, unsigned long); 286static bfd_boolean ieee_read_reference 287 (struct ieee_info *, const bfd_byte **); 288static bfd_boolean ieee_require_asn 289 (struct ieee_info *, const bfd_byte **, bfd_vma *); 290static bfd_boolean ieee_require_atn65 291 (struct ieee_info *, const bfd_byte **, const char **, unsigned long *); 292 293/* Report an error in the IEEE debugging information. */ 294 295static void 296ieee_error (struct ieee_info *info, const bfd_byte *p, const char *s) 297{ 298 if (p != NULL) 299 fprintf (stderr, "%s: 0x%lx: %s (0x%x)\n", bfd_get_filename (info->abfd), 300 (unsigned long) (p - info->bytes), s, *p); 301 else 302 fprintf (stderr, "%s: %s\n", bfd_get_filename (info->abfd), s); 303} 304 305/* Report an unexpected EOF in the IEEE debugging information. */ 306 307static void 308ieee_eof (struct ieee_info *info) 309{ 310 ieee_error (info, (const bfd_byte *) NULL, 311 _("unexpected end of debugging information")); 312} 313 314/* Save a string in memory. */ 315 316static char * 317savestring (const char *start, unsigned long len) 318{ 319 char *ret; 320 321 ret = (char *) xmalloc (len + 1); 322 memcpy (ret, start, len); 323 ret[len] = '\0'; 324 return ret; 325} 326 327/* Read a number which must be present in an IEEE file. */ 328 329static bfd_boolean 330ieee_read_number (struct ieee_info *info, const bfd_byte **pp, bfd_vma *pv) 331{ 332 return ieee_read_optional_number (info, pp, pv, (bfd_boolean *) NULL); 333} 334 335/* Read a number in an IEEE file. If ppresent is not NULL, the number 336 need not be there. */ 337 338static bfd_boolean 339ieee_read_optional_number (struct ieee_info *info, const bfd_byte **pp, 340 bfd_vma *pv, bfd_boolean *ppresent) 341{ 342 ieee_record_enum_type b; 343 344 if (*pp >= info->pend) 345 { 346 if (ppresent != NULL) 347 { 348 *ppresent = FALSE; 349 return TRUE; 350 } 351 ieee_eof (info); 352 return FALSE; 353 } 354 355 b = (ieee_record_enum_type) **pp; 356 ++*pp; 357 358 if (b <= ieee_number_end_enum) 359 { 360 *pv = (bfd_vma) b; 361 if (ppresent != NULL) 362 *ppresent = TRUE; 363 return TRUE; 364 } 365 366 if (b >= ieee_number_repeat_start_enum && b <= ieee_number_repeat_end_enum) 367 { 368 unsigned int i; 369 370 i = (int) b - (int) ieee_number_repeat_start_enum; 371 if (*pp + i - 1 >= info->pend) 372 { 373 ieee_eof (info); 374 return FALSE; 375 } 376 377 *pv = 0; 378 for (; i > 0; i--) 379 { 380 *pv <<= 8; 381 *pv += **pp; 382 ++*pp; 383 } 384 385 if (ppresent != NULL) 386 *ppresent = TRUE; 387 388 return TRUE; 389 } 390 391 if (ppresent != NULL) 392 { 393 --*pp; 394 *ppresent = FALSE; 395 return TRUE; 396 } 397 398 ieee_error (info, *pp - 1, _("invalid number")); 399 return FALSE; 400} 401 402/* Read a required string from an IEEE file. */ 403 404static bfd_boolean 405ieee_read_id (struct ieee_info *info, const bfd_byte **pp, 406 const char **pname, unsigned long *pnamlen) 407{ 408 return ieee_read_optional_id (info, pp, pname, pnamlen, (bfd_boolean *) NULL); 409} 410 411/* Read a string from an IEEE file. If ppresent is not NULL, the 412 string is optional. */ 413 414static bfd_boolean 415ieee_read_optional_id (struct ieee_info *info, const bfd_byte **pp, 416 const char **pname, unsigned long *pnamlen, 417 bfd_boolean *ppresent) 418{ 419 bfd_byte b; 420 unsigned long len; 421 422 if (*pp >= info->pend) 423 { 424 ieee_eof (info); 425 return FALSE; 426 } 427 428 b = **pp; 429 ++*pp; 430 431 if (b <= 0x7f) 432 len = b; 433 else if ((ieee_record_enum_type) b == ieee_extension_length_1_enum) 434 { 435 len = **pp; 436 ++*pp; 437 } 438 else if ((ieee_record_enum_type) b == ieee_extension_length_2_enum) 439 { 440 len = (**pp << 8) + (*pp)[1]; 441 *pp += 2; 442 } 443 else 444 { 445 if (ppresent != NULL) 446 { 447 --*pp; 448 *ppresent = FALSE; 449 return TRUE; 450 } 451 ieee_error (info, *pp - 1, _("invalid string length")); 452 return FALSE; 453 } 454 455 if ((unsigned long) (info->pend - *pp) < len) 456 { 457 ieee_eof (info); 458 return FALSE; 459 } 460 461 *pname = (const char *) *pp; 462 *pnamlen = len; 463 *pp += len; 464 465 if (ppresent != NULL) 466 *ppresent = TRUE; 467 468 return TRUE; 469} 470 471/* Read an expression from an IEEE file. Since this code is only used 472 to parse debugging information, I haven't bothered to write a full 473 blown IEEE expression parser. I've only thrown in the things I've 474 seen in debugging information. This can be easily extended if 475 necessary. */ 476 477static bfd_boolean 478ieee_read_expression (struct ieee_info *info, const bfd_byte **pp, 479 bfd_vma *pv) 480{ 481 const bfd_byte *expr_start; 482#define EXPR_STACK_SIZE (10) 483 bfd_vma expr_stack[EXPR_STACK_SIZE]; 484 bfd_vma *esp; 485 486 expr_start = *pp; 487 488 esp = expr_stack; 489 490 while (1) 491 { 492 const bfd_byte *start; 493 bfd_vma val; 494 bfd_boolean present; 495 ieee_record_enum_type c; 496 497 start = *pp; 498 499 if (! ieee_read_optional_number (info, pp, &val, &present)) 500 return FALSE; 501 502 if (present) 503 { 504 if (esp - expr_stack >= EXPR_STACK_SIZE) 505 { 506 ieee_error (info, start, _("expression stack overflow")); 507 return FALSE; 508 } 509 *esp++ = val; 510 continue; 511 } 512 513 c = (ieee_record_enum_type) **pp; 514 515 if (c >= ieee_module_beginning_enum) 516 break; 517 518 ++*pp; 519 520 if (c == ieee_comma) 521 break; 522 523 switch (c) 524 { 525 default: 526 ieee_error (info, start, _("unsupported IEEE expression operator")); 527 break; 528 529 case ieee_variable_R_enum: 530 { 531 bfd_vma indx; 532 asection *s; 533 534 if (! ieee_read_number (info, pp, &indx)) 535 return FALSE; 536 for (s = info->abfd->sections; s != NULL; s = s->next) 537 if ((bfd_vma) s->target_index == indx) 538 break; 539 if (s == NULL) 540 { 541 ieee_error (info, start, _("unknown section")); 542 return FALSE; 543 } 544 545 if (esp - expr_stack >= EXPR_STACK_SIZE) 546 { 547 ieee_error (info, start, _("expression stack overflow")); 548 return FALSE; 549 } 550 551 *esp++ = bfd_get_section_vma (info->abfd, s); 552 } 553 break; 554 555 case ieee_function_plus_enum: 556 case ieee_function_minus_enum: 557 { 558 bfd_vma v1, v2; 559 560 if (esp - expr_stack < 2) 561 { 562 ieee_error (info, start, _("expression stack underflow")); 563 return FALSE; 564 } 565 566 v1 = *--esp; 567 v2 = *--esp; 568 *esp++ = v1 + v2; 569 } 570 break; 571 } 572 } 573 574 if (esp - 1 != expr_stack) 575 { 576 ieee_error (info, expr_start, _("expression stack mismatch")); 577 return FALSE; 578 } 579 580 *pv = *--esp; 581 582 return TRUE; 583} 584 585/* Return an IEEE builtin type. */ 586 587static debug_type 588ieee_builtin_type (struct ieee_info *info, const bfd_byte *p, 589 unsigned int indx) 590{ 591 void *dhandle; 592 debug_type type; 593 const char *name; 594 595 if (indx < BUILTIN_TYPE_COUNT 596 && info->types.builtins[indx] != DEBUG_TYPE_NULL) 597 return info->types.builtins[indx]; 598 599 dhandle = info->dhandle; 600 601 if (indx >= 32 && indx < 64) 602 { 603 type = debug_make_pointer_type (dhandle, 604 ieee_builtin_type (info, p, indx - 32)); 605 assert (indx < BUILTIN_TYPE_COUNT); 606 info->types.builtins[indx] = type; 607 return type; 608 } 609 610 switch ((enum builtin_types) indx) 611 { 612 default: 613 ieee_error (info, p, _("unknown builtin type")); 614 return NULL; 615 616 case builtin_unknown: 617 type = debug_make_void_type (dhandle); 618 name = NULL; 619 break; 620 621 case builtin_void: 622 type = debug_make_void_type (dhandle); 623 name = "void"; 624 break; 625 626 case builtin_signed_char: 627 type = debug_make_int_type (dhandle, 1, FALSE); 628 name = "signed char"; 629 break; 630 631 case builtin_unsigned_char: 632 type = debug_make_int_type (dhandle, 1, TRUE); 633 name = "unsigned char"; 634 break; 635 636 case builtin_signed_short_int: 637 type = debug_make_int_type (dhandle, 2, FALSE); 638 name = "signed short int"; 639 break; 640 641 case builtin_unsigned_short_int: 642 type = debug_make_int_type (dhandle, 2, TRUE); 643 name = "unsigned short int"; 644 break; 645 646 case builtin_signed_long: 647 type = debug_make_int_type (dhandle, 4, FALSE); 648 name = "signed long"; 649 break; 650 651 case builtin_unsigned_long: 652 type = debug_make_int_type (dhandle, 4, TRUE); 653 name = "unsigned long"; 654 break; 655 656 case builtin_signed_long_long: 657 type = debug_make_int_type (dhandle, 8, FALSE); 658 name = "signed long long"; 659 break; 660 661 case builtin_unsigned_long_long: 662 type = debug_make_int_type (dhandle, 8, TRUE); 663 name = "unsigned long long"; 664 break; 665 666 case builtin_float: 667 type = debug_make_float_type (dhandle, 4); 668 name = "float"; 669 break; 670 671 case builtin_double: 672 type = debug_make_float_type (dhandle, 8); 673 name = "double"; 674 break; 675 676 case builtin_long_double: 677 /* FIXME: The size for this type should depend upon the 678 processor. */ 679 type = debug_make_float_type (dhandle, 12); 680 name = "long double"; 681 break; 682 683 case builtin_long_long_double: 684 type = debug_make_float_type (dhandle, 16); 685 name = "long long double"; 686 break; 687 688 case builtin_quoted_string: 689 type = debug_make_array_type (dhandle, 690 ieee_builtin_type (info, p, 691 ((unsigned int) 692 builtin_char)), 693 ieee_builtin_type (info, p, 694 ((unsigned int) 695 builtin_int)), 696 0, -1, TRUE); 697 name = "QUOTED STRING"; 698 break; 699 700 case builtin_instruction_address: 701 /* FIXME: This should be a code address. */ 702 type = debug_make_int_type (dhandle, 4, TRUE); 703 name = "instruction address"; 704 break; 705 706 case builtin_int: 707 /* FIXME: The size for this type should depend upon the 708 processor. */ 709 type = debug_make_int_type (dhandle, 4, FALSE); 710 name = "int"; 711 break; 712 713 case builtin_unsigned: 714 /* FIXME: The size for this type should depend upon the 715 processor. */ 716 type = debug_make_int_type (dhandle, 4, TRUE); 717 name = "unsigned"; 718 break; 719 720 case builtin_unsigned_int: 721 /* FIXME: The size for this type should depend upon the 722 processor. */ 723 type = debug_make_int_type (dhandle, 4, TRUE); 724 name = "unsigned int"; 725 break; 726 727 case builtin_char: 728 type = debug_make_int_type (dhandle, 1, FALSE); 729 name = "char"; 730 break; 731 732 case builtin_long: 733 type = debug_make_int_type (dhandle, 4, FALSE); 734 name = "long"; 735 break; 736 737 case builtin_short: 738 type = debug_make_int_type (dhandle, 2, FALSE); 739 name = "short"; 740 break; 741 742 case builtin_unsigned_short: 743 type = debug_make_int_type (dhandle, 2, TRUE); 744 name = "unsigned short"; 745 break; 746 747 case builtin_short_int: 748 type = debug_make_int_type (dhandle, 2, FALSE); 749 name = "short int"; 750 break; 751 752 case builtin_signed_short: 753 type = debug_make_int_type (dhandle, 2, FALSE); 754 name = "signed short"; 755 break; 756 757 case builtin_bcd_float: 758 ieee_error (info, p, _("BCD float type not supported")); 759 return DEBUG_TYPE_NULL; 760 } 761 762 if (name != NULL) 763 type = debug_name_type (dhandle, name, type); 764 765 assert (indx < BUILTIN_TYPE_COUNT); 766 767 info->types.builtins[indx] = type; 768 769 return type; 770} 771 772/* Allocate more space in the type table. If ref is TRUE, this is a 773 reference to the type; if it is not already defined, we should set 774 up an indirect type. */ 775 776static bfd_boolean 777ieee_alloc_type (struct ieee_info *info, unsigned int indx, bfd_boolean ref) 778{ 779 unsigned int nalloc; 780 register struct ieee_type *t; 781 struct ieee_type *tend; 782 783 if (indx >= info->types.alloc) 784 { 785 nalloc = info->types.alloc; 786 if (nalloc == 0) 787 nalloc = 4; 788 while (indx >= nalloc) 789 nalloc *= 2; 790 791 info->types.types = ((struct ieee_type *) 792 xrealloc (info->types.types, 793 nalloc * sizeof *info->types.types)); 794 795 memset (info->types.types + info->types.alloc, 0, 796 (nalloc - info->types.alloc) * sizeof *info->types.types); 797 798 tend = info->types.types + nalloc; 799 for (t = info->types.types + info->types.alloc; t < tend; t++) 800 t->type = DEBUG_TYPE_NULL; 801 802 info->types.alloc = nalloc; 803 } 804 805 if (ref) 806 { 807 t = info->types.types + indx; 808 if (t->type == NULL) 809 { 810 t->pslot = (debug_type *) xmalloc (sizeof *t->pslot); 811 *t->pslot = DEBUG_TYPE_NULL; 812 t->type = debug_make_indirect_type (info->dhandle, t->pslot, 813 (const char *) NULL); 814 if (t->type == NULL) 815 return FALSE; 816 } 817 } 818 819 return TRUE; 820} 821 822/* Read a type index and return the corresponding type. */ 823 824static bfd_boolean 825ieee_read_type_index (struct ieee_info *info, const bfd_byte **pp, 826 debug_type *ptype) 827{ 828 const bfd_byte *start; 829 bfd_vma indx; 830 831 start = *pp; 832 833 if (! ieee_read_number (info, pp, &indx)) 834 return FALSE; 835 836 if (indx < 256) 837 { 838 *ptype = ieee_builtin_type (info, start, indx); 839 if (*ptype == NULL) 840 return FALSE; 841 return TRUE; 842 } 843 844 indx -= 256; 845 if (! ieee_alloc_type (info, indx, TRUE)) 846 return FALSE; 847 848 *ptype = info->types.types[indx].type; 849 850 return TRUE; 851} 852 853/* Parse IEEE debugging information for a file. This is passed the 854 bytes which compose the Debug Information Part of an IEEE file. */ 855 856bfd_boolean 857parse_ieee (void *dhandle, bfd *abfd, const bfd_byte *bytes, bfd_size_type len) 858{ 859 struct ieee_info info; 860 unsigned int i; 861 const bfd_byte *p, *pend; 862 863 info.dhandle = dhandle; 864 info.abfd = abfd; 865 info.bytes = bytes; 866 info.pend = bytes + len; 867 info.blockstack.bsp = info.blockstack.stack; 868 info.saw_filename = FALSE; 869 info.vars.alloc = 0; 870 info.vars.vars = NULL; 871 info.global_vars = NULL; 872 info.types.alloc = 0; 873 info.types.types = NULL; 874 info.global_types = NULL; 875 info.tags = NULL; 876 for (i = 0; i < BUILTIN_TYPE_COUNT; i++) 877 info.types.builtins[i] = DEBUG_TYPE_NULL; 878 879 p = bytes; 880 pend = info.pend; 881 while (p < pend) 882 { 883 const bfd_byte *record_start; 884 ieee_record_enum_type c; 885 886 record_start = p; 887 888 c = (ieee_record_enum_type) *p++; 889 890 if (c == ieee_at_record_enum) 891 c = (ieee_record_enum_type) (((unsigned int) c << 8) | *p++); 892 893 if (c <= ieee_number_repeat_end_enum) 894 { 895 ieee_error (&info, record_start, _("unexpected number")); 896 return FALSE; 897 } 898 899 switch (c) 900 { 901 default: 902 ieee_error (&info, record_start, _("unexpected record type")); 903 return FALSE; 904 905 case ieee_bb_record_enum: 906 if (! parse_ieee_bb (&info, &p)) 907 return FALSE; 908 break; 909 910 case ieee_be_record_enum: 911 if (! parse_ieee_be (&info, &p)) 912 return FALSE; 913 break; 914 915 case ieee_nn_record: 916 if (! parse_ieee_nn (&info, &p)) 917 return FALSE; 918 break; 919 920 case ieee_ty_record_enum: 921 if (! parse_ieee_ty (&info, &p)) 922 return FALSE; 923 break; 924 925 case ieee_atn_record_enum: 926 if (! parse_ieee_atn (&info, &p)) 927 return FALSE; 928 break; 929 } 930 } 931 932 if (info.blockstack.bsp != info.blockstack.stack) 933 { 934 ieee_error (&info, (const bfd_byte *) NULL, 935 _("blocks left on stack at end")); 936 return FALSE; 937 } 938 939 return TRUE; 940} 941 942/* Handle an IEEE BB record. */ 943 944static bfd_boolean 945parse_ieee_bb (struct ieee_info *info, const bfd_byte **pp) 946{ 947 const bfd_byte *block_start; 948 bfd_byte b; 949 bfd_vma size; 950 const char *name; 951 unsigned long namlen; 952 char *namcopy = NULL; 953 unsigned int fnindx; 954 bfd_boolean skip; 955 956 block_start = *pp; 957 958 b = **pp; 959 ++*pp; 960 961 if (! ieee_read_number (info, pp, &size) 962 || ! ieee_read_id (info, pp, &name, &namlen)) 963 return FALSE; 964 965 fnindx = (unsigned int) -1; 966 skip = FALSE; 967 968 switch (b) 969 { 970 case 1: 971 /* BB1: Type definitions local to a module. */ 972 namcopy = savestring (name, namlen); 973 if (namcopy == NULL) 974 return FALSE; 975 if (! debug_set_filename (info->dhandle, namcopy)) 976 return FALSE; 977 info->saw_filename = TRUE; 978 979 /* Discard any variables or types we may have seen before. */ 980 if (info->vars.vars != NULL) 981 free (info->vars.vars); 982 info->vars.vars = NULL; 983 info->vars.alloc = 0; 984 if (info->types.types != NULL) 985 free (info->types.types); 986 info->types.types = NULL; 987 info->types.alloc = 0; 988 989 /* Initialize the types to the global types. */ 990 if (info->global_types != NULL) 991 { 992 info->types.alloc = info->global_types->alloc; 993 info->types.types = ((struct ieee_type *) 994 xmalloc (info->types.alloc 995 * sizeof (*info->types.types))); 996 memcpy (info->types.types, info->global_types->types, 997 info->types.alloc * sizeof (*info->types.types)); 998 } 999 1000 break; 1001 1002 case 2: 1003 /* BB2: Global type definitions. The name is supposed to be 1004 empty, but we don't check. */ 1005 if (! debug_set_filename (info->dhandle, "*global*")) 1006 return FALSE; 1007 info->saw_filename = TRUE; 1008 break; 1009 1010 case 3: 1011 /* BB3: High level module block begin. We don't have to do 1012 anything here. The name is supposed to be the same as for 1013 the BB1, but we don't check. */ 1014 break; 1015 1016 case 4: 1017 /* BB4: Global function. */ 1018 { 1019 bfd_vma stackspace, typindx, offset; 1020 debug_type return_type; 1021 1022 if (! ieee_read_number (info, pp, &stackspace) 1023 || ! ieee_read_number (info, pp, &typindx) 1024 || ! ieee_read_expression (info, pp, &offset)) 1025 return FALSE; 1026 1027 /* We have no way to record the stack space. FIXME. */ 1028 1029 if (typindx < 256) 1030 { 1031 return_type = ieee_builtin_type (info, block_start, typindx); 1032 if (return_type == DEBUG_TYPE_NULL) 1033 return FALSE; 1034 } 1035 else 1036 { 1037 typindx -= 256; 1038 if (! ieee_alloc_type (info, typindx, TRUE)) 1039 return FALSE; 1040 fnindx = typindx; 1041 return_type = info->types.types[typindx].type; 1042 if (debug_get_type_kind (info->dhandle, return_type) 1043 == DEBUG_KIND_FUNCTION) 1044 return_type = debug_get_return_type (info->dhandle, 1045 return_type); 1046 } 1047 1048 namcopy = savestring (name, namlen); 1049 if (namcopy == NULL) 1050 return FALSE; 1051 if (! debug_record_function (info->dhandle, namcopy, return_type, 1052 TRUE, offset)) 1053 return FALSE; 1054 } 1055 break; 1056 1057 case 5: 1058 /* BB5: File name for source line numbers. */ 1059 { 1060 unsigned int i; 1061 1062 /* We ignore the date and time. FIXME. */ 1063 for (i = 0; i < 6; i++) 1064 { 1065 bfd_vma ignore; 1066 bfd_boolean present; 1067 1068 if (! ieee_read_optional_number (info, pp, &ignore, &present)) 1069 return FALSE; 1070 if (! present) 1071 break; 1072 } 1073 1074 if (! info->saw_filename) 1075 { 1076 namcopy = savestring (name, namlen); 1077 if (namcopy == NULL) 1078 return FALSE; 1079 if (! debug_set_filename (info->dhandle, namcopy)) 1080 return FALSE; 1081 info->saw_filename = TRUE; 1082 } 1083 1084 namcopy = savestring (name, namlen); 1085 if (namcopy == NULL) 1086 return FALSE; 1087 if (! debug_start_source (info->dhandle, namcopy)) 1088 return FALSE; 1089 } 1090 break; 1091 1092 case 6: 1093 /* BB6: Local function or block. */ 1094 { 1095 bfd_vma stackspace, typindx, offset; 1096 1097 if (! ieee_read_number (info, pp, &stackspace) 1098 || ! ieee_read_number (info, pp, &typindx) 1099 || ! ieee_read_expression (info, pp, &offset)) 1100 return FALSE; 1101 1102 /* We have no way to record the stack space. FIXME. */ 1103 1104 if (namlen == 0) 1105 { 1106 if (! debug_start_block (info->dhandle, offset)) 1107 return FALSE; 1108 /* Change b to indicate that this is a block 1109 rather than a function. */ 1110 b = 0x86; 1111 } 1112 else 1113 { 1114 /* The MRI C++ compiler will output a fake function named 1115 __XRYCPP to hold C++ debugging information. We skip 1116 that function. This is not crucial, but it makes 1117 converting from IEEE to other debug formats work 1118 better. */ 1119 if (strncmp (name, "__XRYCPP", namlen) == 0) 1120 skip = TRUE; 1121 else 1122 { 1123 debug_type return_type; 1124 1125 if (typindx < 256) 1126 { 1127 return_type = ieee_builtin_type (info, block_start, 1128 typindx); 1129 if (return_type == NULL) 1130 return FALSE; 1131 } 1132 else 1133 { 1134 typindx -= 256; 1135 if (! ieee_alloc_type (info, typindx, TRUE)) 1136 return FALSE; 1137 fnindx = typindx; 1138 return_type = info->types.types[typindx].type; 1139 if (debug_get_type_kind (info->dhandle, return_type) 1140 == DEBUG_KIND_FUNCTION) 1141 return_type = debug_get_return_type (info->dhandle, 1142 return_type); 1143 } 1144 1145 namcopy = savestring (name, namlen); 1146 if (namcopy == NULL) 1147 return FALSE; 1148 if (! debug_record_function (info->dhandle, namcopy, 1149 return_type, FALSE, offset)) 1150 return FALSE; 1151 } 1152 } 1153 } 1154 break; 1155 1156 case 10: 1157 /* BB10: Assembler module scope. In the normal case, we 1158 completely ignore all this information. FIXME. */ 1159 { 1160 const char *inam, *vstr; 1161 unsigned long inamlen, vstrlen; 1162 bfd_vma tool_type; 1163 bfd_boolean present; 1164 unsigned int i; 1165 1166 if (! info->saw_filename) 1167 { 1168 namcopy = savestring (name, namlen); 1169 if (namcopy == NULL) 1170 return FALSE; 1171 if (! debug_set_filename (info->dhandle, namcopy)) 1172 return FALSE; 1173 info->saw_filename = TRUE; 1174 } 1175 1176 if (! ieee_read_id (info, pp, &inam, &inamlen) 1177 || ! ieee_read_number (info, pp, &tool_type) 1178 || ! ieee_read_optional_id (info, pp, &vstr, &vstrlen, &present)) 1179 return FALSE; 1180 for (i = 0; i < 6; i++) 1181 { 1182 bfd_vma ignore; 1183 1184 if (! ieee_read_optional_number (info, pp, &ignore, &present)) 1185 return FALSE; 1186 if (! present) 1187 break; 1188 } 1189 } 1190 break; 1191 1192 case 11: 1193 /* BB11: Module section. We completely ignore all this 1194 information. FIXME. */ 1195 { 1196 bfd_vma sectype, secindx, offset, map; 1197 bfd_boolean present; 1198 1199 if (! ieee_read_number (info, pp, §ype) 1200 || ! ieee_read_number (info, pp, &secindx) 1201 || ! ieee_read_expression (info, pp, &offset) 1202 || ! ieee_read_optional_number (info, pp, &map, &present)) 1203 return FALSE; 1204 } 1205 break; 1206 1207 default: 1208 ieee_error (info, block_start, _("unknown BB type")); 1209 return FALSE; 1210 } 1211 1212 1213 /* Push this block on the block stack. */ 1214 1215 if (info->blockstack.bsp >= info->blockstack.stack + BLOCKSTACK_SIZE) 1216 { 1217 ieee_error (info, (const bfd_byte *) NULL, _("stack overflow")); 1218 return FALSE; 1219 } 1220 1221 info->blockstack.bsp->kind = b; 1222 if (b == 5) 1223 info->blockstack.bsp->filename = namcopy; 1224 info->blockstack.bsp->fnindx = fnindx; 1225 info->blockstack.bsp->skip = skip; 1226 ++info->blockstack.bsp; 1227 1228 return TRUE; 1229} 1230 1231/* Handle an IEEE BE record. */ 1232 1233static bfd_boolean 1234parse_ieee_be (struct ieee_info *info, const bfd_byte **pp) 1235{ 1236 bfd_vma offset; 1237 1238 if (info->blockstack.bsp <= info->blockstack.stack) 1239 { 1240 ieee_error (info, *pp, _("stack underflow")); 1241 return FALSE; 1242 } 1243 --info->blockstack.bsp; 1244 1245 switch (info->blockstack.bsp->kind) 1246 { 1247 case 2: 1248 /* When we end the global typedefs block, we copy out the 1249 contents of info->vars. This is because the variable indices 1250 may be reused in the local blocks. However, we need to 1251 preserve them so that we can locate a function returning a 1252 reference variable whose type is named in the global typedef 1253 block. */ 1254 info->global_vars = ((struct ieee_vars *) 1255 xmalloc (sizeof *info->global_vars)); 1256 info->global_vars->alloc = info->vars.alloc; 1257 info->global_vars->vars = ((struct ieee_var *) 1258 xmalloc (info->vars.alloc 1259 * sizeof (*info->vars.vars))); 1260 memcpy (info->global_vars->vars, info->vars.vars, 1261 info->vars.alloc * sizeof (*info->vars.vars)); 1262 1263 /* We also copy out the non builtin parts of info->types, since 1264 the types are discarded when we start a new block. */ 1265 info->global_types = ((struct ieee_types *) 1266 xmalloc (sizeof *info->global_types)); 1267 info->global_types->alloc = info->types.alloc; 1268 info->global_types->types = ((struct ieee_type *) 1269 xmalloc (info->types.alloc 1270 * sizeof (*info->types.types))); 1271 memcpy (info->global_types->types, info->types.types, 1272 info->types.alloc * sizeof (*info->types.types)); 1273 memset (info->global_types->builtins, 0, 1274 sizeof (info->global_types->builtins)); 1275 1276 break; 1277 1278 case 4: 1279 case 6: 1280 if (! ieee_read_expression (info, pp, &offset)) 1281 return FALSE; 1282 if (! info->blockstack.bsp->skip) 1283 { 1284 if (! debug_end_function (info->dhandle, offset + 1)) 1285 return FALSE; 1286 } 1287 break; 1288 1289 case 0x86: 1290 /* This is BE6 when BB6 started a block rather than a local 1291 function. */ 1292 if (! ieee_read_expression (info, pp, &offset)) 1293 return FALSE; 1294 if (! debug_end_block (info->dhandle, offset + 1)) 1295 return FALSE; 1296 break; 1297 1298 case 5: 1299 /* When we end a BB5, we look up the stack for the last BB5, if 1300 there is one, so that we can call debug_start_source. */ 1301 if (info->blockstack.bsp > info->blockstack.stack) 1302 { 1303 struct ieee_block *bl; 1304 1305 bl = info->blockstack.bsp; 1306 do 1307 { 1308 --bl; 1309 if (bl->kind == 5) 1310 { 1311 if (! debug_start_source (info->dhandle, bl->filename)) 1312 return FALSE; 1313 break; 1314 } 1315 } 1316 while (bl != info->blockstack.stack); 1317 } 1318 break; 1319 1320 case 11: 1321 if (! ieee_read_expression (info, pp, &offset)) 1322 return FALSE; 1323 /* We just ignore the module size. FIXME. */ 1324 break; 1325 1326 default: 1327 /* Other block types do not have any trailing information. */ 1328 break; 1329 } 1330 1331 return TRUE; 1332} 1333 1334/* Parse an NN record. */ 1335 1336static bfd_boolean 1337parse_ieee_nn (struct ieee_info *info, const bfd_byte **pp) 1338{ 1339 const bfd_byte *nn_start; 1340 bfd_vma varindx; 1341 const char *name; 1342 unsigned long namlen; 1343 1344 nn_start = *pp; 1345 1346 if (! ieee_read_number (info, pp, &varindx) 1347 || ! ieee_read_id (info, pp, &name, &namlen)) 1348 return FALSE; 1349 1350 if (varindx < 32) 1351 { 1352 ieee_error (info, nn_start, _("illegal variable index")); 1353 return FALSE; 1354 } 1355 varindx -= 32; 1356 1357 if (varindx >= info->vars.alloc) 1358 { 1359 unsigned int alloc; 1360 1361 alloc = info->vars.alloc; 1362 if (alloc == 0) 1363 alloc = 4; 1364 while (varindx >= alloc) 1365 alloc *= 2; 1366 info->vars.vars = ((struct ieee_var *) 1367 xrealloc (info->vars.vars, 1368 alloc * sizeof *info->vars.vars)); 1369 memset (info->vars.vars + info->vars.alloc, 0, 1370 (alloc - info->vars.alloc) * sizeof *info->vars.vars); 1371 info->vars.alloc = alloc; 1372 } 1373 1374 info->vars.vars[varindx].name = name; 1375 info->vars.vars[varindx].namlen = namlen; 1376 1377 return TRUE; 1378} 1379 1380/* Parse a TY record. */ 1381 1382static bfd_boolean 1383parse_ieee_ty (struct ieee_info *info, const bfd_byte **pp) 1384{ 1385 const bfd_byte *ty_start, *ty_var_start, *ty_code_start; 1386 bfd_vma typeindx, varindx, tc; 1387 void *dhandle; 1388 bfd_boolean tag, typdef; 1389 debug_type *arg_slots; 1390 unsigned long type_bitsize; 1391 debug_type type; 1392 1393 ty_start = *pp; 1394 1395 if (! ieee_read_number (info, pp, &typeindx)) 1396 return FALSE; 1397 1398 if (typeindx < 256) 1399 { 1400 ieee_error (info, ty_start, _("illegal type index")); 1401 return FALSE; 1402 } 1403 1404 typeindx -= 256; 1405 if (! ieee_alloc_type (info, typeindx, FALSE)) 1406 return FALSE; 1407 1408 if (**pp != 0xce) 1409 { 1410 ieee_error (info, *pp, _("unknown TY code")); 1411 return FALSE; 1412 } 1413 ++*pp; 1414 1415 ty_var_start = *pp; 1416 1417 if (! ieee_read_number (info, pp, &varindx)) 1418 return FALSE; 1419 1420 if (varindx < 32) 1421 { 1422 ieee_error (info, ty_var_start, _("illegal variable index")); 1423 return FALSE; 1424 } 1425 varindx -= 32; 1426 1427 if (varindx >= info->vars.alloc || info->vars.vars[varindx].name == NULL) 1428 { 1429 ieee_error (info, ty_var_start, _("undefined variable in TY")); 1430 return FALSE; 1431 } 1432 1433 ty_code_start = *pp; 1434 1435 if (! ieee_read_number (info, pp, &tc)) 1436 return FALSE; 1437 1438 dhandle = info->dhandle; 1439 1440 tag = FALSE; 1441 typdef = FALSE; 1442 arg_slots = NULL; 1443 type_bitsize = 0; 1444 switch (tc) 1445 { 1446 default: 1447 ieee_error (info, ty_code_start, _("unknown TY code")); 1448 return FALSE; 1449 1450 case '!': 1451 /* Unknown type, with size. We treat it as int. FIXME. */ 1452 { 1453 bfd_vma size; 1454 1455 if (! ieee_read_number (info, pp, &size)) 1456 return FALSE; 1457 type = debug_make_int_type (dhandle, size, FALSE); 1458 } 1459 break; 1460 1461 case 'A': /* Array. */ 1462 case 'a': /* FORTRAN array in column/row order. FIXME: Not 1463 distinguished from normal array. */ 1464 { 1465 debug_type ele_type; 1466 bfd_vma lower, upper; 1467 1468 if (! ieee_read_type_index (info, pp, &ele_type) 1469 || ! ieee_read_number (info, pp, &lower) 1470 || ! ieee_read_number (info, pp, &upper)) 1471 return FALSE; 1472 type = debug_make_array_type (dhandle, ele_type, 1473 ieee_builtin_type (info, ty_code_start, 1474 ((unsigned int) 1475 builtin_int)), 1476 (bfd_signed_vma) lower, 1477 (bfd_signed_vma) upper, 1478 FALSE); 1479 } 1480 break; 1481 1482 case 'E': 1483 /* Simple enumeration. */ 1484 { 1485 bfd_vma size; 1486 unsigned int alloc; 1487 const char **names; 1488 unsigned int c; 1489 bfd_signed_vma *vals; 1490 unsigned int i; 1491 1492 if (! ieee_read_number (info, pp, &size)) 1493 return FALSE; 1494 /* FIXME: we ignore the enumeration size. */ 1495 1496 alloc = 10; 1497 names = (const char **) xmalloc (alloc * sizeof *names); 1498 memset (names, 0, alloc * sizeof *names); 1499 c = 0; 1500 while (1) 1501 { 1502 const char *name; 1503 unsigned long namlen; 1504 bfd_boolean present; 1505 1506 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present)) 1507 return FALSE; 1508 if (! present) 1509 break; 1510 1511 if (c + 1 >= alloc) 1512 { 1513 alloc += 10; 1514 names = ((const char **) 1515 xrealloc (names, alloc * sizeof *names)); 1516 } 1517 1518 names[c] = savestring (name, namlen); 1519 if (names[c] == NULL) 1520 return FALSE; 1521 ++c; 1522 } 1523 1524 names[c] = NULL; 1525 1526 vals = (bfd_signed_vma *) xmalloc (c * sizeof *vals); 1527 for (i = 0; i < c; i++) 1528 vals[i] = i; 1529 1530 type = debug_make_enum_type (dhandle, names, vals); 1531 tag = TRUE; 1532 } 1533 break; 1534 1535 case 'G': 1536 /* Struct with bit fields. */ 1537 { 1538 bfd_vma size; 1539 unsigned int alloc; 1540 debug_field *fields; 1541 unsigned int c; 1542 1543 if (! ieee_read_number (info, pp, &size)) 1544 return FALSE; 1545 1546 alloc = 10; 1547 fields = (debug_field *) xmalloc (alloc * sizeof *fields); 1548 c = 0; 1549 while (1) 1550 { 1551 const char *name; 1552 unsigned long namlen; 1553 bfd_boolean present; 1554 debug_type ftype; 1555 bfd_vma bitpos, bitsize; 1556 1557 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present)) 1558 return FALSE; 1559 if (! present) 1560 break; 1561 if (! ieee_read_type_index (info, pp, &ftype) 1562 || ! ieee_read_number (info, pp, &bitpos) 1563 || ! ieee_read_number (info, pp, &bitsize)) 1564 return FALSE; 1565 1566 if (c + 1 >= alloc) 1567 { 1568 alloc += 10; 1569 fields = ((debug_field *) 1570 xrealloc (fields, alloc * sizeof *fields)); 1571 } 1572 1573 fields[c] = debug_make_field (dhandle, savestring (name, namlen), 1574 ftype, bitpos, bitsize, 1575 DEBUG_VISIBILITY_PUBLIC); 1576 if (fields[c] == NULL) 1577 return FALSE; 1578 ++c; 1579 } 1580 1581 fields[c] = NULL; 1582 1583 type = debug_make_struct_type (dhandle, TRUE, size, fields); 1584 tag = TRUE; 1585 } 1586 break; 1587 1588 case 'N': 1589 /* Enumeration. */ 1590 { 1591 unsigned int alloc; 1592 const char **names; 1593 bfd_signed_vma *vals; 1594 unsigned int c; 1595 1596 alloc = 10; 1597 names = (const char **) xmalloc (alloc * sizeof *names); 1598 vals = (bfd_signed_vma *) xmalloc (alloc * sizeof *names); 1599 c = 0; 1600 while (1) 1601 { 1602 const char *name; 1603 unsigned long namlen; 1604 bfd_boolean present; 1605 bfd_vma val; 1606 1607 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present)) 1608 return FALSE; 1609 if (! present) 1610 break; 1611 if (! ieee_read_number (info, pp, &val)) 1612 return FALSE; 1613 1614 /* If the length of the name is zero, then the value is 1615 actually the size of the enum. We ignore this 1616 information. FIXME. */ 1617 if (namlen == 0) 1618 continue; 1619 1620 if (c + 1 >= alloc) 1621 { 1622 alloc += 10; 1623 names = ((const char **) 1624 xrealloc (names, alloc * sizeof *names)); 1625 vals = ((bfd_signed_vma *) 1626 xrealloc (vals, alloc * sizeof *vals)); 1627 } 1628 1629 names[c] = savestring (name, namlen); 1630 if (names[c] == NULL) 1631 return FALSE; 1632 vals[c] = (bfd_signed_vma) val; 1633 ++c; 1634 } 1635 1636 names[c] = NULL; 1637 1638 type = debug_make_enum_type (dhandle, names, vals); 1639 tag = TRUE; 1640 } 1641 break; 1642 1643 case 'O': /* Small pointer. We don't distinguish small and large 1644 pointers. FIXME. */ 1645 case 'P': /* Large pointer. */ 1646 { 1647 debug_type t; 1648 1649 if (! ieee_read_type_index (info, pp, &t)) 1650 return FALSE; 1651 type = debug_make_pointer_type (dhandle, t); 1652 } 1653 break; 1654 1655 case 'R': 1656 /* Range. */ 1657 { 1658 bfd_vma low, high, signedp, size; 1659 1660 if (! ieee_read_number (info, pp, &low) 1661 || ! ieee_read_number (info, pp, &high) 1662 || ! ieee_read_number (info, pp, &signedp) 1663 || ! ieee_read_number (info, pp, &size)) 1664 return FALSE; 1665 1666 type = debug_make_range_type (dhandle, 1667 debug_make_int_type (dhandle, size, 1668 ! signedp), 1669 (bfd_signed_vma) low, 1670 (bfd_signed_vma) high); 1671 } 1672 break; 1673 1674 case 'S': /* Struct. */ 1675 case 'U': /* Union. */ 1676 { 1677 bfd_vma size; 1678 unsigned int alloc; 1679 debug_field *fields; 1680 unsigned int c; 1681 1682 if (! ieee_read_number (info, pp, &size)) 1683 return FALSE; 1684 1685 alloc = 10; 1686 fields = (debug_field *) xmalloc (alloc * sizeof *fields); 1687 c = 0; 1688 while (1) 1689 { 1690 const char *name; 1691 unsigned long namlen; 1692 bfd_boolean present; 1693 bfd_vma tindx; 1694 bfd_vma offset; 1695 debug_type ftype; 1696 bfd_vma bitsize; 1697 1698 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present)) 1699 return FALSE; 1700 if (! present) 1701 break; 1702 if (! ieee_read_number (info, pp, &tindx) 1703 || ! ieee_read_number (info, pp, &offset)) 1704 return FALSE; 1705 1706 if (tindx < 256) 1707 { 1708 ftype = ieee_builtin_type (info, ty_code_start, tindx); 1709 bitsize = 0; 1710 offset *= 8; 1711 } 1712 else 1713 { 1714 struct ieee_type *t; 1715 1716 tindx -= 256; 1717 if (! ieee_alloc_type (info, tindx, TRUE)) 1718 return FALSE; 1719 t = info->types.types + tindx; 1720 ftype = t->type; 1721 bitsize = t->bitsize; 1722 if (bitsize == 0) 1723 offset *= 8; 1724 } 1725 1726 if (c + 1 >= alloc) 1727 { 1728 alloc += 10; 1729 fields = ((debug_field *) 1730 xrealloc (fields, alloc * sizeof *fields)); 1731 } 1732 1733 fields[c] = debug_make_field (dhandle, savestring (name, namlen), 1734 ftype, offset, bitsize, 1735 DEBUG_VISIBILITY_PUBLIC); 1736 if (fields[c] == NULL) 1737 return FALSE; 1738 ++c; 1739 } 1740 1741 fields[c] = NULL; 1742 1743 type = debug_make_struct_type (dhandle, tc == 'S', size, fields); 1744 tag = TRUE; 1745 } 1746 break; 1747 1748 case 'T': 1749 /* Typedef. */ 1750 if (! ieee_read_type_index (info, pp, &type)) 1751 return FALSE; 1752 typdef = TRUE; 1753 break; 1754 1755 case 'X': 1756 /* Procedure. FIXME: This is an extern declaration, which we 1757 have no way of representing. */ 1758 { 1759 bfd_vma attr; 1760 debug_type rtype; 1761 bfd_vma nargs; 1762 bfd_boolean present; 1763 struct ieee_var *pv; 1764 1765 /* FIXME: We ignore the attribute and the argument names. */ 1766 1767 if (! ieee_read_number (info, pp, &attr) 1768 || ! ieee_read_type_index (info, pp, &rtype) 1769 || ! ieee_read_number (info, pp, &nargs)) 1770 return FALSE; 1771 do 1772 { 1773 const char *name; 1774 unsigned long namlen; 1775 1776 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present)) 1777 return FALSE; 1778 } 1779 while (present); 1780 1781 pv = info->vars.vars + varindx; 1782 pv->kind = IEEE_EXTERNAL; 1783 if (pv->namlen > 0 1784 && debug_get_type_kind (dhandle, rtype) == DEBUG_KIND_POINTER) 1785 { 1786 /* Set up the return type as an indirect type pointing to 1787 the variable slot, so that we can change it to a 1788 reference later if appropriate. */ 1789 pv->pslot = (debug_type *) xmalloc (sizeof *pv->pslot); 1790 *pv->pslot = rtype; 1791 rtype = debug_make_indirect_type (dhandle, pv->pslot, 1792 (const char *) NULL); 1793 } 1794 1795 type = debug_make_function_type (dhandle, rtype, (debug_type *) NULL, 1796 FALSE); 1797 } 1798 break; 1799 1800 case 'V': 1801 case 'v': 1802 /* Void. This is not documented, but the MRI compiler emits it. */ 1803 type = debug_make_void_type (dhandle); 1804 break; 1805 1806 case 'Z': 1807 /* Array with 0 lower bound. */ 1808 { 1809 debug_type etype; 1810 bfd_vma high; 1811 1812 if (! ieee_read_type_index (info, pp, &etype) 1813 || ! ieee_read_number (info, pp, &high)) 1814 return FALSE; 1815 1816 type = debug_make_array_type (dhandle, etype, 1817 ieee_builtin_type (info, ty_code_start, 1818 ((unsigned int) 1819 builtin_int)), 1820 0, (bfd_signed_vma) high, FALSE); 1821 } 1822 break; 1823 1824 case 'c': /* Complex. */ 1825 case 'd': /* Double complex. */ 1826 { 1827 const char *name; 1828 unsigned long namlen; 1829 1830 /* FIXME: I don't know what the name means. */ 1831 1832 if (! ieee_read_id (info, pp, &name, &namlen)) 1833 return FALSE; 1834 1835 type = debug_make_complex_type (dhandle, tc == 'c' ? 4 : 8); 1836 } 1837 break; 1838 1839 case 'f': 1840 /* Pascal file name. FIXME. */ 1841 ieee_error (info, ty_code_start, _("Pascal file name not supported")); 1842 return FALSE; 1843 1844 case 'g': 1845 /* Bitfield type. */ 1846 { 1847 bfd_vma signedp, bitsize, dummy; 1848 const bfd_byte *hold; 1849 bfd_boolean present; 1850 1851 if (! ieee_read_number (info, pp, &signedp) 1852 || ! ieee_read_number (info, pp, &bitsize)) 1853 return FALSE; 1854 1855 /* I think the documentation says that there is a type index, 1856 but some actual files do not have one. */ 1857 hold = *pp; 1858 if (! ieee_read_optional_number (info, pp, &dummy, &present)) 1859 return FALSE; 1860 if (! present) 1861 { 1862 /* FIXME: This is just a guess. */ 1863 type = debug_make_int_type (dhandle, 4, 1864 signedp ? FALSE : TRUE); 1865 } 1866 else 1867 { 1868 *pp = hold; 1869 if (! ieee_read_type_index (info, pp, &type)) 1870 return FALSE; 1871 } 1872 type_bitsize = bitsize; 1873 } 1874 break; 1875 1876 case 'n': 1877 /* Qualifier. */ 1878 { 1879 bfd_vma kind; 1880 debug_type t; 1881 1882 if (! ieee_read_number (info, pp, &kind) 1883 || ! ieee_read_type_index (info, pp, &t)) 1884 return FALSE; 1885 1886 switch (kind) 1887 { 1888 default: 1889 ieee_error (info, ty_start, _("unsupported qualifier")); 1890 return FALSE; 1891 1892 case 1: 1893 type = debug_make_const_type (dhandle, t); 1894 break; 1895 1896 case 2: 1897 type = debug_make_volatile_type (dhandle, t); 1898 break; 1899 } 1900 } 1901 break; 1902 1903 case 's': 1904 /* Set. */ 1905 { 1906 bfd_vma size; 1907 debug_type etype; 1908 1909 if (! ieee_read_number (info, pp, &size) 1910 || ! ieee_read_type_index (info, pp, &etype)) 1911 return FALSE; 1912 1913 /* FIXME: We ignore the size. */ 1914 1915 type = debug_make_set_type (dhandle, etype, FALSE); 1916 } 1917 break; 1918 1919 case 'x': 1920 /* Procedure with compiler dependencies. */ 1921 { 1922 struct ieee_var *pv; 1923 bfd_vma attr, frame_type, push_mask, nargs, level, father; 1924 debug_type rtype; 1925 debug_type *arg_types; 1926 bfd_boolean varargs; 1927 bfd_boolean present; 1928 1929 /* FIXME: We ignore some of this information. */ 1930 1931 pv = info->vars.vars + varindx; 1932 1933 if (! ieee_read_number (info, pp, &attr) 1934 || ! ieee_read_number (info, pp, &frame_type) 1935 || ! ieee_read_number (info, pp, &push_mask) 1936 || ! ieee_read_type_index (info, pp, &rtype) 1937 || ! ieee_read_number (info, pp, &nargs)) 1938 return FALSE; 1939 if (nargs == (bfd_vma) -1) 1940 { 1941 arg_types = NULL; 1942 varargs = FALSE; 1943 } 1944 else 1945 { 1946 unsigned int i; 1947 1948 arg_types = ((debug_type *) 1949 xmalloc ((nargs + 1) * sizeof *arg_types)); 1950 for (i = 0; i < nargs; i++) 1951 if (! ieee_read_type_index (info, pp, arg_types + i)) 1952 return FALSE; 1953 1954 /* If the last type is pointer to void, this is really a 1955 varargs function. */ 1956 varargs = FALSE; 1957 if (nargs > 0) 1958 { 1959 debug_type last; 1960 1961 last = arg_types[nargs - 1]; 1962 if (debug_get_type_kind (dhandle, last) == DEBUG_KIND_POINTER 1963 && (debug_get_type_kind (dhandle, 1964 debug_get_target_type (dhandle, 1965 last)) 1966 == DEBUG_KIND_VOID)) 1967 { 1968 --nargs; 1969 varargs = TRUE; 1970 } 1971 } 1972 1973 /* If there are any pointer arguments, turn them into 1974 indirect types in case we later need to convert them to 1975 reference types. */ 1976 for (i = 0; i < nargs; i++) 1977 { 1978 if (debug_get_type_kind (dhandle, arg_types[i]) 1979 == DEBUG_KIND_POINTER) 1980 { 1981 if (arg_slots == NULL) 1982 { 1983 arg_slots = ((debug_type *) 1984 xmalloc (nargs * sizeof *arg_slots)); 1985 memset (arg_slots, 0, nargs * sizeof *arg_slots); 1986 } 1987 arg_slots[i] = arg_types[i]; 1988 arg_types[i] = 1989 debug_make_indirect_type (dhandle, 1990 arg_slots + i, 1991 (const char *) NULL); 1992 } 1993 } 1994 1995 arg_types[nargs] = DEBUG_TYPE_NULL; 1996 } 1997 if (! ieee_read_number (info, pp, &level) 1998 || ! ieee_read_optional_number (info, pp, &father, &present)) 1999 return FALSE; 2000 2001 /* We can't distinguish between a global function and a static 2002 function. */ 2003 pv->kind = IEEE_FUNCTION; 2004 2005 if (pv->namlen > 0 2006 && debug_get_type_kind (dhandle, rtype) == DEBUG_KIND_POINTER) 2007 { 2008 /* Set up the return type as an indirect type pointing to 2009 the variable slot, so that we can change it to a 2010 reference later if appropriate. */ 2011 pv->pslot = (debug_type *) xmalloc (sizeof *pv->pslot); 2012 *pv->pslot = rtype; 2013 rtype = debug_make_indirect_type (dhandle, pv->pslot, 2014 (const char *) NULL); 2015 } 2016 2017 type = debug_make_function_type (dhandle, rtype, arg_types, varargs); 2018 } 2019 break; 2020 } 2021 2022 /* Record the type in the table. */ 2023 2024 if (type == DEBUG_TYPE_NULL) 2025 return FALSE; 2026 2027 info->vars.vars[varindx].type = type; 2028 2029 if ((tag || typdef) 2030 && info->vars.vars[varindx].namlen > 0) 2031 { 2032 const char *name; 2033 2034 name = savestring (info->vars.vars[varindx].name, 2035 info->vars.vars[varindx].namlen); 2036 if (typdef) 2037 type = debug_name_type (dhandle, name, type); 2038 else if (tc == 'E' || tc == 'N') 2039 type = debug_tag_type (dhandle, name, type); 2040 else 2041 { 2042 struct ieee_tag *it; 2043 2044 /* We must allocate all struct tags as indirect types, so 2045 that if we later see a definition of the tag as a C++ 2046 record we can update the indirect slot and automatically 2047 change all the existing references. */ 2048 it = (struct ieee_tag *) xmalloc (sizeof *it); 2049 memset (it, 0, sizeof *it); 2050 it->next = info->tags; 2051 info->tags = it; 2052 it->name = name; 2053 it->slot = type; 2054 2055 type = debug_make_indirect_type (dhandle, &it->slot, name); 2056 type = debug_tag_type (dhandle, name, type); 2057 2058 it->type = type; 2059 } 2060 if (type == NULL) 2061 return FALSE; 2062 } 2063 2064 info->types.types[typeindx].type = type; 2065 info->types.types[typeindx].arg_slots = arg_slots; 2066 info->types.types[typeindx].bitsize = type_bitsize; 2067 2068 /* We may have already allocated type as an indirect type pointing 2069 to slot. It does no harm to replace the indirect type with the 2070 real type. Filling in slot as well handles the indirect types 2071 which are already hanging around. */ 2072 if (info->types.types[typeindx].pslot != NULL) 2073 *info->types.types[typeindx].pslot = type; 2074 2075 return TRUE; 2076} 2077 2078/* Parse an ATN record. */ 2079 2080static bfd_boolean 2081parse_ieee_atn (struct ieee_info *info, const bfd_byte **pp) 2082{ 2083 const bfd_byte *atn_start, *atn_code_start; 2084 bfd_vma varindx; 2085 struct ieee_var *pvar; 2086 debug_type type; 2087 bfd_vma atn_code; 2088 void *dhandle; 2089 bfd_vma v, v2, v3, v4, v5; 2090 const char *name; 2091 unsigned long namlen; 2092 char *namcopy; 2093 bfd_boolean present; 2094 int blocktype; 2095 2096 atn_start = *pp; 2097 2098 if (! ieee_read_number (info, pp, &varindx) 2099 || ! ieee_read_type_index (info, pp, &type)) 2100 return FALSE; 2101 2102 atn_code_start = *pp; 2103 2104 if (! ieee_read_number (info, pp, &atn_code)) 2105 return FALSE; 2106 2107 if (varindx == 0) 2108 { 2109 pvar = NULL; 2110 name = ""; 2111 namlen = 0; 2112 } 2113 else if (varindx < 32) 2114 { 2115 /* The MRI compiler reportedly sometimes emits variable lifetime 2116 information for a register. We just ignore it. */ 2117 if (atn_code == 9) 2118 return ieee_read_number (info, pp, &v); 2119 2120 ieee_error (info, atn_start, _("illegal variable index")); 2121 return FALSE; 2122 } 2123 else 2124 { 2125 varindx -= 32; 2126 if (varindx >= info->vars.alloc 2127 || info->vars.vars[varindx].name == NULL) 2128 { 2129 /* The MRI compiler or linker sometimes omits the NN record 2130 for a pmisc record. */ 2131 if (atn_code == 62) 2132 { 2133 if (varindx >= info->vars.alloc) 2134 { 2135 unsigned int alloc; 2136 2137 alloc = info->vars.alloc; 2138 if (alloc == 0) 2139 alloc = 4; 2140 while (varindx >= alloc) 2141 alloc *= 2; 2142 info->vars.vars = ((struct ieee_var *) 2143 xrealloc (info->vars.vars, 2144 (alloc 2145 * sizeof *info->vars.vars))); 2146 memset (info->vars.vars + info->vars.alloc, 0, 2147 ((alloc - info->vars.alloc) 2148 * sizeof *info->vars.vars)); 2149 info->vars.alloc = alloc; 2150 } 2151 2152 pvar = info->vars.vars + varindx; 2153 pvar->name = ""; 2154 pvar->namlen = 0; 2155 } 2156 else 2157 { 2158 ieee_error (info, atn_start, _("undefined variable in ATN")); 2159 return FALSE; 2160 } 2161 } 2162 2163 pvar = info->vars.vars + varindx; 2164 2165 pvar->type = type; 2166 2167 name = pvar->name; 2168 namlen = pvar->namlen; 2169 } 2170 2171 dhandle = info->dhandle; 2172 2173 /* If we are going to call debug_record_variable with a pointer 2174 type, change the type to an indirect type so that we can later 2175 change it to a reference type if we encounter a C++ pmisc 'R' 2176 record. */ 2177 if (pvar != NULL 2178 && type != DEBUG_TYPE_NULL 2179 && debug_get_type_kind (dhandle, type) == DEBUG_KIND_POINTER) 2180 { 2181 switch (atn_code) 2182 { 2183 case 1: 2184 case 2: 2185 case 3: 2186 case 5: 2187 case 8: 2188 case 10: 2189 pvar->pslot = (debug_type *) xmalloc (sizeof *pvar->pslot); 2190 *pvar->pslot = type; 2191 type = debug_make_indirect_type (dhandle, pvar->pslot, 2192 (const char *) NULL); 2193 pvar->type = type; 2194 break; 2195 } 2196 } 2197 2198 switch (atn_code) 2199 { 2200 default: 2201 ieee_error (info, atn_code_start, _("unknown ATN type")); 2202 return FALSE; 2203 2204 case 1: 2205 /* Automatic variable. */ 2206 if (! ieee_read_number (info, pp, &v)) 2207 return FALSE; 2208 namcopy = savestring (name, namlen); 2209 if (type == NULL) 2210 type = debug_make_void_type (dhandle); 2211 if (pvar != NULL) 2212 pvar->kind = IEEE_LOCAL; 2213 return debug_record_variable (dhandle, namcopy, type, DEBUG_LOCAL, v); 2214 2215 case 2: 2216 /* Register variable. */ 2217 if (! ieee_read_number (info, pp, &v)) 2218 return FALSE; 2219 namcopy = savestring (name, namlen); 2220 if (type == NULL) 2221 type = debug_make_void_type (dhandle); 2222 if (pvar != NULL) 2223 pvar->kind = IEEE_LOCAL; 2224 return debug_record_variable (dhandle, namcopy, type, DEBUG_REGISTER, 2225 ieee_regno_to_genreg (info->abfd, v)); 2226 2227 case 3: 2228 /* Static variable. */ 2229 if (! ieee_require_asn (info, pp, &v)) 2230 return FALSE; 2231 namcopy = savestring (name, namlen); 2232 if (type == NULL) 2233 type = debug_make_void_type (dhandle); 2234 if (info->blockstack.bsp <= info->blockstack.stack) 2235 blocktype = 0; 2236 else 2237 blocktype = info->blockstack.bsp[-1].kind; 2238 if (pvar != NULL) 2239 { 2240 if (blocktype == 4 || blocktype == 6) 2241 pvar->kind = IEEE_LOCAL; 2242 else 2243 pvar->kind = IEEE_STATIC; 2244 } 2245 return debug_record_variable (dhandle, namcopy, type, 2246 (blocktype == 4 || blocktype == 6 2247 ? DEBUG_LOCAL_STATIC 2248 : DEBUG_STATIC), 2249 v); 2250 2251 case 4: 2252 /* External function. We don't currently record these. FIXME. */ 2253 if (pvar != NULL) 2254 pvar->kind = IEEE_EXTERNAL; 2255 return TRUE; 2256 2257 case 5: 2258 /* External variable. We don't currently record these. FIXME. */ 2259 if (pvar != NULL) 2260 pvar->kind = IEEE_EXTERNAL; 2261 return TRUE; 2262 2263 case 7: 2264 if (! ieee_read_number (info, pp, &v) 2265 || ! ieee_read_number (info, pp, &v2) 2266 || ! ieee_read_optional_number (info, pp, &v3, &present)) 2267 return FALSE; 2268 if (present) 2269 { 2270 if (! ieee_read_optional_number (info, pp, &v4, &present)) 2271 return FALSE; 2272 } 2273 2274 /* We just ignore the two optional fields in v3 and v4, since 2275 they are not defined. */ 2276 2277 if (! ieee_require_asn (info, pp, &v3)) 2278 return FALSE; 2279 2280 /* We have no way to record the column number. FIXME. */ 2281 2282 return debug_record_line (dhandle, v, v3); 2283 2284 case 8: 2285 /* Global variable. */ 2286 if (! ieee_require_asn (info, pp, &v)) 2287 return FALSE; 2288 namcopy = savestring (name, namlen); 2289 if (type == NULL) 2290 type = debug_make_void_type (dhandle); 2291 if (pvar != NULL) 2292 pvar->kind = IEEE_GLOBAL; 2293 return debug_record_variable (dhandle, namcopy, type, DEBUG_GLOBAL, v); 2294 2295 case 9: 2296 /* Variable lifetime information. */ 2297 if (! ieee_read_number (info, pp, &v)) 2298 return FALSE; 2299 2300 /* We have no way to record this information. FIXME. */ 2301 return TRUE; 2302 2303 case 10: 2304 /* Locked register. The spec says that there are two required 2305 fields, but at least on occasion the MRI compiler only emits 2306 one. */ 2307 if (! ieee_read_number (info, pp, &v) 2308 || ! ieee_read_optional_number (info, pp, &v2, &present)) 2309 return FALSE; 2310 2311 /* I think this means a variable that is both in a register and 2312 a frame slot. We ignore the frame slot. FIXME. */ 2313 2314 namcopy = savestring (name, namlen); 2315 if (type == NULL) 2316 type = debug_make_void_type (dhandle); 2317 if (pvar != NULL) 2318 pvar->kind = IEEE_LOCAL; 2319 return debug_record_variable (dhandle, namcopy, type, DEBUG_REGISTER, v); 2320 2321 case 11: 2322 /* Reserved for FORTRAN common. */ 2323 ieee_error (info, atn_code_start, _("unsupported ATN11")); 2324 2325 /* Return TRUE to keep going. */ 2326 return TRUE; 2327 2328 case 12: 2329 /* Based variable. */ 2330 v3 = 0; 2331 v4 = 0x80; 2332 v5 = 0; 2333 if (! ieee_read_number (info, pp, &v) 2334 || ! ieee_read_number (info, pp, &v2) 2335 || ! ieee_read_optional_number (info, pp, &v3, &present)) 2336 return FALSE; 2337 if (present) 2338 { 2339 if (! ieee_read_optional_number (info, pp, &v4, &present)) 2340 return FALSE; 2341 if (present) 2342 { 2343 if (! ieee_read_optional_number (info, pp, &v5, &present)) 2344 return FALSE; 2345 } 2346 } 2347 2348 /* We have no way to record this information. FIXME. */ 2349 2350 ieee_error (info, atn_code_start, _("unsupported ATN12")); 2351 2352 /* Return TRUE to keep going. */ 2353 return TRUE; 2354 2355 case 16: 2356 /* Constant. The description of this that I have is ambiguous, 2357 so I'm not going to try to implement it. */ 2358 if (! ieee_read_number (info, pp, &v) 2359 || ! ieee_read_optional_number (info, pp, &v2, &present)) 2360 return FALSE; 2361 if (present) 2362 { 2363 if (! ieee_read_optional_number (info, pp, &v2, &present)) 2364 return FALSE; 2365 if (present) 2366 { 2367 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present)) 2368 return FALSE; 2369 } 2370 } 2371 2372 if ((ieee_record_enum_type) **pp == ieee_e2_first_byte_enum) 2373 { 2374 if (! ieee_require_asn (info, pp, &v3)) 2375 return FALSE; 2376 } 2377 2378 return TRUE; 2379 2380 case 19: 2381 /* Static variable from assembler. */ 2382 v2 = 0; 2383 if (! ieee_read_number (info, pp, &v) 2384 || ! ieee_read_optional_number (info, pp, &v2, &present) 2385 || ! ieee_require_asn (info, pp, &v3)) 2386 return FALSE; 2387 namcopy = savestring (name, namlen); 2388 /* We don't really handle this correctly. FIXME. */ 2389 return debug_record_variable (dhandle, namcopy, 2390 debug_make_void_type (dhandle), 2391 v2 != 0 ? DEBUG_GLOBAL : DEBUG_STATIC, 2392 v3); 2393 2394 case 62: 2395 /* Procedure miscellaneous information. */ 2396 case 63: 2397 /* Variable miscellaneous information. */ 2398 case 64: 2399 /* Module miscellaneous information. */ 2400 if (! ieee_read_number (info, pp, &v) 2401 || ! ieee_read_number (info, pp, &v2) 2402 || ! ieee_read_optional_id (info, pp, &name, &namlen, &present)) 2403 return FALSE; 2404 2405 if (atn_code == 62 && v == 80) 2406 { 2407 if (present) 2408 { 2409 ieee_error (info, atn_code_start, 2410 _("unexpected string in C++ misc")); 2411 return FALSE; 2412 } 2413 return ieee_read_cxx_misc (info, pp, v2); 2414 } 2415 2416 /* We just ignore all of this stuff. FIXME. */ 2417 2418 for (; v2 > 0; --v2) 2419 { 2420 switch ((ieee_record_enum_type) **pp) 2421 { 2422 default: 2423 ieee_error (info, *pp, _("bad misc record")); 2424 return FALSE; 2425 2426 case ieee_at_record_enum: 2427 if (! ieee_require_atn65 (info, pp, &name, &namlen)) 2428 return FALSE; 2429 break; 2430 2431 case ieee_e2_first_byte_enum: 2432 if (! ieee_require_asn (info, pp, &v3)) 2433 return FALSE; 2434 break; 2435 } 2436 } 2437 2438 return TRUE; 2439 } 2440 2441 /*NOTREACHED*/ 2442} 2443 2444/* Handle C++ debugging miscellaneous records. This is called for 2445 procedure miscellaneous records of type 80. */ 2446 2447static bfd_boolean 2448ieee_read_cxx_misc (struct ieee_info *info, const bfd_byte **pp, 2449 unsigned long count) 2450{ 2451 const bfd_byte *start; 2452 bfd_vma category; 2453 2454 start = *pp; 2455 2456 /* Get the category of C++ misc record. */ 2457 if (! ieee_require_asn (info, pp, &category)) 2458 return FALSE; 2459 --count; 2460 2461 switch (category) 2462 { 2463 default: 2464 ieee_error (info, start, _("unrecognized C++ misc record")); 2465 return FALSE; 2466 2467 case 'T': 2468 if (! ieee_read_cxx_class (info, pp, count)) 2469 return FALSE; 2470 break; 2471 2472 case 'M': 2473 { 2474 bfd_vma flags; 2475 const char *name; 2476 unsigned long namlen; 2477 2478 /* The IEEE spec indicates that the 'M' record only has a 2479 flags field. The MRI compiler also emits the name of the 2480 function. */ 2481 2482 if (! ieee_require_asn (info, pp, &flags)) 2483 return FALSE; 2484 if (*pp < info->pend 2485 && (ieee_record_enum_type) **pp == ieee_at_record_enum) 2486 { 2487 if (! ieee_require_atn65 (info, pp, &name, &namlen)) 2488 return FALSE; 2489 } 2490 2491 /* This is emitted for method functions, but I don't think we 2492 care very much. It might help if it told us useful 2493 information like the class with which this function is 2494 associated, but it doesn't, so it isn't helpful. */ 2495 } 2496 break; 2497 2498 case 'B': 2499 if (! ieee_read_cxx_defaults (info, pp, count)) 2500 return FALSE; 2501 break; 2502 2503 case 'z': 2504 { 2505 const char *name, *mangled, *cxx_class; 2506 unsigned long namlen, mangledlen, classlen; 2507 bfd_vma control; 2508 2509 /* Pointer to member. */ 2510 2511 if (! ieee_require_atn65 (info, pp, &name, &namlen) 2512 || ! ieee_require_atn65 (info, pp, &mangled, &mangledlen) 2513 || ! ieee_require_atn65 (info, pp, &cxx_class, &classlen) 2514 || ! ieee_require_asn (info, pp, &control)) 2515 return FALSE; 2516 2517 /* FIXME: We should now track down name and change its type. */ 2518 } 2519 break; 2520 2521 case 'R': 2522 if (! ieee_read_reference (info, pp)) 2523 return FALSE; 2524 break; 2525 } 2526 2527 return TRUE; 2528} 2529 2530/* Read a C++ class definition. This is a pmisc type 80 record of 2531 category 'T'. */ 2532 2533static bfd_boolean 2534ieee_read_cxx_class (struct ieee_info *info, const bfd_byte **pp, 2535 unsigned long count) 2536{ 2537 const bfd_byte *start; 2538 bfd_vma cxx_class; 2539 const char *tag; 2540 unsigned long taglen; 2541 struct ieee_tag *it; 2542 void *dhandle; 2543 debug_field *fields; 2544 unsigned int field_count, field_alloc; 2545 debug_baseclass *baseclasses; 2546 unsigned int baseclasses_count, baseclasses_alloc; 2547 const debug_field *structfields; 2548 struct ieee_method 2549 { 2550 const char *name; 2551 unsigned long namlen; 2552 debug_method_variant *variants; 2553 unsigned count; 2554 unsigned int alloc; 2555 } *methods; 2556 unsigned int methods_count, methods_alloc; 2557 debug_type vptrbase; 2558 bfd_boolean ownvptr; 2559 debug_method *dmethods; 2560 2561 start = *pp; 2562 2563 if (! ieee_require_asn (info, pp, &cxx_class)) 2564 return FALSE; 2565 --count; 2566 2567 if (! ieee_require_atn65 (info, pp, &tag, &taglen)) 2568 return FALSE; 2569 --count; 2570 2571 /* Find the C struct with this name. */ 2572 for (it = info->tags; it != NULL; it = it->next) 2573 if (it->name[0] == tag[0] 2574 && strncmp (it->name, tag, taglen) == 0 2575 && strlen (it->name) == taglen) 2576 break; 2577 if (it == NULL) 2578 { 2579 ieee_error (info, start, _("undefined C++ object")); 2580 return FALSE; 2581 } 2582 2583 dhandle = info->dhandle; 2584 2585 fields = NULL; 2586 field_count = 0; 2587 field_alloc = 0; 2588 baseclasses = NULL; 2589 baseclasses_count = 0; 2590 baseclasses_alloc = 0; 2591 methods = NULL; 2592 methods_count = 0; 2593 methods_alloc = 0; 2594 vptrbase = DEBUG_TYPE_NULL; 2595 ownvptr = FALSE; 2596 2597 structfields = debug_get_fields (dhandle, it->type); 2598 2599 while (count > 0) 2600 { 2601 bfd_vma id; 2602 const bfd_byte *spec_start; 2603 2604 spec_start = *pp; 2605 2606 if (! ieee_require_asn (info, pp, &id)) 2607 return FALSE; 2608 --count; 2609 2610 switch (id) 2611 { 2612 default: 2613 ieee_error (info, spec_start, _("unrecognized C++ object spec")); 2614 return FALSE; 2615 2616 case 'b': 2617 { 2618 bfd_vma flags, cinline; 2619 const char *base, *fieldname; 2620 unsigned long baselen, fieldlen; 2621 char *basecopy; 2622 debug_type basetype; 2623 bfd_vma bitpos; 2624 bfd_boolean virtualp; 2625 enum debug_visibility visibility; 2626 debug_baseclass baseclass; 2627 2628 /* This represents a base or friend class. */ 2629 2630 if (! ieee_require_asn (info, pp, &flags) 2631 || ! ieee_require_atn65 (info, pp, &base, &baselen) 2632 || ! ieee_require_asn (info, pp, &cinline) 2633 || ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen)) 2634 return FALSE; 2635 count -= 4; 2636 2637 /* We have no way of recording friend information, so we 2638 just ignore it. */ 2639 if ((flags & BASEFLAGS_FRIEND) != 0) 2640 break; 2641 2642 /* I assume that either all of the members of the 2643 baseclass are included in the object, starting at the 2644 beginning of the object, or that none of them are 2645 included. */ 2646 2647 if ((fieldlen == 0) == (cinline == 0)) 2648 { 2649 ieee_error (info, start, _("unsupported C++ object type")); 2650 return FALSE; 2651 } 2652 2653 basecopy = savestring (base, baselen); 2654 basetype = debug_find_tagged_type (dhandle, basecopy, 2655 DEBUG_KIND_ILLEGAL); 2656 free (basecopy); 2657 if (basetype == DEBUG_TYPE_NULL) 2658 { 2659 ieee_error (info, start, _("C++ base class not defined")); 2660 return FALSE; 2661 } 2662 2663 if (fieldlen == 0) 2664 bitpos = 0; 2665 else 2666 { 2667 const debug_field *pf; 2668 2669 if (structfields == NULL) 2670 { 2671 ieee_error (info, start, _("C++ object has no fields")); 2672 return FALSE; 2673 } 2674 2675 for (pf = structfields; *pf != DEBUG_FIELD_NULL; pf++) 2676 { 2677 const char *fname; 2678 2679 fname = debug_get_field_name (dhandle, *pf); 2680 if (fname == NULL) 2681 return FALSE; 2682 if (fname[0] == fieldname[0] 2683 && strncmp (fname, fieldname, fieldlen) == 0 2684 && strlen (fname) == fieldlen) 2685 break; 2686 } 2687 if (*pf == DEBUG_FIELD_NULL) 2688 { 2689 ieee_error (info, start, 2690 _("C++ base class not found in container")); 2691 return FALSE; 2692 } 2693 2694 bitpos = debug_get_field_bitpos (dhandle, *pf); 2695 } 2696 2697 if ((flags & BASEFLAGS_VIRTUAL) != 0) 2698 virtualp = TRUE; 2699 else 2700 virtualp = FALSE; 2701 if ((flags & BASEFLAGS_PRIVATE) != 0) 2702 visibility = DEBUG_VISIBILITY_PRIVATE; 2703 else 2704 visibility = DEBUG_VISIBILITY_PUBLIC; 2705 2706 baseclass = debug_make_baseclass (dhandle, basetype, bitpos, 2707 virtualp, visibility); 2708 if (baseclass == DEBUG_BASECLASS_NULL) 2709 return FALSE; 2710 2711 if (baseclasses_count + 1 >= baseclasses_alloc) 2712 { 2713 baseclasses_alloc += 10; 2714 baseclasses = ((debug_baseclass *) 2715 xrealloc (baseclasses, 2716 (baseclasses_alloc 2717 * sizeof *baseclasses))); 2718 } 2719 2720 baseclasses[baseclasses_count] = baseclass; 2721 ++baseclasses_count; 2722 baseclasses[baseclasses_count] = DEBUG_BASECLASS_NULL; 2723 } 2724 break; 2725 2726 case 'd': 2727 { 2728 bfd_vma flags; 2729 const char *fieldname, *mangledname; 2730 unsigned long fieldlen, mangledlen; 2731 char *fieldcopy; 2732 bfd_boolean staticp; 2733 debug_type ftype; 2734 const debug_field *pf = NULL; 2735 enum debug_visibility visibility; 2736 debug_field field; 2737 2738 /* This represents a data member. */ 2739 2740 if (! ieee_require_asn (info, pp, &flags) 2741 || ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen) 2742 || ! ieee_require_atn65 (info, pp, &mangledname, &mangledlen)) 2743 return FALSE; 2744 count -= 3; 2745 2746 fieldcopy = savestring (fieldname, fieldlen); 2747 2748 staticp = (flags & CXXFLAGS_STATIC) != 0 ? TRUE : FALSE; 2749 2750 if (staticp) 2751 { 2752 struct ieee_var *pv, *pvend; 2753 2754 /* See if we can find a definition for this variable. */ 2755 pv = info->vars.vars; 2756 pvend = pv + info->vars.alloc; 2757 for (; pv < pvend; pv++) 2758 if (pv->namlen == mangledlen 2759 && strncmp (pv->name, mangledname, mangledlen) == 0) 2760 break; 2761 if (pv < pvend) 2762 ftype = pv->type; 2763 else 2764 { 2765 /* This can happen if the variable is never used. */ 2766 ftype = ieee_builtin_type (info, start, 2767 (unsigned int) builtin_void); 2768 } 2769 } 2770 else 2771 { 2772 unsigned int findx; 2773 2774 if (structfields == NULL) 2775 { 2776 ieee_error (info, start, _("C++ object has no fields")); 2777 return FALSE; 2778 } 2779 2780 for (pf = structfields, findx = 0; 2781 *pf != DEBUG_FIELD_NULL; 2782 pf++, findx++) 2783 { 2784 const char *fname; 2785 2786 fname = debug_get_field_name (dhandle, *pf); 2787 if (fname == NULL) 2788 return FALSE; 2789 if (fname[0] == mangledname[0] 2790 && strncmp (fname, mangledname, mangledlen) == 0 2791 && strlen (fname) == mangledlen) 2792 break; 2793 } 2794 if (*pf == DEBUG_FIELD_NULL) 2795 { 2796 ieee_error (info, start, 2797 _("C++ data member not found in container")); 2798 return FALSE; 2799 } 2800 2801 ftype = debug_get_field_type (dhandle, *pf); 2802 2803 if (debug_get_type_kind (dhandle, ftype) == DEBUG_KIND_POINTER) 2804 { 2805 /* We might need to convert this field into a 2806 reference type later on, so make it an indirect 2807 type. */ 2808 if (it->fslots == NULL) 2809 { 2810 unsigned int fcnt; 2811 const debug_field *pfcnt; 2812 2813 fcnt = 0; 2814 for (pfcnt = structfields; 2815 *pfcnt != DEBUG_FIELD_NULL; 2816 pfcnt++) 2817 ++fcnt; 2818 it->fslots = ((debug_type *) 2819 xmalloc (fcnt * sizeof *it->fslots)); 2820 memset (it->fslots, 0, 2821 fcnt * sizeof *it->fslots); 2822 } 2823 2824 if (ftype == DEBUG_TYPE_NULL) 2825 return FALSE; 2826 it->fslots[findx] = ftype; 2827 ftype = debug_make_indirect_type (dhandle, 2828 it->fslots + findx, 2829 (const char *) NULL); 2830 } 2831 } 2832 if (ftype == DEBUG_TYPE_NULL) 2833 return FALSE; 2834 2835 switch (flags & CXXFLAGS_VISIBILITY) 2836 { 2837 default: 2838 ieee_error (info, start, _("unknown C++ visibility")); 2839 return FALSE; 2840 2841 case CXXFLAGS_VISIBILITY_PUBLIC: 2842 visibility = DEBUG_VISIBILITY_PUBLIC; 2843 break; 2844 2845 case CXXFLAGS_VISIBILITY_PRIVATE: 2846 visibility = DEBUG_VISIBILITY_PRIVATE; 2847 break; 2848 2849 case CXXFLAGS_VISIBILITY_PROTECTED: 2850 visibility = DEBUG_VISIBILITY_PROTECTED; 2851 break; 2852 } 2853 2854 if (staticp) 2855 { 2856 char *mangledcopy; 2857 2858 mangledcopy = savestring (mangledname, mangledlen); 2859 2860 field = debug_make_static_member (dhandle, fieldcopy, 2861 ftype, mangledcopy, 2862 visibility); 2863 } 2864 else 2865 { 2866 bfd_vma bitpos, bitsize; 2867 2868 bitpos = debug_get_field_bitpos (dhandle, *pf); 2869 bitsize = debug_get_field_bitsize (dhandle, *pf); 2870 if (bitpos == (bfd_vma) -1 || bitsize == (bfd_vma) -1) 2871 { 2872 ieee_error (info, start, _("bad C++ field bit pos or size")); 2873 return FALSE; 2874 } 2875 field = debug_make_field (dhandle, fieldcopy, ftype, bitpos, 2876 bitsize, visibility); 2877 } 2878 2879 if (field == DEBUG_FIELD_NULL) 2880 return FALSE; 2881 2882 if (field_count + 1 >= field_alloc) 2883 { 2884 field_alloc += 10; 2885 fields = ((debug_field *) 2886 xrealloc (fields, field_alloc * sizeof *fields)); 2887 } 2888 2889 fields[field_count] = field; 2890 ++field_count; 2891 fields[field_count] = DEBUG_FIELD_NULL; 2892 } 2893 break; 2894 2895 case 'm': 2896 case 'v': 2897 { 2898 bfd_vma flags, voffset, control; 2899 const char *name, *mangled; 2900 unsigned long namlen, mangledlen; 2901 struct ieee_var *pv, *pvend; 2902 debug_type type; 2903 enum debug_visibility visibility; 2904 bfd_boolean constp, volatilep; 2905 char *mangledcopy; 2906 debug_method_variant mv; 2907 struct ieee_method *meth; 2908 unsigned int im; 2909 2910 if (! ieee_require_asn (info, pp, &flags) 2911 || ! ieee_require_atn65 (info, pp, &name, &namlen) 2912 || ! ieee_require_atn65 (info, pp, &mangled, &mangledlen)) 2913 return FALSE; 2914 count -= 3; 2915 if (id != 'v') 2916 voffset = 0; 2917 else 2918 { 2919 if (! ieee_require_asn (info, pp, &voffset)) 2920 return FALSE; 2921 --count; 2922 } 2923 if (! ieee_require_asn (info, pp, &control)) 2924 return FALSE; 2925 --count; 2926 2927 /* We just ignore the control information. */ 2928 2929 /* We have no way to represent friend information, so we 2930 just ignore it. */ 2931 if ((flags & CXXFLAGS_FRIEND) != 0) 2932 break; 2933 2934 /* We should already have seen a type for the function. */ 2935 pv = info->vars.vars; 2936 pvend = pv + info->vars.alloc; 2937 for (; pv < pvend; pv++) 2938 if (pv->namlen == mangledlen 2939 && strncmp (pv->name, mangled, mangledlen) == 0) 2940 break; 2941 2942 if (pv >= pvend) 2943 { 2944 /* We won't have type information for this function if 2945 it is not included in this file. We don't try to 2946 handle this case. FIXME. */ 2947 type = (debug_make_function_type 2948 (dhandle, 2949 ieee_builtin_type (info, start, 2950 (unsigned int) builtin_void), 2951 (debug_type *) NULL, 2952 FALSE)); 2953 } 2954 else 2955 { 2956 debug_type return_type; 2957 const debug_type *arg_types; 2958 bfd_boolean varargs; 2959 2960 if (debug_get_type_kind (dhandle, pv->type) 2961 != DEBUG_KIND_FUNCTION) 2962 { 2963 ieee_error (info, start, 2964 _("bad type for C++ method function")); 2965 return FALSE; 2966 } 2967 2968 return_type = debug_get_return_type (dhandle, pv->type); 2969 arg_types = debug_get_parameter_types (dhandle, pv->type, 2970 &varargs); 2971 if (return_type == DEBUG_TYPE_NULL || arg_types == NULL) 2972 { 2973 ieee_error (info, start, 2974 _("no type information for C++ method function")); 2975 return FALSE; 2976 } 2977 2978 type = debug_make_method_type (dhandle, return_type, it->type, 2979 (debug_type *) arg_types, 2980 varargs); 2981 } 2982 if (type == DEBUG_TYPE_NULL) 2983 return FALSE; 2984 2985 switch (flags & CXXFLAGS_VISIBILITY) 2986 { 2987 default: 2988 ieee_error (info, start, _("unknown C++ visibility")); 2989 return FALSE; 2990 2991 case CXXFLAGS_VISIBILITY_PUBLIC: 2992 visibility = DEBUG_VISIBILITY_PUBLIC; 2993 break; 2994 2995 case CXXFLAGS_VISIBILITY_PRIVATE: 2996 visibility = DEBUG_VISIBILITY_PRIVATE; 2997 break; 2998 2999 case CXXFLAGS_VISIBILITY_PROTECTED: 3000 visibility = DEBUG_VISIBILITY_PROTECTED; 3001 break; 3002 } 3003 3004 constp = (flags & CXXFLAGS_CONST) != 0 ? TRUE : FALSE; 3005 volatilep = (flags & CXXFLAGS_VOLATILE) != 0 ? TRUE : FALSE; 3006 3007 mangledcopy = savestring (mangled, mangledlen); 3008 3009 if ((flags & CXXFLAGS_STATIC) != 0) 3010 { 3011 if (id == 'v') 3012 { 3013 ieee_error (info, start, _("C++ static virtual method")); 3014 return FALSE; 3015 } 3016 mv = debug_make_static_method_variant (dhandle, mangledcopy, 3017 type, visibility, 3018 constp, volatilep); 3019 } 3020 else 3021 { 3022 debug_type vcontext; 3023 3024 if (id != 'v') 3025 vcontext = DEBUG_TYPE_NULL; 3026 else 3027 { 3028 /* FIXME: How can we calculate this correctly? */ 3029 vcontext = it->type; 3030 } 3031 mv = debug_make_method_variant (dhandle, mangledcopy, type, 3032 visibility, constp, 3033 volatilep, voffset, 3034 vcontext); 3035 } 3036 if (mv == DEBUG_METHOD_VARIANT_NULL) 3037 return FALSE; 3038 3039 for (meth = methods, im = 0; im < methods_count; meth++, im++) 3040 if (meth->namlen == namlen 3041 && strncmp (meth->name, name, namlen) == 0) 3042 break; 3043 if (im >= methods_count) 3044 { 3045 if (methods_count >= methods_alloc) 3046 { 3047 methods_alloc += 10; 3048 methods = ((struct ieee_method *) 3049 xrealloc (methods, 3050 methods_alloc * sizeof *methods)); 3051 } 3052 methods[methods_count].name = name; 3053 methods[methods_count].namlen = namlen; 3054 methods[methods_count].variants = NULL; 3055 methods[methods_count].count = 0; 3056 methods[methods_count].alloc = 0; 3057 meth = methods + methods_count; 3058 ++methods_count; 3059 } 3060 3061 if (meth->count + 1 >= meth->alloc) 3062 { 3063 meth->alloc += 10; 3064 meth->variants = ((debug_method_variant *) 3065 xrealloc (meth->variants, 3066 (meth->alloc 3067 * sizeof *meth->variants))); 3068 } 3069 3070 meth->variants[meth->count] = mv; 3071 ++meth->count; 3072 meth->variants[meth->count] = DEBUG_METHOD_VARIANT_NULL; 3073 } 3074 break; 3075 3076 case 'o': 3077 { 3078 bfd_vma spec; 3079 3080 /* We have no way to store this information, so we just 3081 ignore it. */ 3082 if (! ieee_require_asn (info, pp, &spec)) 3083 return FALSE; 3084 --count; 3085 if ((spec & 4) != 0) 3086 { 3087 const char *filename; 3088 unsigned long filenamlen; 3089 bfd_vma lineno; 3090 3091 if (! ieee_require_atn65 (info, pp, &filename, &filenamlen) 3092 || ! ieee_require_asn (info, pp, &lineno)) 3093 return FALSE; 3094 count -= 2; 3095 } 3096 else if ((spec & 8) != 0) 3097 { 3098 const char *mangled; 3099 unsigned long mangledlen; 3100 3101 if (! ieee_require_atn65 (info, pp, &mangled, &mangledlen)) 3102 return FALSE; 3103 --count; 3104 } 3105 else 3106 { 3107 ieee_error (info, start, 3108 _("unrecognized C++ object overhead spec")); 3109 return FALSE; 3110 } 3111 } 3112 break; 3113 3114 case 'z': 3115 { 3116 const char *vname, *base; 3117 unsigned long vnamelen, baselen; 3118 bfd_vma vsize, control; 3119 3120 /* A virtual table pointer. */ 3121 3122 if (! ieee_require_atn65 (info, pp, &vname, &vnamelen) 3123 || ! ieee_require_asn (info, pp, &vsize) 3124 || ! ieee_require_atn65 (info, pp, &base, &baselen) 3125 || ! ieee_require_asn (info, pp, &control)) 3126 return FALSE; 3127 count -= 4; 3128 3129 /* We just ignore the control number. We don't care what 3130 the virtual table name is. We have no way to store the 3131 virtual table size, and I don't think we care anyhow. */ 3132 3133 /* FIXME: We can't handle multiple virtual table pointers. */ 3134 3135 if (baselen == 0) 3136 ownvptr = TRUE; 3137 else 3138 { 3139 char *basecopy; 3140 3141 basecopy = savestring (base, baselen); 3142 vptrbase = debug_find_tagged_type (dhandle, basecopy, 3143 DEBUG_KIND_ILLEGAL); 3144 free (basecopy); 3145 if (vptrbase == DEBUG_TYPE_NULL) 3146 { 3147 ieee_error (info, start, _("undefined C++ vtable")); 3148 return FALSE; 3149 } 3150 } 3151 } 3152 break; 3153 } 3154 } 3155 3156 /* Now that we have seen all the method variants, we can call 3157 debug_make_method for each one. */ 3158 3159 if (methods_count == 0) 3160 dmethods = NULL; 3161 else 3162 { 3163 unsigned int i; 3164 3165 dmethods = ((debug_method *) 3166 xmalloc ((methods_count + 1) * sizeof *dmethods)); 3167 for (i = 0; i < methods_count; i++) 3168 { 3169 char *namcopy; 3170 3171 namcopy = savestring (methods[i].name, methods[i].namlen); 3172 dmethods[i] = debug_make_method (dhandle, namcopy, 3173 methods[i].variants); 3174 if (dmethods[i] == DEBUG_METHOD_NULL) 3175 return FALSE; 3176 } 3177 dmethods[i] = DEBUG_METHOD_NULL; 3178 free (methods); 3179 } 3180 3181 /* The struct type was created as an indirect type pointing at 3182 it->slot. We update it->slot to automatically update all 3183 references to this struct. */ 3184 it->slot = debug_make_object_type (dhandle, 3185 cxx_class != 'u', 3186 debug_get_type_size (dhandle, 3187 it->slot), 3188 fields, baseclasses, dmethods, 3189 vptrbase, ownvptr); 3190 if (it->slot == DEBUG_TYPE_NULL) 3191 return FALSE; 3192 3193 return TRUE; 3194} 3195 3196/* Read C++ default argument value and reference type information. */ 3197 3198static bfd_boolean 3199ieee_read_cxx_defaults (struct ieee_info *info, const bfd_byte **pp, 3200 unsigned long count) 3201{ 3202 const bfd_byte *start; 3203 const char *fnname; 3204 unsigned long fnlen; 3205 bfd_vma defcount; 3206 3207 start = *pp; 3208 3209 /* Giving the function name before the argument count is an addendum 3210 to the spec. The function name is demangled, though, so this 3211 record must always refer to the current function. */ 3212 3213 if (info->blockstack.bsp <= info->blockstack.stack 3214 || info->blockstack.bsp[-1].fnindx == (unsigned int) -1) 3215 { 3216 ieee_error (info, start, _("C++ default values not in a function")); 3217 return FALSE; 3218 } 3219 3220 if (! ieee_require_atn65 (info, pp, &fnname, &fnlen) 3221 || ! ieee_require_asn (info, pp, &defcount)) 3222 return FALSE; 3223 count -= 2; 3224 3225 while (defcount-- > 0) 3226 { 3227 bfd_vma type, val; 3228 const char *strval; 3229 unsigned long strvallen; 3230 3231 if (! ieee_require_asn (info, pp, &type)) 3232 return FALSE; 3233 --count; 3234 3235 switch (type) 3236 { 3237 case 0: 3238 case 4: 3239 break; 3240 3241 case 1: 3242 case 2: 3243 if (! ieee_require_asn (info, pp, &val)) 3244 return FALSE; 3245 --count; 3246 break; 3247 3248 case 3: 3249 case 7: 3250 if (! ieee_require_atn65 (info, pp, &strval, &strvallen)) 3251 return FALSE; 3252 --count; 3253 break; 3254 3255 default: 3256 ieee_error (info, start, _("unrecognized C++ default type")); 3257 return FALSE; 3258 } 3259 3260 /* We have no way to record the default argument values, so we 3261 just ignore them. FIXME. */ 3262 } 3263 3264 /* Any remaining arguments are indices of parameters that are really 3265 reference type. */ 3266 if (count > 0) 3267 { 3268 void *dhandle; 3269 debug_type *arg_slots; 3270 3271 dhandle = info->dhandle; 3272 arg_slots = info->types.types[info->blockstack.bsp[-1].fnindx].arg_slots; 3273 while (count-- > 0) 3274 { 3275 bfd_vma indx; 3276 debug_type target; 3277 3278 if (! ieee_require_asn (info, pp, &indx)) 3279 return FALSE; 3280 /* The index is 1 based. */ 3281 --indx; 3282 if (arg_slots == NULL 3283 || arg_slots[indx] == DEBUG_TYPE_NULL 3284 || (debug_get_type_kind (dhandle, arg_slots[indx]) 3285 != DEBUG_KIND_POINTER)) 3286 { 3287 ieee_error (info, start, _("reference parameter is not a pointer")); 3288 return FALSE; 3289 } 3290 3291 target = debug_get_target_type (dhandle, arg_slots[indx]); 3292 arg_slots[indx] = debug_make_reference_type (dhandle, target); 3293 if (arg_slots[indx] == DEBUG_TYPE_NULL) 3294 return FALSE; 3295 } 3296 } 3297 3298 return TRUE; 3299} 3300 3301/* Read a C++ reference definition. */ 3302 3303static bfd_boolean 3304ieee_read_reference (struct ieee_info *info, const bfd_byte **pp) 3305{ 3306 const bfd_byte *start; 3307 bfd_vma flags; 3308 const char *cxx_class, *name; 3309 unsigned long classlen, namlen; 3310 debug_type *pslot; 3311 debug_type target; 3312 3313 start = *pp; 3314 3315 if (! ieee_require_asn (info, pp, &flags)) 3316 return FALSE; 3317 3318 /* Giving the class name before the member name is in an addendum to 3319 the spec. */ 3320 if (flags == 3) 3321 { 3322 if (! ieee_require_atn65 (info, pp, &cxx_class, &classlen)) 3323 return FALSE; 3324 } 3325 3326 if (! ieee_require_atn65 (info, pp, &name, &namlen)) 3327 return FALSE; 3328 3329 pslot = NULL; 3330 if (flags != 3) 3331 { 3332 int pass; 3333 3334 /* We search from the last variable indices to the first in 3335 hopes of finding local variables correctly. We search the 3336 local variables on the first pass, and the global variables 3337 on the second. FIXME: This probably won't work in all cases. 3338 On the other hand, I don't know what will. */ 3339 for (pass = 0; pass < 2; pass++) 3340 { 3341 struct ieee_vars *vars; 3342 int i; 3343 struct ieee_var *pv = NULL; 3344 3345 if (pass == 0) 3346 vars = &info->vars; 3347 else 3348 { 3349 vars = info->global_vars; 3350 if (vars == NULL) 3351 break; 3352 } 3353 3354 for (i = (int) vars->alloc - 1; i >= 0; i--) 3355 { 3356 bfd_boolean found; 3357 3358 pv = vars->vars + i; 3359 3360 if (pv->pslot == NULL 3361 || pv->namlen != namlen 3362 || strncmp (pv->name, name, namlen) != 0) 3363 continue; 3364 3365 found = FALSE; 3366 switch (flags) 3367 { 3368 default: 3369 ieee_error (info, start, 3370 _("unrecognized C++ reference type")); 3371 return FALSE; 3372 3373 case 0: 3374 /* Global variable or function. */ 3375 if (pv->kind == IEEE_GLOBAL 3376 || pv->kind == IEEE_EXTERNAL 3377 || pv->kind == IEEE_FUNCTION) 3378 found = TRUE; 3379 break; 3380 3381 case 1: 3382 /* Global static variable or function. */ 3383 if (pv->kind == IEEE_STATIC 3384 || pv->kind == IEEE_FUNCTION) 3385 found = TRUE; 3386 break; 3387 3388 case 2: 3389 /* Local variable. */ 3390 if (pv->kind == IEEE_LOCAL) 3391 found = TRUE; 3392 break; 3393 } 3394 3395 if (found) 3396 break; 3397 } 3398 3399 if (i >= 0) 3400 { 3401 pslot = pv->pslot; 3402 break; 3403 } 3404 } 3405 } 3406 else 3407 { 3408 struct ieee_tag *it; 3409 3410 for (it = info->tags; it != NULL; it = it->next) 3411 { 3412 if (it->name[0] == cxx_class[0] 3413 && strncmp (it->name, cxx_class, classlen) == 0 3414 && strlen (it->name) == classlen) 3415 { 3416 if (it->fslots != NULL) 3417 { 3418 const debug_field *pf; 3419 unsigned int findx; 3420 3421 pf = debug_get_fields (info->dhandle, it->type); 3422 if (pf == NULL) 3423 { 3424 ieee_error (info, start, 3425 "C++ reference in class with no fields"); 3426 return FALSE; 3427 } 3428 3429 for (findx = 0; *pf != DEBUG_FIELD_NULL; pf++, findx++) 3430 { 3431 const char *fname; 3432 3433 fname = debug_get_field_name (info->dhandle, *pf); 3434 if (fname == NULL) 3435 return FALSE; 3436 if (strncmp (fname, name, namlen) == 0 3437 && strlen (fname) == namlen) 3438 { 3439 pslot = it->fslots + findx; 3440 break; 3441 } 3442 } 3443 } 3444 3445 break; 3446 } 3447 } 3448 } 3449 3450 if (pslot == NULL) 3451 { 3452 ieee_error (info, start, _("C++ reference not found")); 3453 return FALSE; 3454 } 3455 3456 /* We allocated the type of the object as an indirect type pointing 3457 to *pslot, which we can now update to be a reference type. */ 3458 if (debug_get_type_kind (info->dhandle, *pslot) != DEBUG_KIND_POINTER) 3459 { 3460 ieee_error (info, start, _("C++ reference is not pointer")); 3461 return FALSE; 3462 } 3463 3464 target = debug_get_target_type (info->dhandle, *pslot); 3465 *pslot = debug_make_reference_type (info->dhandle, target); 3466 if (*pslot == DEBUG_TYPE_NULL) 3467 return FALSE; 3468 3469 return TRUE; 3470} 3471 3472/* Require an ASN record. */ 3473 3474static bfd_boolean 3475ieee_require_asn (struct ieee_info *info, const bfd_byte **pp, bfd_vma *pv) 3476{ 3477 const bfd_byte *start; 3478 ieee_record_enum_type c; 3479 bfd_vma varindx; 3480 3481 start = *pp; 3482 3483 c = (ieee_record_enum_type) **pp; 3484 if (c != ieee_e2_first_byte_enum) 3485 { 3486 ieee_error (info, start, _("missing required ASN")); 3487 return FALSE; 3488 } 3489 ++*pp; 3490 3491 c = (ieee_record_enum_type) (((unsigned int) c << 8) | **pp); 3492 if (c != ieee_asn_record_enum) 3493 { 3494 ieee_error (info, start, _("missing required ASN")); 3495 return FALSE; 3496 } 3497 ++*pp; 3498 3499 /* Just ignore the variable index. */ 3500 if (! ieee_read_number (info, pp, &varindx)) 3501 return FALSE; 3502 3503 return ieee_read_expression (info, pp, pv); 3504} 3505 3506/* Require an ATN65 record. */ 3507 3508static bfd_boolean 3509ieee_require_atn65 (struct ieee_info *info, const bfd_byte **pp, 3510 const char **pname, unsigned long *pnamlen) 3511{ 3512 const bfd_byte *start; 3513 ieee_record_enum_type c; 3514 bfd_vma name_indx, type_indx, atn_code; 3515 3516 start = *pp; 3517 3518 c = (ieee_record_enum_type) **pp; 3519 if (c != ieee_at_record_enum) 3520 { 3521 ieee_error (info, start, _("missing required ATN65")); 3522 return FALSE; 3523 } 3524 ++*pp; 3525 3526 c = (ieee_record_enum_type) (((unsigned int) c << 8) | **pp); 3527 if (c != ieee_atn_record_enum) 3528 { 3529 ieee_error (info, start, _("missing required ATN65")); 3530 return FALSE; 3531 } 3532 ++*pp; 3533 3534 if (! ieee_read_number (info, pp, &name_indx) 3535 || ! ieee_read_number (info, pp, &type_indx) 3536 || ! ieee_read_number (info, pp, &atn_code)) 3537 return FALSE; 3538 3539 /* Just ignore name_indx. */ 3540 3541 if (type_indx != 0 || atn_code != 65) 3542 { 3543 ieee_error (info, start, _("bad ATN65 record")); 3544 return FALSE; 3545 } 3546 3547 return ieee_read_id (info, pp, pname, pnamlen); 3548} 3549 3550/* Convert a register number in IEEE debugging information into a 3551 generic register number. */ 3552 3553static int 3554ieee_regno_to_genreg (bfd *abfd, int r) 3555{ 3556 switch (bfd_get_arch (abfd)) 3557 { 3558 case bfd_arch_m68k: 3559 /* For some reasons stabs adds 2 to the floating point register 3560 numbers. */ 3561 if (r >= 16) 3562 r += 2; 3563 break; 3564 3565 case bfd_arch_i960: 3566 /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and 3567 32 to 35 for fp0 to fp3. */ 3568 --r; 3569 break; 3570 3571 default: 3572 break; 3573 } 3574 3575 return r; 3576} 3577 3578/* Convert a generic register number to an IEEE specific one. */ 3579 3580static int 3581ieee_genreg_to_regno (bfd *abfd, int r) 3582{ 3583 switch (bfd_get_arch (abfd)) 3584 { 3585 case bfd_arch_m68k: 3586 /* For some reason stabs add 2 to the floating point register 3587 numbers. */ 3588 if (r >= 18) 3589 r -= 2; 3590 break; 3591 3592 case bfd_arch_i960: 3593 /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and 3594 32 to 35 for fp0 to fp3. */ 3595 ++r; 3596 break; 3597 3598 default: 3599 break; 3600 } 3601 3602 return r; 3603} 3604 3605/* These routines build IEEE debugging information out of the generic 3606 debugging information. */ 3607 3608/* We build the IEEE debugging information byte by byte. Rather than 3609 waste time copying data around, we use a linked list of buffers to 3610 hold the data. */ 3611 3612#define IEEE_BUFSIZE (490) 3613 3614struct ieee_buf 3615{ 3616 /* Next buffer. */ 3617 struct ieee_buf *next; 3618 /* Number of data bytes in this buffer. */ 3619 unsigned int c; 3620 /* Bytes. */ 3621 bfd_byte buf[IEEE_BUFSIZE]; 3622}; 3623 3624/* A list of buffers. */ 3625 3626struct ieee_buflist 3627{ 3628 /* Head of list. */ 3629 struct ieee_buf *head; 3630 /* Tail--last buffer on list. */ 3631 struct ieee_buf *tail; 3632}; 3633 3634/* In order to generate the BB11 blocks required by the HP emulator, 3635 we keep track of ranges of addresses which correspond to a given 3636 compilation unit. */ 3637 3638struct ieee_range 3639{ 3640 /* Next range. */ 3641 struct ieee_range *next; 3642 /* Low address. */ 3643 bfd_vma low; 3644 /* High address. */ 3645 bfd_vma high; 3646}; 3647 3648/* This structure holds information for a class on the type stack. */ 3649 3650struct ieee_type_class 3651{ 3652 /* The name index in the debugging information. */ 3653 unsigned int indx; 3654 /* The pmisc records for the class. */ 3655 struct ieee_buflist pmiscbuf; 3656 /* The number of pmisc records. */ 3657 unsigned int pmisccount; 3658 /* The name of the class holding the virtual table, if not this 3659 class. */ 3660 const char *vclass; 3661 /* Whether this class holds its own virtual table. */ 3662 bfd_boolean ownvptr; 3663 /* The largest virtual table offset seen so far. */ 3664 bfd_vma voffset; 3665 /* The current method. */ 3666 const char *method; 3667 /* Additional pmisc records used to record fields of reference type. */ 3668 struct ieee_buflist refs; 3669}; 3670 3671/* This is how we store types for the writing routines. Most types 3672 are simply represented by a type index. */ 3673 3674struct ieee_write_type 3675{ 3676 /* Type index. */ 3677 unsigned int indx; 3678 /* The size of the type, if known. */ 3679 unsigned int size; 3680 /* The name of the type, if any. */ 3681 const char *name; 3682 /* If this is a function or method type, we build the type here, and 3683 only add it to the output buffers if we need it. */ 3684 struct ieee_buflist fndef; 3685 /* If this is a struct, this is where the struct definition is 3686 built. */ 3687 struct ieee_buflist strdef; 3688 /* If this is a class, this is where the class information is built. */ 3689 struct ieee_type_class *classdef; 3690 /* Whether the type is unsigned. */ 3691 unsigned int unsignedp : 1; 3692 /* Whether this is a reference type. */ 3693 unsigned int referencep : 1; 3694 /* Whether this is in the local type block. */ 3695 unsigned int localp : 1; 3696 /* Whether this is a duplicate struct definition which we are 3697 ignoring. */ 3698 unsigned int ignorep : 1; 3699}; 3700 3701/* This is the type stack used by the debug writing routines. FIXME: 3702 We could generate more efficient output if we remembered when we 3703 have output a particular type before. */ 3704 3705struct ieee_type_stack 3706{ 3707 /* Next entry on stack. */ 3708 struct ieee_type_stack *next; 3709 /* Type information. */ 3710 struct ieee_write_type type; 3711}; 3712 3713/* This is a list of associations between a name and some types. 3714 These are used for typedefs and tags. */ 3715 3716struct ieee_name_type 3717{ 3718 /* Next type for this name. */ 3719 struct ieee_name_type *next; 3720 /* ID number. For a typedef, this is the index of the type to which 3721 this name is typedefed. */ 3722 unsigned int id; 3723 /* Type. */ 3724 struct ieee_write_type type; 3725 /* If this is a tag which has not yet been defined, this is the 3726 kind. If the tag has been defined, this is DEBUG_KIND_ILLEGAL. */ 3727 enum debug_type_kind kind; 3728}; 3729 3730/* We use a hash table to associate names and types. */ 3731 3732struct ieee_name_type_hash_table 3733{ 3734 struct bfd_hash_table root; 3735}; 3736 3737struct ieee_name_type_hash_entry 3738{ 3739 struct bfd_hash_entry root; 3740 /* Information for this name. */ 3741 struct ieee_name_type *types; 3742}; 3743 3744/* This is a list of enums. */ 3745 3746struct ieee_defined_enum 3747{ 3748 /* Next enum. */ 3749 struct ieee_defined_enum *next; 3750 /* Type index. */ 3751 unsigned int indx; 3752 /* Whether this enum has been defined. */ 3753 bfd_boolean defined; 3754 /* Tag. */ 3755 const char *tag; 3756 /* Names. */ 3757 const char **names; 3758 /* Values. */ 3759 bfd_signed_vma *vals; 3760}; 3761 3762/* We keep a list of modified versions of types, so that we don't 3763 output them more than once. */ 3764 3765struct ieee_modified_type 3766{ 3767 /* Pointer to this type. */ 3768 unsigned int pointer; 3769 /* Function with unknown arguments returning this type. */ 3770 unsigned int function; 3771 /* Const version of this type. */ 3772 unsigned int const_qualified; 3773 /* Volatile version of this type. */ 3774 unsigned int volatile_qualified; 3775 /* List of arrays of this type of various bounds. */ 3776 struct ieee_modified_array_type *arrays; 3777}; 3778 3779/* A list of arrays bounds. */ 3780 3781struct ieee_modified_array_type 3782{ 3783 /* Next array bounds. */ 3784 struct ieee_modified_array_type *next; 3785 /* Type index with these bounds. */ 3786 unsigned int indx; 3787 /* Low bound. */ 3788 bfd_signed_vma low; 3789 /* High bound. */ 3790 bfd_signed_vma high; 3791}; 3792 3793/* This is a list of pending function parameter information. We don't 3794 output them until we see the first block. */ 3795 3796struct ieee_pending_parm 3797{ 3798 /* Next pending parameter. */ 3799 struct ieee_pending_parm *next; 3800 /* Name. */ 3801 const char *name; 3802 /* Type index. */ 3803 unsigned int type; 3804 /* Whether the type is a reference. */ 3805 bfd_boolean referencep; 3806 /* Kind. */ 3807 enum debug_parm_kind kind; 3808 /* Value. */ 3809 bfd_vma val; 3810}; 3811 3812/* This is the handle passed down by debug_write. */ 3813 3814struct ieee_handle 3815{ 3816 /* BFD we are writing to. */ 3817 bfd *abfd; 3818 /* Whether we got an error in a subroutine called via traverse or 3819 map_over_sections. */ 3820 bfd_boolean error; 3821 /* Current data buffer list. */ 3822 struct ieee_buflist *current; 3823 /* Current data buffer. */ 3824 struct ieee_buf *curbuf; 3825 /* Filename of current compilation unit. */ 3826 const char *filename; 3827 /* Module name of current compilation unit. */ 3828 const char *modname; 3829 /* List of buffer for global types. */ 3830 struct ieee_buflist global_types; 3831 /* List of finished data buffers. */ 3832 struct ieee_buflist data; 3833 /* List of buffers for typedefs in the current compilation unit. */ 3834 struct ieee_buflist types; 3835 /* List of buffers for variables and functions in the current 3836 compilation unit. */ 3837 struct ieee_buflist vars; 3838 /* List of buffers for C++ class definitions in the current 3839 compilation unit. */ 3840 struct ieee_buflist cxx; 3841 /* List of buffers for line numbers in the current compilation unit. */ 3842 struct ieee_buflist linenos; 3843 /* Ranges for the current compilation unit. */ 3844 struct ieee_range *ranges; 3845 /* Ranges for all debugging information. */ 3846 struct ieee_range *global_ranges; 3847 /* Nested pending ranges. */ 3848 struct ieee_range *pending_ranges; 3849 /* Type stack. */ 3850 struct ieee_type_stack *type_stack; 3851 /* Next unallocated type index. */ 3852 unsigned int type_indx; 3853 /* Next unallocated name index. */ 3854 unsigned int name_indx; 3855 /* Typedefs. */ 3856 struct ieee_name_type_hash_table typedefs; 3857 /* Tags. */ 3858 struct ieee_name_type_hash_table tags; 3859 /* Enums. */ 3860 struct ieee_defined_enum *enums; 3861 /* Modified versions of types. */ 3862 struct ieee_modified_type *modified; 3863 /* Number of entries allocated in modified. */ 3864 unsigned int modified_alloc; 3865 /* 4 byte complex type. */ 3866 unsigned int complex_float_index; 3867 /* 8 byte complex type. */ 3868 unsigned int complex_double_index; 3869 /* The depth of block nesting. This is 0 outside a function, and 1 3870 just after start_function is called. */ 3871 unsigned int block_depth; 3872 /* The name of the current function. */ 3873 const char *fnname; 3874 /* List of buffers for the type of the function we are currently 3875 writing out. */ 3876 struct ieee_buflist fntype; 3877 /* List of buffers for the parameters of the function we are 3878 currently writing out. */ 3879 struct ieee_buflist fnargs; 3880 /* Number of arguments written to fnargs. */ 3881 unsigned int fnargcount; 3882 /* Pending function parameters. */ 3883 struct ieee_pending_parm *pending_parms; 3884 /* Current line number filename. */ 3885 const char *lineno_filename; 3886 /* Line number name index. */ 3887 unsigned int lineno_name_indx; 3888 /* Filename of pending line number. */ 3889 const char *pending_lineno_filename; 3890 /* Pending line number. */ 3891 unsigned long pending_lineno; 3892 /* Address of pending line number. */ 3893 bfd_vma pending_lineno_addr; 3894 /* Highest address seen at end of procedure. */ 3895 bfd_vma highaddr; 3896}; 3897 3898static bfd_boolean ieee_init_buffer 3899 (struct ieee_handle *, struct ieee_buflist *); 3900static bfd_boolean ieee_change_buffer 3901 (struct ieee_handle *, struct ieee_buflist *); 3902static bfd_boolean ieee_append_buffer 3903 (struct ieee_handle *, struct ieee_buflist *, struct ieee_buflist *); 3904static bfd_boolean ieee_real_write_byte (struct ieee_handle *, int); 3905static bfd_boolean ieee_write_2bytes (struct ieee_handle *, int); 3906static bfd_boolean ieee_write_number (struct ieee_handle *, bfd_vma); 3907static bfd_boolean ieee_write_id (struct ieee_handle *, const char *); 3908static bfd_boolean ieee_write_asn 3909 (struct ieee_handle *, unsigned int, bfd_vma); 3910static bfd_boolean ieee_write_atn65 3911 (struct ieee_handle *, unsigned int, const char *); 3912static bfd_boolean ieee_push_type 3913 (struct ieee_handle *, unsigned int, unsigned int, bfd_boolean, 3914 bfd_boolean); 3915static unsigned int ieee_pop_type (struct ieee_handle *); 3916static void ieee_pop_unused_type (struct ieee_handle *); 3917static unsigned int ieee_pop_type_used (struct ieee_handle *, bfd_boolean); 3918static bfd_boolean ieee_add_range 3919 (struct ieee_handle *, bfd_boolean, bfd_vma, bfd_vma); 3920static bfd_boolean ieee_start_range (struct ieee_handle *, bfd_vma); 3921static bfd_boolean ieee_end_range (struct ieee_handle *, bfd_vma); 3922static bfd_boolean ieee_define_type 3923 (struct ieee_handle *, unsigned int, bfd_boolean, bfd_boolean); 3924static bfd_boolean ieee_define_named_type 3925 (struct ieee_handle *, const char *, unsigned int, unsigned int, 3926 bfd_boolean, bfd_boolean, struct ieee_buflist *); 3927static struct ieee_modified_type *ieee_get_modified_info 3928 (struct ieee_handle *, unsigned int); 3929static struct bfd_hash_entry *ieee_name_type_newfunc 3930 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *); 3931static bfd_boolean ieee_write_undefined_tag 3932 (struct ieee_name_type_hash_entry *, void *); 3933static bfd_boolean ieee_finish_compilation_unit (struct ieee_handle *); 3934static void ieee_add_bb11_blocks (bfd *, asection *, void *); 3935static bfd_boolean ieee_add_bb11 3936 (struct ieee_handle *, asection *, bfd_vma, bfd_vma); 3937static bfd_boolean ieee_output_pending_parms (struct ieee_handle *); 3938static unsigned int ieee_vis_to_flags (enum debug_visibility); 3939static bfd_boolean ieee_class_method_var 3940 (struct ieee_handle *, const char *, enum debug_visibility, bfd_boolean, 3941 bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean); 3942 3943static bfd_boolean ieee_start_compilation_unit (void *, const char *); 3944static bfd_boolean ieee_start_source (void *, const char *); 3945static bfd_boolean ieee_empty_type (void *); 3946static bfd_boolean ieee_void_type (void *); 3947static bfd_boolean ieee_int_type (void *, unsigned int, bfd_boolean); 3948static bfd_boolean ieee_float_type (void *, unsigned int); 3949static bfd_boolean ieee_complex_type (void *, unsigned int); 3950static bfd_boolean ieee_bool_type (void *, unsigned int); 3951static bfd_boolean ieee_enum_type 3952 (void *, const char *, const char **, bfd_signed_vma *); 3953static bfd_boolean ieee_pointer_type (void *); 3954static bfd_boolean ieee_function_type (void *, int, bfd_boolean); 3955static bfd_boolean ieee_reference_type (void *); 3956static bfd_boolean ieee_range_type (void *, bfd_signed_vma, bfd_signed_vma); 3957static bfd_boolean ieee_array_type 3958 (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean); 3959static bfd_boolean ieee_set_type (void *, bfd_boolean); 3960static bfd_boolean ieee_offset_type (void *); 3961static bfd_boolean ieee_method_type (void *, bfd_boolean, int, bfd_boolean); 3962static bfd_boolean ieee_const_type (void *); 3963static bfd_boolean ieee_volatile_type (void *); 3964static bfd_boolean ieee_start_struct_type 3965 (void *, const char *, unsigned int, bfd_boolean, unsigned int); 3966static bfd_boolean ieee_struct_field 3967 (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility); 3968static bfd_boolean ieee_end_struct_type (void *); 3969static bfd_boolean ieee_start_class_type 3970 (void *, const char *, unsigned int, bfd_boolean, unsigned int, bfd_boolean, 3971 bfd_boolean); 3972static bfd_boolean ieee_class_static_member 3973 (void *, const char *, const char *, enum debug_visibility); 3974static bfd_boolean ieee_class_baseclass 3975 (void *, bfd_vma, bfd_boolean, enum debug_visibility); 3976static bfd_boolean ieee_class_start_method (void *, const char *); 3977static bfd_boolean ieee_class_method_variant 3978 (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean, 3979 bfd_vma, bfd_boolean); 3980static bfd_boolean ieee_class_static_method_variant 3981 (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean); 3982static bfd_boolean ieee_class_end_method (void *); 3983static bfd_boolean ieee_end_class_type (void *); 3984static bfd_boolean ieee_typedef_type (void *, const char *); 3985static bfd_boolean ieee_tag_type 3986 (void *, const char *, unsigned int, enum debug_type_kind); 3987static bfd_boolean ieee_typdef (void *, const char *); 3988static bfd_boolean ieee_tag (void *, const char *); 3989static bfd_boolean ieee_int_constant (void *, const char *, bfd_vma); 3990static bfd_boolean ieee_float_constant (void *, const char *, double); 3991static bfd_boolean ieee_typed_constant (void *, const char *, bfd_vma); 3992static bfd_boolean ieee_variable 3993 (void *, const char *, enum debug_var_kind, bfd_vma); 3994static bfd_boolean ieee_start_function (void *, const char *, bfd_boolean); 3995static bfd_boolean ieee_function_parameter 3996 (void *, const char *, enum debug_parm_kind, bfd_vma); 3997static bfd_boolean ieee_start_block (void *, bfd_vma); 3998static bfd_boolean ieee_end_block (void *, bfd_vma); 3999static bfd_boolean ieee_end_function (void *); 4000static bfd_boolean ieee_lineno (void *, const char *, unsigned long, bfd_vma); 4001 4002static const struct debug_write_fns ieee_fns = 4003{ 4004 ieee_start_compilation_unit, 4005 ieee_start_source, 4006 ieee_empty_type, 4007 ieee_void_type, 4008 ieee_int_type, 4009 ieee_float_type, 4010 ieee_complex_type, 4011 ieee_bool_type, 4012 ieee_enum_type, 4013 ieee_pointer_type, 4014 ieee_function_type, 4015 ieee_reference_type, 4016 ieee_range_type, 4017 ieee_array_type, 4018 ieee_set_type, 4019 ieee_offset_type, 4020 ieee_method_type, 4021 ieee_const_type, 4022 ieee_volatile_type, 4023 ieee_start_struct_type, 4024 ieee_struct_field, 4025 ieee_end_struct_type, 4026 ieee_start_class_type, 4027 ieee_class_static_member, 4028 ieee_class_baseclass, 4029 ieee_class_start_method, 4030 ieee_class_method_variant, 4031 ieee_class_static_method_variant, 4032 ieee_class_end_method, 4033 ieee_end_class_type, 4034 ieee_typedef_type, 4035 ieee_tag_type, 4036 ieee_typdef, 4037 ieee_tag, 4038 ieee_int_constant, 4039 ieee_float_constant, 4040 ieee_typed_constant, 4041 ieee_variable, 4042 ieee_start_function, 4043 ieee_function_parameter, 4044 ieee_start_block, 4045 ieee_end_block, 4046 ieee_end_function, 4047 ieee_lineno 4048}; 4049 4050/* Initialize a buffer to be empty. */ 4051 4052static bfd_boolean 4053ieee_init_buffer (struct ieee_handle *info ATTRIBUTE_UNUSED, 4054 struct ieee_buflist *buflist) 4055{ 4056 buflist->head = NULL; 4057 buflist->tail = NULL; 4058 return TRUE; 4059} 4060 4061/* See whether a buffer list has any data. */ 4062 4063#define ieee_buffer_emptyp(buflist) ((buflist)->head == NULL) 4064 4065/* Change the current buffer to a specified buffer chain. */ 4066 4067static bfd_boolean 4068ieee_change_buffer (struct ieee_handle *info, struct ieee_buflist *buflist) 4069{ 4070 if (buflist->head == NULL) 4071 { 4072 struct ieee_buf *buf; 4073 4074 buf = (struct ieee_buf *) xmalloc (sizeof *buf); 4075 buf->next = NULL; 4076 buf->c = 0; 4077 buflist->head = buf; 4078 buflist->tail = buf; 4079 } 4080 4081 info->current = buflist; 4082 info->curbuf = buflist->tail; 4083 4084 return TRUE; 4085} 4086 4087/* Append a buffer chain. */ 4088 4089static bfd_boolean 4090ieee_append_buffer (struct ieee_handle *info ATTRIBUTE_UNUSED, 4091 struct ieee_buflist *mainbuf, 4092 struct ieee_buflist *newbuf) 4093{ 4094 if (newbuf->head != NULL) 4095 { 4096 if (mainbuf->head == NULL) 4097 mainbuf->head = newbuf->head; 4098 else 4099 mainbuf->tail->next = newbuf->head; 4100 mainbuf->tail = newbuf->tail; 4101 } 4102 return TRUE; 4103} 4104 4105/* Write a byte into the buffer. We use a macro for speed and a 4106 function for the complex cases. */ 4107 4108#define ieee_write_byte(info, b) \ 4109 ((info)->curbuf->c < IEEE_BUFSIZE \ 4110 ? ((info)->curbuf->buf[(info)->curbuf->c++] = (b), TRUE) \ 4111 : ieee_real_write_byte ((info), (b))) 4112 4113static bfd_boolean 4114ieee_real_write_byte (struct ieee_handle *info, int b) 4115{ 4116 if (info->curbuf->c >= IEEE_BUFSIZE) 4117 { 4118 struct ieee_buf *n; 4119 4120 n = (struct ieee_buf *) xmalloc (sizeof *n); 4121 n->next = NULL; 4122 n->c = 0; 4123 if (info->current->head == NULL) 4124 info->current->head = n; 4125 else 4126 info->current->tail->next = n; 4127 info->current->tail = n; 4128 info->curbuf = n; 4129 } 4130 4131 info->curbuf->buf[info->curbuf->c] = b; 4132 ++info->curbuf->c; 4133 4134 return TRUE; 4135} 4136 4137/* Write out two bytes. */ 4138 4139static bfd_boolean 4140ieee_write_2bytes (struct ieee_handle *info, int i) 4141{ 4142 return (ieee_write_byte (info, i >> 8) 4143 && ieee_write_byte (info, i & 0xff)); 4144} 4145 4146/* Write out an integer. */ 4147 4148static bfd_boolean 4149ieee_write_number (struct ieee_handle *info, bfd_vma v) 4150{ 4151 bfd_vma t; 4152 bfd_byte ab[20]; 4153 bfd_byte *p; 4154 unsigned int c; 4155 4156 if (v <= (bfd_vma) ieee_number_end_enum) 4157 return ieee_write_byte (info, (int) v); 4158 4159 t = v; 4160 p = ab + sizeof ab; 4161 while (t != 0) 4162 { 4163 *--p = t & 0xff; 4164 t >>= 8; 4165 } 4166 c = (ab + 20) - p; 4167 4168 if (c > (unsigned int) (ieee_number_repeat_end_enum 4169 - ieee_number_repeat_start_enum)) 4170 { 4171 fprintf (stderr, _("IEEE numeric overflow: 0x")); 4172 fprintf_vma (stderr, v); 4173 fprintf (stderr, "\n"); 4174 return FALSE; 4175 } 4176 4177 if (! ieee_write_byte (info, (int) ieee_number_repeat_start_enum + c)) 4178 return FALSE; 4179 for (; c > 0; --c, ++p) 4180 { 4181 if (! ieee_write_byte (info, *p)) 4182 return FALSE; 4183 } 4184 4185 return TRUE; 4186} 4187 4188/* Write out a string. */ 4189 4190static bfd_boolean 4191ieee_write_id (struct ieee_handle *info, const char *s) 4192{ 4193 unsigned int len; 4194 4195 len = strlen (s); 4196 if (len <= 0x7f) 4197 { 4198 if (! ieee_write_byte (info, len)) 4199 return FALSE; 4200 } 4201 else if (len <= 0xff) 4202 { 4203 if (! ieee_write_byte (info, (int) ieee_extension_length_1_enum) 4204 || ! ieee_write_byte (info, len)) 4205 return FALSE; 4206 } 4207 else if (len <= 0xffff) 4208 { 4209 if (! ieee_write_byte (info, (int) ieee_extension_length_2_enum) 4210 || ! ieee_write_2bytes (info, len)) 4211 return FALSE; 4212 } 4213 else 4214 { 4215 fprintf (stderr, _("IEEE string length overflow: %u\n"), len); 4216 return FALSE; 4217 } 4218 4219 for (; *s != '\0'; s++) 4220 if (! ieee_write_byte (info, *s)) 4221 return FALSE; 4222 4223 return TRUE; 4224} 4225 4226/* Write out an ASN record. */ 4227 4228static bfd_boolean 4229ieee_write_asn (struct ieee_handle *info, unsigned int indx, bfd_vma val) 4230{ 4231 return (ieee_write_2bytes (info, (int) ieee_asn_record_enum) 4232 && ieee_write_number (info, indx) 4233 && ieee_write_number (info, val)); 4234} 4235 4236/* Write out an ATN65 record. */ 4237 4238static bfd_boolean 4239ieee_write_atn65 (struct ieee_handle *info, unsigned int indx, const char *s) 4240{ 4241 return (ieee_write_2bytes (info, (int) ieee_atn_record_enum) 4242 && ieee_write_number (info, indx) 4243 && ieee_write_number (info, 0) 4244 && ieee_write_number (info, 65) 4245 && ieee_write_id (info, s)); 4246} 4247 4248/* Push a type index onto the type stack. */ 4249 4250static bfd_boolean 4251ieee_push_type (struct ieee_handle *info, unsigned int indx, 4252 unsigned int size, bfd_boolean unsignedp, bfd_boolean localp) 4253{ 4254 struct ieee_type_stack *ts; 4255 4256 ts = (struct ieee_type_stack *) xmalloc (sizeof *ts); 4257 memset (ts, 0, sizeof *ts); 4258 4259 ts->type.indx = indx; 4260 ts->type.size = size; 4261 ts->type.unsignedp = unsignedp; 4262 ts->type.localp = localp; 4263 4264 ts->next = info->type_stack; 4265 info->type_stack = ts; 4266 4267 return TRUE; 4268} 4269 4270/* Pop a type index off the type stack. */ 4271 4272static unsigned int 4273ieee_pop_type (struct ieee_handle *info) 4274{ 4275 return ieee_pop_type_used (info, TRUE); 4276} 4277 4278/* Pop an unused type index off the type stack. */ 4279 4280static void 4281ieee_pop_unused_type (struct ieee_handle *info) 4282{ 4283 (void) ieee_pop_type_used (info, FALSE); 4284} 4285 4286/* Pop a used or unused type index off the type stack. */ 4287 4288static unsigned int 4289ieee_pop_type_used (struct ieee_handle *info, bfd_boolean used) 4290{ 4291 struct ieee_type_stack *ts; 4292 unsigned int ret; 4293 4294 ts = info->type_stack; 4295 assert (ts != NULL); 4296 4297 /* If this is a function type, and we need it, we need to append the 4298 actual definition to the typedef block now. */ 4299 if (used && ! ieee_buffer_emptyp (&ts->type.fndef)) 4300 { 4301 struct ieee_buflist *buflist; 4302 4303 if (ts->type.localp) 4304 { 4305 /* Make sure we have started the types block. */ 4306 if (ieee_buffer_emptyp (&info->types)) 4307 { 4308 if (! ieee_change_buffer (info, &info->types) 4309 || ! ieee_write_byte (info, (int) ieee_bb_record_enum) 4310 || ! ieee_write_byte (info, 1) 4311 || ! ieee_write_number (info, 0) 4312 || ! ieee_write_id (info, info->modname)) 4313 return FALSE; 4314 } 4315 buflist = &info->types; 4316 } 4317 else 4318 { 4319 /* Make sure we started the global type block. */ 4320 if (ieee_buffer_emptyp (&info->global_types)) 4321 { 4322 if (! ieee_change_buffer (info, &info->global_types) 4323 || ! ieee_write_byte (info, (int) ieee_bb_record_enum) 4324 || ! ieee_write_byte (info, 2) 4325 || ! ieee_write_number (info, 0) 4326 || ! ieee_write_id (info, "")) 4327 return FALSE; 4328 } 4329 buflist = &info->global_types; 4330 } 4331 4332 if (! ieee_append_buffer (info, buflist, &ts->type.fndef)) 4333 return FALSE; 4334 } 4335 4336 ret = ts->type.indx; 4337 info->type_stack = ts->next; 4338 free (ts); 4339 return ret; 4340} 4341 4342/* Add a range of bytes included in the current compilation unit. */ 4343 4344static bfd_boolean 4345ieee_add_range (struct ieee_handle *info, bfd_boolean global, bfd_vma low, 4346 bfd_vma high) 4347{ 4348 struct ieee_range **plist, *r, **pr; 4349 4350 if (low == (bfd_vma) -1 || high == (bfd_vma) -1 || low == high) 4351 return TRUE; 4352 4353 if (global) 4354 plist = &info->global_ranges; 4355 else 4356 plist = &info->ranges; 4357 4358 for (r = *plist; r != NULL; r = r->next) 4359 { 4360 if (high >= r->low && low <= r->high) 4361 { 4362 /* The new range overlaps r. */ 4363 if (low < r->low) 4364 r->low = low; 4365 if (high > r->high) 4366 r->high = high; 4367 pr = &r->next; 4368 while (*pr != NULL && (*pr)->low <= r->high) 4369 { 4370 struct ieee_range *n; 4371 4372 if ((*pr)->high > r->high) 4373 r->high = (*pr)->high; 4374 n = (*pr)->next; 4375 free (*pr); 4376 *pr = n; 4377 } 4378 return TRUE; 4379 } 4380 } 4381 4382 r = (struct ieee_range *) xmalloc (sizeof *r); 4383 memset (r, 0, sizeof *r); 4384 4385 r->low = low; 4386 r->high = high; 4387 4388 /* Store the ranges sorted by address. */ 4389 for (pr = plist; *pr != NULL; pr = &(*pr)->next) 4390 if ((*pr)->low > high) 4391 break; 4392 r->next = *pr; 4393 *pr = r; 4394 4395 return TRUE; 4396} 4397 4398/* Start a new range for which we only have the low address. */ 4399 4400static bfd_boolean 4401ieee_start_range (struct ieee_handle *info, bfd_vma low) 4402{ 4403 struct ieee_range *r; 4404 4405 r = (struct ieee_range *) xmalloc (sizeof *r); 4406 memset (r, 0, sizeof *r); 4407 r->low = low; 4408 r->next = info->pending_ranges; 4409 info->pending_ranges = r; 4410 return TRUE; 4411} 4412 4413/* Finish a range started by ieee_start_range. */ 4414 4415static bfd_boolean 4416ieee_end_range (struct ieee_handle *info, bfd_vma high) 4417{ 4418 struct ieee_range *r; 4419 bfd_vma low; 4420 4421 assert (info->pending_ranges != NULL); 4422 r = info->pending_ranges; 4423 low = r->low; 4424 info->pending_ranges = r->next; 4425 free (r); 4426 return ieee_add_range (info, FALSE, low, high); 4427} 4428 4429/* Start defining a type. */ 4430 4431static bfd_boolean 4432ieee_define_type (struct ieee_handle *info, unsigned int size, 4433 bfd_boolean unsignedp, bfd_boolean localp) 4434{ 4435 return ieee_define_named_type (info, (const char *) NULL, 4436 (unsigned int) -1, size, unsignedp, 4437 localp, (struct ieee_buflist *) NULL); 4438} 4439 4440/* Start defining a named type. */ 4441 4442static bfd_boolean 4443ieee_define_named_type (struct ieee_handle *info, const char *name, 4444 unsigned int indx, unsigned int size, 4445 bfd_boolean unsignedp, bfd_boolean localp, 4446 struct ieee_buflist *buflist) 4447{ 4448 unsigned int type_indx; 4449 unsigned int name_indx; 4450 4451 if (indx != (unsigned int) -1) 4452 type_indx = indx; 4453 else 4454 { 4455 type_indx = info->type_indx; 4456 ++info->type_indx; 4457 } 4458 4459 name_indx = info->name_indx; 4460 ++info->name_indx; 4461 4462 if (name == NULL) 4463 name = ""; 4464 4465 /* If we were given a buffer, use it; otherwise, use either the 4466 local or the global type information, and make sure that the type 4467 block is started. */ 4468 if (buflist != NULL) 4469 { 4470 if (! ieee_change_buffer (info, buflist)) 4471 return FALSE; 4472 } 4473 else if (localp) 4474 { 4475 if (! ieee_buffer_emptyp (&info->types)) 4476 { 4477 if (! ieee_change_buffer (info, &info->types)) 4478 return FALSE; 4479 } 4480 else 4481 { 4482 if (! ieee_change_buffer (info, &info->types) 4483 || ! ieee_write_byte (info, (int) ieee_bb_record_enum) 4484 || ! ieee_write_byte (info, 1) 4485 || ! ieee_write_number (info, 0) 4486 || ! ieee_write_id (info, info->modname)) 4487 return FALSE; 4488 } 4489 } 4490 else 4491 { 4492 if (! ieee_buffer_emptyp (&info->global_types)) 4493 { 4494 if (! ieee_change_buffer (info, &info->global_types)) 4495 return FALSE; 4496 } 4497 else 4498 { 4499 if (! ieee_change_buffer (info, &info->global_types) 4500 || ! ieee_write_byte (info, (int) ieee_bb_record_enum) 4501 || ! ieee_write_byte (info, 2) 4502 || ! ieee_write_number (info, 0) 4503 || ! ieee_write_id (info, "")) 4504 return FALSE; 4505 } 4506 } 4507 4508 /* Push the new type on the type stack, write out an NN record, and 4509 write out the start of a TY record. The caller will then finish 4510 the TY record. */ 4511 if (! ieee_push_type (info, type_indx, size, unsignedp, localp)) 4512 return FALSE; 4513 4514 return (ieee_write_byte (info, (int) ieee_nn_record) 4515 && ieee_write_number (info, name_indx) 4516 && ieee_write_id (info, name) 4517 && ieee_write_byte (info, (int) ieee_ty_record_enum) 4518 && ieee_write_number (info, type_indx) 4519 && ieee_write_byte (info, 0xce) 4520 && ieee_write_number (info, name_indx)); 4521} 4522 4523/* Get an entry to the list of modified versions of a type. */ 4524 4525static struct ieee_modified_type * 4526ieee_get_modified_info (struct ieee_handle *info, unsigned int indx) 4527{ 4528 if (indx >= info->modified_alloc) 4529 { 4530 unsigned int nalloc; 4531 4532 nalloc = info->modified_alloc; 4533 if (nalloc == 0) 4534 nalloc = 16; 4535 while (indx >= nalloc) 4536 nalloc *= 2; 4537 info->modified = ((struct ieee_modified_type *) 4538 xrealloc (info->modified, 4539 nalloc * sizeof *info->modified)); 4540 memset (info->modified + info->modified_alloc, 0, 4541 (nalloc - info->modified_alloc) * sizeof *info->modified); 4542 info->modified_alloc = nalloc; 4543 } 4544 4545 return info->modified + indx; 4546} 4547 4548/* Routines for the hash table mapping names to types. */ 4549 4550/* Initialize an entry in the hash table. */ 4551 4552static struct bfd_hash_entry * 4553ieee_name_type_newfunc (struct bfd_hash_entry *entry, 4554 struct bfd_hash_table *table, const char *string) 4555{ 4556 struct ieee_name_type_hash_entry *ret = 4557 (struct ieee_name_type_hash_entry *) entry; 4558 4559 /* Allocate the structure if it has not already been allocated by a 4560 subclass. */ 4561 if (ret == NULL) 4562 ret = ((struct ieee_name_type_hash_entry *) 4563 bfd_hash_allocate (table, sizeof *ret)); 4564 if (ret == NULL) 4565 return NULL; 4566 4567 /* Call the allocation method of the superclass. */ 4568 ret = ((struct ieee_name_type_hash_entry *) 4569 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string)); 4570 if (ret) 4571 { 4572 /* Set local fields. */ 4573 ret->types = NULL; 4574 } 4575 4576 return (struct bfd_hash_entry *) ret; 4577} 4578 4579/* Look up an entry in the hash table. */ 4580 4581#define ieee_name_type_hash_lookup(table, string, create, copy) \ 4582 ((struct ieee_name_type_hash_entry *) \ 4583 bfd_hash_lookup (&(table)->root, (string), (create), (copy))) 4584 4585/* Traverse the hash table. */ 4586 4587#define ieee_name_type_hash_traverse(table, func, info) \ 4588 (bfd_hash_traverse \ 4589 (&(table)->root, \ 4590 (bfd_boolean (*) (struct bfd_hash_entry *, void *)) (func), \ 4591 (info))) 4592 4593/* The general routine to write out IEEE debugging information. */ 4594 4595bfd_boolean 4596write_ieee_debugging_info (bfd *abfd, void *dhandle) 4597{ 4598 struct ieee_handle info; 4599 asection *s; 4600 const char *err; 4601 struct ieee_buf *b; 4602 4603 memset (&info, 0, sizeof info); 4604 info.abfd = abfd; 4605 info.type_indx = 256; 4606 info.name_indx = 32; 4607 4608 if (!bfd_hash_table_init (&info.typedefs.root, ieee_name_type_newfunc, 4609 sizeof (struct ieee_name_type_hash_entry)) 4610 || !bfd_hash_table_init (&info.tags.root, ieee_name_type_newfunc, 4611 sizeof (struct ieee_name_type_hash_entry))) 4612 return FALSE; 4613 4614 if (! ieee_init_buffer (&info, &info.global_types) 4615 || ! ieee_init_buffer (&info, &info.data) 4616 || ! ieee_init_buffer (&info, &info.types) 4617 || ! ieee_init_buffer (&info, &info.vars) 4618 || ! ieee_init_buffer (&info, &info.cxx) 4619 || ! ieee_init_buffer (&info, &info.linenos) 4620 || ! ieee_init_buffer (&info, &info.fntype) 4621 || ! ieee_init_buffer (&info, &info.fnargs)) 4622 return FALSE; 4623 4624 if (! debug_write (dhandle, &ieee_fns, (void *) &info)) 4625 return FALSE; 4626 4627 if (info.filename != NULL) 4628 { 4629 if (! ieee_finish_compilation_unit (&info)) 4630 return FALSE; 4631 } 4632 4633 /* Put any undefined tags in the global typedef information. */ 4634 info.error = FALSE; 4635 ieee_name_type_hash_traverse (&info.tags, 4636 ieee_write_undefined_tag, 4637 (void *) &info); 4638 if (info.error) 4639 return FALSE; 4640 4641 /* Prepend the global typedef information to the other data. */ 4642 if (! ieee_buffer_emptyp (&info.global_types)) 4643 { 4644 /* The HP debugger seems to have a bug in which it ignores the 4645 last entry in the global types, so we add a dummy entry. */ 4646 if (! ieee_change_buffer (&info, &info.global_types) 4647 || ! ieee_write_byte (&info, (int) ieee_nn_record) 4648 || ! ieee_write_number (&info, info.name_indx) 4649 || ! ieee_write_id (&info, "") 4650 || ! ieee_write_byte (&info, (int) ieee_ty_record_enum) 4651 || ! ieee_write_number (&info, info.type_indx) 4652 || ! ieee_write_byte (&info, 0xce) 4653 || ! ieee_write_number (&info, info.name_indx) 4654 || ! ieee_write_number (&info, 'P') 4655 || ! ieee_write_number (&info, (int) builtin_void + 32) 4656 || ! ieee_write_byte (&info, (int) ieee_be_record_enum)) 4657 return FALSE; 4658 4659 if (! ieee_append_buffer (&info, &info.global_types, &info.data)) 4660 return FALSE; 4661 info.data = info.global_types; 4662 } 4663 4664 /* Make sure that we have declare BB11 blocks for each range in the 4665 file. They are added to info->vars. */ 4666 info.error = FALSE; 4667 if (! ieee_init_buffer (&info, &info.vars)) 4668 return FALSE; 4669 bfd_map_over_sections (abfd, ieee_add_bb11_blocks, (void *) &info); 4670 if (info.error) 4671 return FALSE; 4672 if (! ieee_buffer_emptyp (&info.vars)) 4673 { 4674 if (! ieee_change_buffer (&info, &info.vars) 4675 || ! ieee_write_byte (&info, (int) ieee_be_record_enum)) 4676 return FALSE; 4677 4678 if (! ieee_append_buffer (&info, &info.data, &info.vars)) 4679 return FALSE; 4680 } 4681 4682 /* Now all the data is in info.data. Write it out to the BFD. We 4683 normally would need to worry about whether all the other sections 4684 are set up yet, but the IEEE backend will handle this particular 4685 case correctly regardless. */ 4686 if (ieee_buffer_emptyp (&info.data)) 4687 { 4688 /* There is no debugging information. */ 4689 return TRUE; 4690 } 4691 err = NULL; 4692 s = bfd_make_section_with_flags (abfd, ".debug", 4693 SEC_DEBUGGING | SEC_HAS_CONTENTS); 4694 if (s == NULL) 4695 err = "bfd_make_section"; 4696 if (err == NULL) 4697 { 4698 bfd_size_type size; 4699 4700 size = 0; 4701 for (b = info.data.head; b != NULL; b = b->next) 4702 size += b->c; 4703 if (! bfd_set_section_size (abfd, s, size)) 4704 err = "bfd_set_section_size"; 4705 } 4706 if (err == NULL) 4707 { 4708 file_ptr offset; 4709 4710 offset = 0; 4711 for (b = info.data.head; b != NULL; b = b->next) 4712 { 4713 if (! bfd_set_section_contents (abfd, s, b->buf, offset, b->c)) 4714 { 4715 err = "bfd_set_section_contents"; 4716 break; 4717 } 4718 offset += b->c; 4719 } 4720 } 4721 4722 if (err != NULL) 4723 { 4724 fprintf (stderr, "%s: %s: %s\n", bfd_get_filename (abfd), err, 4725 bfd_errmsg (bfd_get_error ())); 4726 return FALSE; 4727 } 4728 4729 bfd_hash_table_free (&info.typedefs.root); 4730 bfd_hash_table_free (&info.tags.root); 4731 4732 return TRUE; 4733} 4734 4735/* Write out information for an undefined tag. This is called via 4736 ieee_name_type_hash_traverse. */ 4737 4738static bfd_boolean 4739ieee_write_undefined_tag (struct ieee_name_type_hash_entry *h, void *p) 4740{ 4741 struct ieee_handle *info = (struct ieee_handle *) p; 4742 struct ieee_name_type *nt; 4743 4744 for (nt = h->types; nt != NULL; nt = nt->next) 4745 { 4746 unsigned int name_indx; 4747 char code; 4748 4749 if (nt->kind == DEBUG_KIND_ILLEGAL) 4750 continue; 4751 4752 if (ieee_buffer_emptyp (&info->global_types)) 4753 { 4754 if (! ieee_change_buffer (info, &info->global_types) 4755 || ! ieee_write_byte (info, (int) ieee_bb_record_enum) 4756 || ! ieee_write_byte (info, 2) 4757 || ! ieee_write_number (info, 0) 4758 || ! ieee_write_id (info, "")) 4759 { 4760 info->error = TRUE; 4761 return FALSE; 4762 } 4763 } 4764 else 4765 { 4766 if (! ieee_change_buffer (info, &info->global_types)) 4767 { 4768 info->error = TRUE; 4769 return FALSE; 4770 } 4771 } 4772 4773 name_indx = info->name_indx; 4774 ++info->name_indx; 4775 if (! ieee_write_byte (info, (int) ieee_nn_record) 4776 || ! ieee_write_number (info, name_indx) 4777 || ! ieee_write_id (info, nt->type.name) 4778 || ! ieee_write_byte (info, (int) ieee_ty_record_enum) 4779 || ! ieee_write_number (info, nt->type.indx) 4780 || ! ieee_write_byte (info, 0xce) 4781 || ! ieee_write_number (info, name_indx)) 4782 { 4783 info->error = TRUE; 4784 return FALSE; 4785 } 4786 4787 switch (nt->kind) 4788 { 4789 default: 4790 abort (); 4791 info->error = TRUE; 4792 return FALSE; 4793 case DEBUG_KIND_STRUCT: 4794 case DEBUG_KIND_CLASS: 4795 code = 'S'; 4796 break; 4797 case DEBUG_KIND_UNION: 4798 case DEBUG_KIND_UNION_CLASS: 4799 code = 'U'; 4800 break; 4801 case DEBUG_KIND_ENUM: 4802 code = 'E'; 4803 break; 4804 } 4805 if (! ieee_write_number (info, code) 4806 || ! ieee_write_number (info, 0)) 4807 { 4808 info->error = TRUE; 4809 return FALSE; 4810 } 4811 } 4812 4813 return TRUE; 4814} 4815 4816/* Start writing out information for a compilation unit. */ 4817 4818static bfd_boolean 4819ieee_start_compilation_unit (void *p, const char *filename) 4820{ 4821 struct ieee_handle *info = (struct ieee_handle *) p; 4822 const char *modname; 4823#ifdef HAVE_DOS_BASED_FILE_SYSTEM 4824 const char *backslash; 4825#endif 4826 char *c, *s; 4827 4828 if (info->filename != NULL) 4829 { 4830 if (! ieee_finish_compilation_unit (info)) 4831 return FALSE; 4832 } 4833 4834 info->filename = filename; 4835 modname = strrchr (filename, '/'); 4836#ifdef HAVE_DOS_BASED_FILE_SYSTEM 4837 /* We could have a mixed forward/back slash case. */ 4838 backslash = strrchr (filename, '\\'); 4839 if (modname == NULL || (backslash != NULL && backslash > modname)) 4840 modname = backslash; 4841#endif 4842 4843 if (modname != NULL) 4844 ++modname; 4845#ifdef HAVE_DOS_BASED_FILE_SYSTEM 4846 else if (filename[0] && filename[1] == ':') 4847 modname = filename + 2; 4848#endif 4849 else 4850 modname = filename; 4851 4852 c = xstrdup (modname); 4853 s = strrchr (c, '.'); 4854 if (s != NULL) 4855 *s = '\0'; 4856 info->modname = c; 4857 4858 if (! ieee_init_buffer (info, &info->types) 4859 || ! ieee_init_buffer (info, &info->vars) 4860 || ! ieee_init_buffer (info, &info->cxx) 4861 || ! ieee_init_buffer (info, &info->linenos)) 4862 return FALSE; 4863 info->ranges = NULL; 4864 4865 /* Always include a BB1 and a BB3 block. That is what the output of 4866 the MRI linker seems to look like. */ 4867 if (! ieee_change_buffer (info, &info->types) 4868 || ! ieee_write_byte (info, (int) ieee_bb_record_enum) 4869 || ! ieee_write_byte (info, 1) 4870 || ! ieee_write_number (info, 0) 4871 || ! ieee_write_id (info, info->modname)) 4872 return FALSE; 4873 4874 ++info->name_indx; 4875 if (! ieee_change_buffer (info, &info->vars) 4876 || ! ieee_write_byte (info, (int) ieee_bb_record_enum) 4877 || ! ieee_write_byte (info, 3) 4878 || ! ieee_write_number (info, 0) 4879 || ! ieee_write_id (info, info->modname)) 4880 return FALSE; 4881 4882 return TRUE; 4883} 4884 4885/* Finish up a compilation unit. */ 4886 4887static bfd_boolean 4888ieee_finish_compilation_unit (struct ieee_handle *info) 4889{ 4890 struct ieee_range *r; 4891 4892 if (! ieee_buffer_emptyp (&info->types)) 4893 { 4894 if (! ieee_change_buffer (info, &info->types) 4895 || ! ieee_write_byte (info, (int) ieee_be_record_enum)) 4896 return FALSE; 4897 } 4898 4899 if (! ieee_buffer_emptyp (&info->cxx)) 4900 { 4901 /* Append any C++ information to the global function and 4902 variable information. */ 4903 assert (! ieee_buffer_emptyp (&info->vars)); 4904 if (! ieee_change_buffer (info, &info->vars)) 4905 return FALSE; 4906 4907 /* We put the pmisc records in a dummy procedure, just as the 4908 MRI compiler does. */ 4909 if (! ieee_write_byte (info, (int) ieee_bb_record_enum) 4910 || ! ieee_write_byte (info, 6) 4911 || ! ieee_write_number (info, 0) 4912 || ! ieee_write_id (info, "__XRYCPP") 4913 || ! ieee_write_number (info, 0) 4914 || ! ieee_write_number (info, 0) 4915 || ! ieee_write_number (info, info->highaddr - 1) 4916 || ! ieee_append_buffer (info, &info->vars, &info->cxx) 4917 || ! ieee_change_buffer (info, &info->vars) 4918 || ! ieee_write_byte (info, (int) ieee_be_record_enum) 4919 || ! ieee_write_number (info, info->highaddr - 1)) 4920 return FALSE; 4921 } 4922 4923 if (! ieee_buffer_emptyp (&info->vars)) 4924 { 4925 if (! ieee_change_buffer (info, &info->vars) 4926 || ! ieee_write_byte (info, (int) ieee_be_record_enum)) 4927 return FALSE; 4928 } 4929 4930 if (info->pending_lineno_filename != NULL) 4931 { 4932 /* Force out the pending line number. */ 4933 if (! ieee_lineno ((void *) info, (const char *) NULL, 0, (bfd_vma) -1)) 4934 return FALSE; 4935 } 4936 if (! ieee_buffer_emptyp (&info->linenos)) 4937 { 4938 if (! ieee_change_buffer (info, &info->linenos) 4939 || ! ieee_write_byte (info, (int) ieee_be_record_enum)) 4940 return FALSE; 4941 if (strcmp (info->filename, info->lineno_filename) != 0) 4942 { 4943 /* We were not in the main file. We just closed the 4944 included line number block, and now we must close the 4945 main line number block. */ 4946 if (! ieee_write_byte (info, (int) ieee_be_record_enum)) 4947 return FALSE; 4948 } 4949 } 4950 4951 if (! ieee_append_buffer (info, &info->data, &info->types) 4952 || ! ieee_append_buffer (info, &info->data, &info->vars) 4953 || ! ieee_append_buffer (info, &info->data, &info->linenos)) 4954 return FALSE; 4955 4956 /* Build BB10/BB11 blocks based on the ranges we recorded. */ 4957 if (! ieee_change_buffer (info, &info->data)) 4958 return FALSE; 4959 4960 if (! ieee_write_byte (info, (int) ieee_bb_record_enum) 4961 || ! ieee_write_byte (info, 10) 4962 || ! ieee_write_number (info, 0) 4963 || ! ieee_write_id (info, info->modname) 4964 || ! ieee_write_id (info, "") 4965 || ! ieee_write_number (info, 0) 4966 || ! ieee_write_id (info, "GNU objcopy")) 4967 return FALSE; 4968 4969 for (r = info->ranges; r != NULL; r = r->next) 4970 { 4971 bfd_vma low, high; 4972 asection *s; 4973 int kind; 4974 4975 low = r->low; 4976 high = r->high; 4977 4978 /* Find the section corresponding to this range. */ 4979 for (s = info->abfd->sections; s != NULL; s = s->next) 4980 { 4981 if (bfd_get_section_vma (info->abfd, s) <= low 4982 && high <= (bfd_get_section_vma (info->abfd, s) 4983 + bfd_section_size (info->abfd, s))) 4984 break; 4985 } 4986 4987 if (s == NULL) 4988 { 4989 /* Just ignore this range. */ 4990 continue; 4991 } 4992 4993 /* Coalesce ranges if it seems reasonable. */ 4994 while (r->next != NULL 4995 && high + 0x1000 >= r->next->low 4996 && (r->next->high 4997 <= (bfd_get_section_vma (info->abfd, s) 4998 + bfd_section_size (info->abfd, s)))) 4999 { 5000 r = r->next; 5001 high = r->high; 5002 } 5003 5004 if ((s->flags & SEC_CODE) != 0) 5005 kind = 1; 5006 else if ((s->flags & SEC_READONLY) != 0) 5007 kind = 3; 5008 else 5009 kind = 2; 5010 5011 if (! ieee_write_byte (info, (int) ieee_bb_record_enum) 5012 || ! ieee_write_byte (info, 11) 5013 || ! ieee_write_number (info, 0) 5014 || ! ieee_write_id (info, "") 5015 || ! ieee_write_number (info, kind) 5016 || ! ieee_write_number (info, s->index + IEEE_SECTION_NUMBER_BASE) 5017 || ! ieee_write_number (info, low) 5018 || ! ieee_write_byte (info, (int) ieee_be_record_enum) 5019 || ! ieee_write_number (info, high - low)) 5020 return FALSE; 5021 5022 /* Add this range to the list of global ranges. */ 5023 if (! ieee_add_range (info, TRUE, low, high)) 5024 return FALSE; 5025 } 5026 5027 if (! ieee_write_byte (info, (int) ieee_be_record_enum)) 5028 return FALSE; 5029 5030 return TRUE; 5031} 5032 5033/* Add BB11 blocks describing each range that we have not already 5034 described. */ 5035 5036static void 5037ieee_add_bb11_blocks (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *data) 5038{ 5039 struct ieee_handle *info = (struct ieee_handle *) data; 5040 bfd_vma low, high; 5041 struct ieee_range *r; 5042 5043 low = bfd_get_section_vma (abfd, sec); 5044 high = low + bfd_section_size (abfd, sec); 5045 5046 /* Find the first range at or after this section. The ranges are 5047 sorted by address. */ 5048 for (r = info->global_ranges; r != NULL; r = r->next) 5049 if (r->high > low) 5050 break; 5051 5052 while (low < high) 5053 { 5054 if (r == NULL || r->low >= high) 5055 { 5056 if (! ieee_add_bb11 (info, sec, low, high)) 5057 info->error = TRUE; 5058 return; 5059 } 5060 5061 if (low < r->low 5062 && r->low - low > 0x100) 5063 { 5064 if (! ieee_add_bb11 (info, sec, low, r->low)) 5065 { 5066 info->error = TRUE; 5067 return; 5068 } 5069 } 5070 low = r->high; 5071 5072 r = r->next; 5073 } 5074} 5075 5076/* Add a single BB11 block for a range. We add it to info->vars. */ 5077 5078static bfd_boolean 5079ieee_add_bb11 (struct ieee_handle *info, asection *sec, bfd_vma low, 5080 bfd_vma high) 5081{ 5082 int kind; 5083 5084 if (! ieee_buffer_emptyp (&info->vars)) 5085 { 5086 if (! ieee_change_buffer (info, &info->vars)) 5087 return FALSE; 5088 } 5089 else 5090 { 5091 const char *filename, *modname; 5092#ifdef HAVE_DOS_BASED_FILE_SYSTEM 5093 const char *backslash; 5094#endif 5095 char *c, *s; 5096 5097 /* Start the enclosing BB10 block. */ 5098 filename = bfd_get_filename (info->abfd); 5099 modname = strrchr (filename, '/'); 5100#ifdef HAVE_DOS_BASED_FILE_SYSTEM 5101 backslash = strrchr (filename, '\\'); 5102 if (modname == NULL || (backslash != NULL && backslash > modname)) 5103 modname = backslash; 5104#endif 5105 5106 if (modname != NULL) 5107 ++modname; 5108#ifdef HAVE_DOS_BASED_FILE_SYSTEM 5109 else if (filename[0] && filename[1] == ':') 5110 modname = filename + 2; 5111#endif 5112 else 5113 modname = filename; 5114 5115 c = xstrdup (modname); 5116 s = strrchr (c, '.'); 5117 if (s != NULL) 5118 *s = '\0'; 5119 5120 if (! ieee_change_buffer (info, &info->vars) 5121 || ! ieee_write_byte (info, (int) ieee_bb_record_enum) 5122 || ! ieee_write_byte (info, 10) 5123 || ! ieee_write_number (info, 0) 5124 || ! ieee_write_id (info, c) 5125 || ! ieee_write_id (info, "") 5126 || ! ieee_write_number (info, 0) 5127 || ! ieee_write_id (info, "GNU objcopy")) 5128 return FALSE; 5129 5130 free (c); 5131 } 5132 5133 if ((sec->flags & SEC_CODE) != 0) 5134 kind = 1; 5135 else if ((sec->flags & SEC_READONLY) != 0) 5136 kind = 3; 5137 else 5138 kind = 2; 5139 5140 if (! ieee_write_byte (info, (int) ieee_bb_record_enum) 5141 || ! ieee_write_byte (info, 11) 5142 || ! ieee_write_number (info, 0) 5143 || ! ieee_write_id (info, "") 5144 || ! ieee_write_number (info, kind) 5145 || ! ieee_write_number (info, sec->index + IEEE_SECTION_NUMBER_BASE) 5146 || ! ieee_write_number (info, low) 5147 || ! ieee_write_byte (info, (int) ieee_be_record_enum) 5148 || ! ieee_write_number (info, high - low)) 5149 return FALSE; 5150 5151 return TRUE; 5152} 5153 5154/* Start recording information from a particular source file. This is 5155 used to record which file defined which types, variables, etc. It 5156 is not used for line numbers, since the lineno entry point passes 5157 down the file name anyhow. IEEE debugging information doesn't seem 5158 to store this information anywhere. */ 5159 5160static bfd_boolean 5161ieee_start_source (void *p ATTRIBUTE_UNUSED, 5162 const char *filename ATTRIBUTE_UNUSED) 5163{ 5164 return TRUE; 5165} 5166 5167/* Make an empty type. */ 5168 5169static bfd_boolean 5170ieee_empty_type (void *p) 5171{ 5172 struct ieee_handle *info = (struct ieee_handle *) p; 5173 5174 return ieee_push_type (info, (int) builtin_unknown, 0, FALSE, FALSE); 5175} 5176 5177/* Make a void type. */ 5178 5179static bfd_boolean 5180ieee_void_type (void *p) 5181{ 5182 struct ieee_handle *info = (struct ieee_handle *) p; 5183 5184 return ieee_push_type (info, (int) builtin_void, 0, FALSE, FALSE); 5185} 5186 5187/* Make an integer type. */ 5188 5189static bfd_boolean 5190ieee_int_type (void *p, unsigned int size, bfd_boolean unsignedp) 5191{ 5192 struct ieee_handle *info = (struct ieee_handle *) p; 5193 unsigned int indx; 5194 5195 switch (size) 5196 { 5197 case 1: 5198 indx = (int) builtin_signed_char; 5199 break; 5200 case 2: 5201 indx = (int) builtin_signed_short_int; 5202 break; 5203 case 4: 5204 indx = (int) builtin_signed_long; 5205 break; 5206 case 8: 5207 indx = (int) builtin_signed_long_long; 5208 break; 5209 default: 5210 fprintf (stderr, _("IEEE unsupported integer type size %u\n"), size); 5211 return FALSE; 5212 } 5213 5214 if (unsignedp) 5215 ++indx; 5216 5217 return ieee_push_type (info, indx, size, unsignedp, FALSE); 5218} 5219 5220/* Make a floating point type. */ 5221 5222static bfd_boolean 5223ieee_float_type (void *p, unsigned int size) 5224{ 5225 struct ieee_handle *info = (struct ieee_handle *) p; 5226 unsigned int indx; 5227 5228 switch (size) 5229 { 5230 case 4: 5231 indx = (int) builtin_float; 5232 break; 5233 case 8: 5234 indx = (int) builtin_double; 5235 break; 5236 case 12: 5237 /* FIXME: This size really depends upon the processor. */ 5238 indx = (int) builtin_long_double; 5239 break; 5240 case 16: 5241 indx = (int) builtin_long_long_double; 5242 break; 5243 default: 5244 fprintf (stderr, _("IEEE unsupported float type size %u\n"), size); 5245 return FALSE; 5246 } 5247 5248 return ieee_push_type (info, indx, size, FALSE, FALSE); 5249} 5250 5251/* Make a complex type. */ 5252 5253static bfd_boolean 5254ieee_complex_type (void *p, unsigned int size) 5255{ 5256 struct ieee_handle *info = (struct ieee_handle *) p; 5257 char code; 5258 5259 switch (size) 5260 { 5261 case 4: 5262 if (info->complex_float_index != 0) 5263 return ieee_push_type (info, info->complex_float_index, size * 2, 5264 FALSE, FALSE); 5265 code = 'c'; 5266 break; 5267 case 12: 5268 case 16: 5269 /* These cases can be output by gcc -gstabs. Outputting the 5270 wrong type is better than crashing. */ 5271 case 8: 5272 if (info->complex_double_index != 0) 5273 return ieee_push_type (info, info->complex_double_index, size * 2, 5274 FALSE, FALSE); 5275 code = 'd'; 5276 break; 5277 default: 5278 fprintf (stderr, _("IEEE unsupported complex type size %u\n"), size); 5279 return FALSE; 5280 } 5281 5282 /* FIXME: I don't know what the string is for. */ 5283 if (! ieee_define_type (info, size * 2, FALSE, FALSE) 5284 || ! ieee_write_number (info, code) 5285 || ! ieee_write_id (info, "")) 5286 return FALSE; 5287 5288 if (size == 4) 5289 info->complex_float_index = info->type_stack->type.indx; 5290 else 5291 info->complex_double_index = info->type_stack->type.indx; 5292 5293 return TRUE; 5294} 5295 5296/* Make a boolean type. IEEE doesn't support these, so we just make 5297 an integer type instead. */ 5298 5299static bfd_boolean 5300ieee_bool_type (void *p, unsigned int size) 5301{ 5302 return ieee_int_type (p, size, TRUE); 5303} 5304 5305/* Make an enumeration. */ 5306 5307static bfd_boolean 5308ieee_enum_type (void *p, const char *tag, const char **names, 5309 bfd_signed_vma *vals) 5310{ 5311 struct ieee_handle *info = (struct ieee_handle *) p; 5312 struct ieee_defined_enum *e; 5313 bfd_boolean localp, simple; 5314 unsigned int indx; 5315 int i = 0; 5316 5317 localp = FALSE; 5318 indx = (unsigned int) -1; 5319 for (e = info->enums; e != NULL; e = e->next) 5320 { 5321 if (tag == NULL) 5322 { 5323 if (e->tag != NULL) 5324 continue; 5325 } 5326 else 5327 { 5328 if (e->tag == NULL 5329 || tag[0] != e->tag[0] 5330 || strcmp (tag, e->tag) != 0) 5331 continue; 5332 } 5333 5334 if (! e->defined) 5335 { 5336 /* This enum tag has been seen but not defined. */ 5337 indx = e->indx; 5338 break; 5339 } 5340 5341 if (names != NULL && e->names != NULL) 5342 { 5343 for (i = 0; names[i] != NULL && e->names[i] != NULL; i++) 5344 { 5345 if (names[i][0] != e->names[i][0] 5346 || vals[i] != e->vals[i] 5347 || strcmp (names[i], e->names[i]) != 0) 5348 break; 5349 } 5350 } 5351 5352 if ((names == NULL && e->names == NULL) 5353 || (names != NULL 5354 && e->names != NULL 5355 && names[i] == NULL 5356 && e->names[i] == NULL)) 5357 { 5358 /* We've seen this enum before. */ 5359 return ieee_push_type (info, e->indx, 0, TRUE, FALSE); 5360 } 5361 5362 if (tag != NULL) 5363 { 5364 /* We've already seen an enum of the same name, so we must make 5365 sure to output this one locally. */ 5366 localp = TRUE; 5367 break; 5368 } 5369 } 5370 5371 /* If this is a simple enumeration, in which the values start at 0 5372 and always increment by 1, we can use type E. Otherwise we must 5373 use type N. */ 5374 5375 simple = TRUE; 5376 if (names != NULL) 5377 { 5378 for (i = 0; names[i] != NULL; i++) 5379 { 5380 if (vals[i] != i) 5381 { 5382 simple = FALSE; 5383 break; 5384 } 5385 } 5386 } 5387 5388 if (! ieee_define_named_type (info, tag, indx, 0, TRUE, localp, 5389 (struct ieee_buflist *) NULL) 5390 || ! ieee_write_number (info, simple ? 'E' : 'N')) 5391 return FALSE; 5392 if (simple) 5393 { 5394 /* FIXME: This is supposed to be the enumeration size, but we 5395 don't store that. */ 5396 if (! ieee_write_number (info, 4)) 5397 return FALSE; 5398 } 5399 if (names != NULL) 5400 { 5401 for (i = 0; names[i] != NULL; i++) 5402 { 5403 if (! ieee_write_id (info, names[i])) 5404 return FALSE; 5405 if (! simple) 5406 { 5407 if (! ieee_write_number (info, vals[i])) 5408 return FALSE; 5409 } 5410 } 5411 } 5412 5413 if (! localp) 5414 { 5415 if (indx == (unsigned int) -1) 5416 { 5417 e = (struct ieee_defined_enum *) xmalloc (sizeof *e); 5418 memset (e, 0, sizeof *e); 5419 e->indx = info->type_stack->type.indx; 5420 e->tag = tag; 5421 5422 e->next = info->enums; 5423 info->enums = e; 5424 } 5425 5426 e->names = names; 5427 e->vals = vals; 5428 e->defined = TRUE; 5429 } 5430 5431 return TRUE; 5432} 5433 5434/* Make a pointer type. */ 5435 5436static bfd_boolean 5437ieee_pointer_type (void *p) 5438{ 5439 struct ieee_handle *info = (struct ieee_handle *) p; 5440 bfd_boolean localp; 5441 unsigned int indx; 5442 struct ieee_modified_type *m = NULL; 5443 5444 localp = info->type_stack->type.localp; 5445 indx = ieee_pop_type (info); 5446 5447 /* A pointer to a simple builtin type can be obtained by adding 32. 5448 FIXME: Will this be a short pointer, and will that matter? */ 5449 if (indx < 32) 5450 return ieee_push_type (info, indx + 32, 0, TRUE, FALSE); 5451 5452 if (! localp) 5453 { 5454 m = ieee_get_modified_info ((struct ieee_handle *) p, indx); 5455 if (m == NULL) 5456 return FALSE; 5457 5458 /* FIXME: The size should depend upon the architecture. */ 5459 if (m->pointer > 0) 5460 return ieee_push_type (info, m->pointer, 4, TRUE, FALSE); 5461 } 5462 5463 if (! ieee_define_type (info, 4, TRUE, localp) 5464 || ! ieee_write_number (info, 'P') 5465 || ! ieee_write_number (info, indx)) 5466 return FALSE; 5467 5468 if (! localp) 5469 m->pointer = info->type_stack->type.indx; 5470 5471 return TRUE; 5472} 5473 5474/* Make a function type. This will be called for a method, but we 5475 don't want to actually add it to the type table in that case. We 5476 handle this by defining the type in a private buffer, and only 5477 adding that buffer to the typedef block if we are going to use it. */ 5478 5479static bfd_boolean 5480ieee_function_type (void *p, int argcount, bfd_boolean varargs) 5481{ 5482 struct ieee_handle *info = (struct ieee_handle *) p; 5483 bfd_boolean localp; 5484 unsigned int *args = NULL; 5485 int i; 5486 unsigned int retindx; 5487 struct ieee_buflist fndef; 5488 struct ieee_modified_type *m; 5489 5490 localp = FALSE; 5491 5492 if (argcount > 0) 5493 { 5494 args = (unsigned int *) xmalloc (argcount * sizeof *args); 5495 for (i = argcount - 1; i >= 0; i--) 5496 { 5497 if (info->type_stack->type.localp) 5498 localp = TRUE; 5499 args[i] = ieee_pop_type (info); 5500 } 5501 } 5502 else if (argcount < 0) 5503 varargs = FALSE; 5504 5505 if (info->type_stack->type.localp) 5506 localp = TRUE; 5507 retindx = ieee_pop_type (info); 5508 5509 m = NULL; 5510 if (argcount < 0 && ! localp) 5511 { 5512 m = ieee_get_modified_info ((struct ieee_handle *) p, retindx); 5513 if (m == NULL) 5514 return FALSE; 5515 5516 if (m->function > 0) 5517 return ieee_push_type (info, m->function, 0, TRUE, FALSE); 5518 } 5519 5520 /* An attribute of 0x41 means that the frame and push mask are 5521 unknown. */ 5522 if (! ieee_init_buffer (info, &fndef) 5523 || ! ieee_define_named_type (info, (const char *) NULL, 5524 (unsigned int) -1, 0, TRUE, localp, 5525 &fndef) 5526 || ! ieee_write_number (info, 'x') 5527 || ! ieee_write_number (info, 0x41) 5528 || ! ieee_write_number (info, 0) 5529 || ! ieee_write_number (info, 0) 5530 || ! ieee_write_number (info, retindx) 5531 || ! ieee_write_number (info, (bfd_vma) argcount + (varargs ? 1 : 0))) 5532 return FALSE; 5533 if (argcount > 0) 5534 { 5535 for (i = 0; i < argcount; i++) 5536 if (! ieee_write_number (info, args[i])) 5537 return FALSE; 5538 free (args); 5539 } 5540 if (varargs) 5541 { 5542 /* A varargs function is represented by writing out the last 5543 argument as type void *, although this makes little sense. */ 5544 if (! ieee_write_number (info, (bfd_vma) builtin_void + 32)) 5545 return FALSE; 5546 } 5547 5548 if (! ieee_write_number (info, 0)) 5549 return FALSE; 5550 5551 /* We wrote the information into fndef, in case we don't need it. 5552 It will be appended to info->types by ieee_pop_type. */ 5553 info->type_stack->type.fndef = fndef; 5554 5555 if (m != NULL) 5556 m->function = info->type_stack->type.indx; 5557 5558 return TRUE; 5559} 5560 5561/* Make a reference type. */ 5562 5563static bfd_boolean 5564ieee_reference_type (void *p) 5565{ 5566 struct ieee_handle *info = (struct ieee_handle *) p; 5567 5568 /* IEEE appears to record a normal pointer type, and then use a 5569 pmisc record to indicate that it is really a reference. */ 5570 5571 if (! ieee_pointer_type (p)) 5572 return FALSE; 5573 info->type_stack->type.referencep = TRUE; 5574 return TRUE; 5575} 5576 5577/* Make a range type. */ 5578 5579static bfd_boolean 5580ieee_range_type (void *p, bfd_signed_vma low, bfd_signed_vma high) 5581{ 5582 struct ieee_handle *info = (struct ieee_handle *) p; 5583 unsigned int size; 5584 bfd_boolean unsignedp, localp; 5585 5586 size = info->type_stack->type.size; 5587 unsignedp = info->type_stack->type.unsignedp; 5588 localp = info->type_stack->type.localp; 5589 ieee_pop_unused_type (info); 5590 return (ieee_define_type (info, size, unsignedp, localp) 5591 && ieee_write_number (info, 'R') 5592 && ieee_write_number (info, (bfd_vma) low) 5593 && ieee_write_number (info, (bfd_vma) high) 5594 && ieee_write_number (info, unsignedp ? 0 : 1) 5595 && ieee_write_number (info, size)); 5596} 5597 5598/* Make an array type. */ 5599 5600static bfd_boolean 5601ieee_array_type (void *p, bfd_signed_vma low, bfd_signed_vma high, 5602 bfd_boolean stringp ATTRIBUTE_UNUSED) 5603{ 5604 struct ieee_handle *info = (struct ieee_handle *) p; 5605 unsigned int eleindx; 5606 bfd_boolean localp; 5607 unsigned int size; 5608 struct ieee_modified_type *m = NULL; 5609 struct ieee_modified_array_type *a; 5610 5611 /* IEEE does not store the range, so we just ignore it. */ 5612 ieee_pop_unused_type (info); 5613 localp = info->type_stack->type.localp; 5614 size = info->type_stack->type.size; 5615 eleindx = ieee_pop_type (info); 5616 5617 /* If we don't know the range, treat the size as exactly one 5618 element. */ 5619 if (low < high) 5620 size *= (high - low) + 1; 5621 5622 if (! localp) 5623 { 5624 m = ieee_get_modified_info (info, eleindx); 5625 if (m == NULL) 5626 return FALSE; 5627 5628 for (a = m->arrays; a != NULL; a = a->next) 5629 { 5630 if (a->low == low && a->high == high) 5631 return ieee_push_type (info, a->indx, size, FALSE, FALSE); 5632 } 5633 } 5634 5635 if (! ieee_define_type (info, size, FALSE, localp) 5636 || ! ieee_write_number (info, low == 0 ? 'Z' : 'C') 5637 || ! ieee_write_number (info, eleindx)) 5638 return FALSE; 5639 if (low != 0) 5640 { 5641 if (! ieee_write_number (info, low)) 5642 return FALSE; 5643 } 5644 5645 if (! ieee_write_number (info, high + 1)) 5646 return FALSE; 5647 5648 if (! localp) 5649 { 5650 a = (struct ieee_modified_array_type *) xmalloc (sizeof *a); 5651 memset (a, 0, sizeof *a); 5652 5653 a->indx = info->type_stack->type.indx; 5654 a->low = low; 5655 a->high = high; 5656 5657 a->next = m->arrays; 5658 m->arrays = a; 5659 } 5660 5661 return TRUE; 5662} 5663 5664/* Make a set type. */ 5665 5666static bfd_boolean 5667ieee_set_type (void *p, bfd_boolean bitstringp ATTRIBUTE_UNUSED) 5668{ 5669 struct ieee_handle *info = (struct ieee_handle *) p; 5670 bfd_boolean localp; 5671 unsigned int eleindx; 5672 5673 localp = info->type_stack->type.localp; 5674 eleindx = ieee_pop_type (info); 5675 5676 /* FIXME: We don't know the size, so we just use 4. */ 5677 5678 return (ieee_define_type (info, 0, TRUE, localp) 5679 && ieee_write_number (info, 's') 5680 && ieee_write_number (info, 4) 5681 && ieee_write_number (info, eleindx)); 5682} 5683 5684/* Make an offset type. */ 5685 5686static bfd_boolean 5687ieee_offset_type (void *p) 5688{ 5689 /* FIXME: The MRI C++ compiler does not appear to generate any 5690 useful type information about an offset type. It just records a 5691 pointer to member as an integer. The MRI/HP IEEE spec does 5692 describe a pmisc record which can be used for a pointer to 5693 member. Unfortunately, it does not describe the target type, 5694 which seems pretty important. I'm going to punt this for now. */ 5695 5696 return ieee_int_type (p, 4, TRUE); 5697} 5698 5699/* Make a method type. */ 5700 5701static bfd_boolean 5702ieee_method_type (void *p, bfd_boolean domain, int argcount, 5703 bfd_boolean varargs) 5704{ 5705 struct ieee_handle *info = (struct ieee_handle *) p; 5706 5707 /* FIXME: The MRI/HP IEEE spec defines a pmisc record to use for a 5708 method, but the definition is incomplete. We just output an 'x' 5709 type. */ 5710 5711 if (domain) 5712 ieee_pop_unused_type (info); 5713 5714 return ieee_function_type (p, argcount, varargs); 5715} 5716 5717/* Make a const qualified type. */ 5718 5719static bfd_boolean 5720ieee_const_type (void *p) 5721{ 5722 struct ieee_handle *info = (struct ieee_handle *) p; 5723 unsigned int size; 5724 bfd_boolean unsignedp, localp; 5725 unsigned int indx; 5726 struct ieee_modified_type *m = NULL; 5727 5728 size = info->type_stack->type.size; 5729 unsignedp = info->type_stack->type.unsignedp; 5730 localp = info->type_stack->type.localp; 5731 indx = ieee_pop_type (info); 5732 5733 if (! localp) 5734 { 5735 m = ieee_get_modified_info (info, indx); 5736 if (m == NULL) 5737 return FALSE; 5738 5739 if (m->const_qualified > 0) 5740 return ieee_push_type (info, m->const_qualified, size, unsignedp, 5741 FALSE); 5742 } 5743 5744 if (! ieee_define_type (info, size, unsignedp, localp) 5745 || ! ieee_write_number (info, 'n') 5746 || ! ieee_write_number (info, 1) 5747 || ! ieee_write_number (info, indx)) 5748 return FALSE; 5749 5750 if (! localp) 5751 m->const_qualified = info->type_stack->type.indx; 5752 5753 return TRUE; 5754} 5755 5756/* Make a volatile qualified type. */ 5757 5758static bfd_boolean 5759ieee_volatile_type (void *p) 5760{ 5761 struct ieee_handle *info = (struct ieee_handle *) p; 5762 unsigned int size; 5763 bfd_boolean unsignedp, localp; 5764 unsigned int indx; 5765 struct ieee_modified_type *m = NULL; 5766 5767 size = info->type_stack->type.size; 5768 unsignedp = info->type_stack->type.unsignedp; 5769 localp = info->type_stack->type.localp; 5770 indx = ieee_pop_type (info); 5771 5772 if (! localp) 5773 { 5774 m = ieee_get_modified_info (info, indx); 5775 if (m == NULL) 5776 return FALSE; 5777 5778 if (m->volatile_qualified > 0) 5779 return ieee_push_type (info, m->volatile_qualified, size, unsignedp, 5780 FALSE); 5781 } 5782 5783 if (! ieee_define_type (info, size, unsignedp, localp) 5784 || ! ieee_write_number (info, 'n') 5785 || ! ieee_write_number (info, 2) 5786 || ! ieee_write_number (info, indx)) 5787 return FALSE; 5788 5789 if (! localp) 5790 m->volatile_qualified = info->type_stack->type.indx; 5791 5792 return TRUE; 5793} 5794 5795/* Convert an enum debug_visibility into a CXXFLAGS value. */ 5796 5797static unsigned int 5798ieee_vis_to_flags (enum debug_visibility visibility) 5799{ 5800 switch (visibility) 5801 { 5802 default: 5803 abort (); 5804 case DEBUG_VISIBILITY_PUBLIC: 5805 return CXXFLAGS_VISIBILITY_PUBLIC; 5806 case DEBUG_VISIBILITY_PRIVATE: 5807 return CXXFLAGS_VISIBILITY_PRIVATE; 5808 case DEBUG_VISIBILITY_PROTECTED: 5809 return CXXFLAGS_VISIBILITY_PROTECTED; 5810 } 5811 /*NOTREACHED*/ 5812} 5813 5814/* Start defining a struct type. We build it in the strdef field on 5815 the stack, to avoid confusing type definitions required by the 5816 fields with the struct type itself. */ 5817 5818static bfd_boolean 5819ieee_start_struct_type (void *p, const char *tag, unsigned int id, 5820 bfd_boolean structp, unsigned int size) 5821{ 5822 struct ieee_handle *info = (struct ieee_handle *) p; 5823 bfd_boolean localp, ignorep; 5824 bfd_boolean copy; 5825 char ab[20]; 5826 const char *look; 5827 struct ieee_name_type_hash_entry *h; 5828 struct ieee_name_type *nt, *ntlook; 5829 struct ieee_buflist strdef; 5830 5831 localp = FALSE; 5832 ignorep = FALSE; 5833 5834 /* We need to create a tag for internal use even if we don't want 5835 one for external use. This will let us refer to an anonymous 5836 struct. */ 5837 if (tag != NULL) 5838 { 5839 look = tag; 5840 copy = FALSE; 5841 } 5842 else 5843 { 5844 sprintf (ab, "__anon%u", id); 5845 look = ab; 5846 copy = TRUE; 5847 } 5848 5849 /* If we already have references to the tag, we must use the 5850 existing type index. */ 5851 h = ieee_name_type_hash_lookup (&info->tags, look, TRUE, copy); 5852 if (h == NULL) 5853 return FALSE; 5854 5855 nt = NULL; 5856 for (ntlook = h->types; ntlook != NULL; ntlook = ntlook->next) 5857 { 5858 if (ntlook->id == id) 5859 nt = ntlook; 5860 else if (! ntlook->type.localp) 5861 { 5862 /* We are creating a duplicate definition of a globally 5863 defined tag. Force it to be local to avoid 5864 confusion. */ 5865 localp = TRUE; 5866 } 5867 } 5868 5869 if (nt != NULL) 5870 { 5871 assert (localp == nt->type.localp); 5872 if (nt->kind == DEBUG_KIND_ILLEGAL && ! localp) 5873 { 5874 /* We've already seen a global definition of the type. 5875 Ignore this new definition. */ 5876 ignorep = TRUE; 5877 } 5878 } 5879 else 5880 { 5881 nt = (struct ieee_name_type *) xmalloc (sizeof *nt); 5882 memset (nt, 0, sizeof *nt); 5883 nt->id = id; 5884 nt->type.name = h->root.string; 5885 nt->next = h->types; 5886 h->types = nt; 5887 nt->type.indx = info->type_indx; 5888 ++info->type_indx; 5889 } 5890 5891 nt->kind = DEBUG_KIND_ILLEGAL; 5892 5893 if (! ieee_init_buffer (info, &strdef) 5894 || ! ieee_define_named_type (info, tag, nt->type.indx, size, TRUE, 5895 localp, &strdef) 5896 || ! ieee_write_number (info, structp ? 'S' : 'U') 5897 || ! ieee_write_number (info, size)) 5898 return FALSE; 5899 5900 if (! ignorep) 5901 { 5902 const char *hold; 5903 5904 /* We never want nt->type.name to be NULL. We want the rest of 5905 the type to be the object set up on the type stack; it will 5906 have a NULL name if tag is NULL. */ 5907 hold = nt->type.name; 5908 nt->type = info->type_stack->type; 5909 nt->type.name = hold; 5910 } 5911 5912 info->type_stack->type.name = tag; 5913 info->type_stack->type.strdef = strdef; 5914 info->type_stack->type.ignorep = ignorep; 5915 5916 return TRUE; 5917} 5918 5919/* Add a field to a struct. */ 5920 5921static bfd_boolean 5922ieee_struct_field (void *p, const char *name, bfd_vma bitpos, bfd_vma bitsize, 5923 enum debug_visibility visibility) 5924{ 5925 struct ieee_handle *info = (struct ieee_handle *) p; 5926 unsigned int size; 5927 bfd_boolean unsignedp; 5928 bfd_boolean referencep; 5929 bfd_boolean localp; 5930 unsigned int indx; 5931 bfd_vma offset; 5932 5933 assert (info->type_stack != NULL 5934 && info->type_stack->next != NULL 5935 && ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef)); 5936 5937 /* If we are ignoring this struct definition, just pop and ignore 5938 the type. */ 5939 if (info->type_stack->next->type.ignorep) 5940 { 5941 ieee_pop_unused_type (info); 5942 return TRUE; 5943 } 5944 5945 size = info->type_stack->type.size; 5946 unsignedp = info->type_stack->type.unsignedp; 5947 referencep = info->type_stack->type.referencep; 5948 localp = info->type_stack->type.localp; 5949 indx = ieee_pop_type (info); 5950 5951 if (localp) 5952 info->type_stack->type.localp = TRUE; 5953 5954 if (info->type_stack->type.classdef != NULL) 5955 { 5956 unsigned int flags; 5957 unsigned int nindx; 5958 5959 /* This is a class. We must add a description of this field to 5960 the class records we are building. */ 5961 5962 flags = ieee_vis_to_flags (visibility); 5963 nindx = info->type_stack->type.classdef->indx; 5964 if (! ieee_change_buffer (info, 5965 &info->type_stack->type.classdef->pmiscbuf) 5966 || ! ieee_write_asn (info, nindx, 'd') 5967 || ! ieee_write_asn (info, nindx, flags) 5968 || ! ieee_write_atn65 (info, nindx, name) 5969 || ! ieee_write_atn65 (info, nindx, name)) 5970 return FALSE; 5971 info->type_stack->type.classdef->pmisccount += 4; 5972 5973 if (referencep) 5974 { 5975 /* We need to output a record recording that this field is 5976 really of reference type. We put this on the refs field 5977 of classdef, so that it can be appended to the C++ 5978 records after the class is defined. */ 5979 5980 nindx = info->name_indx; 5981 ++info->name_indx; 5982 5983 if (! ieee_change_buffer (info, 5984 &info->type_stack->type.classdef->refs) 5985 || ! ieee_write_byte (info, (int) ieee_nn_record) 5986 || ! ieee_write_number (info, nindx) 5987 || ! ieee_write_id (info, "") 5988 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum) 5989 || ! ieee_write_number (info, nindx) 5990 || ! ieee_write_number (info, 0) 5991 || ! ieee_write_number (info, 62) 5992 || ! ieee_write_number (info, 80) 5993 || ! ieee_write_number (info, 4) 5994 || ! ieee_write_asn (info, nindx, 'R') 5995 || ! ieee_write_asn (info, nindx, 3) 5996 || ! ieee_write_atn65 (info, nindx, info->type_stack->type.name) 5997 || ! ieee_write_atn65 (info, nindx, name)) 5998 return FALSE; 5999 } 6000 } 6001 6002 /* If the bitsize doesn't match the expected size, we need to output 6003 a bitfield type. */ 6004 if (size == 0 || bitsize == 0 || bitsize == size * 8) 6005 offset = bitpos / 8; 6006 else 6007 { 6008 if (! ieee_define_type (info, 0, unsignedp, 6009 info->type_stack->type.localp) 6010 || ! ieee_write_number (info, 'g') 6011 || ! ieee_write_number (info, unsignedp ? 0 : 1) 6012 || ! ieee_write_number (info, bitsize) 6013 || ! ieee_write_number (info, indx)) 6014 return FALSE; 6015 indx = ieee_pop_type (info); 6016 offset = bitpos; 6017 } 6018 6019 /* Switch to the struct we are building in order to output this 6020 field definition. */ 6021 return (ieee_change_buffer (info, &info->type_stack->type.strdef) 6022 && ieee_write_id (info, name) 6023 && ieee_write_number (info, indx) 6024 && ieee_write_number (info, offset)); 6025} 6026 6027/* Finish up a struct type. */ 6028 6029static bfd_boolean 6030ieee_end_struct_type (void *p) 6031{ 6032 struct ieee_handle *info = (struct ieee_handle *) p; 6033 struct ieee_buflist *pb; 6034 6035 assert (info->type_stack != NULL 6036 && ! ieee_buffer_emptyp (&info->type_stack->type.strdef)); 6037 6038 /* If we were ignoring this struct definition because it was a 6039 duplicate definition, just through away whatever bytes we have 6040 accumulated. Leave the type on the stack. */ 6041 if (info->type_stack->type.ignorep) 6042 return TRUE; 6043 6044 /* If this is not a duplicate definition of this tag, then localp 6045 will be FALSE, and we can put it in the global type block. 6046 FIXME: We should avoid outputting duplicate definitions which are 6047 the same. */ 6048 if (! info->type_stack->type.localp) 6049 { 6050 /* Make sure we have started the global type block. */ 6051 if (ieee_buffer_emptyp (&info->global_types)) 6052 { 6053 if (! ieee_change_buffer (info, &info->global_types) 6054 || ! ieee_write_byte (info, (int) ieee_bb_record_enum) 6055 || ! ieee_write_byte (info, 2) 6056 || ! ieee_write_number (info, 0) 6057 || ! ieee_write_id (info, "")) 6058 return FALSE; 6059 } 6060 pb = &info->global_types; 6061 } 6062 else 6063 { 6064 /* Make sure we have started the types block. */ 6065 if (ieee_buffer_emptyp (&info->types)) 6066 { 6067 if (! ieee_change_buffer (info, &info->types) 6068 || ! ieee_write_byte (info, (int) ieee_bb_record_enum) 6069 || ! ieee_write_byte (info, 1) 6070 || ! ieee_write_number (info, 0) 6071 || ! ieee_write_id (info, info->modname)) 6072 return FALSE; 6073 } 6074 pb = &info->types; 6075 } 6076 6077 /* Append the struct definition to the types. */ 6078 if (! ieee_append_buffer (info, pb, &info->type_stack->type.strdef) 6079 || ! ieee_init_buffer (info, &info->type_stack->type.strdef)) 6080 return FALSE; 6081 6082 /* Leave the struct on the type stack. */ 6083 6084 return TRUE; 6085} 6086 6087/* Start a class type. */ 6088 6089static bfd_boolean 6090ieee_start_class_type (void *p, const char *tag, unsigned int id, 6091 bfd_boolean structp, unsigned int size, 6092 bfd_boolean vptr, bfd_boolean ownvptr) 6093{ 6094 struct ieee_handle *info = (struct ieee_handle *) p; 6095 const char *vclass; 6096 struct ieee_buflist pmiscbuf; 6097 unsigned int indx; 6098 struct ieee_type_class *classdef; 6099 6100 /* A C++ class is output as a C++ struct along with a set of pmisc 6101 records describing the class. */ 6102 6103 /* We need to have a name so that we can associate the struct and 6104 the class. */ 6105 if (tag == NULL) 6106 { 6107 char *t; 6108 6109 t = (char *) xmalloc (20); 6110 sprintf (t, "__anon%u", id); 6111 tag = t; 6112 } 6113 6114 /* We can't write out the virtual table information until we have 6115 finished the class, because we don't know the virtual table size. 6116 We get the size from the largest voffset we see. */ 6117 vclass = NULL; 6118 if (vptr && ! ownvptr) 6119 { 6120 vclass = info->type_stack->type.name; 6121 assert (vclass != NULL); 6122 /* We don't call ieee_pop_unused_type, since the class should 6123 get defined. */ 6124 (void) ieee_pop_type (info); 6125 } 6126 6127 if (! ieee_start_struct_type (p, tag, id, structp, size)) 6128 return FALSE; 6129 6130 indx = info->name_indx; 6131 ++info->name_indx; 6132 6133 /* We write out pmisc records into the classdef field. We will 6134 write out the pmisc start after we know the number of records we 6135 need. */ 6136 if (! ieee_init_buffer (info, &pmiscbuf) 6137 || ! ieee_change_buffer (info, &pmiscbuf) 6138 || ! ieee_write_asn (info, indx, 'T') 6139 || ! ieee_write_asn (info, indx, structp ? 'o' : 'u') 6140 || ! ieee_write_atn65 (info, indx, tag)) 6141 return FALSE; 6142 6143 classdef = (struct ieee_type_class *) xmalloc (sizeof *classdef); 6144 memset (classdef, 0, sizeof *classdef); 6145 6146 classdef->indx = indx; 6147 classdef->pmiscbuf = pmiscbuf; 6148 classdef->pmisccount = 3; 6149 classdef->vclass = vclass; 6150 classdef->ownvptr = ownvptr; 6151 6152 info->type_stack->type.classdef = classdef; 6153 6154 return TRUE; 6155} 6156 6157/* Add a static member to a class. */ 6158 6159static bfd_boolean 6160ieee_class_static_member (void *p, const char *name, const char *physname, 6161 enum debug_visibility visibility) 6162{ 6163 struct ieee_handle *info = (struct ieee_handle *) p; 6164 unsigned int flags; 6165 unsigned int nindx; 6166 6167 /* We don't care about the type. Hopefully there will be a call to 6168 ieee_variable declaring the physical name and the type, since 6169 that is where an IEEE consumer must get the type. */ 6170 ieee_pop_unused_type (info); 6171 6172 assert (info->type_stack != NULL 6173 && info->type_stack->type.classdef != NULL); 6174 6175 flags = ieee_vis_to_flags (visibility); 6176 flags |= CXXFLAGS_STATIC; 6177 6178 nindx = info->type_stack->type.classdef->indx; 6179 6180 if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf) 6181 || ! ieee_write_asn (info, nindx, 'd') 6182 || ! ieee_write_asn (info, nindx, flags) 6183 || ! ieee_write_atn65 (info, nindx, name) 6184 || ! ieee_write_atn65 (info, nindx, physname)) 6185 return FALSE; 6186 info->type_stack->type.classdef->pmisccount += 4; 6187 6188 return TRUE; 6189} 6190 6191/* Add a base class to a class. */ 6192 6193static bfd_boolean 6194ieee_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean is_virtual, 6195 enum debug_visibility visibility) 6196{ 6197 struct ieee_handle *info = (struct ieee_handle *) p; 6198 const char *bname; 6199 bfd_boolean localp; 6200 unsigned int bindx; 6201 char *fname; 6202 unsigned int flags; 6203 unsigned int nindx; 6204 6205 assert (info->type_stack != NULL 6206 && info->type_stack->type.name != NULL 6207 && info->type_stack->next != NULL 6208 && info->type_stack->next->type.classdef != NULL 6209 && ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef)); 6210 6211 bname = info->type_stack->type.name; 6212 localp = info->type_stack->type.localp; 6213 bindx = ieee_pop_type (info); 6214 6215 /* We are currently defining both a struct and a class. We must 6216 write out a field definition in the struct which holds the base 6217 class. The stabs debugging reader will create a field named 6218 _vb$CLASS for a virtual base class, so we just use that. FIXME: 6219 we should not depend upon a detail of stabs debugging. */ 6220 if (is_virtual) 6221 { 6222 fname = (char *) xmalloc (strlen (bname) + sizeof "_vb$"); 6223 sprintf (fname, "_vb$%s", bname); 6224 flags = BASEFLAGS_VIRTUAL; 6225 } 6226 else 6227 { 6228 if (localp) 6229 info->type_stack->type.localp = TRUE; 6230 6231 fname = (char *) xmalloc (strlen (bname) + sizeof "_b$"); 6232 sprintf (fname, "_b$%s", bname); 6233 6234 if (! ieee_change_buffer (info, &info->type_stack->type.strdef) 6235 || ! ieee_write_id (info, fname) 6236 || ! ieee_write_number (info, bindx) 6237 || ! ieee_write_number (info, bitpos / 8)) 6238 return FALSE; 6239 flags = 0; 6240 } 6241 6242 if (visibility == DEBUG_VISIBILITY_PRIVATE) 6243 flags |= BASEFLAGS_PRIVATE; 6244 6245 nindx = info->type_stack->type.classdef->indx; 6246 6247 if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf) 6248 || ! ieee_write_asn (info, nindx, 'b') 6249 || ! ieee_write_asn (info, nindx, flags) 6250 || ! ieee_write_atn65 (info, nindx, bname) 6251 || ! ieee_write_asn (info, nindx, 0) 6252 || ! ieee_write_atn65 (info, nindx, fname)) 6253 return FALSE; 6254 info->type_stack->type.classdef->pmisccount += 5; 6255 6256 free (fname); 6257 6258 return TRUE; 6259} 6260 6261/* Start building a method for a class. */ 6262 6263static bfd_boolean 6264ieee_class_start_method (void *p, const char *name) 6265{ 6266 struct ieee_handle *info = (struct ieee_handle *) p; 6267 6268 assert (info->type_stack != NULL 6269 && info->type_stack->type.classdef != NULL 6270 && info->type_stack->type.classdef->method == NULL); 6271 6272 info->type_stack->type.classdef->method = name; 6273 6274 return TRUE; 6275} 6276 6277/* Define a new method variant, either static or not. */ 6278 6279static bfd_boolean 6280ieee_class_method_var (struct ieee_handle *info, const char *physname, 6281 enum debug_visibility visibility, 6282 bfd_boolean staticp, bfd_boolean constp, 6283 bfd_boolean volatilep, bfd_vma voffset, 6284 bfd_boolean context) 6285{ 6286 unsigned int flags; 6287 unsigned int nindx; 6288 bfd_boolean is_virtual; 6289 6290 /* We don't need the type of the method. An IEEE consumer which 6291 wants the type must track down the function by the physical name 6292 and get the type from that. */ 6293 ieee_pop_unused_type (info); 6294 6295 /* We don't use the context. FIXME: We probably ought to use it to 6296 adjust the voffset somehow, but I don't really know how. */ 6297 if (context) 6298 ieee_pop_unused_type (info); 6299 6300 assert (info->type_stack != NULL 6301 && info->type_stack->type.classdef != NULL 6302 && info->type_stack->type.classdef->method != NULL); 6303 6304 flags = ieee_vis_to_flags (visibility); 6305 6306 /* FIXME: We never set CXXFLAGS_OVERRIDE, CXXFLAGS_OPERATOR, 6307 CXXFLAGS_CTORDTOR, CXXFLAGS_CTOR, or CXXFLAGS_INLINE. */ 6308 6309 if (staticp) 6310 flags |= CXXFLAGS_STATIC; 6311 if (constp) 6312 flags |= CXXFLAGS_CONST; 6313 if (volatilep) 6314 flags |= CXXFLAGS_VOLATILE; 6315 6316 nindx = info->type_stack->type.classdef->indx; 6317 6318 is_virtual = context || voffset > 0; 6319 6320 if (! ieee_change_buffer (info, 6321 &info->type_stack->type.classdef->pmiscbuf) 6322 || ! ieee_write_asn (info, nindx, is_virtual ? 'v' : 'm') 6323 || ! ieee_write_asn (info, nindx, flags) 6324 || ! ieee_write_atn65 (info, nindx, 6325 info->type_stack->type.classdef->method) 6326 || ! ieee_write_atn65 (info, nindx, physname)) 6327 return FALSE; 6328 6329 if (is_virtual) 6330 { 6331 if (voffset > info->type_stack->type.classdef->voffset) 6332 info->type_stack->type.classdef->voffset = voffset; 6333 if (! ieee_write_asn (info, nindx, voffset)) 6334 return FALSE; 6335 ++info->type_stack->type.classdef->pmisccount; 6336 } 6337 6338 if (! ieee_write_asn (info, nindx, 0)) 6339 return FALSE; 6340 6341 info->type_stack->type.classdef->pmisccount += 5; 6342 6343 return TRUE; 6344} 6345 6346/* Define a new method variant. */ 6347 6348static bfd_boolean 6349ieee_class_method_variant (void *p, const char *physname, 6350 enum debug_visibility visibility, 6351 bfd_boolean constp, bfd_boolean volatilep, 6352 bfd_vma voffset, bfd_boolean context) 6353{ 6354 struct ieee_handle *info = (struct ieee_handle *) p; 6355 6356 return ieee_class_method_var (info, physname, visibility, FALSE, constp, 6357 volatilep, voffset, context); 6358} 6359 6360/* Define a new static method variant. */ 6361 6362static bfd_boolean 6363ieee_class_static_method_variant (void *p, const char *physname, 6364 enum debug_visibility visibility, 6365 bfd_boolean constp, bfd_boolean volatilep) 6366{ 6367 struct ieee_handle *info = (struct ieee_handle *) p; 6368 6369 return ieee_class_method_var (info, physname, visibility, TRUE, constp, 6370 volatilep, 0, FALSE); 6371} 6372 6373/* Finish up a method. */ 6374 6375static bfd_boolean 6376ieee_class_end_method (void *p) 6377{ 6378 struct ieee_handle *info = (struct ieee_handle *) p; 6379 6380 assert (info->type_stack != NULL 6381 && info->type_stack->type.classdef != NULL 6382 && info->type_stack->type.classdef->method != NULL); 6383 6384 info->type_stack->type.classdef->method = NULL; 6385 6386 return TRUE; 6387} 6388 6389/* Finish up a class. */ 6390 6391static bfd_boolean 6392ieee_end_class_type (void *p) 6393{ 6394 struct ieee_handle *info = (struct ieee_handle *) p; 6395 unsigned int nindx; 6396 6397 assert (info->type_stack != NULL 6398 && info->type_stack->type.classdef != NULL); 6399 6400 /* If we were ignoring this class definition because it was a 6401 duplicate definition, just through away whatever bytes we have 6402 accumulated. Leave the type on the stack. */ 6403 if (info->type_stack->type.ignorep) 6404 return TRUE; 6405 6406 nindx = info->type_stack->type.classdef->indx; 6407 6408 /* If we have a virtual table, we can write out the information now. */ 6409 if (info->type_stack->type.classdef->vclass != NULL 6410 || info->type_stack->type.classdef->ownvptr) 6411 { 6412 if (! ieee_change_buffer (info, 6413 &info->type_stack->type.classdef->pmiscbuf) 6414 || ! ieee_write_asn (info, nindx, 'z') 6415 || ! ieee_write_atn65 (info, nindx, "") 6416 || ! ieee_write_asn (info, nindx, 6417 info->type_stack->type.classdef->voffset)) 6418 return FALSE; 6419 if (info->type_stack->type.classdef->ownvptr) 6420 { 6421 if (! ieee_write_atn65 (info, nindx, "")) 6422 return FALSE; 6423 } 6424 else 6425 { 6426 if (! ieee_write_atn65 (info, nindx, 6427 info->type_stack->type.classdef->vclass)) 6428 return FALSE; 6429 } 6430 if (! ieee_write_asn (info, nindx, 0)) 6431 return FALSE; 6432 info->type_stack->type.classdef->pmisccount += 5; 6433 } 6434 6435 /* Now that we know the number of pmisc records, we can write out 6436 the atn62 which starts the pmisc records, and append them to the 6437 C++ buffers. */ 6438 6439 if (! ieee_change_buffer (info, &info->cxx) 6440 || ! ieee_write_byte (info, (int) ieee_nn_record) 6441 || ! ieee_write_number (info, nindx) 6442 || ! ieee_write_id (info, "") 6443 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum) 6444 || ! ieee_write_number (info, nindx) 6445 || ! ieee_write_number (info, 0) 6446 || ! ieee_write_number (info, 62) 6447 || ! ieee_write_number (info, 80) 6448 || ! ieee_write_number (info, 6449 info->type_stack->type.classdef->pmisccount)) 6450 return FALSE; 6451 6452 if (! ieee_append_buffer (info, &info->cxx, 6453 &info->type_stack->type.classdef->pmiscbuf)) 6454 return FALSE; 6455 if (! ieee_buffer_emptyp (&info->type_stack->type.classdef->refs)) 6456 { 6457 if (! ieee_append_buffer (info, &info->cxx, 6458 &info->type_stack->type.classdef->refs)) 6459 return FALSE; 6460 } 6461 6462 return ieee_end_struct_type (p); 6463} 6464 6465/* Push a previously seen typedef onto the type stack. */ 6466 6467static bfd_boolean 6468ieee_typedef_type (void *p, const char *name) 6469{ 6470 struct ieee_handle *info = (struct ieee_handle *) p; 6471 struct ieee_name_type_hash_entry *h; 6472 struct ieee_name_type *nt; 6473 6474 h = ieee_name_type_hash_lookup (&info->typedefs, name, FALSE, FALSE); 6475 6476 /* h should never be NULL, since that would imply that the generic 6477 debugging code has asked for a typedef which it has not yet 6478 defined. */ 6479 assert (h != NULL); 6480 6481 /* We always use the most recently defined type for this name, which 6482 will be the first one on the list. */ 6483 6484 nt = h->types; 6485 if (! ieee_push_type (info, nt->type.indx, nt->type.size, 6486 nt->type.unsignedp, nt->type.localp)) 6487 return FALSE; 6488 6489 /* Copy over any other type information we may have. */ 6490 info->type_stack->type = nt->type; 6491 6492 return TRUE; 6493} 6494 6495/* Push a tagged type onto the type stack. */ 6496 6497static bfd_boolean 6498ieee_tag_type (void *p, const char *name, unsigned int id, 6499 enum debug_type_kind kind) 6500{ 6501 struct ieee_handle *info = (struct ieee_handle *) p; 6502 bfd_boolean localp; 6503 bfd_boolean copy; 6504 char ab[20]; 6505 struct ieee_name_type_hash_entry *h; 6506 struct ieee_name_type *nt; 6507 6508 if (kind == DEBUG_KIND_ENUM) 6509 { 6510 struct ieee_defined_enum *e; 6511 6512 if (name == NULL) 6513 abort (); 6514 for (e = info->enums; e != NULL; e = e->next) 6515 if (e->tag != NULL && strcmp (e->tag, name) == 0) 6516 return ieee_push_type (info, e->indx, 0, TRUE, FALSE); 6517 6518 e = (struct ieee_defined_enum *) xmalloc (sizeof *e); 6519 memset (e, 0, sizeof *e); 6520 6521 e->indx = info->type_indx; 6522 ++info->type_indx; 6523 e->tag = name; 6524 e->defined = FALSE; 6525 6526 e->next = info->enums; 6527 info->enums = e; 6528 6529 return ieee_push_type (info, e->indx, 0, TRUE, FALSE); 6530 } 6531 6532 localp = FALSE; 6533 6534 copy = FALSE; 6535 if (name == NULL) 6536 { 6537 sprintf (ab, "__anon%u", id); 6538 name = ab; 6539 copy = TRUE; 6540 } 6541 6542 h = ieee_name_type_hash_lookup (&info->tags, name, TRUE, copy); 6543 if (h == NULL) 6544 return FALSE; 6545 6546 for (nt = h->types; nt != NULL; nt = nt->next) 6547 { 6548 if (nt->id == id) 6549 { 6550 if (! ieee_push_type (info, nt->type.indx, nt->type.size, 6551 nt->type.unsignedp, nt->type.localp)) 6552 return FALSE; 6553 /* Copy over any other type information we may have. */ 6554 info->type_stack->type = nt->type; 6555 return TRUE; 6556 } 6557 6558 if (! nt->type.localp) 6559 { 6560 /* This is a duplicate of a global type, so it must be 6561 local. */ 6562 localp = TRUE; 6563 } 6564 } 6565 6566 nt = (struct ieee_name_type *) xmalloc (sizeof *nt); 6567 memset (nt, 0, sizeof *nt); 6568 6569 nt->id = id; 6570 nt->type.name = h->root.string; 6571 nt->type.indx = info->type_indx; 6572 nt->type.localp = localp; 6573 ++info->type_indx; 6574 nt->kind = kind; 6575 6576 nt->next = h->types; 6577 h->types = nt; 6578 6579 if (! ieee_push_type (info, nt->type.indx, 0, FALSE, localp)) 6580 return FALSE; 6581 6582 info->type_stack->type.name = h->root.string; 6583 6584 return TRUE; 6585} 6586 6587/* Output a typedef. */ 6588 6589static bfd_boolean 6590ieee_typdef (void *p, const char *name) 6591{ 6592 struct ieee_handle *info = (struct ieee_handle *) p; 6593 struct ieee_write_type type; 6594 unsigned int indx; 6595 bfd_boolean found; 6596 bfd_boolean localp; 6597 struct ieee_name_type_hash_entry *h; 6598 struct ieee_name_type *nt; 6599 6600 type = info->type_stack->type; 6601 indx = type.indx; 6602 6603 /* If this is a simple builtin type using a builtin name, we don't 6604 want to output the typedef itself. We also want to change the 6605 type index to correspond to the name being used. We recognize 6606 names used in stabs debugging output even if they don't exactly 6607 correspond to the names used for the IEEE builtin types. */ 6608 found = FALSE; 6609 if (indx <= (unsigned int) builtin_bcd_float) 6610 { 6611 switch ((enum builtin_types) indx) 6612 { 6613 default: 6614 break; 6615 6616 case builtin_void: 6617 if (strcmp (name, "void") == 0) 6618 found = TRUE; 6619 break; 6620 6621 case builtin_signed_char: 6622 case builtin_char: 6623 if (strcmp (name, "signed char") == 0) 6624 { 6625 indx = (unsigned int) builtin_signed_char; 6626 found = TRUE; 6627 } 6628 else if (strcmp (name, "char") == 0) 6629 { 6630 indx = (unsigned int) builtin_char; 6631 found = TRUE; 6632 } 6633 break; 6634 6635 case builtin_unsigned_char: 6636 if (strcmp (name, "unsigned char") == 0) 6637 found = TRUE; 6638 break; 6639 6640 case builtin_signed_short_int: 6641 case builtin_short: 6642 case builtin_short_int: 6643 case builtin_signed_short: 6644 if (strcmp (name, "signed short int") == 0) 6645 { 6646 indx = (unsigned int) builtin_signed_short_int; 6647 found = TRUE; 6648 } 6649 else if (strcmp (name, "short") == 0) 6650 { 6651 indx = (unsigned int) builtin_short; 6652 found = TRUE; 6653 } 6654 else if (strcmp (name, "short int") == 0) 6655 { 6656 indx = (unsigned int) builtin_short_int; 6657 found = TRUE; 6658 } 6659 else if (strcmp (name, "signed short") == 0) 6660 { 6661 indx = (unsigned int) builtin_signed_short; 6662 found = TRUE; 6663 } 6664 break; 6665 6666 case builtin_unsigned_short_int: 6667 case builtin_unsigned_short: 6668 if (strcmp (name, "unsigned short int") == 0 6669 || strcmp (name, "short unsigned int") == 0) 6670 { 6671 indx = builtin_unsigned_short_int; 6672 found = TRUE; 6673 } 6674 else if (strcmp (name, "unsigned short") == 0) 6675 { 6676 indx = builtin_unsigned_short; 6677 found = TRUE; 6678 } 6679 break; 6680 6681 case builtin_signed_long: 6682 case builtin_int: /* FIXME: Size depends upon architecture. */ 6683 case builtin_long: 6684 if (strcmp (name, "signed long") == 0) 6685 { 6686 indx = builtin_signed_long; 6687 found = TRUE; 6688 } 6689 else if (strcmp (name, "int") == 0) 6690 { 6691 indx = builtin_int; 6692 found = TRUE; 6693 } 6694 else if (strcmp (name, "long") == 0 6695 || strcmp (name, "long int") == 0) 6696 { 6697 indx = builtin_long; 6698 found = TRUE; 6699 } 6700 break; 6701 6702 case builtin_unsigned_long: 6703 case builtin_unsigned: /* FIXME: Size depends upon architecture. */ 6704 case builtin_unsigned_int: /* FIXME: Like builtin_unsigned. */ 6705 if (strcmp (name, "unsigned long") == 0 6706 || strcmp (name, "long unsigned int") == 0) 6707 { 6708 indx = builtin_unsigned_long; 6709 found = TRUE; 6710 } 6711 else if (strcmp (name, "unsigned") == 0) 6712 { 6713 indx = builtin_unsigned; 6714 found = TRUE; 6715 } 6716 else if (strcmp (name, "unsigned int") == 0) 6717 { 6718 indx = builtin_unsigned_int; 6719 found = TRUE; 6720 } 6721 break; 6722 6723 case builtin_signed_long_long: 6724 if (strcmp (name, "signed long long") == 0 6725 || strcmp (name, "long long int") == 0) 6726 found = TRUE; 6727 break; 6728 6729 case builtin_unsigned_long_long: 6730 if (strcmp (name, "unsigned long long") == 0 6731 || strcmp (name, "long long unsigned int") == 0) 6732 found = TRUE; 6733 break; 6734 6735 case builtin_float: 6736 if (strcmp (name, "float") == 0) 6737 found = TRUE; 6738 break; 6739 6740 case builtin_double: 6741 if (strcmp (name, "double") == 0) 6742 found = TRUE; 6743 break; 6744 6745 case builtin_long_double: 6746 if (strcmp (name, "long double") == 0) 6747 found = TRUE; 6748 break; 6749 6750 case builtin_long_long_double: 6751 if (strcmp (name, "long long double") == 0) 6752 found = TRUE; 6753 break; 6754 } 6755 6756 if (found) 6757 type.indx = indx; 6758 } 6759 6760 h = ieee_name_type_hash_lookup (&info->typedefs, name, TRUE, FALSE); 6761 if (h == NULL) 6762 return FALSE; 6763 6764 /* See if we have already defined this type with this name. */ 6765 localp = type.localp; 6766 for (nt = h->types; nt != NULL; nt = nt->next) 6767 { 6768 if (nt->id == indx) 6769 { 6770 /* If this is a global definition, then we don't need to 6771 do anything here. */ 6772 if (! nt->type.localp) 6773 { 6774 ieee_pop_unused_type (info); 6775 return TRUE; 6776 } 6777 } 6778 else 6779 { 6780 /* This is a duplicate definition, so make this one local. */ 6781 localp = TRUE; 6782 } 6783 } 6784 6785 /* We need to add a new typedef for this type. */ 6786 6787 nt = (struct ieee_name_type *) xmalloc (sizeof *nt); 6788 memset (nt, 0, sizeof *nt); 6789 nt->id = indx; 6790 nt->type = type; 6791 nt->type.name = name; 6792 nt->type.localp = localp; 6793 nt->kind = DEBUG_KIND_ILLEGAL; 6794 6795 nt->next = h->types; 6796 h->types = nt; 6797 6798 if (found) 6799 { 6800 /* This is one of the builtin typedefs, so we don't need to 6801 actually define it. */ 6802 ieee_pop_unused_type (info); 6803 return TRUE; 6804 } 6805 6806 indx = ieee_pop_type (info); 6807 6808 if (! ieee_define_named_type (info, name, (unsigned int) -1, type.size, 6809 type.unsignedp, localp, 6810 (struct ieee_buflist *) NULL) 6811 || ! ieee_write_number (info, 'T') 6812 || ! ieee_write_number (info, indx)) 6813 return FALSE; 6814 6815 /* Remove the type we just added to the type stack. This should not 6816 be ieee_pop_unused_type, since the type is used, we just don't 6817 need it now. */ 6818 (void) ieee_pop_type (info); 6819 6820 return TRUE; 6821} 6822 6823/* Output a tag for a type. We don't have to do anything here. */ 6824 6825static bfd_boolean 6826ieee_tag (void *p, const char *name ATTRIBUTE_UNUSED) 6827{ 6828 struct ieee_handle *info = (struct ieee_handle *) p; 6829 6830 /* This should not be ieee_pop_unused_type, since we want the type 6831 to be defined. */ 6832 (void) ieee_pop_type (info); 6833 return TRUE; 6834} 6835 6836/* Output an integer constant. */ 6837 6838static bfd_boolean 6839ieee_int_constant (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED, 6840 bfd_vma val ATTRIBUTE_UNUSED) 6841{ 6842 /* FIXME. */ 6843 return TRUE; 6844} 6845 6846/* Output a floating point constant. */ 6847 6848static bfd_boolean 6849ieee_float_constant (void *p ATTRIBUTE_UNUSED, 6850 const char *name ATTRIBUTE_UNUSED, 6851 double val ATTRIBUTE_UNUSED) 6852{ 6853 /* FIXME. */ 6854 return TRUE; 6855} 6856 6857/* Output a typed constant. */ 6858 6859static bfd_boolean 6860ieee_typed_constant (void *p, const char *name ATTRIBUTE_UNUSED, 6861 bfd_vma val ATTRIBUTE_UNUSED) 6862{ 6863 struct ieee_handle *info = (struct ieee_handle *) p; 6864 6865 /* FIXME. */ 6866 ieee_pop_unused_type (info); 6867 return TRUE; 6868} 6869 6870/* Output a variable. */ 6871 6872static bfd_boolean 6873ieee_variable (void *p, const char *name, enum debug_var_kind kind, 6874 bfd_vma val) 6875{ 6876 struct ieee_handle *info = (struct ieee_handle *) p; 6877 unsigned int name_indx; 6878 unsigned int size; 6879 bfd_boolean referencep; 6880 unsigned int type_indx; 6881 bfd_boolean asn; 6882 int refflag; 6883 6884 size = info->type_stack->type.size; 6885 referencep = info->type_stack->type.referencep; 6886 type_indx = ieee_pop_type (info); 6887 6888 assert (! ieee_buffer_emptyp (&info->vars)); 6889 if (! ieee_change_buffer (info, &info->vars)) 6890 return FALSE; 6891 6892 name_indx = info->name_indx; 6893 ++info->name_indx; 6894 6895 /* Write out an NN and an ATN record for this variable. */ 6896 if (! ieee_write_byte (info, (int) ieee_nn_record) 6897 || ! ieee_write_number (info, name_indx) 6898 || ! ieee_write_id (info, name) 6899 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum) 6900 || ! ieee_write_number (info, name_indx) 6901 || ! ieee_write_number (info, type_indx)) 6902 return FALSE; 6903 switch (kind) 6904 { 6905 default: 6906 abort (); 6907 return FALSE; 6908 case DEBUG_GLOBAL: 6909 if (! ieee_write_number (info, 8) 6910 || ! ieee_add_range (info, FALSE, val, val + size)) 6911 return FALSE; 6912 refflag = 0; 6913 asn = TRUE; 6914 break; 6915 case DEBUG_STATIC: 6916 if (! ieee_write_number (info, 3) 6917 || ! ieee_add_range (info, FALSE, val, val + size)) 6918 return FALSE; 6919 refflag = 1; 6920 asn = TRUE; 6921 break; 6922 case DEBUG_LOCAL_STATIC: 6923 if (! ieee_write_number (info, 3) 6924 || ! ieee_add_range (info, FALSE, val, val + size)) 6925 return FALSE; 6926 refflag = 2; 6927 asn = TRUE; 6928 break; 6929 case DEBUG_LOCAL: 6930 if (! ieee_write_number (info, 1) 6931 || ! ieee_write_number (info, val)) 6932 return FALSE; 6933 refflag = 2; 6934 asn = FALSE; 6935 break; 6936 case DEBUG_REGISTER: 6937 if (! ieee_write_number (info, 2) 6938 || ! ieee_write_number (info, 6939 ieee_genreg_to_regno (info->abfd, val))) 6940 return FALSE; 6941 refflag = 2; 6942 asn = FALSE; 6943 break; 6944 } 6945 6946 if (asn) 6947 { 6948 if (! ieee_write_asn (info, name_indx, val)) 6949 return FALSE; 6950 } 6951 6952 /* If this is really a reference type, then we just output it with 6953 pointer type, and must now output a C++ record indicating that it 6954 is really reference type. */ 6955 if (referencep) 6956 { 6957 unsigned int nindx; 6958 6959 nindx = info->name_indx; 6960 ++info->name_indx; 6961 6962 /* If this is a global variable, we want to output the misc 6963 record in the C++ misc record block. Otherwise, we want to 6964 output it just after the variable definition, which is where 6965 the current buffer is. */ 6966 if (refflag != 2) 6967 { 6968 if (! ieee_change_buffer (info, &info->cxx)) 6969 return FALSE; 6970 } 6971 6972 if (! ieee_write_byte (info, (int) ieee_nn_record) 6973 || ! ieee_write_number (info, nindx) 6974 || ! ieee_write_id (info, "") 6975 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum) 6976 || ! ieee_write_number (info, nindx) 6977 || ! ieee_write_number (info, 0) 6978 || ! ieee_write_number (info, 62) 6979 || ! ieee_write_number (info, 80) 6980 || ! ieee_write_number (info, 3) 6981 || ! ieee_write_asn (info, nindx, 'R') 6982 || ! ieee_write_asn (info, nindx, refflag) 6983 || ! ieee_write_atn65 (info, nindx, name)) 6984 return FALSE; 6985 } 6986 6987 return TRUE; 6988} 6989 6990/* Start outputting information for a function. */ 6991 6992static bfd_boolean 6993ieee_start_function (void *p, const char *name, bfd_boolean global) 6994{ 6995 struct ieee_handle *info = (struct ieee_handle *) p; 6996 bfd_boolean referencep; 6997 unsigned int retindx, typeindx; 6998 6999 referencep = info->type_stack->type.referencep; 7000 retindx = ieee_pop_type (info); 7001 7002 /* Besides recording a BB4 or BB6 block, we record the type of the 7003 function in the BB1 typedef block. We can't write out the full 7004 type until we have seen all the parameters, so we accumulate it 7005 in info->fntype and info->fnargs. */ 7006 if (! ieee_buffer_emptyp (&info->fntype)) 7007 { 7008 /* FIXME: This might happen someday if we support nested 7009 functions. */ 7010 abort (); 7011 } 7012 7013 info->fnname = name; 7014 7015 /* An attribute of 0x40 means that the push mask is unknown. */ 7016 if (! ieee_define_named_type (info, name, (unsigned int) -1, 0, FALSE, TRUE, 7017 &info->fntype) 7018 || ! ieee_write_number (info, 'x') 7019 || ! ieee_write_number (info, 0x40) 7020 || ! ieee_write_number (info, 0) 7021 || ! ieee_write_number (info, 0) 7022 || ! ieee_write_number (info, retindx)) 7023 return FALSE; 7024 7025 typeindx = ieee_pop_type (info); 7026 7027 if (! ieee_init_buffer (info, &info->fnargs)) 7028 return FALSE; 7029 info->fnargcount = 0; 7030 7031 /* If the function return value is actually a reference type, we 7032 must add a record indicating that. */ 7033 if (referencep) 7034 { 7035 unsigned int nindx; 7036 7037 nindx = info->name_indx; 7038 ++info->name_indx; 7039 if (! ieee_change_buffer (info, &info->cxx) 7040 || ! ieee_write_byte (info, (int) ieee_nn_record) 7041 || ! ieee_write_number (info, nindx) 7042 || ! ieee_write_id (info, "") 7043 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum) 7044 || ! ieee_write_number (info, nindx) 7045 || ! ieee_write_number (info, 0) 7046 || ! ieee_write_number (info, 62) 7047 || ! ieee_write_number (info, 80) 7048 || ! ieee_write_number (info, 3) 7049 || ! ieee_write_asn (info, nindx, 'R') 7050 || ! ieee_write_asn (info, nindx, global ? 0 : 1) 7051 || ! ieee_write_atn65 (info, nindx, name)) 7052 return FALSE; 7053 } 7054 7055 assert (! ieee_buffer_emptyp (&info->vars)); 7056 if (! ieee_change_buffer (info, &info->vars)) 7057 return FALSE; 7058 7059 /* The address is written out as the first block. */ 7060 7061 ++info->block_depth; 7062 7063 return (ieee_write_byte (info, (int) ieee_bb_record_enum) 7064 && ieee_write_byte (info, global ? 4 : 6) 7065 && ieee_write_number (info, 0) 7066 && ieee_write_id (info, name) 7067 && ieee_write_number (info, 0) 7068 && ieee_write_number (info, typeindx)); 7069} 7070 7071/* Add a function parameter. This will normally be called before the 7072 first block, so we postpone them until we see the block. */ 7073 7074static bfd_boolean 7075ieee_function_parameter (void *p, const char *name, enum debug_parm_kind kind, 7076 bfd_vma val) 7077{ 7078 struct ieee_handle *info = (struct ieee_handle *) p; 7079 struct ieee_pending_parm *m, **pm; 7080 7081 assert (info->block_depth == 1); 7082 7083 m = (struct ieee_pending_parm *) xmalloc (sizeof *m); 7084 memset (m, 0, sizeof *m); 7085 7086 m->next = NULL; 7087 m->name = name; 7088 m->referencep = info->type_stack->type.referencep; 7089 m->type = ieee_pop_type (info); 7090 m->kind = kind; 7091 m->val = val; 7092 7093 for (pm = &info->pending_parms; *pm != NULL; pm = &(*pm)->next) 7094 ; 7095 *pm = m; 7096 7097 /* Add the type to the fnargs list. */ 7098 if (! ieee_change_buffer (info, &info->fnargs) 7099 || ! ieee_write_number (info, m->type)) 7100 return FALSE; 7101 ++info->fnargcount; 7102 7103 return TRUE; 7104} 7105 7106/* Output pending function parameters. */ 7107 7108static bfd_boolean 7109ieee_output_pending_parms (struct ieee_handle *info) 7110{ 7111 struct ieee_pending_parm *m; 7112 unsigned int refcount; 7113 7114 refcount = 0; 7115 for (m = info->pending_parms; m != NULL; m = m->next) 7116 { 7117 enum debug_var_kind vkind; 7118 7119 switch (m->kind) 7120 { 7121 default: 7122 abort (); 7123 return FALSE; 7124 case DEBUG_PARM_STACK: 7125 case DEBUG_PARM_REFERENCE: 7126 vkind = DEBUG_LOCAL; 7127 break; 7128 case DEBUG_PARM_REG: 7129 case DEBUG_PARM_REF_REG: 7130 vkind = DEBUG_REGISTER; 7131 break; 7132 } 7133 7134 if (! ieee_push_type (info, m->type, 0, FALSE, FALSE)) 7135 return FALSE; 7136 info->type_stack->type.referencep = m->referencep; 7137 if (m->referencep) 7138 ++refcount; 7139 if (! ieee_variable ((void *) info, m->name, vkind, m->val)) 7140 return FALSE; 7141 } 7142 7143 /* If there are any reference parameters, we need to output a 7144 miscellaneous record indicating them. */ 7145 if (refcount > 0) 7146 { 7147 unsigned int nindx, varindx; 7148 7149 /* FIXME: The MRI compiler outputs the demangled function name 7150 here, but we are outputting the mangled name. */ 7151 nindx = info->name_indx; 7152 ++info->name_indx; 7153 if (! ieee_change_buffer (info, &info->vars) 7154 || ! ieee_write_byte (info, (int) ieee_nn_record) 7155 || ! ieee_write_number (info, nindx) 7156 || ! ieee_write_id (info, "") 7157 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum) 7158 || ! ieee_write_number (info, nindx) 7159 || ! ieee_write_number (info, 0) 7160 || ! ieee_write_number (info, 62) 7161 || ! ieee_write_number (info, 80) 7162 || ! ieee_write_number (info, refcount + 3) 7163 || ! ieee_write_asn (info, nindx, 'B') 7164 || ! ieee_write_atn65 (info, nindx, info->fnname) 7165 || ! ieee_write_asn (info, nindx, 0)) 7166 return FALSE; 7167 for (m = info->pending_parms, varindx = 1; 7168 m != NULL; 7169 m = m->next, varindx++) 7170 { 7171 if (m->referencep) 7172 { 7173 if (! ieee_write_asn (info, nindx, varindx)) 7174 return FALSE; 7175 } 7176 } 7177 } 7178 7179 m = info->pending_parms; 7180 while (m != NULL) 7181 { 7182 struct ieee_pending_parm *next; 7183 7184 next = m->next; 7185 free (m); 7186 m = next; 7187 } 7188 7189 info->pending_parms = NULL; 7190 7191 return TRUE; 7192} 7193 7194/* Start a block. If this is the first block, we output the address 7195 to finish the BB4 or BB6, and then output the function parameters. */ 7196 7197static bfd_boolean 7198ieee_start_block (void *p, bfd_vma addr) 7199{ 7200 struct ieee_handle *info = (struct ieee_handle *) p; 7201 7202 if (! ieee_change_buffer (info, &info->vars)) 7203 return FALSE; 7204 7205 if (info->block_depth == 1) 7206 { 7207 if (! ieee_write_number (info, addr) 7208 || ! ieee_output_pending_parms (info)) 7209 return FALSE; 7210 } 7211 else 7212 { 7213 if (! ieee_write_byte (info, (int) ieee_bb_record_enum) 7214 || ! ieee_write_byte (info, 6) 7215 || ! ieee_write_number (info, 0) 7216 || ! ieee_write_id (info, "") 7217 || ! ieee_write_number (info, 0) 7218 || ! ieee_write_number (info, 0) 7219 || ! ieee_write_number (info, addr)) 7220 return FALSE; 7221 } 7222 7223 if (! ieee_start_range (info, addr)) 7224 return FALSE; 7225 7226 ++info->block_depth; 7227 7228 return TRUE; 7229} 7230 7231/* End a block. */ 7232 7233static bfd_boolean 7234ieee_end_block (void *p, bfd_vma addr) 7235{ 7236 struct ieee_handle *info = (struct ieee_handle *) p; 7237 7238 /* The address we are given is the end of the block, but IEEE seems 7239 to want to the address of the last byte in the block, so we 7240 subtract one. */ 7241 if (! ieee_change_buffer (info, &info->vars) 7242 || ! ieee_write_byte (info, (int) ieee_be_record_enum) 7243 || ! ieee_write_number (info, addr - 1)) 7244 return FALSE; 7245 7246 if (! ieee_end_range (info, addr)) 7247 return FALSE; 7248 7249 --info->block_depth; 7250 7251 if (addr > info->highaddr) 7252 info->highaddr = addr; 7253 7254 return TRUE; 7255} 7256 7257/* End a function. */ 7258 7259static bfd_boolean 7260ieee_end_function (void *p) 7261{ 7262 struct ieee_handle *info = (struct ieee_handle *) p; 7263 7264 assert (info->block_depth == 1); 7265 7266 --info->block_depth; 7267 7268 /* Now we can finish up fntype, and add it to the typdef section. 7269 At this point, fntype is the 'x' type up to the argument count, 7270 and fnargs is the argument types. We must add the argument 7271 count, and we must add the level. FIXME: We don't record varargs 7272 functions correctly. In fact, stabs debugging does not give us 7273 enough information to do so. */ 7274 if (! ieee_change_buffer (info, &info->fntype) 7275 || ! ieee_write_number (info, info->fnargcount) 7276 || ! ieee_change_buffer (info, &info->fnargs) 7277 || ! ieee_write_number (info, 0)) 7278 return FALSE; 7279 7280 /* Make sure the typdef block has been started. */ 7281 if (ieee_buffer_emptyp (&info->types)) 7282 { 7283 if (! ieee_change_buffer (info, &info->types) 7284 || ! ieee_write_byte (info, (int) ieee_bb_record_enum) 7285 || ! ieee_write_byte (info, 1) 7286 || ! ieee_write_number (info, 0) 7287 || ! ieee_write_id (info, info->modname)) 7288 return FALSE; 7289 } 7290 7291 if (! ieee_append_buffer (info, &info->types, &info->fntype) 7292 || ! ieee_append_buffer (info, &info->types, &info->fnargs)) 7293 return FALSE; 7294 7295 info->fnname = NULL; 7296 if (! ieee_init_buffer (info, &info->fntype) 7297 || ! ieee_init_buffer (info, &info->fnargs)) 7298 return FALSE; 7299 info->fnargcount = 0; 7300 7301 return TRUE; 7302} 7303 7304/* Record line number information. */ 7305 7306static bfd_boolean 7307ieee_lineno (void *p, const char *filename, unsigned long lineno, bfd_vma addr) 7308{ 7309 struct ieee_handle *info = (struct ieee_handle *) p; 7310 7311 assert (info->filename != NULL); 7312 7313 /* The HP simulator seems to get confused when more than one line is 7314 listed for the same address, at least if they are in different 7315 files. We handle this by always listing the last line for a 7316 given address, since that seems to be the one that gdb uses. */ 7317 if (info->pending_lineno_filename != NULL 7318 && addr != info->pending_lineno_addr) 7319 { 7320 /* Make sure we have a line number block. */ 7321 if (! ieee_buffer_emptyp (&info->linenos)) 7322 { 7323 if (! ieee_change_buffer (info, &info->linenos)) 7324 return FALSE; 7325 } 7326 else 7327 { 7328 info->lineno_name_indx = info->name_indx; 7329 ++info->name_indx; 7330 if (! ieee_change_buffer (info, &info->linenos) 7331 || ! ieee_write_byte (info, (int) ieee_bb_record_enum) 7332 || ! ieee_write_byte (info, 5) 7333 || ! ieee_write_number (info, 0) 7334 || ! ieee_write_id (info, info->filename) 7335 || ! ieee_write_byte (info, (int) ieee_nn_record) 7336 || ! ieee_write_number (info, info->lineno_name_indx) 7337 || ! ieee_write_id (info, "")) 7338 return FALSE; 7339 info->lineno_filename = info->filename; 7340 } 7341 7342 if (strcmp (info->pending_lineno_filename, info->lineno_filename) != 0) 7343 { 7344 if (strcmp (info->filename, info->lineno_filename) != 0) 7345 { 7346 /* We were not in the main file. Close the block for the 7347 included file. */ 7348 if (! ieee_write_byte (info, (int) ieee_be_record_enum)) 7349 return FALSE; 7350 if (strcmp (info->filename, info->pending_lineno_filename) == 0) 7351 { 7352 /* We need a new NN record, and we aren't about to 7353 output one. */ 7354 info->lineno_name_indx = info->name_indx; 7355 ++info->name_indx; 7356 if (! ieee_write_byte (info, (int) ieee_nn_record) 7357 || ! ieee_write_number (info, info->lineno_name_indx) 7358 || ! ieee_write_id (info, "")) 7359 return FALSE; 7360 } 7361 } 7362 if (strcmp (info->filename, info->pending_lineno_filename) != 0) 7363 { 7364 /* We are not changing to the main file. Open a block for 7365 the new included file. */ 7366 info->lineno_name_indx = info->name_indx; 7367 ++info->name_indx; 7368 if (! ieee_write_byte (info, (int) ieee_bb_record_enum) 7369 || ! ieee_write_byte (info, 5) 7370 || ! ieee_write_number (info, 0) 7371 || ! ieee_write_id (info, info->pending_lineno_filename) 7372 || ! ieee_write_byte (info, (int) ieee_nn_record) 7373 || ! ieee_write_number (info, info->lineno_name_indx) 7374 || ! ieee_write_id (info, "")) 7375 return FALSE; 7376 } 7377 info->lineno_filename = info->pending_lineno_filename; 7378 } 7379 7380 if (! ieee_write_2bytes (info, (int) ieee_atn_record_enum) 7381 || ! ieee_write_number (info, info->lineno_name_indx) 7382 || ! ieee_write_number (info, 0) 7383 || ! ieee_write_number (info, 7) 7384 || ! ieee_write_number (info, info->pending_lineno) 7385 || ! ieee_write_number (info, 0) 7386 || ! ieee_write_asn (info, info->lineno_name_indx, 7387 info->pending_lineno_addr)) 7388 return FALSE; 7389 } 7390 7391 info->pending_lineno_filename = filename; 7392 info->pending_lineno = lineno; 7393 info->pending_lineno_addr = addr; 7394 7395 return TRUE; 7396} 7397