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