OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [binutils/] [stabs.c] - Blame information for rev 339

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

Line No. Rev Author Line
1 205 julius
/* stabs.c -- Parse stabs debugging information
2
   Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3
   2005, 2006, 2007, 2008  Free Software Foundation, Inc.
4
   Written by Ian Lance Taylor <ian@cygnus.com>.
5
 
6
   This file is part of GNU Binutils.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3 of the License, or
11
   (at your option) any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program; if not, write to the Free Software
20
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
21
   02110-1301, USA.  */
22
 
23
/* This file contains code which parses stabs debugging information.
24
   The organization of this code is based on the gdb stabs reading
25
   code.  The job it does is somewhat different, because it is not
26
   trying to identify the correct address for anything.  */
27
 
28
#include "sysdep.h"
29
#include "bfd.h"
30
#include "libiberty.h"
31
#include "safe-ctype.h"
32
#include "demangle.h"
33
#include "debug.h"
34
#include "budbg.h"
35
#include "filenames.h"
36
#include "aout/aout64.h"
37
#include "aout/stab_gnu.h"
38
 
39
/* The number of predefined XCOFF types.  */
40
 
41
#define XCOFF_TYPE_COUNT 34
42
 
43
/* This structure is used as a handle so that the stab parsing doesn't
44
   need to use any static variables.  */
45
 
46
struct stab_handle
47
{
48
  /* The BFD.  */
49
  bfd *abfd;
50
  /* TRUE if this is stabs in sections.  */
51
  bfd_boolean sections;
52
  /* The symbol table.  */
53
  asymbol **syms;
54
  /* The number of symbols.  */
55
  long symcount;
56
  /* The accumulated file name string.  */
57
  char *so_string;
58
  /* The value of the last N_SO symbol.  */
59
  bfd_vma so_value;
60
  /* The value of the start of the file, so that we can handle file
61
     relative N_LBRAC and N_RBRAC symbols.  */
62
  bfd_vma file_start_offset;
63
  /* The offset of the start of the function, so that we can handle
64
     function relative N_LBRAC and N_RBRAC symbols.  */
65
  bfd_vma function_start_offset;
66
  /* The version number of gcc which compiled the current compilation
67
     unit, 0 if not compiled by gcc.  */
68
  int gcc_compiled;
69
  /* Whether an N_OPT symbol was seen that was not generated by gcc,
70
     so that we can detect the SunPRO compiler.  */
71
  bfd_boolean n_opt_found;
72
  /* The main file name.  */
73
  char *main_filename;
74
  /* A stack of unfinished N_BINCL files.  */
75
  struct bincl_file *bincl_stack;
76
  /* A list of finished N_BINCL files.  */
77
  struct bincl_file *bincl_list;
78
  /* Whether we are inside a function or not.  */
79
  bfd_boolean within_function;
80
  /* The address of the end of the function, used if we have seen an
81
     N_FUN symbol while in a function.  This is -1 if we have not seen
82
     an N_FUN (the normal case).  */
83
  bfd_vma function_end;
84
  /* The depth of block nesting.  */
85
  int block_depth;
86
  /* List of pending variable definitions.  */
87
  struct stab_pending_var *pending;
88
  /* Number of files for which we have types.  */
89
  unsigned int files;
90
  /* Lists of types per file.  */
91
  struct stab_types **file_types;
92
  /* Predefined XCOFF types.  */
93
  debug_type xcoff_types[XCOFF_TYPE_COUNT];
94
  /* Undefined tags.  */
95
  struct stab_tag *tags;
96
  /* Set by parse_stab_type if it sees a structure defined as a cross
97
     reference to itself.  Reset by parse_stab_type otherwise.  */
98
  bfd_boolean self_crossref;
99
};
100
 
101
/* A list of these structures is used to hold pending variable
102
   definitions seen before the N_LBRAC of a block.  */
103
 
104
struct stab_pending_var
105
{
106
  /* Next pending variable definition.  */
107
  struct stab_pending_var *next;
108
  /* Name.  */
109
  const char *name;
110
  /* Type.  */
111
  debug_type type;
112
  /* Kind.  */
113
  enum debug_var_kind kind;
114
  /* Value.  */
115
  bfd_vma val;
116
};
117
 
118
/* A list of these structures is used to hold the types for a single
119
   file.  */
120
 
121
struct stab_types
122
{
123
  /* Next set of slots for this file.  */
124
  struct stab_types *next;
125
  /* Types indexed by type number.  */
126
#define STAB_TYPES_SLOTS (16)
127
  debug_type types[STAB_TYPES_SLOTS];
128
};
129
 
130
/* We keep a list of undefined tags that we encounter, so that we can
131
   fill them in if the tag is later defined.  */
132
 
133
struct stab_tag
134
{
135
  /* Next undefined tag.  */
136
  struct stab_tag *next;
137
  /* Tag name.  */
138
  const char *name;
139
  /* Type kind.  */
140
  enum debug_type_kind kind;
141
  /* Slot to hold real type when we discover it.  If we don't, we fill
142
     in an undefined tag type.  */
143
  debug_type slot;
144
  /* Indirect type we have created to point at slot.  */
145
  debug_type type;
146
};
147
 
148
static char *savestring (const char *, int);
149
static bfd_vma parse_number (const char **, bfd_boolean *);
150
static void bad_stab (const char *);
151
static void warn_stab (const char *, const char *);
152
static bfd_boolean parse_stab_string
153
  (void *, struct stab_handle *, int, int, bfd_vma, const char *);
154
static debug_type parse_stab_type
155
  (void *, struct stab_handle *, const char *, const char **, debug_type **);
156
static bfd_boolean parse_stab_type_number (const char **, int *);
157
static debug_type parse_stab_range_type
158
  (void *, struct stab_handle *, const char *, const char **, const int *);
159
static debug_type parse_stab_sun_builtin_type (void *, const char **);
160
static debug_type parse_stab_sun_floating_type (void *, const char **);
161
static debug_type parse_stab_enum_type (void *, const char **);
162
static debug_type parse_stab_struct_type
163
  (void *, struct stab_handle *, const char *, const char **,
164
   bfd_boolean, const int *);
165
static bfd_boolean parse_stab_baseclasses
166
  (void *, struct stab_handle *, const char **, debug_baseclass **);
167
static bfd_boolean parse_stab_struct_fields
168
  (void *, struct stab_handle *, const char **, debug_field **, bfd_boolean *);
169
static bfd_boolean parse_stab_cpp_abbrev
170
  (void *, struct stab_handle *, const char **, debug_field *);
171
static bfd_boolean parse_stab_one_struct_field
172
  (void *, struct stab_handle *, const char **, const char *,
173
   debug_field *, bfd_boolean *);
174
static bfd_boolean parse_stab_members
175
  (void *, struct stab_handle *, const char *, const char **, const int *,
176
   debug_method **);
177
static debug_type parse_stab_argtypes
178
  (void *, struct stab_handle *, debug_type, const char *, const char *,
179
   debug_type, const char *, bfd_boolean, bfd_boolean, const char **);
180
static bfd_boolean parse_stab_tilde_field
181
  (void *, struct stab_handle *, const char **, const int *, debug_type *,
182
   bfd_boolean *);
183
static debug_type parse_stab_array_type
184
  (void *, struct stab_handle *, const char **, bfd_boolean);
185
static void push_bincl (struct stab_handle *, const char *, bfd_vma);
186
static const char *pop_bincl (struct stab_handle *);
187
static bfd_boolean find_excl (struct stab_handle *, const char *, bfd_vma);
188
static bfd_boolean stab_record_variable
189
  (void *, struct stab_handle *, const char *, debug_type,
190
   enum debug_var_kind, bfd_vma);
191
static bfd_boolean stab_emit_pending_vars (void *, struct stab_handle *);
192
static debug_type *stab_find_slot (struct stab_handle *, const int *);
193
static debug_type stab_find_type (void *, struct stab_handle *, const int *);
194
static bfd_boolean stab_record_type
195
  (void *, struct stab_handle *, const int *, debug_type);
196
static debug_type stab_xcoff_builtin_type
197
  (void *, struct stab_handle *, int);
198
static debug_type stab_find_tagged_type
199
  (void *, struct stab_handle *, const char *, int, enum debug_type_kind);
200
static debug_type *stab_demangle_argtypes
201
  (void *, struct stab_handle *, const char *, bfd_boolean *, unsigned int);
202
static debug_type *stab_demangle_v3_argtypes
203
  (void *, struct stab_handle *, const char *, bfd_boolean *);
204
static debug_type *stab_demangle_v3_arglist
205
  (void *, struct stab_handle *, struct demangle_component *, bfd_boolean *);
206
static debug_type stab_demangle_v3_arg
207
  (void *, struct stab_handle *, struct demangle_component *, debug_type,
208
   bfd_boolean *);
209
 
210
/* Save a string in memory.  */
211
 
212
static char *
213
savestring (const char *start, int len)
214
{
215
  char *ret;
216
 
217
  ret = (char *) xmalloc (len + 1);
218
  memcpy (ret, start, len);
219
  ret[len] = '\0';
220
  return ret;
221
}
222
 
223
/* Read a number from a string.  */
224
 
225
static bfd_vma
226
parse_number (const char **pp, bfd_boolean *poverflow)
227
{
228
  unsigned long ul;
229
  const char *orig;
230
 
231
  if (poverflow != NULL)
232
    *poverflow = FALSE;
233
 
234
  orig = *pp;
235
 
236
  errno = 0;
237
  ul = strtoul (*pp, (char **) pp, 0);
238
  if (ul + 1 != 0 || errno == 0)
239
    {
240
      /* If bfd_vma is larger than unsigned long, and the number is
241
         meant to be negative, we have to make sure that we sign
242
         extend properly.  */
243
      if (*orig == '-')
244
        return (bfd_vma) (bfd_signed_vma) (long) ul;
245
      return (bfd_vma) ul;
246
    }
247
 
248
  /* Note that even though strtoul overflowed, it should have set *pp
249
     to the end of the number, which is where we want it.  */
250
  if (sizeof (bfd_vma) > sizeof (unsigned long))
251
    {
252
      const char *p;
253
      bfd_boolean neg;
254
      int base;
255
      bfd_vma over, lastdig;
256
      bfd_boolean overflow;
257
      bfd_vma v;
258
 
259
      /* Our own version of strtoul, for a bfd_vma.  */
260
      p = orig;
261
 
262
      neg = FALSE;
263
      if (*p == '+')
264
        ++p;
265
      else if (*p == '-')
266
        {
267
          neg = TRUE;
268
          ++p;
269
        }
270
 
271
      base = 10;
272
      if (*p == '0')
273
        {
274
          if (p[1] == 'x' || p[1] == 'X')
275
            {
276
              base = 16;
277
              p += 2;
278
            }
279
          else
280
            {
281
              base = 8;
282
              ++p;
283
            }
284
        }
285
 
286
      over = ((bfd_vma) (bfd_signed_vma) -1) / (bfd_vma) base;
287
      lastdig = ((bfd_vma) (bfd_signed_vma) -1) % (bfd_vma) base;
288
 
289
      overflow = FALSE;
290
      v = 0;
291
      while (1)
292
        {
293
          int d;
294
 
295
          d = *p++;
296
          if (ISDIGIT (d))
297
            d -= '0';
298
          else if (ISUPPER (d))
299
            d -= 'A';
300
          else if (ISLOWER (d))
301
            d -= 'a';
302
          else
303
            break;
304
 
305
          if (d >= base)
306
            break;
307
 
308
          if (v > over || (v == over && (bfd_vma) d > lastdig))
309
            {
310
              overflow = TRUE;
311
              break;
312
            }
313
        }
314
 
315
      if (! overflow)
316
        {
317
          if (neg)
318
            v = - v;
319
          return v;
320
        }
321
    }
322
 
323
  /* If we get here, the number is too large to represent in a
324
     bfd_vma.  */
325
  if (poverflow != NULL)
326
    *poverflow = TRUE;
327
  else
328
    warn_stab (orig, _("numeric overflow"));
329
 
330
  return 0;
331
}
332
 
333
/* Give an error for a bad stab string.  */
334
 
335
static void
336
bad_stab (const char *p)
337
{
338
  fprintf (stderr, _("Bad stab: %s\n"), p);
339
}
340
 
341
/* Warn about something in a stab string.  */
342
 
343
static void
344
warn_stab (const char *p, const char *err)
345
{
346
  fprintf (stderr, _("Warning: %s: %s\n"), err, p);
347
}
348
 
349
/* Create a handle to parse stabs symbols with.  */
350
 
351
void *
352
start_stab (void *dhandle ATTRIBUTE_UNUSED, bfd *abfd, bfd_boolean sections,
353
            asymbol **syms, long symcount)
354
{
355
  struct stab_handle *ret;
356
 
357
  ret = (struct stab_handle *) xmalloc (sizeof *ret);
358
  memset (ret, 0, sizeof *ret);
359
  ret->abfd = abfd;
360
  ret->sections = sections;
361
  ret->syms = syms;
362
  ret->symcount = symcount;
363
  ret->files = 1;
364
  ret->file_types = (struct stab_types **) xmalloc (sizeof *ret->file_types);
365
  ret->file_types[0] = NULL;
366
  ret->function_end = (bfd_vma) -1;
367
  return (void *) ret;
368
}
369
 
370
/* When we have processed all the stabs information, we need to go
371
   through and fill in all the undefined tags.  */
372
 
373
bfd_boolean
374
finish_stab (void *dhandle, void *handle)
375
{
376
  struct stab_handle *info = (struct stab_handle *) handle;
377
  struct stab_tag *st;
378
 
379
  if (info->within_function)
380
    {
381
      if (! stab_emit_pending_vars (dhandle, info)
382
          || ! debug_end_function (dhandle, info->function_end))
383
        return FALSE;
384
      info->within_function = FALSE;
385
      info->function_end = (bfd_vma) -1;
386
    }
387
 
388
  for (st = info->tags; st != NULL; st = st->next)
389
    {
390
      enum debug_type_kind kind;
391
 
392
      kind = st->kind;
393
      if (kind == DEBUG_KIND_ILLEGAL)
394
        kind = DEBUG_KIND_STRUCT;
395
      st->slot = debug_make_undefined_tagged_type (dhandle, st->name, kind);
396
      if (st->slot == DEBUG_TYPE_NULL)
397
        return FALSE;
398
    }
399
 
400
  return TRUE;
401
}
402
 
403
/* Handle a single stabs symbol.  */
404
 
405
bfd_boolean
406
parse_stab (void *dhandle, void *handle, int type, int desc, bfd_vma value,
407
            const char *string)
408
{
409
  struct stab_handle *info = (struct stab_handle *) handle;
410
 
411
  /* gcc will emit two N_SO strings per compilation unit, one for the
412
     directory name and one for the file name.  We just collect N_SO
413
     strings as we see them, and start the new compilation unit when
414
     we see a non N_SO symbol.  */
415
  if (info->so_string != NULL
416
      && (type != N_SO || *string == '\0' || value != info->so_value))
417
    {
418
      if (! debug_set_filename (dhandle, info->so_string))
419
        return FALSE;
420
      info->main_filename = info->so_string;
421
 
422
      info->gcc_compiled = 0;
423
      info->n_opt_found = FALSE;
424
 
425
      /* Generally, for stabs in the symbol table, the N_LBRAC and
426
         N_RBRAC symbols are relative to the N_SO symbol value.  */
427
      if (! info->sections)
428
        info->file_start_offset = info->so_value;
429
 
430
      /* We need to reset the mapping from type numbers to types.  We
431
         can't free the old mapping, because of the use of
432
         debug_make_indirect_type.  */
433
      info->files = 1;
434
      info->file_types = ((struct stab_types **)
435
                          xmalloc (sizeof *info->file_types));
436
      info->file_types[0] = NULL;
437
 
438
      info->so_string = NULL;
439
 
440
      /* Now process whatever type we just got.  */
441
    }
442
 
443
  switch (type)
444
    {
445
    case N_FN:
446
    case N_FN_SEQ:
447
      break;
448
 
449
    case N_LBRAC:
450
      /* Ignore extra outermost context from SunPRO cc and acc.  */
451
      if (info->n_opt_found && desc == 1)
452
        break;
453
 
454
      if (! info->within_function)
455
        {
456
          fprintf (stderr, _("N_LBRAC not within function\n"));
457
          return FALSE;
458
        }
459
 
460
      /* Start an inner lexical block.  */
461
      if (! debug_start_block (dhandle,
462
                               (value
463
                                + info->file_start_offset
464
                                + info->function_start_offset)))
465
        return FALSE;
466
 
467
      /* Emit any pending variable definitions.  */
468
      if (! stab_emit_pending_vars (dhandle, info))
469
        return FALSE;
470
 
471
      ++info->block_depth;
472
      break;
473
 
474
    case N_RBRAC:
475
      /* Ignore extra outermost context from SunPRO cc and acc.  */
476
      if (info->n_opt_found && desc == 1)
477
        break;
478
 
479
      /* We shouldn't have any pending variable definitions here, but,
480
         if we do, we probably need to emit them before closing the
481
         block.  */
482
      if (! stab_emit_pending_vars (dhandle, info))
483
        return FALSE;
484
 
485
      /* End an inner lexical block.  */
486
      if (! debug_end_block (dhandle,
487
                             (value
488
                              + info->file_start_offset
489
                              + info->function_start_offset)))
490
        return FALSE;
491
 
492
      --info->block_depth;
493
      if (info->block_depth < 0)
494
        {
495
          fprintf (stderr, _("Too many N_RBRACs\n"));
496
          return FALSE;
497
        }
498
      break;
499
 
500
    case N_SO:
501
      /* This always ends a function.  */
502
      if (info->within_function)
503
        {
504
          bfd_vma endval;
505
 
506
          endval = value;
507
          if (*string != '\0'
508
              && info->function_end != (bfd_vma) -1
509
              && info->function_end < endval)
510
            endval = info->function_end;
511
          if (! stab_emit_pending_vars (dhandle, info)
512
              || ! debug_end_function (dhandle, endval))
513
            return FALSE;
514
          info->within_function = FALSE;
515
          info->function_end = (bfd_vma) -1;
516
        }
517
 
518
      /* An empty string is emitted by gcc at the end of a compilation
519
         unit.  */
520
      if (*string == '\0')
521
        return TRUE;
522
 
523
      /* Just accumulate strings until we see a non N_SO symbol.  If
524
         the string starts with a directory separator or some other
525
         form of absolute path specification, we discard the previously
526
         accumulated strings.  */
527
      if (info->so_string == NULL)
528
        info->so_string = xstrdup (string);
529
      else
530
        {
531
          char *f;
532
 
533
          f = info->so_string;
534
 
535
          if (IS_ABSOLUTE_PATH (string))
536
            info->so_string = xstrdup (string);
537
          else
538
            info->so_string = concat (info->so_string, string,
539
                                      (const char *) NULL);
540
          free (f);
541
        }
542
 
543
      info->so_value = value;
544
 
545
      break;
546
 
547
    case N_SOL:
548
      /* Start an include file.  */
549
      if (! debug_start_source (dhandle, string))
550
        return FALSE;
551
      break;
552
 
553
    case N_BINCL:
554
      /* Start an include file which may be replaced.  */
555
      push_bincl (info, string, value);
556
      if (! debug_start_source (dhandle, string))
557
        return FALSE;
558
      break;
559
 
560
    case N_EINCL:
561
      /* End an N_BINCL include.  */
562
      if (! debug_start_source (dhandle, pop_bincl (info)))
563
        return FALSE;
564
      break;
565
 
566
    case N_EXCL:
567
      /* This is a duplicate of a header file named by N_BINCL which
568
         was eliminated by the linker.  */
569
      if (! find_excl (info, string, value))
570
        return FALSE;
571
      break;
572
 
573
    case N_SLINE:
574
      if (! debug_record_line (dhandle, desc,
575
                               value + (info->within_function
576
                                        ? info->function_start_offset : 0)))
577
        return FALSE;
578
      break;
579
 
580
    case N_BCOMM:
581
      if (! debug_start_common_block (dhandle, string))
582
        return FALSE;
583
      break;
584
 
585
    case N_ECOMM:
586
      if (! debug_end_common_block (dhandle, string))
587
        return FALSE;
588
      break;
589
 
590
    case N_FUN:
591
      if (*string == '\0')
592
        {
593
          if (info->within_function)
594
            {
595
              /* This always marks the end of a function; we don't
596
                 need to worry about info->function_end.  */
597
              if (info->sections)
598
                value += info->function_start_offset;
599
              if (! stab_emit_pending_vars (dhandle, info)
600
                  || ! debug_end_function (dhandle, value))
601
                return FALSE;
602
              info->within_function = FALSE;
603
              info->function_end = (bfd_vma) -1;
604
            }
605
          break;
606
        }
607
 
608
      /* A const static symbol in the .text section will have an N_FUN
609
         entry.  We need to use these to mark the end of the function,
610
         in case we are looking at gcc output before it was changed to
611
         always emit an empty N_FUN.  We can't call debug_end_function
612
         here, because it might be a local static symbol.  */
613
      if (info->within_function
614
          && (info->function_end == (bfd_vma) -1
615
              || value < info->function_end))
616
        info->function_end = value;
617
 
618
      /* Fall through.  */
619
      /* FIXME: gdb checks the string for N_STSYM, N_LCSYM or N_ROSYM
620
         symbols, and if it does not start with :S, gdb relocates the
621
         value to the start of the section.  gcc always seems to use
622
         :S, so we don't worry about this.  */
623
      /* Fall through.  */
624
    default:
625
      {
626
        const char *colon;
627
 
628
        colon = strchr (string, ':');
629
        if (colon != NULL
630
            && (colon[1] == 'f' || colon[1] == 'F'))
631
          {
632
            if (info->within_function)
633
              {
634
                bfd_vma endval;
635
 
636
                endval = value;
637
                if (info->function_end != (bfd_vma) -1
638
                    && info->function_end < endval)
639
                  endval = info->function_end;
640
                if (! stab_emit_pending_vars (dhandle, info)
641
                    || ! debug_end_function (dhandle, endval))
642
                  return FALSE;
643
                info->function_end = (bfd_vma) -1;
644
              }
645
            /* For stabs in sections, line numbers and block addresses
646
               are offsets from the start of the function.  */
647
            if (info->sections)
648
              info->function_start_offset = value;
649
            info->within_function = TRUE;
650
          }
651
 
652
        if (! parse_stab_string (dhandle, info, type, desc, value, string))
653
          return FALSE;
654
      }
655
      break;
656
 
657
    case N_OPT:
658
      if (string != NULL && strcmp (string, "gcc2_compiled.") == 0)
659
        info->gcc_compiled = 2;
660
      else if (string != NULL && strcmp (string, "gcc_compiled.") == 0)
661
        info->gcc_compiled = 1;
662
      else
663
        info->n_opt_found = TRUE;
664
      break;
665
 
666
    case N_OBJ:
667
    case N_ENDM:
668
    case N_MAIN:
669
    case N_WARNING:
670
      break;
671
    }
672
 
673
  return TRUE;
674
}
675
 
