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