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