676
/* Parse the stabs string.  */
677
 
678
static bfd_boolean
679
parse_stab_string (void *dhandle, struct stab_handle *info, int stabtype,
680
                   int desc, bfd_vma value, const char *string)
681
{
682
  const char *p;
683
  char *name;
684
  int type;
685
  debug_type dtype;
686
  bfd_boolean synonym;
687
  bfd_boolean self_crossref;
688
  unsigned int lineno;
689
  debug_type *slot;
690
 
691
  p = strchr (string, ':');
692
  if (p == NULL)
693
    return TRUE;
694
 
695
  while (p[1] == ':')
696
    {
697
      p += 2;
698
      p = strchr (p, ':');
699
      if (p == NULL)
700
        {
701
          bad_stab (string);
702
          return FALSE;
703
        }
704
    }
705
 
706
  /* GCC 2.x puts the line number in desc.  SunOS apparently puts in
707
     the number of bytes occupied by a type or object, which we
708
     ignore.  */
709
  if (info->gcc_compiled >= 2)
710
    lineno = desc;
711
  else
712
    lineno = 0;
713
 
714
  /* FIXME: Sometimes the special C++ names start with '.'.  */
715
  name = NULL;
716
  if (string[0] == '$')
717
    {
718
      switch (string[1])
719
        {
720
        case 't':
721
          name = "this";
722
          break;
723
        case 'v':
724
          /* Was: name = "vptr"; */
725
          break;
726
        case 'e':
727
          name = "eh_throw";
728
          break;
729
        case '_':
730
          /* This was an anonymous type that was never fixed up.  */
731
          break;
732
        case 'X':
733
          /* SunPRO (3.0 at least) static variable encoding.  */
734
          break;
735
        default:
736
          warn_stab (string, _("unknown C++ encoded name"));
737
          break;
738
        }
739
    }
740
 
741
  if (name == NULL)
742
    {
743
      if (p == string || (string[0] == ' ' && p == string + 1))
744
        name = NULL;
745
      else
746
        name = savestring (string, p - string);
747
    }
748
 
749
  ++p;
750
  if (ISDIGIT (*p) || *p == '(' || *p == '-')
751
    type = 'l';
752
  else
753
    type = *p++;
754
 
755
  switch (type)
756
    {
757
    case 'c':
758
      /* c is a special case, not followed by a type-number.
759
         SYMBOL:c=iVALUE for an integer constant symbol.
760
         SYMBOL:c=rVALUE for a floating constant symbol.
761
         SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
762
         e.g. "b:c=e6,0" for "const b = blob1"
763
         (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;").  */
764
      if (*p != '=')
765
        {
766
          bad_stab (string);
767
          return FALSE;
768
        }
769
      ++p;
770
      switch (*p++)
771
        {
772
        case 'r':
773
          /* Floating point constant.  */
774
          if (! debug_record_float_const (dhandle, name, atof (p)))
775
            return FALSE;
776
          break;
777
        case 'i':
778
          /* Integer constant.  */
779
          /* Defining integer constants this way is kind of silly,
780
             since 'e' constants allows the compiler to give not only
781
             the value, but the type as well.  C has at least int,
782
             long, unsigned int, and long long as constant types;
783
             other languages probably should have at least unsigned as
784
             well as signed constants.  */
785
          if (! debug_record_int_const (dhandle, name, atoi (p)))
786
            return FALSE;
787
          break;
788
        case 'e':
789
          /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
790
             can be represented as integral.
791
             e.g. "b:c=e6,0" for "const b = blob1"
792
             (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;").  */
793
          dtype = parse_stab_type (dhandle, info, (const char *) NULL,
794
                                   &p, (debug_type **) NULL);
795
          if (dtype == DEBUG_TYPE_NULL)
796
            return FALSE;
797
          if (*p != ',')
798
            {
799
              bad_stab (string);
800
              return FALSE;
801
            }
802
          if (! debug_record_typed_const (dhandle, name, dtype, atoi (p)))
803
            return FALSE;
804
          break;
805
        default:
806
          bad_stab (string);
807
          return FALSE;
808
        }
809
 
810
      break;
811
 
812
    case 'C':
813
      /* The name of a caught exception.  */
814
      dtype = parse_stab_type (dhandle, info, (const char *) NULL,
815
                               &p, (debug_type **) NULL);
816
      if (dtype == DEBUG_TYPE_NULL)
817
        return FALSE;
818
      if (! debug_record_label (dhandle, name, dtype, value))
819
        return FALSE;
820
      break;
821
 
822
    case 'f':
823
    case 'F':
824
      /* A function definition.  */
825
      dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
826
                               (debug_type **) NULL);
827
      if (dtype == DEBUG_TYPE_NULL)
828
        return FALSE;
829
      if (! debug_record_function (dhandle, name, dtype, type == 'F', value))
830
        return FALSE;
831
 
832
      /* Sun acc puts declared types of arguments here.  We don't care
833
         about their actual types (FIXME -- we should remember the whole
834
         function prototype), but the list may define some new types
835
         that we have to remember, so we must scan it now.  */
836
      while (*p == ';')
837
        {
838
          ++p;
839
          if (parse_stab_type (dhandle, info, (const char *) NULL, &p,
840
                               (debug_type **) NULL)
841
              == DEBUG_TYPE_NULL)
842
            return FALSE;
843
        }
844
 
845
      break;
846
 
847
    case 'G':
848
      {
849
        char leading;
850
        long c;
851
        asymbol **ps;
852
 
853
        /* A global symbol.  The value must be extracted from the
854
           symbol table.  */
855
        dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
856
                                 (debug_type **) NULL);
857
        if (dtype == DEBUG_TYPE_NULL)
858
          return FALSE;
859
        leading = bfd_get_symbol_leading_char (info->abfd);
860
        for (c = info->symcount, ps = info->syms; c > 0; --c, ++ps)
861
          {
862
            const char *n;
863
 
864
            n = bfd_asymbol_name (*ps);
865
            if (leading != '\0' && *n == leading)
866
              ++n;
867
            if (*n == *name && strcmp (n, name) == 0)
868
              break;
869
          }
870
        if (c > 0)
871
          value = bfd_asymbol_value (*ps);
872
        if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_GLOBAL,
873
                                    value))
874
          return FALSE;
875
      }
876
      break;
877
 
878
      /* This case is faked by a conditional above, when there is no
879
         code letter in the dbx data.  Dbx data never actually
880
         contains 'l'.  */
881
    case 'l':
882
    case 's':
883
      dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
884
                               (debug_type **) NULL);
885
      if (dtype == DEBUG_TYPE_NULL)
886
        return FALSE;
887
      if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL,
888
                                  value))
889
        return FALSE;
890
      break;
891
 
892
    case 'p':
893
      /* A function parameter.  */
894
      if (*p != 'F')
895
        dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
896
                                 (debug_type **) NULL);
897
      else
898
        {
899
        /* pF is a two-letter code that means a function parameter in
900
           Fortran.  The type-number specifies the type of the return
901
           value.  Translate it into a pointer-to-function type.  */
902
          ++p;
903
          dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
904
                                   (debug_type **) NULL);
905
          if (dtype != DEBUG_TYPE_NULL)
906
            {
907
              debug_type ftype;
908
 
909
              ftype = debug_make_function_type (dhandle, dtype,
910
                                                (debug_type *) NULL, FALSE);
911
              dtype = debug_make_pointer_type (dhandle, ftype);
912
            }
913
        }
914
      if (dtype == DEBUG_TYPE_NULL)
915
        return FALSE;
916
      if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_STACK,
917
                                    value))
918
        return FALSE;
919
 
920
      /* FIXME: At this point gdb considers rearranging the parameter
921
         address on a big endian machine if it is smaller than an int.
922
         We have no way to do that, since we don't really know much
923
         about the target.  */
924
      break;
925
 
926
    case 'P':
927
      if (stabtype == N_FUN)
928
        {
929
          /* Prototype of a function referenced by this file.  */
930
          while (*p == ';')
931
            {
932
              ++p;
933
              if (parse_stab_type (dhandle, info, (const char *) NULL, &p,
934
                                   (debug_type **) NULL)
935
                  == DEBUG_TYPE_NULL)
936
                return FALSE;
937
            }
938
          break;
939
        }
940
      /* Fall through.  */
941
    case 'R':
942
      /* Parameter which is in a register.  */
943
      dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
944
                               (debug_type **) NULL);
945
      if (dtype == DEBUG_TYPE_NULL)
946
        return FALSE;
947
      if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REG,
948
                                    value))
949
        return FALSE;
950
      break;
951
 
952
    case 'r':
953
      /* Register variable (either global or local).  */
954
      dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
955
                               (debug_type **) NULL);
956
      if (dtype == DEBUG_TYPE_NULL)
957
        return FALSE;
958
      if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_REGISTER,
959
                                  value))
960
        return FALSE;
961
 
962
      /* FIXME: At this point gdb checks to combine pairs of 'p' and
963
         'r' stabs into a single 'P' stab.  */
964
      break;
965
 
966
    case 'S':
967
      /* Static symbol at top level of file.  */
968
      dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
969
                               (debug_type **) NULL);
970
      if (dtype == DEBUG_TYPE_NULL)
971
        return FALSE;
972
      if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_STATIC,
973
                                  value))
974
        return FALSE;
975
      break;
976
 
977
    case 't':
978
      /* A typedef.  */
979
      dtype = parse_stab_type (dhandle, info, name, &p, &slot);
980
      if (dtype == DEBUG_TYPE_NULL)
981
        return FALSE;
982
      if (name == NULL)
983
        {
984
          /* A nameless type.  Nothing to do.  */
985
          return TRUE;
986
        }
987
 
988
      dtype = debug_name_type (dhandle, name, dtype);
989
      if (dtype == DEBUG_TYPE_NULL)
990
        return FALSE;
991
 
992
      if (slot != NULL)
993
        *slot = dtype;
994
 
995
      break;
996
 
997
    case 'T':
998
      /* Struct, union, or enum tag.  For GNU C++, this can be be followed
999
         by 't' which means we are typedef'ing it as well.  */
1000
      if (*p != 't')
1001
        {
1002
          synonym = FALSE;
1003
          /* FIXME: gdb sets synonym to TRUE if the current language
1004
             is C++.  */
1005
        }
1006
      else
1007
        {
1008
          synonym = TRUE;
1009
          ++p;
1010
        }
1011
 
1012
      dtype = parse_stab_type (dhandle, info, name, &p, &slot);
1013
      if (dtype == DEBUG_TYPE_NULL)
1014
        return FALSE;
1015
      if (name == NULL)
1016
        return TRUE;
1017
 
1018
      /* INFO->SELF_CROSSREF is set by parse_stab_type if this type is
1019
         a cross reference to itself.  These are generated by some
1020
         versions of g++.  */
1021
      self_crossref = info->self_crossref;
1022
 
1023
      dtype = debug_tag_type (dhandle, name, dtype);
1024
      if (dtype == DEBUG_TYPE_NULL)
1025
        return FALSE;
1026
      if (slot != NULL)
1027
        *slot = dtype;
1028
 
1029
      /* See if we have a cross reference to this tag which we can now
1030
         fill in.  Avoid filling in a cross reference to ourselves,
1031
         because that would lead to circular debugging information.  */
1032
      if (! self_crossref)
1033
        {
1034
          register struct stab_tag **pst;
1035
 
1036
          for (pst = &info->tags; *pst != NULL; pst = &(*pst)->next)
1037
            {
1038
              if ((*pst)->name[0] == name[0]
1039
                  && strcmp ((*pst)->name, name) == 0)
1040
                {
1041
                  (*pst)->slot = dtype;
1042
                  *pst = (*pst)->next;
1043
                  break;
1044
                }
1045
            }
1046
        }
1047
 
1048
      if (synonym)
1049
        {
1050
          dtype = debug_name_type (dhandle, name, dtype);
1051
          if (dtype == DEBUG_TYPE_NULL)
1052
            return FALSE;
1053
 
1054
          if (slot != NULL)
1055
            *slot = dtype;
1056
        }
1057
 
1058
      break;
1059
 
1060
    case 'V':
1061
      /* Static symbol of local scope */
1062
      dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1063
                               (debug_type **) NULL);
1064
      if (dtype == DEBUG_TYPE_NULL)
1065
        return FALSE;
1066
      /* FIXME: gdb checks os9k_stabs here.  */
1067
      if (! stab_record_variable (dhandle, info, name, dtype,
1068
                                  DEBUG_LOCAL_STATIC, value))
1069
        return FALSE;
1070
      break;
1071
 
1072
    case 'v':
1073
      /* Reference parameter.  */
1074
      dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1075
                               (debug_type **) NULL);
1076
      if (dtype == DEBUG_TYPE_NULL)
1077
        return FALSE;
1078
      if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REFERENCE,
1079
                                    value))
1080
        return FALSE;
1081
      break;
1082
 
1083
    case 'a':
1084
      /* Reference parameter which is in a register.  */
1085
      dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1086
                               (debug_type **) NULL);
1087
      if (dtype == DEBUG_TYPE_NULL)
1088
        return FALSE;
1089
      if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REF_REG,
1090
                                    value))
1091
        return FALSE;
1092
      break;
1093
 
1094
    case 'X':
1095
      /* This is used by Sun FORTRAN for "function result value".
1096
         Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1097
         that Pascal uses it too, but when I tried it Pascal used
1098
         "x:3" (local symbol) instead.  */
1099
      dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1100
                               (debug_type **) NULL);
1101
      if (dtype == DEBUG_TYPE_NULL)
1102
        return FALSE;
1103
      if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL,
1104
                                  value))
1105
        return FALSE;
1106
      break;
1107
 
1108
    case 'Y':
1109
      /* SUNPro C++ Namespace =Yn0.  */
1110
      /* Skip the namespace mapping, as it is not used now.  */
1111
      if (*(++p) == 'n' && *(++p) == '0')
1112
        {
1113
          /* =Yn0name; */
1114
          while (*p != ';')
1115
            ++p;
1116
          ++p;
1117
          return TRUE;
1118
        }
1119
      /* TODO SUNPro C++ support:
1120
         Support default arguments after F,P parameters
1121
         Ya = Anonymous unions
1122
         YM,YD = Pointers to class members
1123
         YT,YI = Templates
1124
         YR = Run-time type information (RTTI)  */
1125
 
1126
      /* Fall through.  */
1127
 
1128
    default:
1129
      bad_stab (string);
1130
      return FALSE;
1131
    }
1132
 
1133
  /* FIXME: gdb converts structure values to structure pointers in a
1134
     couple of cases, depending upon the target.  */
1135
 
1136
  return TRUE;
1137
}
1138
 
1139
/* Parse a stabs type.  The typename argument is non-NULL if this is a
1140
   typedef or a tag definition.  The pp argument points to the stab
1141
   string, and is updated.  The slotp argument points to a place to
1142
   store the slot used if the type is being defined.  */
1143
 
1144
static debug_type
1145
parse_stab_type (void *dhandle, struct stab_handle *info, const char *type_name, const char **pp, debug_type **slotp)
1146
{
1147
  const char *orig;
1148
  int typenums[2];
1149
  int size;
1150
  bfd_boolean stringp;
1151
  int descriptor;
1152
  debug_type dtype;
1153
 
1154
  if (slotp != NULL)
1155
    *slotp = NULL;
1156
 
1157
  orig = *pp;
1158
 
1159
  size = -1;
1160
  stringp = FALSE;
1161
 
1162
  info->self_crossref = FALSE;
1163
 
1164
  /* Read type number if present.  The type number may be omitted.
1165
     for instance in a two-dimensional array declared with type
1166
     "ar1;1;10;ar1;1;10;4".  */
1167
  if (! ISDIGIT (**pp) && **pp != '(' && **pp != '-')
1168
    {
1169
      /* 'typenums=' not present, type is anonymous.  Read and return
1170
         the definition, but don't put it in the type vector.  */
1171
      typenums[0] = typenums[1] = -1;
1172
    }
1173
  else
1174
    {
1175
      if (! parse_stab_type_number (pp, typenums))
1176
        return DEBUG_TYPE_NULL;
1177
 
1178
      if (**pp != '=')
1179
        /* Type is not being defined here.  Either it already
1180
           exists, or this is a forward reference to it.  */
1181
        return stab_find_type (dhandle, info, typenums);
1182
 
1183
      /* Only set the slot if the type is being defined.  This means
1184
         that the mapping from type numbers to types will only record
1185
         the name of the typedef which defines a type.  If we don't do
1186
         this, then something like
1187
             typedef int foo;
1188
             int i;
1189
         will record that i is of type foo.  Unfortunately, stabs
1190
         information is ambiguous about variable types.  For this code,
1191
             typedef int foo;
1192
             int i;
1193
             foo j;
1194
         the stabs information records both i and j as having the same
1195
         type.  This could be fixed by patching the compiler.  */
1196
      if (slotp != NULL && typenums[0] >= 0 && typenums[1] >= 0)
1197
        *slotp = stab_find_slot (info, typenums);
1198
 
1199
      /* Type is being defined here.  */
1200
      /* Skip the '='.  */
1201
      ++*pp;
1202
 
1203
      while (**pp == '@')
1204
        {
1205
          const char *p = *pp + 1;
1206
          const char *attr;
1207
 
1208
          if (ISDIGIT (*p) || *p == '(' || *p == '-')
1209
            /* Member type.  */
1210
            break;
1211
 
1212
          /* Type attributes.  */
1213
          attr = p;
1214
 
1215
          for (; *p != ';'; ++p)
1216
            {
1217
              if (*p == '\0')
1218
                {
1219
                  bad_stab (orig);
1220
                  return DEBUG_TYPE_NULL;
1221
                }
1222
            }
1223
          *pp = p + 1;
1224
 
1225
          switch (*attr)
1226
            {
1227
            case 's':
1228
              size = atoi (attr + 1);
1229
              size /= 8;  /* Size is in bits.  We store it in bytes.  */
1230
              if (size <= 0)
1231
                size = -1;
1232
              break;
1233
 
1234
            case 'S':
1235
              stringp = TRUE;
1236
              break;
1237
 
1238
            default:
1239
              /* Ignore unrecognized type attributes, so future
1240
                 compilers can invent new ones.  */
1241
              break;
1242
            }
1243
        }
1244
    }
1245
 
1246
  descriptor = **pp;
1247
  ++*pp;
1248
 
1249
  switch (descriptor)
1250
    {
1251
    case 'x':
1252
      {
1253
        enum debug_type_kind code;
1254
        const char *q1, *q2, *p;
1255
 
1256
        /* A cross reference to another type.  */
1257
        switch (**pp)
1258
          {
1259
          case 's':
1260
            code = DEBUG_KIND_STRUCT;
1261
            break;
1262
          case 'u':
1263
            code = DEBUG_KIND_UNION;
1264
            break;
1265
          case 'e':
1266
            code = DEBUG_KIND_ENUM;
1267
            break;
1268
          default:
1269
            /* Complain and keep going, so compilers can invent new
1270
               cross-reference types.  */
1271
            warn_stab (orig, _("unrecognized cross reference type"));
1272
            code = DEBUG_KIND_STRUCT;
1273
            break;
1274
          }
1275
        ++*pp;
1276
 
1277
        q1 = strchr (*pp, '<');
1278
        p = strchr (*pp, ':');
1279
        if (p == NULL)
1280
          {
1281
            bad_stab (orig);
1282
            return DEBUG_TYPE_NULL;
1283
          }
1284
        if (q1 != NULL && p > q1 && p[1] == ':')
1285
          {
1286
            int nest = 0;
1287
 
1288
            for (q2 = q1; *q2 != '\0'; ++q2)
1289
              {
1290
                if (*q2 == '<')
1291
                  ++nest;
1292
                else if (*q2 == '>')
1293
                  --nest;
1294
                else if (*q2 == ':' && nest == 0)
1295
                  break;
1296
              }
1297
            p = q2;
1298
            if (*p != ':')
1299
              {
1300
                bad_stab (orig);
1301
                return DEBUG_TYPE_NULL;
1302
              }
1303
          }
1304
 
1305
        /* Some versions of g++ can emit stabs like
1306
               fleep:T20=xsfleep:
1307
           which define structures in terms of themselves.  We need to
1308
           tell the caller to avoid building a circular structure.  */
1309
        if (type_name != NULL
1310
            && strncmp (type_name, *pp, p - *pp) == 0
1311
            && type_name[p - *pp] == '\0')
1312
          info->self_crossref = TRUE;
1313
 
1314
        dtype = stab_find_tagged_type (dhandle, info, *pp, p - *pp, code);
1315
 
1316
        *pp = p + 1;
1317
      }
1318
      break;
1319
 
1320
    case '-':
1321
    case '0':
1322
    case '1':
1323
    case '2':
1324
    case '3':
1325
    case '4':
1326
    case '5':
1327
    case '6':
1328
    case '7':
1329
    case '8':
1330
    case '9':
1331
    case '(':
1332
      {
1333
        const char *hold;
1334
        int xtypenums[2];
1335
 
1336
        /* This type is defined as another type.  */
1337
        (*pp)--;
1338
        hold = *pp;
1339
 
1340
        /* Peek ahead at the number to detect void.  */
1341
        if (! parse_stab_type_number (pp, xtypenums))
1342
          return DEBUG_TYPE_NULL;
1343
 
1344
        if (typenums[0] == xtypenums[0] && typenums[1] == xtypenums[1])
1345
          {
1346
            /* This type is being defined as itself, which means that
1347
               it is void.  */
1348
            dtype = debug_make_void_type (dhandle);
1349
          }
1350
        else
1351
          {
1352
            *pp = hold;
1353
 
1354
            /* Go back to the number and have parse_stab_type get it.
1355
               This means that we can deal with something like
1356
               t(1,2)=(3,4)=... which the Lucid compiler uses.  */
1357
            dtype = parse_stab_type (dhandle, info, (const char *) NULL,
1358
                                     pp, (debug_type **) NULL);
1359
            if (dtype == DEBUG_TYPE_NULL)
1360
              return DEBUG_TYPE_NULL;
1361
          }
1362
 
1363
        if (typenums[0] != -1)
1364
          {
1365
            if (! stab_record_type (dhandle, info, typenums, dtype))
1366
              return DEBUG_TYPE_NULL;
1367
          }
1368
 
1369
        break;
1370
      }
1371
 
1372
    case '*':
1373
      dtype = debug_make_pointer_type (dhandle,
1374
                                       parse_stab_type (dhandle, info,
1375
                                                        (const char *) NULL,
1376
                                                        pp,
1377
                                                        (debug_type **) NULL));
1378
      break;
1379
 
1380
    case '&':
1381
      /* Reference to another type.  */
1382
      dtype = (debug_make_reference_type
1383
               (dhandle,
1384
                parse_stab_type (dhandle, info, (const char *) NULL, pp,
1385
                                 (debug_type **) NULL)));
1386
      break;
1387
 
1388
    case 'f':
1389
      /* Function returning another type.  */
1390
      /* FIXME: gdb checks os9k_stabs here.  */
1391
      dtype = (debug_make_function_type
1392
               (dhandle,
1393
                parse_stab_type (dhandle, info, (const char *) NULL, pp,
1394
                                 (debug_type **) NULL),
1395
                (debug_type *) NULL, FALSE));
1396
      break;
1397
 
1398
    case 'k':
1399
      /* Const qualifier on some type (Sun).  */
1400
      /* FIXME: gdb accepts 'c' here if os9k_stabs.  */
1401
      dtype = debug_make_const_type (dhandle,
1402
                                     parse_stab_type (dhandle, info,
1403
                                                      (const char *) NULL,
1404
                                                      pp,
1405
                                                      (debug_type **) NULL));
1406
      break;
1407
 
1408
    case 'B':
1409
      /* Volatile qual on some type (Sun).  */
1410
      /* FIXME: gdb accepts 'i' here if os9k_stabs.  */
1411
      dtype = (debug_make_volatile_type
1412
               (dhandle,
1413
                parse_stab_type (dhandle, info, (const char *) NULL, pp,
1414
                                 (debug_type **) NULL)));
1415
      break;
1416
 
1417
    case '@':
1418
      /* Offset (class & variable) type.  This is used for a pointer
1419
         relative to an object.  */
1420
      {
1421
        debug_type domain;
1422
        debug_type memtype;
1423
 
1424
        /* Member type.  */
1425
 
1426
        domain = parse_stab_type (dhandle, info, (const char *) NULL, pp,
1427
                                  (debug_type **) NULL);
1428
        if (domain == DEBUG_TYPE_NULL)
1429
          return DEBUG_TYPE_NULL;
1430
 
1431
        if (**pp != ',')
1432
          {
1433
            bad_stab (orig);
1434
            return DEBUG_TYPE_NULL;
1435
          }
1436
        ++*pp;
1437
 
1438
        memtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
1439
                                   (debug_type **) NULL);
1440
        if (memtype == DEBUG_TYPE_NULL)
1441
          return DEBUG_TYPE_NULL;
1442
 
1443
        dtype = debug_make_offset_type (dhandle, domain, memtype);
1444
      }
1445
      break;
1446
 
1447
    case '#':
1448
      /* Method (class & fn) type.  */
1449
      if (**pp == '#')
1450
        {
1451
          debug_type return_type;
1452
 
1453
          ++*pp;
1454
          return_type = parse_stab_type (dhandle, info, (const char *) NULL,
1455
                                         pp, (debug_type **) NULL);
1456
          if (return_type == DEBUG_TYPE_NULL)
1457
            return DEBUG_TYPE_NULL;
1458
          if (**pp != ';')
1459
            {
1460
              bad_stab (orig);
1461
              return DEBUG_TYPE_NULL;
1462
            }
1463
          ++*pp;
1464
          dtype = debug_make_method_type (dhandle, return_type,
1465
                                          DEBUG_TYPE_NULL,
1466
                                          (debug_type *) NULL, FALSE);
1467
        }
1468
      else
1469
        {
1470
          debug_type domain;
1471
          debug_type return_type;
1472
          debug_type *args;
1473
          unsigned int n;
1474
          unsigned int alloc;
1475
          bfd_boolean varargs;
1476
 
1477
          domain = parse_stab_type (dhandle, info, (const char *) NULL,
1478
                                    pp, (debug_type **) NULL);
1479
          if (domain == DEBUG_TYPE_NULL)
1480
            return DEBUG_TYPE_NULL;
1481
 
1482
          if (**pp != ',')
1483
            {
1484
              bad_stab (orig);
1485
              return DEBUG_TYPE_NULL;
1486
            }
1487
          ++*pp;
1488
 
1489
          return_type = parse_stab_type (dhandle, info, (const char *) NULL,
1490
                                         pp, (debug_type **) NULL);
1491
          if (return_type == DEBUG_TYPE_NULL)
1492
            return DEBUG_TYPE_NULL;
1493
 
1494
          alloc = 10;
1495
          args = (debug_type *) xmalloc (alloc * sizeof *args);
1496
          n = 0;
1497
          while (**pp != ';')
1498
            {
1499
              if (**pp != ',')
1500
                {
1501
                  bad_stab (orig);
1502
                  return DEBUG_TYPE_NULL;
1503
                }
1504
              ++*pp;
1505
 
1506
              if (n + 1 >= alloc)
1507
                {
1508
                  alloc += 10;
1509
                  args = ((debug_type *)
1510
                          xrealloc (args, alloc * sizeof *args));
1511
                }
1512
 
1513
              args[n] = parse_stab_type (dhandle, info, (const char *) NULL,
1514
                                         pp, (debug_type **) NULL);
1515
              if (args[n] == DEBUG_TYPE_NULL)
1516
                return DEBUG_TYPE_NULL;
1517
              ++n;
1518
            }
1519
          ++*pp;
1520
 
1521
          /* If the last type is not void, then this function takes a
1522
             variable number of arguments.  Otherwise, we must strip
1523
             the void type.  */
1524
          if (n == 0
1525
              || debug_get_type_kind (dhandle, args[n - 1]) != DEBUG_KIND_VOID)
1526
            varargs = TRUE;
1527
          else
1528
            {
1529
              --n;
1530
              varargs = FALSE;
1531
            }
1532
 
1533
          args[n] = DEBUG_TYPE_NULL;
1534
 
1535
          dtype = debug_make_method_type (dhandle, return_type, domain, args,
1536
                                          varargs);
1537
        }
1538
      break;
1539
 
1540
    case 'r':
1541
      /* Range type.  */
1542
      dtype = parse_stab_range_type (dhandle, info, type_name, pp, typenums);
1543
      break;
1544
 
1545
    case 'b':
1546
      /* FIXME: gdb checks os9k_stabs here.  */
1547
      /* Sun ACC builtin int type.  */
1548
      dtype = parse_stab_sun_builtin_type (dhandle, pp);
1549
      break;
1550
 
1551
    case 'R':
1552
      /* Sun ACC builtin float type.  */
1553
      dtype = parse_stab_sun_floating_type (dhandle, pp);
1554
      break;
1555
 
1556
    case 'e':
1557
      /* Enumeration type.  */
1558
      dtype = parse_stab_enum_type (dhandle, pp);
1559
      break;
1560
 
1561
    case 's':
1562
    case 'u':
1563
      /* Struct or union type.  */
1564
      dtype = parse_stab_struct_type (dhandle, info, type_name, pp,
1565
                                      descriptor == 's', typenums);
1566
      break;
1567
 
1568
    case 'a':
1569
      /* Array type.  */
1570
      if (**pp != 'r')
1571
        {
1572
          bad_stab (orig);
1573
          return DEBUG_TYPE_NULL;
1574
        }
1575
      ++*pp;
1576
 
1577
      dtype = parse_stab_array_type (dhandle, info, pp, stringp);
1578
      break;
1579
 
1580
    case 'S':
1581
      dtype = debug_make_set_type (dhandle,
1582
                                   parse_stab_type (dhandle, info,
1583
                                                    (const char *) NULL,
1584
                                                    pp,
1585
                                                    (debug_type **) NULL),
1586
                                   stringp);
1587
      break;
1588
 
1589
    default:
1590
      bad_stab (orig);
1591
      return DEBUG_TYPE_NULL;
1592
    }
