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