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