1593
 
1594
  if (dtype == DEBUG_TYPE_NULL)
1595
    return DEBUG_TYPE_NULL;
1596
 
1597
  if (typenums[0] != -1)
1598
    {
1599
      if (! stab_record_type (dhandle, info, typenums, dtype))
1600
        return DEBUG_TYPE_NULL;
1601
    }
1602
 
1603
  if (size != -1)
1604
    {
1605
      if (! debug_record_type_size (dhandle, dtype, (unsigned int) size))
1606
        return DEBUG_TYPE_NULL;
1607
    }
1608
 
1609
  return dtype;
1610
}
1611
 
1612
/* Read a number by which a type is referred to in dbx data, or
1613
   perhaps read a pair (FILENUM, TYPENUM) in parentheses.  Just a
1614
   single number N is equivalent to (0,N).  Return the two numbers by
1615
   storing them in the vector TYPENUMS.  */
1616
 
1617
static bfd_boolean
1618
parse_stab_type_number (const char **pp, int *typenums)
1619
{
1620
  const char *orig;
1621
 
1622
  orig = *pp;
1623
 
1624
  if (**pp != '(')
1625
    {
1626
      typenums[0] = 0;
1627
      typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL);
1628
    }
1629
  else
1630
    {
1631
      ++*pp;
1632
      typenums[0] = (int) parse_number (pp, (bfd_boolean *) NULL);
1633
      if (**pp != ',')
1634
        {
1635
          bad_stab (orig);
1636
          return FALSE;
1637
        }
1638
      ++*pp;
1639
      typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL);
1640
      if (**pp != ')')
1641
        {
1642
          bad_stab (orig);
1643
          return FALSE;
1644
        }
1645
      ++*pp;
1646
    }
1647
 
1648
  return TRUE;
1649
}
1650
 
1651
/* Parse a range type.  */
1652
 
1653
static debug_type
1654
parse_stab_range_type (void *dhandle, struct stab_handle *info, const char *type_name, const char **pp, const int *typenums)
1655
{
1656
  const char *orig;
1657
  int rangenums[2];
1658
  bfd_boolean self_subrange;
1659
  debug_type index_type;
1660
  const char *s2, *s3;
1661
  bfd_signed_vma n2, n3;
1662
  bfd_boolean ov2, ov3;
1663
 
1664
  orig = *pp;
1665
 
1666
  index_type = DEBUG_TYPE_NULL;
1667
 
1668
  /* First comes a type we are a subrange of.
1669
     In C it is usually 0, 1 or the type being defined.  */
1670
  if (! parse_stab_type_number (pp, rangenums))
1671
    return DEBUG_TYPE_NULL;
1672
 
1673
  self_subrange = (rangenums[0] == typenums[0]
1674
                   && rangenums[1] == typenums[1]);
1675
 
1676
  if (**pp == '=')
1677
    {
1678
      *pp = orig;
1679
      index_type = parse_stab_type (dhandle, info, (const char *) NULL,
1680
                                    pp, (debug_type **) NULL);
1681
      if (index_type == DEBUG_TYPE_NULL)
1682
        return DEBUG_TYPE_NULL;
1683
    }
1684
 
1685
  if (**pp == ';')
1686
    ++*pp;
1687
 
1688
  /* The remaining two operands are usually lower and upper bounds of
1689
     the range.  But in some special cases they mean something else.  */
1690
  s2 = *pp;
1691
  n2 = parse_number (pp, &ov2);
1692
  if (**pp != ';')
1693
    {
1694
      bad_stab (orig);
1695
      return DEBUG_TYPE_NULL;
1696
    }
1697
  ++*pp;
1698
 
1699
  s3 = *pp;
1700
  n3 = parse_number (pp, &ov3);
1701
  if (**pp != ';')
1702
    {
1703
      bad_stab (orig);
1704
      return DEBUG_TYPE_NULL;
1705
    }
1706
  ++*pp;
1707
 
1708
  if (ov2 || ov3)
1709
    {
1710
      /* gcc will emit range stabs for long long types.  Handle this
1711
         as a special case.  FIXME: This needs to be more general.  */
1712
#define LLLOW   "01000000000000000000000;"
1713
#define LLHIGH   "0777777777777777777777;"
1714
#define ULLHIGH "01777777777777777777777;"
1715
      if (index_type == DEBUG_TYPE_NULL)
1716
        {
1717
          if (CONST_STRNEQ (s2, LLLOW)
1718
              && CONST_STRNEQ (s3, LLHIGH))
1719
            return debug_make_int_type (dhandle, 8, FALSE);
1720
          if (! ov2
1721
              && n2 == 0
1722
              && CONST_STRNEQ (s3, ULLHIGH))
1723
            return debug_make_int_type (dhandle, 8, TRUE);
1724
        }
1725
 
1726
      warn_stab (orig, _("numeric overflow"));
1727
    }
1728
 
1729
  if (index_type == DEBUG_TYPE_NULL)
1730
    {
1731
      /* A type defined as a subrange of itself, with both bounds 0,
1732
         is void.  */
1733
      if (self_subrange && n2 == 0 && n3 == 0)
1734
        return debug_make_void_type (dhandle);
1735
 
1736
      /* A type defined as a subrange of itself, with n2 positive and
1737
         n3 zero, is a complex type, and n2 is the number of bytes.  */
1738
      if (self_subrange && n3 == 0 && n2 > 0)
1739
        return debug_make_complex_type (dhandle, n2);
1740
 
1741
      /* If n3 is zero and n2 is positive, this is a floating point
1742
         type, and n2 is the number of bytes.  */
1743
      if (n3 == 0 && n2 > 0)
1744
        return debug_make_float_type (dhandle, n2);
1745
 
1746
      /* If the upper bound is -1, this is an unsigned int.  */
1747
      if (n2 == 0 && n3 == -1)
1748
        {
1749
          /* When gcc is used with -gstabs, but not -gstabs+, it will emit
1750
                 long long int:t6=r1;0;-1;
1751
                 long long unsigned int:t7=r1;0;-1;
1752
             We hack here to handle this reasonably.  */
1753
          if (type_name != NULL)
1754
            {
1755
              if (strcmp (type_name, "long long int") == 0)
1756
                return debug_make_int_type (dhandle, 8, FALSE);
1757
              else if (strcmp (type_name, "long long unsigned int") == 0)
1758
                return debug_make_int_type (dhandle, 8, TRUE);
1759
            }
1760
          /* FIXME: The size here really depends upon the target.  */
1761
          return debug_make_int_type (dhandle, 4, TRUE);
1762
        }
1763
 
1764
      /* A range of 0 to 127 is char.  */
1765
      if (self_subrange && n2 == 0 && n3 == 127)
1766
        return debug_make_int_type (dhandle, 1, FALSE);
1767
 
1768
      /* FIXME: gdb checks for the language CHILL here.  */
1769
 
1770
      if (n2 == 0)
1771
        {
1772
          if (n3 < 0)
1773
            return debug_make_int_type (dhandle, - n3, TRUE);
1774
          else if (n3 == 0xff)
1775
            return debug_make_int_type (dhandle, 1, TRUE);
1776
          else if (n3 == 0xffff)
1777
            return debug_make_int_type (dhandle, 2, TRUE);
1778
          else if (n3 == (bfd_signed_vma) 0xffffffff)
1779
            return debug_make_int_type (dhandle, 4, TRUE);
1780
#ifdef BFD64
1781
          else if (n3 == ((((bfd_signed_vma) 0xffffffff) << 32) | 0xffffffff))
1782
            return debug_make_int_type (dhandle, 8, TRUE);
1783
#endif
1784
        }
1785
      else if (n3 == 0
1786
               && n2 < 0
1787
               && (self_subrange || n2 == -8))
1788
        return debug_make_int_type (dhandle, - n2, TRUE);
1789
      else if (n2 == - n3 - 1 || n2 == n3 + 1)
1790
        {
1791
          if (n3 == 0x7f)
1792
            return debug_make_int_type (dhandle, 1, FALSE);
1793
          else if (n3 == 0x7fff)
1794
            return debug_make_int_type (dhandle, 2, FALSE);
1795
          else if (n3 == 0x7fffffff)
1796
            return debug_make_int_type (dhandle, 4, FALSE);
1797
#ifdef BFD64
1798
          else if (n3 == ((((bfd_vma) 0x7fffffff) << 32) | 0xffffffff))
1799
            return debug_make_int_type (dhandle, 8, FALSE);
1800
#endif
1801
        }
1802
    }
1803
 
1804
  /* At this point I don't have the faintest idea how to deal with a
1805
     self_subrange type; I'm going to assume that this is used as an
1806
     idiom, and that all of them are special cases.  So . . .  */
1807
  if (self_subrange)
1808
    {
1809
      bad_stab (orig);
1810
      return DEBUG_TYPE_NULL;
1811
    }
1812
 
1813
  index_type = stab_find_type (dhandle, info, rangenums);
1814
  if (index_type == DEBUG_TYPE_NULL)
1815
    {
1816
      /* Does this actually ever happen?  Is that why we are worrying
1817
         about dealing with it rather than just calling error_type?  */
1818
      warn_stab (orig, _("missing index type"));
1819
      index_type = debug_make_int_type (dhandle, 4, FALSE);
1820
    }
1821
 
1822
  return debug_make_range_type (dhandle, index_type, n2, n3);
1823
}
1824
 
1825
/* Sun's ACC uses a somewhat saner method for specifying the builtin
1826
   typedefs in every file (for int, long, etc):
1827
 
1828
        type = b <signed> <width>; <offset>; <nbits>
1829
        signed = u or s.  Possible c in addition to u or s (for char?).
1830
        offset = offset from high order bit to start bit of type.
1831
        width is # bytes in object of this type, nbits is # bits in type.
1832
 
1833
   The width/offset stuff appears to be for small objects stored in
1834
   larger ones (e.g. `shorts' in `int' registers).  We ignore it for now,
1835
   FIXME.  */
1836
 
1837
static debug_type
1838
parse_stab_sun_builtin_type (void *dhandle, const char **pp)
1839
{
1840
  const char *orig;
1841
  bfd_boolean unsignedp;
1842
  bfd_vma bits;
1843
 
1844
  orig = *pp;
1845
 
1846
  switch (**pp)
1847
    {
1848
    case 's':
1849
      unsignedp = FALSE;
1850
      break;
1851
    case 'u':
1852
      unsignedp = TRUE;
1853
      break;
1854
    default:
1855
      bad_stab (orig);
1856
      return DEBUG_TYPE_NULL;
1857
    }
1858
  ++*pp;
1859
 
1860
  /* OpenSolaris source code indicates that one of "cbv" characters
1861
     can come next and specify the intrinsic 'iformat' encoding.
1862
     'c' is character encoding, 'b' is boolean encoding, and 'v' is
1863
     varargs encoding.  This field can be safely ignored because
1864
     the type of the field is determined from the bitwidth extracted
1865
     below.  */
1866
  if (**pp == 'c' || **pp == 'b' || **pp == 'v')
1867
    ++*pp;
1868
 
1869
  /* The first number appears to be the number of bytes occupied
1870
     by this type, except that unsigned short is 4 instead of 2.
1871
     Since this information is redundant with the third number,
1872
     we will ignore it.  */
1873
  (void) parse_number (pp, (bfd_boolean *) NULL);
1874
  if (**pp != ';')
1875
    {
1876
      bad_stab (orig);
1877
      return DEBUG_TYPE_NULL;
1878
    }
1879
  ++*pp;
1880
 
1881
  /* The second number is always 0, so ignore it too.  */
1882
  (void) parse_number (pp, (bfd_boolean *) NULL);
1883
  if (**pp != ';')
1884
    {
1885
      bad_stab (orig);
1886
      return DEBUG_TYPE_NULL;
1887
    }
1888
  ++*pp;
1889
 
1890
  /* The third number is the number of bits for this type.  */
1891
  bits = parse_number (pp, (bfd_boolean *) NULL);
1892
 
1893
  /* The type *should* end with a semicolon.  If it are embedded
1894
     in a larger type the semicolon may be the only way to know where
1895
     the type ends.  If this type is at the end of the stabstring we
1896
     can deal with the omitted semicolon (but we don't have to like
1897
     it).  Don't bother to complain(), Sun's compiler omits the semicolon
1898
     for "void".  */
1899
  if (**pp == ';')
1900
    ++*pp;
1901
 
1902
  if (bits == 0)
1903
    return debug_make_void_type (dhandle);
1904
 
1905
  return debug_make_int_type (dhandle, bits / 8, unsignedp);
1906
}
1907
 
1908
/* Parse a builtin floating type generated by the Sun compiler.  */
1909
 
1910
static debug_type
1911
parse_stab_sun_floating_type (void *dhandle, const char **pp)
1912
{
1913
  const char *orig;
1914
  bfd_vma details;
1915
  bfd_vma bytes;
1916
 
1917
  orig = *pp;
1918
 
1919
  /* The first number has more details about the type, for example
1920
     FN_COMPLEX.  */
1921
  details = parse_number (pp, (bfd_boolean *) NULL);
1922
  if (**pp != ';')
1923
    {
1924
      bad_stab (orig);
1925
      return DEBUG_TYPE_NULL;
1926
    }
1927
 
1928
  /* The second number is the number of bytes occupied by this type */
1929
  bytes = parse_number (pp, (bfd_boolean *) NULL);
1930
  if (**pp != ';')
1931
    {
1932
      bad_stab (orig);
1933
      return DEBUG_TYPE_NULL;
1934
    }
1935
 
1936
  if (details == NF_COMPLEX
1937
      || details == NF_COMPLEX16
1938
      || details == NF_COMPLEX32)
1939
    return debug_make_complex_type (dhandle, bytes);
1940
 
1941
  return debug_make_float_type (dhandle, bytes);
1942
}
1943
 
1944
/* Handle an enum type.  */
1945
 
1946
static debug_type
1947
parse_stab_enum_type (void *dhandle, const char **pp)
1948
{
1949
  const char *orig;
1950
  const char **names;
1951
  bfd_signed_vma *values;
1952
  unsigned int n;
1953
  unsigned int alloc;
1954
 
1955
  orig = *pp;
1956
 
1957
  /* FIXME: gdb checks os9k_stabs here.  */
1958
 
1959
  /* The aix4 compiler emits an extra field before the enum members;
1960
     my guess is it's a type of some sort.  Just ignore it.  */
1961
  if (**pp == '-')
1962
    {
1963
      while (**pp != ':')
1964
        ++*pp;
1965
      ++*pp;
1966
    }
1967
 
1968
  /* Read the value-names and their values.
1969
     The input syntax is NAME:VALUE,NAME:VALUE, and so on.
1970
     A semicolon or comma instead of a NAME means the end.  */
1971
  alloc = 10;
1972
  names = (const char **) xmalloc (alloc * sizeof *names);
1973
  values = (bfd_signed_vma *) xmalloc (alloc * sizeof *values);
1974
  n = 0;
1975
  while (**pp != '\0' && **pp != ';' && **pp != ',')
1976
    {
1977
      const char *p;
1978
      char *name;
1979
      bfd_signed_vma val;
1980
 
1981
      p = *pp;
1982
      while (*p != ':')
1983
        ++p;
1984
 
1985
      name = savestring (*pp, p - *pp);
1986
 
1987
      *pp = p + 1;
1988
      val = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
1989
      if (**pp != ',')
1990
        {
1991
          bad_stab (orig);
1992
          return DEBUG_TYPE_NULL;
1993
        }
1994
      ++*pp;
1995
 
1996
      if (n + 1 >= alloc)
1997
        {
1998
          alloc += 10;
1999
          names = ((const char **)
2000
                   xrealloc (names, alloc * sizeof *names));
2001
          values = ((bfd_signed_vma *)
2002
                    xrealloc (values, alloc * sizeof *values));
2003
        }
2004
 
2005
      names[n] = name;
2006
      values[n] = val;
2007
      ++n;
2008
    }
2009
 
2010
  names[n] = NULL;
2011
  values[n] = 0;
2012
 
2013
  if (**pp == ';')
2014
    ++*pp;
2015
 
2016
  return debug_make_enum_type (dhandle, names, values);
2017
}
2018
 
