binutils/ieee.c

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