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