Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / binutils-2.21 / binutils / ieee.c
1 /* ieee.c -- Read and write IEEE-695 debugging information.
2    Copyright 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007,
3    2008, 2009, 2010  Free Software Foundation, Inc.
4    Written by Ian Lance Taylor <ian@cygnus.com>.
5
6    This file is part of GNU Binutils.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
21    02110-1301, USA.  */
22
23 /* This file reads and writes IEEE-695 debugging information.  */
24
25 #include "sysdep.h"
26 #include <assert.h>
27 #include "bfd.h"
28 #include "ieee.h"
29 #include "libiberty.h"
30 #include "debug.h"
31 #include "budbg.h"
32 #include "filenames.h"
33
34 /* This structure holds an entry on the block stack.  */
35
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   /* TRUE if this function is being skipped.  */
45   bfd_boolean skip;
46 };
47
48 /* This structure is the block stack.  */
49
50 #define BLOCKSTACK_SIZE (16)
51
52 struct ieee_blockstack
53 {
54   /* The stack pointer.  */
55   struct ieee_block *bsp;
56   /* The stack.  */
57   struct ieee_block stack[BLOCKSTACK_SIZE];
58 };
59
60 /* This structure holds information for a variable.  */
61
62 enum ieee_var_kind
63   {
64     IEEE_UNKNOWN,
65     IEEE_EXTERNAL,
66     IEEE_GLOBAL,
67     IEEE_STATIC,
68     IEEE_LOCAL,
69     IEEE_FUNCTION
70   };
71
72 struct ieee_var
73 {
74   /* Start of name.  */
75   const char *name;
76   /* Length of name.  */
77   unsigned long namlen;
78   /* Type.  */
79   debug_type type;
80   /* Slot if we make an indirect type.  */
81   debug_type *pslot;
82   /* Kind of variable or function.  */
83   enum ieee_var_kind kind;
84 };
85
86 /* This structure holds all the variables.  */
87
88 struct ieee_vars
89 {
90   /* Number of slots allocated.  */
91   unsigned int alloc;
92   /* Variables.  */
93   struct ieee_var *vars;
94 };
95
96 /* This structure holds information for a type.  We need this because
97    we don't want to represent bitfields as real types.  */
98
99 struct ieee_type
100 {
101   /* Type.  */
102   debug_type type;
103   /* Slot if this is type is referenced before it is defined.  */
104   debug_type *pslot;
105   /* Slots for arguments if we make indirect types for them.  */
106   debug_type *arg_slots;
107   /* If this is a bitfield, this is the size in bits.  If this is not
108      a bitfield, this is zero.  */
109   unsigned long bitsize;
110 };
111
112 /* This structure holds all the type information.  */
113
114 struct ieee_types
115 {
116   /* Number of slots allocated.  */
117   unsigned int alloc;
118   /* Types.  */
119   struct ieee_type *types;
120   /* Builtin types.  */
121 #define BUILTIN_TYPE_COUNT (60)
122   debug_type builtins[BUILTIN_TYPE_COUNT];
123 };
124
125 /* This structure holds a linked last of structs with their tag names,
126    so that we can convert them to C++ classes if necessary.  */
127
128 struct ieee_tag
129 {
130   /* Next tag.  */
131   struct ieee_tag *next;
132   /* This tag name.  */
133   const char *name;
134   /* The type of the tag.  */
135   debug_type type;
136   /* The tagged type is an indirect type pointing at this slot.  */
137   debug_type slot;
138   /* This is an array of slots used when a field type is converted
139      into a indirect type, in case it needs to be later converted into
140      a reference type.  */
141   debug_type *fslots;
142 };
143
144 /* This structure holds the information we pass around to the parsing
145    functions.  */
146
147 struct ieee_info
148 {
149   /* The debugging handle.  */
150   void *dhandle;
151   /* The BFD.  */
152   bfd *abfd;
153   /* The start of the bytes to be parsed.  */
154   const bfd_byte *bytes;
155   /* The end of the bytes to be parsed.  */
156   const bfd_byte *pend;
157   /* The block stack.  */
158   struct ieee_blockstack blockstack;
159   /* Whether we have seen a BB1 or BB2.  */
160   bfd_boolean saw_filename;
161   /* The variables.  */
162   struct ieee_vars vars;
163   /* The global variables, after a global typedef block.  */
164   struct ieee_vars *global_vars;
165   /* The types.  */
166   struct ieee_types types;
167   /* The global types, after a global typedef block.  */
168   struct ieee_types *global_types;
169   /* The list of tagged structs.  */
170   struct ieee_tag *tags;
171 };
172
173 /* Basic builtin types, not including the pointers.  */
174
175 enum builtin_types
176 {
177   builtin_unknown = 0,
178   builtin_void = 1,
179   builtin_signed_char = 2,
180   builtin_unsigned_char = 3,
181   builtin_signed_short_int = 4,
182   builtin_unsigned_short_int = 5,
183   builtin_signed_long = 6,
184   builtin_unsigned_long = 7,
185   builtin_signed_long_long = 8,
186   builtin_unsigned_long_long = 9,
187   builtin_float = 10,
188   builtin_double = 11,
189   builtin_long_double = 12,
190   builtin_long_long_double = 13,
191   builtin_quoted_string = 14,
192   builtin_instruction_address = 15,
193   builtin_int = 16,
194   builtin_unsigned = 17,
195   builtin_unsigned_int = 18,
196   builtin_char = 19,
197   builtin_long = 20,
198   builtin_short = 21,
199   builtin_unsigned_short = 22,
200   builtin_short_int = 23,
201   builtin_signed_short = 24,
202   builtin_bcd_float = 25
203 };
204
205 /* These are the values found in the derivation flags of a 'b'
206    component record of a 'T' type extension record in a C++ pmisc
207    record.  These are bitmasks.  */
208
209 /* Set for a private base class, clear for a public base class.
210    Protected base classes are not supported.  */
211 #define BASEFLAGS_PRIVATE (0x1)
212 /* Set for a virtual base class.  */
213 #define BASEFLAGS_VIRTUAL (0x2)
214 /* Set for a friend class, clear for a base class.  */
215 #define BASEFLAGS_FRIEND (0x10)
216
217 /* These are the values found in the specs flags of a 'd', 'm', or 'v'
218    component record of a 'T' type extension record in a C++ pmisc
219    record.  The same flags are used for a 'M' record in a C++ pmisc
220    record.  */
221
222 /* The lower two bits hold visibility information.  */
223 #define CXXFLAGS_VISIBILITY (0x3)
224 /* This value in the lower two bits indicates a public member.  */
225 #define CXXFLAGS_VISIBILITY_PUBLIC (0x0)
226 /* This value in the lower two bits indicates a private member.  */
227 #define CXXFLAGS_VISIBILITY_PRIVATE (0x1)
228 /* This value in the lower two bits indicates a protected member.  */
229 #define CXXFLAGS_VISIBILITY_PROTECTED (0x2)
230 /* Set for a static member.  */
231 #define CXXFLAGS_STATIC (0x4)
232 /* Set for a virtual override.  */
233 #define CXXFLAGS_OVERRIDE (0x8)
234 /* Set for a friend function.  */
235 #define CXXFLAGS_FRIEND (0x10)
236 /* Set for a const function.  */
237 #define CXXFLAGS_CONST (0x20)
238 /* Set for a volatile function.  */
239 #define CXXFLAGS_VOLATILE (0x40)
240 /* Set for an overloaded function.  */
241 #define CXXFLAGS_OVERLOADED (0x80)
242 /* Set for an operator function.  */
243 #define CXXFLAGS_OPERATOR (0x100)
244 /* Set for a constructor or destructor.  */
245 #define CXXFLAGS_CTORDTOR (0x400)
246 /* Set for a constructor.  */
247 #define CXXFLAGS_CTOR (0x200)
248 /* Set for an inline function.  */
249 #define CXXFLAGS_INLINE (0x800)
250
251 /* Local functions.  */
252
253 static void ieee_error (struct ieee_info *, const bfd_byte *, const char *);
254 static void ieee_eof (struct ieee_info *);
255 static char *savestring (const char *, unsigned long);
256 static bfd_boolean ieee_read_number
257   (struct ieee_info *, const bfd_byte **, bfd_vma *);
258 static bfd_boolean ieee_read_optional_number
259   (struct ieee_info *, const bfd_byte **, bfd_vma *, bfd_boolean *);
260 static bfd_boolean ieee_read_id
261   (struct ieee_info *, const bfd_byte **, const char **, unsigned long *);
262 static bfd_boolean ieee_read_optional_id
263   (struct ieee_info *, const bfd_byte **, const char **, unsigned long *,
264    bfd_boolean *);
265 static bfd_boolean ieee_read_expression
266   (struct ieee_info *, const bfd_byte **, bfd_vma *);
267 static debug_type ieee_builtin_type
268   (struct ieee_info *, const bfd_byte *, unsigned int);
269 static bfd_boolean ieee_alloc_type
270   (struct ieee_info *, unsigned int, bfd_boolean);
271 static bfd_boolean ieee_read_type_index
272   (struct ieee_info *, const bfd_byte **, debug_type *);
273 static int ieee_regno_to_genreg (bfd *, int);
274 static int ieee_genreg_to_regno (bfd *, int);
275 static bfd_boolean parse_ieee_bb (struct ieee_info *, const bfd_byte **);
276 static bfd_boolean parse_ieee_be (struct ieee_info *, const bfd_byte **);
277 static bfd_boolean parse_ieee_nn (struct ieee_info *, const bfd_byte **);
278 static bfd_boolean parse_ieee_ty (struct ieee_info *, const bfd_byte **);
279 static bfd_boolean parse_ieee_atn (struct ieee_info *, const bfd_byte **);
280 static bfd_boolean ieee_read_cxx_misc
281   (struct ieee_info *, const bfd_byte **, unsigned long);
282 static bfd_boolean ieee_read_cxx_class
283   (struct ieee_info *, const bfd_byte **, unsigned long);
284 static bfd_boolean ieee_read_cxx_defaults
285   (struct ieee_info *, const bfd_byte **, unsigned long);
286 static bfd_boolean ieee_read_reference
287   (struct ieee_info *, const bfd_byte **);
288 static bfd_boolean ieee_require_asn
289   (struct ieee_info *, const bfd_byte **, bfd_vma *);
290 static bfd_boolean ieee_require_atn65
291   (struct ieee_info *, const bfd_byte **, const char **, unsigned long *);
292
293 /* Report an error in the IEEE debugging information.  */
294
295 static void
296 ieee_error (struct ieee_info *info, const bfd_byte *p, const char *s)
297 {
298   if (p != NULL)
299     fprintf (stderr, "%s: 0x%lx: %s (0x%x)\n", bfd_get_filename (info->abfd),
300              (unsigned long) (p - info->bytes), s, *p);
301   else
302     fprintf (stderr, "%s: %s\n", bfd_get_filename (info->abfd), s);
303 }
304
305 /* Report an unexpected EOF in the IEEE debugging information.  */
306
307 static void
308 ieee_eof (struct ieee_info *info)
309 {
310   ieee_error (info, (const bfd_byte *) NULL,
311               _("unexpected end of debugging information"));
312 }
313
314 /* Save a string in memory.  */
315
316 static char *
317 savestring (const char *start, unsigned long len)
318 {
319   char *ret;
320
321   ret = (char *) xmalloc (len + 1);
322   memcpy (ret, start, len);
323   ret[len] = '\0';
324   return ret;
325 }
326
327 /* Read a number which must be present in an IEEE file.  */
328
329 static bfd_boolean
330 ieee_read_number (struct ieee_info *info, const bfd_byte **pp, bfd_vma *pv)
331 {
332   return ieee_read_optional_number (info, pp, pv, (bfd_boolean *) NULL);
333 }
334
335 /* Read a number in an IEEE file.  If ppresent is not NULL, the number
336    need not be there.  */
337
338 static bfd_boolean
339 ieee_read_optional_number (struct ieee_info *info, const bfd_byte **pp,
340                            bfd_vma *pv, bfd_boolean *ppresent)
341 {
342   ieee_record_enum_type b;
343
344   if (*pp >= info->pend)
345     {
346       if (ppresent != NULL)
347         {
348           *ppresent = FALSE;
349           return TRUE;
350         }
351       ieee_eof (info);
352       return FALSE;
353     }
354
355   b = (ieee_record_enum_type) **pp;
356   ++*pp;
357
358   if (b <= ieee_number_end_enum)
359     {
360       *pv = (bfd_vma) b;
361       if (ppresent != NULL)
362         *ppresent = TRUE;
363       return TRUE;
364     }
365
366   if (b >= ieee_number_repeat_start_enum && b <= ieee_number_repeat_end_enum)
367     {
368       unsigned int i;
369
370       i = (int) b - (int) ieee_number_repeat_start_enum;
371       if (*pp + i - 1 >= info->pend)
372         {
373           ieee_eof (info);
374           return FALSE;
375         }
376
377       *pv = 0;
378       for (; i > 0; i--)
379         {
380           *pv <<= 8;
381           *pv += **pp;
382           ++*pp;
383         }
384
385       if (ppresent != NULL)
386         *ppresent = TRUE;
387
388       return TRUE;
389     }
390
391   if (ppresent != NULL)
392     {
393       --*pp;
394       *ppresent = FALSE;
395       return TRUE;
396     }
397
398   ieee_error (info, *pp - 1, _("invalid number"));
399   return FALSE;
400 }
401
402 /* Read a required string from an IEEE file.  */
403
404 static bfd_boolean
405 ieee_read_id (struct ieee_info *info, const bfd_byte **pp,
406               const char **pname, unsigned long *pnamlen)
407 {
408   return ieee_read_optional_id (info, pp, pname, pnamlen, (bfd_boolean *) NULL);
409 }
410
411 /* Read a string from an IEEE file.  If ppresent is not NULL, the
412    string is optional.  */
413
414 static bfd_boolean
415 ieee_read_optional_id (struct ieee_info *info, const bfd_byte **pp,
416                        const char **pname, unsigned long *pnamlen,
417                        bfd_boolean *ppresent)
418 {
419   bfd_byte b;
420   unsigned long len;
421
422   if (*pp >= info->pend)
423     {
424       ieee_eof (info);
425       return FALSE;
426     }
427
428   b = **pp;
429   ++*pp;
430
431   if (b <= 0x7f)
432     len = b;
433   else if ((ieee_record_enum_type) b == ieee_extension_length_1_enum)
434     {
435       len = **pp;
436       ++*pp;
437     }
438   else if ((ieee_record_enum_type) b == ieee_extension_length_2_enum)
439     {
440       len = (**pp << 8) + (*pp)[1];
441       *pp += 2;
442     }
443   else
444     {
445       if (ppresent != NULL)
446         {
447           --*pp;
448           *ppresent = FALSE;
449           return TRUE;
450         }
451       ieee_error (info, *pp - 1, _("invalid string length"));
452       return FALSE;
453     }
454
455   if ((unsigned long) (info->pend - *pp) < len)
456     {
457       ieee_eof (info);
458       return FALSE;
459     }
460
461   *pname = (const char *) *pp;
462   *pnamlen = len;
463   *pp += len;
464
465   if (ppresent != NULL)
466     *ppresent = TRUE;
467
468   return TRUE;
469 }
470
471 /* Read an expression from an IEEE file.  Since this code is only used
472    to parse debugging information, I haven't bothered to write a full
473    blown IEEE expression parser.  I've only thrown in the things I've
474    seen in debugging information.  This can be easily extended if
475    necessary.  */
476
477 static bfd_boolean
478 ieee_read_expression (struct ieee_info *info, const bfd_byte **pp,
479                       bfd_vma *pv)
480 {
481   const bfd_byte *expr_start;
482 #define EXPR_STACK_SIZE (10)
483   bfd_vma expr_stack[EXPR_STACK_SIZE];
484   bfd_vma *esp;
485
486   expr_start = *pp;
487
488   esp = expr_stack;
489
490   while (1)
491     {
492       const bfd_byte *start;
493       bfd_vma val;
494       bfd_boolean present;
495       ieee_record_enum_type c;
496
497       start = *pp;
498
499       if (! ieee_read_optional_number (info, pp, &val, &present))
500         return FALSE;
501
502       if (present)
503         {
504           if (esp - expr_stack >= EXPR_STACK_SIZE)
505             {
506               ieee_error (info, start, _("expression stack overflow"));
507               return FALSE;
508             }
509           *esp++ = val;
510           continue;
511         }
512
513       c = (ieee_record_enum_type) **pp;
514
515       if (c >= ieee_module_beginning_enum)
516         break;
517
518       ++*pp;
519
520       if (c == ieee_comma)
521         break;
522
523       switch (c)
524         {
525         default:
526           ieee_error (info, start, _("unsupported IEEE expression operator"));
527           break;
528
529         case ieee_variable_R_enum:
530           {
531             bfd_vma indx;
532             asection *s;
533
534             if (! ieee_read_number (info, pp, &indx))
535               return FALSE;
536             for (s = info->abfd->sections; s != NULL; s = s->next)
537               if ((bfd_vma) s->target_index == indx)
538                 break;
539             if (s == NULL)
540               {
541                 ieee_error (info, start, _("unknown section"));
542                 return FALSE;
543               }
544
545             if (esp - expr_stack >= EXPR_STACK_SIZE)
546               {
547                 ieee_error (info, start, _("expression stack overflow"));
548                 return FALSE;
549               }
550
551             *esp++ = bfd_get_section_vma (info->abfd, s);
552           }
553           break;
554
555         case ieee_function_plus_enum:
556         case ieee_function_minus_enum:
557           {
558             bfd_vma v1, v2;
559
560             if (esp - expr_stack < 2)
561               {
562                 ieee_error (info, start, _("expression stack underflow"));
563                 return FALSE;
564               }
565
566             v1 = *--esp;
567             v2 = *--esp;
568             *esp++ = v1 + v2;
569           }
570           break;
571         }
572     }
573
574   if (esp - 1 != expr_stack)
575     {
576       ieee_error (info, expr_start, _("expression stack mismatch"));
577       return FALSE;
578     }
579
580   *pv = *--esp;
581
582   return TRUE;
583 }
584
585 /* Return an IEEE builtin type.  */
586
587 static debug_type
588 ieee_builtin_type (struct ieee_info *info, const bfd_byte *p,
589                    unsigned int indx)
590 {
591   void *dhandle;
592   debug_type type;
593   const char *name;
594
595   if (indx < BUILTIN_TYPE_COUNT
596       && info->types.builtins[indx] != DEBUG_TYPE_NULL)
597     return info->types.builtins[indx];
598
599   dhandle = info->dhandle;
600
601   if (indx >= 32 && indx < 64)
602     {
603       type = debug_make_pointer_type (dhandle,
604                                       ieee_builtin_type (info, p, indx - 32));
605       assert (indx < BUILTIN_TYPE_COUNT);
606       info->types.builtins[indx] = type;
607       return type;
608     }
609
610   switch ((enum builtin_types) indx)
611     {
612     default:
613       ieee_error (info, p, _("unknown builtin type"));
614       return NULL;
615
616     case builtin_unknown:
617       type = debug_make_void_type (dhandle);
618       name = NULL;
619       break;
620
621     case builtin_void:
622       type = debug_make_void_type (dhandle);
623       name = "void";
624       break;
625
626     case builtin_signed_char:
627       type = debug_make_int_type (dhandle, 1, FALSE);
628       name = "signed char";
629       break;
630
631     case builtin_unsigned_char:
632       type = debug_make_int_type (dhandle, 1, TRUE);
633       name = "unsigned char";
634       break;
635
636     case builtin_signed_short_int:
637       type = debug_make_int_type (dhandle, 2, FALSE);
638       name = "signed short int";
639       break;
640
641     case builtin_unsigned_short_int:
642       type = debug_make_int_type (dhandle, 2, TRUE);
643       name = "unsigned short int";
644       break;
645
646     case builtin_signed_long:
647       type = debug_make_int_type (dhandle, 4, FALSE);
648       name = "signed long";
649       break;
650
651     case builtin_unsigned_long:
652       type = debug_make_int_type (dhandle, 4, TRUE);
653       name = "unsigned long";
654       break;
655
656     case builtin_signed_long_long:
657       type = debug_make_int_type (dhandle, 8, FALSE);
658       name = "signed long long";
659       break;
660
661     case builtin_unsigned_long_long:
662       type = debug_make_int_type (dhandle, 8, TRUE);
663       name = "unsigned long long";
664       break;
665
666     case builtin_float:
667       type = debug_make_float_type (dhandle, 4);
668       name = "float";
669       break;
670
671     case builtin_double:
672       type = debug_make_float_type (dhandle, 8);
673       name = "double";
674       break;
675
676     case builtin_long_double:
677       /* FIXME: The size for this type should depend upon the
678          processor.  */
679       type = debug_make_float_type (dhandle, 12);
680       name = "long double";
681       break;
682
683     case builtin_long_long_double:
684       type = debug_make_float_type (dhandle, 16);
685       name = "long long double";
686       break;
687
688     case builtin_quoted_string:
689       type = debug_make_array_type (dhandle,
690                                     ieee_builtin_type (info, p,
691                                                        ((unsigned int)
692                                                         builtin_char)),
693                                     ieee_builtin_type (info, p,
694                                                        ((unsigned int)
695                                                         builtin_int)),
696                                     0, -1, TRUE);
697       name = "QUOTED STRING";
698       break;
699
700     case builtin_instruction_address:
701       /* FIXME: This should be a code address.  */
702       type = debug_make_int_type (dhandle, 4, TRUE);
703       name = "instruction address";
704       break;
705
706     case builtin_int:
707       /* FIXME: The size for this type should depend upon the
708          processor.  */
709       type = debug_make_int_type (dhandle, 4, FALSE);
710       name = "int";
711       break;
712
713     case builtin_unsigned:
714       /* FIXME: The size for this type should depend upon the
715          processor.  */
716       type = debug_make_int_type (dhandle, 4, TRUE);
717       name = "unsigned";
718       break;
719
720     case builtin_unsigned_int:
721       /* FIXME: The size for this type should depend upon the
722          processor.  */
723       type = debug_make_int_type (dhandle, 4, TRUE);
724       name = "unsigned int";
725       break;
726
727     case builtin_char:
728       type = debug_make_int_type (dhandle, 1, FALSE);
729       name = "char";
730       break;
731
732     case builtin_long:
733       type = debug_make_int_type (dhandle, 4, FALSE);
734       name = "long";
735       break;
736
737     case builtin_short:
738       type = debug_make_int_type (dhandle, 2, FALSE);
739       name = "short";
740       break;
741
742     case builtin_unsigned_short:
743       type = debug_make_int_type (dhandle, 2, TRUE);
744       name = "unsigned short";
745       break;
746
747     case builtin_short_int:
748       type = debug_make_int_type (dhandle, 2, FALSE);
749       name = "short int";
750       break;
751
752     case builtin_signed_short:
753       type = debug_make_int_type (dhandle, 2, FALSE);
754       name = "signed short";
755       break;
756
757     case builtin_bcd_float:
758       ieee_error (info, p, _("BCD float type not supported"));
759       return DEBUG_TYPE_NULL;
760     }
761
762   if (name != NULL)
763     type = debug_name_type (dhandle, name, type);
764
765   assert (indx < BUILTIN_TYPE_COUNT);
766
767   info->types.builtins[indx] = type;
768
769   return type;
770 }
771
772 /* Allocate more space in the type table.  If ref is TRUE, this is a
773    reference to the type; if it is not already defined, we should set
774    up an indirect type.  */
775
776 static bfd_boolean
777 ieee_alloc_type (struct ieee_info *info, unsigned int indx, bfd_boolean ref)
778 {
779   unsigned int nalloc;
780   register struct ieee_type *t;
781   struct ieee_type *tend;
782
783   if (indx >= info->types.alloc)
784     {
785       nalloc = info->types.alloc;
786       if (nalloc == 0)
787         nalloc = 4;
788       while (indx >= nalloc)
789         nalloc *= 2;
790
791       info->types.types = ((struct ieee_type *)
792                            xrealloc (info->types.types,
793                                      nalloc * sizeof *info->types.types));
794
795       memset (info->types.types + info->types.alloc, 0,
796               (nalloc - info->types.alloc) * sizeof *info->types.types);
797
798       tend = info->types.types + nalloc;
799       for (t = info->types.types + info->types.alloc; t < tend; t++)
800         t->type = DEBUG_TYPE_NULL;
801
802       info->types.alloc = nalloc;
803     }
804
805   if (ref)
806     {
807       t = info->types.types + indx;
808       if (t->type == NULL)
809         {
810           t->pslot = (debug_type *) xmalloc (sizeof *t->pslot);
811           *t->pslot = DEBUG_TYPE_NULL;
812           t->type = debug_make_indirect_type (info->dhandle, t->pslot,
813                                               (const char *) NULL);
814           if (t->type == NULL)
815             return FALSE;
816         }
817     }
818
819   return TRUE;
820 }
821
822 /* Read a type index and return the corresponding type.  */
823
824 static bfd_boolean
825 ieee_read_type_index (struct ieee_info *info, const bfd_byte **pp,
826                       debug_type *ptype)
827 {
828   const bfd_byte *start;
829   bfd_vma indx;
830
831   start = *pp;
832
833   if (! ieee_read_number (info, pp, &indx))
834     return FALSE;
835
836   if (indx < 256)
837     {
838       *ptype = ieee_builtin_type (info, start, indx);
839       if (*ptype == NULL)
840         return FALSE;
841       return TRUE;
842     }
843
844   indx -= 256;
845   if (! ieee_alloc_type (info, indx, TRUE))
846     return FALSE;
847
848   *ptype = info->types.types[indx].type;
849
850   return TRUE;
851 }
852
853 /* Parse IEEE debugging information for a file.  This is passed the
854    bytes which compose the Debug Information Part of an IEEE file.  */
855
856 bfd_boolean
857 parse_ieee (void *dhandle, bfd *abfd, const bfd_byte *bytes, bfd_size_type len)
858 {
859   struct ieee_info info;
860   unsigned int i;
861   const bfd_byte *p, *pend;
862
863   info.dhandle = dhandle;
864   info.abfd = abfd;
865   info.bytes = bytes;
866   info.pend = bytes + len;
867   info.blockstack.bsp = info.blockstack.stack;
868   info.saw_filename = FALSE;
869   info.vars.alloc = 0;
870   info.vars.vars = NULL;
871   info.global_vars = NULL;
872   info.types.alloc = 0;
873   info.types.types = NULL;
874   info.global_types = NULL;
875   info.tags = NULL;
876   for (i = 0; i < BUILTIN_TYPE_COUNT; i++)
877     info.types.builtins[i] = DEBUG_TYPE_NULL;
878
879   p = bytes;
880   pend = info.pend;
881   while (p < pend)
882     {
883       const bfd_byte *record_start;
884       ieee_record_enum_type c;
885
886       record_start = p;
887
888       c = (ieee_record_enum_type) *p++;
889
890       if (c == ieee_at_record_enum)
891         c = (ieee_record_enum_type) (((unsigned int) c << 8) | *p++);
892
893       if (c <= ieee_number_repeat_end_enum)
894         {
895           ieee_error (&info, record_start, _("unexpected number"));
896           return FALSE;
897         }
898
899       switch (c)
900         {
901         default:
902           ieee_error (&info, record_start, _("unexpected record type"));
903           return FALSE;
904
905         case ieee_bb_record_enum:
906           if (! parse_ieee_bb (&info, &p))
907             return FALSE;
908           break;
909
910         case ieee_be_record_enum:
911           if (! parse_ieee_be (&info, &p))
912             return FALSE;
913           break;
914
915         case ieee_nn_record:
916           if (! parse_ieee_nn (&info, &p))
917             return FALSE;
918           break;
919
920         case ieee_ty_record_enum:
921           if (! parse_ieee_ty (&info, &p))
922             return FALSE;
923           break;
924
925         case ieee_atn_record_enum:
926           if (! parse_ieee_atn (&info, &p))
927             return FALSE;
928           break;
929         }
930     }
931
932   if (info.blockstack.bsp != info.blockstack.stack)
933     {
934       ieee_error (&info, (const bfd_byte *) NULL,
935                   _("blocks left on stack at end"));
936       return FALSE;
937     }
938
939   return TRUE;
940 }
941
942 /* Handle an IEEE BB record.  */
943
944 static bfd_boolean
945 parse_ieee_bb (struct ieee_info *info, const bfd_byte **pp)
946 {
947   const bfd_byte *block_start;
948   bfd_byte b;
949   bfd_vma size;
950   const char *name;
951   unsigned long namlen;
952   char *namcopy = NULL;
953   unsigned int fnindx;
954   bfd_boolean skip;
955
956   block_start = *pp;
957
958   b = **pp;
959   ++*pp;
960
961   if (! ieee_read_number (info, pp, &size)
962       || ! ieee_read_id (info, pp, &name, &namlen))
963     return FALSE;
964
965   fnindx = (unsigned int) -1;
966   skip = FALSE;
967
968   switch (b)
969     {
970     case 1:
971       /* BB1: Type definitions local to a module.  */
972       namcopy = savestring (name, namlen);
973       if (namcopy == NULL)
974         return FALSE;
975       if (! debug_set_filename (info->dhandle, namcopy))
976         return FALSE;
977       info->saw_filename = TRUE;
978
979       /* Discard any variables or types we may have seen before.  */
980       if (info->vars.vars != NULL)
981         free (info->vars.vars);
982       info->vars.vars = NULL;
983       info->vars.alloc = 0;
984       if (info->types.types != NULL)
985         free (info->types.types);
986       info->types.types = NULL;
987       info->types.alloc = 0;
988
989       /* Initialize the types to the global types.  */
990       if (info->global_types != NULL)
991         {
992           info->types.alloc = info->global_types->alloc;
993           info->types.types = ((struct ieee_type *)
994                                xmalloc (info->types.alloc
995                                         * sizeof (*info->types.types)));
996           memcpy (info->types.types, info->global_types->types,
997                   info->types.alloc * sizeof (*info->types.types));
998         }
999
1000       break;
1001
1002     case 2:
1003       /* BB2: Global type definitions.  The name is supposed to be
1004          empty, but we don't check.  */
1005       if (! debug_set_filename (info->dhandle, "*global*"))
1006         return FALSE;
1007       info->saw_filename = TRUE;
1008       break;
1009
1010     case 3:
1011       /* BB3: High level module block begin.  We don't have to do
1012          anything here.  The name is supposed to be the same as for
1013          the BB1, but we don't check.  */
1014       break;
1015
1016     case 4:
1017       /* BB4: Global function.  */
1018       {
1019         bfd_vma stackspace, typindx, offset;
1020         debug_type return_type;
1021
1022         if (! ieee_read_number (info, pp, &stackspace)
1023             || ! ieee_read_number (info, pp, &typindx)
1024             || ! ieee_read_expression (info, pp, &offset))
1025           return FALSE;
1026
1027         /* We have no way to record the stack space.  FIXME.  */
1028
1029         if (typindx < 256)
1030           {
1031             return_type = ieee_builtin_type (info, block_start, typindx);
1032             if (return_type == DEBUG_TYPE_NULL)
1033               return FALSE;
1034           }
1035         else
1036           {
1037             typindx -= 256;
1038             if (! ieee_alloc_type (info, typindx, TRUE))
1039               return FALSE;
1040             fnindx = typindx;
1041             return_type = info->types.types[typindx].type;
1042             if (debug_get_type_kind (info->dhandle, return_type)
1043                 == DEBUG_KIND_FUNCTION)
1044               return_type = debug_get_return_type (info->dhandle,
1045                                                    return_type);
1046           }
1047
1048         namcopy = savestring (name, namlen);
1049         if (namcopy == NULL)
1050           return FALSE;
1051         if (! debug_record_function (info->dhandle, namcopy, return_type,
1052                                      TRUE, offset))
1053           return FALSE;
1054       }
1055       break;
1056
1057     case 5:
1058       /* BB5: File name for source line numbers.  */
1059       {
1060         unsigned int i;
1061
1062         /* We ignore the date and time.  FIXME.  */
1063         for (i = 0; i < 6; i++)
1064           {
1065             bfd_vma ignore;
1066             bfd_boolean present;
1067
1068             if (! ieee_read_optional_number (info, pp, &ignore, &present))
1069               return FALSE;
1070             if (! present)
1071               break;
1072           }
1073
1074         if (! info->saw_filename)
1075           {
1076             namcopy = savestring (name, namlen);
1077             if (namcopy == NULL)
1078               return FALSE;
1079             if (! debug_set_filename (info->dhandle, namcopy))
1080               return FALSE;
1081             info->saw_filename = TRUE;
1082           }
1083
1084         namcopy = savestring (name, namlen);
1085         if (namcopy == NULL)
1086           return FALSE;
1087         if (! debug_start_source (info->dhandle, namcopy))
1088           return FALSE;
1089       }
1090       break;
1091
1092     case 6:
1093       /* BB6: Local function or block.  */
1094       {
1095         bfd_vma stackspace, typindx, offset;
1096
1097         if (! ieee_read_number (info, pp, &stackspace)
1098             || ! ieee_read_number (info, pp, &typindx)
1099             || ! ieee_read_expression (info, pp, &offset))
1100           return FALSE;
1101
1102         /* We have no way to record the stack space.  FIXME.  */
1103
1104         if (namlen == 0)
1105           {
1106             if (! debug_start_block (info->dhandle, offset))
1107               return FALSE;
1108             /* Change b to indicate that this is a block
1109                rather than a function.  */
1110             b = 0x86;
1111           }
1112         else
1113           {
1114             /* The MRI C++ compiler will output a fake function named
1115                __XRYCPP to hold C++ debugging information.  We skip
1116                that function.  This is not crucial, but it makes
1117                converting from IEEE to other debug formats work
1118                better.  */
1119             if (strncmp (name, "__XRYCPP", namlen) == 0)
1120               skip = TRUE;
1121             else
1122               {
1123                 debug_type return_type;
1124
1125                 if (typindx < 256)
1126                   {
1127                     return_type = ieee_builtin_type (info, block_start,
1128                                                      typindx);
1129                     if (return_type == NULL)
1130                       return FALSE;
1131                   }
1132                 else
1133                   {
1134                     typindx -= 256;
1135                     if (! ieee_alloc_type (info, typindx, TRUE))
1136                       return FALSE;
1137                     fnindx = typindx;
1138                     return_type = info->types.types[typindx].type;
1139                     if (debug_get_type_kind (info->dhandle, return_type)
1140                         == DEBUG_KIND_FUNCTION)
1141                       return_type = debug_get_return_type (info->dhandle,
1142                                                            return_type);
1143                   }
1144
1145                 namcopy = savestring (name, namlen);
1146                 if (namcopy == NULL)
1147                   return FALSE;
1148                 if (! debug_record_function (info->dhandle, namcopy,
1149                                              return_type, FALSE, offset))
1150                   return FALSE;
1151               }
1152           }
1153       }
1154       break;
1155
1156     case 10:
1157       /* BB10: Assembler module scope.  In the normal case, we
1158          completely ignore all this information.  FIXME.  */
1159       {
1160         const char *inam, *vstr;
1161         unsigned long inamlen, vstrlen;
1162         bfd_vma tool_type;
1163         bfd_boolean present;
1164         unsigned int i;
1165
1166         if (! info->saw_filename)
1167           {
1168             namcopy = savestring (name, namlen);
1169             if (namcopy == NULL)
1170               return FALSE;
1171             if (! debug_set_filename (info->dhandle, namcopy))
1172               return FALSE;
1173             info->saw_filename = TRUE;
1174           }
1175
1176         if (! ieee_read_id (info, pp, &inam, &inamlen)
1177             || ! ieee_read_number (info, pp, &tool_type)
1178             || ! ieee_read_optional_id (info, pp, &vstr, &vstrlen, &present))
1179           return FALSE;
1180         for (i = 0; i < 6; i++)
1181           {
1182             bfd_vma ignore;
1183
1184             if (! ieee_read_optional_number (info, pp, &ignore, &present))
1185               return FALSE;
1186             if (! present)
1187               break;
1188           }
1189       }
1190       break;
1191
1192     case 11:
1193       /* BB11: Module section.  We completely ignore all this
1194          information.  FIXME.  */
1195       {
1196         bfd_vma sectype, secindx, offset, map;
1197         bfd_boolean present;
1198
1199         if (! ieee_read_number (info, pp, &sectype)
1200             || ! ieee_read_number (info, pp, &secindx)
1201             || ! ieee_read_expression (info, pp, &offset)
1202             || ! ieee_read_optional_number (info, pp, &map, &present))
1203           return FALSE;
1204       }
1205       break;
1206
1207     default:
1208       ieee_error (info, block_start, _("unknown BB type"));
1209       return FALSE;
1210     }
1211
1212
1213   /* Push this block on the block stack.  */
1214
1215   if (info->blockstack.bsp >= info->blockstack.stack + BLOCKSTACK_SIZE)
1216     {
1217       ieee_error (info, (const bfd_byte *) NULL, _("stack overflow"));
1218       return FALSE;
1219     }
1220
1221   info->blockstack.bsp->kind = b;
1222   if (b == 5)
1223     info->blockstack.bsp->filename = namcopy;
1224   info->blockstack.bsp->fnindx = fnindx;
1225   info->blockstack.bsp->skip = skip;
1226   ++info->blockstack.bsp;
1227
1228   return TRUE;
1229 }
1230
1231 /* Handle an IEEE BE record.  */
1232
1233 static bfd_boolean
1234 parse_ieee_be (struct ieee_info *info, const bfd_byte **pp)
1235 {
1236   bfd_vma offset;
1237
1238   if (info->blockstack.bsp <= info->blockstack.stack)
1239     {
1240       ieee_error (info, *pp, _("stack underflow"));
1241       return FALSE;
1242     }
1243   --info->blockstack.bsp;
1244
1245   switch (info->blockstack.bsp->kind)
1246     {
1247     case 2:
1248       /* When we end the global typedefs block, we copy out the
1249          contents of info->vars.  This is because the variable indices
1250          may be reused in the local blocks.  However, we need to
1251          preserve them so that we can locate a function returning a
1252          reference variable whose type is named in the global typedef
1253          block.  */
1254       info->global_vars = ((struct ieee_vars *)
1255                            xmalloc (sizeof *info->global_vars));
1256       info->global_vars->alloc = info->vars.alloc;
1257       info->global_vars->vars = ((struct ieee_var *)
1258                                  xmalloc (info->vars.alloc
1259                                           * sizeof (*info->vars.vars)));
1260       memcpy (info->global_vars->vars, info->vars.vars,
1261               info->vars.alloc * sizeof (*info->vars.vars));
1262
1263       /* We also copy out the non builtin parts of info->types, since
1264          the types are discarded when we start a new block.  */
1265       info->global_types = ((struct ieee_types *)
1266                             xmalloc (sizeof *info->global_types));
1267       info->global_types->alloc = info->types.alloc;
1268       info->global_types->types = ((struct ieee_type *)
1269                                    xmalloc (info->types.alloc
1270                                             * sizeof (*info->types.types)));
1271       memcpy (info->global_types->types, info->types.types,
1272               info->types.alloc * sizeof (*info->types.types));
1273       memset (info->global_types->builtins, 0,
1274               sizeof (info->global_types->builtins));
1275
1276       break;
1277
1278     case 4:
1279     case 6:
1280       if (! ieee_read_expression (info, pp, &offset))
1281         return FALSE;
1282       if (! info->blockstack.bsp->skip)
1283         {
1284           if (! debug_end_function (info->dhandle, offset + 1))
1285             return FALSE;
1286         }
1287       break;
1288
1289     case 0x86:
1290       /* This is BE6 when BB6 started a block rather than a local
1291          function.  */
1292       if (! ieee_read_expression (info, pp, &offset))
1293         return FALSE;
1294       if (! debug_end_block (info->dhandle, offset + 1))
1295         return FALSE;
1296       break;
1297
1298     case 5:
1299       /* When we end a BB5, we look up the stack for the last BB5, if
1300          there is one, so that we can call debug_start_source.  */
1301       if (info->blockstack.bsp > info->blockstack.stack)
1302         {
1303           struct ieee_block *bl;
1304
1305           bl = info->blockstack.bsp;
1306           do
1307             {
1308               --bl;
1309               if (bl->kind == 5)
1310                 {
1311                   if (! debug_start_source (info->dhandle, bl->filename))
1312                     return FALSE;
1313                   break;
1314                 }
1315             }
1316           while (bl != info->blockstack.stack);
1317         }
1318       break;
1319
1320     case 11:
1321       if (! ieee_read_expression (info, pp, &offset))
1322         return FALSE;
1323       /* We just ignore the module size.  FIXME.  */
1324       break;
1325
1326     default:
1327       /* Other block types do not have any trailing information.  */
1328       break;
1329     }
1330
1331   return TRUE;
1332 }
1333
1334 /* Parse an NN record.  */
1335
1336 static bfd_boolean
1337 parse_ieee_nn (struct ieee_info *info, const bfd_byte **pp)
1338 {
1339   const bfd_byte *nn_start;
1340   bfd_vma varindx;
1341   const char *name;
1342   unsigned long namlen;
1343
1344   nn_start = *pp;
1345
1346   if (! ieee_read_number (info, pp, &varindx)
1347       || ! ieee_read_id (info, pp, &name, &namlen))
1348     return FALSE;
1349
1350   if (varindx < 32)
1351     {
1352       ieee_error (info, nn_start, _("illegal variable index"));
1353       return FALSE;
1354     }
1355   varindx -= 32;
1356
1357   if (varindx >= info->vars.alloc)
1358     {
1359       unsigned int alloc;
1360
1361       alloc = info->vars.alloc;
1362       if (alloc == 0)
1363         alloc = 4;
1364       while (varindx >= alloc)
1365         alloc *= 2;
1366       info->vars.vars = ((struct ieee_var *)
1367                          xrealloc (info->vars.vars,
1368                                    alloc * sizeof *info->vars.vars));
1369       memset (info->vars.vars + info->vars.alloc, 0,
1370               (alloc - info->vars.alloc) * sizeof *info->vars.vars);
1371       info->vars.alloc = alloc;
1372     }
1373
1374   info->vars.vars[varindx].name = name;
1375   info->vars.vars[varindx].namlen = namlen;
1376
1377   return TRUE;
1378 }
1379
1380 /* Parse a TY record.  */
1381
1382 static bfd_boolean
1383 parse_ieee_ty (struct ieee_info *info, const bfd_byte **pp)
1384 {
1385   const bfd_byte *ty_start, *ty_var_start, *ty_code_start;
1386   bfd_vma typeindx, varindx, tc;
1387   void *dhandle;
1388   bfd_boolean tag, typdef;
1389   debug_type *arg_slots;
1390   unsigned long type_bitsize;
1391   debug_type type;
1392
1393   ty_start = *pp;
1394
1395   if (! ieee_read_number (info, pp, &typeindx))
1396     return FALSE;
1397
1398   if (typeindx < 256)
1399     {
1400       ieee_error (info, ty_start, _("illegal type index"));
1401       return FALSE;
1402     }
1403
1404   typeindx -= 256;
1405   if (! ieee_alloc_type (info, typeindx, FALSE))
1406     return FALSE;
1407
1408   if (**pp != 0xce)
1409     {
1410       ieee_error (info, *pp, _("unknown TY code"));
1411       return FALSE;
1412     }
1413   ++*pp;
1414
1415   ty_var_start = *pp;
1416
1417   if (! ieee_read_number (info, pp, &varindx))
1418     return FALSE;
1419
1420   if (varindx < 32)
1421     {
1422       ieee_error (info, ty_var_start, _("illegal variable index"));
1423       return FALSE;
1424     }
1425   varindx -= 32;
1426
1427   if (varindx >= info->vars.alloc || info->vars.vars[varindx].name == NULL)
1428     {
1429       ieee_error (info, ty_var_start, _("undefined variable in TY"));
1430       return FALSE;
1431     }
1432
1433   ty_code_start = *pp;
1434
1435   if (! ieee_read_number (info, pp, &tc))
1436     return FALSE;
1437
1438   dhandle = info->dhandle;
1439
1440   tag = FALSE;
1441   typdef = FALSE;
1442   arg_slots = NULL;
1443   type_bitsize = 0;
1444   switch (tc)
1445     {
1446     default:
1447       ieee_error (info, ty_code_start, _("unknown TY code"));
1448       return FALSE;
1449
1450     case '!':
1451       /* Unknown type, with size.  We treat it as int.  FIXME.  */
1452       {
1453         bfd_vma size;
1454
1455         if (! ieee_read_number (info, pp, &size))
1456           return FALSE;
1457         type = debug_make_int_type (dhandle, size, FALSE);
1458       }
1459       break;
1460
1461     case 'A': /* Array.  */
1462     case 'a': /* FORTRAN array in column/row order.  FIXME: Not
1463                  distinguished from normal array.  */
1464       {
1465         debug_type ele_type;
1466         bfd_vma lower, upper;
1467
1468         if (! ieee_read_type_index (info, pp, &ele_type)
1469             || ! ieee_read_number (info, pp, &lower)
1470             || ! ieee_read_number (info, pp, &upper))
1471           return FALSE;
1472         type = debug_make_array_type (dhandle, ele_type,
1473                                       ieee_builtin_type (info, ty_code_start,
1474                                                          ((unsigned int)
1475                                                           builtin_int)),
1476                                       (bfd_signed_vma) lower,
1477                                       (bfd_signed_vma) upper,
1478                                       FALSE);
1479       }
1480       break;
1481
1482     case 'E':
1483       /* Simple enumeration.  */
1484       {
1485         bfd_vma size;
1486         unsigned int alloc;
1487         const char **names;
1488         unsigned int c;
1489         bfd_signed_vma *vals;
1490         unsigned int i;
1491
1492         if (! ieee_read_number (info, pp, &size))
1493           return FALSE;
1494         /* FIXME: we ignore the enumeration size.  */
1495
1496         alloc = 10;
1497         names = (const char **) xmalloc (alloc * sizeof *names);
1498         memset (names, 0, alloc * sizeof *names);
1499         c = 0;
1500         while (1)
1501           {
1502             const char *name;
1503             unsigned long namlen;
1504             bfd_boolean present;
1505
1506             if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1507               return FALSE;
1508             if (! present)
1509               break;
1510
1511             if (c + 1 >= alloc)
1512               {
1513                 alloc += 10;
1514                 names = ((const char **)
1515                          xrealloc (names, alloc * sizeof *names));
1516               }
1517
1518             names[c] = savestring (name, namlen);
1519             if (names[c] == NULL)
1520               return FALSE;
1521             ++c;
1522           }
1523
1524         names[c] = NULL;
1525
1526         vals = (bfd_signed_vma *) xmalloc (c * sizeof *vals);
1527         for (i = 0; i < c; i++)
1528           vals[i] = i;
1529
1530         type = debug_make_enum_type (dhandle, names, vals);
1531         tag = TRUE;
1532       }
1533       break;
1534
1535     case 'G':
1536       /* Struct with bit fields.  */
1537       {
1538         bfd_vma size;
1539         unsigned int alloc;
1540         debug_field *fields;
1541         unsigned int c;
1542
1543         if (! ieee_read_number (info, pp, &size))
1544           return FALSE;
1545
1546         alloc = 10;
1547         fields = (debug_field *) xmalloc (alloc * sizeof *fields);
1548         c = 0;
1549         while (1)
1550           {
1551             const char *name;
1552             unsigned long namlen;
1553             bfd_boolean present;
1554             debug_type ftype;
1555             bfd_vma bitpos, bitsize;
1556
1557             if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1558               return FALSE;
1559             if (! present)
1560               break;
1561             if (! ieee_read_type_index (info, pp, &ftype)
1562                 || ! ieee_read_number (info, pp, &bitpos)
1563                 || ! ieee_read_number (info, pp, &bitsize))
1564               return FALSE;
1565
1566             if (c + 1 >= alloc)
1567               {
1568                 alloc += 10;
1569                 fields = ((debug_field *)
1570                           xrealloc (fields, alloc * sizeof *fields));
1571               }
1572
1573             fields[c] = debug_make_field (dhandle, savestring (name, namlen),
1574                                           ftype, bitpos, bitsize,
1575                                           DEBUG_VISIBILITY_PUBLIC);
1576             if (fields[c] == NULL)
1577               return FALSE;
1578             ++c;
1579           }
1580
1581         fields[c] = NULL;
1582
1583         type = debug_make_struct_type (dhandle, TRUE, size, fields);
1584         tag = TRUE;
1585       }
1586       break;
1587
1588     case 'N':
1589       /* Enumeration.  */
1590       {
1591         unsigned int alloc;
1592         const char **names;
1593         bfd_signed_vma *vals;
1594         unsigned int c;
1595
1596         alloc = 10;
1597         names = (const char **) xmalloc (alloc * sizeof *names);
1598         vals = (bfd_signed_vma *) xmalloc (alloc * sizeof *names);
1599         c = 0;
1600         while (1)
1601           {
1602             const char *name;
1603             unsigned long namlen;
1604             bfd_boolean present;
1605             bfd_vma val;
1606
1607             if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1608               return FALSE;
1609             if (! present)
1610               break;
1611             if (! ieee_read_number (info, pp, &val))
1612               return FALSE;
1613
1614             /* If the length of the name is zero, then the value is
1615                actually the size of the enum.  We ignore this
1616                information.  FIXME.  */
1617             if (namlen == 0)
1618               continue;
1619
1620             if (c + 1 >= alloc)
1621               {
1622                 alloc += 10;
1623                 names = ((const char **)
1624                          xrealloc (names, alloc * sizeof *names));
1625                 vals = ((bfd_signed_vma *)
1626                         xrealloc (vals, alloc * sizeof *vals));
1627               }
1628
1629             names[c] = savestring (name, namlen);
1630             if (names[c] == NULL)
1631               return FALSE;
1632             vals[c] = (bfd_signed_vma) val;
1633             ++c;
1634           }
1635
1636         names[c] = NULL;
1637
1638         type = debug_make_enum_type (dhandle, names, vals);
1639         tag = TRUE;
1640       }
1641       break;
1642
1643     case 'O': /* Small pointer.  We don't distinguish small and large
1644                  pointers.  FIXME.  */
1645     case 'P': /* Large pointer.  */
1646       {
1647         debug_type t;
1648
1649         if (! ieee_read_type_index (info, pp, &t))
1650           return FALSE;
1651         type = debug_make_pointer_type (dhandle, t);
1652       }
1653       break;
1654
1655     case 'R':
1656       /* Range.  */
1657       {
1658         bfd_vma low, high, signedp, size;
1659
1660         if (! ieee_read_number (info, pp, &low)
1661             || ! ieee_read_number (info, pp, &high)
1662             || ! ieee_read_number (info, pp, &signedp)
1663             || ! ieee_read_number (info, pp, &size))
1664           return FALSE;
1665
1666         type = debug_make_range_type (dhandle,
1667                                       debug_make_int_type (dhandle, size,
1668                                                            ! signedp),
1669                                       (bfd_signed_vma) low,
1670                                       (bfd_signed_vma) high);
1671       }
1672       break;
1673
1674     case 'S': /* Struct.  */
1675     case 'U': /* Union.  */
1676       {
1677         bfd_vma size;
1678         unsigned int alloc;
1679         debug_field *fields;
1680         unsigned int c;
1681
1682         if (! ieee_read_number (info, pp, &size))
1683           return FALSE;
1684
1685         alloc = 10;
1686         fields = (debug_field *) xmalloc (alloc * sizeof *fields);
1687         c = 0;
1688         while (1)
1689           {
1690             const char *name;
1691             unsigned long namlen;
1692             bfd_boolean present;
1693             bfd_vma tindx;
1694             bfd_vma offset;
1695             debug_type ftype;
1696             bfd_vma bitsize;
1697
1698             if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1699               return FALSE;
1700             if (! present)
1701               break;
1702             if (! ieee_read_number (info, pp, &tindx)
1703                 || ! ieee_read_number (info, pp, &offset))
1704               return FALSE;
1705
1706             if (tindx < 256)
1707               {
1708                 ftype = ieee_builtin_type (info, ty_code_start, tindx);
1709                 bitsize = 0;
1710                 offset *= 8;
1711               }
1712             else
1713               {
1714                 struct ieee_type *t;
1715
1716                 tindx -= 256;
1717                 if (! ieee_alloc_type (info, tindx, TRUE))
1718                   return FALSE;
1719                 t = info->types.types + tindx;
1720                 ftype = t->type;
1721                 bitsize = t->bitsize;
1722                 if (bitsize == 0)
1723                   offset *= 8;
1724               }
1725
1726             if (c + 1 >= alloc)
1727               {
1728                 alloc += 10;
1729                 fields = ((debug_field *)
1730                           xrealloc (fields, alloc * sizeof *fields));
1731               }
1732
1733             fields[c] = debug_make_field (dhandle, savestring (name, namlen),
1734                                           ftype, offset, bitsize,
1735                                           DEBUG_VISIBILITY_PUBLIC);
1736             if (fields[c] == NULL)
1737               return FALSE;
1738             ++c;
1739           }
1740
1741         fields[c] = NULL;
1742
1743         type = debug_make_struct_type (dhandle, tc == 'S', size, fields);
1744         tag = TRUE;
1745       }
1746       break;
1747
1748     case 'T':
1749       /* Typedef.  */
1750       if (! ieee_read_type_index (info, pp, &type))
1751         return FALSE;
1752       typdef = TRUE;
1753       break;
1754
1755     case 'X':
1756       /* Procedure.  FIXME: This is an extern declaration, which we
1757          have no way of representing.  */
1758       {
1759         bfd_vma attr;
1760         debug_type rtype;
1761         bfd_vma nargs;
1762         bfd_boolean present;
1763         struct ieee_var *pv;
1764
1765         /* FIXME: We ignore the attribute and the argument names.  */
1766
1767         if (! ieee_read_number (info, pp, &attr)
1768             || ! ieee_read_type_index (info, pp, &rtype)
1769             || ! ieee_read_number (info, pp, &nargs))
1770           return FALSE;
1771         do
1772           {
1773             const char *name;
1774             unsigned long namlen;
1775
1776             if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1777               return FALSE;
1778           }
1779         while (present);
1780
1781         pv = info->vars.vars + varindx;
1782         pv->kind = IEEE_EXTERNAL;
1783         if (pv->namlen > 0
1784             && debug_get_type_kind (dhandle, rtype) == DEBUG_KIND_POINTER)
1785           {
1786             /* Set up the return type as an indirect type pointing to
1787                the variable slot, so that we can change it to a
1788                reference later if appropriate.  */
1789             pv->pslot = (debug_type *) xmalloc (sizeof *pv->pslot);
1790             *pv->pslot = rtype;
1791             rtype = debug_make_indirect_type (dhandle, pv->pslot,
1792                                               (const char *) NULL);
1793           }
1794
1795         type = debug_make_function_type (dhandle, rtype, (debug_type *) NULL,
1796                                          FALSE);
1797       }
1798       break;
1799
1800     case 'V':
1801     case 'v':
1802       /* Void.  This is not documented, but the MRI compiler emits it.  */
1803       type = debug_make_void_type (dhandle);
1804       break;
1805
1806     case 'Z':
1807       /* Array with 0 lower bound.  */
1808       {
1809         debug_type etype;
1810         bfd_vma high;
1811
1812         if (! ieee_read_type_index (info, pp, &etype)
1813             || ! ieee_read_number (info, pp, &high))
1814           return FALSE;
1815
1816         type = debug_make_array_type (dhandle, etype,
1817                                       ieee_builtin_type (info, ty_code_start,
1818                                                          ((unsigned int)
1819                                                           builtin_int)),
1820                                       0, (bfd_signed_vma) high, FALSE);
1821       }
1822       break;
1823
1824     case 'c': /* Complex.  */
1825     case 'd': /* Double complex.  */
1826       {
1827         const char *name;
1828         unsigned long namlen;
1829
1830         /* FIXME: I don't know what the name means.  */
1831
1832         if (! ieee_read_id (info, pp, &name, &namlen))
1833           return FALSE;
1834
1835         type = debug_make_complex_type (dhandle, tc == 'c' ? 4 : 8);
1836       }
1837       break;
1838
1839     case 'f':
1840       /* Pascal file name.  FIXME.  */
1841       ieee_error (info, ty_code_start, _("Pascal file name not supported"));
1842       return FALSE;
1843
1844     case 'g':
1845       /* Bitfield type.  */
1846       {
1847         bfd_vma signedp, bitsize, dummy;
1848         const bfd_byte *hold;
1849         bfd_boolean present;
1850
1851         if (! ieee_read_number (info, pp, &signedp)
1852             || ! ieee_read_number (info, pp, &bitsize))
1853           return FALSE;
1854
1855         /* I think the documentation says that there is a type index,
1856            but some actual files do not have one.  */
1857         hold = *pp;
1858         if (! ieee_read_optional_number (info, pp, &dummy, &present))
1859           return FALSE;
1860         if (! present)
1861           {
1862             /* FIXME: This is just a guess.  */
1863             type = debug_make_int_type (dhandle, 4,
1864                                         signedp ? FALSE : TRUE);
1865           }
1866         else
1867           {
1868             *pp = hold;
1869             if (! ieee_read_type_index (info, pp, &type))
1870               return FALSE;
1871           }
1872         type_bitsize = bitsize;
1873       }
1874       break;
1875
1876     case 'n':
1877       /* Qualifier.  */
1878       {
1879         bfd_vma kind;
1880         debug_type t;
1881
1882         if (! ieee_read_number (info, pp, &kind)
1883             || ! ieee_read_type_index (info, pp, &t))
1884           return FALSE;
1885
1886         switch (kind)
1887           {
1888           default:
1889             ieee_error (info, ty_start, _("unsupported qualifier"));
1890             return FALSE;
1891
1892           case 1:
1893             type = debug_make_const_type (dhandle, t);
1894             break;
1895
1896           case 2:
1897             type = debug_make_volatile_type (dhandle, t);
1898             break;
1899           }
1900       }
1901       break;
1902
1903     case 's':
1904       /* Set.  */
1905       {
1906         bfd_vma size;
1907         debug_type etype;
1908
1909         if (! ieee_read_number (info, pp, &size)
1910             || ! ieee_read_type_index (info, pp, &etype))
1911           return FALSE;
1912
1913         /* FIXME: We ignore the size.  */
1914
1915         type = debug_make_set_type (dhandle, etype, FALSE);
1916       }
1917       break;
1918
1919     case 'x':
1920       /* Procedure with compiler dependencies.  */
1921       {
1922         struct ieee_var *pv;
1923         bfd_vma attr, frame_type, push_mask, nargs, level, father;
1924         debug_type rtype;
1925         debug_type *arg_types;
1926         bfd_boolean varargs;
1927         bfd_boolean present;
1928
1929         /* FIXME: We ignore some of this information.  */
1930
1931         pv = info->vars.vars + varindx;
1932
1933         if (! ieee_read_number (info, pp, &attr)
1934             || ! ieee_read_number (info, pp, &frame_type)
1935             || ! ieee_read_number (info, pp, &push_mask)
1936             || ! ieee_read_type_index (info, pp, &rtype)
1937             || ! ieee_read_number (info, pp, &nargs))
1938           return FALSE;
1939         if (nargs == (bfd_vma) -1)
1940           {
1941             arg_types = NULL;
1942             varargs = FALSE;
1943           }
1944         else
1945           {
1946             unsigned int i;
1947
1948             arg_types = ((debug_type *)
1949                          xmalloc ((nargs + 1) * sizeof *arg_types));
1950             for (i = 0; i < nargs; i++)
1951               if (! ieee_read_type_index (info, pp, arg_types + i))
1952                 return FALSE;
1953
1954             /* If the last type is pointer to void, this is really a
1955                varargs function.  */
1956             varargs = FALSE;
1957             if (nargs > 0)
1958               {
1959                 debug_type last;
1960
1961                 last = arg_types[nargs - 1];
1962                 if (debug_get_type_kind (dhandle, last) == DEBUG_KIND_POINTER
1963                     && (debug_get_type_kind (dhandle,
1964                                              debug_get_target_type (dhandle,
1965                                                                     last))
1966                         == DEBUG_KIND_VOID))
1967                   {
1968                     --nargs;
1969                     varargs = TRUE;
1970                   }
1971               }
1972
1973             /* If there are any pointer arguments, turn them into
1974                indirect types in case we later need to convert them to
1975                reference types.  */
1976             for (i = 0; i < nargs; i++)
1977               {
1978                 if (debug_get_type_kind (dhandle, arg_types[i])
1979                     == DEBUG_KIND_POINTER)
1980                   {
1981                     if (arg_slots == NULL)
1982                       {
1983                         arg_slots = ((debug_type *)
1984                                      xmalloc (nargs * sizeof *arg_slots));
1985                         memset (arg_slots, 0, nargs * sizeof *arg_slots);
1986                       }
1987                     arg_slots[i] = arg_types[i];
1988                     arg_types[i] =
1989                       debug_make_indirect_type (dhandle,
1990                                                 arg_slots + i,
1991                                                 (const char *) NULL);
1992                   }
1993               }
1994
1995             arg_types[nargs] = DEBUG_TYPE_NULL;
1996           }
1997         if (! ieee_read_number (info, pp, &level)
1998             || ! ieee_read_optional_number (info, pp, &father, &present))
1999           return FALSE;
2000
2001         /* We can't distinguish between a global function and a static
2002            function.  */
2003         pv->kind = IEEE_FUNCTION;
2004
2005         if (pv->namlen > 0
2006             && debug_get_type_kind (dhandle, rtype) == DEBUG_KIND_POINTER)
2007           {
2008             /* Set up the return type as an indirect type pointing to
2009                the variable slot, so that we can change it to a
2010                reference later if appropriate.  */
2011             pv->pslot = (debug_type *) xmalloc (sizeof *pv->pslot);
2012             *pv->pslot = rtype;
2013             rtype = debug_make_indirect_type (dhandle, pv->pslot,
2014                                               (const char *) NULL);
2015           }
2016
2017         type = debug_make_function_type (dhandle, rtype, arg_types, varargs);
2018       }
2019       break;
2020     }
2021
2022   /* Record the type in the table.  */
2023
2024   if (type == DEBUG_TYPE_NULL)
2025     return FALSE;
2026
2027   info->vars.vars[varindx].type = type;
2028
2029   if ((tag || typdef)
2030       && info->vars.vars[varindx].namlen > 0)
2031     {
2032       const char *name;
2033
2034       name = savestring (info->vars.vars[varindx].name,
2035                          info->vars.vars[varindx].namlen);
2036       if (typdef)
2037         type = debug_name_type (dhandle, name, type);
2038       else if (tc == 'E' || tc == 'N')
2039         type = debug_tag_type (dhandle, name, type);
2040       else
2041         {
2042           struct ieee_tag *it;
2043
2044           /* We must allocate all struct tags as indirect types, so
2045              that if we later see a definition of the tag as a C++
2046              record we can update the indirect slot and automatically
2047              change all the existing references.  */
2048           it = (struct ieee_tag *) xmalloc (sizeof *it);
2049           memset (it, 0, sizeof *it);
2050           it->next = info->tags;
2051           info->tags = it;
2052           it->name = name;
2053           it->slot = type;
2054
2055           type = debug_make_indirect_type (dhandle, &it->slot, name);
2056           type = debug_tag_type (dhandle, name, type);
2057
2058           it->type = type;
2059         }
2060       if (type == NULL)
2061         return FALSE;
2062     }
2063
2064   info->types.types[typeindx].type = type;
2065   info->types.types[typeindx].arg_slots = arg_slots;
2066   info->types.types[typeindx].bitsize = type_bitsize;
2067
2068   /* We may have already allocated type as an indirect type pointing
2069      to slot.  It does no harm to replace the indirect type with the
2070      real type.  Filling in slot as well handles the indirect types
2071      which are already hanging around.  */
2072   if (info->types.types[typeindx].pslot != NULL)
2073     *info->types.types[typeindx].pslot = type;
2074
2075   return TRUE;
2076 }
2077
2078 /* Parse an ATN record.  */
2079
2080 static bfd_boolean
2081 parse_ieee_atn (struct ieee_info *info, const bfd_byte **pp)
2082 {
2083   const bfd_byte *atn_start, *atn_code_start;
2084   bfd_vma varindx;
2085   struct ieee_var *pvar;
2086   debug_type type;
2087   bfd_vma atn_code;
2088   void *dhandle;
2089   bfd_vma v, v2, v3, v4, v5;
2090   const char *name;
2091   unsigned long namlen;
2092   char *namcopy;
2093   bfd_boolean present;
2094   int blocktype;
2095
2096   atn_start = *pp;
2097
2098   if (! ieee_read_number (info, pp, &varindx)
2099       || ! ieee_read_type_index (info, pp, &type))
2100     return FALSE;
2101
2102   atn_code_start = *pp;
2103
2104   if (! ieee_read_number (info, pp, &atn_code))
2105     return FALSE;
2106
2107   if (varindx == 0)
2108     {
2109       pvar = NULL;
2110       name = "";
2111       namlen = 0;
2112     }
2113   else if (varindx < 32)
2114     {
2115       /* The MRI compiler reportedly sometimes emits variable lifetime
2116          information for a register.  We just ignore it.  */
2117       if (atn_code == 9)
2118         return ieee_read_number (info, pp, &v);
2119
2120       ieee_error (info, atn_start, _("illegal variable index"));
2121       return FALSE;
2122     }
2123   else
2124     {
2125       varindx -= 32;
2126       if (varindx >= info->vars.alloc
2127           || info->vars.vars[varindx].name == NULL)
2128         {
2129           /* The MRI compiler or linker sometimes omits the NN record
2130              for a pmisc record.  */
2131           if (atn_code == 62)
2132             {
2133               if (varindx >= info->vars.alloc)
2134                 {
2135                   unsigned int alloc;
2136
2137                   alloc = info->vars.alloc;
2138                   if (alloc == 0)
2139                     alloc = 4;
2140                   while (varindx >= alloc)
2141                     alloc *= 2;
2142                   info->vars.vars = ((struct ieee_var *)
2143                                      xrealloc (info->vars.vars,
2144                                                (alloc
2145                                                 * sizeof *info->vars.vars)));
2146                   memset (info->vars.vars + info->vars.alloc, 0,
2147                           ((alloc - info->vars.alloc)
2148                            * sizeof *info->vars.vars));
2149                   info->vars.alloc = alloc;
2150                 }
2151
2152               pvar = info->vars.vars + varindx;
2153               pvar->name = "";
2154               pvar->namlen = 0;
2155             }
2156           else
2157             {
2158               ieee_error (info, atn_start, _("undefined variable in ATN"));
2159               return FALSE;
2160             }
2161         }
2162
2163       pvar = info->vars.vars + varindx;
2164
2165       pvar->type = type;
2166
2167       name = pvar->name;
2168       namlen = pvar->namlen;
2169     }
2170
2171   dhandle = info->dhandle;
2172
2173   /* If we are going to call debug_record_variable with a pointer
2174      type, change the type to an indirect type so that we can later
2175      change it to a reference type if we encounter a C++ pmisc 'R'
2176      record.  */
2177   if (pvar != NULL
2178       && type != DEBUG_TYPE_NULL
2179       && debug_get_type_kind (dhandle, type) == DEBUG_KIND_POINTER)
2180     {
2181       switch (atn_code)
2182         {
2183         case 1:
2184         case 2:
2185         case 3:
2186         case 5:
2187         case 8:
2188         case 10:
2189           pvar->pslot = (debug_type *) xmalloc (sizeof *pvar->pslot);
2190           *pvar->pslot = type;
2191           type = debug_make_indirect_type (dhandle, pvar->pslot,
2192                                            (const char *) NULL);
2193           pvar->type = type;
2194           break;
2195         }
2196     }
2197
2198   switch (atn_code)
2199     {
2200     default:
2201       ieee_error (info, atn_code_start, _("unknown ATN type"));
2202       return FALSE;
2203
2204     case 1:
2205       /* Automatic variable.  */
2206       if (! ieee_read_number (info, pp, &v))
2207         return FALSE;
2208       namcopy = savestring (name, namlen);
2209       if (type == NULL)
2210         type = debug_make_void_type (dhandle);
2211       if (pvar != NULL)
2212         pvar->kind = IEEE_LOCAL;
2213       return debug_record_variable (dhandle, namcopy, type, DEBUG_LOCAL, v);
2214
2215     case 2:
2216       /* Register variable.  */
2217       if (! ieee_read_number (info, pp, &v))
2218         return FALSE;
2219       namcopy = savestring (name, namlen);
2220       if (type == NULL)
2221         type = debug_make_void_type (dhandle);
2222       if (pvar != NULL)
2223         pvar->kind = IEEE_LOCAL;
2224       return debug_record_variable (dhandle, namcopy, type, DEBUG_REGISTER,
2225                                     ieee_regno_to_genreg (info->abfd, v));
2226
2227     case 3:
2228       /* Static variable.  */
2229       if (! ieee_require_asn (info, pp, &v))
2230         return FALSE;
2231       namcopy = savestring (name, namlen);
2232       if (type == NULL)
2233         type = debug_make_void_type (dhandle);
2234       if (info->blockstack.bsp <= info->blockstack.stack)
2235         blocktype = 0;
2236       else
2237         blocktype = info->blockstack.bsp[-1].kind;
2238       if (pvar != NULL)
2239         {
2240           if (blocktype == 4 || blocktype == 6)
2241             pvar->kind = IEEE_LOCAL;
2242           else
2243             pvar->kind = IEEE_STATIC;
2244         }
2245       return debug_record_variable (dhandle, namcopy, type,
2246                                     (blocktype == 4 || blocktype == 6
2247                                      ? DEBUG_LOCAL_STATIC
2248                                      : DEBUG_STATIC),
2249                                     v);
2250
2251     case 4:
2252       /* External function.  We don't currently record these.  FIXME.  */
2253       if (pvar != NULL)
2254         pvar->kind = IEEE_EXTERNAL;
2255       return TRUE;
2256
2257     case 5:
2258       /* External variable.  We don't currently record these.  FIXME.  */
2259       if (pvar != NULL)
2260         pvar->kind = IEEE_EXTERNAL;
2261       return TRUE;
2262
2263     case 7:
2264       if (! ieee_read_number (info, pp, &v)
2265           || ! ieee_read_number (info, pp, &v2)
2266           || ! ieee_read_optional_number (info, pp, &v3, &present))
2267         return FALSE;
2268       if (present)
2269         {
2270           if (! ieee_read_optional_number (info, pp, &v4, &present))
2271             return FALSE;
2272         }
2273
2274       /* We just ignore the two optional fields in v3 and v4, since
2275          they are not defined.  */
2276
2277       if (! ieee_require_asn (info, pp, &v3))
2278         return FALSE;
2279
2280       /* We have no way to record the column number.  FIXME.  */
2281
2282       return debug_record_line (dhandle, v, v3);
2283
2284     case 8:
2285       /* Global variable.  */
2286       if (! ieee_require_asn (info, pp, &v))
2287         return FALSE;
2288       namcopy = savestring (name, namlen);
2289       if (type == NULL)
2290         type = debug_make_void_type (dhandle);
2291       if (pvar != NULL)
2292         pvar->kind = IEEE_GLOBAL;
2293       return debug_record_variable (dhandle, namcopy, type, DEBUG_GLOBAL, v);
2294
2295     case 9:
2296       /* Variable lifetime information.  */
2297       if (! ieee_read_number (info, pp, &v))
2298         return FALSE;
2299
2300       /* We have no way to record this information.  FIXME.  */
2301       return TRUE;
2302
2303     case 10:
2304       /* Locked register.  The spec says that there are two required
2305          fields, but at least on occasion the MRI compiler only emits
2306          one.  */
2307       if (! ieee_read_number (info, pp, &v)
2308           || ! ieee_read_optional_number (info, pp, &v2, &present))
2309         return FALSE;
2310
2311       /* I think this means a variable that is both in a register and
2312          a frame slot.  We ignore the frame slot.  FIXME.  */
2313
2314       namcopy = savestring (name, namlen);
2315       if (type == NULL)
2316         type = debug_make_void_type (dhandle);
2317       if (pvar != NULL)
2318         pvar->kind = IEEE_LOCAL;
2319       return debug_record_variable (dhandle, namcopy, type, DEBUG_REGISTER, v);
2320
2321     case 11:
2322       /* Reserved for FORTRAN common.  */
2323       ieee_error (info, atn_code_start, _("unsupported ATN11"));
2324
2325       /* Return TRUE to keep going.  */
2326       return TRUE;
2327
2328     case 12:
2329       /* Based variable.  */
2330       v3 = 0;
2331       v4 = 0x80;
2332       v5 = 0;
2333       if (! ieee_read_number (info, pp, &v)
2334           || ! ieee_read_number (info, pp, &v2)
2335           || ! ieee_read_optional_number (info, pp, &v3, &present))
2336         return FALSE;
2337       if (present)
2338         {
2339           if (! ieee_read_optional_number (info, pp, &v4, &present))
2340             return FALSE;
2341           if (present)
2342             {
2343               if (! ieee_read_optional_number (info, pp, &v5, &present))
2344                 return FALSE;
2345             }
2346         }
2347
2348       /* We have no way to record this information.  FIXME.  */
2349
2350       ieee_error (info, atn_code_start, _("unsupported ATN12"));
2351
2352       /* Return TRUE to keep going.  */
2353       return TRUE;
2354
2355     case 16:
2356       /* Constant.  The description of this that I have is ambiguous,
2357          so I'm not going to try to implement it.  */
2358       if (! ieee_read_number (info, pp, &v)
2359           || ! ieee_read_optional_number (info, pp, &v2, &present))
2360         return FALSE;
2361       if (present)
2362         {
2363           if (! ieee_read_optional_number (info, pp, &v2, &present))
2364             return FALSE;
2365           if (present)
2366             {
2367               if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
2368                 return FALSE;
2369             }
2370         }
2371
2372       if ((ieee_record_enum_type) **pp == ieee_e2_first_byte_enum)
2373         {
2374           if (! ieee_require_asn (info, pp, &v3))
2375             return FALSE;
2376         }
2377
2378       return TRUE;
2379
2380     case 19:
2381       /* Static variable from assembler.  */
2382       v2 = 0;
2383       if (! ieee_read_number (info, pp, &v)
2384           || ! ieee_read_optional_number (info, pp, &v2, &present)
2385           || ! ieee_require_asn (info, pp, &v3))
2386         return FALSE;
2387       namcopy = savestring (name, namlen);
2388       /* We don't really handle this correctly.  FIXME.  */
2389       return debug_record_variable (dhandle, namcopy,
2390                                     debug_make_void_type (dhandle),
2391                                     v2 != 0 ? DEBUG_GLOBAL : DEBUG_STATIC,
2392                                     v3);
2393
2394     case 62:
2395       /* Procedure miscellaneous information.  */
2396     case 63:
2397       /* Variable miscellaneous information.  */
2398     case 64:
2399       /* Module miscellaneous information.  */
2400       if (! ieee_read_number (info, pp, &v)
2401           || ! ieee_read_number (info, pp, &v2)
2402           || ! ieee_read_optional_id (info, pp, &name, &namlen, &present))
2403         return FALSE;
2404
2405       if (atn_code == 62 && v == 80)
2406         {
2407           if (present)
2408             {
2409               ieee_error (info, atn_code_start,
2410                           _("unexpected string in C++ misc"));
2411               return FALSE;
2412             }
2413           return ieee_read_cxx_misc (info, pp, v2);
2414         }
2415
2416       /* We just ignore all of this stuff.  FIXME.  */
2417
2418       for (; v2 > 0; --v2)
2419         {
2420           switch ((ieee_record_enum_type) **pp)
2421             {
2422             default:
2423               ieee_error (info, *pp, _("bad misc record"));
2424               return FALSE;
2425
2426             case ieee_at_record_enum:
2427               if (! ieee_require_atn65 (info, pp, &name, &namlen))
2428                 return FALSE;
2429               break;
2430
2431             case ieee_e2_first_byte_enum:
2432               if (! ieee_require_asn (info, pp, &v3))
2433                 return FALSE;
2434               break;
2435             }
2436         }
2437
2438       return TRUE;
2439     }
2440
2441   /*NOTREACHED*/
2442 }
2443
2444 /* Handle C++ debugging miscellaneous records.  This is called for
2445    procedure miscellaneous records of type 80.  */
2446
2447 static bfd_boolean
2448 ieee_read_cxx_misc (struct ieee_info *info, const bfd_byte **pp,
2449                     unsigned long count)
2450 {
2451   const bfd_byte *start;
2452   bfd_vma category;
2453
2454   start = *pp;
2455
2456   /* Get the category of C++ misc record.  */
2457   if (! ieee_require_asn (info, pp, &category))
2458     return FALSE;
2459   --count;
2460
2461   switch (category)
2462     {
2463     default:
2464       ieee_error (info, start, _("unrecognized C++ misc record"));
2465       return FALSE;
2466
2467     case 'T':
2468       if (! ieee_read_cxx_class (info, pp, count))
2469         return FALSE;
2470       break;
2471
2472     case 'M':
2473       {
2474         bfd_vma flags;
2475         const char *name;
2476         unsigned long namlen;
2477
2478         /* The IEEE spec indicates that the 'M' record only has a
2479            flags field.  The MRI compiler also emits the name of the
2480            function.  */
2481
2482         if (! ieee_require_asn (info, pp, &flags))
2483           return FALSE;
2484         if (*pp < info->pend
2485             && (ieee_record_enum_type) **pp == ieee_at_record_enum)
2486           {
2487             if (! ieee_require_atn65 (info, pp, &name, &namlen))
2488               return FALSE;
2489           }
2490
2491         /* This is emitted for method functions, but I don't think we
2492            care very much.  It might help if it told us useful
2493            information like the class with which this function is
2494            associated, but it doesn't, so it isn't helpful.  */
2495       }
2496       break;
2497
2498     case 'B':
2499       if (! ieee_read_cxx_defaults (info, pp, count))
2500         return FALSE;
2501       break;
2502
2503     case 'z':
2504       {
2505         const char *name, *mangled, *cxx_class;
2506         unsigned long namlen, mangledlen, classlen;
2507         bfd_vma control;
2508
2509         /* Pointer to member.  */
2510
2511         if (! ieee_require_atn65 (info, pp, &name, &namlen)
2512             || ! ieee_require_atn65 (info, pp, &mangled, &mangledlen)
2513             || ! ieee_require_atn65 (info, pp, &cxx_class, &classlen)
2514             || ! ieee_require_asn (info, pp, &control))
2515           return FALSE;
2516
2517         /* FIXME: We should now track down name and change its type.  */
2518       }
2519       break;
2520
2521     case 'R':
2522       if (! ieee_read_reference (info, pp))
2523         return FALSE;
2524       break;
2525     }
2526
2527   return TRUE;
2528 }
2529
2530 /* Read a C++ class definition.  This is a pmisc type 80 record of
2531    category 'T'.  */
2532
2533 static bfd_boolean
2534 ieee_read_cxx_class (struct ieee_info *info, const bfd_byte **pp,
2535                      unsigned long count)
2536 {
2537   const bfd_byte *start;
2538   bfd_vma cxx_class;
2539   const char *tag;
2540   unsigned long taglen;
2541   struct ieee_tag *it;
2542   void *dhandle;
2543   debug_field *fields;
2544   unsigned int field_count, field_alloc;
2545   debug_baseclass *baseclasses;
2546   unsigned int baseclasses_count, baseclasses_alloc;
2547   const debug_field *structfields;
2548   struct ieee_method
2549     {
2550       const char *name;
2551       unsigned long namlen;
2552       debug_method_variant *variants;
2553       unsigned count;
2554       unsigned int alloc;
2555     } *methods;
2556   unsigned int methods_count, methods_alloc;
2557   debug_type vptrbase;
2558   bfd_boolean ownvptr;
2559   debug_method *dmethods;
2560
2561   start = *pp;
2562
2563   if (! ieee_require_asn (info, pp, &cxx_class))
2564     return FALSE;
2565   --count;
2566
2567   if (! ieee_require_atn65 (info, pp, &tag, &taglen))
2568     return FALSE;
2569   --count;
2570
2571   /* Find the C struct with this name.  */
2572   for (it = info->tags; it != NULL; it = it->next)
2573     if (it->name[0] == tag[0]
2574         && strncmp (it->name, tag, taglen) == 0
2575         && strlen (it->name) == taglen)
2576       break;
2577   if (it == NULL)
2578     {
2579       ieee_error (info, start, _("undefined C++ object"));
2580       return FALSE;
2581     }
2582
2583   dhandle = info->dhandle;
2584
2585   fields = NULL;
2586   field_count = 0;
2587   field_alloc = 0;
2588   baseclasses = NULL;
2589   baseclasses_count = 0;
2590   baseclasses_alloc = 0;
2591   methods = NULL;
2592   methods_count = 0;
2593   methods_alloc = 0;
2594   vptrbase = DEBUG_TYPE_NULL;
2595   ownvptr = FALSE;
2596
2597   structfields = debug_get_fields (dhandle, it->type);
2598
2599   while (count > 0)
2600     {
2601       bfd_vma id;
2602       const bfd_byte *spec_start;
2603
2604       spec_start = *pp;
2605
2606       if (! ieee_require_asn (info, pp, &id))
2607         return FALSE;
2608       --count;
2609
2610       switch (id)
2611         {
2612         default:
2613           ieee_error (info, spec_start, _("unrecognized C++ object spec"));
2614           return FALSE;
2615
2616         case 'b':
2617           {
2618             bfd_vma flags, cinline;
2619             const char *base, *fieldname;
2620             unsigned long baselen, fieldlen;
2621             char *basecopy;
2622             debug_type basetype;
2623             bfd_vma bitpos;
2624             bfd_boolean virtualp;
2625             enum debug_visibility visibility;
2626             debug_baseclass baseclass;
2627
2628             /* This represents a base or friend class.  */
2629
2630             if (! ieee_require_asn (info, pp, &flags)
2631                 || ! ieee_require_atn65 (info, pp, &base, &baselen)
2632                 || ! ieee_require_asn (info, pp, &cinline)
2633                 || ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen))
2634               return FALSE;
2635             count -= 4;
2636
2637             /* We have no way of recording friend information, so we
2638                just ignore it.  */
2639             if ((flags & BASEFLAGS_FRIEND) != 0)
2640               break;
2641
2642             /* I assume that either all of the members of the
2643                baseclass are included in the object, starting at the
2644                beginning of the object, or that none of them are
2645                included.  */
2646
2647             if ((fieldlen == 0) == (cinline == 0))
2648               {
2649                 ieee_error (info, start, _("unsupported C++ object type"));
2650                 return FALSE;
2651               }
2652
2653             basecopy = savestring (base, baselen);
2654             basetype = debug_find_tagged_type (dhandle, basecopy,
2655                                                DEBUG_KIND_ILLEGAL);
2656             free (basecopy);
2657             if (basetype == DEBUG_TYPE_NULL)
2658               {
2659                 ieee_error (info, start, _("C++ base class not defined"));
2660                 return FALSE;
2661               }
2662
2663             if (fieldlen == 0)
2664               bitpos = 0;
2665             else
2666               {
2667                 const debug_field *pf;
2668
2669                 if (structfields == NULL)
2670                   {
2671                     ieee_error (info, start, _("C++ object has no fields"));
2672                     return FALSE;
2673                   }
2674
2675                 for (pf = structfields; *pf != DEBUG_FIELD_NULL; pf++)
2676                   {
2677                     const char *fname;
2678
2679                     fname = debug_get_field_name (dhandle, *pf);
2680                     if (fname == NULL)
2681                       return FALSE;
2682                     if (fname[0] == fieldname[0]
2683                         && strncmp (fname, fieldname, fieldlen) == 0
2684                         && strlen (fname) == fieldlen)
2685                       break;
2686                   }
2687                 if (*pf == DEBUG_FIELD_NULL)
2688                   {
2689                     ieee_error (info, start,
2690                                 _("C++ base class not found in container"));
2691                     return FALSE;
2692                   }
2693
2694                 bitpos = debug_get_field_bitpos (dhandle, *pf);
2695               }
2696
2697             if ((flags & BASEFLAGS_VIRTUAL) != 0)
2698               virtualp = TRUE;
2699             else
2700               virtualp = FALSE;
2701             if ((flags & BASEFLAGS_PRIVATE) != 0)
2702               visibility = DEBUG_VISIBILITY_PRIVATE;
2703             else
2704               visibility = DEBUG_VISIBILITY_PUBLIC;
2705
2706             baseclass = debug_make_baseclass (dhandle, basetype, bitpos,
2707                                               virtualp, visibility);
2708             if (baseclass == DEBUG_BASECLASS_NULL)
2709               return FALSE;
2710
2711             if (baseclasses_count + 1 >= baseclasses_alloc)
2712               {
2713                 baseclasses_alloc += 10;
2714                 baseclasses = ((debug_baseclass *)
2715                                xrealloc (baseclasses,
2716                                          (baseclasses_alloc
2717                                           * sizeof *baseclasses)));
2718               }
2719
2720             baseclasses[baseclasses_count] = baseclass;
2721             ++baseclasses_count;
2722             baseclasses[baseclasses_count] = DEBUG_BASECLASS_NULL;
2723           }
2724           break;
2725
2726         case 'd':
2727           {
2728             bfd_vma flags;
2729             const char *fieldname, *mangledname;
2730             unsigned long fieldlen, mangledlen;
2731             char *fieldcopy;
2732             bfd_boolean staticp;
2733             debug_type ftype;
2734             const debug_field *pf = NULL;
2735             enum debug_visibility visibility;
2736             debug_field field;
2737
2738             /* This represents a data member.  */
2739
2740             if (! ieee_require_asn (info, pp, &flags)
2741                 || ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen)
2742                 || ! ieee_require_atn65 (info, pp, &mangledname, &mangledlen))
2743               return FALSE;
2744             count -= 3;
2745
2746             fieldcopy = savestring (fieldname, fieldlen);
2747
2748             staticp = (flags & CXXFLAGS_STATIC) != 0 ? TRUE : FALSE;
2749
2750             if (staticp)
2751               {
2752                 struct ieee_var *pv, *pvend;
2753
2754                 /* See if we can find a definition for this variable.  */
2755                 pv = info->vars.vars;
2756                 pvend = pv + info->vars.alloc;
2757                 for (; pv < pvend; pv++)
2758                   if (pv->namlen == mangledlen
2759                       && strncmp (pv->name, mangledname, mangledlen) == 0)
2760                     break;
2761                 if (pv < pvend)
2762                   ftype = pv->type;
2763                 else
2764                   {
2765                     /* This can happen if the variable is never used.  */
2766                     ftype = ieee_builtin_type (info, start,
2767                                                (unsigned int) builtin_void);
2768                   }
2769               }
2770             else
2771               {
2772                 unsigned int findx;
2773
2774                 if (structfields == NULL)
2775                   {
2776                     ieee_error (info, start, _("C++ object has no fields"));
2777                     return FALSE;
2778                   }
2779
2780                 for (pf = structfields, findx = 0;
2781                      *pf != DEBUG_FIELD_NULL;
2782                      pf++, findx++)
2783                   {
2784                     const char *fname;
2785
2786                     fname = debug_get_field_name (dhandle, *pf);
2787                     if (fname == NULL)
2788                       return FALSE;
2789                     if (fname[0] == mangledname[0]
2790                         && strncmp (fname, mangledname, mangledlen) == 0
2791                         && strlen (fname) == mangledlen)
2792                       break;
2793                   }
2794                 if (*pf == DEBUG_FIELD_NULL)
2795                   {
2796                     ieee_error (info, start,
2797                                 _("C++ data member not found in container"));
2798                     return FALSE;
2799                   }
2800
2801                 ftype = debug_get_field_type (dhandle, *pf);
2802
2803                 if (debug_get_type_kind (dhandle, ftype) == DEBUG_KIND_POINTER)
2804                   {
2805                     /* We might need to convert this field into a
2806                        reference type later on, so make it an indirect
2807                        type.  */
2808                     if (it->fslots == NULL)
2809                       {
2810                         unsigned int fcnt;
2811                         const debug_field *pfcnt;
2812
2813                         fcnt = 0;
2814                         for (pfcnt = structfields;
2815                              *pfcnt != DEBUG_FIELD_NULL;
2816                              pfcnt++)
2817                           ++fcnt;
2818                         it->fslots = ((debug_type *)
2819                                       xmalloc (fcnt * sizeof *it->fslots));
2820                         memset (it->fslots, 0,
2821                                 fcnt * sizeof *it->fslots);
2822                       }
2823
2824                     if (ftype == DEBUG_TYPE_NULL)
2825                       return FALSE;
2826                     it->fslots[findx] = ftype;
2827                     ftype = debug_make_indirect_type (dhandle,
2828                                                       it->fslots + findx,
2829                                                       (const char *) NULL);
2830                   }
2831               }
2832             if (ftype == DEBUG_TYPE_NULL)
2833               return FALSE;
2834
2835             switch (flags & CXXFLAGS_VISIBILITY)
2836               {
2837               default:
2838                 ieee_error (info, start, _("unknown C++ visibility"));
2839                 return FALSE;
2840
2841               case CXXFLAGS_VISIBILITY_PUBLIC:
2842                 visibility = DEBUG_VISIBILITY_PUBLIC;
2843                 break;
2844
2845               case CXXFLAGS_VISIBILITY_PRIVATE:
2846                 visibility = DEBUG_VISIBILITY_PRIVATE;
2847                 break;
2848
2849               case CXXFLAGS_VISIBILITY_PROTECTED:
2850                 visibility = DEBUG_VISIBILITY_PROTECTED;
2851                 break;
2852               }
2853
2854             if (staticp)
2855               {
2856                 char *mangledcopy;
2857
2858                 mangledcopy = savestring (mangledname, mangledlen);
2859
2860                 field = debug_make_static_member (dhandle, fieldcopy,
2861                                                   ftype, mangledcopy,
2862                                                   visibility);
2863               }
2864             else
2865               {
2866                 bfd_vma bitpos, bitsize;
2867
2868                 bitpos = debug_get_field_bitpos (dhandle, *pf);
2869                 bitsize = debug_get_field_bitsize (dhandle, *pf);
2870                 if (bitpos == (bfd_vma) -1 || bitsize == (bfd_vma) -1)
2871                   {
2872                     ieee_error (info, start, _("bad C++ field bit pos or size"));
2873                     return FALSE;
2874                   }
2875                 field = debug_make_field (dhandle, fieldcopy, ftype, bitpos,
2876                                           bitsize, visibility);
2877               }
2878
2879             if (field == DEBUG_FIELD_NULL)
2880               return FALSE;
2881
2882             if (field_count + 1 >= field_alloc)
2883               {
2884                 field_alloc += 10;
2885                 fields = ((debug_field *)
2886                           xrealloc (fields, field_alloc * sizeof *fields));
2887               }
2888
2889             fields[field_count] = field;
2890             ++field_count;
2891             fields[field_count] = DEBUG_FIELD_NULL;
2892           }
2893           break;
2894
2895         case 'm':
2896         case 'v':
2897           {
2898             bfd_vma flags, voffset, control;
2899             const char *name, *mangled;
2900             unsigned long namlen, mangledlen;
2901             struct ieee_var *pv, *pvend;
2902             debug_type type;
2903             enum debug_visibility visibility;
2904             bfd_boolean constp, volatilep;
2905             char *mangledcopy;
2906             debug_method_variant mv;
2907             struct ieee_method *meth;
2908             unsigned int im;
2909
2910             if (! ieee_require_asn (info, pp, &flags)
2911                 || ! ieee_require_atn65 (info, pp, &name, &namlen)
2912                 || ! ieee_require_atn65 (info, pp, &mangled, &mangledlen))
2913               return FALSE;
2914             count -= 3;
2915             if (id != 'v')
2916               voffset = 0;
2917             else
2918               {
2919                 if (! ieee_require_asn (info, pp, &voffset))
2920                   return FALSE;
2921                 --count;
2922               }
2923             if (! ieee_require_asn (info, pp, &control))
2924               return FALSE;
2925             --count;
2926
2927             /* We just ignore the control information.  */
2928
2929             /* We have no way to represent friend information, so we
2930                just ignore it.  */
2931             if ((flags & CXXFLAGS_FRIEND) != 0)
2932               break;
2933
2934             /* We should already have seen a type for the function.  */
2935             pv = info->vars.vars;
2936             pvend = pv + info->vars.alloc;
2937             for (; pv < pvend; pv++)
2938               if (pv->namlen == mangledlen
2939                   && strncmp (pv->name, mangled, mangledlen) == 0)
2940                 break;
2941
2942             if (pv >= pvend)
2943               {
2944                 /* We won't have type information for this function if
2945                    it is not included in this file.  We don't try to
2946                    handle this case.  FIXME.  */
2947                 type = (debug_make_function_type
2948                         (dhandle,
2949                          ieee_builtin_type (info, start,
2950                                             (unsigned int) builtin_void),
2951                          (debug_type *) NULL,
2952                          FALSE));
2953               }
2954             else
2955               {
2956                 debug_type return_type;
2957                 const debug_type *arg_types;
2958                 bfd_boolean varargs;
2959
2960                 if (debug_get_type_kind (dhandle, pv->type)
2961                     != DEBUG_KIND_FUNCTION)
2962                   {
2963                     ieee_error (info, start,
2964                                 _("bad type for C++ method function"));
2965                     return FALSE;
2966                   }
2967
2968                 return_type = debug_get_return_type (dhandle, pv->type);
2969                 arg_types = debug_get_parameter_types (dhandle, pv->type,
2970                                                        &varargs);
2971                 if (return_type == DEBUG_TYPE_NULL || arg_types == NULL)
2972                   {
2973                     ieee_error (info, start,
2974                                 _("no type information for C++ method function"));
2975                     return FALSE;
2976                   }
2977
2978                 type = debug_make_method_type (dhandle, return_type, it->type,
2979                                                (debug_type *) arg_types,
2980                                                varargs);
2981               }
2982             if (type == DEBUG_TYPE_NULL)
2983               return FALSE;
2984
2985             switch (flags & CXXFLAGS_VISIBILITY)
2986               {
2987               default:
2988                 ieee_error (info, start, _("unknown C++ visibility"));
2989                 return FALSE;
2990
2991               case CXXFLAGS_VISIBILITY_PUBLIC:
2992                 visibility = DEBUG_VISIBILITY_PUBLIC;
2993                 break;
2994
2995               case CXXFLAGS_VISIBILITY_PRIVATE:
2996                 visibility = DEBUG_VISIBILITY_PRIVATE;
2997                 break;
2998
2999               case CXXFLAGS_VISIBILITY_PROTECTED:
3000                 visibility = DEBUG_VISIBILITY_PROTECTED;
3001                 break;
3002               }
3003
3004             constp = (flags & CXXFLAGS_CONST) != 0 ? TRUE : FALSE;
3005             volatilep = (flags & CXXFLAGS_VOLATILE) != 0 ? TRUE : FALSE;
3006
3007             mangledcopy = savestring (mangled, mangledlen);
3008
3009             if ((flags & CXXFLAGS_STATIC) != 0)
3010               {
3011                 if (id == 'v')
3012                   {
3013                     ieee_error (info, start, _("C++ static virtual method"));
3014                     return FALSE;
3015                   }
3016                 mv = debug_make_static_method_variant (dhandle, mangledcopy,
3017                                                        type, visibility,
3018                                                        constp, volatilep);
3019               }
3020             else
3021               {
3022                 debug_type vcontext;
3023
3024                 if (id != 'v')
3025                   vcontext = DEBUG_TYPE_NULL;
3026                 else
3027                   {
3028                     /* FIXME: How can we calculate this correctly?  */
3029                     vcontext = it->type;
3030                   }
3031                 mv = debug_make_method_variant (dhandle, mangledcopy, type,
3032                                                 visibility, constp,
3033                                                 volatilep, voffset,
3034                                                 vcontext);
3035               }
3036             if (mv == DEBUG_METHOD_VARIANT_NULL)
3037               return FALSE;
3038
3039             for (meth = methods, im = 0; im < methods_count; meth++, im++)
3040               if (meth->namlen == namlen
3041                   && strncmp (meth->name, name, namlen) == 0)
3042                 break;
3043             if (im >= methods_count)
3044               {
3045                 if (methods_count >= methods_alloc)
3046                   {
3047                     methods_alloc += 10;
3048                     methods = ((struct ieee_method *)
3049                                xrealloc (methods,
3050                                          methods_alloc * sizeof *methods));
3051                   }
3052                 methods[methods_count].name = name;
3053                 methods[methods_count].namlen = namlen;
3054                 methods[methods_count].variants = NULL;
3055                 methods[methods_count].count = 0;
3056                 methods[methods_count].alloc = 0;
3057                 meth = methods + methods_count;
3058                 ++methods_count;
3059               }
3060
3061             if (meth->count + 1 >= meth->alloc)
3062               {
3063                 meth->alloc += 10;
3064                 meth->variants = ((debug_method_variant *)
3065                                   xrealloc (meth->variants,
3066                                             (meth->alloc
3067                                              * sizeof *meth->variants)));
3068               }
3069
3070             meth->variants[meth->count] = mv;
3071             ++meth->count;
3072             meth->variants[meth->count] = DEBUG_METHOD_VARIANT_NULL;
3073           }
3074           break;
3075
3076         case 'o':
3077           {
3078             bfd_vma spec;
3079
3080             /* We have no way to store this information, so we just
3081                ignore it.  */
3082             if (! ieee_require_asn (info, pp, &spec))
3083               return FALSE;
3084             --count;
3085             if ((spec & 4) != 0)
3086               {
3087                 const char *filename;
3088                 unsigned long filenamlen;
3089                 bfd_vma lineno;
3090
3091                 if (! ieee_require_atn65 (info, pp, &filename, &filenamlen)
3092                     || ! ieee_require_asn (info, pp, &lineno))
3093                   return FALSE;
3094                 count -= 2;
3095               }
3096             else if ((spec & 8) != 0)
3097               {
3098                 const char *mangled;
3099                 unsigned long mangledlen;
3100
3101                 if (! ieee_require_atn65 (info, pp, &mangled, &mangledlen))
3102                   return FALSE;
3103                 --count;
3104               }
3105             else
3106               {
3107                 ieee_error (info, start,
3108                             _("unrecognized C++ object overhead spec"));
3109                 return FALSE;
3110               }
3111           }
3112           break;
3113
3114         case 'z':
3115           {
3116             const char *vname, *base;
3117             unsigned long vnamelen, baselen;
3118             bfd_vma vsize, control;
3119
3120             /* A virtual table pointer.  */
3121
3122             if (! ieee_require_atn65 (info, pp, &vname, &vnamelen)
3123                 || ! ieee_require_asn (info, pp, &vsize)
3124                 || ! ieee_require_atn65 (info, pp, &base, &baselen)
3125                 || ! ieee_require_asn (info, pp, &control))
3126               return FALSE;
3127             count -= 4;
3128
3129             /* We just ignore the control number.  We don't care what
3130                the virtual table name is.  We have no way to store the
3131                virtual table size, and I don't think we care anyhow.  */
3132
3133             /* FIXME: We can't handle multiple virtual table pointers.  */
3134
3135             if (baselen == 0)
3136               ownvptr = TRUE;
3137             else
3138               {
3139                 char *basecopy;
3140
3141                 basecopy = savestring (base, baselen);
3142                 vptrbase = debug_find_tagged_type (dhandle, basecopy,
3143                                                    DEBUG_KIND_ILLEGAL);
3144                 free (basecopy);
3145                 if (vptrbase == DEBUG_TYPE_NULL)
3146                   {
3147                     ieee_error (info, start, _("undefined C++ vtable"));
3148                     return FALSE;
3149                   }
3150               }
3151           }
3152           break;
3153         }
3154     }
3155
3156   /* Now that we have seen all the method variants, we can call
3157      debug_make_method for each one.  */
3158
3159   if (methods_count == 0)
3160     dmethods = NULL;
3161   else
3162     {
3163       unsigned int i;
3164
3165       dmethods = ((debug_method *)
3166                   xmalloc ((methods_count + 1) * sizeof *dmethods));
3167       for (i = 0; i < methods_count; i++)
3168         {
3169           char *namcopy;
3170
3171           namcopy = savestring (methods[i].name, methods[i].namlen);
3172           dmethods[i] = debug_make_method (dhandle, namcopy,
3173                                            methods[i].variants);
3174           if (dmethods[i] == DEBUG_METHOD_NULL)
3175             return FALSE;
3176         }
3177       dmethods[i] = DEBUG_METHOD_NULL;
3178       free (methods);
3179     }
3180
3181   /* The struct type was created as an indirect type pointing at
3182      it->slot.  We update it->slot to automatically update all
3183      references to this struct.  */
3184   it->slot = debug_make_object_type (dhandle,
3185                                      cxx_class != 'u',
3186                                      debug_get_type_size (dhandle,
3187                                                           it->slot),
3188                                      fields, baseclasses, dmethods,
3189                                      vptrbase, ownvptr);
3190   if (it->slot == DEBUG_TYPE_NULL)
3191     return FALSE;
3192
3193   return TRUE;
3194 }
3195
3196 /* Read C++ default argument value and reference type information.  */
3197
3198 static bfd_boolean
3199 ieee_read_cxx_defaults (struct ieee_info *info, const bfd_byte **pp,
3200                         unsigned long count)
3201 {
3202   const bfd_byte *start;
3203   const char *fnname;
3204   unsigned long fnlen;
3205   bfd_vma defcount;
3206
3207   start = *pp;
3208
3209   /* Giving the function name before the argument count is an addendum
3210      to the spec.  The function name is demangled, though, so this
3211      record must always refer to the current function.  */
3212
3213   if (info->blockstack.bsp <= info->blockstack.stack
3214       || info->blockstack.bsp[-1].fnindx == (unsigned int) -1)
3215     {
3216       ieee_error (info, start, _("C++ default values not in a function"));
3217       return FALSE;
3218     }
3219
3220   if (! ieee_require_atn65 (info, pp, &fnname, &fnlen)
3221       || ! ieee_require_asn (info, pp, &defcount))
3222     return FALSE;
3223   count -= 2;
3224
3225   while (defcount-- > 0)
3226     {
3227       bfd_vma type, val;
3228       const char *strval;
3229       unsigned long strvallen;
3230
3231       if (! ieee_require_asn (info, pp, &type))
3232         return FALSE;
3233       --count;
3234
3235       switch (type)
3236         {
3237         case 0:
3238         case 4:
3239           break;
3240
3241         case 1:
3242         case 2:
3243           if (! ieee_require_asn (info, pp, &val))
3244             return FALSE;
3245           --count;
3246           break;
3247
3248         case 3:
3249         case 7:
3250           if (! ieee_require_atn65 (info, pp, &strval, &strvallen))
3251             return FALSE;
3252           --count;
3253           break;
3254
3255         default:
3256           ieee_error (info, start, _("unrecognized C++ default type"));
3257           return FALSE;
3258         }
3259
3260       /* We have no way to record the default argument values, so we
3261          just ignore them.  FIXME.  */
3262     }
3263
3264   /* Any remaining arguments are indices of parameters that are really
3265      reference type.  */
3266   if (count > 0)
3267     {
3268       void *dhandle;
3269       debug_type *arg_slots;
3270
3271       dhandle = info->dhandle;
3272       arg_slots = info->types.types[info->blockstack.bsp[-1].fnindx].arg_slots;
3273       while (count-- > 0)
3274         {
3275           bfd_vma indx;
3276           debug_type target;
3277
3278           if (! ieee_require_asn (info, pp, &indx))
3279             return FALSE;
3280           /* The index is 1 based.  */
3281           --indx;
3282           if (arg_slots == NULL
3283               || arg_slots[indx] == DEBUG_TYPE_NULL
3284               || (debug_get_type_kind (dhandle, arg_slots[indx])
3285                   != DEBUG_KIND_POINTER))
3286             {
3287               ieee_error (info, start, _("reference parameter is not a pointer"));
3288               return FALSE;
3289             }
3290
3291           target = debug_get_target_type (dhandle, arg_slots[indx]);
3292           arg_slots[indx] = debug_make_reference_type (dhandle, target);
3293           if (arg_slots[indx] == DEBUG_TYPE_NULL)
3294             return FALSE;
3295         }
3296     }
3297
3298   return TRUE;
3299 }
3300
3301 /* Read a C++ reference definition.  */
3302
3303 static bfd_boolean
3304 ieee_read_reference (struct ieee_info *info, const bfd_byte **pp)
3305 {
3306   const bfd_byte *start;
3307   bfd_vma flags;
3308   const char *cxx_class, *name;
3309   unsigned long classlen, namlen;
3310   debug_type *pslot;
3311   debug_type target;
3312
3313   start = *pp;
3314
3315   if (! ieee_require_asn (info, pp, &flags))
3316     return FALSE;
3317
3318   /* Giving the class name before the member name is in an addendum to
3319      the spec.  */
3320   if (flags == 3)
3321     {
3322       if (! ieee_require_atn65 (info, pp, &cxx_class, &classlen))
3323         return FALSE;
3324     }
3325
3326   if (! ieee_require_atn65 (info, pp, &name, &namlen))
3327     return FALSE;
3328
3329   pslot = NULL;
3330   if (flags != 3)
3331     {
3332       int pass;
3333
3334       /* We search from the last variable indices to the first in
3335          hopes of finding local variables correctly.  We search the
3336          local variables on the first pass, and the global variables
3337          on the second.  FIXME: This probably won't work in all cases.
3338          On the other hand, I don't know what will.  */
3339       for (pass = 0; pass < 2; pass++)
3340         {
3341           struct ieee_vars *vars;
3342           int i;
3343           struct ieee_var *pv = NULL;
3344
3345           if (pass == 0)
3346             vars = &info->vars;
3347           else
3348             {
3349               vars = info->global_vars;
3350               if (vars == NULL)
3351                 break;
3352             }
3353
3354           for (i = (int) vars->alloc - 1; i >= 0; i--)
3355             {
3356               bfd_boolean found;
3357
3358               pv = vars->vars + i;
3359
3360               if (pv->pslot == NULL
3361                   || pv->namlen != namlen
3362                   || strncmp (pv->name, name, namlen) != 0)
3363                 continue;
3364
3365               found = FALSE;
3366               switch (flags)
3367                 {
3368                 default:
3369                   ieee_error (info, start,
3370                               _("unrecognized C++ reference type"));
3371                   return FALSE;
3372
3373                 case 0:
3374                   /* Global variable or function.  */
3375                   if (pv->kind == IEEE_GLOBAL
3376                       || pv->kind == IEEE_EXTERNAL
3377                       || pv->kind == IEEE_FUNCTION)
3378                     found = TRUE;
3379                   break;
3380
3381                 case 1:
3382                   /* Global static variable or function.  */
3383                   if (pv->kind == IEEE_STATIC
3384                       || pv->kind == IEEE_FUNCTION)
3385                     found = TRUE;
3386                   break;
3387
3388                 case 2:
3389                   /* Local variable.  */
3390                   if (pv->kind == IEEE_LOCAL)
3391                     found = TRUE;
3392                   break;
3393                 }
3394
3395               if (found)
3396                 break;
3397             }
3398
3399           if (i >= 0)
3400             {
3401               pslot = pv->pslot;
3402               break;
3403             }
3404         }
3405     }
3406   else
3407     {
3408       struct ieee_tag *it;
3409
3410       for (it = info->tags; it != NULL; it = it->next)
3411         {
3412           if (it->name[0] == cxx_class[0]
3413               && strncmp (it->name, cxx_class, classlen) == 0
3414               && strlen (it->name) == classlen)
3415             {
3416               if (it->fslots != NULL)
3417                 {
3418                   const debug_field *pf;
3419                   unsigned int findx;
3420
3421                   pf = debug_get_fields (info->dhandle, it->type);
3422                   if (pf == NULL)
3423                     {
3424                       ieee_error (info, start,
3425                                   "C++ reference in class with no fields");
3426                       return FALSE;
3427                     }
3428
3429                   for (findx = 0; *pf != DEBUG_FIELD_NULL; pf++, findx++)
3430                     {
3431                       const char *fname;
3432
3433                       fname = debug_get_field_name (info->dhandle, *pf);
3434                       if (fname == NULL)
3435                         return FALSE;
3436                       if (strncmp (fname, name, namlen) == 0
3437                           && strlen (fname) == namlen)
3438                         {
3439                           pslot = it->fslots + findx;
3440                           break;
3441                         }
3442                     }
3443                 }
3444
3445               break;
3446             }
3447         }
3448     }
3449
3450   if (pslot == NULL)
3451     {
3452       ieee_error (info, start, _("C++ reference not found"));
3453       return FALSE;
3454     }
3455
3456   /* We allocated the type of the object as an indirect type pointing
3457      to *pslot, which we can now update to be a reference type.  */
3458   if (debug_get_type_kind (info->dhandle, *pslot) != DEBUG_KIND_POINTER)
3459     {
3460       ieee_error (info, start, _("C++ reference is not pointer"));
3461       return FALSE;
3462     }
3463
3464   target = debug_get_target_type (info->dhandle, *pslot);
3465   *pslot = debug_make_reference_type (info->dhandle, target);
3466   if (*pslot == DEBUG_TYPE_NULL)
3467     return FALSE;
3468
3469   return TRUE;
3470 }
3471
3472 /* Require an ASN record.  */
3473
3474 static bfd_boolean
3475 ieee_require_asn (struct ieee_info *info, const bfd_byte **pp, bfd_vma *pv)
3476 {
3477   const bfd_byte *start;
3478   ieee_record_enum_type c;
3479   bfd_vma varindx;
3480
3481   start = *pp;
3482
3483   c = (ieee_record_enum_type) **pp;
3484   if (c != ieee_e2_first_byte_enum)
3485     {
3486       ieee_error (info, start, _("missing required ASN"));
3487       return FALSE;
3488     }
3489   ++*pp;
3490
3491   c = (ieee_record_enum_type) (((unsigned int) c << 8) | **pp);
3492   if (c != ieee_asn_record_enum)
3493     {
3494       ieee_error (info, start, _("missing required ASN"));
3495       return FALSE;
3496     }
3497   ++*pp;
3498
3499   /* Just ignore the variable index.  */
3500   if (! ieee_read_number (info, pp, &varindx))
3501     return FALSE;
3502
3503   return ieee_read_expression (info, pp, pv);
3504 }
3505
3506 /* Require an ATN65 record.  */
3507
3508 static bfd_boolean
3509 ieee_require_atn65 (struct ieee_info *info, const bfd_byte **pp,
3510                     const char **pname, unsigned long *pnamlen)
3511 {
3512   const bfd_byte *start;
3513   ieee_record_enum_type c;
3514   bfd_vma name_indx, type_indx, atn_code;
3515
3516   start = *pp;
3517
3518   c = (ieee_record_enum_type) **pp;
3519   if (c != ieee_at_record_enum)
3520     {
3521       ieee_error (info, start, _("missing required ATN65"));
3522       return FALSE;
3523     }
3524   ++*pp;
3525
3526   c = (ieee_record_enum_type) (((unsigned int) c << 8) | **pp);
3527   if (c != ieee_atn_record_enum)
3528     {
3529       ieee_error (info, start, _("missing required ATN65"));
3530       return FALSE;
3531     }
3532   ++*pp;
3533
3534   if (! ieee_read_number (info, pp, &name_indx)
3535       || ! ieee_read_number (info, pp, &type_indx)
3536       || ! ieee_read_number (info, pp, &atn_code))
3537     return FALSE;
3538
3539   /* Just ignore name_indx.  */
3540
3541   if (type_indx != 0 || atn_code != 65)
3542     {
3543       ieee_error (info, start, _("bad ATN65 record"));
3544       return FALSE;
3545     }
3546
3547   return ieee_read_id (info, pp, pname, pnamlen);
3548 }
3549 \f
3550 /* Convert a register number in IEEE debugging information into a
3551    generic register number.  */
3552
3553 static int
3554 ieee_regno_to_genreg (bfd *abfd, int r)
3555 {
3556   switch (bfd_get_arch (abfd))
3557     {
3558     case bfd_arch_m68k:
3559       /* For some reasons stabs adds 2 to the floating point register
3560          numbers.  */
3561       if (r >= 16)
3562         r += 2;
3563       break;
3564
3565     case bfd_arch_i960:
3566       /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and
3567          32 to 35 for fp0 to fp3.  */
3568       --r;
3569       break;
3570
3571     default:
3572       break;
3573     }
3574
3575   return r;
3576 }
3577
3578 /* Convert a generic register number to an IEEE specific one.  */
3579
3580 static int
3581 ieee_genreg_to_regno (bfd *abfd, int r)
3582 {
3583   switch (bfd_get_arch (abfd))
3584     {
3585     case bfd_arch_m68k:
3586       /* For some reason stabs add 2 to the floating point register
3587          numbers.  */
3588       if (r >= 18)
3589         r -= 2;
3590       break;
3591
3592     case bfd_arch_i960:
3593       /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and
3594          32 to 35 for fp0 to fp3.  */
3595       ++r;
3596       break;
3597
3598     default:
3599       break;
3600     }
3601
3602   return r;
3603 }
3604 \f
3605 /* These routines build IEEE debugging information out of the generic
3606    debugging information.  */
3607
3608 /* We build the IEEE debugging information byte by byte.  Rather than
3609    waste time copying data around, we use a linked list of buffers to
3610    hold the data.  */
3611
3612 #define IEEE_BUFSIZE (490)
3613
3614 struct ieee_buf
3615 {
3616   /* Next buffer.  */
3617   struct ieee_buf *next;
3618   /* Number of data bytes in this buffer.  */
3619   unsigned int c;
3620   /* Bytes.  */
3621   bfd_byte buf[IEEE_BUFSIZE];
3622 };
3623
3624 /* A list of buffers.  */
3625
3626 struct ieee_buflist
3627 {
3628   /* Head of list.  */
3629   struct ieee_buf *head;
3630   /* Tail--last buffer on list.  */
3631   struct ieee_buf *tail;
3632 };
3633
3634 /* In order to generate the BB11 blocks required by the HP emulator,
3635    we keep track of ranges of addresses which correspond to a given
3636    compilation unit.  */
3637
3638 struct ieee_range
3639 {
3640   /* Next range.  */
3641   struct ieee_range *next;
3642   /* Low address.  */
3643   bfd_vma low;
3644   /* High address.  */
3645   bfd_vma high;
3646 };
3647
3648 /* This structure holds information for a class on the type stack.  */
3649
3650 struct ieee_type_class
3651 {
3652   /* The name index in the debugging information.  */
3653   unsigned int indx;
3654   /* The pmisc records for the class.  */
3655   struct ieee_buflist pmiscbuf;
3656   /* The number of pmisc records.  */
3657   unsigned int pmisccount;
3658   /* The name of the class holding the virtual table, if not this
3659      class.  */
3660   const char *vclass;
3661   /* Whether this class holds its own virtual table.  */
3662   bfd_boolean ownvptr;
3663   /* The largest virtual table offset seen so far.  */
3664   bfd_vma voffset;
3665   /* The current method.  */
3666   const char *method;
3667   /* Additional pmisc records used to record fields of reference type.  */
3668   struct ieee_buflist refs;
3669 };
3670
3671 /* This is how we store types for the writing routines.  Most types
3672    are simply represented by a type index.  */
3673
3674 struct ieee_write_type
3675 {
3676   /* Type index.  */
3677   unsigned int indx;
3678   /* The size of the type, if known.  */
3679   unsigned int size;
3680   /* The name of the type, if any.  */
3681   const char *name;
3682   /* If this is a function or method type, we build the type here, and
3683      only add it to the output buffers if we need it.  */
3684   struct ieee_buflist fndef;
3685   /* If this is a struct, this is where the struct definition is
3686      built.  */
3687   struct ieee_buflist strdef;
3688   /* If this is a class, this is where the class information is built.  */
3689   struct ieee_type_class *classdef;
3690   /* Whether the type is unsigned.  */
3691   unsigned int unsignedp : 1;
3692   /* Whether this is a reference type.  */
3693   unsigned int referencep : 1;
3694   /* Whether this is in the local type block.  */
3695   unsigned int localp : 1;
3696   /* Whether this is a duplicate struct definition which we are
3697      ignoring.  */
3698   unsigned int ignorep : 1;
3699 };
3700
3701 /* This is the type stack used by the debug writing routines.  FIXME:
3702    We could generate more efficient output if we remembered when we
3703    have output a particular type before.  */
3704
3705 struct ieee_type_stack
3706 {
3707   /* Next entry on stack.  */
3708   struct ieee_type_stack *next;
3709   /* Type information.  */
3710   struct ieee_write_type type;
3711 };
3712
3713 /* This is a list of associations between a name and some types.
3714    These are used for typedefs and tags.  */
3715
3716 struct ieee_name_type
3717 {
3718   /* Next type for this name.  */
3719   struct ieee_name_type *next;
3720   /* ID number.  For a typedef, this is the index of the type to which
3721      this name is typedefed.  */
3722   unsigned int id;
3723   /* Type.  */
3724   struct ieee_write_type type;
3725   /* If this is a tag which has not yet been defined, this is the
3726      kind.  If the tag has been defined, this is DEBUG_KIND_ILLEGAL.  */
3727   enum debug_type_kind kind;
3728 };
3729
3730 /* We use a hash table to associate names and types.  */
3731
3732 struct ieee_name_type_hash_table
3733 {
3734   struct bfd_hash_table root;
3735 };
3736
3737 struct ieee_name_type_hash_entry
3738 {
3739   struct bfd_hash_entry root;
3740   /* Information for this name.  */
3741   struct ieee_name_type *types;
3742 };
3743
3744 /* This is a list of enums.  */
3745
3746 struct ieee_defined_enum
3747 {
3748   /* Next enum.  */
3749   struct ieee_defined_enum *next;
3750   /* Type index.  */
3751   unsigned int indx;
3752   /* Whether this enum has been defined.  */
3753   bfd_boolean defined;
3754   /* Tag.  */
3755   const char *tag;
3756   /* Names.  */
3757   const char **names;
3758   /* Values.  */
3759   bfd_signed_vma *vals;
3760 };
3761
3762 /* We keep a list of modified versions of types, so that we don't
3763    output them more than once.  */
3764
3765 struct ieee_modified_type
3766 {
3767   /* Pointer to this type.  */
3768   unsigned int pointer;
3769   /* Function with unknown arguments returning this type.  */
3770   unsigned int function;
3771   /* Const version of this type.  */
3772   unsigned int const_qualified;
3773   /* Volatile version of this type.  */
3774   unsigned int volatile_qualified;
3775   /* List of arrays of this type of various bounds.  */
3776   struct ieee_modified_array_type *arrays;
3777 };
3778
3779 /* A list of arrays bounds.  */
3780
3781 struct ieee_modified_array_type
3782 {
3783   /* Next array bounds.  */
3784   struct ieee_modified_array_type *next;
3785   /* Type index with these bounds.  */
3786   unsigned int indx;
3787   /* Low bound.  */
3788   bfd_signed_vma low;
3789   /* High bound.  */
3790   bfd_signed_vma high;
3791 };
3792
3793 /* This is a list of pending function parameter information.  We don't
3794    output them until we see the first block.  */
3795
3796 struct ieee_pending_parm
3797 {
3798   /* Next pending parameter.  */
3799   struct ieee_pending_parm *next;
3800   /* Name.  */
3801   const char *name;
3802   /* Type index.  */
3803   unsigned int type;
3804   /* Whether the type is a reference.  */
3805   bfd_boolean referencep;
3806   /* Kind.  */
3807   enum debug_parm_kind kind;
3808   /* Value.  */
3809   bfd_vma val;
3810 };
3811
3812 /* This is the handle passed down by debug_write.  */
3813
3814 struct ieee_handle
3815 {
3816   /* BFD we are writing to.  */
3817   bfd *abfd;
3818   /* Whether we got an error in a subroutine called via traverse or
3819      map_over_sections.  */
3820   bfd_boolean error;
3821   /* Current data buffer list.  */
3822   struct ieee_buflist *current;
3823   /* Current data buffer.  */
3824   struct ieee_buf *curbuf;
3825   /* Filename of current compilation unit.  */
3826   const char *filename;
3827   /* Module name of current compilation unit.  */
3828   const char *modname;
3829   /* List of buffer for global types.  */
3830   struct ieee_buflist global_types;
3831   /* List of finished data buffers.  */
3832   struct ieee_buflist data;
3833   /* List of buffers for typedefs in the current compilation unit.  */
3834   struct ieee_buflist types;
3835   /* List of buffers for variables and functions in the current
3836      compilation unit.  */
3837   struct ieee_buflist vars;
3838   /* List of buffers for C++ class definitions in the current
3839      compilation unit.  */
3840   struct ieee_buflist cxx;
3841   /* List of buffers for line numbers in the current compilation unit.  */
3842   struct ieee_buflist linenos;
3843   /* Ranges for the current compilation unit.  */
3844   struct ieee_range *ranges;
3845   /* Ranges for all debugging information.  */
3846   struct ieee_range *global_ranges;
3847   /* Nested pending ranges.  */
3848   struct ieee_range *pending_ranges;
3849   /* Type stack.  */
3850   struct ieee_type_stack *type_stack;
3851   /* Next unallocated type index.  */
3852   unsigned int type_indx;
3853   /* Next unallocated name index.  */
3854   unsigned int name_indx;
3855   /* Typedefs.  */
3856   struct ieee_name_type_hash_table typedefs;
3857   /* Tags.  */
3858   struct ieee_name_type_hash_table tags;
3859   /* Enums.  */
3860   struct ieee_defined_enum *enums;
3861   /* Modified versions of types.  */
3862   struct ieee_modified_type *modified;
3863   /* Number of entries allocated in modified.  */
3864   unsigned int modified_alloc;
3865   /* 4 byte complex type.  */
3866   unsigned int complex_float_index;
3867   /* 8 byte complex type.  */
3868   unsigned int complex_double_index;
3869   /* The depth of block nesting.  This is 0 outside a function, and 1
3870      just after start_function is called.  */
3871   unsigned int block_depth;
3872   /* The name of the current function.  */
3873   const char *fnname;
3874   /* List of buffers for the type of the function we are currently
3875      writing out.  */
3876   struct ieee_buflist fntype;
3877   /* List of buffers for the parameters of the function we are
3878      currently writing out.  */
3879   struct ieee_buflist fnargs;
3880   /* Number of arguments written to fnargs.  */
3881   unsigned int fnargcount;
3882   /* Pending function parameters.  */
3883   struct ieee_pending_parm *pending_parms;
3884   /* Current line number filename.  */
3885   const char *lineno_filename;
3886   /* Line number name index.  */
3887   unsigned int lineno_name_indx;
3888   /* Filename of pending line number.  */
3889   const char *pending_lineno_filename;
3890   /* Pending line number.  */
3891   unsigned long pending_lineno;
3892   /* Address of pending line number.  */
3893   bfd_vma pending_lineno_addr;
3894   /* Highest address seen at end of procedure.  */
3895   bfd_vma highaddr;
3896 };
3897
3898 static bfd_boolean ieee_init_buffer
3899   (struct ieee_handle *, struct ieee_buflist *);
3900 static bfd_boolean ieee_change_buffer
3901   (struct ieee_handle *, struct ieee_buflist *);
3902 static bfd_boolean ieee_append_buffer
3903   (struct ieee_handle *, struct ieee_buflist *, struct ieee_buflist *);
3904 static bfd_boolean ieee_real_write_byte (struct ieee_handle *, int);
3905 static bfd_boolean ieee_write_2bytes (struct ieee_handle *, int);
3906 static bfd_boolean ieee_write_number (struct ieee_handle *, bfd_vma);
3907 static bfd_boolean ieee_write_id (struct ieee_handle *, const char *);
3908 static bfd_boolean ieee_write_asn
3909   (struct ieee_handle *, unsigned int, bfd_vma);
3910 static bfd_boolean ieee_write_atn65
3911   (struct ieee_handle *, unsigned int, const char *);
3912 static bfd_boolean ieee_push_type
3913   (struct ieee_handle *, unsigned int, unsigned int, bfd_boolean,
3914    bfd_boolean);
3915 static unsigned int ieee_pop_type (struct ieee_handle *);
3916 static void ieee_pop_unused_type (struct ieee_handle *);
3917 static unsigned int ieee_pop_type_used (struct ieee_handle *, bfd_boolean);
3918 static bfd_boolean ieee_add_range
3919   (struct ieee_handle *, bfd_boolean, bfd_vma, bfd_vma);
3920 static bfd_boolean ieee_start_range (struct ieee_handle *, bfd_vma);
3921 static bfd_boolean ieee_end_range (struct ieee_handle *, bfd_vma);
3922 static bfd_boolean ieee_define_type
3923   (struct ieee_handle *, unsigned int, bfd_boolean, bfd_boolean);
3924 static bfd_boolean ieee_define_named_type
3925   (struct ieee_handle *, const char *, unsigned int, unsigned int,
3926    bfd_boolean, bfd_boolean, struct ieee_buflist *);
3927 static struct ieee_modified_type *ieee_get_modified_info
3928   (struct ieee_handle *, unsigned int);
3929 static struct bfd_hash_entry *ieee_name_type_newfunc
3930   (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
3931 static bfd_boolean ieee_write_undefined_tag
3932   (struct ieee_name_type_hash_entry *, void *);
3933 static bfd_boolean ieee_finish_compilation_unit (struct ieee_handle *);
3934 static void ieee_add_bb11_blocks (bfd *, asection *, void *);
3935 static bfd_boolean ieee_add_bb11
3936   (struct ieee_handle *, asection *, bfd_vma, bfd_vma);
3937 static bfd_boolean ieee_output_pending_parms (struct ieee_handle *);
3938 static unsigned int ieee_vis_to_flags (enum debug_visibility);
3939 static bfd_boolean ieee_class_method_var
3940   (struct ieee_handle *, const char *, enum debug_visibility, bfd_boolean,
3941    bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean);
3942
3943 static bfd_boolean ieee_start_compilation_unit (void *, const char *);
3944 static bfd_boolean ieee_start_source (void *, const char *);
3945 static bfd_boolean ieee_empty_type (void *);
3946 static bfd_boolean ieee_void_type (void *);
3947 static bfd_boolean ieee_int_type (void *, unsigned int, bfd_boolean);
3948 static bfd_boolean ieee_float_type (void *, unsigned int);
3949 static bfd_boolean ieee_complex_type (void *, unsigned int);
3950 static bfd_boolean ieee_bool_type (void *, unsigned int);
3951 static bfd_boolean ieee_enum_type
3952   (void *, const char *, const char **, bfd_signed_vma *);
3953 static bfd_boolean ieee_pointer_type (void *);
3954 static bfd_boolean ieee_function_type (void *, int, bfd_boolean);
3955 static bfd_boolean ieee_reference_type (void *);
3956 static bfd_boolean ieee_range_type (void *, bfd_signed_vma, bfd_signed_vma);
3957 static bfd_boolean ieee_array_type
3958   (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean);
3959 static bfd_boolean ieee_set_type (void *, bfd_boolean);
3960 static bfd_boolean ieee_offset_type (void *);
3961 static bfd_boolean ieee_method_type (void *, bfd_boolean, int, bfd_boolean);
3962 static bfd_boolean ieee_const_type (void *);
3963 static bfd_boolean ieee_volatile_type (void *);
3964 static bfd_boolean ieee_start_struct_type
3965   (void *, const char *, unsigned int, bfd_boolean, unsigned int);
3966 static bfd_boolean ieee_struct_field
3967   (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
3968 static bfd_boolean ieee_end_struct_type (void *);
3969 static bfd_boolean ieee_start_class_type
3970   (void *, const char *, unsigned int, bfd_boolean, unsigned int, bfd_boolean,
3971    bfd_boolean);
3972 static bfd_boolean ieee_class_static_member
3973   (void *, const char *, const char *, enum debug_visibility);
3974 static bfd_boolean ieee_class_baseclass
3975   (void *, bfd_vma, bfd_boolean, enum debug_visibility);
3976 static bfd_boolean ieee_class_start_method (void *, const char *);
3977 static bfd_boolean ieee_class_method_variant
3978   (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean,
3979    bfd_vma, bfd_boolean);
3980 static bfd_boolean ieee_class_static_method_variant
3981   (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
3982 static bfd_boolean ieee_class_end_method (void *);
3983 static bfd_boolean ieee_end_class_type (void *);
3984 static bfd_boolean ieee_typedef_type (void *, const char *);
3985 static bfd_boolean ieee_tag_type
3986   (void *, const char *, unsigned int, enum debug_type_kind);
3987 static bfd_boolean ieee_typdef (void *, const char *);
3988 static bfd_boolean ieee_tag (void *, const char *);
3989 static bfd_boolean ieee_int_constant (void *, const char *, bfd_vma);
3990 static bfd_boolean ieee_float_constant (void *, const char *, double);
3991 static bfd_boolean ieee_typed_constant (void *, const char *, bfd_vma);
3992 static bfd_boolean ieee_variable
3993   (void *, const char *, enum debug_var_kind, bfd_vma);
3994 static bfd_boolean ieee_start_function (void *, const char *, bfd_boolean);
3995 static bfd_boolean ieee_function_parameter
3996   (void *, const char *, enum debug_parm_kind, bfd_vma);
3997 static bfd_boolean ieee_start_block (void *, bfd_vma);
3998 static bfd_boolean ieee_end_block (void *, bfd_vma);
3999 static bfd_boolean ieee_end_function (void *);
4000 static bfd_boolean ieee_lineno (void *, const char *, unsigned long, bfd_vma);
4001
4002 static const struct debug_write_fns ieee_fns =
4003 {
4004   ieee_start_compilation_unit,
4005   ieee_start_source,
4006   ieee_empty_type,
4007   ieee_void_type,
4008   ieee_int_type,
4009   ieee_float_type,
4010   ieee_complex_type,
4011   ieee_bool_type,
4012   ieee_enum_type,
4013   ieee_pointer_type,
4014   ieee_function_type,
4015   ieee_reference_type,
4016   ieee_range_type,
4017   ieee_array_type,
4018   ieee_set_type,
4019   ieee_offset_type,
4020   ieee_method_type,
4021   ieee_const_type,
4022   ieee_volatile_type,
4023   ieee_start_struct_type,
4024   ieee_struct_field,
4025   ieee_end_struct_type,
4026   ieee_start_class_type,
4027   ieee_class_static_member,
4028   ieee_class_baseclass,
4029   ieee_class_start_method,
4030   ieee_class_method_variant,
4031   ieee_class_static_method_variant,
4032   ieee_class_end_method,
4033   ieee_end_class_type,
4034   ieee_typedef_type,
4035   ieee_tag_type,
4036   ieee_typdef,
4037   ieee_tag,
4038   ieee_int_constant,
4039   ieee_float_constant,
4040   ieee_typed_constant,
4041   ieee_variable,
4042   ieee_start_function,
4043   ieee_function_parameter,
4044   ieee_start_block,
4045   ieee_end_block,
4046   ieee_end_function,
4047   ieee_lineno
4048 };
4049
4050 /* Initialize a buffer to be empty.  */
4051
4052 static bfd_boolean
4053 ieee_init_buffer (struct ieee_handle *info ATTRIBUTE_UNUSED,
4054                   struct ieee_buflist *buflist)
4055 {
4056   buflist->head = NULL;
4057   buflist->tail = NULL;
4058   return TRUE;
4059 }
4060
4061 /* See whether a buffer list has any data.  */
4062
4063 #define ieee_buffer_emptyp(buflist) ((buflist)->head == NULL)
4064
4065 /* Change the current buffer to a specified buffer chain.  */
4066
4067 static bfd_boolean
4068 ieee_change_buffer (struct ieee_handle *info, struct ieee_buflist *buflist)
4069 {
4070   if (buflist->head == NULL)
4071     {
4072       struct ieee_buf *buf;
4073
4074       buf = (struct ieee_buf *) xmalloc (sizeof *buf);
4075       buf->next = NULL;
4076       buf->c = 0;
4077       buflist->head = buf;
4078       buflist->tail = buf;
4079     }
4080
4081   info->current = buflist;
4082   info->curbuf = buflist->tail;
4083
4084   return TRUE;
4085 }
4086
4087 /* Append a buffer chain.  */
4088
4089 static bfd_boolean
4090 ieee_append_buffer (struct ieee_handle *info ATTRIBUTE_UNUSED,
4091                     struct ieee_buflist *mainbuf,
4092                     struct ieee_buflist *newbuf)
4093 {
4094   if (newbuf->head != NULL)
4095     {
4096       if (mainbuf->head == NULL)
4097         mainbuf->head = newbuf->head;
4098       else
4099         mainbuf->tail->next = newbuf->head;
4100       mainbuf->tail = newbuf->tail;
4101     }
4102   return TRUE;
4103 }
4104
4105 /* Write a byte into the buffer.  We use a macro for speed and a
4106    function for the complex cases.  */
4107
4108 #define ieee_write_byte(info, b)                                \
4109   ((info)->curbuf->c < IEEE_BUFSIZE                             \
4110    ? ((info)->curbuf->buf[(info)->curbuf->c++] = (b), TRUE)     \
4111    : ieee_real_write_byte ((info), (b)))
4112
4113 static bfd_boolean
4114 ieee_real_write_byte (struct ieee_handle *info, int b)
4115 {
4116   if (info->curbuf->c >= IEEE_BUFSIZE)
4117     {
4118       struct ieee_buf *n;
4119
4120       n = (struct ieee_buf *) xmalloc (sizeof *n);
4121       n->next = NULL;
4122       n->c = 0;
4123       if (info->current->head == NULL)
4124         info->current->head = n;
4125       else
4126         info->current->tail->next = n;
4127       info->current->tail = n;
4128       info->curbuf = n;
4129     }
4130
4131   info->curbuf->buf[info->curbuf->c] = b;
4132   ++info->curbuf->c;
4133
4134   return TRUE;
4135 }
4136
4137 /* Write out two bytes.  */
4138
4139 static bfd_boolean
4140 ieee_write_2bytes (struct ieee_handle *info, int i)
4141 {
4142   return (ieee_write_byte (info, i >> 8)
4143           && ieee_write_byte (info, i & 0xff));
4144 }
4145
4146 /* Write out an integer.  */
4147
4148 static bfd_boolean
4149