2019
/* Read the description of a structure (or union type) and return an object
2020
   describing the type.
2021
 
2022
   PP points to a character pointer that points to the next unconsumed token
2023
   in the stabs string.  For example, given stabs "A:T4=s4a:1,0,32;;",
2024
   *PP will point to "4a:1,0,32;;".  */
2025
 
2026
static debug_type
2027
parse_stab_struct_type (void *dhandle, struct stab_handle *info,
2028
                        const char *tagname, const char **pp,
2029
                        bfd_boolean structp, const int *typenums)
2030
{
2031
  const char *orig;
2032
  bfd_vma size;
2033
  debug_baseclass *baseclasses;
2034
  debug_field *fields;
2035
  bfd_boolean statics;
2036
  debug_method *methods;
2037
  debug_type vptrbase;
2038
  bfd_boolean ownvptr;
2039
 
2040
  orig = *pp;
2041
 
2042
  /* Get the size.  */
2043
  size = parse_number (pp, (bfd_boolean *) NULL);
2044
 
2045
  /* Get the other information.  */
2046
  if (! parse_stab_baseclasses (dhandle, info, pp, &baseclasses)
2047
      || ! parse_stab_struct_fields (dhandle, info, pp, &fields, &statics)
2048
      || ! parse_stab_members (dhandle, info, tagname, pp, typenums, &methods)
2049
      || ! parse_stab_tilde_field (dhandle, info, pp, typenums, &vptrbase,
2050
                                   &ownvptr))
2051
    return DEBUG_TYPE_NULL;
2052
 
2053
  if (! statics
2054
      && baseclasses == NULL
2055
      && methods == NULL
2056
      && vptrbase == DEBUG_TYPE_NULL
2057
      && ! ownvptr)
2058
    return debug_make_struct_type (dhandle, structp, size, fields);
2059
 
2060
  return debug_make_object_type (dhandle, structp, size, fields, baseclasses,
2061
                                 methods, vptrbase, ownvptr);
2062
}
2063
 
2064
/* The stabs for C++ derived classes contain baseclass information which
2065
   is marked by a '!' character after the total size.  This function is
2066
   called when we encounter the baseclass marker, and slurps up all the
2067
   baseclass information.
2068
 
2069
   Immediately following the '!' marker is the number of base classes that
2070
   the class is derived from, followed by information for each base class.
2071
   For each base class, there are two visibility specifiers, a bit offset
2072
   to the base class information within the derived class, a reference to
2073
   the type for the base class, and a terminating semicolon.
2074
 
2075
   A typical example, with two base classes, would be "!2,020,19;0264,21;".
2076
                                                       ^^ ^ ^ ^  ^ ^  ^
2077
        Baseclass information marker __________________|| | | |  | |  |
2078
        Number of baseclasses __________________________| | | |  | |  |
2079
        Visibility specifiers (2) ________________________| | |  | |  |
2080
        Offset in bits from start of class _________________| |  | |  |
2081
        Type number for base class ___________________________|  | |  |
2082
        Visibility specifiers (2) _______________________________| |  |
2083
        Offset in bits from start of class ________________________|  |
2084
        Type number of base class ____________________________________|
2085
 
2086
  Return TRUE for success, FALSE for failure.  */
2087
 
2088
static bfd_boolean
2089
parse_stab_baseclasses (void *dhandle, struct stab_handle *info,
2090
                        const char **pp, debug_baseclass **retp)
2091
{
2092
  const char *orig;
2093
  unsigned int c, i;
2094
  debug_baseclass *classes;
2095
 
2096
  *retp = NULL;
2097
 
2098
  orig = *pp;
2099
 
2100
  if (**pp != '!')
2101
    {
2102
      /* No base classes.  */
2103
      return TRUE;
2104
    }
2105
  ++*pp;
2106
 
2107
  c = (unsigned int) parse_number (pp, (bfd_boolean *) NULL);
2108
 
2109
  if (**pp != ',')
2110
    {
2111
      bad_stab (orig);
2112
      return FALSE;
2113
    }
2114
  ++*pp;
2115
 
2116
  classes = (debug_baseclass *) xmalloc ((c + 1) * sizeof (**retp));
2117
 
2118
  for (i = 0; i < c; i++)
2119
    {
2120
      bfd_boolean is_virtual;
2121
      enum debug_visibility visibility;
2122
      bfd_vma bitpos;
2123
      debug_type type;
2124
 
2125
      switch (**pp)
2126
        {
2127
        case '0':
2128
          is_virtual = FALSE;
2129
          break;
2130
        case '1':
2131
          is_virtual = TRUE;
2132
          break;
2133
        default:
2134
          warn_stab (orig, _("unknown virtual character for baseclass"));
2135
          is_virtual = FALSE;
2136
          break;
2137
        }
2138
      ++*pp;
2139
 
2140
      switch (**pp)
2141
        {
2142
        case '0':
2143
          visibility = DEBUG_VISIBILITY_PRIVATE;
2144
          break;
2145
        case '1':
2146
          visibility = DEBUG_VISIBILITY_PROTECTED;
2147
          break;
2148
        case '2':
2149
          visibility = DEBUG_VISIBILITY_PUBLIC;
2150
          break;
2151
        default:
2152
          warn_stab (orig, _("unknown visibility character for baseclass"));
2153
          visibility = DEBUG_VISIBILITY_PUBLIC;
2154
          break;
2155
        }
2156
      ++*pp;
2157
 
2158
      /* The remaining value is the bit offset of the portion of the
2159
         object corresponding to this baseclass.  Always zero in the
2160
         absence of multiple inheritance.  */
2161
      bitpos = parse_number (pp, (bfd_boolean *) NULL);
2162
      if (**pp != ',')
2163
        {
2164
          bad_stab (orig);
2165
          return FALSE;
2166
        }
2167
      ++*pp;
2168
 
2169
      type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2170
                              (debug_type **) NULL);
2171
      if (type == DEBUG_TYPE_NULL)
2172
        return FALSE;
2173
 
2174
      classes[i] = debug_make_baseclass (dhandle, type, bitpos, is_virtual,
2175
                                         visibility);
2176
      if (classes[i] == DEBUG_BASECLASS_NULL)
2177
        return FALSE;
2178
 
2179
      if (**pp != ';')
2180
        return FALSE;
2181
      ++*pp;
2182
    }
2183
 
2184
  classes[i] = DEBUG_BASECLASS_NULL;
2185
 
2186
  *retp = classes;
2187
 
2188
  return TRUE;
2189
}
2190
 
2191
/* Read struct or class data fields.  They have the form:
2192
 
2193
        NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2194
 
2195
   At the end, we see a semicolon instead of a field.
2196
 
2197
   In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2198
   a static field.
2199
 
2200
   The optional VISIBILITY is one of:
2201
 
2202
        '/0'    (VISIBILITY_PRIVATE)
2203
        '/1'    (VISIBILITY_PROTECTED)
2204
        '/2'    (VISIBILITY_PUBLIC)
2205
        '/9'    (VISIBILITY_IGNORE)
2206
 
2207
   or nothing, for C style fields with public visibility.
2208
 
2209
   Returns 1 for success, 0 for failure.  */
2210
 
2211
static bfd_boolean
2212
parse_stab_struct_fields (void *dhandle, struct stab_handle *info,
2213
                          const char **pp, debug_field **retp,
2214
                          bfd_boolean *staticsp)
2215
{
2216
  const char *orig;
2217
  const char *p;
2218
  debug_field *fields;
2219
  unsigned int c;
2220
  unsigned int alloc;
2221
 
2222
  *retp = NULL;
2223
  *staticsp = FALSE;
2224
 
2225
  orig = *pp;
2226
 
2227
  c = 0;
2228
  alloc = 10;
2229
  fields = (debug_field *) xmalloc (alloc * sizeof *fields);
2230
  while (**pp != ';')
2231
    {
2232
      /* FIXME: gdb checks os9k_stabs here.  */
2233
 
2234
      p = *pp;
2235
 
2236
      /* Add 1 to c to leave room for NULL pointer at end.  */
2237
      if (c + 1 >= alloc)
2238
        {
2239
          alloc += 10;
2240
          fields = ((debug_field *)
2241
                    xrealloc (fields, alloc * sizeof *fields));
2242
        }
2243
 
2244
      /* If it starts with CPLUS_MARKER it is a special abbreviation,
2245
         unless the CPLUS_MARKER is followed by an underscore, in
2246
         which case it is just the name of an anonymous type, which we
2247
         should handle like any other type name.  We accept either '$'
2248
         or '.', because a field name can never contain one of these
2249
         characters except as a CPLUS_MARKER.  */
2250
 
2251
      if ((*p == '$' || *p == '.') && p[1] != '_')
2252
        {
2253
          ++*pp;
2254
          if (! parse_stab_cpp_abbrev (dhandle, info, pp, fields + c))
2255
            return FALSE;
2256
          ++c;
2257
          continue;
2258
        }
2259
 
2260
      /* Look for the ':' that separates the field name from the field
2261
         values.  Data members are delimited by a single ':', while member
2262
         functions are delimited by a pair of ':'s.  When we hit the member
2263
         functions (if any), terminate scan loop and return.  */
2264
 
2265
      p = strchr (p, ':');
2266
      if (p == NULL)
2267
        {
2268
          bad_stab (orig);
2269
          return FALSE;
2270
        }
2271
 
2272
      if (p[1] == ':')
2273
        break;
2274
 
2275
      if (! parse_stab_one_struct_field (dhandle, info, pp, p, fields + c,
2276
                                         staticsp))
2277
        return FALSE;
2278
 
2279
      ++c;
2280
    }
2281
 
2282
  fields[c] = DEBUG_FIELD_NULL;
2283
 
2284
  *retp = fields;
2285
 
2286
  return TRUE;
2287
}
2288
 
2289
/* Special GNU C++ name.  */
2290
 
2291
static bfd_boolean
2292
parse_stab_cpp_abbrev (void *dhandle, struct stab_handle *info,
2293
                       const char **pp, debug_field *retp)
2294
{
2295
  const char *orig;
2296
  int cpp_abbrev;
2297
  debug_type context;
2298
  const char *name;
2299
  const char *type_name;
2300
  debug_type type;
2301
  bfd_vma bitpos;
2302
 
2303
  *retp = DEBUG_FIELD_NULL;
2304
 
2305
  orig = *pp;
2306
 
2307
  if (**pp != 'v')
2308
    {
2309
      bad_stab (*pp);
2310
      return FALSE;
2311
    }
2312
  ++*pp;
2313
 
2314
  cpp_abbrev = **pp;
2315
  ++*pp;
2316
 
2317
  /* At this point, *pp points to something like "22:23=*22...", where
2318
     the type number before the ':' is the "context" and everything
2319
     after is a regular type definition.  Lookup the type, find it's
2320
     name, and construct the field name.  */
2321
 
2322
  context = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2323
                             (debug_type **) NULL);
2324
  if (context == DEBUG_TYPE_NULL)
2325
    return FALSE;
2326
 
2327
  switch (cpp_abbrev)
2328
    {
2329
    case 'f':
2330
      /* $vf -- a virtual function table pointer.  */
2331
      name = "_vptr$";
2332
      break;
2333
    case 'b':
2334
      /* $vb -- a virtual bsomethingorother */
2335
      type_name = debug_get_type_name (dhandle, context);
2336
      if (type_name == NULL)
2337
        {
2338
          warn_stab (orig, _("unnamed $vb type"));
2339
          type_name = "FOO";
2340
        }
2341
      name = concat ("_vb$", type_name, (const char *) NULL);
2342
      break;
2343
    default:
2344
      warn_stab (orig, _("unrecognized C++ abbreviation"));
2345
      name = "INVALID_CPLUSPLUS_ABBREV";
2346
      break;
2347
    }
2348
 
2349
  if (**pp != ':')
2350
    {
2351
      bad_stab (orig);
2352
      return FALSE;
2353
    }
2354
  ++*pp;
2355
 
2356
  type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2357
                          (debug_type **) NULL);
2358
  if (**pp != ',')
2359
    {
2360
      bad_stab (orig);
2361
      return FALSE;
2362
    }
2363
  ++*pp;
2364
 
2365
  bitpos = parse_number (pp, (bfd_boolean *) NULL);
2366
  if (**pp != ';')
2367
    {
2368
      bad_stab (orig);
2369
      return FALSE;
2370
    }
2371
  ++*pp;
2372
 
2373
  *retp = debug_make_field (dhandle, name, type, bitpos, 0,
2374
                            DEBUG_VISIBILITY_PRIVATE);
2375
  if (*retp == DEBUG_FIELD_NULL)
2376
    return FALSE;
2377
 
2378
  return TRUE;
2379
}
2380
 
2381
/* Parse a single field in a struct or union.  */
2382
 
2383
static bfd_boolean
2384
parse_stab_one_struct_field (void *dhandle, struct stab_handle *info,
2385
                             const char **pp, const char *p,
2386
                             debug_field *retp, bfd_boolean *staticsp)
2387
{
2388
  const char *orig;
2389
  char *name;
2390
  enum debug_visibility visibility;
2391
  debug_type type;
2392
  bfd_vma bitpos;
2393
  bfd_vma bitsize;
2394
 
2395
  orig = *pp;
2396
 
2397
  /* FIXME: gdb checks ARM_DEMANGLING here.  */
2398
 
2399
  name = savestring (*pp, p - *pp);
2400
 
2401
  *pp = p + 1;
2402
 
2403
  if (**pp != '/')
2404
    visibility = DEBUG_VISIBILITY_PUBLIC;
2405
  else
2406
    {
2407
      ++*pp;
2408
      switch (**pp)
2409
        {
2410
        case '0':
2411
          visibility = DEBUG_VISIBILITY_PRIVATE;
2412
          break;
2413
        case '1':
2414
          visibility = DEBUG_VISIBILITY_PROTECTED;
2415
          break;
2416
        case '2':
2417
          visibility = DEBUG_VISIBILITY_PUBLIC;
2418
          break;
2419
        default:
2420
          warn_stab (orig, _("unknown visibility character for field"));
2421
          visibility = DEBUG_VISIBILITY_PUBLIC;
2422
          break;
2423
        }
2424
      ++*pp;
2425
    }
2426
 
2427
  type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2428
                          (debug_type **) NULL);
2429
  if (type == DEBUG_TYPE_NULL)
2430
    return FALSE;
2431
 
2432
  if (**pp == ':')
2433
    {
2434
      char *varname;
2435
 
2436
      /* This is a static class member.  */
2437
      ++*pp;
2438
      p = strchr (*pp, ';');
2439
      if (p == NULL)
2440
        {
2441
          bad_stab (orig);
2442
          return FALSE;
2443
        }
2444
 
2445
      varname = savestring (*pp, p - *pp);
2446
 
2447
      *pp = p + 1;
2448
 
2449
      *retp = debug_make_static_member (dhandle, name, type, varname,
2450
                                        visibility);
2451
      *staticsp = TRUE;
2452
 
2453
      return TRUE;
2454
    }
2455
 
2456
  if (**pp != ',')
2457
    {
2458
      bad_stab (orig);
2459
      return FALSE;
2460
    }
2461
  ++*pp;
2462
 
2463
  bitpos = parse_number (pp, (bfd_boolean *) NULL);
2464
  if (**pp != ',')
2465
    {
2466
      bad_stab (orig);
2467
      return FALSE;
2468
    }
2469
  ++*pp;
2470
 
2471
  bitsize = parse_number (pp, (bfd_boolean *) NULL);
2472
  if (**pp != ';')
2473
    {
2474
      bad_stab (orig);
2475
      return FALSE;
2476
    }
2477
  ++*pp;
2478
 
2479
  if (bitpos == 0 && bitsize == 0)
2480
    {
2481
      /* This can happen in two cases: (1) at least for gcc 2.4.5 or
2482
         so, it is a field which has been optimized out.  The correct
2483
         stab for this case is to use VISIBILITY_IGNORE, but that is a
2484
         recent invention.  (2) It is a 0-size array.  For example
2485
         union { int num; char str[0]; } foo.  Printing "<no value>"
2486
         for str in "p foo" is OK, since foo.str (and thus foo.str[3])
2487
         will continue to work, and a 0-size array as a whole doesn't
2488
         have any contents to print.
2489
 
2490
         I suspect this probably could also happen with gcc -gstabs
2491
         (not -gstabs+) for static fields, and perhaps other C++
2492
         extensions.  Hopefully few people use -gstabs with gdb, since
2493
         it is intended for dbx compatibility.  */
2494
      visibility = DEBUG_VISIBILITY_IGNORE;
2495
    }
2496
 
2497
  /* FIXME: gdb does some stuff here to mark fields as unpacked.  */
2498
 
2499
  *retp = debug_make_field (dhandle, name, type, bitpos, bitsize, visibility);
2500
 
2501
  return TRUE;
2502
}
2503
 
2504
/* Read member function stabs info for C++ classes.  The form of each member
2505
   function data is:
2506
 
2507
        NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2508
 
2509
   An example with two member functions is:
2510
 
2511
        afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2512
 
2513
   For the case of overloaded operators, the format is op$::*.funcs, where
2514
   $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2515
   name (such as `+=') and `.' marks the end of the operator name.  */
2516
 
2517
static bfd_boolean
2518
parse_stab_members (void *dhandle, struct stab_handle *info,
2519
                    const char *tagname, const char **pp,
2520
                    const int *typenums, debug_method **retp)
2521
{
2522
  const char *orig;
2523
  debug_method *methods;
2524
  unsigned int c;
2525
  unsigned int alloc;
2526
 
2527
  *retp = NULL;
2528
 
2529
  orig = *pp;
2530
 
2531
  alloc = 0;
2532
  methods = NULL;
2533
  c = 0;
2534
 
2535
  while (**pp != ';')
2536
    {
2537
      const char *p;
2538
      char *name;
2539
      debug_method_variant *variants;
2540
      unsigned int cvars;
2541
      unsigned int allocvars;
2542
      debug_type look_ahead_type;
2543
 
2544
      p = strchr (*pp, ':');
2545
      if (p == NULL || p[1] != ':')
2546
        break;
2547
 
2548
      /* FIXME: Some systems use something other than '$' here.  */
2549
      if ((*pp)[0] != 'o' || (*pp)[1] != 'p' || (*pp)[2] != '$')
2550
        {
2551
          name = savestring (*pp, p - *pp);
2552
          *pp = p + 2;
2553
        }
2554
      else
2555
        {
2556
          /* This is a completely weird case.  In order to stuff in the
2557
             names that might contain colons (the usual name delimiter),
2558
             Mike Tiemann defined a different name format which is
2559
             signalled if the identifier is "op$".  In that case, the
2560
             format is "op$::XXXX." where XXXX is the name.  This is
2561
             used for names like "+" or "=".  YUUUUUUUK!  FIXME!  */
2562
          *pp = p + 2;
2563
          for (p = *pp; *p != '.' && *p != '\0'; p++)
2564
            ;
2565
          if (*p != '.')
2566
            {
2567
              bad_stab (orig);
2568
              return FALSE;
2569
            }
2570
          name = savestring (*pp, p - *pp);
2571
          *pp = p + 1;
2572
        }
2573
 
2574
      allocvars = 10;
2575
      variants = ((debug_method_variant *)
2576
                  xmalloc (allocvars * sizeof *variants));
2577
      cvars = 0;
2578
 
2579
      look_ahead_type = DEBUG_TYPE_NULL;
2580
 
2581
      do
2582
        {
2583
          debug_type type;
2584
          bfd_boolean stub;
2585
          char *argtypes;
2586
          enum debug_visibility visibility;
2587
          bfd_boolean constp, volatilep, staticp;
2588
          bfd_vma voffset;
2589
          debug_type context;
2590
          const char *physname;
2591
          bfd_boolean varargs;
2592
 
2593
          if (look_ahead_type != DEBUG_TYPE_NULL)
2594
            {
2595
              /* g++ version 1 kludge */
2596
              type = look_ahead_type;
2597
              look_ahead_type = DEBUG_TYPE_NULL;
2598
            }
2599
          else
2600
            {
2601
              type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2602
                                      (debug_type **) NULL);
2603
              if (type == DEBUG_TYPE_NULL)
2604
                return FALSE;
2605
              if (**pp != ':')
2606
                {
2607
                  bad_stab (orig);
2608
                  return FALSE;
2609
                }
2610
            }
2611
 
2612
          ++*pp;
2613
          p = strchr (*pp, ';');
2614
          if (p == NULL)
2615
            {
2616
              bad_stab (orig);
2617
              return FALSE;
2618
            }
2619
 
2620
          stub = FALSE;
2621
          if (debug_get_type_kind (dhandle, type) == DEBUG_KIND_METHOD
2622
              && debug_get_parameter_types (dhandle, type, &varargs) == NULL)
2623
            stub = TRUE;
2624
 
2625
          argtypes = savestring (*pp, p - *pp);
2626
          *pp = p + 1;
2627
 
2628
          switch (**pp)
2629
            {
2630
            case '0':
2631
              visibility = DEBUG_VISIBILITY_PRIVATE;
2632
              break;
2633
            case '1':
2634
              visibility = DEBUG_VISIBILITY_PROTECTED;
2635
              break;
2636
            default:
2637
              visibility = DEBUG_VISIBILITY_PUBLIC;
2638
              break;
2639
            }
2640
          ++*pp;
2641
 
2642
          constp = FALSE;
2643
          volatilep = FALSE;
2644
          switch (**pp)
2645
            {
2646
            case 'A':
2647
              /* Normal function.  */
2648
              ++*pp;
2649
              break;
2650
            case 'B':
2651
              /* const member function.  */
2652
              constp = TRUE;
2653
              ++*pp;
2654
              break;
2655
            case 'C':
2656
              /* volatile member function.  */
2657
              volatilep = TRUE;
2658
              ++*pp;
2659
              break;
2660
            case 'D':
2661
              /* const volatile member function.  */
2662
              constp = TRUE;
2663
              volatilep = TRUE;
2664
              ++*pp;
2665
              break;
2666
            case '*':
2667
            case '?':
2668
            case '.':
2669
              /* File compiled with g++ version 1; no information.  */
2670
              break;
2671
            default:
2672
              warn_stab (orig, _("const/volatile indicator missing"));
2673
              break;
2674
            }
2675
 
2676
          staticp = FALSE;
2677
          switch (**pp)
2678
            {
2679
            case '*':
2680
              /* virtual member function, followed by index.  The sign
2681
                 bit is supposedly set to distinguish
2682
                 pointers-to-methods from virtual function indicies.  */
2683
              ++*pp;
2684
              voffset = parse_number (pp, (bfd_boolean *) NULL);
2685
              if (**pp != ';')
2686
                {
2687
                  bad_stab (orig);
2688
                  return FALSE;
2689
                }
2690
              ++*pp;
2691
              voffset &= 0x7fffffff;
2692
 
2693
              if (**pp == ';' || *pp == '\0')
2694
                {
2695
                  /* Must be g++ version 1.  */
2696
                  context = DEBUG_TYPE_NULL;
2697
                }
2698
              else
2699
                {
2700
                  /* Figure out from whence this virtual function
2701
                     came.  It may belong to virtual function table of
2702
                     one of its baseclasses.  */
2703
                  look_ahead_type = parse_stab_type (dhandle, info,
2704
                                                     (const char *) NULL,
2705
                                                     pp,
2706
                                                     (debug_type **) NULL);
2707
                  if (**pp == ':')
2708
                    {
2709
                      /* g++ version 1 overloaded methods.  */
2710
                      context = DEBUG_TYPE_NULL;
2711
                    }
2712
                  else
2713
                    {
2714
                      context = look_ahead_type;
2715
                      look_ahead_type = DEBUG_TYPE_NULL;
2716
                      if (**pp != ';')
2717
                        {
2718
                          bad_stab (orig);
2719
                          return FALSE;
2720
                        }
2721
                      ++*pp;
2722
                    }
2723
                }
2724
              break;
2725
 
2726
            case '?':
2727
              /* static member function.  */
2728
              ++*pp;
2729
              staticp = TRUE;
2730
              voffset = 0;
2731
              context = DEBUG_TYPE_NULL;
2732
              if (strncmp (argtypes, name, strlen (name)) != 0)
2733
                stub = TRUE;
2734
              break;
2735
 
2736
            default:
2737
              warn_stab (orig, "member function type missing");
2738
              voffset = 0;
2739
              context = DEBUG_TYPE_NULL;
2740
              break;
2741
 
2742
            case '.':
2743
              ++*pp;
2744
              voffset = 0;
2745
              context = DEBUG_TYPE_NULL;
2746
              break;
2747
            }
2748
 
2749
          /* If the type is not a stub, then the argtypes string is
2750
             the physical name of the function.  Otherwise the
2751
             argtypes string is the mangled form of the argument
2752
             types, and the full type and the physical name must be
2753
             extracted from them.  */
2754
          if (! stub)
2755
            physname = argtypes;
2756
          else
2757
            {
2758
              debug_type class_type, return_type;
2759
 
2760
              class_type = stab_find_type (dhandle, info, typenums);
2761
              if (class_type == DEBUG_TYPE_NULL)
2762
                return FALSE;
2763
              return_type = debug_get_return_type (dhandle, type);
2764
              if (return_type == DEBUG_TYPE_NULL)
2765
                {
2766
                  bad_stab (orig);
2767
                  return FALSE;
2768
                }
2769
              type = parse_stab_argtypes (dhandle, info, class_type, name,
2770
                                          tagname, return_type, argtypes,
2771
                                          constp, volatilep, &physname);
2772
              if (type == DEBUG_TYPE_NULL)
2773
                return FALSE;
2774
            }
2775
 
2776
          if (cvars + 1 >= allocvars)
2777
            {
2778
              allocvars += 10;
2779
              variants = ((debug_method_variant *)
2780
                          xrealloc (variants,
2781
                                    allocvars * sizeof *variants));
2782
            }
2783
 
2784
          if (! staticp)
2785
            variants[cvars] = debug_make_method_variant (dhandle, physname,
2786
                                                         type, visibility,
2787
                                                         constp, volatilep,
2788
                                                         voffset, context);
2789
          else
2790
            variants[cvars] = debug_make_static_method_variant (dhandle,
2791
                                                                physname,
2792
                                                                type,
2793
                                                                visibility,
2794
                                                                constp,
2795
                                                                volatilep);
2796
          if (variants[cvars] == DEBUG_METHOD_VARIANT_NULL)
2797
            return FALSE;
2798
 
2799
          ++cvars;
2800
        }
2801
      while (**pp != ';' && **pp != '\0');
2802
 
2803
      variants[cvars] = DEBUG_METHOD_VARIANT_NULL;
2804
 
2805
      if (**pp != '\0')
2806
        ++*pp;
2807
 
2808
      if (c + 1 >= alloc)
2809
        {
2810
          alloc += 10;
2811
          methods = ((debug_method *)
2812
                     xrealloc (methods, alloc * sizeof *methods));
2813
        }
2814
 
2815
      methods[c] = debug_make_method (dhandle, name, variants);
2816
 
2817
      ++c;
2818
    }
