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