Subversion Repositories Kolibri OS

Rev

Rev 5217 | Details | Compare with Previous | Last modification | View Log | RSS feed

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