2819
 
2820
  if (methods != NULL)
2821
    methods[c] = DEBUG_METHOD_NULL;
2822
 
2823
  *retp = methods;
2824
 
2825
  return TRUE;
2826
}
2827
 
2828
/* Parse a string representing argument types for a method.  Stabs
2829
   tries to save space by packing argument types into a mangled
2830
   string.  This string should give us enough information to extract
2831
   both argument types and the physical name of the function, given
2832
   the tag name.  */
2833
 
2834
static debug_type
2835
parse_stab_argtypes (void *dhandle, struct stab_handle *info,
2836
                     debug_type class_type, const char *fieldname,
2837
                     const char *tagname, debug_type return_type,
2838
                     const char *argtypes, bfd_boolean constp,
2839
                     bfd_boolean volatilep, const char **pphysname)
2840
{
2841
  bfd_boolean is_full_physname_constructor;
2842
  bfd_boolean is_constructor;
2843
  bfd_boolean is_destructor;
2844
  bfd_boolean is_v3;
2845
  debug_type *args;
2846
  bfd_boolean varargs;
2847
  unsigned int physname_len = 0;
2848
 
2849
  /* Constructors are sometimes handled specially.  */
2850
  is_full_physname_constructor = ((argtypes[0] == '_'
2851
                                   && argtypes[1] == '_'
2852
                                   && (ISDIGIT (argtypes[2])
2853
                                       || argtypes[2] == 'Q'
2854
                                       || argtypes[2] == 't'))
2855
                                  || CONST_STRNEQ (argtypes, "__ct"));
2856
 
2857
  is_constructor = (is_full_physname_constructor
2858
                    || (tagname != NULL
2859
                        && strcmp (fieldname, tagname) == 0));
2860
  is_destructor = ((argtypes[0] == '_'
2861
                    && (argtypes[1] == '$' || argtypes[1] == '.')
2862
                    && argtypes[2] == '_')
2863
                   || CONST_STRNEQ (argtypes, "__dt"));
2864
  is_v3 = argtypes[0] == '_' && argtypes[1] == 'Z';
2865
 
2866
  if (is_destructor || is_full_physname_constructor || is_v3)
2867
    *pphysname = argtypes;
2868
  else
2869
    {
2870
      unsigned int len;
2871
      const char *const_prefix;
2872
      const char *volatile_prefix;
2873
      char buf[20];
2874
      unsigned int mangled_name_len;
2875
      char *physname;
2876
 
2877
      len = tagname == NULL ? 0 : strlen (tagname);
2878
      const_prefix = constp ? "C" : "";
2879
      volatile_prefix = volatilep ? "V" : "";
2880
 
2881
      if (len == 0)
2882
        sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
2883
      else if (tagname != NULL && strchr (tagname, '<') != NULL)
2884
        {
2885
          /* Template methods are fully mangled.  */
2886
          sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
2887
          tagname = NULL;
2888
          len = 0;
2889
        }
2890
      else
2891
        sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
2892
 
2893
      mangled_name_len = ((is_constructor ? 0 : strlen (fieldname))
2894
                          + strlen (buf)
2895
                          + len
2896
                          + strlen (argtypes)
2897
                          + 1);
2898
 
2899
      if (fieldname[0] == 'o'
2900
          && fieldname[1] == 'p'
2901
          && (fieldname[2] == '$' || fieldname[2] == '.'))
2902
        {
2903
          const char *opname;
2904
 
2905
          opname = cplus_mangle_opname (fieldname + 3, 0);
2906
          if (opname == NULL)
2907
            {
2908
              fprintf (stderr, _("No mangling for \"%s\"\n"), fieldname);
2909
              return DEBUG_TYPE_NULL;
2910
            }
2911
          mangled_name_len += strlen (opname);
2912
          physname = (char *) xmalloc (mangled_name_len);
2913
          strncpy (physname, fieldname, 3);
2914
          strcpy (physname + 3, opname);
2915
        }
2916
      else
2917
        {
2918
          physname = (char *) xmalloc (mangled_name_len);
2919
          if (is_constructor)
2920
            physname[0] = '\0';
2921
          else
2922
            strcpy (physname, fieldname);
2923
        }
2924
 
2925
      physname_len = strlen (physname);
2926
      strcat (physname, buf);
2927
      if (tagname != NULL)
2928
        strcat (physname, tagname);
2929
      strcat (physname, argtypes);
2930
 
2931
      *pphysname = physname;
2932
    }
2933
 
2934
  if (*argtypes == '\0' || is_destructor)
2935
    {
2936
      args = (debug_type *) xmalloc (sizeof *args);
2937
      *args = NULL;
2938
      return debug_make_method_type (dhandle, return_type, class_type, args,
2939
                                     FALSE);
2940
    }
2941
 
2942
  args = stab_demangle_argtypes (dhandle, info, *pphysname, &varargs, physname_len);
2943
  if (args == NULL)
2944
    return DEBUG_TYPE_NULL;
2945
 
2946
  return debug_make_method_type (dhandle, return_type, class_type, args,
2947
                                 varargs);
2948
}
2949
 
2950
/* The tail end of stabs for C++ classes that contain a virtual function
2951
   pointer contains a tilde, a %, and a type number.
2952
   The type number refers to the base class (possibly this class itself) which
2953
   contains the vtable pointer for the current class.
2954
 
2955
   This function is called when we have parsed all the method declarations,
2956
   so we can look for the vptr base class info.  */
2957
 
2958
static bfd_boolean
2959
parse_stab_tilde_field (void *dhandle, struct stab_handle *info,
2960
                        const char **pp, const int *typenums,
2961
                        debug_type *retvptrbase, bfd_boolean *retownvptr)
2962
{
2963
  const char *orig;
2964
  const char *hold;
2965
  int vtypenums[2];
2966
 
2967
  *retvptrbase = DEBUG_TYPE_NULL;
2968
  *retownvptr = FALSE;
2969
 
2970
  orig = *pp;
2971
 
2972
  /* If we are positioned at a ';', then skip it.  */
2973
  if (**pp == ';')
2974
    ++*pp;
2975
 
2976
  if (**pp != '~')
2977
    return TRUE;
2978
 
2979
  ++*pp;
2980
 
2981
  if (**pp == '=' || **pp == '+' || **pp == '-')
2982
    {
2983
      /* Obsolete flags that used to indicate the presence of
2984
         constructors and/or destructors.  */
2985
      ++*pp;
2986
    }
2987
 
2988
  if (**pp != '%')
2989
    return TRUE;
2990
 
2991
  ++*pp;
2992
 
2993
  hold = *pp;
2994
 
2995
  /* The next number is the type number of the base class (possibly
2996
     our own class) which supplies the vtable for this class.  */
2997
  if (! parse_stab_type_number (pp, vtypenums))
2998
    return FALSE;
2999
 
3000
  if (vtypenums[0] == typenums[0]
3001
      && vtypenums[1] == typenums[1])
3002
    *retownvptr = TRUE;
3003
  else
3004
    {
3005
      debug_type vtype;
3006
      const char *p;
3007
 
3008
      *pp = hold;
3009
 
3010
      vtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3011
                               (debug_type **) NULL);
3012
      for (p = *pp; *p != ';' && *p != '\0'; p++)
3013
        ;
3014
      if (*p != ';')
3015
        {
3016
          bad_stab (orig);
3017
          return FALSE;
3018
        }
3019
 
3020
      *retvptrbase = vtype;
3021
 
3022
      *pp = p + 1;
3023
    }
3024
 
3025
  return TRUE;
3026
}
3027
 
3028
/* Read a definition of an array type.  */
3029
 
3030
static debug_type
3031
parse_stab_array_type (void *dhandle, struct stab_handle *info,
3032
                       const char **pp, bfd_boolean stringp)
3033
{
3034
  const char *orig;
3035
  const char *p;
3036
  int typenums[2];
3037
  debug_type index_type;
3038
  bfd_boolean adjustable;
3039
  bfd_signed_vma lower, upper;
3040
  debug_type element_type;
3041
 
3042
  /* Format of an array type:
3043
     "ar<index type>;lower;upper;<array_contents_type>".
3044
     OS9000: "arlower,upper;<array_contents_type>".
3045
 
3046
     Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3047
     for these, produce a type like float[][].  */
3048
 
3049
  orig = *pp;
3050
 
3051
  /* FIXME: gdb checks os9k_stabs here.  */
3052
 
3053
  /* If the index type is type 0, we take it as int.  */
3054
  p = *pp;
3055
  if (! parse_stab_type_number (&p, typenums))
3056
    return DEBUG_TYPE_NULL;
3057
  if (typenums[0] == 0 && typenums[1] == 0 && **pp != '=')
3058
    {
3059
      index_type = debug_find_named_type (dhandle, "int");
3060
      if (index_type == DEBUG_TYPE_NULL)
3061
        {
3062
          index_type = debug_make_int_type (dhandle, 4, FALSE);
3063
          if (index_type == DEBUG_TYPE_NULL)
3064
            return DEBUG_TYPE_NULL;
3065
        }
3066
      *pp = p;
3067
    }
3068
  else
3069
    {
3070
      index_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3071
                                    (debug_type **) NULL);
3072
    }
3073
 
3074
  if (**pp != ';')
3075
    {
3076
      bad_stab (orig);
3077
      return DEBUG_TYPE_NULL;
3078
    }
3079
  ++*pp;
3080
 
3081
  adjustable = FALSE;
3082
 
3083
  if (! ISDIGIT (**pp) && **pp != '-')
3084
    {
3085
      ++*pp;
3086
      adjustable = TRUE;
3087
    }
3088
 
3089
  lower = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
3090
  if (**pp != ';')
3091
    {
3092
      bad_stab (orig);
3093
      return DEBUG_TYPE_NULL;
3094
    }
3095
  ++*pp;
3096
 
3097
  if (! ISDIGIT (**pp) && **pp != '-')
3098
    {
3099
      ++*pp;
3100
      adjustable = TRUE;
3101
    }
3102
 
3103
  upper = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
3104
  if (**pp != ';')
3105
    {
3106
      bad_stab (orig);
3107
      return DEBUG_TYPE_NULL;
3108
    }
3109
  ++*pp;
3110
 
3111
  element_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3112
                                  (debug_type **) NULL);
3113
  if (element_type == DEBUG_TYPE_NULL)
3114
    return DEBUG_TYPE_NULL;
3115
 
3116
  if (adjustable)
3117
    {
3118
      lower = 0;
3119
      upper = -1;
3120
    }
3121
 
3122
  return debug_make_array_type (dhandle, element_type, index_type, lower,
3123
                                upper, stringp);
3124
}
3125
 
3126
/* This struct holds information about files we have seen using
3127
   N_BINCL.  */
3128
 
3129
struct bincl_file
3130
{
3131
  /* The next N_BINCL file.  */
3132
  struct bincl_file *next;
3133
  /* The next N_BINCL on the stack.  */
3134
  struct bincl_file *next_stack;
3135
  /* The file name.  */
3136
  const char *name;
3137
  /* The hash value.  */
3138
  bfd_vma hash;
3139
  /* The file index.  */
3140
  unsigned int file;
3141
  /* The list of types defined in this file.  */
3142
  struct stab_types *file_types;
3143
};
3144
 
3145
/* Start a new N_BINCL file, pushing it onto the stack.  */
3146
 
3147
static void
3148
push_bincl (struct stab_handle *info, const char *name, bfd_vma hash)
3149
{
3150
  struct bincl_file *n;
3151
 
3152
  n = (struct bincl_file *) xmalloc (sizeof *n);
3153
  n->next = info->bincl_list;
3154
  n->next_stack = info->bincl_stack;
3155
  n->name = name;
3156
  n->hash = hash;
3157
  n->file = info->files;
3158
  n->file_types = NULL;
3159
  info->bincl_list = n;
3160
  info->bincl_stack = n;
3161
 
3162
  ++info->files;
3163
  info->file_types = ((struct stab_types **)
3164
                      xrealloc (info->file_types,
3165
                                (info->files
3166
                                 * sizeof *info->file_types)));
3167
  info->file_types[n->file] = NULL;
3168
}
3169
 
3170
/* Finish an N_BINCL file, at an N_EINCL, popping the name off the
3171
   stack.  */
3172
 
3173
static const char *
3174
pop_bincl (struct stab_handle *info)
3175
{
3176
  struct bincl_file *o;
3177
 
3178
  o = info->bincl_stack;
3179
  if (o == NULL)
3180
    return info->main_filename;
3181
  info->bincl_stack = o->next_stack;
3182
 
3183
  o->file_types = info->file_types[o->file];
3184
 
3185
  if (info->bincl_stack == NULL)
3186
    return info->main_filename;
3187
  return info->bincl_stack->name;
3188
}
3189
 
3190
/* Handle an N_EXCL: get the types from the corresponding N_BINCL.  */
3191
 
3192
static bfd_boolean
3193
find_excl (struct stab_handle *info, const char *name, bfd_vma hash)
3194
{
3195
  struct bincl_file *l;
3196
 
3197
  ++info->files;
3198
  info->file_types = ((struct stab_types **)
3199
                      xrealloc (info->file_types,
3200
                                (info->files
3201
                                 * sizeof *info->file_types)));
3202
 
3203
  for (l = info->bincl_list; l != NULL; l = l->next)
3204
    if (l->hash == hash && strcmp (l->name, name) == 0)
3205
      break;
3206
  if (l == NULL)
3207
    {
3208
      warn_stab (name, _("Undefined N_EXCL"));
3209
      info->file_types[info->files - 1] = NULL;
3210
      return TRUE;
3211
    }
3212
 
3213
  info->file_types[info->files - 1] = l->file_types;
3214
 
3215
  return TRUE;
3216
}
3217
 
3218
/* Handle a variable definition.  gcc emits variable definitions for a
3219
   block before the N_LBRAC, so we must hold onto them until we see
3220
   it.  The SunPRO compiler emits variable definitions after the
3221
   N_LBRAC, so we can call debug_record_variable immediately.  */
3222
 
3223
static bfd_boolean
3224
stab_record_variable (void *dhandle, struct stab_handle *info,
3225
                      const char *name, debug_type type,
3226
                      enum debug_var_kind kind, bfd_vma val)
3227
{
3228
  struct stab_pending_var *v;
3229
 
3230
  if ((kind == DEBUG_GLOBAL || kind == DEBUG_STATIC)
3231
      || ! info->within_function
3232
      || (info->gcc_compiled == 0 && info->n_opt_found))
3233
    return debug_record_variable (dhandle, name, type, kind, val);
3234
 
3235
  v = (struct stab_pending_var *) xmalloc (sizeof *v);
3236
  memset (v, 0, sizeof *v);
3237
 
3238
  v->next = info->pending;
3239
  v->name = name;
3240
  v->type = type;
3241
  v->kind = kind;
3242
  v->val = val;
3243
  info->pending = v;
3244
 
3245
  return TRUE;
3246
}
3247
 
3248
/* Emit pending variable definitions.  This is called after we see the
3249
   N_LBRAC that starts the block.  */
3250
 
3251
static bfd_boolean
3252
stab_emit_pending_vars (void *dhandle, struct stab_handle *info)
3253
{
3254
  struct stab_pending_var *v;
3255
 
3256
  v = info->pending;
3257
  while (v != NULL)
3258
    {
3259
      struct stab_pending_var *next;
3260
 
3261
      if (! debug_record_variable (dhandle, v->name, v->type, v->kind, v->val))
3262
        return FALSE;
3263
 
3264
      next = v->next;
3265
      free (v);
3266
      v = next;
3267
    }
3268
 
3269
  info->pending = NULL;
3270
 
3271
  return TRUE;
3272
}
3273
 
3274
/* Find the slot for a type in the database.  */
3275
 
3276
static debug_type *
3277
stab_find_slot (struct stab_handle *info, const int *typenums)
3278
{
3279
  int filenum;
3280
  int index;
3281
  struct stab_types **ps;
3282
 
3283
  filenum = typenums[0];
3284
  index = typenums[1];
3285
 
3286
  if (filenum < 0 || (unsigned int) filenum >= info->files)
3287
    {
3288
      fprintf (stderr, _("Type file number %d out of range\n"), filenum);
3289
      return NULL;
3290
    }
3291
  if (index < 0)
3292
    {
3293
      fprintf (stderr, _("Type index number %d out of range\n"), index);
3294
      return NULL;
3295
    }
3296
 
3297
  ps = info->file_types + filenum;
3298
 
3299
  while (index >= STAB_TYPES_SLOTS)
3300
    {
3301
      if (*ps == NULL)
3302
        {
3303
          *ps = (struct stab_types *) xmalloc (sizeof **ps);
3304
          memset (*ps, 0, sizeof **ps);
3305
        }
3306
      ps = &(*ps)->next;
3307
      index -= STAB_TYPES_SLOTS;
3308
    }
3309
  if (*ps == NULL)
3310
    {
3311
      *ps = (struct stab_types *) xmalloc (sizeof **ps);
3312
      memset (*ps, 0, sizeof **ps);
3313
    }
3314
 
3315
  return (*ps)->types + index;
3316
}
3317
 
3318
/* Find a type given a type number.  If the type has not been
3319
   allocated yet, create an indirect type.  */
3320
 
3321
static debug_type
3322
stab_find_type (void *dhandle, struct stab_handle *info, const int *typenums)
3323
{
3324
  debug_type *slot;
3325
 
3326
  if (typenums[0] == 0 && typenums[1] < 0)
3327
    {
3328
      /* A negative type number indicates an XCOFF builtin type.  */
3329
      return stab_xcoff_builtin_type (dhandle, info, typenums[1]);
3330
    }
3331
 
3332
  slot = stab_find_slot (info, typenums);
3333
  if (slot == NULL)
3334
    return DEBUG_TYPE_NULL;
3335
 
3336
  if (*slot == DEBUG_TYPE_NULL)
3337
    return debug_make_indirect_type (dhandle, slot, (const char *) NULL);
3338
 
3339
  return *slot;
3340
}
3341
 
3342
/* Record that a given type number refers to a given type.  */
3343
 
3344
static bfd_boolean
3345
stab_record_type (void *dhandle ATTRIBUTE_UNUSED, struct stab_handle *info,
3346
                  const int *typenums, debug_type type)
3347
{
3348
  debug_type *slot;
3349
 
3350
  slot = stab_find_slot (info, typenums);
3351
  if (slot == NULL)
3352
    return FALSE;
3353
 
3354
  /* gdb appears to ignore type redefinitions, so we do as well.  */
3355
 
3356
  *slot = type;
3357
 
3358
  return TRUE;
3359
}
3360
 
3361
/* Return an XCOFF builtin type.  */
3362
 
3363
static debug_type
3364
stab_xcoff_builtin_type (void *dhandle, struct stab_handle *info,
3365
                         int typenum)
