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