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