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