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