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