OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [binutils/] [ieee.c] - Blame information for rev 299

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.