3366
{
3367
  debug_type rettype;
3368
  const char *name;
3369
 
3370
  if (typenum >= 0 || typenum < -XCOFF_TYPE_COUNT)
3371
    {
3372
      fprintf (stderr, _("Unrecognized XCOFF type %d\n"), typenum);
3373
      return DEBUG_TYPE_NULL;
3374
    }
3375
  if (info->xcoff_types[-typenum] != NULL)
3376
    return info->xcoff_types[-typenum];
3377
 
3378
  switch (-typenum)
3379
    {
3380
    case 1:
3381
      /* The size of this and all the other types are fixed, defined
3382
         by the debugging format.  */
3383
      name = "int";
3384
      rettype = debug_make_int_type (dhandle, 4, FALSE);
3385
      break;
3386
    case 2:
3387
      name = "char";
3388
      rettype = debug_make_int_type (dhandle, 1, FALSE);
3389
      break;
3390
    case 3:
3391
      name = "short";
3392
      rettype = debug_make_int_type (dhandle, 2, FALSE);
3393
      break;
3394
    case 4:
3395
      name = "long";
3396
      rettype = debug_make_int_type (dhandle, 4, FALSE);
3397
      break;
3398
    case 5:
3399
      name = "unsigned char";
3400
      rettype = debug_make_int_type (dhandle, 1, TRUE);
3401
      break;
3402
    case 6:
3403
      name = "signed char";
3404
      rettype = debug_make_int_type (dhandle, 1, FALSE);
3405
      break;
3406
    case 7:
3407
      name = "unsigned short";
3408
      rettype = debug_make_int_type (dhandle, 2, TRUE);
3409
      break;
3410
    case 8:
3411
      name = "unsigned int";
3412
      rettype = debug_make_int_type (dhandle, 4, TRUE);
3413
      break;
3414
    case 9:
3415
      name = "unsigned";
3416
      rettype = debug_make_int_type (dhandle, 4, TRUE);
3417
    case 10:
3418
      name = "unsigned long";
3419
      rettype = debug_make_int_type (dhandle, 4, TRUE);
3420
      break;
3421
    case 11:
3422
      name = "void";
3423
      rettype = debug_make_void_type (dhandle);
3424
      break;
3425
    case 12:
3426
      /* IEEE single precision (32 bit).  */
3427
      name = "float";
3428
      rettype = debug_make_float_type (dhandle, 4);
3429
      break;
3430
    case 13:
3431
      /* IEEE double precision (64 bit).  */
3432
      name = "double";
3433
      rettype = debug_make_float_type (dhandle, 8);
3434
      break;
3435
    case 14:
3436
      /* This is an IEEE double on the RS/6000, and different machines
3437
         with different sizes for "long double" should use different
3438
         negative type numbers.  See stabs.texinfo.  */
3439
      name = "long double";
3440
      rettype = debug_make_float_type (dhandle, 8);
3441
      break;
3442
    case 15:
3443
      name = "integer";
3444
      rettype = debug_make_int_type (dhandle, 4, FALSE);
3445
      break;
3446
    case 16:
3447
      name = "boolean";
3448
      rettype = debug_make_bool_type (dhandle, 4);
3449
      break;
3450
    case 17:
3451
      name = "short real";
3452
      rettype = debug_make_float_type (dhandle, 4);
3453
      break;
3454
    case 18:
3455
      name = "real";
3456
      rettype = debug_make_float_type (dhandle, 8);
3457
      break;
3458
    case 19:
3459
      /* FIXME */
3460
      name = "stringptr";
3461
      rettype = NULL;
3462
      break;
3463
    case 20:
3464
      /* FIXME */
3465
      name = "character";
3466
      rettype = debug_make_int_type (dhandle, 1, TRUE);
3467
      break;
3468
    case 21:
3469
      name = "logical*1";
3470
      rettype = debug_make_bool_type (dhandle, 1);
3471
      break;
3472
    case 22:
3473
      name = "logical*2";
3474
      rettype = debug_make_bool_type (dhandle, 2);
3475
      break;
3476
    case 23:
3477
      name = "logical*4";
3478
      rettype = debug_make_bool_type (dhandle, 4);
3479
      break;
3480
    case 24:
3481
      name = "logical";
3482
      rettype = debug_make_bool_type (dhandle, 4);
3483
      break;
3484
    case 25:
3485
      /* Complex type consisting of two IEEE single precision values.  */
3486
      name = "complex";
3487
      rettype = debug_make_complex_type (dhandle, 8);
3488
      break;
3489
    case 26:
3490
      /* Complex type consisting of two IEEE double precision values.  */
3491
      name = "double complex";
3492
      rettype = debug_make_complex_type (dhandle, 16);
3493
      break;
3494
    case 27:
3495
      name = "integer*1";
3496
      rettype = debug_make_int_type (dhandle, 1, FALSE);
3497
      break;
3498
    case 28:
3499
      name = "integer*2";
3500
      rettype = debug_make_int_type (dhandle, 2, FALSE);
3501
      break;
3502
    case 29:
3503
      name = "integer*4";
3504
      rettype = debug_make_int_type (dhandle, 4, FALSE);
3505
      break;
3506
    case 30:
3507
      /* FIXME */
3508
      name = "wchar";
3509
      rettype = debug_make_int_type (dhandle, 2, FALSE);
3510
      break;
3511
    case 31:
3512
      name = "long long";
3513
      rettype = debug_make_int_type (dhandle, 8, FALSE);
3514
      break;
3515
    case 32:
3516
      name = "unsigned long long";
3517
      rettype = debug_make_int_type (dhandle, 8, TRUE);
3518
      break;
3519
    case 33:
3520
      name = "logical*8";
3521
      rettype = debug_make_bool_type (dhandle, 8);
3522
      break;
3523
    case 34:
3524
      name = "integer*8";
3525
      rettype = debug_make_int_type (dhandle, 8, FALSE);
3526
      break;
3527
    default:
3528
      abort ();
3529
    }
3530
 
3531
  rettype = debug_name_type (dhandle, name, rettype);
3532
 
3533
  info->xcoff_types[-typenum] = rettype;
3534
 
3535
  return rettype;
3536
}
3537
 
3538
/* Find or create a tagged type.  */
3539
 
3540
static debug_type
3541
stab_find_tagged_type (void *dhandle, struct stab_handle *info,
3542
                       const char *p, int len, enum debug_type_kind kind)
3543
{
3544
  char *name;
3545
  debug_type dtype;
3546
  struct stab_tag *st;
3547
 
3548
  name = savestring (p, len);
3549
 
3550
  /* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same
3551
     namespace.  This is right for C, and I don't know how to handle
3552
     other languages.  FIXME.  */
3553
  dtype = debug_find_tagged_type (dhandle, name, DEBUG_KIND_ILLEGAL);
3554
  if (dtype != DEBUG_TYPE_NULL)
3555
    {
3556
      free (name);
3557
      return dtype;
3558
    }
3559
 
3560
  /* We need to allocate an entry on the undefined tag list.  */
3561
  for (st = info->tags; st != NULL; st = st->next)
3562
    {
3563
      if (st->name[0] == name[0]
3564
          && strcmp (st->name, name) == 0)
3565
        {
3566
          if (st->kind == DEBUG_KIND_ILLEGAL)
3567
            st->kind = kind;
3568
          free (name);
3569
          break;
3570
        }
3571
    }
3572
  if (st == NULL)
3573
    {
3574
      st = (struct stab_tag *) xmalloc (sizeof *st);
3575
      memset (st, 0, sizeof *st);
3576
 
3577
      st->next = info->tags;
3578
      st->name = name;
3579
      st->kind = kind;
3580
      st->slot = DEBUG_TYPE_NULL;
3581
      st->type = debug_make_indirect_type (dhandle, &st->slot, name);
3582
      info->tags = st;
3583
    }
3584
 
3585
  return st->type;
3586
}
3587
 
3588
/* In order to get the correct argument types for a stubbed method, we
3589
   need to extract the argument types from a C++ mangled string.
3590
   Since the argument types can refer back to the return type, this
3591
   means that we must demangle the entire physical name.  In gdb this
3592
   is done by calling cplus_demangle and running the results back
3593
   through the C++ expression parser.  Since we have no expression
3594
   parser, we must duplicate much of the work of cplus_demangle here.
3595
 
3596
   We assume that GNU style demangling is used, since this is only
3597
   done for method stubs, and only g++ should output that form of
3598
   debugging information.  */
3599
 
3600
/* This structure is used to hold a pointer to type information which
3601
   demangling a string.  */
3602
 
3603
struct stab_demangle_typestring
3604
{
3605
  /* The start of the type.  This is not null terminated.  */
3606
  const char *typestring;
3607
  /* The length of the type.  */
3608
  unsigned int len;
3609
};
3610
 
3611
/* This structure is used to hold information while demangling a
3612
   string.  */
3613
 
3614
struct stab_demangle_info
3615
{
3616
  /* The debugging information handle.  */
3617
  void *dhandle;
3618
  /* The stab information handle.  */
3619
  struct stab_handle *info;
3620
  /* The array of arguments we are building.  */
3621
  debug_type *args;
3622
  /* Whether the method takes a variable number of arguments.  */
3623
  bfd_boolean varargs;
3624
  /* The array of types we have remembered.  */
3625
  struct stab_demangle_typestring *typestrings;
3626
  /* The number of typestrings.  */
3627
  unsigned int typestring_count;
3628
  /* The number of typestring slots we have allocated.  */
3629
  unsigned int typestring_alloc;
3630
};
3631
 
3632
static void stab_bad_demangle (const char *);
3633
static unsigned int stab_demangle_count (const char **);
3634
static bfd_boolean stab_demangle_get_count (const char **, unsigned int *);
3635
static bfd_boolean stab_demangle_prefix
3636
  (struct stab_demangle_info *, const char **, unsigned int);
3637
static bfd_boolean stab_demangle_function_name
3638
  (struct stab_demangle_info *, const char **, const char *);
3639
static bfd_boolean stab_demangle_signature
3640
  (struct stab_demangle_info *, const char **);
3641
static bfd_boolean stab_demangle_qualified
3642
  (struct stab_demangle_info *, const char **, debug_type *);
3643
static bfd_boolean stab_demangle_template
3644
  (struct stab_demangle_info *, const char **, char **);
3645
static bfd_boolean stab_demangle_class
3646
  (struct stab_demangle_info *, const char **, const char **);
3647
static bfd_boolean stab_demangle_args
3648
  (struct stab_demangle_info *, const char **, debug_type **, bfd_boolean *);
3649
static bfd_boolean stab_demangle_arg
3650
  (struct stab_demangle_info *, const char **, debug_type **,
3651
   unsigned int *, unsigned int *);
3652
static bfd_boolean stab_demangle_type
3653
  (struct stab_demangle_info *, const char **, debug_type *);
3654
static bfd_boolean stab_demangle_fund_type
3655
  (struct stab_demangle_info *, const char **, debug_type *);
3656
static bfd_boolean stab_demangle_remember_type
3657
  (struct stab_demangle_info *, const char *, int);
3658
 
3659
/* Warn about a bad demangling.  */
3660
 
3661
static void
3662
stab_bad_demangle (const char *s)
3663
{
3664
  fprintf (stderr, _("bad mangled name `%s'\n"), s);
3665
}
3666
 
3667
/* Get a count from a stab string.  */
3668
 
3669
static unsigned int
3670
stab_demangle_count (const char **pp)
3671
{
3672
  unsigned int count;
3673
 
3674
  count = 0;
3675
  while (ISDIGIT (**pp))
3676
    {
3677
      count *= 10;
3678
      count += **pp - '0';
3679
      ++*pp;
3680
    }
3681
  return count;
3682
}
3683
 
3684
/* Require a count in a string.  The count may be multiple digits, in
3685
   which case it must end in an underscore.  */
3686
 
3687
static bfd_boolean
3688
stab_demangle_get_count (const char **pp, unsigned int *pi)
3689
{
3690
  if (! ISDIGIT (**pp))
3691
    return FALSE;
3692
 
3693
  *pi = **pp - '0';
3694
  ++*pp;
3695
  if (ISDIGIT (**pp))
3696
    {
3697
      unsigned int count;
3698
      const char *p;
3699
 
3700
      count = *pi;
3701
      p = *pp;
3702
      do
3703
        {
3704
          count *= 10;
3705
          count += *p - '0';
3706
          ++p;
3707
        }
3708
      while (ISDIGIT (*p));
3709
      if (*p == '_')
3710
        {
3711
          *pp = p + 1;
3712
          *pi = count;
3713
        }
3714
    }
3715
 
3716
  return TRUE;
3717
}
3718
 
3719
/* This function demangles a physical name, returning a NULL
3720
   terminated array of argument types.  */
3721
 
3722
static debug_type *
3723
stab_demangle_argtypes (void *dhandle, struct stab_handle *info,
3724
                        const char *physname, bfd_boolean *pvarargs,
3725
                        unsigned int physname_len)
3726
{
3727
  struct stab_demangle_info minfo;
3728
 
3729
  /* Check for the g++ V3 ABI.  */
3730
  if (physname[0] == '_' && physname[1] == 'Z')
3731
    return stab_demangle_v3_argtypes (dhandle, info, physname, pvarargs);
3732
 
3733
  minfo.dhandle = dhandle;
3734
  minfo.info = info;
3735
  minfo.args = NULL;
3736
  minfo.varargs = FALSE;
3737
  minfo.typestring_alloc = 10;
3738
  minfo.typestrings = ((struct stab_demangle_typestring *)
3739
                       xmalloc (minfo.typestring_alloc
3740
                                * sizeof *minfo.typestrings));
3741
  minfo.typestring_count = 0;
3742
 
3743
  /* cplus_demangle checks for special GNU mangled forms, but we can't
3744
     see any of them in mangled method argument types.  */
3745
 
3746
  if (! stab_demangle_prefix (&minfo, &physname, physname_len))
3747
    goto error_return;
3748
 
3749
  if (*physname != '\0')
3750
    {
3751
      if (! stab_demangle_signature (&minfo, &physname))
3752
        goto error_return;
3753
    }
3754
 
3755
  free (minfo.typestrings);
3756
  minfo.typestrings = NULL;
3757
 
3758
  if (minfo.args == NULL)
3759
    fprintf (stderr, _("no argument types in mangled string\n"));
3760
 
3761
  *pvarargs = minfo.varargs;
3762
  return minfo.args;
3763
 
3764
 error_return:
3765
  if (minfo.typestrings != NULL)
3766
    free (minfo.typestrings);
3767
  return NULL;
3768
}
3769
 
3770
/* Demangle the prefix of the mangled name.  */
3771
 
3772
static bfd_boolean
3773
stab_demangle_prefix (struct stab_demangle_info *minfo, const char **pp,
3774
                      unsigned int physname_len)
3775
{
3776
  const char *scan;
3777
  unsigned int i;
3778
 
3779
  /* cplus_demangle checks for global constructors and destructors,
3780
     but we can't see them in mangled argument types.  */
3781
 
3782
  if (physname_len)
3783
    scan = *pp + physname_len;
3784
  else
3785
    {
3786
      /* Look for `__'.  */
3787
      scan = *pp;
3788
      do
3789
        scan = strchr (scan, '_');
3790
      while (scan != NULL && *++scan != '_');
3791
 
3792
      if (scan == NULL)
3793
        {
3794
          stab_bad_demangle (*pp);
3795
          return FALSE;
3796
        }
3797
 
3798
      --scan;
3799
 
3800
      /* We found `__'; move ahead to the last contiguous `__' pair.  */
3801
      i = strspn (scan, "_");
3802
      if (i > 2)
3803
        scan += i - 2;
3804
    }
3805
 
3806
  if (scan == *pp
3807
      && (ISDIGIT (scan[2])
3808
          || scan[2] == 'Q'
3809
          || scan[2] == 't'))
3810
    {
3811
      /* This is a GNU style constructor name.  */
3812
      *pp = scan + 2;
3813
      return TRUE;
3814
    }
3815
  else if (scan == *pp
3816
           && ! ISDIGIT (scan[2])
3817
           && scan[2] != 't')
3818
    {
3819
      /* Look for the `__' that separates the prefix from the
3820
         signature.  */
3821
      while (*scan == '_')
3822
        ++scan;
3823
      scan = strstr (scan, "__");
3824
      if (scan == NULL || scan[2] == '\0')
3825
        {
3826
          stab_bad_demangle (*pp);
3827
          return FALSE;
3828
        }
3829
 
3830
      return stab_demangle_function_name (minfo, pp, scan);
3831
    }
3832
  else if (scan[2] != '\0')
3833
    {
3834
      /* The name doesn't start with `__', but it does contain `__'.  */
3835
      return stab_demangle_function_name (minfo, pp, scan);
3836
    }
3837
  else
3838
    {
3839
      stab_bad_demangle (*pp);
3840
      return FALSE;
3841
    }
3842
  /*NOTREACHED*/
3843
}
3844
 
3845
/* Demangle a function name prefix.  The scan argument points to the
3846
   double underscore which separates the function name from the
3847
   signature.  */
3848
 
3849
static bfd_boolean
3850
stab_demangle_function_name (struct stab_demangle_info *minfo,
3851
                             const char **pp, const char *scan)
3852
{
3853
  const char *name;
3854
 
3855
  /* The string from *pp to scan is the name of the function.  We
3856
     don't care about the name, since we just looking for argument
3857
     types.  However, for conversion operators, the name may include a
3858
     type which we must remember in order to handle backreferences.  */
3859
 
3860
  name = *pp;
3861
  *pp = scan + 2;
3862
 
3863
  if (*pp - name >= 5
3864
           && CONST_STRNEQ (name, "type")
3865
           && (name[4] == '$' || name[4] == '.'))
3866
    {
3867
      const char *tem;
3868
 
3869
      /* This is a type conversion operator.  */
3870
      tem = name + 5;
3871
      if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
3872
        return FALSE;
3873
    }
3874
  else if (name[0] == '_'
3875
           && name[1] == '_'
3876
           && name[2] == 'o'
3877
           && name[3] == 'p')
3878
    {
3879
      const char *tem;
3880
 
3881
      /* This is a type conversion operator.  */
3882
      tem = name + 4;
3883
      if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
3884
        return FALSE;
3885
    }
3886
 
3887
  return TRUE;
3888
}
3889
 
3890
/* Demangle the signature.  This is where the argument types are
3891
   found.  */
3892
 
