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, §ype)
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