~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to pstack/ieee.c

  • Committer: brian
  • Date: 2008-06-25 05:29:13 UTC
  • Revision ID: brian@localhost.localdomain-20080625052913-6upwo0jsrl4lnapl
clean slate

Show diffs side-by-side

added added

removed removed

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