3893
static bfd_boolean
3894
stab_demangle_signature (struct stab_demangle_info *minfo, const char **pp)
3895
{
3896
  const char *orig;
3897
  bfd_boolean expect_func, func_done;
3898
  const char *hold;
3899
 
3900
  orig = *pp;
3901
 
3902
  expect_func = FALSE;
3903
  func_done = FALSE;
3904
  hold = NULL;
3905
 
3906
  while (**pp != '\0')
3907
    {
3908
      switch (**pp)
3909
        {
3910
        case 'Q':
3911
          hold = *pp;
3912
          if (! stab_demangle_qualified (minfo, pp, (debug_type *) NULL)
3913
              || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
3914
            return FALSE;
3915
          expect_func = TRUE;
3916
          hold = NULL;
3917
          break;
3918
 
3919
        case 'S':
3920
          /* Static member function.  FIXME: Can this happen?  */
3921
          if (hold == NULL)
3922
            hold = *pp;
3923
          ++*pp;
3924
          break;
3925
 
3926
        case 'C':
3927
          /* Const member function.  */
3928
          if (hold == NULL)
3929
            hold = *pp;
3930
          ++*pp;
3931
          break;
3932
 
3933
        case '0': case '1': case '2': case '3': case '4':
3934
        case '5': case '6': case '7': case '8': case '9':
3935
          if (hold == NULL)
3936
            hold = *pp;
3937
          if (! stab_demangle_class (minfo, pp, (const char **) NULL)
3938
              || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
3939
            return FALSE;
3940
          expect_func = TRUE;
3941
          hold = NULL;
3942
          break;
3943
 
3944
        case 'F':
3945
          /* Function.  I don't know if this actually happens with g++
3946
             output.  */
3947
          hold = NULL;
3948
          func_done = TRUE;
3949
          ++*pp;
3950
          if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3951
            return FALSE;
3952
          break;
3953
 
3954
        case 't':
3955
          /* Template.  */
3956
          if (hold == NULL)
3957
            hold = *pp;
3958
          if (! stab_demangle_template (minfo, pp, (char **) NULL)
3959
              || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
3960
            return FALSE;
3961
          hold = NULL;
3962
          expect_func = TRUE;
3963
          break;
3964
 
3965
        case '_':
3966
          /* At the outermost level, we cannot have a return type
3967
             specified, so if we run into another '_' at this point we
3968
             are dealing with a mangled name that is either bogus, or
3969
             has been mangled by some algorithm we don't know how to
3970
             deal with.  So just reject the entire demangling.  */
3971
          stab_bad_demangle (orig);
3972
          return FALSE;
3973
 
3974
        default:
3975
          /* Assume we have stumbled onto the first outermost function
3976
             argument token, and start processing args.  */
3977
          func_done = TRUE;
3978
          if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3979
            return FALSE;
3980
          break;
3981
        }
3982
 
3983
      if (expect_func)
3984
        {
3985
          func_done = TRUE;
3986
          if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3987
            return FALSE;
3988
        }
3989
    }
3990
 
3991
  if (! func_done)
3992
    {
3993
      /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
3994
         bar__3fooi is 'foo::bar(int)'.  We get here when we find the
3995
         first case, and need to ensure that the '(void)' gets added
3996
         to the current declp.  */
3997
      if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3998
        return FALSE;
3999
    }
4000
 
4001
  return TRUE;
4002
}
4003
 
4004
/* Demangle a qualified name, such as "Q25Outer5Inner" which is the
4005
   mangled form of "Outer::Inner".  */
4006
 
4007
static bfd_boolean
4008
stab_demangle_qualified (struct stab_demangle_info *minfo, const char **pp,
4009
                         debug_type *ptype)
4010
{
4011
  const char *orig;
4012
  const char *p;
4013
  unsigned int qualifiers;
4014
  debug_type context;
4015
 
4016
  orig = *pp;
4017
 
4018
  switch ((*pp)[1])
4019
    {
4020
    case '_':
4021
      /* GNU mangled name with more than 9 classes.  The count is
4022
         preceded by an underscore (to distinguish it from the <= 9
4023
         case) and followed by an underscore.  */
4024
      p = *pp + 2;
4025
      if (! ISDIGIT (*p) || *p == '0')
4026
        {
4027
          stab_bad_demangle (orig);
4028
          return FALSE;
4029
        }
4030
      qualifiers = atoi (p);
4031
      while (ISDIGIT (*p))
4032
        ++p;
4033
      if (*p != '_')
4034
        {
4035
          stab_bad_demangle (orig);
4036
          return FALSE;
4037
        }
4038
      *pp = p + 1;
4039
      break;
4040
 
4041
    case '1': case '2': case '3': case '4': case '5':
4042
    case '6': case '7': case '8': case '9':
4043
      qualifiers = (*pp)[1] - '0';
4044
      /* Skip an optional underscore after the count.  */
4045
      if ((*pp)[2] == '_')
4046
        ++*pp;
4047
      *pp += 2;
4048
      break;
4049
 
4050
    case '0':
4051
    default:
4052
      stab_bad_demangle (orig);
4053
      return FALSE;
4054
    }
4055
 
4056
  context = DEBUG_TYPE_NULL;
4057
 
4058
  /* Pick off the names.  */
4059
  while (qualifiers-- > 0)
4060
    {
4061
      if (**pp == '_')
4062
        ++*pp;
4063
      if (**pp == 't')
4064
        {
4065
          char *name;
4066
 
4067
          if (! stab_demangle_template (minfo, pp,
4068
                                        ptype != NULL ? &name : NULL))
4069
            return FALSE;
4070
 
4071
          if (ptype != NULL)
4072
            {
4073
              context = stab_find_tagged_type (minfo->dhandle, minfo->info,
4074
                                               name, strlen (name),
4075
                                               DEBUG_KIND_CLASS);
4076
              free (name);
4077
              if (context == DEBUG_TYPE_NULL)
4078
                return FALSE;
4079
            }
4080
        }
4081
      else
4082
        {
4083
          unsigned int len;
4084
 
4085
          len = stab_demangle_count (pp);
4086
          if (strlen (*pp) < len)
4087
            {
4088
              stab_bad_demangle (orig);
4089
              return FALSE;
4090
            }
4091
 
4092
          if (ptype != NULL)
4093
            {
4094
              const debug_field *fields;
4095
 
4096
              fields = NULL;
4097
              if (context != DEBUG_TYPE_NULL)
4098
                fields = debug_get_fields (minfo->dhandle, context);
4099
 
4100
              context = DEBUG_TYPE_NULL;
4101
 
4102
              if (fields != NULL)
4103
                {
4104
                  char *name;
4105
 
4106
                  /* Try to find the type by looking through the
4107
                     fields of context until we find a field with the
4108
                     same type.  This ought to work for a class
4109
                     defined within a class, but it won't work for,
4110
                     e.g., an enum defined within a class.  stabs does
4111
                     not give us enough information to figure out the
4112
                     latter case.  */
4113
 
4114
                  name = savestring (*pp, len);
4115
 
4116
                  for (; *fields != DEBUG_FIELD_NULL; fields++)
4117
                    {
4118
                      debug_type ft;
4119
                      const char *dn;
4120
 
4121
                      ft = debug_get_field_type (minfo->dhandle, *fields);
4122
                      if (ft == NULL)
4123
                        return FALSE;
4124
                      dn = debug_get_type_name (minfo->dhandle, ft);
4125
                      if (dn != NULL && strcmp (dn, name) == 0)
4126
                        {
4127
                          context = ft;
4128
                          break;
4129
                        }
4130
                    }
4131
 
4132
                  free (name);
4133
                }
4134
 
4135
              if (context == DEBUG_TYPE_NULL)
4136
                {
4137
                  /* We have to fall back on finding the type by name.
4138
                     If there are more types to come, then this must
4139
                     be a class.  Otherwise, it could be anything.  */
4140
 
4141
                  if (qualifiers == 0)
4142
                    {
4143
                      char *name;
4144
 
4145
                      name = savestring (*pp, len);
4146
                      context = debug_find_named_type (minfo->dhandle,
4147
                                                       name);
4148
                      free (name);
4149
                    }
4150
 
4151
                  if (context == DEBUG_TYPE_NULL)
4152
                    {
4153
                      context = stab_find_tagged_type (minfo->dhandle,
4154
                                                       minfo->info,
4155
                                                       *pp, len,
4156
                                                       (qualifiers == 0
4157
                                                        ? DEBUG_KIND_ILLEGAL
4158
                                                        : DEBUG_KIND_CLASS));
4159
                      if (context == DEBUG_TYPE_NULL)
4160
                        return FALSE;
4161
                    }
4162
                }
4163
            }
4164
 
4165
          *pp += len;
4166
        }
4167
    }
4168
 
4169
  if (ptype != NULL)
4170
    *ptype = context;
4171
 
4172
  return TRUE;
4173
}
4174
 
4175
/* Demangle a template.  If PNAME is not NULL, this sets *PNAME to a
4176
   string representation of the template.  */
4177
 
4178
static bfd_boolean
4179
stab_demangle_template (struct stab_demangle_info *minfo, const char **pp,
4180
                        char **pname)
4181
{
4182
  const char *orig;
4183
  unsigned int r, i;
4184
 
4185
  orig = *pp;
4186
 
4187
  ++*pp;
4188
 
4189
  /* Skip the template name.  */
4190
  r = stab_demangle_count (pp);
4191
  if (r == 0 || strlen (*pp) < r)
4192
    {
4193
      stab_bad_demangle (orig);
4194
      return FALSE;
4195
    }
4196
  *pp += r;
4197
 
4198
  /* Get the size of the parameter list.  */
4199
  if (stab_demangle_get_count (pp, &r) == 0)
4200
    {
4201
      stab_bad_demangle (orig);
4202
      return FALSE;
4203
    }
4204
 
4205
  for (i = 0; i < r; i++)
4206
    {
4207
      if (**pp == 'Z')
4208
        {
4209
          /* This is a type parameter.  */
4210
          ++*pp;
4211
          if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
4212
            return FALSE;
4213
        }
4214
      else
4215
        {
4216
          const char *old_p;
4217
          bfd_boolean pointerp, realp, integralp, charp, boolp;
4218
          bfd_boolean done;
4219
 
4220
          old_p = *pp;
4221
          pointerp = FALSE;
4222
          realp = FALSE;
4223
          integralp = FALSE;
4224
          charp = FALSE;
4225
          boolp = FALSE;
4226
          done = FALSE;
4227
 
4228
          /* This is a value parameter.  */
4229
 
4230
          if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
4231
            return FALSE;
4232
 
4233
          while (*old_p != '\0' && ! done)
4234
            {
4235
              switch (*old_p)
4236
                {
4237
                case 'P':
4238
                case 'p':
4239
                case 'R':
4240
                  pointerp = TRUE;
4241
                  done = TRUE;
4242
                  break;
4243
                case 'C':       /* Const.  */
4244
                case 'S':       /* Signed.  */
4245
                case 'U':       /* Unsigned.  */
4246
                case 'V':       /* Volatile.  */
4247
                case 'F':       /* Function.  */
4248
                case 'M':       /* Member function.  */
4249
                case 'O':       /* ??? */
4250
                  ++old_p;
4251
                  break;
4252
                case 'Q':       /* Qualified name.  */
4253
                  integralp = TRUE;
4254
                  done = TRUE;
4255
                  break;
4256
                case 'T':       /* Remembered type.  */
4257
                  abort ();
4258
                case 'v':       /* Void.  */
4259
                  abort ();
4260
                case 'x':       /* Long long.  */
4261
                case 'l':       /* Long.  */
4262
                case 'i':       /* Int.  */
4263
                case 's':       /* Short.  */
4264
                case 'w':       /* Wchar_t.  */
4265
                  integralp = TRUE;
4266
                  done = TRUE;
4267
                  break;
4268
                case 'b':       /* Bool.  */
4269
                  boolp = TRUE;
4270
                  done = TRUE;
4271
                  break;
4272
                case 'c':       /* Char.  */
4273
                  charp = TRUE;
4274
                  done = TRUE;
4275
                  break;
4276
                case 'r':       /* Long double.  */
4277
                case 'd':       /* Double.  */
4278
                case 'f':       /* Float.  */
4279
                  realp = TRUE;
4280
                  done = TRUE;
4281
                  break;
4282
                default:
4283
                  /* Assume it's a user defined integral type.  */
4284
                  integralp = TRUE;
4285
                  done = TRUE;
4286
                  break;
4287
                }
4288
            }
4289
 
4290
          if (integralp)
4291
            {
4292
              if (**pp == 'm')
4293
                ++*pp;
4294
              while (ISDIGIT (**pp))
4295
                ++*pp;
4296
            }
4297
          else if (charp)
4298
            {
4299
              unsigned int val;
4300
 
4301
              if (**pp == 'm')
4302
                ++*pp;
4303
              val = stab_demangle_count (pp);
4304
              if (val == 0)
4305
                {
4306
                  stab_bad_demangle (orig);
4307
                  return FALSE;
4308
                }
4309
            }
4310
          else if (boolp)
4311
            {
4312
              unsigned int val;
4313
 
4314
              val = stab_demangle_count (pp);
4315
              if (val != 0 && val != 1)
4316
                {
4317
                  stab_bad_demangle (orig);
4318
                  return FALSE;
4319
                }
4320
            }
4321
          else if (realp)
4322
            {
4323
              if (**pp == 'm')
4324
                ++*pp;
4325
              while (ISDIGIT (**pp))
4326
                ++*pp;
4327
              if (**pp == '.')
4328
                {
4329
                  ++*pp;
4330
                  while (ISDIGIT (**pp))
4331
                    ++*pp;
4332
                }
4333
              if (**pp == 'e')
4334
                {
4335
                  ++*pp;
4336
                  while (ISDIGIT (**pp))
4337
                    ++*pp;
4338
                }
4339
            }
4340
          else if (pointerp)
4341
            {
4342
              unsigned int len;
4343
 
4344
              len = stab_demangle_count (pp);
4345
              if (len == 0)
4346
                {
4347
                  stab_bad_demangle (orig);
4348
                  return FALSE;
4349
                }
4350
              *pp += len;
4351
            }
4352
        }
4353
    }
4354
 
4355
  /* We can translate this to a string fairly easily by invoking the
4356
     regular demangling routine.  */
4357
  if (pname != NULL)
4358
    {
4359
      char *s1, *s2, *s3, *s4 = NULL;
4360
      char *from, *to;
4361
 
4362
      s1 = savestring (orig, *pp - orig);
4363
 
4364
      s2 = concat ("NoSuchStrinG__", s1, (const char *) NULL);
4365
 
4366
      free (s1);
4367
 
4368
      s3 = cplus_demangle (s2, DMGL_ANSI);
4369
 
4370
      free (s2);
4371
 
4372
      if (s3 != NULL)
4373
        s4 = strstr (s3, "::NoSuchStrinG");
4374
      if (s3 == NULL || s4 == NULL)
4375
        {
4376
          stab_bad_demangle (orig);
4377
          if (s3 != NULL)
4378
            free (s3);
4379
          return FALSE;
4380
        }
4381
 
4382
      /* Eliminating all spaces, except those between > characters,
4383
         makes it more likely that the demangled name will match the
4384
         name which g++ used as the structure name.  */
4385
      for (from = to = s3; from != s4; ++from)
4386
        if (*from != ' '
4387
            || (from[1] == '>' && from > s3 && from[-1] == '>'))
4388
          *to++ = *from;
4389
 
4390
      *pname = savestring (s3, to - s3);
4391
 
4392
      free (s3);
4393
    }
4394
 
4395
  return TRUE;
4396
}
4397
 
4398
/* Demangle a class name.  */
4399
 
4400
static bfd_boolean
4401
stab_demangle_class (struct stab_demangle_info *minfo ATTRIBUTE_UNUSED,
4402
                     const char **pp, const char **pstart)
4403
{
4404
  const char *orig;
4405
  unsigned int n;
4406
 
4407
  orig = *pp;
4408
 
4409
  n = stab_demangle_count (pp);
4410
  if (strlen (*pp) < n)
4411
    {
4412
      stab_bad_demangle (orig);
4413
      return FALSE;
4414
    }
4415
 
4416
  if (pstart != NULL)
4417
    *pstart = *pp;
4418
 
4419
  *pp += n;
4420
 
4421
  return TRUE;
4422
}
4423
 
4424
/* Demangle function arguments.  If the pargs argument is not NULL, it
4425
   is set to a NULL terminated array holding the arguments.  */
4426
 
4427
static bfd_boolean
4428
stab_demangle_args (struct stab_demangle_info *minfo, const char **pp,
4429
                    debug_type **pargs, bfd_boolean *pvarargs)
4430
{
4431
  const char *orig;
4432
  unsigned int alloc, count;
4433
 
4434
  orig = *pp;
4435
 
4436
  alloc = 10;
4437
  if (pargs != NULL)
4438
    {
4439
      *pargs = (debug_type *) xmalloc (alloc * sizeof **pargs);
4440
      *pvarargs = FALSE;
4441
    }
4442
  count = 0;
4443
 
4444
  while (**pp != '_' && **pp != '\0' && **pp != 'e')
4445
    {
4446
      if (**pp == 'N' || **pp == 'T')
4447
        {
4448
          char temptype;
4449
          unsigned int r, t;
4450
 
4451
          temptype = **pp;
4452
          ++*pp;
4453
 
4454
          if (temptype == 'T')
4455
            r = 1;
4456
          else
4457
            {
4458
              if (! stab_demangle_get_count (pp, &r))
4459
                {
4460
                  stab_bad_demangle (orig);
4461
                  return FALSE;
4462
                }
4463
            }
4464
 
4465
          if (! stab_demangle_get_count (pp, &t))
4466
            {
4467
              stab_bad_demangle (orig);
4468
              return FALSE;
4469
            }
4470
 
4471
          if (t >= minfo->typestring_count)
4472
            {
4473
              stab_bad_demangle (orig);
4474
              return FALSE;
4475
            }
4476
          while (r-- > 0)
4477
            {
4478
              const char *tem;
4479
 
4480
              tem = minfo->typestrings[t].typestring;
4481
              if (! stab_demangle_arg (minfo, &tem, pargs, &count, &alloc))
4482
                return FALSE;
4483
            }
4484
        }
4485
      else
4486
        {
4487
          if (! stab_demangle_arg (minfo, pp, pargs, &count, &alloc))
4488
            return FALSE;
4489
        }
4490
    }
4491
 
4492
  if (pargs != NULL)
4493
    (*pargs)[count] = DEBUG_TYPE_NULL;
4494
 
4495
  if (**pp == 'e')
4496
    {
4497
      if (pargs != NULL)
4498
        *pvarargs = TRUE;
4499
      ++*pp;
4500
    }
4501
 
4502
  return TRUE;
4503
}
4504
 
4505
/* Demangle a single argument.  */
4506
 
4507
static bfd_boolean
4508
stab_demangle_arg (struct stab_demangle_info *minfo, const char **pp,
4509
                   debug_type **pargs, unsigned int *pcount,
4510
                   unsigned int *palloc)
4511
{
4512
  const char *start;
4513
  debug_type type;
4514
 
4515
  start = *pp;
4516
  if (! stab_demangle_type (minfo, pp,
4517
                            pargs == NULL ? (debug_type *) NULL : &type)
4518
      || ! stab_demangle_remember_type (minfo, start, *pp - start))
4519
    return FALSE;
4520
 
4521
  if (pargs != NULL)
4522
    {
4523
      if (type == DEBUG_TYPE_NULL)
4524
        return FALSE;
4525
 
4526
      if (*pcount + 1 >= *palloc)
4527
        {
4528
          *palloc += 10;
4529
          *pargs = ((debug_type *)
4530
                    xrealloc (*pargs, *palloc * sizeof **pargs));
4531
        }
4532
      (*pargs)[*pcount] = type;
4533
      ++*pcount;
4534
    }
4535
 
4536
  return TRUE;
4537
}
4538
 
4539
/* Demangle a type.  If the ptype argument is not NULL, *ptype is set
4540
   to the newly allocated type.  */
4541
 
4542
static bfd_boolean
4543
stab_demangle_type (struct stab_demangle_info *minfo, const char **pp,
4544
                    debug_type *ptype)
4545
{
4546
  const char *orig;
4547
 
4548
  orig = *pp;
4549
 
4550
  switch (**pp)
4551
    {
4552
    case 'P':
4553
    case 'p':
4554
      /* A pointer type.  */
4555
      ++*pp;
4556
      if (! stab_demangle_type (minfo, pp, ptype))
4557
        return FALSE;
4558
      if (ptype != NULL)
4559
        *ptype = debug_make_pointer_type (minfo->dhandle, *ptype);
4560
      break;
4561
 
4562
    case 'R':
4563
      /* A reference type.  */
4564
      ++*pp;
4565
      if (! stab_demangle_type (minfo, pp, ptype))
4566
        return FALSE;
4567
      if (ptype != NULL)
4568
        *ptype = debug_make_reference_type (minfo->dhandle, *ptype);
4569
      break;
4570
 
4571
    case 'A':
4572
      /* An array.  */
4573
      {
4574
        unsigned long high;
4575
 
4576
        ++*pp;
4577
        high = 0;
4578
        while (**pp != '\0' && **pp != '_')
4579
          {
4580
            if (! ISDIGIT (**pp))
4581
              {
4582
                stab_bad_demangle (orig);
4583
                return FALSE;
4584
              }
4585
            high *= 10;
4586
            high += **pp - '0';
4587
            ++*pp;
4588
          }
4589
        if (**pp != '_')
4590
          {
4591
            stab_bad_demangle (orig);
4592
            return FALSE;
4593
          }
4594
        ++*pp;
4595
 
4596
        if (! stab_demangle_type (minfo, pp, ptype))
4597
          return FALSE;
4598
        if (ptype != NULL)
4599
          {
4600
            debug_type int_type;
4601
 
4602
            int_type = debug_find_named_type (minfo->dhandle, "int");
4603
            if (int_type == NULL)
4604
              int_type = debug_make_int_type (minfo->dhandle, 4, FALSE);
4605
            *ptype = debug_make_array_type (minfo->dhandle, *ptype, int_type,
4606
                                            0, high, FALSE);
4607
          }
4608
      }
4609
      break;
4610
 
4611
    case 'T':
4612
      /* A back reference to a remembered type.  */
4613
      {
4614
        unsigned int i;
4615
        const char *p;
4616
 
4617
        ++*pp;
4618
        if (! stab_demangle_get_count (pp, &i))
4619
          {
4620
            stab_bad_demangle (orig);
4621
            return FALSE;
4622
          }
4623
        if (i >= minfo->typestring_count)
4624
          {
4625
            stab_bad_demangle (orig);
4626
            return FALSE;
4627
          }
4628
        p = minfo->typestrings[i].typestring;
4629
        if (! stab_demangle_type (minfo, &p, ptype))
4630
          return FALSE;
4631
      }
4632
      break;
4633
 
4634
    case 'F':
4635
      /* A function.  */
4636
      {
4637
        debug_type *args;
4638
        bfd_boolean varargs;
4639
 
4640
        ++*pp;
4641
        if (! stab_demangle_args (minfo, pp,
4642
                                  (ptype == NULL
4643
                                   ? (debug_type **) NULL
4644
                                   : &args),
4645
                                  (ptype == NULL
4646
                                   ? (bfd_boolean *) NULL
4647
                                   : &varargs)))
4648
          return FALSE;
4649
        if (**pp != '_')
4650
          {
4651
            /* cplus_demangle will accept a function without a return
4652
               type, but I don't know when that will happen, or what
4653
               to do if it does.  */
4654
            stab_bad_demangle (orig);
4655
            return FALSE;
4656
          }
4657
        ++*pp;
4658
        if (! stab_demangle_type (minfo, pp, ptype))
4659
          return FALSE;
4660
        if (ptype != NULL)
4661
          *ptype = debug_make_function_type (minfo->dhandle, *ptype, args,
4662
                                             varargs);
4663
 
4664
      }
4665
      break;
4666
 
4667
    case 'M':
4668
    case 'O':
4669
      {
4670
        bfd_boolean memberp, constp, volatilep;
4671
        debug_type class_type = DEBUG_TYPE_NULL;
4672
        debug_type *args;
4673
        bfd_boolean varargs;
4674
        unsigned int n;
4675
        const char *name;
4676
 
4677
        memberp = **pp == 'M';
4678
        constp = FALSE;
4679
        volatilep = FALSE;
4680
        args = NULL;
4681
        varargs = FALSE;
4682
 
4683
        ++*pp;
4684
        if (ISDIGIT (**pp))
4685
          {
4686
            n = stab_demangle_count (pp);
4687
            if (strlen (*pp) < n)
4688
              {
4689
                stab_bad_demangle (orig);
4690
                return FALSE;
4691
              }
4692
            name = *pp;
4693
            *pp += n;
4694
 
4695
            if (ptype != NULL)
4696
              {
4697
                class_type = stab_find_tagged_type (minfo->dhandle,
4698
                                                    minfo->info,
4699
                                                    name, (int) n,
4700
                                                    DEBUG_KIND_CLASS);
4701
                if (class_type == DEBUG_TYPE_NULL)
4702
                  return FALSE;
4703
              }
4704
          }
4705
        else if (**pp == 'Q')
4706
          {
4707
            if (! stab_demangle_qualified (minfo, pp,
4708
                                           (ptype == NULL
4709
                                            ? (debug_type *) NULL
4710
                                            : &class_type)))
4711
              return FALSE;
4712
          }
4713
        else
4714
          {
4715
            stab_bad_demangle (orig);
4716
            return FALSE;
4717
          }
4718
 
4719
        if (memberp)
4720
          {
4721
            if (**pp == 'C')
4722
              {
4723
                constp = TRUE;
4724
                ++*pp;
4725
              }
4726
            else if (**pp == 'V')
4727
              {
4728
                volatilep = TRUE;
4729
                ++*pp;
4730
              }
4731
            if (**pp != 'F')
4732
              {
4733
                stab_bad_demangle (orig);
4734
                return FALSE;
4735
              }
4736
            ++*pp;
4737
            if (! stab_demangle_args (minfo, pp,
4738
                                      (ptype == NULL
4739
                                       ? (debug_type **) NULL
4740
                                       : &args),
4741
                                      (ptype == NULL
4742
                                       ? (bfd_boolean *) NULL
4743
                                       : &varargs)))
4744
              return FALSE;
4745
          }
4746
 
4747
        if (**pp != '_')
4748
          {
4749
            stab_bad_demangle (orig);
4750
            return FALSE;
4751
          }
4752
        ++*pp;
4753
 
4754
        if (! stab_demangle_type (minfo, pp, ptype))
4755
          return FALSE;
4756
 
4757
        if (ptype != NULL)
4758
          {
4759
            if (! memberp)
4760
              *ptype = debug_make_offset_type (minfo->dhandle, class_type,
4761
                                               *ptype);
4762
            else
4763
              {
4764
                /* FIXME: We have no way to record constp or
4765
                   volatilep.  */
4766
                *ptype = debug_make_method_type (minfo->dhandle, *ptype,
4767
                                                 class_type, args, varargs);
4768
              }
4769
          }
4770
      }
4771
      break;
4772
 
4773
    case 'G':
4774
      ++*pp;
4775
      if (! stab_demangle_type (minfo, pp, ptype))
4776
        return FALSE;
4777
      break;
4778
 
4779
    case 'C':
4780
      ++*pp;
4781
      if (! stab_demangle_type (minfo, pp, ptype))
4782
        return FALSE;
4783
      if (ptype != NULL)
4784
        *ptype = debug_make_const_type (minfo->dhandle, *ptype);
4785
      break;
4786
 
4787
    case 'Q':
4788
      {
4789
        const char *hold;
4790
 
4791
        hold = *pp;
4792
        if (! stab_demangle_qualified (minfo, pp, ptype))
4793
          return FALSE;
4794
      }
4795
      break;
4796
 
4797
    default:
4798
      if (! stab_demangle_fund_type (minfo, pp, ptype))
4799
        return FALSE;
4800
      break;
4801
    }
4802
 
4803
  return TRUE;
4804
}
4805
 
4806
/* Demangle a fundamental type.  If the ptype argument is not NULL,
4807
   *ptype is set to the newly allocated type.  */
4808
 
4809
static bfd_boolean
4810
stab_demangle_fund_type (struct stab_demangle_info *minfo, const char **pp,
4811
                         debug_type *ptype)
4812
{
4813
  const char *orig;
4814
  bfd_boolean constp, volatilep, unsignedp, signedp;
4815
  bfd_boolean done;
4816
 
4817
  orig = *pp;
4818
 
4819
  constp = FALSE;
4820
  volatilep = FALSE;
4821
  unsignedp = FALSE;
4822
  signedp = FALSE;
4823
 
4824
  done = FALSE;
4825
  while (! done)
4826
    {
4827
      switch (**pp)
4828
        {
4829
        case 'C':
4830
          constp = TRUE;
4831
          ++*pp;
4832
          break;
4833
 
4834
        case 'U':
4835
          unsignedp = TRUE;
4836
          ++*pp;
4837
          break;
4838
 
4839
        case 'S':
4840
          signedp = TRUE;
4841
          ++*pp;
4842
          break;
4843
 
4844
        case 'V':
4845
          volatilep = TRUE;
4846
          ++*pp;
4847
          break;
4848
 
4849
        default:
4850
          done = TRUE;
4851
          break;
4852
        }
4853
    }
4854
 
4855
  switch (**pp)
4856
    {
4857
    case '\0':
4858
    case '_':
4859
      /* cplus_demangle permits this, but I don't know what it means.  */
4860
      stab_bad_demangle (orig);
4861
      break;
4862
 
4863
    case 'v': /* void */
4864
      if (ptype != NULL)
4865
        {
4866
          *ptype = debug_find_named_type (minfo->dhandle, "void");
4867
          if (*ptype == DEBUG_TYPE_NULL)
4868
            *ptype = debug_make_void_type (minfo->dhandle);
4869
        }
4870
      ++*pp;
4871
      break;
4872
 
4873
    case 'x': /* long long */
4874
      if (ptype != NULL)
4875
        {
4876
          *ptype = debug_find_named_type (minfo->dhandle,
4877
                                          (unsignedp
4878
                                           ? "long long unsigned int"
4879
                                           : "long long int"));
4880
          if (*ptype == DEBUG_TYPE_NULL)
4881
            *ptype = debug_make_int_type (minfo->dhandle, 8, unsignedp);
4882
        }
4883
      ++*pp;
4884
      break;
4885
 
4886
    case 'l': /* long */
4887
      if (ptype != NULL)
4888
        {
4889
          *ptype = debug_find_named_type (minfo->dhandle,
4890
                                          (unsignedp
4891
                                           ? "long unsigned int"
4892
                                           : "long int"));
4893
          if (*ptype == DEBUG_TYPE_NULL)
4894
            *ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp);
4895
        }
4896
      ++*pp;
4897
      break;
4898
 
4899
    case 'i': /* int */
4900
      if (ptype != NULL)
4901
        {
4902
          *ptype = debug_find_named_type (minfo->dhandle,
4903
                                          (unsignedp
4904
                                           ? "unsigned int"
4905
                                           : "int"));
4906
          if (*ptype == DEBUG_TYPE_NULL)
4907
            *ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp);
4908
        }
4909
      ++*pp;
4910
      break;
4911
 
4912
    case 's': /* short */
4913
      if (ptype != NULL)
4914
        {
4915
          *ptype = debug_find_named_type (minfo->dhandle,
4916
                                          (unsignedp
4917
                                           ? "short unsigned int"
4918
                                           : "short int"));
4919
          if (*ptype == DEBUG_TYPE_NULL)
4920
            *ptype = debug_make_int_type (minfo->dhandle, 2, unsignedp);
4921
        }
4922
      ++*pp;
4923
      break;
4924
 
4925
    case 'b': /* bool */
4926
      if (ptype != NULL)
4927
        {
4928
          *ptype = debug_find_named_type (minfo->dhandle, "bool");
4929
          if (*ptype == DEBUG_TYPE_NULL)
4930
            *ptype = debug_make_bool_type (minfo->dhandle, 4);
4931
        }
4932
      ++*pp;
4933
      break;
4934
 
4935
    case 'c': /* char */
4936
      if (ptype != NULL)
4937
        {
4938
          *ptype = debug_find_named_type (minfo->dhandle,
4939
                                          (unsignedp
4940
                                           ? "unsigned char"
4941
                                           : (signedp
4942
                                              ? "signed char"
4943
                                              : "char")));
4944
          if (*ptype == DEBUG_TYPE_NULL)
4945
            *ptype = debug_make_int_type (minfo->dhandle, 1, unsignedp);
4946
        }
4947
      ++*pp;
4948
      break;
4949
 
4950
    case 'w': /* wchar_t */
4951
      if (ptype != NULL)
4952
        {
4953
          *ptype = debug_find_named_type (minfo->dhandle, "__wchar_t");
4954
          if (*ptype == DEBUG_TYPE_NULL)
4955
            *ptype = debug_make_int_type (minfo->dhandle, 2, TRUE);
4956
        }
4957
      ++*pp;
4958
      break;
4959
 
4960
    case 'r': /* long double */
4961
      if (ptype != NULL)
4962
        {
4963
          *ptype = debug_find_named_type (minfo->dhandle, "long double");
4964
          if (*ptype == DEBUG_TYPE_NULL)
4965
            *ptype = debug_make_float_type (minfo->dhandle, 8);
4966
        }
4967
      ++*pp;
4968
      break;
4969
 
4970
    case 'd': /* double */
4971
      if (ptype != NULL)
4972
        {
4973
          *ptype = debug_find_named_type (minfo->dhandle, "double");
4974
          if (*ptype == DEBUG_TYPE_NULL)
4975
            *ptype = debug_make_float_type (minfo->dhandle, 8);
4976
        }
4977
      ++*pp;
4978
      break;
4979
 
4980
    case 'f': /* float */
4981
      if (ptype != NULL)
4982
        {
4983
          *ptype = debug_find_named_type (minfo->dhandle, "float");
4984
          if (*ptype == DEBUG_TYPE_NULL)
4985
            *ptype = debug_make_float_type (minfo->dhandle, 4);
4986
        }
4987
      ++*pp;
4988
      break;
4989
 
4990
    case 'G':
4991
      ++*pp;
4992
      if (! ISDIGIT (**pp))
4993
        {
4994
          stab_bad_demangle (orig);
4995
          return FALSE;
4996
        }
4997
      /* Fall through.  */
4998
    case '0': case '1': case '2': case '3': case '4':
4999
    case '5': case '6': case '7': case '8': case '9':
5000
      {
5001
        const char *hold;
5002
 
5003
        if (! stab_demangle_class (minfo, pp, &hold))
5004
          return FALSE;
5005
        if (ptype != NULL)
5006
          {
5007
            char *name;
5008
 
5009
            name = savestring (hold, *pp - hold);
5010
            *ptype = debug_find_named_type (minfo->dhandle, name);
5011
            free (name);
5012
            if (*ptype == DEBUG_TYPE_NULL)
5013
              {
5014
                /* FIXME: It is probably incorrect to assume that
5015
                   undefined types are tagged types.  */
5016
                *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
5017
                                                hold, *pp - hold,
5018
                                                DEBUG_KIND_ILLEGAL);
5019
                if (*ptype == DEBUG_TYPE_NULL)
5020
                  return FALSE;
5021
              }
5022
          }
5023
      }
5024
      break;
5025
 
5026
    case 't':
5027
      {
5028
        char *name;
5029
 
5030
        if (! stab_demangle_template (minfo, pp,
5031
                                      ptype != NULL ? &name : NULL))
5032
          return FALSE;
5033
        if (ptype != NULL)
5034
          {
5035
            *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
5036
                                            name, strlen (name),
5037
                                            DEBUG_KIND_CLASS);
5038
            free (name);
5039
            if (*ptype == DEBUG_TYPE_NULL)
5040
              return FALSE;
5041
          }
5042
      }
5043
      break;
5044
 
5045
    default:
5046
      stab_bad_demangle (orig);
5047
      return FALSE;
5048
    }
