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   switch (bfd_get_arch (abfd))
3436     {
3437     case bfd_arch_m68k:
3438       /* For some reasons stabs adds 2 to the floating point register
3439          numbers.  */
3440       if (r >= 16)
3441         r += 2;
3442       break;
3443
3444     case bfd_arch_i960:
3445       /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and
3446          32 to 35 for fp0 to fp3.  */
3447       --r;
3448       break;
3449
3450     default:
3451       break;
3452     }
3453
3454   return r;
3455 }
3456
3457 /* Convert a generic register number to an IEEE specific one.  */
3458
3459 static int
3460 ieee_genreg_to_regno (abfd, r)
3461      bfd *abfd;
3462      int r;
3463 {
3464   switch (bfd_get_arch (abfd))
3465     {
3466     case bfd_arch_m68k:
3467       /* For some reason stabs add 2 to the floating point register
3468          numbers.  */
3469       if (r >= 18)
3470         r -= 2;
3471       break;
3472
3473     case bfd_arch_i960:
3474       /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and
3475          32 to 35 for fp0 to fp3.  */
3476       ++r;
3477       break;
3478
3479     default:
3480       break;
3481     }
3482
3483   return r;
3484 }
3485 \f
3486 /* These routines build IEEE debugging information out of the generic
3487    debugging information.  */
3488
3489 /* We build the IEEE debugging information byte by byte.  Rather than
3490    waste time copying data around, we use a linked list of buffers to
3491    hold the data.  */
3492
3493 #define IEEE_BUFSIZE (490)
3494
3495 struct ieee_buf
3496 {
3497   /* Next buffer.  */
3498   struct ieee_buf *next;
3499   /* Number of data bytes in this buffer.  */
3500   unsigned int c;
3501   /* Bytes.  */
3502   bfd_byte buf[IEEE_BUFSIZE];
3503 };
3504
3505 /* A list of buffers.  */
3506
3507 struct ieee_buflist
3508 {
3509   /* Head of list.  */
3510   struct ieee_buf *head;
3511   /* Tail--last buffer on list.  */
3512   struct ieee_buf *tail;
3513 };
3514
3515 /* In order to generate the BB11 blocks required by the HP emulator,
3516    we keep track of ranges of addresses which correspond to a given
3517    compilation unit.  */
3518
3519 struct ieee_range
3520 {
3521   /* Next range.  */
3522   struct ieee_range *next;
3523   /* Low address.  */
3524   bfd_vma low;
3525   /* High address.  */
3526   bfd_vma high;
3527 };
3528
3529 /* This structure holds information for a class on the type stack.  */
3530
3531 struct ieee_type_class
3532 {
3533   /* The name index in the debugging information.  */
3534   unsigned int indx;
3535   /* The pmisc records for the class.  */
3536   struct ieee_buflist pmiscbuf;
3537   /* The number of pmisc records.  */
3538   unsigned int pmisccount;
3539   /* The name of the class holding the virtual table, if not this
3540      class.  */
3541   const char *vclass;
3542   /* Whether this class holds its own virtual table.  */
3543   boolean ownvptr;
3544   /* The largest virtual table offset seen so far.  */
3545   bfd_vma voffset;
3546   /* The current method.  */
3547   const char *method;
3548   /* Additional pmisc records used to record fields of reference type.  */
3549   struct ieee_buflist refs;
3550 };
3551
3552 /* This is how we store types for the writing routines.  Most types
3553    are simply represented by a type index.  */
3554
3555 struct ieee_write_type
3556 {
3557   /* Type index.  */
3558   unsigned int indx;
3559   /* The size of the type, if known.  */
3560   unsigned int size;
3561   /* The name of the type, if any.  */
3562   const char *name;
3563   /* If this is a function or method type, we build the type here, and
3564      only add it to the output buffers if we need it.  */
3565   struct ieee_buflist fndef;
3566   /* If this is a struct, this is where the struct definition is
3567      built.  */
3568   struct ieee_buflist strdef;
3569   /* If this is a class, this is where the class information is built.  */
3570   struct ieee_type_class *classdef;
3571   /* Whether the type is unsigned.  */
3572   unsigned int unsignedp : 1;
3573   /* Whether this is a reference type.  */
3574   unsigned int referencep : 1;
3575   /* Whether this is in the local type block.  */
3576   unsigned int localp : 1;
3577   /* Whether this is a duplicate struct definition which we are
3578      ignoring.  */
3579   unsigned int ignorep : 1;
3580 };
3581
3582 /* This is the type stack used by the debug writing routines.  FIXME:
3583    We could generate more efficient output if we remembered when we
3584    have output a particular type before.  */
3585
3586 struct ieee_type_stack
3587 {
3588   /* Next entry on stack.  */
3589   struct ieee_type_stack *next;
3590   /* Type information.  */
3591   struct ieee_write_type type;
3592 };
3593
3594 /* This is a list of associations between a name and some types.
3595    These are used for typedefs and tags.  */
3596
3597 struct ieee_name_type
3598 {
3599   /* Next type for this name.  */
3600   struct ieee_name_type *next;
3601   /* ID number.  For a typedef, this is the index of the type to which
3602      this name is typedefed.  */
3603   unsigned int id;
3604   /* Type.  */
3605   struct ieee_write_type type;
3606   /* If this is a tag which has not yet been defined, this is the
3607      kind.  If the tag has been defined, this is DEBUG_KIND_ILLEGAL.  */
3608   enum debug_type_kind kind;
3609 };
3610
3611 /* We use a hash table to associate names and types.  */
3612
3613 struct ieee_name_type_hash_table
3614 {
3615   struct bfd_hash_table root;
3616 };
3617
3618 struct ieee_name_type_hash_entry
3619 {
3620   struct bfd_hash_entry root;
3621   /* Information for this name.  */
3622   struct ieee_name_type *types;
3623 };
3624
3625 /* This is a list of enums.  */
3626
3627 struct ieee_defined_enum
3628 {
3629   /* Next enum.  */
3630   struct ieee_defined_enum *next;
3631   /* Type index.  */
3632   unsigned int indx;
3633   /* Tag.  */
3634   const char *tag;
3635   /* Names.  */
3636   const char **names;
3637   /* Values.  */
3638   bfd_signed_vma *vals;
3639 };
3640
3641 /* We keep a list of modified versions of types, so that we don't
3642    output them more than once.  */
3643
3644 struct ieee_modified_type
3645 {
3646   /* Pointer to this type.  */
3647   unsigned int pointer;
3648   /* Function with unknown arguments returning this type.  */
3649   unsigned int function;
3650   /* Const version of this type.  */
3651   unsigned int const_qualified;
3652   /* Volatile version of this type.  */
3653   unsigned int volatile_qualified;
3654   /* List of arrays of this type of various bounds.  */
3655   struct ieee_modified_array_type *arrays;
3656 };
3657
3658 /* A list of arrays bounds.  */
3659
3660 struct ieee_modified_array_type
3661 {
3662   /* Next array bounds.  */
3663   struct ieee_modified_array_type *next;
3664   /* Type index with these bounds.  */
3665   unsigned int indx;
3666   /* Low bound.  */
3667   bfd_signed_vma low;
3668   /* High bound.  */
3669   bfd_signed_vma high;
3670 };
3671
3672 /* This is a list of pending function parameter information.  We don't
3673    output them until we see the first block.  */
3674
3675 struct ieee_pending_parm
3676 {
3677   /* Next pending parameter.  */
3678   struct ieee_pending_parm *next;
3679   /* Name.  */
3680   const char *name;
3681   /* Type index.  */
3682   unsigned int type;
3683   /* Whether the type is a reference.  */
3684   boolean referencep;
3685   /* Kind.  */
3686   enum debug_parm_kind kind;
3687   /* Value.  */
3688   bfd_vma val;
3689 };
3690
3691 /* This is the handle passed down by debug_write.  */
3692
3693 struct ieee_handle
3694 {
3695   /* BFD we are writing to.  */
3696   bfd *abfd;
3697   /* Whether we got an error in a subroutine called via traverse or
3698      map_over_sections.  */
3699   boolean error;
3700   /* Current data buffer list.  */
3701   struct ieee_buflist *current;
3702   /* Current data buffer.  */
3703   struct ieee_buf *curbuf;
3704   /* Filename of current compilation unit.  */
3705   const char *filename;
3706   /* Module name of current compilation unit.  */
3707   const char *modname;
3708   /* List of buffer for global types.  */
3709   struct ieee_buflist global_types;
3710   /* List of finished data buffers.  */
3711   struct ieee_buflist data;
3712   /* List of buffers for typedefs in the current compilation unit.  */
3713   struct ieee_buflist types;
3714   /* List of buffers for variables and functions in the current
3715      compilation unit.  */
3716   struct ieee_buflist vars;
3717   /* List of buffers for C++ class definitions in the current
3718      compilation unit.  */
3719   struct ieee_buflist cxx;
3720   /* List of buffers for line numbers in the current compilation unit.  */
3721   struct ieee_buflist linenos;
3722   /* Ranges for the current compilation unit.  */
3723   struct ieee_range *ranges;
3724   /* Ranges for all debugging information.  */
3725   struct ieee_range *global_ranges;
3726   /* Nested pending ranges.  */
3727   struct ieee_range *pending_ranges;
3728   /* Type stack.  */
3729   struct ieee_type_stack *type_stack;
3730   /* Next unallocated type index.  */
3731   unsigned int type_indx;
3732   /* Next unallocated name index.  */
3733   unsigned int name_indx;
3734   /* Typedefs.  */
3735   struct ieee_name_type_hash_table typedefs;
3736   /* Tags.  */
3737   struct ieee_name_type_hash_table tags;
3738   /* Enums.  */
3739   struct ieee_defined_enum *enums;
3740   /* Modified versions of types.  */
3741   struct ieee_modified_type *modified;
3742   /* Number of entries allocated in modified.  */
3743   unsigned int modified_alloc;
3744   /* The depth of block nesting.  This is 0 outside a function, and 1
3745      just after start_function is called.  */
3746   unsigned int block_depth;
3747   /* The name of the current function.  */
3748   const char *fnname;
3749   /* List of buffers for the type of the function we are currently
3750      writing out.  */
3751   struct ieee_buflist fntype;
3752   /* List of buffers for the parameters of the function we are
3753      currently writing out.  */
3754   struct ieee_buflist fnargs;
3755   /* Number of arguments written to fnargs.  */
3756   unsigned int fnargcount;
3757   /* Pending function parameters.  */
3758   struct ieee_pending_parm *pending_parms;
3759   /* Current line number filename.  */
3760   const char *lineno_filename;
3761   /* Line number name index.  */
3762   unsigned int lineno_name_indx;
3763   /* Filename of pending line number.  */
3764   const char *pending_lineno_filename;
3765   /* Pending line number.  */
3766   unsigned long pending_lineno;
3767   /* Address of pending line number.  */
3768   bfd_vma pending_lineno_addr;
3769   /* Highest address seen at end of procedure.  */
3770   bfd_vma highaddr;
3771 };
3772
3773 static boolean ieee_init_buffer
3774   PARAMS ((struct ieee_handle *, struct ieee_buflist *));
3775 static boolean ieee_change_buffer
3776   PARAMS ((struct ieee_handle *, struct ieee_buflist *));
3777 static boolean ieee_append_buffer
3778   PARAMS ((struct ieee_handle *, struct ieee_buflist *,
3779            struct ieee_buflist *));
3780 static boolean ieee_real_write_byte PARAMS ((struct ieee_handle *, int));
3781 static boolean ieee_write_2bytes PARAMS ((struct ieee_handle *, int));
3782 static boolean ieee_write_number PARAMS ((struct ieee_handle *, bfd_vma));
3783 static boolean ieee_write_id PARAMS ((struct ieee_handle *, const char *));
3784 static boolean ieee_write_asn
3785   PARAMS ((struct ieee_handle *, unsigned int, bfd_vma));
3786 static boolean ieee_write_atn65
3787   PARAMS ((struct ieee_handle *, unsigned int, const char *));
3788 static boolean ieee_push_type
3789   PARAMS ((struct ieee_handle *, unsigned int, unsigned int, boolean,
3790            boolean));
3791 static unsigned int ieee_pop_type PARAMS ((struct ieee_handle *));
3792 static void ieee_pop_unused_type PARAMS ((struct ieee_handle *));
3793 static unsigned int ieee_pop_type_used
3794   PARAMS ((struct ieee_handle *, boolean));
3795 static boolean ieee_add_range
3796   PARAMS ((struct ieee_handle *, boolean, bfd_vma, bfd_vma));
3797 static boolean ieee_start_range PARAMS ((struct ieee_handle *, bfd_vma));
3798 static boolean ieee_end_range PARAMS ((struct ieee_handle *, bfd_vma));
3799 static boolean ieee_define_type
3800   PARAMS ((struct ieee_handle *, unsigned int, boolean, boolean));
3801 static boolean ieee_define_named_type
3802   PARAMS ((struct ieee_handle *, const char *, unsigned int, unsigned int,
3803            boolean, boolean, struct ieee_buflist *));
3804 static struct ieee_modified_type *ieee_get_modified_info
3805   PARAMS ((struct ieee_handle *, unsigned int));
3806 static struct bfd_hash_entry *ieee_name_type_newfunc
3807   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
3808 static boolean ieee_write_undefined_tag
3809   PARAMS ((struct ieee_name_type_hash_entry *, PTR));
3810 static boolean ieee_finish_compilation_unit PARAMS ((struct ieee_handle *));
3811 static void ieee_add_bb11_blocks PARAMS ((bfd *, asection *, PTR));
3812 static boolean ieee_add_bb11
3813   PARAMS ((struct ieee_handle *, asection *, bfd_vma, bfd_vma));
3814 static boolean ieee_output_pending_parms PARAMS ((struct ieee_handle *));
3815 static unsigned int ieee_vis_to_flags PARAMS ((enum debug_visibility));
3816 static boolean ieee_class_method_var
3817   PARAMS ((struct ieee_handle *, const char *, enum debug_visibility, boolean,
3818            boolean, boolean, bfd_vma, boolean));
3819
3820 static boolean ieee_start_compilation_unit PARAMS ((PTR, const char *));
3821 static boolean ieee_start_source PARAMS ((PTR, const char *));
3822 static boolean ieee_empty_type PARAMS ((PTR));
3823 static boolean ieee_void_type PARAMS ((PTR));
3824 static boolean ieee_int_type PARAMS ((PTR, unsigned int, boolean));
3825 static boolean ieee_float_type PARAMS ((PTR, unsigned int));
3826 static boolean ieee_complex_type PARAMS ((PTR, unsigned int));
3827 static boolean ieee_bool_type PARAMS ((PTR, unsigned int));
3828 static boolean ieee_enum_type
3829   PARAMS ((PTR, const char *, const char **, bfd_signed_vma *));
3830 static boolean ieee_pointer_type PARAMS ((PTR));
3831 static boolean ieee_function_type PARAMS ((PTR, int, boolean));
3832 static boolean ieee_reference_type PARAMS ((PTR));
3833 static boolean ieee_range_type PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma));
3834 static boolean ieee_array_type
3835   PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma, boolean));
3836 static boolean ieee_set_type PARAMS ((PTR, boolean));
3837 static boolean ieee_offset_type PARAMS ((PTR));
3838 static boolean ieee_method_type PARAMS ((PTR, boolean, int, boolean));
3839 static boolean ieee_const_type PARAMS ((PTR));
3840 static boolean ieee_volatile_type PARAMS ((PTR));
3841 static boolean ieee_start_struct_type
3842   PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int));
3843 static boolean ieee_struct_field
3844   PARAMS ((PTR, const char *, bfd_vma, bfd_vma, enum debug_visibility));
3845 static boolean ieee_end_struct_type PARAMS ((PTR));
3846 static boolean ieee_start_class_type
3847   PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int, boolean,
3848            boolean));
3849 static boolean ieee_class_static_member
3850   PARAMS ((PTR, const char *, const char *, enum debug_visibility));
3851 static boolean ieee_class_baseclass
3852   PARAMS ((PTR, bfd_vma, boolean, enum debug_visibility));
3853 static boolean ieee_class_start_method PARAMS ((PTR, const char *));
3854 static boolean ieee_class_method_variant
3855   PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean,
3856            bfd_vma, boolean));
3857 static boolean ieee_class_static_method_variant
3858   PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean));
3859 static boolean ieee_class_end_method PARAMS ((PTR));
3860 static boolean ieee_end_class_type PARAMS ((PTR));
3861 static boolean ieee_typedef_type PARAMS ((PTR, const char *));
3862 static boolean ieee_tag_type
3863   PARAMS ((PTR, const char *, unsigned int, enum debug_type_kind));
3864 static boolean ieee_typdef PARAMS ((PTR, const char *));
3865 static boolean ieee_tag PARAMS ((PTR, const char *));
3866 static boolean ieee_int_constant PARAMS ((PTR, const char *, bfd_vma));
3867 static boolean ieee_float_constant PARAMS ((PTR, const char *, double));
3868 static boolean ieee_typed_constant PARAMS ((PTR, const char *, bfd_vma));
3869 static boolean ieee_variable
3870   PARAMS ((PTR, const char *, enum debug_var_kind, bfd_vma));
3871 static boolean ieee_start_function PARAMS ((PTR, const char *, boolean));
3872 static boolean ieee_function_parameter
3873   PARAMS ((PTR, const char *, enum debug_parm_kind, bfd_vma));
3874 static boolean ieee_start_block PARAMS ((PTR, bfd_vma));
3875 static boolean ieee_end_block PARAMS ((PTR, bfd_vma));
3876 static boolean ieee_end_function PARAMS ((PTR));
3877 static boolean ieee_lineno
3878   PARAMS ((PTR, const char *, unsigned long, bfd_vma));
3879
3880 static const struct debug_write_fns ieee_fns =
3881 {
3882   ieee_start_compilation_unit,
3883   ieee_start_source,
3884   ieee_empty_type,
3885   ieee_void_type,
3886   ieee_int_type,
3887   ieee_float_type,
3888   ieee_complex_type,
3889   ieee_bool_type,
3890   ieee_enum_type,
3891   ieee_pointer_type,
3892   ieee_function_type,
3893   ieee_reference_type,
3894   ieee_range_type,
3895   ieee_array_type,
3896   ieee_set_type,
3897   ieee_offset_type,
3898   ieee_method_type,
3899   ieee_const_type,
3900   ieee_volatile_type,
3901   ieee_start_struct_type,
3902   ieee_struct_field,
3903   ieee_end_struct_type,
3904   ieee_start_class_type,
3905   ieee_class_static_member,
3906   ieee_class_baseclass,
3907   ieee_class_start_method,
3908   ieee_class_method_variant,
3909   ieee_class_static_method_variant,
3910   ieee_class_end_method,
3911   ieee_end_class_type,
3912   ieee_typedef_type,
3913   ieee_tag_type,
3914   ieee_typdef,
3915   ieee_tag,
3916   ieee_int_constant,
3917   ieee_float_constant,
3918   ieee_typed_constant,
3919   ieee_variable,
3920   ieee_start_function,
3921   ieee_function_parameter,
3922   ieee_start_block,
3923   ieee_end_block,
3924   ieee_end_function,
3925   ieee_lineno
3926 };
3927
3928 /* Initialize a buffer to be empty.  */
3929
3930 /*ARGSUSED*/
3931 static boolean
3932 ieee_init_buffer (info, buflist)
3933      struct ieee_handle *info;
3934      struct ieee_buflist *buflist;
3935 {
3936   buflist->head = NULL;
3937   buflist->tail = NULL;
3938   return true;
3939 }
3940
3941 /* See whether a buffer list has any data.  */
3942
3943 #define ieee_buffer_emptyp(buflist) ((buflist)->head == NULL)
3944
3945 /* Change the current buffer to a specified buffer chain.  */
3946
3947 static boolean
3948 ieee_change_buffer (info, buflist)
3949      struct ieee_handle *info;
3950      struct ieee_buflist *buflist;
3951 {
3952   if (buflist->head == NULL)
3953     {
3954       struct ieee_buf *buf;
3955
3956       buf = (struct ieee_buf *) xmalloc (sizeof *buf);
3957       buf->next = NULL;
3958       buf->c = 0;
3959       buflist->head = buf;
3960       buflist->tail = buf;
3961     }
3962
3963   info->current = buflist;
3964   info->curbuf = buflist->tail;
3965
3966   return true;
3967 }
3968
3969 /* Append a buffer chain.  */
3970
3971 /*ARGSUSED*/
3972 static boolean
3973 ieee_append_buffer (info, mainbuf, newbuf)
3974      struct ieee_handle *info;
3975      struct ieee_buflist *mainbuf;
3976      struct ieee_buflist *newbuf;
3977 {
3978   if (newbuf->head != NULL)
3979     {
3980       if (mainbuf->head == NULL)
3981         mainbuf->head = newbuf->head;
3982       else
3983         mainbuf->tail->next = newbuf->head;
3984       mainbuf->tail = newbuf->tail;
3985     }
3986   return true;
3987 }
3988
3989 /* Write a byte into the buffer.  We use a macro for speed and a
3990    function for the complex cases.  */
3991
3992 #define ieee_write_byte(info, b)                                \
3993   ((info)->curbuf->c < IEEE_BUFSIZE                             \
3994    ? ((info)->curbuf->buf[(info)->curbuf->c++] = (b), true)     \
3995    : ieee_real_write_byte ((info), (b)))
3996
3997 static boolean
3998 ieee_real_write_byte (info, b)
3999      struct ieee_handle *info;
4000      int b;
4001 {
4002   if (info->curbuf->c >= IEEE_BUFSIZE)
4003     {
4004       struct ieee_buf *n;
4005
4006       n = (struct ieee_buf *) xmalloc (sizeof *n);
4007       n->next = NULL;
4008       n->c = 0;
4009       if (info->current->head == NULL)
4010         info->current->head = n;
4011       else
4012         info->current->tail->next = n;
4013       info->current->tail = n;
4014       info->curbuf = n;
4015     }
4016
4017   info->curbuf->buf[info->curbuf->c] = b;
4018   ++info->curbuf->c;
4019
4020   return true;
4021 }
4022
4023 /* Write out two bytes.  */
4024
4025 static boolean
4026 ieee_write_2bytes (info, i)
4027      struct ieee_handle *info;
4028      int i;
4029 {
4030   return (ieee_write_byte (info, i >> 8)
4031           && ieee_write_byte (info, i & 0xff));
4032 }
4033
4034 /* Write out an integer.  */
4035
4036 static boolean
4037 ieee_write_number (info, v)
4038      struct ieee_handle *info;
4039      bfd_vma v;
4040 {
4041   bfd_vma t;
4042   bfd_byte ab[20];
4043   bfd_byte *p;
4044   unsigned int c;
4045
4046   if (v <= (bfd_vma) ieee_number_end_enum)
4047     return ieee_write_byte (info, (int) v);
4048
4049   t = v;
4050   p = ab + sizeof ab;
4051   while (t != 0)
4052     {
4053       *--p = t & 0xff;
4054       t >>= 8;
4055     }
4056   c = (ab + 20) - p;
4057
4058   if (c > (unsigned int) (ieee_number_repeat_end_enum
4059                           - ieee_number_repeat_start_enum))
4060     {
4061       fprintf (stderr, "IEEE numeric overflow: 0x");
4062       fprintf_vma (stderr, v);
4063       fprintf (stderr, "\n");
4064       return false;
4065     }
4066
4067   if (! ieee_write_byte (info, (int) ieee_number_repeat_start_enum + c))
4068     return false;
4069   for (; c > 0; --c, ++p)
4070     {
4071       if (! ieee_write_byte (info, *p))
4072         return false;
4073     }
4074
4075   return true;
4076 }
4077
4078 /* Write out a string.  */
4079
4080 static boolean
4081 ieee_write_id (info, s)
4082      struct ieee_handle *info;
4083      const char *s;
4084 {
4085   unsigned int len;
4086
4087   len = strlen (s);
4088   if (len <= 0x7f)
4089     {
4090       if (! ieee_write_byte (info, len))
4091         return false;
4092     }
4093   else if (len <= 0xff)
4094     {
4095       if (! ieee_write_byte (info, (int) ieee_extension_length_1_enum)
4096           || ! ieee_write_byte (info, len))
4097         return false;
4098     }
4099   else if (len <= 0xffff)
4100     {
4101       if (! ieee_write_byte (info, (int) ieee_extension_length_2_enum)
4102           || ! ieee_write_2bytes (info, len))
4103         return false;
4104     }
4105   else
4106     {
4107       fprintf (stderr, "IEEE string length overflow: %u\n", len);
4108       return false;
4109     }
4110
4111   for (; *s != '\0'; s++)
4112     if (! ieee_write_byte (info, *s))
4113       return false;
4114
4115   return true;
4116 }
4117
4118 /* Write out an ASN record.  */
4119
4120 static boolean
4121 ieee_write_asn (info, indx, val)
4122      struct ieee_handle *info;
4123      unsigned int indx;
4124      bfd_vma val;
4125 {
4126   return (ieee_write_2bytes (info, (int) ieee_asn_record_enum)
4127           && ieee_write_number (info, indx)
4128           && ieee_write_number (info, val));
4129 }
4130
4131 /* Write out an ATN65 record.  */
4132
4133 static boolean
4134 ieee_write_atn65 (info, indx, s)
4135      struct ieee_handle *info;
4136      unsigned int indx;
4137      const char *s;
4138 {
4139   return (ieee_write_2bytes (info, (int) ieee_atn_record_enum)
4140           && ieee_write_number (info, indx)
4141           && ieee_write_number (info, 0)
4142           && ieee_write_number (info, 65)
4143           && ieee_write_id (info, s));
4144 }
4145
4146 /* Push a type index onto the type stack.  */
4147
4148 static boolean
4149 ieee_push_type (info, indx, size, unsignedp, localp)
4150      struct ieee_handle *info;
4151      unsigned int indx;
4152      unsigned int size;
4153      boolean unsignedp;
4154      boolean localp;
4155 {
4156   struct ieee_type_stack *ts;
4157
4158   ts = (struct ieee_type_stack *) xmalloc (sizeof *ts);
4159   memset (ts, 0, sizeof *ts);
4160
4161   ts->type.indx = indx;
4162   ts->type.size = size;
4163   ts->type.unsignedp = unsignedp;
4164   ts->type.localp = localp;
4165
4166   ts->next = info->type_stack;
4167   info->type_stack = ts;
4168
4169   return true;
4170 }
4171
4172 /* Pop a type index off the type stack.  */
4173
4174 static unsigned int
4175 ieee_pop_type (info)
4176      struct ieee_handle *info;
4177 {
4178   return ieee_pop_type_used (info, true);
4179 }
4180
4181 /* Pop an unused type index off the type stack.  */
4182
4183 static void
4184 ieee_pop_unused_type (info)
4185      struct ieee_handle *info;
4186 {
4187   (void) ieee_pop_type_used (info, false);
4188 }
4189
4190 /* Pop a used or unused type index off the type stack.  */
4191
4192 static unsigned int
4193 ieee_pop_type_used (info, used)
4194      struct ieee_handle *info;
4195      boolean used;
4196 {
4197   struct ieee_type_stack *ts;
4198   unsigned int ret;
4199
4200   ts = info->type_stack;
4201   assert (ts != NULL);
4202
4203   /* If this is a function type, and we need it, we need to append the
4204      actual definition to the typedef block now.  */
4205   if (used && ! ieee_buffer_emptyp (&ts->type.fndef))
4206     {
4207       struct ieee_buflist *buflist;
4208
4209       if (ts->type.localp)
4210         {
4211           /* Make sure we have started the types block.  */
4212           if (ieee_buffer_emptyp (&info->types))
4213             {
4214               if (! ieee_change_buffer (info, &info->types)
4215                   || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4216                   || ! ieee_write_byte (info, 1)
4217                   || ! ieee_write_number (info, 0)
4218                   || ! ieee_write_id (info, info->modname))
4219                 return false;
4220             }
4221           buflist = &info->types;
4222         }
4223       else
4224         {
4225           /* Make sure we started the global type block.  */
4226           if (ieee_buffer_emptyp (&info->global_types))
4227             {
4228               if (! ieee_change_buffer (info, &info->global_types)
4229                   || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4230                   || ! ieee_write_byte (info, 2)
4231                   || ! ieee_write_number (info, 0)
4232                   || ! ieee_write_id (info, ""))
4233                 return false;
4234             }
4235           buflist = &info->global_types;
4236         }
4237
4238       if (! ieee_append_buffer (info, buflist, &ts->type.fndef))
4239         return false;
4240     }
4241
4242   ret = ts->type.indx;
4243   info->type_stack = ts->next;
4244   free (ts);
4245   return ret;
4246 }
4247
4248 /* Add a range of bytes included in the current compilation unit.  */
4249
4250 static boolean
4251 ieee_add_range (info, global, low, high)
4252      struct ieee_handle *info;
4253      boolean global;
4254      bfd_vma low;
4255      bfd_vma high;
4256 {
4257   struct ieee_range **plist, *r, **pr;
4258
4259   if (low == (bfd_vma) -1 || high == (bfd_vma) -1 || low == high)
4260     return true;
4261
4262   if (global)
4263     plist = &info->global_ranges;
4264   else
4265     plist = &info->ranges;
4266
4267   for (r = *plist; r != NULL; r = r->next)
4268     {
4269       if (high >= r->low && low <= r->high)
4270         {
4271           /* The new range overlaps r.  */
4272           if (low < r->low)
4273             r->low = low;
4274           if (high > r->high)
4275             r->high = high;
4276           pr = &r->next;
4277           while (*pr != NULL && (*pr)->low <= r->high)
4278             {
4279               struct ieee_range *n;
4280
4281               if ((*pr)->high > r->high)
4282                 r->high = (*pr)->high;
4283               n = (*pr)->next;
4284               free (*pr);
4285               *pr = n;
4286             }
4287           return true;
4288         }
4289     }
4290
4291   r = (struct ieee_range *) xmalloc (sizeof *r);
4292   memset (r, 0, sizeof *r);
4293
4294   r->low = low;
4295   r->high = high;
4296
4297   /* Store the ranges sorted by address.  */
4298   for (pr = plist; *pr != NULL; pr = &(*pr)->next)
4299     if ((*pr)->low > high)
4300       break;
4301   r->next = *pr;
4302   *pr = r;
4303
4304   return true;
4305 }
4306
4307 /* Start a new range for which we only have the low address.  */
4308
4309 static boolean
4310 ieee_start_range (info, low)
4311      struct ieee_handle *info;
4312      bfd_vma low;
4313 {
4314   struct ieee_range *r;
4315
4316   r = (struct ieee_range *) xmalloc (sizeof *r);
4317   memset (r, 0, sizeof *r);
4318   r->low = low;
4319   r->next = info->pending_ranges;
4320   info->pending_ranges = r;
4321   return true;
4322 }
4323
4324 /* Finish a range started by ieee_start_range.  */
4325
4326 static boolean
4327 ieee_end_range (info, high)
4328      struct ieee_handle *info;
4329      bfd_vma high;
4330 {
4331   struct ieee_range *r;
4332   bfd_vma low;
4333
4334   assert (info->pending_ranges != NULL);
4335   r = info->pending_ranges;
4336   low = r->low;
4337   info->pending_ranges = r->next;
4338   free (r);
4339   return ieee_add_range (info, false, low, high);
4340 }
4341
4342 /* Start defining a type.  */
4343
4344 static boolean
4345 ieee_define_type (info, size, unsignedp, localp)
4346      struct ieee_handle *info;
4347      unsigned int size;
4348      boolean unsignedp;
4349      boolean localp;
4350 {
4351   return ieee_define_named_type (info, (const char *) NULL,
4352                                  (unsigned int) -1, size, unsignedp,
4353                                  localp, (struct ieee_buflist *) NULL);
4354 }
4355
4356 /* Start defining a named type.  */
4357
4358 static boolean
4359 ieee_define_named_type (info, name, indx, size, unsignedp, localp, buflist)
4360      struct ieee_handle *info;
4361      const char *name;
4362      unsigned int indx;
4363      unsigned int size;
4364      boolean unsignedp;
4365      boolean localp;
4366      struct ieee_buflist *buflist;
4367 {
4368   unsigned int type_indx;
4369   unsigned int name_indx;
4370
4371   if (indx != (unsigned int) -1)
4372     type_indx = indx;
4373   else
4374     {
4375       type_indx = info->type_indx;
4376       ++info->type_indx;
4377     }
4378
4379   name_indx = info->name_indx;
4380   ++info->name_indx;
4381
4382   if (name == NULL)
4383     name = "";
4384
4385   /* If we were given a buffer, use it; otherwise, use either the
4386      local or the global type information, and make sure that the type
4387      block is started.  */
4388   if (buflist != NULL)
4389     {
4390       if (! ieee_change_buffer (info, buflist))
4391         return false;
4392     }
4393   else if (localp)
4394     {
4395       if (! ieee_buffer_emptyp (&info->types))
4396         {
4397           if (! ieee_change_buffer (info, &info->types))
4398             return false;
4399         }
4400       else
4401         {
4402           if (! ieee_change_buffer (info, &info->types)
4403               || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4404               || ! ieee_write_byte (info, 1)
4405               || ! ieee_write_number (info, 0)
4406               || ! ieee_write_id (info, info->modname))
4407             return false;
4408         }
4409     }
4410   else
4411     {
4412       if (! ieee_buffer_emptyp (&info->global_types))
4413         {
4414           if (! ieee_change_buffer (info, &info->global_types))
4415             return false;
4416         }
4417       else
4418         {
4419           if (! ieee_change_buffer (info, &info->global_types)
4420               || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4421               || ! ieee_write_byte (info, 2)
4422               || ! ieee_write_number (info, 0)
4423               || ! ieee_write_id (info, ""))
4424             return false;
4425         }
4426     }
4427
4428   /* Push the new type on the type stack, write out an NN record, and
4429      write out the start of a TY record.  The caller will then finish
4430      the TY record.  */
4431   if (! ieee_push_type (info, type_indx, size, unsignedp, localp))
4432     return false;
4433
4434   return (ieee_write_byte (info, (int) ieee_nn_record)
4435           && ieee_write_number (info, name_indx)
4436           && ieee_write_id (info, name)
4437           && ieee_write_byte (info, (int) ieee_ty_record_enum)
4438           && ieee_write_number (info, type_indx)
4439           && ieee_write_byte (info, 0xce)
4440           && ieee_write_number (info, name_indx));
4441 }
4442
4443 /* Get an entry to the list of modified versions of a type.  */
4444
4445 static struct ieee_modified_type *
4446 ieee_get_modified_info (info, indx)
4447      struct ieee_handle *info;
4448      unsigned int indx;
4449 {
4450   if (indx >= info->modified_alloc)
4451     {
4452       unsigned int nalloc;
4453
4454       nalloc = info->modified_alloc;
4455       if (nalloc == 0)
4456         nalloc = 16;
4457       while (indx >= nalloc)
4458         nalloc *= 2;
4459       info->modified = ((struct ieee_modified_type *)
4460                         xrealloc (info->modified,
4461                                   nalloc * sizeof *info->modified));
4462       memset (info->modified + info->modified_alloc, 0,
4463               (nalloc - info->modified_alloc) * sizeof *info->modified);
4464       info->modified_alloc = nalloc;
4465     }
4466
4467   return info->modified + indx;
4468 }
4469 \f
4470 /* Routines for the hash table mapping names to types.  */
4471
4472 /* Initialize an entry in the hash table.  */
4473
4474 static struct bfd_hash_entry *
4475 ieee_name_type_newfunc (entry, table, string)
4476      struct bfd_hash_entry *entry;
4477      struct bfd_hash_table *table;
4478      const char *string;
4479 {
4480   struct ieee_name_type_hash_entry *ret =
4481     (struct ieee_name_type_hash_entry *) entry;
4482
4483   /* Allocate the structure if it has not already been allocated by a
4484      subclass.  */
4485   if (ret == NULL)
4486     ret = ((struct ieee_name_type_hash_entry *)
4487            bfd_hash_allocate (table, sizeof *ret));
4488   if (ret == NULL)
4489     return NULL;
4490
4491   /* Call the allocation method of the superclass.  */
4492   ret = ((struct ieee_name_type_hash_entry *)
4493          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
4494   if (ret)
4495     {
4496       /* Set local fields.  */
4497       ret->types = NULL;
4498     }
4499
4500   return (struct bfd_hash_entry *) ret;
4501 }
4502
4503 /* Look up an entry in the hash table.  */
4504
4505 #define ieee_name_type_hash_lookup(table, string, create, copy) \
4506   ((struct ieee_name_type_hash_entry *) \
4507    bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
4508
4509 /* Traverse the hash table.  */
4510
4511 #define ieee_name_type_hash_traverse(table, func, info)                 \
4512   (bfd_hash_traverse                                                    \
4513    (&(table)->root,                                                     \
4514     (boolean (*) PARAMS ((struct bfd_hash_entry *, PTR))) (func),       \
4515     (info)))
4516 \f
4517 /* The general routine to write out IEEE debugging information.  */
4518
4519 boolean
4520 write_ieee_debugging_info (abfd, dhandle)
4521      bfd *abfd;
4522      PTR dhandle;
4523 {
4524   struct ieee_handle info;
4525   asection *s;
4526   const char *err;
4527   struct ieee_buf *b;
4528
4529   memset (&info, 0, sizeof info);
4530   info.abfd = abfd;
4531   info.type_indx = 256;
4532   info.name_indx = 32;
4533
4534   if (! bfd_hash_table_init (&info.typedefs.root, ieee_name_type_newfunc)
4535       || ! bfd_hash_table_init (&info.tags.root, ieee_name_type_newfunc))
4536     return false;
4537
4538   if (! ieee_init_buffer (&info, &info.global_types)
4539       || ! ieee_init_buffer (&info, &info.data)
4540       || ! ieee_init_buffer (&info, &info.types)
4541       || ! ieee_init_buffer (&info, &info.vars)
4542       || ! ieee_init_buffer (&info, &info.cxx)
4543       || ! ieee_init_buffer (&info, &info.linenos)
4544       || ! ieee_init_buffer (&info, &info.fntype)
4545       || ! ieee_init_buffer (&info, &info.fnargs))
4546     return false;
4547
4548   if (! debug_write (dhandle, &ieee_fns, (PTR) &info))
4549     return false;
4550
4551   if (info.filename != NULL)
4552     {
4553       if (! ieee_finish_compilation_unit (&info))
4554         return false;
4555     }
4556
4557   /* Put any undefined tags in the global typedef information.  */
4558   info.error = false;
4559   ieee_name_type_hash_traverse (&info.tags,
4560                                 ieee_write_undefined_tag,
4561                                 (PTR) &info);
4562   if (info.error)
4563     return false;
4564
4565   /* Prepend the global typedef information to the other data.  */
4566   if (! ieee_buffer_emptyp (&info.global_types))
4567     {
4568       if (! ieee_change_buffer (&info, &info.global_types)
4569           || ! ieee_write_byte (&info, (int) ieee_be_record_enum))
4570         return false;
4571
4572       if (! ieee_append_buffer (&info, &info.global_types, &info.data))
4573         return false;
4574       info.data = info.global_types;
4575     }
4576
4577   /* Make sure that we have declare BB11 blocks for each range in the
4578      file.  They are added to info->vars.  */
4579   info.error = false;
4580   if (! ieee_init_buffer (&info, &info.vars))
4581     return false;
4582   bfd_map_over_sections (abfd, ieee_add_bb11_blocks, (PTR) &info);
4583   if (info.error)
4584     return false;
4585   if (! ieee_buffer_emptyp (&info.vars))
4586     {
4587       if (! ieee_change_buffer (&info, &info.vars)
4588           || ! ieee_write_byte (&info, (int) ieee_be_record_enum))
4589         return false;
4590
4591       if (! ieee_append_buffer (&info, &info.data, &info.vars))
4592         return false;
4593     }
4594
4595   /* Now all the data is in info.data.  Write it out to the BFD.  We
4596      normally would need to worry about whether all the other sections
4597      are set up yet, but the IEEE backend will handle this particular
4598      case correctly regardless.  */
4599   if (ieee_buffer_emptyp (&info.data))
4600     {
4601       /* There is no debugging information.  */
4602       return true;
4603     }
4604   err = NULL;
4605   s = bfd_make_section (abfd, ".debug");
4606   if (s == NULL)
4607     err = "bfd_make_section";
4608   if (err == NULL)
4609     {
4610       if (! bfd_set_section_flags (abfd, s, SEC_DEBUGGING | SEC_HAS_CONTENTS))
4611         err = "bfd_set_section_flags";
4612     }
4613   if (err == NULL)
4614     {
4615       bfd_size_type size;
4616
4617       size = 0;
4618       for (b = info.data.head; b != NULL; b = b->next)
4619         size += b->c;
4620       if (! bfd_set_section_size (abfd, s, size))
4621         err = "bfd_set_section_size";
4622     }
4623   if (err == NULL)
4624     {
4625       file_ptr offset;
4626
4627       offset = 0;
4628       for (b = info.data.head; b != NULL; b = b->next)
4629         {
4630           if (! bfd_set_section_contents (abfd, s, b->buf, offset, b->c))
4631             {
4632               err = "bfd_set_section_contents";
4633               break;
4634             }
4635           offset += b->c;
4636         }
4637     }
4638
4639   if (err != NULL)
4640     {
4641       fprintf (stderr, "%s: %s: %s\n", bfd_get_filename (abfd), err,
4642                bfd_errmsg (bfd_get_error ()));
4643       return false;
4644     }
4645
4646   bfd_hash_table_free (&info.typedefs.root);
4647   bfd_hash_table_free (&info.tags.root);
4648
4649   return true;
4650 }
4651
4652 /* Write out information for an undefined tag.  This is called via
4653    ieee_name_type_hash_traverse.  */
4654
4655 static boolean
4656 ieee_write_undefined_tag (h, p)
4657      struct ieee_name_type_hash_entry *h;
4658      PTR p;
4659 {
4660   struct ieee_handle *info = (struct ieee_handle *) p;
4661   struct ieee_name_type *nt;
4662
4663   for (nt = h->types; nt != NULL; nt = nt->next)
4664     {
4665       unsigned int name_indx;
4666       char code;
4667
4668       if (nt->kind == DEBUG_KIND_ILLEGAL)
4669         continue;
4670
4671       if (ieee_buffer_emptyp (&info->global_types))
4672         {
4673           if (! ieee_change_buffer (info, &info->global_types)
4674               || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4675               || ! ieee_write_byte (info, 2)
4676               || ! ieee_write_number (info, 0)
4677               || ! ieee_write_id (info, ""))
4678             {
4679               info->error = true;
4680               return false;
4681             }
4682         }
4683       else
4684         {
4685           if (! ieee_change_buffer (info, &info->global_types))
4686             {
4687               info->error = true;
4688               return false;
4689             }
4690         }
4691
4692       name_indx = info->name_indx;
4693       ++info->name_indx;
4694       if (! ieee_write_byte (info, (int) ieee_nn_record)
4695           || ! ieee_write_number (info, name_indx)
4696           || ! ieee_write_id (info, nt->type.name)
4697           || ! ieee_write_byte (info, (int) ieee_ty_record_enum)
4698           || ! ieee_write_number (info, nt->type.indx)
4699           || ! ieee_write_byte (info, 0xce)
4700           || ! ieee_write_number (info, name_indx))
4701         {
4702           info->error = true;
4703           return false;
4704         }
4705
4706       switch (nt->kind)
4707         {
4708         default:
4709           abort ();
4710           info->error = true;
4711           return false;
4712         case DEBUG_KIND_STRUCT:
4713         case DEBUG_KIND_CLASS:
4714           code = 'S';
4715           break;
4716         case DEBUG_KIND_UNION:
4717         case DEBUG_KIND_UNION_CLASS:
4718           code = 'U';
4719           break;
4720         case DEBUG_KIND_ENUM:
4721           code = 'E';
4722           break;
4723         }
4724       if (! ieee_write_number (info, code)
4725           || ! ieee_write_number (info, 0))
4726         {
4727           info->error = true;
4728           return false;
4729         }
4730     }
4731
4732   return true;
4733 }
4734
4735 /* Start writing out information for a compilation unit.  */
4736
4737 static boolean
4738 ieee_start_compilation_unit (p, filename)
4739      PTR p;
4740      const char *filename;
4741 {
4742   struct ieee_handle *info = (struct ieee_handle *) p;
4743   const char *modname;
4744   char *c, *s;
4745   unsigned int nindx;
4746
4747   if (info->filename != NULL)
4748     {
4749       if (! ieee_finish_compilation_unit (info))
4750         return false;
4751     }
4752
4753   info->filename = filename;
4754   modname = strrchr (filename, '/');
4755   if (modname != NULL)
4756     ++modname;
4757   else
4758     {
4759       modname = strrchr (filename, '\\');
4760       if (modname != NULL)
4761         ++modname;
4762       else
4763         modname = filename;
4764     }
4765   c = xstrdup (modname);
4766   s = strrchr (c, '.');
4767   if (s != NULL)
4768     *s = '\0';
4769   info->modname = c;
4770
4771   if (! ieee_init_buffer (info, &info->types)
4772       || ! ieee_init_buffer (info, &info->vars)
4773       || ! ieee_init_buffer (info, &info->cxx)
4774       || ! ieee_init_buffer (info, &info->linenos))
4775     return false;
4776   info->ranges = NULL;
4777
4778   /* Always include a BB1 and a BB3 block.  That is what the output of
4779      the MRI linker seems to look like.  */
4780   if (! ieee_change_buffer (info, &info->types)
4781       || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4782       || ! ieee_write_byte (info, 1)
4783       || ! ieee_write_number (info, 0)
4784       || ! ieee_write_id (info, info->modname))
4785     return false;
4786
4787   nindx = info->name_indx;
4788   ++info->name_indx;
4789   if (! ieee_change_buffer (info, &info->vars)
4790       || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4791       || ! ieee_write_byte (info, 3)
4792       || ! ieee_write_number (info, 0)
4793       || ! ieee_write_id (info, info->modname))
4794     return false;
4795
4796   return true;
4797 }
4798
4799 /* Finish up a compilation unit.  */
4800
4801 static boolean
4802 ieee_finish_compilation_unit (info)
4803      struct ieee_handle *info;
4804 {
4805   struct ieee_range *r;
4806
4807   if (! ieee_buffer_emptyp (&info->types))
4808     {
4809       if (! ieee_change_buffer (info, &info->types)
4810           || ! ieee_write_byte (info, (int) ieee_be_record_enum))
4811         return false;
4812     }
4813
4814   if (! ieee_buffer_emptyp (&info->cxx))
4815     {
4816       /* Append any C++ information to the global function and
4817          variable information.  */
4818       assert (! ieee_buffer_emptyp (&info->vars));
4819       if (! ieee_change_buffer (info, &info->vars))
4820         return false;
4821
4822       /* We put the pmisc records in a dummy procedure, just as the
4823          MRI compiler does.  */
4824       if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
4825           || ! ieee_write_byte (info, 6)
4826           || ! ieee_write_number (info, 0)
4827           || ! ieee_write_id (info, "__XRYCPP")
4828           || ! ieee_write_number (info, 0)
4829           || ! ieee_write_number (info, 0)
4830           || ! ieee_write_number (info, info->highaddr - 1)
4831           || ! ieee_append_buffer (info, &info->vars, &info->cxx)
4832           || ! ieee_change_buffer (info, &info->vars)
4833           || ! ieee_write_byte (info, (int) ieee_be_record_enum)
4834           || ! ieee_write_number (info, info->highaddr - 1))
4835         return false;
4836     }
4837
4838   if (! ieee_buffer_emptyp (&info->vars))
4839     {
4840       if (! ieee_change_buffer (info, &info->vars)
4841           || ! ieee_write_byte (info, (int) ieee_be_record_enum))
4842         return false;
4843     }
4844
4845   if (info->pending_lineno_filename != NULL)
4846     {
4847       /* Force out the pending line number.  */
4848       if (! ieee_lineno ((PTR) info, (const char *) NULL, 0, (bfd_vma) -1))
4849         return false;
4850     }
4851   if (! ieee_buffer_emptyp (&info->linenos))
4852     {
4853       if (! ieee_change_buffer (info, &info->linenos)
4854           || ! ieee_write_byte (info, (int) ieee_be_record_enum))
4855         return false;
4856       if (strcmp (info->filename, info->lineno_filename) != 0)
4857         {
4858           /* We were not in the main file.  We just closed the
4859              included line number block, and now we must close the
4860              main line number block.  */
4861           if (! ieee_write_byte (info, (int) ieee_be_record_enum))
4862             return false;
4863         }
4864     }
4865
4866   if (! ieee_append_buffer (info, &info->data, &info->types)
4867       || ! ieee_append_buffer (info, &info->data, &info->vars)
4868       || ! ieee_append_buffer (info, &info->data, &info->linenos))
4869     return false;
4870
4871   /* Build BB10/BB11 blocks based on the ranges we recorded.  */
4872   if (! ieee_change_buffer (info, &info->data))
4873     return false;
4874
4875   if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
4876       || ! ieee_write_byte (info, 10)
4877       || ! ieee_write_number (info, 0)
4878       || ! ieee_write_id (info, info->modname)
4879       || ! ieee_write_id (info, "")
4880       || ! ieee_write_number (info, 0)
4881       || ! ieee_write_id (info, "GNU objcopy"))
4882     return false;
4883
4884   for (r = info->ranges; r != NULL; r = r->next)
4885     {
4886       bfd_vma low, high;
4887       asection *s;
4888       int kind;
4889
4890       low = r->low;
4891       high = r->high;
4892
4893       /* Find the section corresponding to this range.  */
4894       for (s = info->abfd->sections; s != NULL; s = s->next)
4895         {
4896           if (bfd_get_section_vma (info->abfd, s) <= low
4897               && high <= (bfd_get_section_vma (info->abfd, s)
4898                           + bfd_section_size (info->abfd, s)))
4899             break;
4900         }
4901
4902       if (s == NULL)
4903         {
4904           /* Just ignore this range.  */
4905           continue;
4906         }
4907
4908       /* Coalesce ranges if it seems reasonable.  */
4909       while (r->next != NULL
4910              && high + 64 >= r->next->low
4911              && (r->next->high
4912                  <= (bfd_get_section_vma (info->abfd, s)
4913                      + bfd_section_size (info->abfd, s))))
4914         {
4915           r = r->next;
4916           high = r->high;
4917         }
4918
4919       if ((s->flags & SEC_CODE) != 0)
4920         kind = 1;
4921       else if ((s->flags & SEC_READONLY) != 0)
4922         kind = 3;
4923       else
4924         kind = 2;
4925
4926       if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
4927           || ! ieee_write_byte (info, 11)
4928           || ! ieee_write_number (info, 0)
4929           || ! ieee_write_id (info, "")
4930           || ! ieee_write_number (info, kind)
4931           || ! ieee_write_number (info, s->index + IEEE_SECTION_NUMBER_BASE)
4932           || ! ieee_write_number (info, low)
4933           || ! ieee_write_byte (info, (int) ieee_be_record_enum)
4934           || ! ieee_write_number (info, high - low))
4935         return false;
4936
4937       /* Add this range to the list of global ranges.  */
4938       if (! ieee_add_range (info, true, low, high))
4939         return false;
4940     }
4941
4942   if (! ieee_write_byte (info, (int) ieee_be_record_enum))
4943     return false;
4944
4945   return true;
4946 }
4947
4948 /* Add BB11 blocks describing each range that we have not already
4949    described.  */
4950
4951 static void
4952 ieee_add_bb11_blocks (abfd, sec, data)
4953      bfd *abfd;
4954      asection *sec;
4955      PTR data;
4956 {
4957   struct ieee_handle *info = (struct ieee_handle *) data;
4958   bfd_vma low, high;
4959   struct ieee_range *r;
4960
4961   low = bfd_get_section_vma (abfd, sec);
4962   high = low + bfd_section_size (abfd, sec);
4963
4964   /* Find the first range at or after this section.  The ranges are
4965      sorted by address.  */
4966   for (r = info->global_ranges; r != NULL; r = r->next)
4967     if (r->high > low)
4968       break;
4969
4970   while (low < high)
4971     {
4972       if (r == NULL || r->low >= high)
4973         {
4974           if (! ieee_add_bb11 (info, sec, low, high))
4975             info->error = true;
4976           return;
4977         }
4978
4979       if (low < r->low)
4980         {
4981           if (! ieee_add_bb11 (info, sec, low, r->low))
4982             {
4983               info->error = true;
4984               return;
4985             }
4986         }
4987       low = r->high;
4988
4989       r = r->next;
4990     }
4991 }
4992
4993 /* Add a single BB11 block for a range.  We add it to info->vars.  */
4994
4995 static boolean
4996 ieee_add_bb11 (info, sec, low, high)
4997      struct ieee_handle *info;
4998      asection *sec;
4999      bfd_vma low;
5000      bfd_vma high;
5001 {
5002   int kind;
5003
5004   if (! ieee_buffer_emptyp (&info->vars))
5005     {
5006       if (! ieee_change_buffer (info, &info->vars))
5007         return false;
5008     }
5009   else
5010     {
5011       const char *filename, *modname;
5012       char *c, *s;
5013
5014       /* Start the enclosing BB10 block.  */
5015       filename = bfd_get_filename (info->abfd);
5016       modname = strrchr (filename, '/');
5017       if (modname != NULL)
5018         ++modname;
5019       else
5020         {
5021           modname = strrchr (filename, '\\');
5022           if (modname != NULL)
5023             ++modname;
5024           else
5025             modname = filename;
5026         }
5027       c = xstrdup (modname);
5028       s = strrchr (c, '.');
5029       if (s != NULL)
5030         *s = '\0';
5031
5032       if (! ieee_change_buffer (info, &info->vars)
5033           || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
5034           || ! ieee_write_byte (info, 10)
5035           || ! ieee_write_number (info, 0)
5036           || ! ieee_write_id (info, c)
5037           || ! ieee_write_id (info, "")
5038           || ! ieee_write_number (info, 0)
5039           || ! ieee_write_id (info, "GNU objcopy"))
5040         return false;
5041
5042       free (c);
5043     }
5044
5045   if ((sec->flags & SEC_CODE) != 0)
5046     kind = 1;
5047   else if ((sec->flags & SEC_READONLY) != 0)
5048     kind = 3;
5049   else
5050     kind = 2;
5051
5052   if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
5053       || ! ieee_write_byte (info, 11)
5054       || ! ieee_write_number (info, 0)
5055       || ! ieee_write_id (info, "")
5056       || ! ieee_write_number (info, kind)
5057       || ! ieee_write_number (info, sec->index + IEEE_SECTION_NUMBER_BASE)
5058       || ! ieee_write_number (info, low)
5059       || ! ieee_write_byte (info, (int) ieee_be_record_enum)
5060       || ! ieee_write_number (info, high - low))
5061     return false;
5062
5063   return true;
5064 }
5065
5066 /* Start recording information from a particular source file.  This is
5067    used to record which file defined which types, variables, etc.  It
5068    is not used for line numbers, since the lineno entry point passes
5069    down the file name anyhow.  IEEE debugging information doesn't seem
5070    to store this information anywhere.  */
5071
5072 /*ARGSUSED*/
5073 static boolean
5074 ieee_start_source (p, filename)
5075      PTR p;
5076      const char *filename;
5077 {
5078   return true;
5079 }
5080
5081 /* Make an empty type.  */
5082
5083 static boolean
5084 ieee_empty_type (p)
5085      PTR p;
5086 {
5087   struct ieee_handle *info = (struct ieee_handle *) p;
5088
5089   return ieee_push_type (info, 0, 0, false, false);
5090 }
5091
5092 /* Make a void type.  */
5093
5094 static boolean
5095 ieee_void_type (p)
5096      PTR p;
5097 {
5098   struct ieee_handle *info = (struct ieee_handle *) p;
5099
5100   return ieee_push_type (info, 1, 0, false, false);
5101 }
5102
5103 /* Make an integer type.  */
5104
5105 static boolean
5106 ieee_int_type (p, size, unsignedp)
5107      PTR p;
5108      unsigned int size;
5109      boolean unsignedp;
5110 {
5111   struct ieee_handle *info = (struct ieee_handle *) p;
5112   unsigned int indx;
5113
5114   switch (size)
5115     {
5116     case 1:
5117       indx = (int) builtin_signed_char;
5118       break;
5119     case 2:
5120       indx = (int) builtin_signed_short_int;
5121       break;
5122     case 4:
5123       indx = (int) builtin_signed_long;
5124       break;
5125     case 8:
5126       indx = (int) builtin_signed_long_long;
5127       break;
5128     default:
5129       fprintf (stderr, "IEEE unsupported integer type size %u\n", size);
5130       return false;
5131     }
5132
5133   if (unsignedp)
5134     ++indx;
5135
5136   return ieee_push_type (info, indx, size, unsignedp, false);
5137 }
5138
5139 /* Make a floating point type.  */
5140
5141 static boolean
5142 ieee_float_type (p, size)
5143      PTR p;
5144      unsigned int size;
5145 {
5146   struct ieee_handle *info = (struct ieee_handle *) p;
5147   unsigned int indx;
5148
5149   switch (size)
5150     {
5151     case 4:
5152       indx = (int) builtin_float;
5153       break;
5154     case 8:
5155       indx = (int) builtin_double;
5156       break;
5157     case 12:
5158       /* FIXME: This size really depends upon the processor.  */
5159       indx = (int) builtin_long_double;
5160       break;
5161     case 16:
5162       indx = (int) builtin_long_long_double;
5163       break;
5164     default:
5165       fprintf (stderr, "IEEE unsupported float type size %u\n", size);
5166       return false;
5167     }
5168
5169   return ieee_push_type (info, indx, size, false, false);
5170 }
5171
5172 /* Make a complex type.  */
5173
5174 static boolean
5175 ieee_complex_type (p, size)
5176      PTR p;
5177      unsigned int size;
5178 {
5179   struct ieee_handle *info = (struct ieee_handle *) p;
5180   char code;
5181
5182   switch (size)
5183     {
5184     case 4:
5185       code = 'c';
5186       break;
5187     case 8:
5188       code = 'd';
5189       break;
5190     default:
5191       fprintf (stderr, "IEEE unsupported complex type size %u\n", size);
5192       return false;
5193     }
5194
5195   /* FIXME: I don't know what the string is for.  */
5196   return (ieee_define_type (info, size, false, false)
5197           && ieee_write_number (info, code)
5198           && ieee_write_id (info, ""));
5199 }
5200
5201 /* Make a boolean type.  IEEE doesn't support these, so we just make
5202    an integer type instead.  */
5203
5204 static boolean
5205 ieee_bool_type (p, size)
5206      PTR p;
5207      unsigned int size;
5208 {
5209   return ieee_int_type (p, size, true);
5210 }
5211
5212 /* Make an enumeration.  */
5213
5214 static boolean
5215 ieee_enum_type (p, tag, names, vals)
5216      PTR p;
5217      const char *tag;
5218      const char **names;
5219      bfd_signed_vma *vals;
5220 {
5221   struct ieee_handle *info = (struct ieee_handle *) p;
5222   struct ieee_defined_enum *e;
5223   boolean localp, simple;
5224   int i;
5225
5226   localp = false;
5227   for (e = info->enums; e != NULL; e = e->next)
5228     {
5229       if (tag == NULL)
5230         {
5231           if (e->tag != NULL)
5232             continue;
5233         }
5234       else
5235         {
5236           if (e->tag == NULL
5237               || tag[0] != e->tag[0]
5238               || strcmp (tag, e->tag) != 0)
5239             continue;
5240         }
5241
5242       if (names != NULL && e->names != NULL)
5243         {
5244           for (i = 0; names[i] != NULL && e->names[i] != NULL; i++)
5245             {
5246               if (names[i][0] != e->names[i][0]
5247                   || vals[i] != e->vals[i]
5248                   || strcmp (names[i], e->names[i]) != 0)
5249                 break;
5250             }
5251         }
5252
5253       if ((names == NULL && e->names == NULL)
5254           || (names[i] == NULL && e->names[i] == NULL))
5255         {
5256           /* We've seen this enum before.  */
5257           return ieee_push_type (info, e->indx, 0, true, false);
5258         }
5259
5260       if (tag != NULL)
5261         {
5262           /* We've already seen an enum of the same name, so we must make
5263              sure to output this one locally.  */
5264           localp = true;
5265           break;
5266         }
5267     }
5268
5269   /* If this is a simple enumeration, in which the values start at 0
5270      and always increment by 1, we can use type E.  Otherwise we must
5271      use type N.  */
5272
5273   simple = true;
5274   if (names != NULL)
5275     {
5276       for (i = 0; names[i] != NULL; i++)
5277         {
5278           if (vals[i] != i)
5279             {
5280               simple = false;
5281               break;
5282             }
5283         }
5284     }
5285
5286   if (! ieee_define_named_type (info, tag, (unsigned int) -1, 0,
5287                                 true, localp, (struct ieee_buflist *) NULL)
5288       || ! ieee_write_number (info, simple ? 'E' : 'N'))
5289     return false;
5290   if (simple)
5291     {
5292       /* FIXME: This is supposed to be the enumeration size, but we
5293          don't store that.  */
5294       if (! ieee_write_number (info, 4))
5295         return false;
5296     }
5297   if (names != NULL)
5298     {
5299       for (i = 0; names[i] != NULL; i++)
5300         {
5301           if (! ieee_write_id (info, names[i]))
5302             return false;
5303           if (! simple)
5304             {
5305               if (! ieee_write_number (info, vals[i]))
5306                 return false;
5307             }
5308         }
5309     }
5310
5311   if (! localp)
5312     {
5313       e = (struct ieee_defined_enum *) xmalloc (sizeof *e);
5314       memset (e, 0, sizeof *e);
5315
5316       e->indx = info->type_stack->type.indx;
5317       e->tag = tag;
5318       e->names = names;
5319       e->vals = vals;
5320
5321       e->next = info->enums;
5322       info->enums = e;
5323     }
5324
5325   return true;
5326 }
5327
5328 /* Make a pointer type.  */
5329
5330 static boolean
5331 ieee_pointer_type (p)
5332      PTR p;
5333 {
5334   struct ieee_handle *info = (struct ieee_handle *) p;
5335   boolean localp;
5336   unsigned int indx;
5337   struct ieee_modified_type *m = NULL;
5338
5339   localp = info->type_stack->type.localp;
5340   indx = ieee_pop_type (info);
5341
5342   /* A pointer to a simple builtin type can be obtained by adding 32.
5343      FIXME: Will this be a short pointer, and will that matter?  */
5344   if (indx < 32)
5345     return ieee_push_type (info, indx + 32, 0, true, false);
5346
5347   if (! localp)
5348     {
5349       m = ieee_get_modified_info (p, indx);
5350       if (m == NULL)
5351         return false;
5352
5353       /* FIXME: The size should depend upon the architecture.  */
5354       if (m->pointer > 0)
5355         return ieee_push_type (info, m->pointer, 4, true, false);
5356     }
5357
5358   if (! ieee_define_type (info, 4, true, localp)
5359       || ! ieee_write_number (info, 'P')
5360       || ! ieee_write_number (info, indx))
5361     return false;
5362
5363   if (! localp)
5364     m->pointer = info->type_stack->type.indx;
5365
5366   return true;
5367 }
5368
5369 /* Make a function type.  This will be called for a method, but we
5370    don't want to actually add it to the type table in that case.  We
5371    handle this by defining the type in a private buffer, and only
5372    adding that buffer to the typedef block if we are going to use it.  */
5373
5374 static boolean
5375 ieee_function_type (p, argcount, varargs)
5376      PTR p;
5377      int argcount;
5378      boolean varargs;
5379 {
5380   struct ieee_handle *info = (struct ieee_handle *) p;
5381   boolean localp;
5382   unsigned int *args = NULL;
5383   int i;
5384   unsigned int retindx;
5385   struct ieee_buflist fndef;
5386   struct ieee_modified_type *m;
5387
5388   localp = false;
5389
5390   if (argcount > 0)
5391     {
5392       args = (unsigned int *) xmalloc (argcount * sizeof *args);
5393       for (i = argcount - 1; i >= 0; i--)
5394         {
5395           if (info->type_stack->type.localp)
5396             localp = true;
5397           args[i] = ieee_pop_type (info);
5398         }
5399     }
5400   else if (argcount < 0)
5401     varargs = false;
5402
5403   if (info->type_stack->type.localp)
5404     localp = true;
5405   retindx = ieee_pop_type (info);
5406
5407   m = NULL;
5408   if (argcount < 0 && ! localp)
5409     {
5410       m = ieee_get_modified_info (p, retindx);
5411       if (m == NULL)
5412         return false;
5413
5414       if (m->function > 0)
5415         return ieee_push_type (info, m->function, 0, true, false);
5416     }
5417
5418   /* An attribute of 0x41 means that the frame and push mask are
5419      unknown.  */
5420   if (! ieee_init_buffer (info, &fndef)
5421       || ! ieee_define_named_type (info, (const char *) NULL,
5422                                    (unsigned int) -1, 0, true, localp,
5423                                    &fndef)
5424       || ! ieee_write_number (info, 'x')
5425       || ! ieee_write_number (info, 0x41)
5426       || ! ieee_write_number (info, 0)
5427       || ! ieee_write_number (info, 0)
5428       || ! ieee_write_number (info, retindx)
5429       || ! ieee_write_number (info, (bfd_vma) argcount + (varargs ? 1 : 0)))
5430     return false;
5431   if (argcount > 0)
5432     {
5433       for (i = 0; i < argcount; i++)
5434         if (! ieee_write_number (info, args[i]))
5435           return false;
5436       free (args);
5437     }
5438   if (varargs)
5439     {
5440       /* A varargs function is represented by writing out the last
5441          argument as type void *, although this makes little sense.  */
5442       if (! ieee_write_number (info, (bfd_vma) builtin_void + 32))
5443         return false;
5444     }
5445
5446   if (! ieee_write_number (info, 0))
5447     return false;
5448
5449   /* We wrote the information into fndef, in case we don't need it.
5450      It will be appended to info->types by ieee_pop_type.  */
5451   info->type_stack->type.fndef = fndef;
5452
5453   if (m != NULL)
5454     m->function = info->type_stack->type.indx;
5455
5456   return true;
5457 }
5458
5459 /* Make a reference type.  */
5460
5461 static boolean
5462 ieee_reference_type (p)
5463      PTR p;
5464 {
5465   struct ieee_handle *info = (struct ieee_handle *) p;
5466
5467   /* IEEE appears to record a normal pointer type, and then use a
5468      pmisc record to indicate that it is really a reference.  */
5469
5470   if (! ieee_pointer_type (p))
5471     return false;
5472   info->type_stack->type.referencep = true;
5473   return true;
5474 }
5475
5476 /* Make a range type.  */
5477
5478 static boolean
5479 ieee_range_type (p, low, high)
5480      PTR p;
5481      bfd_signed_vma low;
5482      bfd_signed_vma high;
5483 {
5484   struct ieee_handle *info = (struct ieee_handle *) p;
5485   unsigned int size;
5486   boolean unsignedp, localp;
5487
5488   size = info->type_stack->type.size;
5489   unsignedp = info->type_stack->type.unsignedp;
5490   localp = info->type_stack->type.localp;
5491   ieee_pop_unused_type (info);
5492   return (ieee_define_type (info, size, unsignedp, localp)
5493           && ieee_write_number (info, 'R')
5494           && ieee_write_number (info, (bfd_vma) low)
5495           && ieee_write_number (info, (bfd_vma) high)
5496           && ieee_write_number (info, unsignedp ? 0 : 1)
5497           && ieee_write_number (info, size));
5498 }
5499
5500 /* Make an array type.  */
5501
5502 /*ARGSUSED*/
5503 static boolean
5504 ieee_array_type (p, low, high, stringp)
5505      PTR p;
5506      bfd_signed_vma low;
5507      bfd_signed_vma high;
5508      boolean stringp;
5509 {
5510   struct ieee_handle *info = (struct ieee_handle *) p;
5511   unsigned int eleindx;
5512   boolean localp;
5513   struct ieee_modified_type *m = NULL;
5514   struct ieee_modified_array_type *a;
5515
5516   /* IEEE does not store the range, so we just ignore it.  */
5517   ieee_pop_unused_type (info);
5518   localp = info->type_stack->type.localp;
5519   eleindx = ieee_pop_type (info);
5520
5521   if (! localp)
5522     {
5523       m = ieee_get_modified_info (info, eleindx);
5524       if (m == NULL)
5525         return false;
5526
5527       for (a = m->arrays; a != NULL; a = a->next)
5528         {
5529           if (a->low == low && a->high == high)
5530             return ieee_push_type (info, a->indx, 0, false, false);
5531         }
5532     }
5533
5534   if (! ieee_define_type (info, 0, false, localp)
5535       || ! ieee_write_number (info, low == 0 ? 'Z' : 'C')
5536       || ! ieee_write_number (info, eleindx))
5537     return false;
5538   if (low != 0)
5539     {
5540       if (! ieee_write_number (info, low))
5541         return false;
5542     }
5543
5544   if (! ieee_write_number (info, high + 1))
5545     return false;
5546
5547   if (! localp)
5548     {
5549       a = (struct ieee_modified_array_type *) xmalloc (sizeof *a);
5550       memset (a, 0, sizeof *a);
5551
5552       a->indx = info->type_stack->type.indx;
5553       a->low = low;
5554       a->high = high;
5555
5556       a->next = m->arrays;
5557       m->arrays = a;
5558     }
5559
5560   return true;
5561 }
5562
5563 /* Make a set type.  */
5564
5565 static boolean
5566 ieee_set_type (p, bitstringp)
5567      PTR p;
5568      boolean bitstringp;
5569 {
5570   struct ieee_handle *info = (struct ieee_handle *) p;
5571   boolean localp;
5572   unsigned int eleindx;
5573
5574   localp = info->type_stack->type.localp;
5575   eleindx = ieee_pop_type (info);
5576
5577   /* FIXME: We don't know the size, so we just use 4.  */
5578
5579   return (ieee_define_type (info, 0, true, localp)
5580           && ieee_write_number (info, 's')
5581           && ieee_write_number (info, 4)
5582           && ieee_write_number (info, eleindx));
5583 }
5584
5585 /* Make an offset type.  */
5586
5587 static boolean
5588 ieee_offset_type (p)
5589      PTR p;
5590 {
5591   struct ieee_handle *info = (struct ieee_handle *) p;
5592   unsigned int targetindx, baseindx;
5593
5594   targetindx = ieee_pop_type (info);
5595   baseindx = ieee_pop_type (info);
5596
5597   /* FIXME: The MRI C++ compiler does not appear to generate any
5598      useful type information about an offset type.  It just records a
5599      pointer to member as an integer.  The MRI/HP IEEE spec does
5600      describe a pmisc record which can be used for a pointer to
5601      member.  Unfortunately, it does not describe the target type,
5602      which seems pretty important.  I'm going to punt this for now.  */
5603
5604   return ieee_int_type (p, 4, true);
5605 }
5606
5607 /* Make a method type.  */
5608
5609 static boolean
5610 ieee_method_type (p, domain, argcount, varargs)
5611      PTR p;
5612      boolean domain;
5613      int argcount;
5614      boolean varargs;
5615 {
5616   struct ieee_handle *info = (struct ieee_handle *) p;
5617
5618   /* FIXME: The MRI/HP IEEE spec defines a pmisc record to use for a
5619      method, but the definition is incomplete.  We just output an 'x'
5620      type.  */
5621
5622   if (domain)
5623     ieee_pop_unused_type (info);
5624
5625   return ieee_function_type (p, argcount, varargs);
5626 }
5627
5628 /* Make a const qualified type.  */
5629
5630 static boolean
5631 ieee_const_type (p)
5632      PTR p;
5633 {
5634   struct ieee_handle *info = (struct ieee_handle *) p;
5635   unsigned int size;
5636   boolean unsignedp, localp;
5637   unsigned int indx;
5638   struct ieee_modified_type *m = NULL;
5639
5640   size = info->type_stack->type.size;
5641   unsignedp = info->type_stack->type.unsignedp;
5642   localp = info->type_stack->type.localp;
5643   indx = ieee_pop_type (info);
5644
5645   if (! localp)
5646     {
5647       m = ieee_get_modified_info (info, indx);
5648       if (m == NULL)
5649         return false;
5650
5651       if (m->const_qualified > 0)
5652         return ieee_push_type (info, m->const_qualified, size, unsignedp,
5653                                false);
5654     }
5655
5656   if (! ieee_define_type (info, size, unsignedp, localp)
5657       || ! ieee_write_number (info, 'n')
5658       || ! ieee_write_number (info, 1)
5659       || ! ieee_write_number (info, indx))
5660     return false;
5661
5662   if (! localp)
5663     m->const_qualified = info->type_stack->type.indx;
5664
5665   return true;
5666 }
5667
5668 /* Make a volatile qualified type.  */
5669
5670 static boolean
5671 ieee_volatile_type (p)
5672      PTR p;
5673 {
5674   struct ieee_handle *info = (struct ieee_handle *) p;
5675   unsigned int size;
5676   boolean unsignedp, localp;
5677   unsigned int indx;
5678   struct ieee_modified_type *m = NULL;
5679
5680   size = info->type_stack->type.size;
5681   unsignedp = info->type_stack->type.unsignedp;
5682   localp = info->type_stack->type.localp;
5683   indx = ieee_pop_type (info);
5684
5685   if (! localp)
5686     {
5687       m = ieee_get_modified_info (info, indx);
5688       if (m == NULL)
5689         return false;
5690
5691       if (m->volatile_qualified > 0)
5692         return ieee_push_type (info, m->volatile_qualified, size, unsignedp,
5693                                false);
5694     }
5695
5696   if (! ieee_define_type (info, size, unsignedp, localp)
5697       || ! ieee_write_number (info, 'n')
5698       || ! ieee_write_number (info, 2)
5699       || ! ieee_write_number (info, indx))
5700     return false;
5701
5702   if (! localp)
5703     m->volatile_qualified = info->type_stack->type.indx;
5704
5705   return true;
5706 }
5707
5708 /* Convert an enum debug_visibility into a CXXFLAGS value.  */
5709
5710 static unsigned int
5711 ieee_vis_to_flags (visibility)
5712      enum debug_visibility visibility;
5713 {
5714   switch (visibility)
5715     {
5716     default:
5717       abort ();
5718     case DEBUG_VISIBILITY_PUBLIC:
5719       return CXXFLAGS_VISIBILITY_PUBLIC;
5720     case DEBUG_VISIBILITY_PRIVATE:
5721       return CXXFLAGS_VISIBILITY_PRIVATE;
5722     case DEBUG_VISIBILITY_PROTECTED:
5723       return CXXFLAGS_VISIBILITY_PROTECTED;
5724     }
5725   /*NOTREACHED*/
5726 }
5727
5728 /* Start defining a struct type.  We build it in the strdef field on
5729    the stack, to avoid confusing type definitions required by the
5730    fields with the struct type itself.  */
5731
5732 static boolean
5733 ieee_start_struct_type (p, tag, id, structp, size)
5734      PTR p;
5735      const char *tag;
5736      unsigned int id;
5737      boolean structp;
5738      unsigned int size;
5739 {
5740   struct ieee_handle *info = (struct ieee_handle *) p;
5741   boolean localp, ignorep;
5742   boolean copy;
5743   char ab[20];
5744   const char *look;
5745   struct ieee_name_type_hash_entry *h;
5746   struct ieee_name_type *nt, *ntlook;
5747   struct ieee_buflist strdef;
5748
5749   localp = false;
5750   ignorep = false;
5751
5752   /* We need to create a tag for internal use even if we don't want
5753      one for external use.  This will let us refer to an anonymous
5754      struct.  */
5755   if (tag != NULL)
5756     {
5757       look = tag;
5758       copy = false;
5759     }
5760   else
5761     {
5762       sprintf (ab, "__anon%u", id);
5763       look = ab;
5764       copy = true;
5765     }
5766
5767   /* If we already have references to the tag, we must use the
5768      existing type index.  */
5769   h = ieee_name_type_hash_lookup (&info->tags, look, true, copy);
5770   if (h == NULL)
5771     return false;
5772
5773   nt = NULL;
5774   for (ntlook = h->types; ntlook != NULL; ntlook = ntlook->next)
5775     {
5776       if (ntlook->id == id)
5777         nt = ntlook;
5778       else if (! ntlook->type.localp)
5779         {
5780           /* We are creating a duplicate definition of a globally
5781              defined tag.  Force it to be local to avoid
5782              confusion.  */
5783           localp = true;
5784         }
5785     }
5786
5787   if (nt != NULL)
5788     {
5789       assert (localp == nt->type.localp);
5790       if (nt->kind == DEBUG_KIND_ILLEGAL && ! localp)
5791         {
5792           /* We've already seen a global definition of the type.
5793              Ignore this new definition.  */
5794           ignorep = true;
5795         }
5796     }
5797   else
5798     {
5799       nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
5800       memset (nt, 0, sizeof *nt);
5801       nt->id = id;
5802       nt->type.name = h->root.string;
5803       nt->next = h->types;
5804       h->types = nt;
5805       nt->type.indx = info->type_indx;
5806       ++info->type_indx;
5807     }
5808
5809   nt->kind = DEBUG_KIND_ILLEGAL;
5810
5811   if (! ieee_init_buffer (info, &strdef)
5812       || ! ieee_define_named_type (info, tag, nt->type.indx, size, true,
5813                                    localp, &strdef)
5814       || ! ieee_write_number (info, structp ? 'S' : 'U')
5815       || ! ieee_write_number (info, size))
5816     return false;
5817
5818   if (! ignorep)
5819     {
5820       const char *hold;
5821
5822       /* We never want nt->type.name to be NULL.  We want the rest of
5823          the type to be the object set up on the type stack; it will
5824          have a NULL name if tag is NULL.  */
5825       hold = nt->type.name;
5826       nt->type = info->type_stack->type;
5827       nt->type.name = hold;
5828     }
5829
5830   info->type_stack->type.name = tag;
5831   info->type_stack->type.strdef = strdef;
5832   info->type_stack->type.ignorep = ignorep;
5833
5834   return true;
5835 }
5836
5837 /* Add a field to a struct.  */
5838
5839 static boolean
5840 ieee_struct_field (p, name, bitpos, bitsize, visibility)
5841      PTR p;
5842      const char *name;
5843      bfd_vma bitpos;
5844      bfd_vma bitsize;
5845      enum debug_visibility visibility;
5846 {
5847   struct ieee_handle *info = (struct ieee_handle *) p;
5848   unsigned int size;
5849   boolean unsignedp;
5850   boolean referencep;
5851   boolean localp;
5852   unsigned int indx;
5853   bfd_vma offset;
5854
5855   assert (info->type_stack != NULL
5856           && info->type_stack->next != NULL
5857           && ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef));
5858
5859   /* If we are ignoring this struct definition, just pop and ignore
5860      the type.  */
5861   if (info->type_stack->next->type.ignorep)
5862     {
5863       ieee_pop_unused_type (info);
5864       return true;
5865     }
5866
5867   size = info->type_stack->type.size;
5868   unsignedp = info->type_stack->type.unsignedp;
5869   referencep = info->type_stack->type.referencep;
5870   localp = info->type_stack->type.localp;
5871   indx = ieee_pop_type (info);
5872
5873   if (localp)
5874     info->type_stack->type.localp = true;
5875
5876   if (info->type_stack->type.classdef != NULL)
5877     {
5878       unsigned int flags;
5879       unsigned int nindx;
5880
5881       /* This is a class.  We must add a description of this field to
5882          the class records we are building.  */
5883
5884       flags = ieee_vis_to_flags (visibility);
5885       nindx = info->type_stack->type.classdef->indx;
5886       if (! ieee_change_buffer (info,
5887                                 &info->type_stack->type.classdef->pmiscbuf)
5888           || ! ieee_write_asn (info, nindx, 'd')
5889           || ! ieee_write_asn (info, nindx, flags)
5890           || ! ieee_write_atn65 (info, nindx, name)
5891           || ! ieee_write_atn65 (info, nindx, name))
5892         return false;
5893       info->type_stack->type.classdef->pmisccount += 4;
5894
5895       if (referencep)
5896         {
5897           unsigned int nindx;
5898
5899           /* We need to output a record recording that this field is
5900              really of reference type.  We put this on the refs field
5901              of classdef, so that it can be appended to the C++
5902              records after the class is defined.  */
5903
5904           nindx = info->name_indx;
5905           ++info->name_indx;
5906
5907           if (! ieee_change_buffer (info,
5908                                     &info->type_stack->type.classdef->refs)
5909               || ! ieee_write_byte (info, (int) ieee_nn_record)
5910               || ! ieee_write_number (info, nindx)
5911               || ! ieee_write_id (info, "")
5912               || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
5913               || ! ieee_write_number (info, nindx)
5914               || ! ieee_write_number (info, 0)
5915               || ! ieee_write_number (info, 62)
5916               || ! ieee_write_number (info, 80)
5917               || ! ieee_write_number (info, 4)
5918               || ! ieee_write_asn (info, nindx, 'R')
5919               || ! ieee_write_asn (info, nindx, 3)
5920               || ! ieee_write_atn65 (info, nindx, info->type_stack->type.name)
5921               || ! ieee_write_atn65 (info, nindx, name))
5922             return false;
5923         }
5924     }
5925
5926   /* If the bitsize doesn't match the expected size, we need to output
5927      a bitfield type.  */
5928   if (size == 0 || bitsize == 0 || bitsize == size * 8)
5929     offset = bitpos / 8;
5930   else
5931     {
5932       if (! ieee_define_type (info, 0, unsignedp,
5933                               info->type_stack->type.localp)
5934           || ! ieee_write_number (info, 'g')
5935           || ! ieee_write_number (info, unsignedp ? 0 : 1)
5936           || ! ieee_write_number (info, bitsize)
5937           || ! ieee_write_number (info, indx))
5938         return false;
5939       indx = ieee_pop_type (info);
5940       offset = bitpos;
5941     }
5942
5943   /* Switch to the struct we are building in order to output this
5944      field definition.  */
5945   return (ieee_change_buffer (info, &info->type_stack->type.strdef)
5946           && ieee_write_id (info, name)
5947           && ieee_write_number (info, indx)
5948           && ieee_write_number (info, offset));
5949 }
5950
5951 /* Finish up a struct type.  */
5952
5953 static boolean
5954 ieee_end_struct_type (p)
5955      PTR p;
5956 {
5957   struct ieee_handle *info = (struct ieee_handle *) p;
5958   struct ieee_buflist *pb;
5959
5960   assert (info->type_stack != NULL
5961           && ! ieee_buffer_emptyp (&info->type_stack->type.strdef));
5962
5963   /* If we were ignoring this struct definition because it was a
5964      duplicate defintion, just through away whatever bytes we have
5965      accumulated.  Leave the type on the stack. */
5966   if (info->type_stack->type.ignorep)
5967     return true;
5968
5969   /* If this is not a duplicate definition of this tag, then localp
5970      will be false, and we can put it in the global type block.
5971      FIXME: We should avoid outputting duplicate definitions which are
5972      the same.  */
5973   if (! info->type_stack->type.localp)
5974     {
5975       /* Make sure we have started the global type block.  */
5976       if (ieee_buffer_emptyp (&info->global_types))
5977         {
5978           if (! ieee_change_buffer (info, &info->global_types)
5979               || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
5980               || ! ieee_write_byte (info, 2)
5981               || ! ieee_write_number (info, 0)
5982               || ! ieee_write_id (info, ""))
5983             return false;
5984         }
5985       pb = &info->global_types;
5986     }
5987   else
5988     {
5989       /* Make sure we have started the types block.  */
5990       if (ieee_buffer_emptyp (&info->types))
5991         {
5992           if (! ieee_change_buffer (info, &info->types)
5993               || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
5994               || ! ieee_write_byte (info, 1)
5995               || ! ieee_write_number (info, 0)
5996               || ! ieee_write_id (info, info->modname))
5997             return false;
5998         }
5999       pb = &info->types;
6000     }
6001
6002   /* Append the struct definition to the types.  */
6003   if (! ieee_append_buffer (info, pb, &info->type_stack->type.strdef)
6004       || ! ieee_init_buffer (info, &info->type_stack->type.strdef))
6005     return false;
6006
6007   /* Leave the struct on the type stack.  */
6008
6009   return true;
6010 }
6011
6012 /* Start a class type.  */
6013
6014 static boolean
6015 ieee_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
6016      PTR p;
6017      const char *tag;
6018      unsigned int id;
6019      boolean structp;
6020      unsigned int size;
6021      boolean vptr;
6022      boolean ownvptr;
6023 {
6024   struct ieee_handle *info = (struct ieee_handle *) p;
6025   const char *vclass;
6026   struct ieee_buflist pmiscbuf;
6027   unsigned int indx;
6028   struct ieee_type_class *classdef;
6029
6030   /* A C++ class is output as a C++ struct along with a set of pmisc
6031      records describing the class.  */
6032
6033   /* We need to have a name so that we can associate the struct and
6034      the class.  */
6035   if (tag == NULL)
6036     {
6037       char *t;
6038
6039       t = (char *) xmalloc (20);
6040       sprintf (t, "__anon%u", id);
6041       tag = t;
6042     }
6043
6044   /* We can't write out the virtual table information until we have
6045      finished the class, because we don't know the virtual table size.
6046      We get the size from the largest voffset we see.  */
6047   vclass = NULL;
6048   if (vptr && ! ownvptr)
6049     {
6050       vclass = info->type_stack->type.name;
6051       assert (vclass != NULL);
6052       /* We don't call ieee_pop_unused_type, since the class should
6053          get defined.  */
6054       (void) ieee_pop_type (info);
6055     }
6056
6057   if (! ieee_start_struct_type (p, tag, id, structp, size))
6058     return false;
6059
6060   indx = info->name_indx;
6061   ++info->name_indx;
6062
6063   /* We write out pmisc records into the classdef field.  We will
6064      write out the pmisc start after we know the number of records we
6065      need.  */
6066   if (! ieee_init_buffer (info, &pmiscbuf)
6067       || ! ieee_change_buffer (info, &pmiscbuf)
6068       || ! ieee_write_asn (info, indx, 'T')
6069       || ! ieee_write_asn (info, indx, structp ? 'o' : 'u')
6070       || ! ieee_write_atn65 (info, indx, tag))
6071     return false;
6072
6073   classdef = (struct ieee_type_class *) xmalloc (sizeof *classdef);
6074   memset (classdef, 0, sizeof *classdef);
6075
6076   classdef->indx = indx;
6077   classdef->pmiscbuf = pmiscbuf;
6078   classdef->pmisccount = 3;
6079   classdef->vclass = vclass;
6080   classdef->ownvptr = ownvptr;
6081
6082   info->type_stack->type.classdef = classdef;
6083
6084   return true;
6085 }
6086
6087 /* Add a static member to a class.  */
6088
6089 static boolean
6090 ieee_class_static_member (p, name, physname, visibility)
6091      PTR p;
6092      const char *name;
6093      const char *physname;
6094      enum debug_visibility visibility;
6095 {
6096   struct ieee_handle *info = (struct ieee_handle *) p;
6097   unsigned int flags;
6098   unsigned int nindx;
6099
6100   /* We don't care about the type.  Hopefully there will be a call to
6101      ieee_variable declaring the physical name and the type, since
6102      that is where an IEEE consumer must get the type.  */
6103   ieee_pop_unused_type (info);
6104
6105   assert (info->type_stack != NULL
6106           && info->type_stack->type.classdef != NULL);
6107
6108   flags = ieee_vis_to_flags (visibility);
6109   flags |= CXXFLAGS_STATIC;
6110
6111   nindx = info->type_stack->type.classdef->indx;
6112
6113   if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf)
6114       || ! ieee_write_asn (info, nindx, 'd')
6115       || ! ieee_write_asn (info, nindx, flags)
6116       || ! ieee_write_atn65 (info, nindx, name)
6117       || ! ieee_write_atn65 (info, nindx, physname))
6118     return false;
6119   info->type_stack->type.classdef->pmisccount += 4;
6120
6121   return true;
6122 }
6123
6124 /* Add a base class to a class.  */
6125
6126 static boolean
6127 ieee_class_baseclass (p, bitpos, virtual, visibility)
6128      PTR p;
6129      bfd_vma bitpos;
6130      boolean virtual;
6131      enum debug_visibility visibility;
6132 {
6133   struct ieee_handle *info = (struct ieee_handle *) p;
6134   const char *bname;
6135   boolean localp;
6136   unsigned int bindx;
6137   char *fname;
6138   unsigned int flags;
6139   unsigned int nindx;
6140
6141   assert (info->type_stack != NULL
6142           && info->type_stack->type.name != NULL
6143           && info->type_stack->next != NULL
6144           && info->type_stack->next->type.classdef != NULL
6145           && ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef));
6146
6147   bname = info->type_stack->type.name;
6148   localp = info->type_stack->type.localp;
6149   bindx = ieee_pop_type (info);
6150
6151   /* We are currently defining both a struct and a class.  We must
6152      write out a field definition in the struct which holds the base
6153      class.  The stabs debugging reader will create a field named
6154      _vb$CLASS for a virtual base class, so we just use that.  FIXME:
6155      we should not depend upon a detail of stabs debugging.  */
6156   if (virtual)
6157     {
6158       fname = (char *) xmalloc (strlen (bname) + sizeof "_vb$");
6159       sprintf (fname, "_vb$%s", bname);
6160       flags = BASEFLAGS_VIRTUAL;
6161     }
6162   else
6163     {
6164       if (localp)
6165         info->type_stack->type.localp = true;
6166
6167       fname = (char *) xmalloc (strlen (bname) + sizeof "_b$");
6168       sprintf (fname, "_b$%s", bname);
6169
6170       if (! ieee_change_buffer (info, &info->type_stack->type.strdef)
6171           || ! ieee_write_id (info, fname)
6172           || ! ieee_write_number (info, bindx)
6173           || ! ieee_write_number (info, bitpos / 8))
6174         return false;
6175       flags = 0;
6176     }
6177
6178   if (visibility == DEBUG_VISIBILITY_PRIVATE)
6179     flags |= BASEFLAGS_PRIVATE;
6180
6181   nindx = info->type_stack->type.classdef->indx;
6182
6183   if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf)
6184       || ! ieee_write_asn (info, nindx, 'b')
6185       || ! ieee_write_asn (info, nindx, flags)
6186       || ! ieee_write_atn65 (info, nindx, bname)
6187       || ! ieee_write_asn (info, nindx, 0)
6188       || ! ieee_write_atn65 (info, nindx, fname))
6189     return false;
6190   info->type_stack->type.classdef->pmisccount += 5;
6191
6192   free (fname);
6193
6194   return true;
6195 }
6196
6197 /* Start building a method for a class.  */
6198
6199 static boolean
6200 ieee_class_start_method (p, name)
6201      PTR p;
6202      const char *name;
6203 {
6204   struct ieee_handle *info = (struct ieee_handle *) p;
6205
6206   assert (info->type_stack != NULL
6207           && info->type_stack->type.classdef != NULL
6208           && info->type_stack->type.classdef->method == NULL);
6209
6210   info->type_stack->type.classdef->method = name;
6211
6212   return true;
6213 }
6214
6215 /* Define a new method variant, either static or not.  */
6216
6217 static boolean
6218 ieee_class_method_var (info, physname, visibility, staticp, constp,
6219                        volatilep, voffset, context)
6220      struct ieee_handle *info;
6221      const char *physname;
6222      enum debug_visibility visibility;
6223      boolean staticp;
6224      boolean constp;
6225      boolean volatilep;
6226      bfd_vma voffset;
6227      boolean context;
6228 {
6229   unsigned int flags;
6230   unsigned int nindx;
6231   boolean virtual;
6232
6233   /* We don't need the type of the method.  An IEEE consumer which
6234      wants the type must track down the function by the physical name
6235      and get the type from that.  */
6236   ieee_pop_unused_type (info);
6237
6238   /* We don't use the context.  FIXME: We probably ought to use it to
6239      adjust the voffset somehow, but I don't really know how.  */
6240   if (context)
6241     ieee_pop_unused_type (info);
6242
6243   assert (info->type_stack != NULL
6244           && info->type_stack->type.classdef != NULL
6245           && info->type_stack->type.classdef->method != NULL);
6246
6247   flags = ieee_vis_to_flags (visibility);
6248
6249   /* FIXME: We never set CXXFLAGS_OVERRIDE, CXXFLAGS_OPERATOR,
6250      CXXFLAGS_CTORDTOR, CXXFLAGS_CTOR, or CXXFLAGS_INLINE.  */
6251
6252   if (staticp)
6253     flags |= CXXFLAGS_STATIC;
6254   if (constp)
6255     flags |= CXXFLAGS_CONST;
6256   if (volatilep)
6257     flags |= CXXFLAGS_VOLATILE;
6258
6259   nindx = info->type_stack->type.classdef->indx;
6260
6261   virtual = context || voffset > 0;
6262
6263   if (! ieee_change_buffer (info,
6264                             &info->type_stack->type.classdef->pmiscbuf)
6265       || ! ieee_write_asn (info, nindx, virtual ? 'v' : 'm')
6266       || ! ieee_write_asn (info, nindx, flags)
6267       || ! ieee_write_atn65 (info, nindx,
6268                              info->type_stack->type.classdef->method)
6269       || ! ieee_write_atn65 (info, nindx, physname))
6270     return false;
6271
6272   if (virtual)
6273     {
6274       if (voffset > info->type_stack->type.classdef->voffset)
6275         info->type_stack->type.classdef->voffset = voffset;
6276       if (! ieee_write_asn (info, nindx, voffset))
6277         return false;
6278       ++info->type_stack->type.classdef->pmisccount;
6279     }
6280
6281   if (! ieee_write_asn (info, nindx, 0))
6282     return false;
6283
6284   info->type_stack->type.classdef->pmisccount += 5;
6285
6286   return true;
6287 }
6288
6289 /* Define a new method variant.  */
6290
6291 static boolean
6292 ieee_class_method_variant (p, physname, visibility, constp, volatilep,
6293                            voffset, context)
6294      PTR p;
6295      const char *physname;
6296      enum debug_visibility visibility;
6297      boolean constp;
6298      boolean volatilep;
6299      bfd_vma voffset;
6300      boolean context;
6301 {
6302   struct ieee_handle *info = (struct ieee_handle *) p;
6303
6304   return ieee_class_method_var (info, physname, visibility, false, constp,
6305                                 volatilep, voffset, context);
6306 }
6307
6308 /* Define a new static method variant.  */
6309
6310 static boolean
6311 ieee_class_static_method_variant (p, physname, visibility, constp, volatilep)
6312      PTR p;
6313      const char *physname;
6314      enum debug_visibility visibility;
6315      boolean constp;
6316      boolean volatilep;
6317 {
6318   struct ieee_handle *info = (struct ieee_handle *) p;
6319
6320   return ieee_class_method_var (info, physname, visibility, true, constp,
6321                                 volatilep, 0, false);
6322 }
6323
6324 /* Finish up a method.  */
6325
6326 static boolean
6327 ieee_class_end_method (p)
6328      PTR p;
6329 {
6330   struct ieee_handle *info = (struct ieee_handle *) p;
6331
6332   assert (info->type_stack != NULL
6333           && info->type_stack->type.classdef != NULL
6334           && info->type_stack->type.classdef->method != NULL);
6335
6336   info->type_stack->type.classdef->method = NULL;
6337
6338   return true;
6339 }
6340
6341 /* Finish up a class.  */
6342
6343 static boolean
6344 ieee_end_class_type (p)
6345      PTR p;
6346 {
6347   struct ieee_handle *info = (struct ieee_handle *) p;
6348   unsigned int nindx;
6349
6350   assert (info->type_stack != NULL
6351           && info->type_stack->type.classdef != NULL);
6352
6353   /* If we were ignoring this class definition because it was a
6354      duplicate definition, just through away whatever bytes we have
6355      accumulated.  Leave the type on the stack.  */
6356   if (info->type_stack->type.ignorep)
6357     return true;
6358
6359   nindx = info->type_stack->type.classdef->indx;
6360
6361   /* If we have a virtual table, we can write out the information now.  */
6362   if (info->type_stack->type.classdef->vclass != NULL
6363       || info->type_stack->type.classdef->ownvptr)
6364     {
6365       if (! ieee_change_buffer (info,
6366                                 &info->type_stack->type.classdef->pmiscbuf)
6367           || ! ieee_write_asn (info, nindx, 'z')
6368           || ! ieee_write_atn65 (info, nindx, "")
6369           || ! ieee_write_asn (info, nindx,
6370                                info->type_stack->type.classdef->voffset))
6371         return false;
6372       if (info->type_stack->type.classdef->ownvptr)
6373         {
6374           if (! ieee_write_atn65 (info, nindx, ""))
6375             return false;
6376         }
6377       else
6378         {
6379           if (! ieee_write_atn65 (info, nindx,
6380                                   info->type_stack->type.classdef->vclass))
6381             return false;
6382         }
6383       if (! ieee_write_asn (info, nindx, 0))
6384         return false;
6385       info->type_stack->type.classdef->pmisccount += 5;
6386     }
6387
6388   /* Now that we know the number of pmisc records, we can write out
6389      the atn62 which starts the pmisc records, and append them to the
6390      C++ buffers.  */
6391
6392   if (! ieee_change_buffer (info, &info->cxx)
6393       || ! ieee_write_byte (info, (int) ieee_nn_record)
6394       || ! ieee_write_number (info, nindx)
6395       || ! ieee_write_id (info, "")
6396       || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6397       || ! ieee_write_number (info, nindx)
6398       || ! ieee_write_number (info, 0)
6399       || ! ieee_write_number (info, 62)
6400       || ! ieee_write_number (info, 80)
6401       || ! ieee_write_number (info,
6402                               info->type_stack->type.classdef->pmisccount))
6403     return false;
6404
6405   if (! ieee_append_buffer (info, &info->cxx,
6406                             &info->type_stack->type.classdef->pmiscbuf))
6407     return false;
6408   if (! ieee_buffer_emptyp (&info->type_stack->type.classdef->refs))
6409     {
6410       if (! ieee_append_buffer (info, &info->cxx,
6411                                 &info->type_stack->type.classdef->refs))
6412         return false;
6413     }
6414
6415   return ieee_end_struct_type (p);
6416 }
6417
6418 /* Push a previously seen typedef onto the type stack.  */
6419
6420 static boolean
6421 ieee_typedef_type (p, name)
6422      PTR p;
6423      const char *name;
6424 {
6425   struct ieee_handle *info = (struct ieee_handle *) p;
6426   struct ieee_name_type_hash_entry *h;
6427   struct ieee_name_type *nt;
6428
6429   h = ieee_name_type_hash_lookup (&info->typedefs, name, false, false);
6430
6431   /* h should never be NULL, since that would imply that the generic
6432      debugging code has asked for a typedef which it has not yet
6433      defined.  */
6434   assert (h != NULL);
6435
6436   /* We always use the most recently defined type for this name, which
6437      will be the first one on the list.  */
6438
6439   nt = h->types;
6440   if (! ieee_push_type (info, nt->type.indx, nt->type.size,
6441                         nt->type.unsignedp, nt->type.localp))
6442     return false;
6443
6444   /* Copy over any other type information we may have.  */
6445   info->type_stack->type = nt->type;
6446
6447   return true;
6448 }
6449
6450 /* Push a tagged type onto the type stack.  */
6451
6452 static boolean
6453 ieee_tag_type (p, name, id, kind)
6454      PTR p;
6455      const char *name;
6456      unsigned int id;
6457      enum debug_type_kind kind;
6458 {
6459   struct ieee_handle *info = (struct ieee_handle *) p;
6460   boolean localp;
6461   boolean copy;
6462   char ab[20];
6463   struct ieee_name_type_hash_entry *h;
6464   struct ieee_name_type *nt;
6465
6466   if (kind == DEBUG_KIND_ENUM)
6467     {
6468       struct ieee_defined_enum *e;
6469
6470       if (name == NULL)
6471         abort ();
6472       for (e = info->enums; e != NULL; e = e->next)
6473         if (e->tag != NULL && strcmp (e->tag, name) == 0)
6474           return ieee_push_type (info, e->indx, 0, true, false);
6475       abort ();
6476     }
6477
6478   localp = false;
6479
6480   copy = false;
6481   if (name == NULL)
6482     {
6483       sprintf (ab, "__anon%u", id);
6484       name = ab;
6485       copy = true;
6486     }
6487
6488   h = ieee_name_type_hash_lookup (&info->tags, name, true, copy);
6489   if (h == NULL)
6490     return false;
6491
6492   for (nt = h->types; nt != NULL; nt = nt->next)
6493     {
6494       if (nt->id == id)
6495         {
6496           if (! ieee_push_type (info, nt->type.indx, nt->type.size,
6497                                 nt->type.unsignedp, nt->type.localp))
6498             return false;
6499           /* Copy over any other type information we may have.  */
6500           info->type_stack->type = nt->type;
6501           return true;
6502         }
6503
6504       if (! nt->type.localp)
6505         {
6506           /* This is a duplicate of a global type, so it must be
6507              local. */
6508           localp = true;
6509         }
6510     }
6511
6512   nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
6513   memset (nt, 0, sizeof *nt);
6514
6515   nt->id = id;
6516   nt->type.name = h->root.string;
6517   nt->type.indx = info->type_indx;
6518   nt->type.localp = localp;
6519   ++info->type_indx;
6520   nt->kind = kind;
6521
6522   nt->next = h->types;
6523   h->types = nt;
6524
6525   if (! ieee_push_type (info, nt->type.indx, 0, false, localp))
6526     return false;
6527
6528   info->type_stack->type.name = h->root.string;
6529
6530   return true;
6531 }
6532
6533 /* Output a typedef.  */
6534
6535 static boolean
6536 ieee_typdef (p, name)
6537      PTR p;
6538      const char *name;
6539 {
6540   struct ieee_handle *info = (struct ieee_handle *) p;
6541   struct ieee_write_type type;
6542   unsigned int indx;
6543   boolean found;
6544   boolean localp;
6545   struct ieee_name_type_hash_entry *h;
6546   struct ieee_name_type *nt;
6547
6548   type = info->type_stack->type;
6549   indx = type.indx;
6550
6551   /* If this is a simple builtin type using a builtin name, we don't
6552      want to output the typedef itself.  We also want to change the
6553      type index to correspond to the name being used.  We recognize
6554      names used in stabs debugging output even if they don't exactly
6555      correspond to the names used for the IEEE builtin types.  */
6556   found = false;
6557   if (indx <= (unsigned int) builtin_bcd_float)
6558     {
6559       switch ((enum builtin_types) indx)
6560         {
6561         default:
6562           break;
6563
6564         case builtin_void:
6565           if (strcmp (name, "void") == 0)
6566             found = true;
6567           break;
6568
6569         case builtin_signed_char:
6570         case builtin_char:
6571           if (strcmp (name, "signed char") == 0)
6572             {
6573               indx = (unsigned int) builtin_signed_char;
6574               found = true;
6575             }
6576           else if (strcmp (name, "char") == 0)
6577             {
6578               indx = (unsigned int) builtin_char;
6579               found = true;
6580             }
6581           break;
6582
6583         case builtin_unsigned_char:
6584           if (strcmp (name, "unsigned char") == 0)
6585             found = true;
6586           break;
6587
6588         case builtin_signed_short_int:
6589         case builtin_short:
6590         case builtin_short_int:
6591         case builtin_signed_short:
6592           if (strcmp (name, "signed short int") == 0)
6593             {
6594               indx = (unsigned int) builtin_signed_short_int;
6595               found = true;
6596             }
6597           else if (strcmp (name, "short") == 0)
6598             {
6599               indx = (unsigned int) builtin_short;
6600               found = true;
6601             }
6602           else if (strcmp (name, "short int") == 0)
6603             {
6604               indx = (unsigned int) builtin_short_int;
6605               found = true;
6606             }
6607           else if (strcmp (name, "signed short") == 0)
6608             {
6609               indx = (unsigned int) builtin_signed_short;
6610               found = true;
6611             }
6612           break;
6613
6614         case builtin_unsigned_short_int:
6615         case builtin_unsigned_short:
6616           if (strcmp (name, "unsigned short int") == 0
6617               || strcmp (name, "short unsigned int") == 0)
6618             {
6619               indx = builtin_unsigned_short_int;
6620               found = true;
6621             }
6622           else if (strcmp (name, "unsigned short") == 0)
6623             {
6624               indx = builtin_unsigned_short;
6625               found = true;
6626             }
6627           break;
6628
6629         case builtin_signed_long:
6630         case builtin_int: /* FIXME: Size depends upon architecture.  */
6631         case builtin_long:
6632           if (strcmp (name, "signed long") == 0)
6633             {
6634               indx = builtin_signed_long;
6635               found = true;
6636             }
6637           else if (strcmp (name, "int") == 0)
6638             {
6639               indx = builtin_int;
6640               found = true;
6641             }
6642           else if (strcmp (name, "long") == 0
6643                    || strcmp (name, "long int") == 0)
6644             {
6645               indx = builtin_long;
6646               found = true;
6647             }
6648           break;
6649
6650         case builtin_unsigned_long:
6651         case builtin_unsigned: /* FIXME: Size depends upon architecture.  */
6652         case builtin_unsigned_int: /* FIXME: Like builtin_unsigned.  */
6653           if (strcmp (name, "unsigned long") == 0
6654               || strcmp (name, "long unsigned int") == 0)
6655             {
6656               indx = builtin_unsigned_long;
6657               found = true;
6658             }
6659           else if (strcmp (name, "unsigned") == 0)
6660             {
6661               indx = builtin_unsigned;
6662               found = true;
6663             }
6664           else if (strcmp (name, "unsigned int") == 0)
6665             {
6666               indx = builtin_unsigned_int;
6667               found = true;
6668             }
6669           break;
6670
6671         case builtin_signed_long_long:
6672           if (strcmp (name, "signed long long") == 0
6673               || strcmp (name, "long long int") == 0)
6674             found = true;
6675           break;
6676
6677         case builtin_unsigned_long_long:
6678           if (strcmp (name, "unsigned long long") == 0
6679               || strcmp (name, "long long unsigned int") == 0)
6680             found = true;
6681           break;
6682
6683         case builtin_float:
6684           if (strcmp (name, "float") == 0)
6685             found = true;
6686           break;
6687
6688         case builtin_double:
6689           if (strcmp (name, "double") == 0)
6690             found = true;
6691           break;
6692
6693         case builtin_long_double:
6694           if (strcmp (name, "long double") == 0)
6695             found = true;
6696           break;
6697
6698         case builtin_long_long_double:
6699           if (strcmp (name, "long long double") == 0)
6700             found = true;
6701           break;
6702         }
6703
6704       if (found)
6705         type.indx = indx;
6706     }
6707
6708   h = ieee_name_type_hash_lookup (&info->typedefs, name, true, false);
6709   if (h == NULL)
6710     return false;
6711
6712   /* See if we have already defined this type with this name.  */
6713   localp = type.localp;
6714   for (nt = h->types; nt != NULL; nt = nt->next)
6715     {
6716       if (nt->id == indx)
6717         {
6718           /* If this is a global definition, then we don't need to
6719              do anything here.  */
6720           if (! nt->type.localp)
6721             {
6722               ieee_pop_unused_type (info);
6723               return true;
6724             }
6725         }
6726       else
6727         {
6728           /* This is a duplicate definition, so make this one local.  */
6729           localp = true;
6730         }
6731     }
6732
6733   /* We need to add a new typedef for this type.  */
6734
6735   nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
6736   memset (nt, 0, sizeof *nt);
6737   nt->id = indx;
6738   nt->type = type;
6739   nt->type.name = name;
6740   nt->type.localp = localp;
6741   nt->kind = DEBUG_KIND_ILLEGAL;
6742
6743   nt->next = h->types;
6744   h->types = nt;
6745
6746   if (found)
6747     {
6748       /* This is one of the builtin typedefs, so we don't need to
6749          actually define it.  */
6750       ieee_pop_unused_type (info);
6751       return true;
6752     }
6753
6754   indx = ieee_pop_type (info);
6755
6756   if (! ieee_define_named_type (info, name, (unsigned int) -1, type.size,
6757                                 type.unsignedp, localp,
6758                                 (struct ieee_buflist *) NULL)
6759       || ! ieee_write_number (info, 'T')
6760       || ! ieee_write_number (info, indx))
6761     return false;
6762
6763   /* Remove the type we just added to the type stack.  This should not
6764      be ieee_pop_unused_type, since the type is used, we just don't
6765      need it now.  */
6766   (void) ieee_pop_type (info);
6767
6768   return true;
6769 }
6770
6771 /* Output a tag for a type.  We don't have to do anything here.  */
6772
6773 static boolean
6774 ieee_tag (p, name)
6775      PTR p;
6776      const char *name;
6777 {
6778   struct ieee_handle *info = (struct ieee_handle *) p;
6779
6780   /* This should not be ieee_pop_unused_type, since we want the type
6781      to be defined.  */
6782   (void) ieee_pop_type (info);
6783   return true;
6784 }
6785
6786 /* Output an integer constant.  */
6787
6788 static boolean
6789 ieee_int_constant (p, name, val)
6790      PTR p;
6791      const char *name;
6792      bfd_vma val;
6793 {
6794   /* FIXME.  */
6795   return true;
6796 }
6797
6798 /* Output a floating point constant.  */
6799
6800 static boolean
6801 ieee_float_constant (p, name, val)
6802      PTR p;
6803      const char *name;
6804      double val;
6805 {
6806   /* FIXME.  */
6807   return true;
6808 }
6809
6810 /* Output a typed constant.  */
6811
6812 static boolean
6813 ieee_typed_constant (p, name, val)
6814      PTR p;
6815      const char *name;
6816      bfd_vma val;
6817 {
6818   struct ieee_handle *info = (struct ieee_handle *) p;
6819
6820   /* FIXME.  */
6821   ieee_pop_unused_type (info);
6822   return true;
6823 }
6824
6825 /* Output a variable.  */
6826
6827 static boolean
6828 ieee_variable (p, name, kind, val)
6829      PTR p;
6830      const char *name;
6831      enum debug_var_kind kind;
6832      bfd_vma val;
6833 {
6834   struct ieee_handle *info = (struct ieee_handle *) p;
6835   unsigned int name_indx;
6836   unsigned int size;
6837   boolean referencep;
6838   unsigned int type_indx;
6839   boolean asn;
6840   int refflag;
6841
6842   size = info->type_stack->type.size;
6843   referencep = info->type_stack->type.referencep;
6844   type_indx = ieee_pop_type (info);
6845
6846   assert (! ieee_buffer_emptyp (&info->vars));
6847   if (! ieee_change_buffer (info, &info->vars))
6848     return false;
6849
6850   name_indx = info->name_indx;
6851   ++info->name_indx;
6852
6853   /* Write out an NN and an ATN record for this variable.  */
6854   if (! ieee_write_byte (info, (int) ieee_nn_record)
6855       || ! ieee_write_number (info, name_indx)
6856       || ! ieee_write_id (info, name)
6857       || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6858       || ! ieee_write_number (info, name_indx)
6859       || ! ieee_write_number (info, type_indx))
6860     return false;
6861   switch (kind)
6862     {
6863     default:
6864       abort ();
6865       return false;
6866     case DEBUG_GLOBAL:
6867       if (! ieee_write_number (info, 8)
6868           || ! ieee_add_range (info, false, val, val + size))
6869         return false;
6870       refflag = 0;
6871       asn = true;
6872       break;
6873     case DEBUG_STATIC:
6874       if (! ieee_write_number (info, 3)
6875           || ! ieee_add_range (info, false, val, val + size))
6876         return false;
6877       refflag = 1;
6878       asn = true;
6879       break;
6880     case DEBUG_LOCAL_STATIC:
6881       if (! ieee_write_number (info, 3)
6882           || ! ieee_add_range (info, false, val, val + size))
6883         return false;
6884       refflag = 2;
6885       asn = true;
6886       break;
6887     case DEBUG_LOCAL:
6888       if (! ieee_write_number (info, 1)
6889           || ! ieee_write_number (info, val))
6890         return false;
6891       refflag = 2;
6892       asn = false;
6893       break;
6894     case DEBUG_REGISTER:
6895       if (! ieee_write_number (info, 2)
6896           || ! ieee_write_number (info,
6897                                   ieee_genreg_to_regno (info->abfd, val)))
6898         return false;
6899       refflag = 2;
6900       asn = false;
6901       break;
6902     }
6903
6904   if (asn)
6905     {
6906       if (! ieee_write_asn (info, name_indx, val))
6907         return false;
6908     }
6909
6910   /* If this is really a reference type, then we just output it with
6911      pointer type, and must now output a C++ record indicating that it
6912      is really reference type.  */
6913   if (referencep)
6914     {
6915       unsigned int nindx;
6916
6917       nindx = info->name_indx;
6918       ++info->name_indx;
6919
6920       /* If this is a global variable, we want to output the misc
6921          record in the C++ misc record block.  Otherwise, we want to
6922          output it just after the variable definition, which is where
6923          the current buffer is.  */
6924       if (refflag != 2)
6925         {
6926           if (! ieee_change_buffer (info, &info->cxx))
6927             return false;
6928         }
6929
6930       if (! ieee_write_byte (info, (int) ieee_nn_record)
6931           || ! ieee_write_number (info, nindx)
6932           || ! ieee_write_id (info, "")
6933           || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6934           || ! ieee_write_number (info, nindx)
6935           || ! ieee_write_number (info, 0)
6936           || ! ieee_write_number (info, 62)
6937           || ! ieee_write_number (info, 80)
6938           || ! ieee_write_number (info, 3)
6939           || ! ieee_write_asn (info, nindx, 'R')
6940           || ! ieee_write_asn (info, nindx, refflag)
6941           || ! ieee_write_atn65 (info, nindx, name))
6942         return false;
6943     }
6944
6945   return true;
6946 }
6947
6948 /* Start outputting information for a function.  */
6949
6950 static boolean
6951 ieee_start_function (p, name, global)
6952      PTR p;
6953      const char *name;
6954      boolean global;
6955 {
6956   struct ieee_handle *info = (struct ieee_handle *) p;
6957   boolean referencep;
6958   unsigned int retindx, typeindx;
6959
6960   referencep = info->type_stack->type.referencep;
6961   retindx = ieee_pop_type (info);
6962
6963   /* Besides recording a BB4 or BB6 block, we record the type of the
6964      function in the BB1 typedef block.  We can't write out the full
6965      type until we have seen all the parameters, so we accumulate it
6966      in info->fntype and info->fnargs.  */
6967   if (! ieee_buffer_emptyp (&info->fntype))
6968     {
6969       /* FIXME: This might happen someday if we support nested
6970          functions.  */
6971       abort ();
6972     }
6973
6974   info->fnname = name;
6975
6976   /* An attribute of 0x40 means that the push mask is unknown.  */
6977   if (! ieee_define_named_type (info, name, (unsigned int) -1, 0, false, true,
6978                                 &info->fntype)
6979       || ! ieee_write_number (info, 'x')
6980       || ! ieee_write_number (info, 0x40)
6981       || ! ieee_write_number (info, 0)
6982       || ! ieee_write_number (info, 0)
6983       || ! ieee_write_number (info, retindx))
6984     return false;
6985
6986   typeindx = ieee_pop_type (info);
6987
6988   if (! ieee_init_buffer (info, &info->fnargs))
6989     return false;
6990   info->fnargcount = 0;
6991
6992   /* If the function return value is actually a reference type, we
6993      must add a record indicating that.  */
6994   if (referencep)
6995     {
6996       unsigned int nindx;
6997
6998       nindx = info->name_indx;
6999       ++info->name_indx;
7000       if (! ieee_change_buffer (info, &info->cxx)
7001           || ! ieee_write_byte (info, (int) ieee_nn_record)
7002           || ! ieee_write_number (info, nindx)
7003           || ! ieee_write_id (info, "")
7004           || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7005           || ! ieee_write_number (info, nindx)
7006           || ! ieee_write_number (info, 0)
7007           || ! ieee_write_number (info, 62)
7008           || ! ieee_write_number (info, 80)
7009           || ! ieee_write_number (info, 3)
7010           || ! ieee_write_asn (info, nindx, 'R')
7011           || ! ieee_write_asn (info, nindx, global ? 0 : 1)
7012           || ! ieee_write_atn65 (info, nindx, name))
7013         return false;
7014     }
7015
7016   assert (! ieee_buffer_emptyp (&info->vars));
7017   if (! ieee_change_buffer (info, &info->vars))
7018     return false;
7019
7020   /* The address is written out as the first block.  */
7021
7022   ++info->block_depth;
7023
7024   return (ieee_write_byte (info, (int) ieee_bb_record_enum)
7025           && ieee_write_byte (info, global ? 4 : 6)
7026           && ieee_write_number (info, 0)
7027           && ieee_write_id (info, name)
7028           && ieee_write_number (info, 0)
7029           && ieee_write_number (info, typeindx));
7030 }
7031
7032 /* Add a function parameter.  This will normally be called before the
7033    first block, so we postpone them until we see the block.  */
7034
7035 static boolean
7036 ieee_function_parameter (p, name, kind, val)
7037      PTR p;
7038      const char *name;
7039      enum debug_parm_kind kind;
7040      bfd_vma val;
7041 {
7042   struct ieee_handle *info = (struct ieee_handle *) p;
7043   struct ieee_pending_parm *m, **pm;
7044
7045   assert (info->block_depth == 1);
7046
7047   m = (struct ieee_pending_parm *) xmalloc (sizeof *m);
7048   memset (m, 0, sizeof *m);
7049
7050   m->next = NULL;
7051   m->name = name;
7052   m->referencep = info->type_stack->type.referencep;
7053   m->type = ieee_pop_type (info);
7054   m->kind = kind;
7055   m->val = val;
7056
7057   for (pm = &info->pending_parms; *pm != NULL; pm = &(*pm)->next)
7058     ;
7059   *pm = m;
7060
7061   /* Add the type to the fnargs list.  */
7062   if (! ieee_change_buffer (info, &info->fnargs)
7063       || ! ieee_write_number (info, m->type))
7064     return false;
7065   ++info->fnargcount;
7066
7067   return true;
7068 }
7069
7070 /* Output pending function parameters.  */
7071
7072 static boolean
7073 ieee_output_pending_parms (info)
7074      struct ieee_handle *info;
7075 {
7076   struct ieee_pending_parm *m;
7077   unsigned int refcount;
7078
7079   refcount = 0;
7080   for (m = info->pending_parms; m != NULL; m = m->next)
7081     {
7082       enum debug_var_kind vkind;
7083
7084       switch (m->kind)
7085         {
7086         default:
7087           abort ();
7088           return false;
7089         case DEBUG_PARM_STACK:
7090         case DEBUG_PARM_REFERENCE:
7091           vkind = DEBUG_LOCAL;
7092           break;
7093         case DEBUG_PARM_REG:
7094         case DEBUG_PARM_REF_REG:
7095           vkind = DEBUG_REGISTER;
7096           break;
7097         }
7098
7099       if (! ieee_push_type (info, m->type, 0, false, false))
7100         return false;
7101       info->type_stack->type.referencep = m->referencep;
7102       if (m->referencep)
7103         ++refcount;
7104       if (! ieee_variable ((PTR) info, m->name, vkind, m->val))
7105         return false;
7106     }
7107
7108   /* If there are any reference parameters, we need to output a
7109      miscellaneous record indicating them.  */
7110   if (refcount > 0)
7111     {
7112       unsigned int nindx, varindx;
7113
7114       /* FIXME: The MRI compiler outputs the demangled function name
7115          here, but we are outputting the mangled name.  */
7116       nindx = info->name_indx;
7117       ++info->name_indx;
7118       if (! ieee_change_buffer (info, &info->vars)
7119           || ! ieee_write_byte (info, (int) ieee_nn_record)
7120           || ! ieee_write_number (info, nindx)
7121           || ! ieee_write_id (info, "")
7122           || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7123           || ! ieee_write_number (info, nindx)
7124           || ! ieee_write_number (info, 0)
7125           || ! ieee_write_number (info, 62)
7126           || ! ieee_write_number (info, 80)
7127           || ! ieee_write_number (info, refcount + 3)
7128           || ! ieee_write_asn (info, nindx, 'B')
7129           || ! ieee_write_atn65 (info, nindx, info->fnname)
7130           || ! ieee_write_asn (info, nindx, 0))
7131         return false;
7132       for (m = info->pending_parms, varindx = 1;
7133            m != NULL;
7134            m = m->next, varindx++)
7135         {
7136           if (m->referencep)
7137             {
7138               if (! ieee_write_asn (info, nindx, varindx))
7139                 return false;
7140             }
7141         }
7142     }
7143
7144   m = info->pending_parms;
7145   while (m != NULL)
7146     {
7147       struct ieee_pending_parm *next;
7148
7149       next = m->next;
7150       free (m);
7151       m = next;
7152     }
7153
7154   info->pending_parms = NULL;
7155
7156   return true;
7157 }
7158
7159 /* Start a block.  If this is the first block, we output the address
7160    to finish the BB4 or BB6, and then output the function parameters.  */
7161
7162 static boolean
7163 ieee_start_block (p, addr)
7164      PTR p;
7165      bfd_vma addr;
7166 {
7167   struct ieee_handle *info = (struct ieee_handle *) p;
7168
7169   if (! ieee_change_buffer (info, &info->vars))
7170     return false;
7171
7172   if (info->block_depth == 1)
7173     {
7174       if (! ieee_write_number (info, addr)
7175           || ! ieee_output_pending_parms (info))
7176         return false;
7177     }
7178   else
7179     {
7180       if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
7181           || ! ieee_write_byte (info, 6)
7182           || ! ieee_write_number (info, 0)
7183           || ! ieee_write_id (info, "")
7184           || ! ieee_write_number (info, 0)
7185           || ! ieee_write_number (info, 0)
7186           || ! ieee_write_number (info, addr))
7187         return false;
7188     }
7189
7190   if (! ieee_start_range (info, addr))
7191     return false;
7192
7193   ++info->block_depth;
7194
7195   return true;
7196 }
7197
7198 /* End a block.  */
7199
7200 static boolean
7201 ieee_end_block (p, addr)
7202      PTR p;
7203      bfd_vma addr;
7204 {
7205   struct ieee_handle *info = (struct ieee_handle *) p;
7206
7207   /* The address we are given is the end of the block, but IEEE seems
7208      to want to the address of the last byte in the block, so we
7209      subtract one.  */
7210   if (! ieee_change_buffer (info, &info->vars)
7211       || ! ieee_write_byte (info, (int) ieee_be_record_enum)
7212       || ! ieee_write_number (info, addr - 1))
7213     return false;
7214
7215   if (! ieee_end_range (info, addr))
7216     return false;
7217
7218   --info->block_depth;
7219
7220   if (addr > info->highaddr)
7221     info->highaddr = addr;
7222
7223   return true;
7224 }
7225
7226 /* End a function.  */
7227
7228 static boolean
7229 ieee_end_function (p)
7230      PTR p;
7231 {
7232   struct ieee_handle *info = (struct ieee_handle *) p;
7233
7234   assert (info->block_depth == 1);
7235
7236   --info->block_depth;
7237
7238   /* Now we can finish up fntype, and add it to the typdef section.
7239      At this point, fntype is the 'x' type up to the argument count,
7240      and fnargs is the argument types.  We must add the argument
7241      count, and we must add the level.  FIXME: We don't record varargs
7242      functions correctly.  In fact, stabs debugging does not give us
7243      enough information to do so.  */
7244   if (! ieee_change_buffer (info, &info->fntype)
7245       || ! ieee_write_number (info, info->fnargcount)
7246       || ! ieee_change_buffer (info, &info->fnargs)
7247       || ! ieee_write_number (info, 0))
7248     return false;
7249
7250   /* Make sure the typdef block has been started.  */
7251   if (ieee_buffer_emptyp (&info->types))
7252     {
7253       if (! ieee_change_buffer (info, &info->types)
7254           || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
7255           || ! ieee_write_byte (info, 1)
7256           || ! ieee_write_number (info, 0)
7257           || ! ieee_write_id (info, info->modname))
7258         return false;
7259     }
7260
7261   if (! ieee_append_buffer (info, &info->types, &info->fntype)
7262       || ! ieee_append_buffer (info, &info->types, &info->fnargs))
7263     return false;
7264
7265   info->fnname = NULL;
7266   if (! ieee_init_buffer (info, &info->fntype)
7267       || ! ieee_init_buffer (info, &info->fnargs))
7268     return false;
7269   info->fnargcount = 0;
7270
7271   return true;
7272 }
7273
7274 /* Record line number information.  */
7275
7276 static boolean
7277 ieee_lineno (p, filename, lineno, addr)
7278      PTR p;
7279      const char *filename;
7280      unsigned long lineno;
7281      bfd_vma addr;
7282 {
7283   struct ieee_handle *info = (struct ieee_handle *) p;
7284
7285   assert (info->filename != NULL);
7286
7287   /* The HP simulator seems to get confused when more than one line is
7288      listed for the same address, at least if they are in different
7289      files.  We handle this by always listing the last line for a
7290      given address, since that seems to be the one that gdb uses.  */
7291   if (info->pending_lineno_filename != NULL
7292       && addr != info->pending_lineno_addr)
7293     {
7294       /* Make sure we have a line number block.  */
7295       if (! ieee_buffer_emptyp (&info->linenos))
7296         {
7297           if (! ieee_change_buffer (info, &info->linenos))
7298             return false;
7299         }
7300       else
7301         {
7302           info->lineno_name_indx = info->name_indx;
7303           ++info->name_indx;
7304           if (! ieee_change_buffer (info, &info->linenos)
7305               || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
7306               || ! ieee_write_byte (info, 5)
7307               || ! ieee_write_number (info, 0)
7308               || ! ieee_write_id (info, info->filename)
7309               || ! ieee_write_byte (info, (int) ieee_nn_record)
7310               || ! ieee_write_number (info, info->lineno_name_indx)
7311               || ! ieee_write_id (info, ""))
7312             return false;
7313           info->lineno_filename = info->filename;
7314         }
7315
7316       if (strcmp (info->pending_lineno_filename, info->lineno_filename) != 0)
7317         {
7318           if (strcmp (info->filename, info->lineno_filename) != 0)
7319             {
7320               /* We were not in the main file.  Close the block for the
7321                  included file.  */
7322               if (! ieee_write_byte (info, (int) ieee_be_record_enum))
7323                 return false;
7324               if (strcmp (info->filename, info->pending_lineno_filename) == 0)
7325                 {
7326                   /* We need a new NN record, and we aren't output to
7327                      output one.  */
7328                   info->lineno_name_indx = info->name_indx;
7329                   ++info->name_indx;
7330                   if (! ieee_write_byte (info, (int) ieee_nn_record)
7331                       || ! ieee_write_number (info, info->lineno_name_indx)
7332                       || ! ieee_write_id (info, ""))
7333                     return false;
7334                 }
7335             }
7336           if (strcmp (info->filename, info->pending_lineno_filename) != 0)
7337             {
7338               /* We are not changing to the main file.  Open a block for
7339                  the new included file.  */
7340               info->lineno_name_indx = info->name_indx;
7341               ++info->name_indx;
7342               if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
7343                   || ! ieee_write_byte (info, 5)
7344                   || ! ieee_write_number (info, 0)
7345                   || ! ieee_write_id (info, info->pending_lineno_filename)
7346                   || ! ieee_write_byte (info, (int) ieee_nn_record)
7347                   || ! ieee_write_number (info, info->lineno_name_indx)
7348                   || ! ieee_write_id (info, ""))
7349                 return false;
7350             }
7351           info->lineno_filename = info->pending_lineno_filename;
7352         }
7353
7354       if (! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7355           || ! ieee_write_number (info, info->lineno_name_indx)
7356           || ! ieee_write_number (info, 0)
7357           || ! ieee_write_number (info, 7)
7358           || ! ieee_write_number (info, info->pending_lineno)
7359           || ! ieee_write_number (info, 0)
7360           || ! ieee_write_asn (info, info->lineno_name_indx,
7361                                info->pending_lineno_addr))
7362         return false;
7363     }
7364
7365   info->pending_lineno_filename = filename;
7366   info->pending_lineno = lineno;
7367   info->pending_lineno_addr = addr;
7368
7369   return true;
7370 }