5049
 
5050
  if (ptype != NULL)
5051
    {
5052
      if (constp)
5053
        *ptype = debug_make_const_type (minfo->dhandle, *ptype);
5054
      if (volatilep)
5055
        *ptype = debug_make_volatile_type (minfo->dhandle, *ptype);
5056
    }
5057
 
5058
  return TRUE;
5059
}
5060
 
5061
/* Remember a type string in a demangled string.  */
5062
 
5063
static bfd_boolean
5064
stab_demangle_remember_type (struct stab_demangle_info *minfo,
5065
                             const char *p, int len)
5066
{
5067
  if (minfo->typestring_count >= minfo->typestring_alloc)
5068
    {
5069
      minfo->typestring_alloc += 10;
5070
      minfo->typestrings = ((struct stab_demangle_typestring *)
5071
                            xrealloc (minfo->typestrings,
5072
                                      (minfo->typestring_alloc
5073
                                       * sizeof *minfo->typestrings)));
5074
    }
5075
 
5076
  minfo->typestrings[minfo->typestring_count].typestring = p;
5077
  minfo->typestrings[minfo->typestring_count].len = (unsigned int) len;
5078
  ++minfo->typestring_count;
5079
 
5080
  return TRUE;
5081
}
5082
 
5083
/* Demangle names encoded using the g++ V3 ABI.  The newer versions of
5084
   g++ which use this ABI do not encode ordinary method argument types
5085
   in a mangled name; they simply output the argument types.  However,
5086
   for a static method, g++ simply outputs the return type and the
5087
   physical name.  So in that case we need to demangle the name here.
5088
   Here PHYSNAME is the physical name of the function, and we set the
5089
   variable pointed at by PVARARGS to indicate whether this function
5090
   is varargs.  This returns NULL, or a NULL terminated array of
5091
   argument types.  */
5092
 
5093
static debug_type *
5094
stab_demangle_v3_argtypes (void *dhandle, struct stab_handle *info,
5095
                           const char *physname, bfd_boolean *pvarargs)
5096
{
5097
  struct demangle_component *dc;
5098
  void *mem;
5099
  debug_type *pargs;
5100
 
5101
  dc = cplus_demangle_v3_components (physname, DMGL_PARAMS | DMGL_ANSI, &mem);
5102
  if (dc == NULL)
5103
    {
5104
      stab_bad_demangle (physname);
5105
      return NULL;
5106
    }
5107
 
5108
  /* We expect to see TYPED_NAME, and the right subtree describes the
5109
     function type.  */
5110
  if (dc->type != DEMANGLE_COMPONENT_TYPED_NAME
5111
      || dc->u.s_binary.right->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
5112
    {
5113
      fprintf (stderr, _("Demangled name is not a function\n"));
5114
      free (mem);
5115
      return NULL;
5116
    }
5117
 
5118
  pargs = stab_demangle_v3_arglist (dhandle, info,
5119
                                    dc->u.s_binary.right->u.s_binary.right,
5120
                                    pvarargs);
5121
 
5122
  free (mem);
5123
 
5124
  return pargs;
5125
}
5126
 
5127
/* Demangle an argument list in a struct demangle_component tree.
5128
   Returns a DEBUG_TYPE_NULL terminated array of argument types, and
5129
   sets *PVARARGS to indicate whether this is a varargs function.  */
5130
 
5131
static debug_type *
5132
stab_demangle_v3_arglist (void *dhandle, struct stab_handle *info,
5133
                          struct demangle_component *arglist,
5134
                          bfd_boolean *pvarargs)
5135
{
5136
  struct demangle_component *dc;
5137
  unsigned int alloc, count;
5138
  debug_type *pargs;
5139
 
5140
  alloc = 10;
5141
  pargs = (debug_type *) xmalloc (alloc * sizeof *pargs);
5142
  *pvarargs = FALSE;
5143
 
5144
  count = 0;
5145
 
5146
  for (dc = arglist;
5147
       dc != NULL;
5148
       dc = dc->u.s_binary.right)
5149
    {
5150
      debug_type arg;
5151
      bfd_boolean varargs;
5152
 
5153
      if (dc->type != DEMANGLE_COMPONENT_ARGLIST)
5154
        {
5155
          fprintf (stderr, _("Unexpected type in v3 arglist demangling\n"));
5156
          free (pargs);
5157
          return NULL;
5158
        }
5159
 
5160
      arg = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left,
5161
                                  NULL, &varargs);
5162
      if (arg == NULL)
5163
        {
5164
          if (varargs)
5165
            {
5166
              *pvarargs = TRUE;
5167
              continue;
5168
            }
5169
          free (pargs);
5170
          return NULL;
5171
        }
5172
 
5173
      if (count + 1 >= alloc)
5174
        {
5175
          alloc += 10;
5176
          pargs = (debug_type *) xrealloc (pargs, alloc * sizeof *pargs);
5177
        }
5178
 
5179
      pargs[count] = arg;
5180
      ++count;
5181
    }
5182
 
5183
  pargs[count] = DEBUG_TYPE_NULL;
5184
 
5185
  return pargs;
5186
}
5187
 
5188
/* Convert a struct demangle_component tree describing an argument
5189
   type into a debug_type.  */
5190
 
5191
static debug_type
5192
stab_demangle_v3_arg (void *dhandle, struct stab_handle *info,
5193
                      struct demangle_component *dc, debug_type context,
5194
                      bfd_boolean *pvarargs)
5195
{
5196
  debug_type dt;
5197
 
5198
  if (pvarargs != NULL)
5199
    *pvarargs = FALSE;
5200
 
5201
  switch (dc->type)
5202
    {
5203
      /* FIXME: These are demangle component types which we probably
5204
         need to handle one way or another.  */
5205
    case DEMANGLE_COMPONENT_LOCAL_NAME:
5206
    case DEMANGLE_COMPONENT_TYPED_NAME:
5207
    case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
5208
    case DEMANGLE_COMPONENT_CTOR:
5209
    case DEMANGLE_COMPONENT_DTOR:
5210
    case DEMANGLE_COMPONENT_JAVA_CLASS:
5211
    case DEMANGLE_COMPONENT_RESTRICT_THIS:
5212
    case DEMANGLE_COMPONENT_VOLATILE_THIS:
5213
    case DEMANGLE_COMPONENT_CONST_THIS:
5214
    case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5215
    case DEMANGLE_COMPONENT_COMPLEX:
5216
    case DEMANGLE_COMPONENT_IMAGINARY:
5217
    case DEMANGLE_COMPONENT_VENDOR_TYPE:
5218
    case DEMANGLE_COMPONENT_ARRAY_TYPE:
5219
    case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5220
    case DEMANGLE_COMPONENT_ARGLIST:
5221
    default:
5222
      fprintf (stderr, _("Unrecognized demangle component %d\n"),
5223
               (int) dc->type);
5224
      return NULL;
5225
 
5226
    case DEMANGLE_COMPONENT_NAME:
5227
      if (context != NULL)
5228
        {
5229
          const debug_field *fields;
5230
 
5231
          fields = debug_get_fields (dhandle, context);
5232
          if (fields != NULL)
5233
            {
5234
              /* Try to find this type by looking through the context
5235
                 class.  */
5236
              for (; *fields != DEBUG_FIELD_NULL; fields++)
5237
                {
5238
                  debug_type ft;
5239
                  const char *dn;
5240
 
5241
                  ft = debug_get_field_type (dhandle, *fields);
5242
                  if (ft == NULL)
5243
                    return NULL;
5244
                  dn = debug_get_type_name (dhandle, ft);
5245
                  if (dn != NULL
5246
                      && (int) strlen (dn) == dc->u.s_name.len
5247
                      && strncmp (dn, dc->u.s_name.s, dc->u.s_name.len) == 0)
5248
                    return ft;
5249
                }
5250
            }
5251
        }
5252
      return stab_find_tagged_type (dhandle, info, dc->u.s_name.s,
5253
                                    dc->u.s_name.len, DEBUG_KIND_ILLEGAL);
5254
 
5255
    case DEMANGLE_COMPONENT_QUAL_NAME:
5256
      context = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left,
5257
                                      context, NULL);
5258
      if (context == NULL)
5259
        return NULL;
5260
      return stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.right,
5261
                                   context, NULL);
5262
 
5263
    case DEMANGLE_COMPONENT_TEMPLATE:
5264
      {
5265
        char *p;
5266
        size_t alc;
5267
 
5268
        /* We print this component to get a class name which we can
5269
           use.  FIXME: This probably won't work if the template uses
5270
           template parameters which refer to an outer template.  */
5271
        p = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, dc, 20, &alc);
5272
        if (p == NULL)
5273
          {
5274
            fprintf (stderr, _("Failed to print demangled template\n"));
5275
            return NULL;
5276
          }
5277
        dt = stab_find_tagged_type (dhandle, info, p, strlen (p),
5278
                                    DEBUG_KIND_CLASS);
5279
        free (p);
5280
        return dt;
5281
      }
5282
 
5283
    case DEMANGLE_COMPONENT_SUB_STD:
5284
      return stab_find_tagged_type (dhandle, info, dc->u.s_string.string,
5285
                                    dc->u.s_string.len, DEBUG_KIND_ILLEGAL);
5286
 
5287
    case DEMANGLE_COMPONENT_RESTRICT:
5288
    case DEMANGLE_COMPONENT_VOLATILE:
5289
    case DEMANGLE_COMPONENT_CONST:
5290
    case DEMANGLE_COMPONENT_POINTER:
5291
    case DEMANGLE_COMPONENT_REFERENCE:
5292
      dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL,
5293
                                 NULL);
5294
      if (dt == NULL)
5295
        return NULL;
5296
 
5297
      switch (dc->type)
5298
        {
5299
        default:
5300
          abort ();
5301
        case DEMANGLE_COMPONENT_RESTRICT:
5302
          /* FIXME: We have no way to represent restrict.  */
5303
          return dt;
5304
        case DEMANGLE_COMPONENT_VOLATILE:
5305
          return debug_make_volatile_type (dhandle, dt);
5306
        case DEMANGLE_COMPONENT_CONST:
5307
          return debug_make_const_type (dhandle, dt);
5308
        case DEMANGLE_COMPONENT_POINTER:
5309
          return debug_make_pointer_type (dhandle, dt);
5310
        case DEMANGLE_COMPONENT_REFERENCE:
5311
          return debug_make_reference_type (dhandle, dt);
5312
        }
5313
 
5314
    case DEMANGLE_COMPONENT_FUNCTION_TYPE:
5315
      {
5316
        debug_type *pargs;
5317
        bfd_boolean varargs;
5318
 
5319
        if (dc->u.s_binary.left == NULL)
5320
          {
5321
            /* In this case the return type is actually unknown.
5322
               However, I'm not sure this will ever arise in practice;
5323
               normally an unknown return type would only appear at
5324
               the top level, which is handled above.  */
5325
            dt = debug_make_void_type (dhandle);
5326
          }
5327
        else
5328
          dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL,
5329
                                     NULL);
5330
        if (dt == NULL)
5331
          return NULL;
5332
 
5333
        pargs = stab_demangle_v3_arglist (dhandle, info,
5334
                                          dc->u.s_binary.right,
5335
                                          &varargs);
5336
        if (pargs == NULL)
5337
          return NULL;
5338
 
5339
        return debug_make_function_type (dhandle, dt, pargs, varargs);
5340
      }
5341
 
5342
    case DEMANGLE_COMPONENT_BUILTIN_TYPE:
5343
      {
5344
        char *p;
5345
        size_t alc;
5346
        debug_type ret;
5347
 
5348
        /* We print this component in order to find out the type name.
5349
           FIXME: Should we instead expose the
5350
           demangle_builtin_type_info structure?  */
5351
        p = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, dc, 20, &alc);
5352
        if (p == NULL)
5353
          {
5354
            fprintf (stderr, _("Couldn't get demangled builtin type\n"));
5355
            return NULL;
5356
          }
5357
 
5358
        /* The mangling is based on the type, but does not itself
5359
           indicate what the sizes are.  So we have to guess.  */
5360
        if (strcmp (p, "signed char") == 0)
5361
          ret = debug_make_int_type (dhandle, 1, FALSE);
5362
        else if (strcmp (p, "bool") == 0)
5363
          ret = debug_make_bool_type (dhandle, 1);
5364
        else if (strcmp (p, "char") == 0)
5365
          ret = debug_make_int_type (dhandle, 1, FALSE);
5366
        else if (strcmp (p, "double") == 0)
5367
          ret = debug_make_float_type (dhandle, 8);
5368
        else if (strcmp (p, "long double") == 0)
5369
          ret = debug_make_float_type (dhandle, 8);
5370
        else if (strcmp (p, "float") == 0)
5371
          ret = debug_make_float_type (dhandle, 4);
5372
        else if (strcmp (p, "__float128") == 0)
5373
          ret = debug_make_float_type (dhandle, 16);
5374
        else if (strcmp (p, "unsigned char") == 0)
5375
          ret = debug_make_int_type (dhandle, 1, TRUE);
5376
        else if (strcmp (p, "int") == 0)
5377
          ret = debug_make_int_type (dhandle, 4, FALSE);
5378
        else if (strcmp (p, "unsigned int") == 0)
5379
          ret = debug_make_int_type (dhandle, 4, TRUE);
5380
        else if (strcmp (p, "long") == 0)
5381
          ret = debug_make_int_type (dhandle, 4, FALSE);
5382
        else if (strcmp (p, "unsigned long") == 0)
5383
          ret = debug_make_int_type (dhandle, 4, TRUE);
5384
        else if (strcmp (p, "__int128") == 0)
5385
          ret = debug_make_int_type (dhandle, 16, FALSE);
5386
        else if (strcmp (p, "unsigned __int128") == 0)
5387
          ret = debug_make_int_type (dhandle, 16, TRUE);
5388
        else if (strcmp (p, "short") == 0)
5389
          ret = debug_make_int_type (dhandle, 2, FALSE);
5390
        else if (strcmp (p, "unsigned short") == 0)
5391
          ret = debug_make_int_type (dhandle, 2, TRUE);
5392
        else if (strcmp (p, "void") == 0)
5393
          ret = debug_make_void_type (dhandle);
5394
        else if (strcmp (p, "wchar_t") == 0)
5395
          ret = debug_make_int_type (dhandle, 4, TRUE);
5396
        else if (strcmp (p, "long long") == 0)
5397
          ret = debug_make_int_type (dhandle, 8, FALSE);
5398
        else if (strcmp (p, "unsigned long long") == 0)
5399
          ret = debug_make_int_type (dhandle, 8, TRUE);
5400
        else if (strcmp (p, "...") == 0)
5401
          {
5402
            if (pvarargs == NULL)
5403
              fprintf (stderr, _("Unexpected demangled varargs\n"));
5404
            else
5405
              *pvarargs = TRUE;
5406
            ret = NULL;
5407
          }
5408
        else
5409
          {
5410
            fprintf (stderr, _("Unrecognized demangled builtin type\n"));
5411
            ret = NULL;
5412
          }
5413
 
5414
        free (p);
5415
 
5416
        return ret;
5417
      }
5418
    }
5419
}

powered by: WebSVN 2.1.0

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