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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [binutils/] [stabs.c] - Blame information for rev 820

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

Line No. Rev Author Line
1 38 julius
/* stabs.c -- Parse stabs debugging information
2
   Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3
   2006, 2007 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
    default:
1109
      bad_stab (string);
1110
      return FALSE;
1111
    }
1112
 
1113
  /* FIXME: gdb converts structure values to structure pointers in a
1114
     couple of cases, depending upon the target.  */
1115
 
1116
  return TRUE;
1117
}
1118
 
1119
/* Parse a stabs type.  The typename argument is non-NULL if this is a
1120
   typedef or a tag definition.  The pp argument points to the stab
1121
   string, and is updated.  The slotp argument points to a place to
1122
   store the slot used if the type is being defined.  */
1123
 
1124
static debug_type
1125
parse_stab_type (void *dhandle, struct stab_handle *info, const char *typename, const char **pp, debug_type **slotp)
1126
{
1127
  const char *orig;
1128
  int typenums[2];
1129
  int size;
1130
  bfd_boolean stringp;
1131
  int descriptor;
1132
  debug_type dtype;
1133
 
1134
  if (slotp != NULL)
1135
    *slotp = NULL;
1136
 
1137
  orig = *pp;
1138
 
1139
  size = -1;
1140
  stringp = FALSE;
1141
 
1142
  info->self_crossref = FALSE;
1143
 
1144
  /* Read type number if present.  The type number may be omitted.
1145
     for instance in a two-dimensional array declared with type
1146
     "ar1;1;10;ar1;1;10;4".  */
1147
  if (! ISDIGIT (**pp) && **pp != '(' && **pp != '-')
1148
    {
1149
      /* 'typenums=' not present, type is anonymous.  Read and return
1150
         the definition, but don't put it in the type vector.  */
1151
      typenums[0] = typenums[1] = -1;
1152
    }
1153
  else
1154
    {
1155
      if (! parse_stab_type_number (pp, typenums))
1156
        return DEBUG_TYPE_NULL;
1157
 
1158
      if (**pp != '=')
1159
        /* Type is not being defined here.  Either it already
1160
           exists, or this is a forward reference to it.  */
1161
        return stab_find_type (dhandle, info, typenums);
1162
 
1163
      /* Only set the slot if the type is being defined.  This means
1164
         that the mapping from type numbers to types will only record
1165
         the name of the typedef which defines a type.  If we don't do
1166
         this, then something like
1167
             typedef int foo;
1168
             int i;
1169
         will record that i is of type foo.  Unfortunately, stabs
1170
         information is ambiguous about variable types.  For this code,
1171
             typedef int foo;
1172
             int i;
1173
             foo j;
1174
         the stabs information records both i and j as having the same
1175
         type.  This could be fixed by patching the compiler.  */
1176
      if (slotp != NULL && typenums[0] >= 0 && typenums[1] >= 0)
1177
        *slotp = stab_find_slot (info, typenums);
1178
 
1179
      /* Type is being defined here.  */
1180
      /* Skip the '='.  */
1181
      ++*pp;
1182
 
1183
      while (**pp == '@')
1184
        {
1185
          const char *p = *pp + 1;
1186
          const char *attr;
1187
 
1188
          if (ISDIGIT (*p) || *p == '(' || *p == '-')
1189
            /* Member type.  */
1190
            break;
1191
 
1192
          /* Type attributes.  */
1193
          attr = p;
1194
 
1195
          for (; *p != ';'; ++p)
1196
            {
1197
              if (*p == '\0')
1198
                {
1199
                  bad_stab (orig);
1200
                  return DEBUG_TYPE_NULL;
1201
                }
1202
            }
1203
          *pp = p + 1;
1204
 
1205
          switch (*attr)
1206
            {
1207
            case 's':
1208
              size = atoi (attr + 1);
1209
              size /= 8;  /* Size is in bits.  We store it in bytes.  */
1210
              if (size <= 0)
1211
                size = -1;
1212
              break;
1213
 
1214
            case 'S':
1215
              stringp = TRUE;
1216
              break;
1217
 
1218
            default:
1219
              /* Ignore unrecognized type attributes, so future
1220
                 compilers can invent new ones.  */
1221
              break;
1222
            }
1223
        }
1224
    }
1225
 
1226
  descriptor = **pp;
1227
  ++*pp;
1228
 
1229
  switch (descriptor)
1230
    {
1231
    case 'x':
1232
      {
1233
        enum debug_type_kind code;
1234
        const char *q1, *q2, *p;
1235
 
1236
        /* A cross reference to another type.  */
1237
        switch (**pp)
1238
          {
1239
          case 's':
1240
            code = DEBUG_KIND_STRUCT;
1241
            break;
1242
          case 'u':
1243
            code = DEBUG_KIND_UNION;
1244
            break;
1245
          case 'e':
1246
            code = DEBUG_KIND_ENUM;
1247
            break;
1248
          default:
1249
            /* Complain and keep going, so compilers can invent new
1250
               cross-reference types.  */
1251
            warn_stab (orig, _("unrecognized cross reference type"));
1252
            code = DEBUG_KIND_STRUCT;
1253
            break;
1254
          }
1255
        ++*pp;
1256
 
1257
        q1 = strchr (*pp, '<');
1258
        p = strchr (*pp, ':');
1259
        if (p == NULL)
1260
          {
1261
            bad_stab (orig);
1262
            return DEBUG_TYPE_NULL;
1263
          }
1264
        if (q1 != NULL && p > q1 && p[1] == ':')
1265
          {
1266
            int nest = 0;
1267
 
1268
            for (q2 = q1; *q2 != '\0'; ++q2)
1269
              {
1270
                if (*q2 == '<')
1271
                  ++nest;
1272
                else if (*q2 == '>')
1273
                  --nest;
1274
                else if (*q2 == ':' && nest == 0)
1275
                  break;
1276
              }
1277
            p = q2;
1278
            if (*p != ':')
1279
              {
1280
                bad_stab (orig);
1281
                return DEBUG_TYPE_NULL;
1282
              }
1283
          }
1284
 
1285
        /* Some versions of g++ can emit stabs like
1286
               fleep:T20=xsfleep:
1287
           which define structures in terms of themselves.  We need to
1288
           tell the caller to avoid building a circular structure.  */
1289
        if (typename != NULL
1290
            && strncmp (typename, *pp, p - *pp) == 0
1291
            && typename[p - *pp] == '\0')
1292
          info->self_crossref = TRUE;
1293
 
1294
        dtype = stab_find_tagged_type (dhandle, info, *pp, p - *pp, code);
1295
 
1296
        *pp = p + 1;
1297
      }
1298
      break;
1299
 
1300
    case '-':
1301
    case '0':
1302
    case '1':
1303
    case '2':
1304
    case '3':
1305
    case '4':
1306
    case '5':
1307
    case '6':
1308
    case '7':
1309
    case '8':
1310
    case '9':
1311
    case '(':
1312
      {
1313
        const char *hold;
1314
        int xtypenums[2];
1315
 
1316
        /* This type is defined as another type.  */
1317
        (*pp)--;
1318
        hold = *pp;
1319
 
1320
        /* Peek ahead at the number to detect void.  */
1321
        if (! parse_stab_type_number (pp, xtypenums))
1322
          return DEBUG_TYPE_NULL;
1323
 
1324
        if (typenums[0] == xtypenums[0] && typenums[1] == xtypenums[1])
1325
          {
1326
            /* This type is being defined as itself, which means that
1327
               it is void.  */
1328
            dtype = debug_make_void_type (dhandle);
1329
          }
1330
        else
1331
          {
1332
            *pp = hold;
1333
 
1334
            /* Go back to the number and have parse_stab_type get it.
1335
               This means that we can deal with something like
1336
               t(1,2)=(3,4)=... which the Lucid compiler uses.  */
1337
            dtype = parse_stab_type (dhandle, info, (const char *) NULL,
1338
                                     pp, (debug_type **) NULL);
1339
            if (dtype == DEBUG_TYPE_NULL)
1340
              return DEBUG_TYPE_NULL;
1341
          }
1342
 
1343
        if (typenums[0] != -1)
1344
          {
1345
            if (! stab_record_type (dhandle, info, typenums, dtype))
1346
              return DEBUG_TYPE_NULL;
1347
          }
1348
 
1349
        break;
1350
      }
1351
 
1352
    case '*':
1353
      dtype = debug_make_pointer_type (dhandle,
1354
                                       parse_stab_type (dhandle, info,
1355
                                                        (const char *) NULL,
1356
                                                        pp,
1357
                                                        (debug_type **) NULL));
1358
      break;
1359
 
1360
    case '&':
1361
      /* Reference to another type.  */
1362
      dtype = (debug_make_reference_type
1363
               (dhandle,
1364
                parse_stab_type (dhandle, info, (const char *) NULL, pp,
1365
                                 (debug_type **) NULL)));
1366
      break;
1367
 
1368
    case 'f':
1369
      /* Function returning another type.  */
1370
      /* FIXME: gdb checks os9k_stabs here.  */
1371
      dtype = (debug_make_function_type
1372
               (dhandle,
1373
                parse_stab_type (dhandle, info, (const char *) NULL, pp,
1374
                                 (debug_type **) NULL),
1375
                (debug_type *) NULL, FALSE));
1376
      break;
1377
 
1378
    case 'k':
1379
      /* Const qualifier on some type (Sun).  */
1380
      /* FIXME: gdb accepts 'c' here if os9k_stabs.  */
1381
      dtype = debug_make_const_type (dhandle,
1382
                                     parse_stab_type (dhandle, info,
1383
                                                      (const char *) NULL,
1384
                                                      pp,
1385
                                                      (debug_type **) NULL));
1386
      break;
1387
 
1388
    case 'B':
1389
      /* Volatile qual on some type (Sun).  */
1390
      /* FIXME: gdb accepts 'i' here if os9k_stabs.  */
1391
      dtype = (debug_make_volatile_type
1392
               (dhandle,
1393
                parse_stab_type (dhandle, info, (const char *) NULL, pp,
1394
                                 (debug_type **) NULL)));
1395
      break;
1396
 
1397
    case '@':
1398
      /* Offset (class & variable) type.  This is used for a pointer
1399
         relative to an object.  */
1400
      {
1401
        debug_type domain;
1402
        debug_type memtype;
1403
 
1404
        /* Member type.  */
1405
 
1406
        domain = parse_stab_type (dhandle, info, (const char *) NULL, pp,
1407
                                  (debug_type **) NULL);
1408
        if (domain == DEBUG_TYPE_NULL)
1409
          return DEBUG_TYPE_NULL;
1410
 
1411
        if (**pp != ',')
1412
          {
1413
            bad_stab (orig);
1414
            return DEBUG_TYPE_NULL;
1415
          }
1416
        ++*pp;
1417
 
1418
        memtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
1419
                                   (debug_type **) NULL);
1420
        if (memtype == DEBUG_TYPE_NULL)
1421
          return DEBUG_TYPE_NULL;
1422
 
1423
        dtype = debug_make_offset_type (dhandle, domain, memtype);
1424
      }
1425
      break;
1426
 
1427
    case '#':
1428
      /* Method (class & fn) type.  */
1429
      if (**pp == '#')
1430
        {
1431
          debug_type return_type;
1432
 
1433
          ++*pp;
1434
          return_type = parse_stab_type (dhandle, info, (const char *) NULL,
1435
                                         pp, (debug_type **) NULL);
1436
          if (return_type == DEBUG_TYPE_NULL)
1437
            return DEBUG_TYPE_NULL;
1438
          if (**pp != ';')
1439
            {
1440
              bad_stab (orig);
1441
              return DEBUG_TYPE_NULL;
1442
            }
1443
          ++*pp;
1444
          dtype = debug_make_method_type (dhandle, return_type,
1445
                                          DEBUG_TYPE_NULL,
1446
                                          (debug_type *) NULL, FALSE);
1447
        }
1448
      else
1449
        {
1450
          debug_type domain;
1451
          debug_type return_type;
1452
          debug_type *args;
1453
          unsigned int n;
1454
          unsigned int alloc;
1455
          bfd_boolean varargs;
1456
 
1457
          domain = parse_stab_type (dhandle, info, (const char *) NULL,
1458
                                    pp, (debug_type **) NULL);
1459
          if (domain == DEBUG_TYPE_NULL)
1460
            return DEBUG_TYPE_NULL;
1461
 
1462
          if (**pp != ',')
1463
            {
1464
              bad_stab (orig);
1465
              return DEBUG_TYPE_NULL;
1466
            }
1467
          ++*pp;
1468
 
1469
          return_type = parse_stab_type (dhandle, info, (const char *) NULL,
1470
                                         pp, (debug_type **) NULL);
1471
          if (return_type == DEBUG_TYPE_NULL)
1472
            return DEBUG_TYPE_NULL;
1473
 
1474
          alloc = 10;
1475
          args = (debug_type *) xmalloc (alloc * sizeof *args);
1476
          n = 0;
1477
          while (**pp != ';')
1478
            {
1479
              if (**pp != ',')
1480
                {
1481
                  bad_stab (orig);
1482
                  return DEBUG_TYPE_NULL;
1483
                }
1484
              ++*pp;
1485
 
1486
              if (n + 1 >= alloc)
1487
                {
1488
                  alloc += 10;
1489
                  args = ((debug_type *)
1490
                          xrealloc (args, alloc * sizeof *args));
1491
                }
1492
 
1493
              args[n] = parse_stab_type (dhandle, info, (const char *) NULL,
1494
                                         pp, (debug_type **) NULL);
1495
              if (args[n] == DEBUG_TYPE_NULL)
1496
                return DEBUG_TYPE_NULL;
1497
              ++n;
1498
            }
1499
          ++*pp;
1500
 
1501
          /* If the last type is not void, then this function takes a
1502
             variable number of arguments.  Otherwise, we must strip
1503
             the void type.  */
1504
          if (n == 0
1505
              || debug_get_type_kind (dhandle, args[n - 1]) != DEBUG_KIND_VOID)
1506
            varargs = TRUE;
1507
          else
1508
            {
1509
              --n;
1510
              varargs = FALSE;
1511
            }
1512
 
1513
          args[n] = DEBUG_TYPE_NULL;
1514
 
1515
          dtype = debug_make_method_type (dhandle, return_type, domain, args,
1516
                                          varargs);
1517
        }
1518
      break;
1519
 
1520
    case 'r':
1521
      /* Range type.  */
1522
      dtype = parse_stab_range_type (dhandle, info, typename, pp, typenums);
1523
      break;
1524
 
1525
    case 'b':
1526
      /* FIXME: gdb checks os9k_stabs here.  */
1527
      /* Sun ACC builtin int type.  */
1528
      dtype = parse_stab_sun_builtin_type (dhandle, pp);
1529
      break;
1530
 
1531
    case 'R':
1532
      /* Sun ACC builtin float type.  */
1533
      dtype = parse_stab_sun_floating_type (dhandle, pp);
1534
      break;
1535
 
1536
    case 'e':
1537
      /* Enumeration type.  */
1538
      dtype = parse_stab_enum_type (dhandle, pp);
1539
      break;
1540
 
1541
    case 's':
1542
    case 'u':
1543
      /* Struct or union type.  */
1544
      dtype = parse_stab_struct_type (dhandle, info, typename, pp,
1545
                                      descriptor == 's', typenums);
1546
      break;
1547
 
1548
    case 'a':
1549
      /* Array type.  */
1550
      if (**pp != 'r')
1551
        {
1552
          bad_stab (orig);
1553
          return DEBUG_TYPE_NULL;
1554
        }
1555
      ++*pp;
1556
 
1557
      dtype = parse_stab_array_type (dhandle, info, pp, stringp);
1558
      break;
1559
 
1560
    case 'S':
1561
      dtype = debug_make_set_type (dhandle,
1562
                                   parse_stab_type (dhandle, info,
1563
                                                    (const char *) NULL,
1564
                                                    pp,
1565
                                                    (debug_type **) NULL),
1566
                                   stringp);
1567
      break;
1568
 
1569
    default:
1570
      bad_stab (orig);
1571
      return DEBUG_TYPE_NULL;
1572
    }
1573
 
1574
  if (dtype == DEBUG_TYPE_NULL)
1575
    return DEBUG_TYPE_NULL;
1576
 
1577
  if (typenums[0] != -1)
1578
    {
1579
      if (! stab_record_type (dhandle, info, typenums, dtype))
1580
        return DEBUG_TYPE_NULL;
1581
    }
1582
 
1583
  if (size != -1)
1584
    {
1585
      if (! debug_record_type_size (dhandle, dtype, (unsigned int) size))
1586
        return DEBUG_TYPE_NULL;
1587
    }
1588
 
1589
  return dtype;
1590
}
1591
 
1592
/* Read a number by which a type is referred to in dbx data, or
1593
   perhaps read a pair (FILENUM, TYPENUM) in parentheses.  Just a
1594
   single number N is equivalent to (0,N).  Return the two numbers by
1595
   storing them in the vector TYPENUMS.  */
1596
 
1597
static bfd_boolean
1598
parse_stab_type_number (const char **pp, int *typenums)
1599
{
1600
  const char *orig;
1601
 
1602
  orig = *pp;
1603
 
1604
  if (**pp != '(')
1605
    {
1606
      typenums[0] = 0;
1607
      typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL);
1608
    }
1609
  else
1610
    {
1611
      ++*pp;
1612
      typenums[0] = (int) parse_number (pp, (bfd_boolean *) NULL);
1613
      if (**pp != ',')
1614
        {
1615
          bad_stab (orig);
1616
          return FALSE;
1617
        }
1618
      ++*pp;
1619
      typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL);
1620
      if (**pp != ')')
1621
        {
1622
          bad_stab (orig);
1623
          return FALSE;
1624
        }
1625
      ++*pp;
1626
    }
1627
 
1628
  return TRUE;
1629
}
1630
 
1631
/* Parse a range type.  */
1632
 
1633
static debug_type
1634
parse_stab_range_type (void *dhandle, struct stab_handle *info, const char *typename, const char **pp, const int *typenums)
1635
{
1636
  const char *orig;
1637
  int rangenums[2];
1638
  bfd_boolean self_subrange;
1639
  debug_type index_type;
1640
  const char *s2, *s3;
1641
  bfd_signed_vma n2, n3;
1642
  bfd_boolean ov2, ov3;
1643
 
1644
  orig = *pp;
1645
 
1646
  index_type = DEBUG_TYPE_NULL;
1647
 
1648
  /* First comes a type we are a subrange of.
1649
     In C it is usually 0, 1 or the type being defined.  */
1650
  if (! parse_stab_type_number (pp, rangenums))
1651
    return DEBUG_TYPE_NULL;
1652
 
1653
  self_subrange = (rangenums[0] == typenums[0]
1654
                   && rangenums[1] == typenums[1]);
1655
 
1656
  if (**pp == '=')
1657
    {
1658
      *pp = orig;
1659
      index_type = parse_stab_type (dhandle, info, (const char *) NULL,
1660
                                    pp, (debug_type **) NULL);
1661
      if (index_type == DEBUG_TYPE_NULL)
1662
        return DEBUG_TYPE_NULL;
1663
    }
1664
 
1665
  if (**pp == ';')
1666
    ++*pp;
1667
 
1668
  /* The remaining two operands are usually lower and upper bounds of
1669
     the range.  But in some special cases they mean something else.  */
1670
  s2 = *pp;
1671
  n2 = parse_number (pp, &ov2);
1672
  if (**pp != ';')
1673
    {
1674
      bad_stab (orig);
1675
      return DEBUG_TYPE_NULL;
1676
    }
1677
  ++*pp;
1678
 
1679
  s3 = *pp;
1680
  n3 = parse_number (pp, &ov3);
1681
  if (**pp != ';')
1682
    {
1683
      bad_stab (orig);
1684
      return DEBUG_TYPE_NULL;
1685
    }
1686
  ++*pp;
1687
 
1688
  if (ov2 || ov3)
1689
    {
1690
      /* gcc will emit range stabs for long long types.  Handle this
1691
         as a special case.  FIXME: This needs to be more general.  */
1692
#define LLLOW   "01000000000000000000000;"
1693
#define LLHIGH   "0777777777777777777777;"
1694
#define ULLHIGH "01777777777777777777777;"
1695
      if (index_type == DEBUG_TYPE_NULL)
1696
        {
1697
          if (CONST_STRNEQ (s2, LLLOW)
1698
              && CONST_STRNEQ (s3, LLHIGH))
1699
            return debug_make_int_type (dhandle, 8, FALSE);
1700
          if (! ov2
1701
              && n2 == 0
1702
              && CONST_STRNEQ (s3, ULLHIGH))
1703
            return debug_make_int_type (dhandle, 8, TRUE);
1704
        }
1705
 
1706
      warn_stab (orig, _("numeric overflow"));
1707
    }
1708
 
1709
  if (index_type == DEBUG_TYPE_NULL)
1710
    {
1711
      /* A type defined as a subrange of itself, with both bounds 0,
1712
         is void.  */
1713
      if (self_subrange && n2 == 0 && n3 == 0)
1714
        return debug_make_void_type (dhandle);
1715
 
1716
      /* A type defined as a subrange of itself, with n2 positive and
1717
         n3 zero, is a complex type, and n2 is the number of bytes.  */
1718
      if (self_subrange && n3 == 0 && n2 > 0)
1719
        return debug_make_complex_type (dhandle, n2);
1720
 
1721
      /* If n3 is zero and n2 is positive, this is a floating point
1722
         type, and n2 is the number of bytes.  */
1723
      if (n3 == 0 && n2 > 0)
1724
        return debug_make_float_type (dhandle, n2);
1725
 
1726
      /* If the upper bound is -1, this is an unsigned int.  */
1727
      if (n2 == 0 && n3 == -1)
1728
        {
1729
          /* When gcc is used with -gstabs, but not -gstabs+, it will emit
1730
                 long long int:t6=r1;0;-1;
1731
                 long long unsigned int:t7=r1;0;-1;
1732
             We hack here to handle this reasonably.  */
1733
          if (typename != NULL)
1734
            {
1735
              if (strcmp (typename, "long long int") == 0)
1736
                return debug_make_int_type (dhandle, 8, FALSE);
1737
              else if (strcmp (typename, "long long unsigned int") == 0)
1738
                return debug_make_int_type (dhandle, 8, TRUE);
1739
            }
1740
          /* FIXME: The size here really depends upon the target.  */
1741
          return debug_make_int_type (dhandle, 4, TRUE);
1742
        }
1743
 
1744
      /* A range of 0 to 127 is char.  */
1745
      if (self_subrange && n2 == 0 && n3 == 127)
1746
        return debug_make_int_type (dhandle, 1, FALSE);
1747
 
1748
      /* FIXME: gdb checks for the language CHILL here.  */
1749
 
1750
      if (n2 == 0)
1751
        {
1752
          if (n3 < 0)
1753
            return debug_make_int_type (dhandle, - n3, TRUE);
1754
          else if (n3 == 0xff)
1755
            return debug_make_int_type (dhandle, 1, TRUE);
1756
          else if (n3 == 0xffff)
1757
            return debug_make_int_type (dhandle, 2, TRUE);
1758
          else if (n3 == (bfd_signed_vma) 0xffffffff)
1759
            return debug_make_int_type (dhandle, 4, TRUE);
1760
#ifdef BFD64
1761
          else if (n3 == ((((bfd_signed_vma) 0xffffffff) << 32) | 0xffffffff))
1762
            return debug_make_int_type (dhandle, 8, TRUE);
1763
#endif
1764
        }
1765
      else if (n3 == 0
1766
               && n2 < 0
1767
               && (self_subrange || n2 == -8))
1768
        return debug_make_int_type (dhandle, - n2, TRUE);
1769
      else if (n2 == - n3 - 1 || n2 == n3 + 1)
1770
        {
1771
          if (n3 == 0x7f)
1772
            return debug_make_int_type (dhandle, 1, FALSE);
1773
          else if (n3 == 0x7fff)
1774
            return debug_make_int_type (dhandle, 2, FALSE);
1775
          else if (n3 == 0x7fffffff)
1776
            return debug_make_int_type (dhandle, 4, FALSE);
1777
#ifdef BFD64
1778
          else if (n3 == ((((bfd_vma) 0x7fffffff) << 32) | 0xffffffff))
1779
            return debug_make_int_type (dhandle, 8, FALSE);
1780
#endif
1781
        }
1782
    }
1783
 
1784
  /* At this point I don't have the faintest idea how to deal with a
1785
     self_subrange type; I'm going to assume that this is used as an
1786
     idiom, and that all of them are special cases.  So . . .  */
1787
  if (self_subrange)
1788
    {
1789
      bad_stab (orig);
1790
      return DEBUG_TYPE_NULL;
1791
    }
1792
 
1793
  index_type = stab_find_type (dhandle, info, rangenums);
1794
  if (index_type == DEBUG_TYPE_NULL)
1795
    {
1796
      /* Does this actually ever happen?  Is that why we are worrying
1797
         about dealing with it rather than just calling error_type?  */
1798
      warn_stab (orig, _("missing index type"));
1799
      index_type = debug_make_int_type (dhandle, 4, FALSE);
1800
    }
1801
 
1802
  return debug_make_range_type (dhandle, index_type, n2, n3);
1803
}
1804
 
1805
/* Sun's ACC uses a somewhat saner method for specifying the builtin
1806
   typedefs in every file (for int, long, etc):
1807
 
1808
        type = b <signed> <width>; <offset>; <nbits>
1809
        signed = u or s.  Possible c in addition to u or s (for char?).
1810
        offset = offset from high order bit to start bit of type.
1811
        width is # bytes in object of this type, nbits is # bits in type.
1812
 
1813
   The width/offset stuff appears to be for small objects stored in
1814
   larger ones (e.g. `shorts' in `int' registers).  We ignore it for now,
1815
   FIXME.  */
1816
 
1817
static debug_type
1818
parse_stab_sun_builtin_type (void *dhandle, const char **pp)
1819
{
1820
  const char *orig;
1821
  bfd_boolean unsignedp;
1822
  bfd_vma bits;
1823
 
1824
  orig = *pp;
1825
 
1826
  switch (**pp)
1827
    {
1828
    case 's':
1829
      unsignedp = FALSE;
1830
      break;
1831
    case 'u':
1832
      unsignedp = TRUE;
1833
      break;
1834
    default:
1835
      bad_stab (orig);
1836
      return DEBUG_TYPE_NULL;
1837
    }
1838
  ++*pp;
1839
 
1840
  /* For some odd reason, all forms of char put a c here.  This is strange
1841
     because no other type has this honor.  We can safely ignore this because
1842
     we actually determine 'char'acterness by the number of bits specified in
1843
     the descriptor.  */
1844
  if (**pp == 'c')
1845
    ++*pp;
1846
 
1847
  /* The first number appears to be the number of bytes occupied
1848
     by this type, except that unsigned short is 4 instead of 2.
1849
     Since this information is redundant with the third number,
1850
     we will ignore it.  */
1851
  (void) parse_number (pp, (bfd_boolean *) NULL);
1852
  if (**pp != ';')
1853
    {
1854
      bad_stab (orig);
1855
      return DEBUG_TYPE_NULL;
1856
    }
1857
  ++*pp;
1858
 
1859
  /* The second number is always 0, so ignore it too.  */
1860
  (void) parse_number (pp, (bfd_boolean *) NULL);
1861
  if (**pp != ';')
1862
    {
1863
      bad_stab (orig);
1864
      return DEBUG_TYPE_NULL;
1865
    }
1866
  ++*pp;
1867
 
1868
  /* The third number is the number of bits for this type.  */
1869
  bits = parse_number (pp, (bfd_boolean *) NULL);
1870
 
1871
  /* The type *should* end with a semicolon.  If it are embedded
1872
     in a larger type the semicolon may be the only way to know where
1873
     the type ends.  If this type is at the end of the stabstring we
1874
     can deal with the omitted semicolon (but we don't have to like
1875
     it).  Don't bother to complain(), Sun's compiler omits the semicolon
1876
     for "void".  */
1877
  if (**pp == ';')
1878
    ++*pp;
1879
 
1880
  if (bits == 0)
1881
    return debug_make_void_type (dhandle);
1882
 
1883
  return debug_make_int_type (dhandle, bits / 8, unsignedp);
1884
}
1885
 
1886
/* Parse a builtin floating type generated by the Sun compiler.  */
1887
 
1888
static debug_type
1889
parse_stab_sun_floating_type (void *dhandle, const char **pp)
1890
{
1891
  const char *orig;
1892
  bfd_vma details;
1893
  bfd_vma bytes;
1894
 
1895
  orig = *pp;
1896
 
1897
  /* The first number has more details about the type, for example
1898
     FN_COMPLEX.  */
1899
  details = parse_number (pp, (bfd_boolean *) NULL);
1900
  if (**pp != ';')
1901
    {
1902
      bad_stab (orig);
1903
      return DEBUG_TYPE_NULL;
1904
    }
1905
 
1906
  /* The second number is the number of bytes occupied by this type */
1907
  bytes = parse_number (pp, (bfd_boolean *) NULL);
1908
  if (**pp != ';')
1909
    {
1910
      bad_stab (orig);
1911
      return DEBUG_TYPE_NULL;
1912
    }
1913
 
1914
  if (details == NF_COMPLEX
1915
      || details == NF_COMPLEX16
1916
      || details == NF_COMPLEX32)
1917
    return debug_make_complex_type (dhandle, bytes);
1918
 
1919
  return debug_make_float_type (dhandle, bytes);
1920
}
1921
 
1922
/* Handle an enum type.  */
1923
 
1924
static debug_type
1925
parse_stab_enum_type (void *dhandle, const char **pp)
1926
{
1927
  const char *orig;
1928
  const char **names;
1929
  bfd_signed_vma *values;
1930
  unsigned int n;
1931
  unsigned int alloc;
1932
 
1933
  orig = *pp;
1934
 
1935
  /* FIXME: gdb checks os9k_stabs here.  */
1936
 
1937
  /* The aix4 compiler emits an extra field before the enum members;
1938
     my guess is it's a type of some sort.  Just ignore it.  */
1939
  if (**pp == '-')
1940
    {
1941
      while (**pp != ':')
1942
        ++*pp;
1943
      ++*pp;
1944
    }
1945
 
1946
  /* Read the value-names and their values.
1947
     The input syntax is NAME:VALUE,NAME:VALUE, and so on.
1948
     A semicolon or comma instead of a NAME means the end.  */
1949
  alloc = 10;
1950
  names = (const char **) xmalloc (alloc * sizeof *names);
1951
  values = (bfd_signed_vma *) xmalloc (alloc * sizeof *values);
1952
  n = 0;
1953
  while (**pp != '\0' && **pp != ';' && **pp != ',')
1954
    {
1955
      const char *p;
1956
      char *name;
1957
      bfd_signed_vma val;
1958
 
1959
      p = *pp;
1960
      while (*p != ':')
1961
        ++p;
1962
 
1963
      name = savestring (*pp, p - *pp);
1964
 
1965
      *pp = p + 1;
1966
      val = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
1967
      if (**pp != ',')
1968
        {
1969
          bad_stab (orig);
1970
          return DEBUG_TYPE_NULL;
1971
        }
1972
      ++*pp;
1973
 
1974
      if (n + 1 >= alloc)
1975
        {
1976
          alloc += 10;
1977
          names = ((const char **)
1978
                   xrealloc (names, alloc * sizeof *names));
1979
          values = ((bfd_signed_vma *)
1980
                    xrealloc (values, alloc * sizeof *values));
1981
        }
1982
 
1983
      names[n] = name;
1984
      values[n] = val;
1985
      ++n;
1986
    }
1987
 
1988
  names[n] = NULL;
1989
  values[n] = 0;
1990
 
1991
  if (**pp == ';')
1992
    ++*pp;
1993
 
1994
  return debug_make_enum_type (dhandle, names, values);
1995
}
1996
 
1997
/* Read the description of a structure (or union type) and return an object
1998
   describing the type.
1999
 
2000
   PP points to a character pointer that points to the next unconsumed token
2001
   in the stabs string.  For example, given stabs "A:T4=s4a:1,0,32;;",
2002
   *PP will point to "4a:1,0,32;;".  */
2003
 
2004
static debug_type
2005
parse_stab_struct_type (void *dhandle, struct stab_handle *info,
2006
                        const char *tagname, const char **pp,
2007
                        bfd_boolean structp, const int *typenums)
2008
{
2009
  const char *orig;
2010
  bfd_vma size;
2011
  debug_baseclass *baseclasses;
2012
  debug_field *fields;
2013
  bfd_boolean statics;
2014
  debug_method *methods;
2015
  debug_type vptrbase;
2016
  bfd_boolean ownvptr;
2017
 
2018
  orig = *pp;
2019
 
2020
  /* Get the size.  */
2021
  size = parse_number (pp, (bfd_boolean *) NULL);
2022
 
2023
  /* Get the other information.  */
2024
  if (! parse_stab_baseclasses (dhandle, info, pp, &baseclasses)
2025
      || ! parse_stab_struct_fields (dhandle, info, pp, &fields, &statics)
2026
      || ! parse_stab_members (dhandle, info, tagname, pp, typenums, &methods)
2027
      || ! parse_stab_tilde_field (dhandle, info, pp, typenums, &vptrbase,
2028
                                   &ownvptr))
2029
    return DEBUG_TYPE_NULL;
2030
 
2031
  if (! statics
2032
      && baseclasses == NULL
2033
      && methods == NULL
2034
      && vptrbase == DEBUG_TYPE_NULL
2035
      && ! ownvptr)
2036
    return debug_make_struct_type (dhandle, structp, size, fields);
2037
 
2038
  return debug_make_object_type (dhandle, structp, size, fields, baseclasses,
2039
                                 methods, vptrbase, ownvptr);
2040
}
2041
 
2042
/* The stabs for C++ derived classes contain baseclass information which
2043
   is marked by a '!' character after the total size.  This function is
2044
   called when we encounter the baseclass marker, and slurps up all the
2045
   baseclass information.
2046
 
2047
   Immediately following the '!' marker is the number of base classes that
2048
   the class is derived from, followed by information for each base class.
2049
   For each base class, there are two visibility specifiers, a bit offset
2050
   to the base class information within the derived class, a reference to
2051
   the type for the base class, and a terminating semicolon.
2052
 
2053
   A typical example, with two base classes, would be "!2,020,19;0264,21;".
2054
                                                       ^^ ^ ^ ^  ^ ^  ^
2055
        Baseclass information marker __________________|| | | |  | |  |
2056
        Number of baseclasses __________________________| | | |  | |  |
2057
        Visibility specifiers (2) ________________________| | |  | |  |
2058
        Offset in bits from start of class _________________| |  | |  |
2059
        Type number for base class ___________________________|  | |  |
2060
        Visibility specifiers (2) _______________________________| |  |
2061
        Offset in bits from start of class ________________________|  |
2062
        Type number of base class ____________________________________|
2063
 
2064
  Return TRUE for success, FALSE for failure.  */
2065
 
2066
static bfd_boolean
2067
parse_stab_baseclasses (void *dhandle, struct stab_handle *info,
2068
                        const char **pp, debug_baseclass **retp)
2069
{
2070
  const char *orig;
2071
  unsigned int c, i;
2072
  debug_baseclass *classes;
2073
 
2074
  *retp = NULL;
2075
 
2076
  orig = *pp;
2077
 
2078
  if (**pp != '!')
2079
    {
2080
      /* No base classes.  */
2081
      return TRUE;
2082
    }
2083
  ++*pp;
2084
 
2085
  c = (unsigned int) parse_number (pp, (bfd_boolean *) NULL);
2086
 
2087
  if (**pp != ',')
2088
    {
2089
      bad_stab (orig);
2090
      return FALSE;
2091
    }
2092
  ++*pp;
2093
 
2094
  classes = (debug_baseclass *) xmalloc ((c + 1) * sizeof (**retp));
2095
 
2096
  for (i = 0; i < c; i++)
2097
    {
2098
      bfd_boolean virtual;
2099
      enum debug_visibility visibility;
2100
      bfd_vma bitpos;
2101
      debug_type type;
2102
 
2103
      switch (**pp)
2104
        {
2105
        case '0':
2106
          virtual = FALSE;
2107
          break;
2108
        case '1':
2109
          virtual = TRUE;
2110
          break;
2111
        default:
2112
          warn_stab (orig, _("unknown virtual character for baseclass"));
2113
          virtual = FALSE;
2114
          break;
2115
        }
2116
      ++*pp;
2117
 
2118
      switch (**pp)
2119
        {
2120
        case '0':
2121
          visibility = DEBUG_VISIBILITY_PRIVATE;
2122
          break;
2123
        case '1':
2124
          visibility = DEBUG_VISIBILITY_PROTECTED;
2125
          break;
2126
        case '2':
2127
          visibility = DEBUG_VISIBILITY_PUBLIC;
2128
          break;
2129
        default:
2130
          warn_stab (orig, _("unknown visibility character for baseclass"));
2131
          visibility = DEBUG_VISIBILITY_PUBLIC;
2132
          break;
2133
        }
2134
      ++*pp;
2135
 
2136
      /* The remaining value is the bit offset of the portion of the
2137
         object corresponding to this baseclass.  Always zero in the
2138
         absence of multiple inheritance.  */
2139
      bitpos = parse_number (pp, (bfd_boolean *) NULL);
2140
      if (**pp != ',')
2141
        {
2142
          bad_stab (orig);
2143
          return FALSE;
2144
        }
2145
      ++*pp;
2146
 
2147
      type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2148
                              (debug_type **) NULL);
2149
      if (type == DEBUG_TYPE_NULL)
2150
        return FALSE;
2151
 
2152
      classes[i] = debug_make_baseclass (dhandle, type, bitpos, virtual,
2153
                                         visibility);
2154
      if (classes[i] == DEBUG_BASECLASS_NULL)
2155
        return FALSE;
2156
 
2157
      if (**pp != ';')
2158
        return FALSE;
2159
      ++*pp;
2160
    }
2161
 
2162
  classes[i] = DEBUG_BASECLASS_NULL;
2163
 
2164
  *retp = classes;
2165
 
2166
  return TRUE;
2167
}
2168
 
2169
/* Read struct or class data fields.  They have the form:
2170
 
2171
        NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2172
 
2173
   At the end, we see a semicolon instead of a field.
2174
 
2175
   In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2176
   a static field.
2177
 
2178
   The optional VISIBILITY is one of:
2179
 
2180
        '/0'    (VISIBILITY_PRIVATE)
2181
        '/1'    (VISIBILITY_PROTECTED)
2182
        '/2'    (VISIBILITY_PUBLIC)
2183
        '/9'    (VISIBILITY_IGNORE)
2184
 
2185
   or nothing, for C style fields with public visibility.
2186
 
2187
   Returns 1 for success, 0 for failure.  */
2188
 
2189
static bfd_boolean
2190
parse_stab_struct_fields (void *dhandle, struct stab_handle *info,
2191
                          const char **pp, debug_field **retp,
2192
                          bfd_boolean *staticsp)
2193
{
2194
  const char *orig;
2195
  const char *p;
2196
  debug_field *fields;
2197
  unsigned int c;
2198
  unsigned int alloc;
2199
 
2200
  *retp = NULL;
2201
  *staticsp = FALSE;
2202
 
2203
  orig = *pp;
2204
 
2205
  c = 0;
2206
  alloc = 10;
2207
  fields = (debug_field *) xmalloc (alloc * sizeof *fields);
2208
  while (**pp != ';')
2209
    {
2210
      /* FIXME: gdb checks os9k_stabs here.  */
2211
 
2212
      p = *pp;
2213
 
2214
      /* Add 1 to c to leave room for NULL pointer at end.  */
2215
      if (c + 1 >= alloc)
2216
        {
2217
          alloc += 10;
2218
          fields = ((debug_field *)
2219
                    xrealloc (fields, alloc * sizeof *fields));
2220
        }
2221
 
2222
      /* If it starts with CPLUS_MARKER it is a special abbreviation,
2223
         unless the CPLUS_MARKER is followed by an underscore, in
2224
         which case it is just the name of an anonymous type, which we
2225
         should handle like any other type name.  We accept either '$'
2226
         or '.', because a field name can never contain one of these
2227
         characters except as a CPLUS_MARKER.  */
2228
 
2229
      if ((*p == '$' || *p == '.') && p[1] != '_')
2230
        {
2231
          ++*pp;
2232
          if (! parse_stab_cpp_abbrev (dhandle, info, pp, fields + c))
2233
            return FALSE;
2234
          ++c;
2235
          continue;
2236
        }
2237
 
2238
      /* Look for the ':' that separates the field name from the field
2239
         values.  Data members are delimited by a single ':', while member
2240
         functions are delimited by a pair of ':'s.  When we hit the member
2241
         functions (if any), terminate scan loop and return.  */
2242
 
2243
      p = strchr (p, ':');
2244
      if (p == NULL)
2245
        {
2246
          bad_stab (orig);
2247
          return FALSE;
2248
        }
2249
 
2250
      if (p[1] == ':')
2251
        break;
2252
 
2253
      if (! parse_stab_one_struct_field (dhandle, info, pp, p, fields + c,
2254
                                         staticsp))
2255
        return FALSE;
2256
 
2257
      ++c;
2258
    }
2259
 
2260
  fields[c] = DEBUG_FIELD_NULL;
2261
 
2262
  *retp = fields;
2263
 
2264
  return TRUE;
2265
}
2266
 
2267
/* Special GNU C++ name.  */
2268
 
2269
static bfd_boolean
2270
parse_stab_cpp_abbrev (void *dhandle, struct stab_handle *info,
2271
                       const char **pp, debug_field *retp)
2272
{
2273
  const char *orig;
2274
  int cpp_abbrev;
2275
  debug_type context;
2276
  const char *name;
2277
  const char *typename;
2278
  debug_type type;
2279
  bfd_vma bitpos;
2280
 
2281
  *retp = DEBUG_FIELD_NULL;
2282
 
2283
  orig = *pp;
2284
 
2285
  if (**pp != 'v')
2286
    {
2287
      bad_stab (*pp);
2288
      return FALSE;
2289
    }
2290
  ++*pp;
2291
 
2292
  cpp_abbrev = **pp;
2293
  ++*pp;
2294
 
2295
  /* At this point, *pp points to something like "22:23=*22...", where
2296
     the type number before the ':' is the "context" and everything
2297
     after is a regular type definition.  Lookup the type, find it's
2298
     name, and construct the field name.  */
2299
 
2300
  context = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2301
                             (debug_type **) NULL);
2302
  if (context == DEBUG_TYPE_NULL)
2303
    return FALSE;
2304
 
2305
  switch (cpp_abbrev)
2306
    {
2307
    case 'f':
2308
      /* $vf -- a virtual function table pointer.  */
2309
      name = "_vptr$";
2310
      break;
2311
    case 'b':
2312
      /* $vb -- a virtual bsomethingorother */
2313
      typename = debug_get_type_name (dhandle, context);
2314
      if (typename == NULL)
2315
        {
2316
          warn_stab (orig, _("unnamed $vb type"));
2317
          typename = "FOO";
2318
        }
2319
      name = concat ("_vb$", typename, (const char *) NULL);
2320
      break;
2321
    default:
2322
      warn_stab (orig, _("unrecognized C++ abbreviation"));
2323
      name = "INVALID_CPLUSPLUS_ABBREV";
2324
      break;
2325
    }
2326
 
2327
  if (**pp != ':')
2328
    {
2329
      bad_stab (orig);
2330
      return FALSE;
2331
    }
2332
  ++*pp;
2333
 
2334
  type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2335
                          (debug_type **) NULL);
2336
  if (**pp != ',')
2337
    {
2338
      bad_stab (orig);
2339
      return FALSE;
2340
    }
2341
  ++*pp;
2342
 
2343
  bitpos = parse_number (pp, (bfd_boolean *) NULL);
2344
  if (**pp != ';')
2345
    {
2346
      bad_stab (orig);
2347
      return FALSE;
2348
    }
2349
  ++*pp;
2350
 
2351
  *retp = debug_make_field (dhandle, name, type, bitpos, 0,
2352
                            DEBUG_VISIBILITY_PRIVATE);
2353
  if (*retp == DEBUG_FIELD_NULL)
2354
    return FALSE;
2355
 
2356
  return TRUE;
2357
}
2358
 
2359
/* Parse a single field in a struct or union.  */
2360
 
2361
static bfd_boolean
2362
parse_stab_one_struct_field (void *dhandle, struct stab_handle *info,
2363
                             const char **pp, const char *p,
2364
                             debug_field *retp, bfd_boolean *staticsp)
2365
{
2366
  const char *orig;
2367
  char *name;
2368
  enum debug_visibility visibility;
2369
  debug_type type;
2370
  bfd_vma bitpos;
2371
  bfd_vma bitsize;
2372
 
2373
  orig = *pp;
2374
 
2375
  /* FIXME: gdb checks ARM_DEMANGLING here.  */
2376
 
2377
  name = savestring (*pp, p - *pp);
2378
 
2379
  *pp = p + 1;
2380
 
2381
  if (**pp != '/')
2382
    visibility = DEBUG_VISIBILITY_PUBLIC;
2383
  else
2384
    {
2385
      ++*pp;
2386
      switch (**pp)
2387
        {
2388
        case '0':
2389
          visibility = DEBUG_VISIBILITY_PRIVATE;
2390
          break;
2391
        case '1':
2392
          visibility = DEBUG_VISIBILITY_PROTECTED;
2393
          break;
2394
        case '2':
2395
          visibility = DEBUG_VISIBILITY_PUBLIC;
2396
          break;
2397
        default:
2398
          warn_stab (orig, _("unknown visibility character for field"));
2399
          visibility = DEBUG_VISIBILITY_PUBLIC;
2400
          break;
2401
        }
2402
      ++*pp;
2403
    }
2404
 
2405
  type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2406
                          (debug_type **) NULL);
2407
  if (type == DEBUG_TYPE_NULL)
2408
    return FALSE;
2409
 
2410
  if (**pp == ':')
2411
    {
2412
      char *varname;
2413
 
2414
      /* This is a static class member.  */
2415
      ++*pp;
2416
      p = strchr (*pp, ';');
2417
      if (p == NULL)
2418
        {
2419
          bad_stab (orig);
2420
          return FALSE;
2421
        }
2422
 
2423
      varname = savestring (*pp, p - *pp);
2424
 
2425
      *pp = p + 1;
2426
 
2427
      *retp = debug_make_static_member (dhandle, name, type, varname,
2428
                                        visibility);
2429
      *staticsp = TRUE;
2430
 
2431
      return TRUE;
2432
    }
2433
 
2434
  if (**pp != ',')
2435
    {
2436
      bad_stab (orig);
2437
      return FALSE;
2438
    }
2439
  ++*pp;
2440
 
2441
  bitpos = parse_number (pp, (bfd_boolean *) NULL);
2442
  if (**pp != ',')
2443
    {
2444
      bad_stab (orig);
2445
      return FALSE;
2446
    }
2447
  ++*pp;
2448
 
2449
  bitsize = parse_number (pp, (bfd_boolean *) NULL);
2450
  if (**pp != ';')
2451
    {
2452
      bad_stab (orig);
2453
      return FALSE;
2454
    }
2455
  ++*pp;
2456
 
2457
  if (bitpos == 0 && bitsize == 0)
2458
    {
2459
      /* This can happen in two cases: (1) at least for gcc 2.4.5 or
2460
         so, it is a field which has been optimized out.  The correct
2461
         stab for this case is to use VISIBILITY_IGNORE, but that is a
2462
         recent invention.  (2) It is a 0-size array.  For example
2463
         union { int num; char str[0]; } foo.  Printing "<no value>"
2464
         for str in "p foo" is OK, since foo.str (and thus foo.str[3])
2465
         will continue to work, and a 0-size array as a whole doesn't
2466
         have any contents to print.
2467
 
2468
         I suspect this probably could also happen with gcc -gstabs
2469
         (not -gstabs+) for static fields, and perhaps other C++
2470
         extensions.  Hopefully few people use -gstabs with gdb, since
2471
         it is intended for dbx compatibility.  */
2472
      visibility = DEBUG_VISIBILITY_IGNORE;
2473
    }
2474
 
2475
  /* FIXME: gdb does some stuff here to mark fields as unpacked.  */
2476
 
2477
  *retp = debug_make_field (dhandle, name, type, bitpos, bitsize, visibility);
2478
 
2479
  return TRUE;
2480
}
2481
 
2482
/* Read member function stabs info for C++ classes.  The form of each member
2483
   function data is:
2484
 
2485
        NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2486
 
2487
   An example with two member functions is:
2488
 
2489
        afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2490
 
2491
   For the case of overloaded operators, the format is op$::*.funcs, where
2492
   $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2493
   name (such as `+=') and `.' marks the end of the operator name.  */
2494
 
2495
static bfd_boolean
2496
parse_stab_members (void *dhandle, struct stab_handle *info,
2497
                    const char *tagname, const char **pp,
2498
                    const int *typenums, debug_method **retp)
2499
{
2500
  const char *orig;
2501
  debug_method *methods;
2502
  unsigned int c;
2503
  unsigned int alloc;
2504
 
2505
  *retp = NULL;
2506
 
2507
  orig = *pp;
2508
 
2509
  alloc = 0;
2510
  methods = NULL;
2511
  c = 0;
2512
 
2513
  while (**pp != ';')
2514
    {
2515
      const char *p;
2516
      char *name;
2517
      debug_method_variant *variants;
2518
      unsigned int cvars;
2519
      unsigned int allocvars;
2520
      debug_type look_ahead_type;
2521
 
2522
      p = strchr (*pp, ':');
2523
      if (p == NULL || p[1] != ':')
2524
        break;
2525
 
2526
      /* FIXME: Some systems use something other than '$' here.  */
2527
      if ((*pp)[0] != 'o' || (*pp)[1] != 'p' || (*pp)[2] != '$')
2528
        {
2529
          name = savestring (*pp, p - *pp);
2530
          *pp = p + 2;
2531
        }
2532
      else
2533
        {
2534
          /* This is a completely weird case.  In order to stuff in the
2535
             names that might contain colons (the usual name delimiter),
2536
             Mike Tiemann defined a different name format which is
2537
             signalled if the identifier is "op$".  In that case, the
2538
             format is "op$::XXXX." where XXXX is the name.  This is
2539
             used for names like "+" or "=".  YUUUUUUUK!  FIXME!  */
2540
          *pp = p + 2;
2541
          for (p = *pp; *p != '.' && *p != '\0'; p++)
2542
            ;
2543
          if (*p != '.')
2544
            {
2545
              bad_stab (orig);
2546
              return FALSE;
2547
            }
2548
          name = savestring (*pp, p - *pp);
2549
          *pp = p + 1;
2550
        }
2551
 
2552
      allocvars = 10;
2553
      variants = ((debug_method_variant *)
2554
                  xmalloc (allocvars * sizeof *variants));
2555
      cvars = 0;
2556
 
2557
      look_ahead_type = DEBUG_TYPE_NULL;
2558
 
2559
      do
2560
        {
2561
          debug_type type;
2562
          bfd_boolean stub;
2563
          char *argtypes;
2564
          enum debug_visibility visibility;
2565
          bfd_boolean constp, volatilep, staticp;
2566
          bfd_vma voffset;
2567
          debug_type context;
2568
          const char *physname;
2569
          bfd_boolean varargs;
2570
 
2571
          if (look_ahead_type != DEBUG_TYPE_NULL)
2572
            {
2573
              /* g++ version 1 kludge */
2574
              type = look_ahead_type;
2575
              look_ahead_type = DEBUG_TYPE_NULL;
2576
            }
2577
          else
2578
            {
2579
              type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2580
                                      (debug_type **) NULL);
2581
              if (type == DEBUG_TYPE_NULL)
2582
                return FALSE;
2583
              if (**pp != ':')
2584
                {
2585
                  bad_stab (orig);
2586
                  return FALSE;
2587
                }
2588
            }
2589
 
2590
          ++*pp;
2591
          p = strchr (*pp, ';');
2592
          if (p == NULL)
2593
            {
2594
              bad_stab (orig);
2595
              return FALSE;
2596
            }
2597
 
2598
          stub = FALSE;
2599
          if (debug_get_type_kind (dhandle, type) == DEBUG_KIND_METHOD
2600
              && debug_get_parameter_types (dhandle, type, &varargs) == NULL)
2601
            stub = TRUE;
2602
 
2603
          argtypes = savestring (*pp, p - *pp);
2604
          *pp = p + 1;
2605
 
2606
          switch (**pp)
2607
            {
2608
            case '0':
2609
              visibility = DEBUG_VISIBILITY_PRIVATE;
2610
              break;
2611
            case '1':
2612
              visibility = DEBUG_VISIBILITY_PROTECTED;
2613
              break;
2614
            default:
2615
              visibility = DEBUG_VISIBILITY_PUBLIC;
2616
              break;
2617
            }
2618
          ++*pp;
2619
 
2620
          constp = FALSE;
2621
          volatilep = FALSE;
2622
          switch (**pp)
2623
            {
2624
            case 'A':
2625
              /* Normal function.  */
2626
              ++*pp;
2627
              break;
2628
            case 'B':
2629
              /* const member function.  */
2630
              constp = TRUE;
2631
              ++*pp;
2632
              break;
2633
            case 'C':
2634
              /* volatile member function.  */
2635
              volatilep = TRUE;
2636
              ++*pp;
2637
              break;
2638
            case 'D':
2639
              /* const volatile member function.  */
2640
              constp = TRUE;
2641
              volatilep = TRUE;
2642
              ++*pp;
2643
              break;
2644
            case '*':
2645
            case '?':
2646
            case '.':
2647
              /* File compiled with g++ version 1; no information.  */
2648
              break;
2649
            default:
2650
              warn_stab (orig, _("const/volatile indicator missing"));
2651
              break;
2652
            }
2653
 
2654
          staticp = FALSE;
2655
          switch (**pp)
2656
            {
2657
            case '*':
2658
              /* virtual member function, followed by index.  The sign
2659
                 bit is supposedly set to distinguish
2660
                 pointers-to-methods from virtual function indicies.  */
2661
              ++*pp;
2662
              voffset = parse_number (pp, (bfd_boolean *) NULL);
2663
              if (**pp != ';')
2664
                {
2665
                  bad_stab (orig);
2666
                  return FALSE;
2667
                }
2668
              ++*pp;
2669
              voffset &= 0x7fffffff;
2670
 
2671
              if (**pp == ';' || *pp == '\0')
2672
                {
2673
                  /* Must be g++ version 1.  */
2674
                  context = DEBUG_TYPE_NULL;
2675
                }
2676
              else
2677
                {
2678
                  /* Figure out from whence this virtual function
2679
                     came.  It may belong to virtual function table of
2680
                     one of its baseclasses.  */
2681
                  look_ahead_type = parse_stab_type (dhandle, info,
2682
                                                     (const char *) NULL,
2683
                                                     pp,
2684
                                                     (debug_type **) NULL);
2685
                  if (**pp == ':')
2686
                    {
2687
                      /* g++ version 1 overloaded methods.  */
2688
                      context = DEBUG_TYPE_NULL;
2689
                    }
2690
                  else
2691
                    {
2692
                      context = look_ahead_type;
2693
                      look_ahead_type = DEBUG_TYPE_NULL;
2694
                      if (**pp != ';')
2695
                        {
2696
                          bad_stab (orig);
2697
                          return FALSE;
2698
                        }
2699
                      ++*pp;
2700
                    }
2701
                }
2702
              break;
2703
 
2704
            case '?':
2705
              /* static member function.  */
2706
              ++*pp;
2707
              staticp = TRUE;
2708
              voffset = 0;
2709
              context = DEBUG_TYPE_NULL;
2710
              if (strncmp (argtypes, name, strlen (name)) != 0)
2711
                stub = TRUE;
2712
              break;
2713
 
2714
            default:
2715
              warn_stab (orig, "member function type missing");
2716
              voffset = 0;
2717
              context = DEBUG_TYPE_NULL;
2718
              break;
2719
 
2720
            case '.':
2721
              ++*pp;
2722
              voffset = 0;
2723
              context = DEBUG_TYPE_NULL;
2724
              break;
2725
            }
2726
 
2727
          /* If the type is not a stub, then the argtypes string is
2728
             the physical name of the function.  Otherwise the
2729
             argtypes string is the mangled form of the argument
2730
             types, and the full type and the physical name must be
2731
             extracted from them.  */
2732
          if (! stub)
2733
            physname = argtypes;
2734
          else
2735
            {
2736
              debug_type class_type, return_type;
2737
 
2738
              class_type = stab_find_type (dhandle, info, typenums);
2739
              if (class_type == DEBUG_TYPE_NULL)
2740
                return FALSE;
2741
              return_type = debug_get_return_type (dhandle, type);
2742
              if (return_type == DEBUG_TYPE_NULL)
2743
                {
2744
                  bad_stab (orig);
2745
                  return FALSE;
2746
                }
2747
              type = parse_stab_argtypes (dhandle, info, class_type, name,
2748
                                          tagname, return_type, argtypes,
2749
                                          constp, volatilep, &physname);
2750
              if (type == DEBUG_TYPE_NULL)
2751
                return FALSE;
2752
            }
2753
 
2754
          if (cvars + 1 >= allocvars)
2755
            {
2756
              allocvars += 10;
2757
              variants = ((debug_method_variant *)
2758
                          xrealloc (variants,
2759
                                    allocvars * sizeof *variants));
2760
            }
2761
 
2762
          if (! staticp)
2763
            variants[cvars] = debug_make_method_variant (dhandle, physname,
2764
                                                         type, visibility,
2765
                                                         constp, volatilep,
2766
                                                         voffset, context);
2767
          else
2768
            variants[cvars] = debug_make_static_method_variant (dhandle,
2769
                                                                physname,
2770
                                                                type,
2771
                                                                visibility,
2772
                                                                constp,
2773
                                                                volatilep);
2774
          if (variants[cvars] == DEBUG_METHOD_VARIANT_NULL)
2775
            return FALSE;
2776
 
2777
          ++cvars;
2778
        }
2779
      while (**pp != ';' && **pp != '\0');
2780
 
2781
      variants[cvars] = DEBUG_METHOD_VARIANT_NULL;
2782
 
2783
      if (**pp != '\0')
2784
        ++*pp;
2785
 
2786
      if (c + 1 >= alloc)
2787
        {
2788
          alloc += 10;
2789
          methods = ((debug_method *)
2790
                     xrealloc (methods, alloc * sizeof *methods));
2791
        }
2792
 
2793
      methods[c] = debug_make_method (dhandle, name, variants);
2794
 
2795
      ++c;
2796
    }
2797
 
2798
  if (methods != NULL)
2799
    methods[c] = DEBUG_METHOD_NULL;
2800
 
2801
  *retp = methods;
2802
 
2803
  return TRUE;
2804
}
2805
 
2806
/* Parse a string representing argument types for a method.  Stabs
2807
   tries to save space by packing argument types into a mangled
2808
   string.  This string should give us enough information to extract
2809
   both argument types and the physical name of the function, given
2810
   the tag name.  */
2811
 
2812
static debug_type
2813
parse_stab_argtypes (void *dhandle, struct stab_handle *info,
2814
                     debug_type class_type, const char *fieldname,
2815
                     const char *tagname, debug_type return_type,
2816
                     const char *argtypes, bfd_boolean constp,
2817
                     bfd_boolean volatilep, const char **pphysname)
2818
{
2819
  bfd_boolean is_full_physname_constructor;
2820
  bfd_boolean is_constructor;
2821
  bfd_boolean is_destructor;
2822
  bfd_boolean is_v3;
2823
  debug_type *args;
2824
  bfd_boolean varargs;
2825
  unsigned int physname_len = 0;
2826
 
2827
  /* Constructors are sometimes handled specially.  */
2828
  is_full_physname_constructor = ((argtypes[0] == '_'
2829
                                   && argtypes[1] == '_'
2830
                                   && (ISDIGIT (argtypes[2])
2831
                                       || argtypes[2] == 'Q'
2832
                                       || argtypes[2] == 't'))
2833
                                  || CONST_STRNEQ (argtypes, "__ct"));
2834
 
2835
  is_constructor = (is_full_physname_constructor
2836
                    || (tagname != NULL
2837
                        && strcmp (fieldname, tagname) == 0));
2838
  is_destructor = ((argtypes[0] == '_'
2839
                    && (argtypes[1] == '$' || argtypes[1] == '.')
2840
                    && argtypes[2] == '_')
2841
                   || CONST_STRNEQ (argtypes, "__dt"));
2842
  is_v3 = argtypes[0] == '_' && argtypes[1] == 'Z';
2843
 
2844
  if (is_destructor || is_full_physname_constructor || is_v3)
2845
    *pphysname = argtypes;
2846
  else
2847
    {
2848
      unsigned int len;
2849
      const char *const_prefix;
2850
      const char *volatile_prefix;
2851
      char buf[20];
2852
      unsigned int mangled_name_len;
2853
      char *physname;
2854
 
2855
      len = tagname == NULL ? 0 : strlen (tagname);
2856
      const_prefix = constp ? "C" : "";
2857
      volatile_prefix = volatilep ? "V" : "";
2858
 
2859
      if (len == 0)
2860
        sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
2861
      else if (tagname != NULL && strchr (tagname, '<') != NULL)
2862
        {
2863
          /* Template methods are fully mangled.  */
2864
          sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
2865
          tagname = NULL;
2866
          len = 0;
2867
        }
2868
      else
2869
        sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
2870
 
2871
      mangled_name_len = ((is_constructor ? 0 : strlen (fieldname))
2872
                          + strlen (buf)
2873
                          + len
2874
                          + strlen (argtypes)
2875
                          + 1);
2876
 
2877
      if (fieldname[0] == 'o'
2878
          && fieldname[1] == 'p'
2879
          && (fieldname[2] == '$' || fieldname[2] == '.'))
2880
        {
2881
          const char *opname;
2882
 
2883
          opname = cplus_mangle_opname (fieldname + 3, 0);
2884
          if (opname == NULL)
2885
            {
2886
              fprintf (stderr, _("No mangling for \"%s\"\n"), fieldname);
2887
              return DEBUG_TYPE_NULL;
2888
            }
2889
          mangled_name_len += strlen (opname);
2890
          physname = (char *) xmalloc (mangled_name_len);
2891
          strncpy (physname, fieldname, 3);
2892
          strcpy (physname + 3, opname);
2893
        }
2894
      else
2895
        {
2896
          physname = (char *) xmalloc (mangled_name_len);
2897
          if (is_constructor)
2898
            physname[0] = '\0';
2899
          else
2900
            strcpy (physname, fieldname);
2901
        }
2902
 
2903
      physname_len = strlen (physname);
2904
      strcat (physname, buf);
2905
      if (tagname != NULL)
2906
        strcat (physname, tagname);
2907
      strcat (physname, argtypes);
2908
 
2909
      *pphysname = physname;
2910
    }
2911
 
2912
  if (*argtypes == '\0' || is_destructor)
2913
    {
2914
      args = (debug_type *) xmalloc (sizeof *args);
2915
      *args = NULL;
2916
      return debug_make_method_type (dhandle, return_type, class_type, args,
2917
                                     FALSE);
2918
    }
2919
 
2920
  args = stab_demangle_argtypes (dhandle, info, *pphysname, &varargs, physname_len);
2921
  if (args == NULL)
2922
    return DEBUG_TYPE_NULL;
2923
 
2924
  return debug_make_method_type (dhandle, return_type, class_type, args,
2925
                                 varargs);
2926
}
2927
 
2928
/* The tail end of stabs for C++ classes that contain a virtual function
2929
   pointer contains a tilde, a %, and a type number.
2930
   The type number refers to the base class (possibly this class itself) which
2931
   contains the vtable pointer for the current class.
2932
 
2933
   This function is called when we have parsed all the method declarations,
2934
   so we can look for the vptr base class info.  */
2935
 
2936
static bfd_boolean
2937
parse_stab_tilde_field (void *dhandle, struct stab_handle *info,
2938
                        const char **pp, const int *typenums,
2939
                        debug_type *retvptrbase, bfd_boolean *retownvptr)
2940
{
2941
  const char *orig;
2942
  const char *hold;
2943
  int vtypenums[2];
2944
 
2945
  *retvptrbase = DEBUG_TYPE_NULL;
2946
  *retownvptr = FALSE;
2947
 
2948
  orig = *pp;
2949
 
2950
  /* If we are positioned at a ';', then skip it.  */
2951
  if (**pp == ';')
2952
    ++*pp;
2953
 
2954
  if (**pp != '~')
2955
    return TRUE;
2956
 
2957
  ++*pp;
2958
 
2959
  if (**pp == '=' || **pp == '+' || **pp == '-')
2960
    {
2961
      /* Obsolete flags that used to indicate the presence of
2962
         constructors and/or destructors.  */
2963
      ++*pp;
2964
    }
2965
 
2966
  if (**pp != '%')
2967
    return TRUE;
2968
 
2969
  ++*pp;
2970
 
2971
  hold = *pp;
2972
 
2973
  /* The next number is the type number of the base class (possibly
2974
     our own class) which supplies the vtable for this class.  */
2975
  if (! parse_stab_type_number (pp, vtypenums))
2976
    return FALSE;
2977
 
2978
  if (vtypenums[0] == typenums[0]
2979
      && vtypenums[1] == typenums[1])
2980
    *retownvptr = TRUE;
2981
  else
2982
    {
2983
      debug_type vtype;
2984
      const char *p;
2985
 
2986
      *pp = hold;
2987
 
2988
      vtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2989
                               (debug_type **) NULL);
2990
      for (p = *pp; *p != ';' && *p != '\0'; p++)
2991
        ;
2992
      if (*p != ';')
2993
        {
2994
          bad_stab (orig);
2995
          return FALSE;
2996
        }
2997
 
2998
      *retvptrbase = vtype;
2999
 
3000
      *pp = p + 1;
3001
    }
3002
 
3003
  return TRUE;
3004
}
3005
 
3006
/* Read a definition of an array type.  */
3007
 
3008
static debug_type
3009
parse_stab_array_type (void *dhandle, struct stab_handle *info,
3010
                       const char **pp, bfd_boolean stringp)
3011
{
3012
  const char *orig;
3013
  const char *p;
3014
  int typenums[2];
3015
  debug_type index_type;
3016
  bfd_boolean adjustable;
3017
  bfd_signed_vma lower, upper;
3018
  debug_type element_type;
3019
 
3020
  /* Format of an array type:
3021
     "ar<index type>;lower;upper;<array_contents_type>".
3022
     OS9000: "arlower,upper;<array_contents_type>".
3023
 
3024
     Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3025
     for these, produce a type like float[][].  */
3026
 
3027
  orig = *pp;
3028
 
3029
  /* FIXME: gdb checks os9k_stabs here.  */
3030
 
3031
  /* If the index type is type 0, we take it as int.  */
3032
  p = *pp;
3033
  if (! parse_stab_type_number (&p, typenums))
3034
    return DEBUG_TYPE_NULL;
3035
  if (typenums[0] == 0 && typenums[1] == 0 && **pp != '=')
3036
    {
3037
      index_type = debug_find_named_type (dhandle, "int");
3038
      if (index_type == DEBUG_TYPE_NULL)
3039
        {
3040
          index_type = debug_make_int_type (dhandle, 4, FALSE);
3041
          if (index_type == DEBUG_TYPE_NULL)
3042
            return DEBUG_TYPE_NULL;
3043
        }
3044
      *pp = p;
3045
    }
3046
  else
3047
    {
3048
      index_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3049
                                    (debug_type **) NULL);
3050
    }
3051
 
3052
  if (**pp != ';')
3053
    {
3054
      bad_stab (orig);
3055
      return DEBUG_TYPE_NULL;
3056
    }
3057
  ++*pp;
3058
 
3059
  adjustable = FALSE;
3060
 
3061
  if (! ISDIGIT (**pp) && **pp != '-')
3062
    {
3063
      ++*pp;
3064
      adjustable = TRUE;
3065
    }
3066
 
3067
  lower = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
3068
  if (**pp != ';')
3069
    {
3070
      bad_stab (orig);
3071
      return DEBUG_TYPE_NULL;
3072
    }
3073
  ++*pp;
3074
 
3075
  if (! ISDIGIT (**pp) && **pp != '-')
3076
    {
3077
      ++*pp;
3078
      adjustable = TRUE;
3079
    }
3080
 
3081
  upper = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
3082
  if (**pp != ';')
3083
    {
3084
      bad_stab (orig);
3085
      return DEBUG_TYPE_NULL;
3086
    }
3087
  ++*pp;
3088
 
3089
  element_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3090
                                  (debug_type **) NULL);
3091
  if (element_type == DEBUG_TYPE_NULL)
3092
    return DEBUG_TYPE_NULL;
3093
 
3094
  if (adjustable)
3095
    {
3096
      lower = 0;
3097
      upper = -1;
3098
    }
3099
 
3100
  return debug_make_array_type (dhandle, element_type, index_type, lower,
3101
                                upper, stringp);
3102
}
3103
 
3104
/* This struct holds information about files we have seen using
3105
   N_BINCL.  */
3106
 
3107
struct bincl_file
3108
{
3109
  /* The next N_BINCL file.  */
3110
  struct bincl_file *next;
3111
  /* The next N_BINCL on the stack.  */
3112
  struct bincl_file *next_stack;
3113
  /* The file name.  */
3114
  const char *name;
3115
  /* The hash value.  */
3116
  bfd_vma hash;
3117
  /* The file index.  */
3118
  unsigned int file;
3119
  /* The list of types defined in this file.  */
3120
  struct stab_types *file_types;
3121
};
3122
 
3123
/* Start a new N_BINCL file, pushing it onto the stack.  */
3124
 
3125
static void
3126
push_bincl (struct stab_handle *info, const char *name, bfd_vma hash)
3127
{
3128
  struct bincl_file *n;
3129
 
3130
  n = (struct bincl_file *) xmalloc (sizeof *n);
3131
  n->next = info->bincl_list;
3132
  n->next_stack = info->bincl_stack;
3133
  n->name = name;
3134
  n->hash = hash;
3135
  n->file = info->files;
3136
  n->file_types = NULL;
3137
  info->bincl_list = n;
3138
  info->bincl_stack = n;
3139
 
3140
  ++info->files;
3141
  info->file_types = ((struct stab_types **)
3142
                      xrealloc (info->file_types,
3143
                                (info->files
3144
                                 * sizeof *info->file_types)));
3145
  info->file_types[n->file] = NULL;
3146
}
3147
 
3148
/* Finish an N_BINCL file, at an N_EINCL, popping the name off the
3149
   stack.  */
3150
 
3151
static const char *
3152
pop_bincl (struct stab_handle *info)
3153
{
3154
  struct bincl_file *o;
3155
 
3156
  o = info->bincl_stack;
3157
  if (o == NULL)
3158
    return info->main_filename;
3159
  info->bincl_stack = o->next_stack;
3160
 
3161
  o->file_types = info->file_types[o->file];
3162
 
3163
  if (info->bincl_stack == NULL)
3164
    return info->main_filename;
3165
  return info->bincl_stack->name;
3166
}
3167
 
3168
/* Handle an N_EXCL: get the types from the corresponding N_BINCL.  */
3169
 
3170
static bfd_boolean
3171
find_excl (struct stab_handle *info, const char *name, bfd_vma hash)
3172
{
3173
  struct bincl_file *l;
3174
 
3175
  ++info->files;
3176
  info->file_types = ((struct stab_types **)
3177
                      xrealloc (info->file_types,
3178
                                (info->files
3179
                                 * sizeof *info->file_types)));
3180
 
3181
  for (l = info->bincl_list; l != NULL; l = l->next)
3182
    if (l->hash == hash && strcmp (l->name, name) == 0)
3183
      break;
3184
  if (l == NULL)
3185
    {
3186
      warn_stab (name, _("Undefined N_EXCL"));
3187
      info->file_types[info->files - 1] = NULL;
3188
      return TRUE;
3189
    }
3190
 
3191
  info->file_types[info->files - 1] = l->file_types;
3192
 
3193
  return TRUE;
3194
}
3195
 
3196
/* Handle a variable definition.  gcc emits variable definitions for a
3197
   block before the N_LBRAC, so we must hold onto them until we see
3198
   it.  The SunPRO compiler emits variable definitions after the
3199
   N_LBRAC, so we can call debug_record_variable immediately.  */
3200
 
3201
static bfd_boolean
3202
stab_record_variable (void *dhandle, struct stab_handle *info,
3203
                      const char *name, debug_type type,
3204
                      enum debug_var_kind kind, bfd_vma val)
3205
{
3206
  struct stab_pending_var *v;
3207
 
3208
  if ((kind == DEBUG_GLOBAL || kind == DEBUG_STATIC)
3209
      || ! info->within_function
3210
      || (info->gcc_compiled == 0 && info->n_opt_found))
3211
    return debug_record_variable (dhandle, name, type, kind, val);
3212
 
3213
  v = (struct stab_pending_var *) xmalloc (sizeof *v);
3214
  memset (v, 0, sizeof *v);
3215
 
3216
  v->next = info->pending;
3217
  v->name = name;
3218
  v->type = type;
3219
  v->kind = kind;
3220
  v->val = val;
3221
  info->pending = v;
3222
 
3223
  return TRUE;
3224
}
3225
 
3226
/* Emit pending variable definitions.  This is called after we see the
3227
   N_LBRAC that starts the block.  */
3228
 
3229
static bfd_boolean
3230
stab_emit_pending_vars (void *dhandle, struct stab_handle *info)
3231
{
3232
  struct stab_pending_var *v;
3233
 
3234
  v = info->pending;
3235
  while (v != NULL)
3236
    {
3237
      struct stab_pending_var *next;
3238
 
3239
      if (! debug_record_variable (dhandle, v->name, v->type, v->kind, v->val))
3240
        return FALSE;
3241
 
3242
      next = v->next;
3243
      free (v);
3244
      v = next;
3245
    }
3246
 
3247
  info->pending = NULL;
3248
 
3249
  return TRUE;
3250
}
3251
 
3252
/* Find the slot for a type in the database.  */
3253
 
3254
static debug_type *
3255
stab_find_slot (struct stab_handle *info, const int *typenums)
3256
{
3257
  int filenum;
3258
  int index;
3259
  struct stab_types **ps;
3260
 
3261
  filenum = typenums[0];
3262
  index = typenums[1];
3263
 
3264
  if (filenum < 0 || (unsigned int) filenum >= info->files)
3265
    {
3266
      fprintf (stderr, _("Type file number %d out of range\n"), filenum);
3267
      return NULL;
3268
    }
3269
  if (index < 0)
3270
    {
3271
      fprintf (stderr, _("Type index number %d out of range\n"), index);
3272
      return NULL;
3273
    }
3274
 
3275
  ps = info->file_types + filenum;
3276
 
3277
  while (index >= STAB_TYPES_SLOTS)
3278
    {
3279
      if (*ps == NULL)
3280
        {
3281
          *ps = (struct stab_types *) xmalloc (sizeof **ps);
3282
          memset (*ps, 0, sizeof **ps);
3283
        }
3284
      ps = &(*ps)->next;
3285
      index -= STAB_TYPES_SLOTS;
3286
    }
3287
  if (*ps == NULL)
3288
    {
3289
      *ps = (struct stab_types *) xmalloc (sizeof **ps);
3290
      memset (*ps, 0, sizeof **ps);
3291
    }
3292
 
3293
  return (*ps)->types + index;
3294
}
3295
 
3296
/* Find a type given a type number.  If the type has not been
3297
   allocated yet, create an indirect type.  */
3298
 
3299
static debug_type
3300
stab_find_type (void *dhandle, struct stab_handle *info, const int *typenums)
3301
{
3302
  debug_type *slot;
3303
 
3304
  if (typenums[0] == 0 && typenums[1] < 0)
3305
    {
3306
      /* A negative type number indicates an XCOFF builtin type.  */
3307
      return stab_xcoff_builtin_type (dhandle, info, typenums[1]);
3308
    }
3309
 
3310
  slot = stab_find_slot (info, typenums);
3311
  if (slot == NULL)
3312
    return DEBUG_TYPE_NULL;
3313
 
3314
  if (*slot == DEBUG_TYPE_NULL)
3315
    return debug_make_indirect_type (dhandle, slot, (const char *) NULL);
3316
 
3317
  return *slot;
3318
}
3319
 
3320
/* Record that a given type number refers to a given type.  */
3321
 
3322
static bfd_boolean
3323
stab_record_type (void *dhandle ATTRIBUTE_UNUSED, struct stab_handle *info,
3324
                  const int *typenums, debug_type type)
3325
{
3326
  debug_type *slot;
3327
 
3328
  slot = stab_find_slot (info, typenums);
3329
  if (slot == NULL)
3330
    return FALSE;
3331
 
3332
  /* gdb appears to ignore type redefinitions, so we do as well.  */
3333
 
3334
  *slot = type;
3335
 
3336
  return TRUE;
3337
}
3338
 
3339
/* Return an XCOFF builtin type.  */
3340
 
3341
static debug_type
3342
stab_xcoff_builtin_type (void *dhandle, struct stab_handle *info,
3343
                         int typenum)
3344
{
3345
  debug_type rettype;
3346
  const char *name;
3347
 
3348
  if (typenum >= 0 || typenum < -XCOFF_TYPE_COUNT)
3349
    {
3350
      fprintf (stderr, _("Unrecognized XCOFF type %d\n"), typenum);
3351
      return DEBUG_TYPE_NULL;
3352
    }
3353
  if (info->xcoff_types[-typenum] != NULL)
3354
    return info->xcoff_types[-typenum];
3355
 
3356
  switch (-typenum)
3357
    {
3358
    case 1:
3359
      /* The size of this and all the other types are fixed, defined
3360
         by the debugging format.  */
3361
      name = "int";
3362
      rettype = debug_make_int_type (dhandle, 4, FALSE);
3363
      break;
3364
    case 2:
3365
      name = "char";
3366
      rettype = debug_make_int_type (dhandle, 1, FALSE);
3367
      break;
3368
    case 3:
3369
      name = "short";
3370
      rettype = debug_make_int_type (dhandle, 2, FALSE);
3371
      break;
3372
    case 4:
3373
      name = "long";
3374
      rettype = debug_make_int_type (dhandle, 4, FALSE);
3375
      break;
3376
    case 5:
3377
      name = "unsigned char";
3378
      rettype = debug_make_int_type (dhandle, 1, TRUE);
3379
      break;
3380
    case 6:
3381
      name = "signed char";
3382
      rettype = debug_make_int_type (dhandle, 1, FALSE);
3383
      break;
3384
    case 7:
3385
      name = "unsigned short";
3386
      rettype = debug_make_int_type (dhandle, 2, TRUE);
3387
      break;
3388
    case 8:
3389
      name = "unsigned int";
3390
      rettype = debug_make_int_type (dhandle, 4, TRUE);
3391
      break;
3392
    case 9:
3393
      name = "unsigned";
3394
      rettype = debug_make_int_type (dhandle, 4, TRUE);
3395
    case 10:
3396
      name = "unsigned long";
3397
      rettype = debug_make_int_type (dhandle, 4, TRUE);
3398
      break;
3399
    case 11:
3400
      name = "void";
3401
      rettype = debug_make_void_type (dhandle);
3402
      break;
3403
    case 12:
3404
      /* IEEE single precision (32 bit).  */
3405
      name = "float";
3406
      rettype = debug_make_float_type (dhandle, 4);
3407
      break;
3408
    case 13:
3409
      /* IEEE double precision (64 bit).  */
3410
      name = "double";
3411
      rettype = debug_make_float_type (dhandle, 8);
3412
      break;
3413
    case 14:
3414
      /* This is an IEEE double on the RS/6000, and different machines
3415
         with different sizes for "long double" should use different
3416
         negative type numbers.  See stabs.texinfo.  */
3417
      name = "long double";
3418
      rettype = debug_make_float_type (dhandle, 8);
3419
      break;
3420
    case 15:
3421
      name = "integer";
3422
      rettype = debug_make_int_type (dhandle, 4, FALSE);
3423
      break;
3424
    case 16:
3425
      name = "boolean";
3426
      rettype = debug_make_bool_type (dhandle, 4);
3427
      break;
3428
    case 17:
3429
      name = "short real";
3430
      rettype = debug_make_float_type (dhandle, 4);
3431
      break;
3432
    case 18:
3433
      name = "real";
3434
      rettype = debug_make_float_type (dhandle, 8);
3435
      break;
3436
    case 19:
3437
      /* FIXME */
3438
      name = "stringptr";
3439
      rettype = NULL;
3440
      break;
3441
    case 20:
3442
      /* FIXME */
3443
      name = "character";
3444
      rettype = debug_make_int_type (dhandle, 1, TRUE);
3445
      break;
3446
    case 21:
3447
      name = "logical*1";
3448
      rettype = debug_make_bool_type (dhandle, 1);
3449
      break;
3450
    case 22:
3451
      name = "logical*2";
3452
      rettype = debug_make_bool_type (dhandle, 2);
3453
      break;
3454
    case 23:
3455
      name = "logical*4";
3456
      rettype = debug_make_bool_type (dhandle, 4);
3457
      break;
3458
    case 24:
3459
      name = "logical";
3460
      rettype = debug_make_bool_type (dhandle, 4);
3461
      break;
3462
    case 25:
3463
      /* Complex type consisting of two IEEE single precision values.  */
3464
      name = "complex";
3465
      rettype = debug_make_complex_type (dhandle, 8);
3466
      break;
3467
    case 26:
3468
      /* Complex type consisting of two IEEE double precision values.  */
3469
      name = "double complex";
3470
      rettype = debug_make_complex_type (dhandle, 16);
3471
      break;
3472
    case 27:
3473
      name = "integer*1";
3474
      rettype = debug_make_int_type (dhandle, 1, FALSE);
3475
      break;
3476
    case 28:
3477
      name = "integer*2";
3478
      rettype = debug_make_int_type (dhandle, 2, FALSE);
3479
      break;
3480
    case 29:
3481
      name = "integer*4";
3482
      rettype = debug_make_int_type (dhandle, 4, FALSE);
3483
      break;
3484
    case 30:
3485
      /* FIXME */
3486
      name = "wchar";
3487
      rettype = debug_make_int_type (dhandle, 2, FALSE);
3488
      break;
3489
    case 31:
3490
      name = "long long";
3491
      rettype = debug_make_int_type (dhandle, 8, FALSE);
3492
      break;
3493
    case 32:
3494
      name = "unsigned long long";
3495
      rettype = debug_make_int_type (dhandle, 8, TRUE);
3496
      break;
3497
    case 33:
3498
      name = "logical*8";
3499
      rettype = debug_make_bool_type (dhandle, 8);
3500
      break;
3501
    case 34:
3502
      name = "integer*8";
3503
      rettype = debug_make_int_type (dhandle, 8, FALSE);
3504
      break;
3505
    default:
3506
      abort ();
3507
    }
3508
 
3509
  rettype = debug_name_type (dhandle, name, rettype);
3510
 
3511
  info->xcoff_types[-typenum] = rettype;
3512
 
3513
  return rettype;
3514
}
3515
 
3516
/* Find or create a tagged type.  */
3517
 
3518
static debug_type
3519
stab_find_tagged_type (void *dhandle, struct stab_handle *info,
3520
                       const char *p, int len, enum debug_type_kind kind)
3521
{
3522
  char *name;
3523
  debug_type dtype;
3524
  struct stab_tag *st;
3525
 
3526
  name = savestring (p, len);
3527
 
3528
  /* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same
3529
     namespace.  This is right for C, and I don't know how to handle
3530
     other languages.  FIXME.  */
3531
  dtype = debug_find_tagged_type (dhandle, name, DEBUG_KIND_ILLEGAL);
3532
  if (dtype != DEBUG_TYPE_NULL)
3533
    {
3534
      free (name);
3535
      return dtype;
3536
    }
3537
 
3538
  /* We need to allocate an entry on the undefined tag list.  */
3539
  for (st = info->tags; st != NULL; st = st->next)
3540
    {
3541
      if (st->name[0] == name[0]
3542
          && strcmp (st->name, name) == 0)
3543
        {
3544
          if (st->kind == DEBUG_KIND_ILLEGAL)
3545
            st->kind = kind;
3546
          free (name);
3547
          break;
3548
        }
3549
    }
3550
  if (st == NULL)
3551
    {
3552
      st = (struct stab_tag *) xmalloc (sizeof *st);
3553
      memset (st, 0, sizeof *st);
3554
 
3555
      st->next = info->tags;
3556
      st->name = name;
3557
      st->kind = kind;
3558
      st->slot = DEBUG_TYPE_NULL;
3559
      st->type = debug_make_indirect_type (dhandle, &st->slot, name);
3560
      info->tags = st;
3561
    }
3562
 
3563
  return st->type;
3564
}
3565
 
3566
/* In order to get the correct argument types for a stubbed method, we
3567
   need to extract the argument types from a C++ mangled string.
3568
   Since the argument types can refer back to the return type, this
3569
   means that we must demangle the entire physical name.  In gdb this
3570
   is done by calling cplus_demangle and running the results back
3571
   through the C++ expression parser.  Since we have no expression
3572
   parser, we must duplicate much of the work of cplus_demangle here.
3573
 
3574
   We assume that GNU style demangling is used, since this is only
3575
   done for method stubs, and only g++ should output that form of
3576
   debugging information.  */
3577
 
3578
/* This structure is used to hold a pointer to type information which
3579
   demangling a string.  */
3580
 
3581
struct stab_demangle_typestring
3582
{
3583
  /* The start of the type.  This is not null terminated.  */
3584
  const char *typestring;
3585
  /* The length of the type.  */
3586
  unsigned int len;
3587
};
3588
 
3589
/* This structure is used to hold information while demangling a
3590
   string.  */
3591
 
3592
struct stab_demangle_info
3593
{
3594
  /* The debugging information handle.  */
3595
  void *dhandle;
3596
  /* The stab information handle.  */
3597
  struct stab_handle *info;
3598
  /* The array of arguments we are building.  */
3599
  debug_type *args;
3600
  /* Whether the method takes a variable number of arguments.  */
3601
  bfd_boolean varargs;
3602
  /* The array of types we have remembered.  */
3603
  struct stab_demangle_typestring *typestrings;
3604
  /* The number of typestrings.  */
3605
  unsigned int typestring_count;
3606
  /* The number of typestring slots we have allocated.  */
3607
  unsigned int typestring_alloc;
3608
};
3609
 
3610
static void stab_bad_demangle (const char *);
3611
static unsigned int stab_demangle_count (const char **);
3612
static bfd_boolean stab_demangle_get_count (const char **, unsigned int *);
3613
static bfd_boolean stab_demangle_prefix
3614
  (struct stab_demangle_info *, const char **, unsigned int);
3615
static bfd_boolean stab_demangle_function_name
3616
  (struct stab_demangle_info *, const char **, const char *);
3617
static bfd_boolean stab_demangle_signature
3618
  (struct stab_demangle_info *, const char **);
3619
static bfd_boolean stab_demangle_qualified
3620
  (struct stab_demangle_info *, const char **, debug_type *);
3621
static bfd_boolean stab_demangle_template
3622
  (struct stab_demangle_info *, const char **, char **);
3623
static bfd_boolean stab_demangle_class
3624
  (struct stab_demangle_info *, const char **, const char **);
3625
static bfd_boolean stab_demangle_args
3626
  (struct stab_demangle_info *, const char **, debug_type **, bfd_boolean *);
3627
static bfd_boolean stab_demangle_arg
3628
  (struct stab_demangle_info *, const char **, debug_type **,
3629
   unsigned int *, unsigned int *);
3630
static bfd_boolean stab_demangle_type
3631
  (struct stab_demangle_info *, const char **, debug_type *);
3632
static bfd_boolean stab_demangle_fund_type
3633
  (struct stab_demangle_info *, const char **, debug_type *);
3634
static bfd_boolean stab_demangle_remember_type
3635
  (struct stab_demangle_info *, const char *, int);
3636
 
3637
/* Warn about a bad demangling.  */
3638
 
3639
static void
3640
stab_bad_demangle (const char *s)
3641
{
3642
  fprintf (stderr, _("bad mangled name `%s'\n"), s);
3643
}
3644
 
3645
/* Get a count from a stab string.  */
3646
 
3647
static unsigned int
3648
stab_demangle_count (const char **pp)
3649
{
3650
  unsigned int count;
3651
 
3652
  count = 0;
3653
  while (ISDIGIT (**pp))
3654
    {
3655
      count *= 10;
3656
      count += **pp - '0';
3657
      ++*pp;
3658
    }
3659
  return count;
3660
}
3661
 
3662
/* Require a count in a string.  The count may be multiple digits, in
3663
   which case it must end in an underscore.  */
3664
 
3665
static bfd_boolean
3666
stab_demangle_get_count (const char **pp, unsigned int *pi)
3667
{
3668
  if (! ISDIGIT (**pp))
3669
    return FALSE;
3670
 
3671
  *pi = **pp - '0';
3672
  ++*pp;
3673
  if (ISDIGIT (**pp))
3674
    {
3675
      unsigned int count;
3676
      const char *p;
3677
 
3678
      count = *pi;
3679
      p = *pp;
3680
      do
3681
        {
3682
          count *= 10;
3683
          count += *p - '0';
3684
          ++p;
3685
        }
3686
      while (ISDIGIT (*p));
3687
      if (*p == '_')
3688
        {
3689
          *pp = p + 1;
3690
          *pi = count;
3691
        }
3692
    }
3693
 
3694
  return TRUE;
3695
}
3696
 
3697
/* This function demangles a physical name, returning a NULL
3698
   terminated array of argument types.  */
3699
 
3700
static debug_type *
3701
stab_demangle_argtypes (void *dhandle, struct stab_handle *info,
3702
                        const char *physname, bfd_boolean *pvarargs,
3703
                        unsigned int physname_len)
3704
{
3705
  struct stab_demangle_info minfo;
3706
 
3707
  /* Check for the g++ V3 ABI.  */
3708
  if (physname[0] == '_' && physname[1] == 'Z')
3709
    return stab_demangle_v3_argtypes (dhandle, info, physname, pvarargs);
3710
 
3711
  minfo.dhandle = dhandle;
3712
  minfo.info = info;
3713
  minfo.args = NULL;
3714
  minfo.varargs = FALSE;
3715
  minfo.typestring_alloc = 10;
3716
  minfo.typestrings = ((struct stab_demangle_typestring *)
3717
                       xmalloc (minfo.typestring_alloc
3718
                                * sizeof *minfo.typestrings));
3719
  minfo.typestring_count = 0;
3720
 
3721
  /* cplus_demangle checks for special GNU mangled forms, but we can't
3722
     see any of them in mangled method argument types.  */
3723
 
3724
  if (! stab_demangle_prefix (&minfo, &physname, physname_len))
3725
    goto error_return;
3726
 
3727
  if (*physname != '\0')
3728
    {
3729
      if (! stab_demangle_signature (&minfo, &physname))
3730
        goto error_return;
3731
    }
3732
 
3733
  free (minfo.typestrings);
3734
  minfo.typestrings = NULL;
3735
 
3736
  if (minfo.args == NULL)
3737
    fprintf (stderr, _("no argument types in mangled string\n"));
3738
 
3739
  *pvarargs = minfo.varargs;
3740
  return minfo.args;
3741
 
3742
 error_return:
3743
  if (minfo.typestrings != NULL)
3744
    free (minfo.typestrings);
3745
  return NULL;
3746
}
3747
 
3748
/* Demangle the prefix of the mangled name.  */
3749
 
3750
static bfd_boolean
3751
stab_demangle_prefix (struct stab_demangle_info *minfo, const char **pp,
3752
                      unsigned int physname_len)
3753
{
3754
  const char *scan;
3755
  unsigned int i;
3756
 
3757
  /* cplus_demangle checks for global constructors and destructors,
3758
     but we can't see them in mangled argument types.  */
3759
 
3760
  if (physname_len)
3761
    scan = *pp + physname_len;
3762
  else
3763
    {
3764
      /* Look for `__'.  */
3765
      scan = *pp;
3766
      do
3767
        scan = strchr (scan, '_');
3768
      while (scan != NULL && *++scan != '_');
3769
 
3770
      if (scan == NULL)
3771
        {
3772
          stab_bad_demangle (*pp);
3773
          return FALSE;
3774
        }
3775
 
3776
      --scan;
3777
 
3778
      /* We found `__'; move ahead to the last contiguous `__' pair.  */
3779
      i = strspn (scan, "_");
3780
      if (i > 2)
3781
        scan += i - 2;
3782
    }
3783
 
3784
  if (scan == *pp
3785
      && (ISDIGIT (scan[2])
3786
          || scan[2] == 'Q'
3787
          || scan[2] == 't'))
3788
    {
3789
      /* This is a GNU style constructor name.  */
3790
      *pp = scan + 2;
3791
      return TRUE;
3792
    }
3793
  else if (scan == *pp
3794
           && ! ISDIGIT (scan[2])
3795
           && scan[2] != 't')
3796
    {
3797
      /* Look for the `__' that separates the prefix from the
3798
         signature.  */
3799
      while (*scan == '_')
3800
        ++scan;
3801
      scan = strstr (scan, "__");
3802
      if (scan == NULL || scan[2] == '\0')
3803
        {
3804
          stab_bad_demangle (*pp);
3805
          return FALSE;
3806
        }
3807
 
3808
      return stab_demangle_function_name (minfo, pp, scan);
3809
    }
3810
  else if (scan[2] != '\0')
3811
    {
3812
      /* The name doesn't start with `__', but it does contain `__'.  */
3813
      return stab_demangle_function_name (minfo, pp, scan);
3814
    }
3815
  else
3816
    {
3817
      stab_bad_demangle (*pp);
3818
      return FALSE;
3819
    }
3820
  /*NOTREACHED*/
3821
}
3822
 
3823
/* Demangle a function name prefix.  The scan argument points to the
3824
   double underscore which separates the function name from the
3825
   signature.  */
3826
 
3827
static bfd_boolean
3828
stab_demangle_function_name (struct stab_demangle_info *minfo,
3829
                             const char **pp, const char *scan)
3830
{
3831
  const char *name;
3832
 
3833
  /* The string from *pp to scan is the name of the function.  We
3834
     don't care about the name, since we just looking for argument
3835
     types.  However, for conversion operators, the name may include a
3836
     type which we must remember in order to handle backreferences.  */
3837
 
3838
  name = *pp;
3839
  *pp = scan + 2;
3840
 
3841
  if (*pp - name >= 5
3842
           && CONST_STRNEQ (name, "type")
3843
           && (name[4] == '$' || name[4] == '.'))
3844
    {
3845
      const char *tem;
3846
 
3847
      /* This is a type conversion operator.  */
3848
      tem = name + 5;
3849
      if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
3850
        return FALSE;
3851
    }
3852
  else if (name[0] == '_'
3853
           && name[1] == '_'
3854
           && name[2] == 'o'
3855
           && name[3] == 'p')
3856
    {
3857
      const char *tem;
3858
 
3859
      /* This is a type conversion operator.  */
3860
      tem = name + 4;
3861
      if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
3862
        return FALSE;
3863
    }
3864
 
3865
  return TRUE;
3866
}
3867
 
3868
/* Demangle the signature.  This is where the argument types are
3869
   found.  */
3870
 
3871
static bfd_boolean
3872
stab_demangle_signature (struct stab_demangle_info *minfo, const char **pp)
3873
{
3874
  const char *orig;
3875
  bfd_boolean expect_func, func_done;
3876
  const char *hold;
3877
 
3878
  orig = *pp;
3879
 
3880
  expect_func = FALSE;
3881
  func_done = FALSE;
3882
  hold = NULL;
3883
 
3884
  while (**pp != '\0')
3885
    {
3886
      switch (**pp)
3887
        {
3888
        case 'Q':
3889
          hold = *pp;
3890
          if (! stab_demangle_qualified (minfo, pp, (debug_type *) NULL)
3891
              || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
3892
            return FALSE;
3893
          expect_func = TRUE;
3894
          hold = NULL;
3895
          break;
3896
 
3897
        case 'S':
3898
          /* Static member function.  FIXME: Can this happen?  */
3899
          if (hold == NULL)
3900
            hold = *pp;
3901
          ++*pp;
3902
          break;
3903
 
3904
        case 'C':
3905
          /* Const member function.  */
3906
          if (hold == NULL)
3907
            hold = *pp;
3908
          ++*pp;
3909
          break;
3910
 
3911
        case '0': case '1': case '2': case '3': case '4':
3912
        case '5': case '6': case '7': case '8': case '9':
3913
          if (hold == NULL)
3914
            hold = *pp;
3915
          if (! stab_demangle_class (minfo, pp, (const char **) NULL)
3916
              || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
3917
            return FALSE;
3918
          expect_func = TRUE;
3919
          hold = NULL;
3920
          break;
3921
 
3922
        case 'F':
3923
          /* Function.  I don't know if this actually happens with g++
3924
             output.  */
3925
          hold = NULL;
3926
          func_done = TRUE;
3927
          ++*pp;
3928
          if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3929
            return FALSE;
3930
          break;
3931
 
3932
        case 't':
3933
          /* Template.  */
3934
          if (hold == NULL)
3935
            hold = *pp;
3936
          if (! stab_demangle_template (minfo, pp, (char **) NULL)
3937
              || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
3938
            return FALSE;
3939
          hold = NULL;
3940
          expect_func = TRUE;
3941
          break;
3942
 
3943
        case '_':
3944
          /* At the outermost level, we cannot have a return type
3945
             specified, so if we run into another '_' at this point we
3946
             are dealing with a mangled name that is either bogus, or
3947
             has been mangled by some algorithm we don't know how to
3948
             deal with.  So just reject the entire demangling.  */
3949
          stab_bad_demangle (orig);
3950
          return FALSE;
3951
 
3952
        default:
3953
          /* Assume we have stumbled onto the first outermost function
3954
             argument token, and start processing args.  */
3955
          func_done = TRUE;
3956
          if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3957
            return FALSE;
3958
          break;
3959
        }
3960
 
3961
      if (expect_func)
3962
        {
3963
          func_done = TRUE;
3964
          if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3965
            return FALSE;
3966
        }
3967
    }
3968
 
3969
  if (! func_done)
3970
    {
3971
      /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
3972
         bar__3fooi is 'foo::bar(int)'.  We get here when we find the
3973
         first case, and need to ensure that the '(void)' gets added
3974
         to the current declp.  */
3975
      if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3976
        return FALSE;
3977
    }
3978
 
3979
  return TRUE;
3980
}
3981
 
3982
/* Demangle a qualified name, such as "Q25Outer5Inner" which is the
3983
   mangled form of "Outer::Inner".  */
3984
 
3985
static bfd_boolean
3986
stab_demangle_qualified (struct stab_demangle_info *minfo, const char **pp,
3987
                         debug_type *ptype)
3988
{
3989
  const char *orig;
3990
  const char *p;
3991
  unsigned int qualifiers;
3992
  debug_type context;
3993
 
3994
  orig = *pp;
3995
 
3996
  switch ((*pp)[1])
3997
    {
3998
    case '_':
3999
      /* GNU mangled name with more than 9 classes.  The count is
4000
         preceded by an underscore (to distinguish it from the <= 9
4001
         case) and followed by an underscore.  */
4002
      p = *pp + 2;
4003
      if (! ISDIGIT (*p) || *p == '0')
4004
        {
4005
          stab_bad_demangle (orig);
4006
          return FALSE;
4007
        }
4008
      qualifiers = atoi (p);
4009
      while (ISDIGIT (*p))
4010
        ++p;
4011
      if (*p != '_')
4012
        {
4013
          stab_bad_demangle (orig);
4014
          return FALSE;
4015
        }
4016
      *pp = p + 1;
4017
      break;
4018
 
4019
    case '1': case '2': case '3': case '4': case '5':
4020
    case '6': case '7': case '8': case '9':
4021
      qualifiers = (*pp)[1] - '0';
4022
      /* Skip an optional underscore after the count.  */
4023
      if ((*pp)[2] == '_')
4024
        ++*pp;
4025
      *pp += 2;
4026
      break;
4027
 
4028
    case '0':
4029
    default:
4030
      stab_bad_demangle (orig);
4031
      return FALSE;
4032
    }
4033
 
4034
  context = DEBUG_TYPE_NULL;
4035
 
4036
  /* Pick off the names.  */
4037
  while (qualifiers-- > 0)
4038
    {
4039
      if (**pp == '_')
4040
        ++*pp;
4041
      if (**pp == 't')
4042
        {
4043
          char *name;
4044
 
4045
          if (! stab_demangle_template (minfo, pp,
4046
                                        ptype != NULL ? &name : NULL))
4047
            return FALSE;
4048
 
4049
          if (ptype != NULL)
4050
            {
4051
              context = stab_find_tagged_type (minfo->dhandle, minfo->info,
4052
                                               name, strlen (name),
4053
                                               DEBUG_KIND_CLASS);
4054
              free (name);
4055
              if (context == DEBUG_TYPE_NULL)
4056
                return FALSE;
4057
            }
4058
        }
4059
      else
4060
        {
4061
          unsigned int len;
4062
 
4063
          len = stab_demangle_count (pp);
4064
          if (strlen (*pp) < len)
4065
            {
4066
              stab_bad_demangle (orig);
4067
              return FALSE;
4068
            }
4069
 
4070
          if (ptype != NULL)
4071
            {
4072
              const debug_field *fields;
4073
 
4074
              fields = NULL;
4075
              if (context != DEBUG_TYPE_NULL)
4076
                fields = debug_get_fields (minfo->dhandle, context);
4077
 
4078
              context = DEBUG_TYPE_NULL;
4079
 
4080
              if (fields != NULL)
4081
                {
4082
                  char *name;
4083
 
4084
                  /* Try to find the type by looking through the
4085
                     fields of context until we find a field with the
4086
                     same type.  This ought to work for a class
4087
                     defined within a class, but it won't work for,
4088
                     e.g., an enum defined within a class.  stabs does
4089
                     not give us enough information to figure out the
4090
                     latter case.  */
4091
 
4092
                  name = savestring (*pp, len);
4093
 
4094
                  for (; *fields != DEBUG_FIELD_NULL; fields++)
4095
                    {
4096
                      debug_type ft;
4097
                      const char *dn;
4098
 
4099
                      ft = debug_get_field_type (minfo->dhandle, *fields);
4100
                      if (ft == NULL)
4101
                        return FALSE;
4102
                      dn = debug_get_type_name (minfo->dhandle, ft);
4103
                      if (dn != NULL && strcmp (dn, name) == 0)
4104
                        {
4105
                          context = ft;
4106
                          break;
4107
                        }
4108
                    }
4109
 
4110
                  free (name);
4111
                }
4112
 
4113
              if (context == DEBUG_TYPE_NULL)
4114
                {
4115
                  /* We have to fall back on finding the type by name.
4116
                     If there are more types to come, then this must
4117
                     be a class.  Otherwise, it could be anything.  */
4118
 
4119
                  if (qualifiers == 0)
4120
                    {
4121
                      char *name;
4122
 
4123
                      name = savestring (*pp, len);
4124
                      context = debug_find_named_type (minfo->dhandle,
4125
                                                       name);
4126
                      free (name);
4127
                    }
4128
 
4129
                  if (context == DEBUG_TYPE_NULL)
4130
                    {
4131
                      context = stab_find_tagged_type (minfo->dhandle,
4132
                                                       minfo->info,
4133
                                                       *pp, len,
4134
                                                       (qualifiers == 0
4135
                                                        ? DEBUG_KIND_ILLEGAL
4136
                                                        : DEBUG_KIND_CLASS));
4137
                      if (context == DEBUG_TYPE_NULL)
4138
                        return FALSE;
4139
                    }
4140
                }
4141
            }
4142
 
4143
          *pp += len;
4144
        }
4145
    }
4146
 
4147
  if (ptype != NULL)
4148
    *ptype = context;
4149
 
4150
  return TRUE;
4151
}
4152
 
4153
/* Demangle a template.  If PNAME is not NULL, this sets *PNAME to a
4154
   string representation of the template.  */
4155
 
4156
static bfd_boolean
4157
stab_demangle_template (struct stab_demangle_info *minfo, const char **pp,
4158
                        char **pname)
4159
{
4160
  const char *orig;
4161
  unsigned int r, i;
4162
 
4163
  orig = *pp;
4164
 
4165
  ++*pp;
4166
 
4167
  /* Skip the template name.  */
4168
  r = stab_demangle_count (pp);
4169
  if (r == 0 || strlen (*pp) < r)
4170
    {
4171
      stab_bad_demangle (orig);
4172
      return FALSE;
4173
    }
4174
  *pp += r;
4175
 
4176
  /* Get the size of the parameter list.  */
4177
  if (stab_demangle_get_count (pp, &r) == 0)
4178
    {
4179
      stab_bad_demangle (orig);
4180
      return FALSE;
4181
    }
4182
 
4183
  for (i = 0; i < r; i++)
4184
    {
4185
      if (**pp == 'Z')
4186
        {
4187
          /* This is a type parameter.  */
4188
          ++*pp;
4189
          if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
4190
            return FALSE;
4191
        }
4192
      else
4193
        {
4194
          const char *old_p;
4195
          bfd_boolean pointerp, realp, integralp, charp, boolp;
4196
          bfd_boolean done;
4197
 
4198
          old_p = *pp;
4199
          pointerp = FALSE;
4200
          realp = FALSE;
4201
          integralp = FALSE;
4202
          charp = FALSE;
4203
          boolp = FALSE;
4204
          done = FALSE;
4205
 
4206
          /* This is a value parameter.  */
4207
 
4208
          if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
4209
            return FALSE;
4210
 
4211
          while (*old_p != '\0' && ! done)
4212
            {
4213
              switch (*old_p)
4214
                {
4215
                case 'P':
4216
                case 'p':
4217
                case 'R':
4218
                  pointerp = TRUE;
4219
                  done = TRUE;
4220
                  break;
4221
                case 'C':       /* Const.  */
4222
                case 'S':       /* Signed.  */
4223
                case 'U':       /* Unsigned.  */
4224
                case 'V':       /* Volatile.  */
4225
                case 'F':       /* Function.  */
4226
                case 'M':       /* Member function.  */
4227
                case 'O':       /* ??? */
4228
                  ++old_p;
4229
                  break;
4230
                case 'Q':       /* Qualified name.  */
4231
                  integralp = TRUE;
4232
                  done = TRUE;
4233
                  break;
4234
                case 'T':       /* Remembered type.  */
4235
                  abort ();
4236
                case 'v':       /* Void.  */
4237
                  abort ();
4238
                case 'x':       /* Long long.  */
4239
                case 'l':       /* Long.  */
4240
                case 'i':       /* Int.  */
4241
                case 's':       /* Short.  */
4242
                case 'w':       /* Wchar_t.  */
4243
                  integralp = TRUE;
4244
                  done = TRUE;
4245
                  break;
4246
                case 'b':       /* Bool.  */
4247
                  boolp = TRUE;
4248
                  done = TRUE;
4249
                  break;
4250
                case 'c':       /* Char.  */
4251
                  charp = TRUE;
4252
                  done = TRUE;
4253
                  break;
4254
                case 'r':       /* Long double.  */
4255
                case 'd':       /* Double.  */
4256
                case 'f':       /* Float.  */
4257
                  realp = TRUE;
4258
                  done = TRUE;
4259
                  break;
4260
                default:
4261
                  /* Assume it's a user defined integral type.  */
4262
                  integralp = TRUE;
4263
                  done = TRUE;
4264
                  break;
4265
                }
4266
            }
4267
 
4268
          if (integralp)
4269
            {
4270
              if (**pp == 'm')
4271
                ++*pp;
4272
              while (ISDIGIT (**pp))
4273
                ++*pp;
4274
            }
4275
          else if (charp)
4276
            {
4277
              unsigned int val;
4278
 
4279
              if (**pp == 'm')
4280
                ++*pp;
4281
              val = stab_demangle_count (pp);
4282
              if (val == 0)
4283
                {
4284
                  stab_bad_demangle (orig);
4285
                  return FALSE;
4286
                }
4287
            }
4288
          else if (boolp)
4289
            {
4290
              unsigned int val;
4291
 
4292
              val = stab_demangle_count (pp);
4293
              if (val != 0 && val != 1)
4294
                {
4295
                  stab_bad_demangle (orig);
4296
                  return FALSE;
4297
                }
4298
            }
4299
          else if (realp)
4300
            {
4301
              if (**pp == 'm')
4302
                ++*pp;
4303
              while (ISDIGIT (**pp))
4304
                ++*pp;
4305
              if (**pp == '.')
4306
                {
4307
                  ++*pp;
4308
                  while (ISDIGIT (**pp))
4309
                    ++*pp;
4310
                }
4311
              if (**pp == 'e')
4312
                {
4313
                  ++*pp;
4314
                  while (ISDIGIT (**pp))
4315
                    ++*pp;
4316
                }
4317
            }
4318
          else if (pointerp)
4319
            {
4320
              unsigned int len;
4321
 
4322
              len = stab_demangle_count (pp);
4323
              if (len == 0)
4324
                {
4325
                  stab_bad_demangle (orig);
4326
                  return FALSE;
4327
                }
4328
              *pp += len;
4329
            }
4330
        }
4331
    }
4332
 
4333
  /* We can translate this to a string fairly easily by invoking the
4334
     regular demangling routine.  */
4335
  if (pname != NULL)
4336
    {
4337
      char *s1, *s2, *s3, *s4 = NULL;
4338
      char *from, *to;
4339
 
4340
      s1 = savestring (orig, *pp - orig);
4341
 
4342
      s2 = concat ("NoSuchStrinG__", s1, (const char *) NULL);
4343
 
4344
      free (s1);
4345
 
4346
      s3 = cplus_demangle (s2, DMGL_ANSI);
4347
 
4348
      free (s2);
4349
 
4350
      if (s3 != NULL)
4351
        s4 = strstr (s3, "::NoSuchStrinG");
4352
      if (s3 == NULL || s4 == NULL)
4353
        {
4354
          stab_bad_demangle (orig);
4355
          if (s3 != NULL)
4356
            free (s3);
4357
          return FALSE;
4358
        }
4359
 
4360
      /* Eliminating all spaces, except those between > characters,
4361
         makes it more likely that the demangled name will match the
4362
         name which g++ used as the structure name.  */
4363
      for (from = to = s3; from != s4; ++from)
4364
        if (*from != ' '
4365
            || (from[1] == '>' && from > s3 && from[-1] == '>'))
4366
          *to++ = *from;
4367
 
4368
      *pname = savestring (s3, to - s3);
4369
 
4370
      free (s3);
4371
    }
4372
 
4373
  return TRUE;
4374
}
4375
 
4376
/* Demangle a class name.  */
4377
 
4378
static bfd_boolean
4379
stab_demangle_class (struct stab_demangle_info *minfo ATTRIBUTE_UNUSED,
4380
                     const char **pp, const char **pstart)
4381
{
4382
  const char *orig;
4383
  unsigned int n;
4384
 
4385
  orig = *pp;
4386
 
4387
  n = stab_demangle_count (pp);
4388
  if (strlen (*pp) < n)
4389
    {
4390
      stab_bad_demangle (orig);
4391
      return FALSE;
4392
    }
4393
 
4394
  if (pstart != NULL)
4395
    *pstart = *pp;
4396
 
4397
  *pp += n;
4398
 
4399
  return TRUE;
4400
}
4401
 
4402
/* Demangle function arguments.  If the pargs argument is not NULL, it
4403
   is set to a NULL terminated array holding the arguments.  */
4404
 
4405
static bfd_boolean
4406
stab_demangle_args (struct stab_demangle_info *minfo, const char **pp,
4407
                    debug_type **pargs, bfd_boolean *pvarargs)
4408
{
4409
  const char *orig;
4410
  unsigned int alloc, count;
4411
 
4412
  orig = *pp;
4413
 
4414
  alloc = 10;
4415
  if (pargs != NULL)
4416
    {
4417
      *pargs = (debug_type *) xmalloc (alloc * sizeof **pargs);
4418
      *pvarargs = FALSE;
4419
    }
4420
  count = 0;
4421
 
4422
  while (**pp != '_' && **pp != '\0' && **pp != 'e')
4423
    {
4424
      if (**pp == 'N' || **pp == 'T')
4425
        {
4426
          char temptype;
4427
          unsigned int r, t;
4428
 
4429
          temptype = **pp;
4430
          ++*pp;
4431
 
4432
          if (temptype == 'T')
4433
            r = 1;
4434
          else
4435
            {
4436
              if (! stab_demangle_get_count (pp, &r))
4437
                {
4438
                  stab_bad_demangle (orig);
4439
                  return FALSE;
4440
                }
4441
            }
4442
 
4443
          if (! stab_demangle_get_count (pp, &t))
4444
            {
4445
              stab_bad_demangle (orig);
4446
              return FALSE;
4447
            }
4448
 
4449
          if (t >= minfo->typestring_count)
4450
            {
4451
              stab_bad_demangle (orig);
4452
              return FALSE;
4453
            }
4454
          while (r-- > 0)
4455
            {
4456
              const char *tem;
4457
 
4458
              tem = minfo->typestrings[t].typestring;
4459
              if (! stab_demangle_arg (minfo, &tem, pargs, &count, &alloc))
4460
                return FALSE;
4461
            }
4462
        }
4463
      else
4464
        {
4465
          if (! stab_demangle_arg (minfo, pp, pargs, &count, &alloc))
4466
            return FALSE;
4467
        }
4468
    }
4469
 
4470
  if (pargs != NULL)
4471
    (*pargs)[count] = DEBUG_TYPE_NULL;
4472
 
4473
  if (**pp == 'e')
4474
    {
4475
      if (pargs != NULL)
4476
        *pvarargs = TRUE;
4477
      ++*pp;
4478
    }
4479
 
4480
  return TRUE;
4481
}
4482
 
4483
/* Demangle a single argument.  */
4484
 
4485
static bfd_boolean
4486
stab_demangle_arg (struct stab_demangle_info *minfo, const char **pp,
4487
                   debug_type **pargs, unsigned int *pcount,
4488
                   unsigned int *palloc)
4489
{
4490
  const char *start;
4491
  debug_type type;
4492
 
4493
  start = *pp;
4494
  if (! stab_demangle_type (minfo, pp,
4495
                            pargs == NULL ? (debug_type *) NULL : &type)
4496
      || ! stab_demangle_remember_type (minfo, start, *pp - start))
4497
    return FALSE;
4498
 
4499
  if (pargs != NULL)
4500
    {
4501
      if (type == DEBUG_TYPE_NULL)
4502
        return FALSE;
4503
 
4504
      if (*pcount + 1 >= *palloc)
4505
        {
4506
          *palloc += 10;
4507
          *pargs = ((debug_type *)
4508
                    xrealloc (*pargs, *palloc * sizeof **pargs));
4509
        }
4510
      (*pargs)[*pcount] = type;
4511
      ++*pcount;
4512
    }
4513
 
4514
  return TRUE;
4515
}
4516
 
4517
/* Demangle a type.  If the ptype argument is not NULL, *ptype is set
4518
   to the newly allocated type.  */
4519
 
4520
static bfd_boolean
4521
stab_demangle_type (struct stab_demangle_info *minfo, const char **pp,
4522
                    debug_type *ptype)
4523
{
4524
  const char *orig;
4525
 
4526
  orig = *pp;
4527
 
4528
  switch (**pp)
4529
    {
4530
    case 'P':
4531
    case 'p':
4532
      /* A pointer type.  */
4533
      ++*pp;
4534
      if (! stab_demangle_type (minfo, pp, ptype))
4535
        return FALSE;
4536
      if (ptype != NULL)
4537
        *ptype = debug_make_pointer_type (minfo->dhandle, *ptype);
4538
      break;
4539
 
4540
    case 'R':
4541
      /* A reference type.  */
4542
      ++*pp;
4543
      if (! stab_demangle_type (minfo, pp, ptype))
4544
        return FALSE;
4545
      if (ptype != NULL)
4546
        *ptype = debug_make_reference_type (minfo->dhandle, *ptype);
4547
      break;
4548
 
4549
    case 'A':
4550
      /* An array.  */
4551
      {
4552
        unsigned long high;
4553
 
4554
        ++*pp;
4555
        high = 0;
4556
        while (**pp != '\0' && **pp != '_')
4557
          {
4558
            if (! ISDIGIT (**pp))
4559
              {
4560
                stab_bad_demangle (orig);
4561
                return FALSE;
4562
              }
4563
            high *= 10;
4564
            high += **pp - '0';
4565
            ++*pp;
4566
          }
4567
        if (**pp != '_')
4568
          {
4569
            stab_bad_demangle (orig);
4570
            return FALSE;
4571
          }
4572
        ++*pp;
4573
 
4574
        if (! stab_demangle_type (minfo, pp, ptype))
4575
          return FALSE;
4576
        if (ptype != NULL)
4577
          {
4578
            debug_type int_type;
4579
 
4580
            int_type = debug_find_named_type (minfo->dhandle, "int");
4581
            if (int_type == NULL)
4582
              int_type = debug_make_int_type (minfo->dhandle, 4, FALSE);
4583
            *ptype = debug_make_array_type (minfo->dhandle, *ptype, int_type,
4584
                                            0, high, FALSE);
4585
          }
4586
      }
4587
      break;
4588
 
4589
    case 'T':
4590
      /* A back reference to a remembered type.  */
4591
      {
4592
        unsigned int i;
4593
        const char *p;
4594
 
4595
        ++*pp;
4596
        if (! stab_demangle_get_count (pp, &i))
4597
          {
4598
            stab_bad_demangle (orig);
4599
            return FALSE;
4600
          }
4601
        if (i >= minfo->typestring_count)
4602
          {
4603
            stab_bad_demangle (orig);
4604
            return FALSE;
4605
          }
4606
        p = minfo->typestrings[i].typestring;
4607
        if (! stab_demangle_type (minfo, &p, ptype))
4608
          return FALSE;
4609
      }
4610
      break;
4611
 
4612
    case 'F':
4613
      /* A function.  */
4614
      {
4615
        debug_type *args;
4616
        bfd_boolean varargs;
4617
 
4618
        ++*pp;
4619
        if (! stab_demangle_args (minfo, pp,
4620
                                  (ptype == NULL
4621
                                   ? (debug_type **) NULL
4622
                                   : &args),
4623
                                  (ptype == NULL
4624
                                   ? (bfd_boolean *) NULL
4625
                                   : &varargs)))
4626
          return FALSE;
4627
        if (**pp != '_')
4628
          {
4629
            /* cplus_demangle will accept a function without a return
4630
               type, but I don't know when that will happen, or what
4631
               to do if it does.  */
4632
            stab_bad_demangle (orig);
4633
            return FALSE;
4634
          }
4635
        ++*pp;
4636
        if (! stab_demangle_type (minfo, pp, ptype))
4637
          return FALSE;
4638
        if (ptype != NULL)
4639
          *ptype = debug_make_function_type (minfo->dhandle, *ptype, args,
4640
                                             varargs);
4641
 
4642
      }
4643
      break;
4644
 
4645
    case 'M':
4646
    case 'O':
4647
      {
4648
        bfd_boolean memberp, constp, volatilep;
4649
        debug_type class_type = DEBUG_TYPE_NULL;
4650
        debug_type *args;
4651
        bfd_boolean varargs;
4652
        unsigned int n;
4653
        const char *name;
4654
 
4655
        memberp = **pp == 'M';
4656
        constp = FALSE;
4657
        volatilep = FALSE;
4658
        args = NULL;
4659
        varargs = FALSE;
4660
 
4661
        ++*pp;
4662
        if (ISDIGIT (**pp))
4663
          {
4664
            n = stab_demangle_count (pp);
4665
            if (strlen (*pp) < n)
4666
              {
4667
                stab_bad_demangle (orig);
4668
                return FALSE;
4669
              }
4670
            name = *pp;
4671
            *pp += n;
4672
 
4673
            if (ptype != NULL)
4674
              {
4675
                class_type = stab_find_tagged_type (minfo->dhandle,
4676
                                                    minfo->info,
4677
                                                    name, (int) n,
4678
                                                    DEBUG_KIND_CLASS);
4679
                if (class_type == DEBUG_TYPE_NULL)
4680
                  return FALSE;
4681
              }
4682
          }
4683
        else if (**pp == 'Q')
4684
          {
4685
            if (! stab_demangle_qualified (minfo, pp,
4686
                                           (ptype == NULL
4687
                                            ? (debug_type *) NULL
4688
                                            : &class_type)))
4689
              return FALSE;
4690
          }
4691
        else
4692
          {
4693
            stab_bad_demangle (orig);
4694
            return FALSE;
4695
          }
4696
 
4697
        if (memberp)
4698
          {
4699
            if (**pp == 'C')
4700
              {
4701
                constp = TRUE;
4702
                ++*pp;
4703
              }
4704
            else if (**pp == 'V')
4705
              {
4706
                volatilep = TRUE;
4707
                ++*pp;
4708
              }
4709
            if (**pp != 'F')
4710
              {
4711
                stab_bad_demangle (orig);
4712
                return FALSE;
4713
              }
4714
            ++*pp;
4715
            if (! stab_demangle_args (minfo, pp,
4716
                                      (ptype == NULL
4717
                                       ? (debug_type **) NULL
4718
                                       : &args),
4719
                                      (ptype == NULL
4720
                                       ? (bfd_boolean *) NULL
4721
                                       : &varargs)))
4722
              return FALSE;
4723
          }
4724
 
4725
        if (**pp != '_')
4726
          {
4727
            stab_bad_demangle (orig);
4728
            return FALSE;
4729
          }
4730
        ++*pp;
4731
 
4732
        if (! stab_demangle_type (minfo, pp, ptype))
4733
          return FALSE;
4734
 
4735
        if (ptype != NULL)
4736
          {
4737
            if (! memberp)
4738
              *ptype = debug_make_offset_type (minfo->dhandle, class_type,
4739
                                               *ptype);
4740
            else
4741
              {
4742
                /* FIXME: We have no way to record constp or
4743
                   volatilep.  */
4744
                *ptype = debug_make_method_type (minfo->dhandle, *ptype,
4745
                                                 class_type, args, varargs);
4746
              }
4747
          }
4748
      }
4749
      break;
4750
 
4751
    case 'G':
4752
      ++*pp;
4753
      if (! stab_demangle_type (minfo, pp, ptype))
4754
        return FALSE;
4755
      break;
4756
 
4757
    case 'C':
4758
      ++*pp;
4759
      if (! stab_demangle_type (minfo, pp, ptype))
4760
        return FALSE;
4761
      if (ptype != NULL)
4762
        *ptype = debug_make_const_type (minfo->dhandle, *ptype);
4763
      break;
4764
 
4765
    case 'Q':
4766
      {
4767
        const char *hold;
4768
 
4769
        hold = *pp;
4770
        if (! stab_demangle_qualified (minfo, pp, ptype))
4771
          return FALSE;
4772
      }
4773
      break;
4774
 
4775
    default:
4776
      if (! stab_demangle_fund_type (minfo, pp, ptype))
4777
        return FALSE;
4778
      break;
4779
    }
4780
 
4781
  return TRUE;
4782
}
4783
 
4784
/* Demangle a fundamental type.  If the ptype argument is not NULL,
4785
   *ptype is set to the newly allocated type.  */
4786
 
4787
static bfd_boolean
4788
stab_demangle_fund_type (struct stab_demangle_info *minfo, const char **pp,
4789
                         debug_type *ptype)
4790
{
4791
  const char *orig;
4792
  bfd_boolean constp, volatilep, unsignedp, signedp;
4793
  bfd_boolean done;
4794
 
4795
  orig = *pp;
4796
 
4797
  constp = FALSE;
4798
  volatilep = FALSE;
4799
  unsignedp = FALSE;
4800
  signedp = FALSE;
4801
 
4802
  done = FALSE;
4803
  while (! done)
4804
    {
4805
      switch (**pp)
4806
        {
4807
        case 'C':
4808
          constp = TRUE;
4809
          ++*pp;
4810
          break;
4811
 
4812
        case 'U':
4813
          unsignedp = TRUE;
4814
          ++*pp;
4815
          break;
4816
 
4817
        case 'S':
4818
          signedp = TRUE;
4819
          ++*pp;
4820
          break;
4821
 
4822
        case 'V':
4823
          volatilep = TRUE;
4824
          ++*pp;
4825
          break;
4826
 
4827
        default:
4828
          done = TRUE;
4829
          break;
4830
        }
4831
    }
4832
 
4833
  switch (**pp)
4834
    {
4835
    case '\0':
4836
    case '_':
4837
      /* cplus_demangle permits this, but I don't know what it means.  */
4838
      stab_bad_demangle (orig);
4839
      break;
4840
 
4841
    case 'v': /* void */
4842
      if (ptype != NULL)
4843
        {
4844
          *ptype = debug_find_named_type (minfo->dhandle, "void");
4845
          if (*ptype == DEBUG_TYPE_NULL)
4846
            *ptype = debug_make_void_type (minfo->dhandle);
4847
        }
4848
      ++*pp;
4849
      break;
4850
 
4851
    case 'x': /* long long */
4852
      if (ptype != NULL)
4853
        {
4854
          *ptype = debug_find_named_type (minfo->dhandle,
4855
                                          (unsignedp
4856
                                           ? "long long unsigned int"
4857
                                           : "long long int"));
4858
          if (*ptype == DEBUG_TYPE_NULL)
4859
            *ptype = debug_make_int_type (minfo->dhandle, 8, unsignedp);
4860
        }
4861
      ++*pp;
4862
      break;
4863
 
4864
    case 'l': /* long */
4865
      if (ptype != NULL)
4866
        {
4867
          *ptype = debug_find_named_type (minfo->dhandle,
4868
                                          (unsignedp
4869
                                           ? "long unsigned int"
4870
                                           : "long int"));
4871
          if (*ptype == DEBUG_TYPE_NULL)
4872
            *ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp);
4873
        }
4874
      ++*pp;
4875
      break;
4876
 
4877
    case 'i': /* int */
4878
      if (ptype != NULL)
4879
        {
4880
          *ptype = debug_find_named_type (minfo->dhandle,
4881
                                          (unsignedp
4882
                                           ? "unsigned int"
4883
                                           : "int"));
4884
          if (*ptype == DEBUG_TYPE_NULL)
4885
            *ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp);
4886
        }
4887
      ++*pp;
4888
      break;
4889
 
4890
    case 's': /* short */
4891
      if (ptype != NULL)
4892
        {
4893
          *ptype = debug_find_named_type (minfo->dhandle,
4894
                                          (unsignedp
4895
                                           ? "short unsigned int"
4896
                                           : "short int"));
4897
          if (*ptype == DEBUG_TYPE_NULL)
4898
            *ptype = debug_make_int_type (minfo->dhandle, 2, unsignedp);
4899
        }
4900
      ++*pp;
4901
      break;
4902
 
4903
    case 'b': /* bool */
4904
      if (ptype != NULL)
4905
        {
4906
          *ptype = debug_find_named_type (minfo->dhandle, "bool");
4907
          if (*ptype == DEBUG_TYPE_NULL)
4908
            *ptype = debug_make_bool_type (minfo->dhandle, 4);
4909
        }
4910
      ++*pp;
4911
      break;
4912
 
4913
    case 'c': /* char */
4914
      if (ptype != NULL)
4915
        {
4916
          *ptype = debug_find_named_type (minfo->dhandle,
4917
                                          (unsignedp
4918
                                           ? "unsigned char"
4919
                                           : (signedp
4920
                                              ? "signed char"
4921
                                              : "char")));
4922
          if (*ptype == DEBUG_TYPE_NULL)
4923
            *ptype = debug_make_int_type (minfo->dhandle, 1, unsignedp);
4924
        }
4925
      ++*pp;
4926
      break;
4927
 
4928
    case 'w': /* wchar_t */
4929
      if (ptype != NULL)
4930
        {
4931
          *ptype = debug_find_named_type (minfo->dhandle, "__wchar_t");
4932
          if (*ptype == DEBUG_TYPE_NULL)
4933
            *ptype = debug_make_int_type (minfo->dhandle, 2, TRUE);
4934
        }
4935
      ++*pp;
4936
      break;
4937
 
4938
    case 'r': /* long double */
4939
      if (ptype != NULL)
4940
        {
4941
          *ptype = debug_find_named_type (minfo->dhandle, "long double");
4942
          if (*ptype == DEBUG_TYPE_NULL)
4943
            *ptype = debug_make_float_type (minfo->dhandle, 8);
4944
        }
4945
      ++*pp;
4946
      break;
4947
 
4948
    case 'd': /* double */
4949
      if (ptype != NULL)
4950
        {
4951
          *ptype = debug_find_named_type (minfo->dhandle, "double");
4952
          if (*ptype == DEBUG_TYPE_NULL)
4953
            *ptype = debug_make_float_type (minfo->dhandle, 8);
4954
        }
4955
      ++*pp;
4956
      break;
4957
 
4958
    case 'f': /* float */
4959
      if (ptype != NULL)
4960
        {
4961
          *ptype = debug_find_named_type (minfo->dhandle, "float");
4962
          if (*ptype == DEBUG_TYPE_NULL)
4963
            *ptype = debug_make_float_type (minfo->dhandle, 4);
4964
        }
4965
      ++*pp;
4966
      break;
4967
 
4968
    case 'G':
4969
      ++*pp;
4970
      if (! ISDIGIT (**pp))
4971
        {
4972
          stab_bad_demangle (orig);
4973
          return FALSE;
4974
        }
4975
      /* Fall through.  */
4976
    case '0': case '1': case '2': case '3': case '4':
4977
    case '5': case '6': case '7': case '8': case '9':
4978
      {
4979
        const char *hold;
4980
 
4981
        if (! stab_demangle_class (minfo, pp, &hold))
4982
          return FALSE;
4983
        if (ptype != NULL)
4984
          {
4985
            char *name;
4986
 
4987
            name = savestring (hold, *pp - hold);
4988
            *ptype = debug_find_named_type (minfo->dhandle, name);
4989
            free (name);
4990
            if (*ptype == DEBUG_TYPE_NULL)
4991
              {
4992
                /* FIXME: It is probably incorrect to assume that
4993
                   undefined types are tagged types.  */
4994
                *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
4995
                                                hold, *pp - hold,
4996
                                                DEBUG_KIND_ILLEGAL);
4997
                if (*ptype == DEBUG_TYPE_NULL)
4998
                  return FALSE;
4999
              }
5000
          }
5001
      }
5002
      break;
5003
 
5004
    case 't':
5005
      {
5006
        char *name;
5007
 
5008
        if (! stab_demangle_template (minfo, pp,
5009
                                      ptype != NULL ? &name : NULL))
5010
          return FALSE;
5011
        if (ptype != NULL)
5012
          {
5013
            *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
5014
                                            name, strlen (name),
5015
                                            DEBUG_KIND_CLASS);
5016
            free (name);
5017
            if (*ptype == DEBUG_TYPE_NULL)
5018
              return FALSE;
5019
          }
5020
      }
5021
      break;
5022
 
5023
    default:
5024
      stab_bad_demangle (orig);
5025
      return FALSE;
5026
    }
5027
 
5028
  if (ptype != NULL)
5029
    {
5030
      if (constp)
5031
        *ptype = debug_make_const_type (minfo->dhandle, *ptype);
5032
      if (volatilep)
5033
        *ptype = debug_make_volatile_type (minfo->dhandle, *ptype);
5034
    }
5035
 
5036
  return TRUE;
5037
}
5038
 
5039
/* Remember a type string in a demangled string.  */
5040
 
5041
static bfd_boolean
5042
stab_demangle_remember_type (struct stab_demangle_info *minfo,
5043
                             const char *p, int len)
5044
{
5045
  if (minfo->typestring_count >= minfo->typestring_alloc)
5046
    {
5047
      minfo->typestring_alloc += 10;
5048
      minfo->typestrings = ((struct stab_demangle_typestring *)
5049
                            xrealloc (minfo->typestrings,
5050
                                      (minfo->typestring_alloc
5051
                                       * sizeof *minfo->typestrings)));
5052
    }
5053
 
5054
  minfo->typestrings[minfo->typestring_count].typestring = p;
5055
  minfo->typestrings[minfo->typestring_count].len = (unsigned int) len;
5056
  ++minfo->typestring_count;
5057
 
5058
  return TRUE;
5059
}
5060
 
5061
/* Demangle names encoded using the g++ V3 ABI.  The newer versions of
5062
   g++ which use this ABI do not encode ordinary method argument types
5063
   in a mangled name; they simply output the argument types.  However,
5064
   for a static method, g++ simply outputs the return type and the
5065
   physical name.  So in that case we need to demangle the name here.
5066
   Here PHYSNAME is the physical name of the function, and we set the
5067
   variable pointed at by PVARARGS to indicate whether this function
5068
   is varargs.  This returns NULL, or a NULL terminated array of
5069
   argument types.  */
5070
 
5071
static debug_type *
5072
stab_demangle_v3_argtypes (void *dhandle, struct stab_handle *info,
5073
                           const char *physname, bfd_boolean *pvarargs)
5074
{
5075
  struct demangle_component *dc;
5076
  void *mem;
5077
  debug_type *pargs;
5078
 
5079
  dc = cplus_demangle_v3_components (physname, DMGL_PARAMS | DMGL_ANSI, &mem);
5080
  if (dc == NULL)
5081
    {
5082
      stab_bad_demangle (physname);
5083
      return NULL;
5084
    }
5085
 
5086
  /* We expect to see TYPED_NAME, and the right subtree describes the
5087
     function type.  */
5088
  if (dc->type != DEMANGLE_COMPONENT_TYPED_NAME
5089
      || dc->u.s_binary.right->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
5090
    {
5091
      fprintf (stderr, _("Demangled name is not a function\n"));
5092
      free (mem);
5093
      return NULL;
5094
    }
5095
 
5096
  pargs = stab_demangle_v3_arglist (dhandle, info,
5097
                                    dc->u.s_binary.right->u.s_binary.right,
5098
                                    pvarargs);
5099
 
5100
  free (mem);
5101
 
5102
  return pargs;
5103
}
5104
 
5105
/* Demangle an argument list in a struct demangle_component tree.
5106
   Returns a DEBUG_TYPE_NULL terminated array of argument types, and
5107
   sets *PVARARGS to indicate whether this is a varargs function.  */
5108
 
5109
static debug_type *
5110
stab_demangle_v3_arglist (void *dhandle, struct stab_handle *info,
5111
                          struct demangle_component *arglist,
5112
                          bfd_boolean *pvarargs)
5113
{
5114
  struct demangle_component *dc;
5115
  unsigned int alloc, count;
5116
  debug_type *pargs;
5117
 
5118
  alloc = 10;
5119
  pargs = (debug_type *) xmalloc (alloc * sizeof *pargs);
5120
  *pvarargs = FALSE;
5121
 
5122
  count = 0;
5123
 
5124
  for (dc = arglist;
5125
       dc != NULL;
5126
       dc = dc->u.s_binary.right)
5127
    {
5128
      debug_type arg;
5129
      bfd_boolean varargs;
5130
 
5131
      if (dc->type != DEMANGLE_COMPONENT_ARGLIST)
5132
        {
5133
          fprintf (stderr, _("Unexpected type in v3 arglist demangling\n"));
5134
          free (pargs);
5135
          return NULL;
5136
        }
5137
 
5138
      arg = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left,
5139
                                  NULL, &varargs);
5140
      if (arg == NULL)
5141
        {
5142
          if (varargs)
5143
            {
5144
              *pvarargs = TRUE;
5145
              continue;
5146
            }
5147
          free (pargs);
5148
          return NULL;
5149
        }
5150
 
5151
      if (count + 1 >= alloc)
5152
        {
5153
          alloc += 10;
5154
          pargs = (debug_type *) xrealloc (pargs, alloc * sizeof *pargs);
5155
        }
5156
 
5157
      pargs[count] = arg;
5158
      ++count;
5159
    }
5160
 
5161
  pargs[count] = DEBUG_TYPE_NULL;
5162
 
5163
  return pargs;
5164
}
5165
 
5166
/* Convert a struct demangle_component tree describing an argument
5167
   type into a debug_type.  */
5168
 
5169
static debug_type
5170
stab_demangle_v3_arg (void *dhandle, struct stab_handle *info,
5171
                      struct demangle_component *dc, debug_type context,
5172
                      bfd_boolean *pvarargs)
5173
{
5174
  debug_type dt;
5175
 
5176
  if (pvarargs != NULL)
5177
    *pvarargs = FALSE;
5178
 
5179
  switch (dc->type)
5180
    {
5181
      /* FIXME: These are demangle component types which we probably
5182
         need to handle one way or another.  */
5183
    case DEMANGLE_COMPONENT_LOCAL_NAME:
5184
    case DEMANGLE_COMPONENT_TYPED_NAME:
5185
    case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
5186
    case DEMANGLE_COMPONENT_CTOR:
5187
    case DEMANGLE_COMPONENT_DTOR:
5188
    case DEMANGLE_COMPONENT_JAVA_CLASS:
5189
    case DEMANGLE_COMPONENT_RESTRICT_THIS:
5190
    case DEMANGLE_COMPONENT_VOLATILE_THIS:
5191
    case DEMANGLE_COMPONENT_CONST_THIS:
5192
    case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5193
    case DEMANGLE_COMPONENT_COMPLEX:
5194
    case DEMANGLE_COMPONENT_IMAGINARY:
5195
    case DEMANGLE_COMPONENT_VENDOR_TYPE:
5196
    case DEMANGLE_COMPONENT_ARRAY_TYPE:
5197
    case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5198
    case DEMANGLE_COMPONENT_ARGLIST:
5199
    default:
5200
      fprintf (stderr, _("Unrecognized demangle component %d\n"),
5201
               (int) dc->type);
5202
      return NULL;
5203
 
5204
    case DEMANGLE_COMPONENT_NAME:
5205
      if (context != NULL)
5206
        {
5207
          const debug_field *fields;
5208
 
5209
          fields = debug_get_fields (dhandle, context);
5210
          if (fields != NULL)
5211
            {
5212
              /* Try to find this type by looking through the context
5213
                 class.  */
5214
              for (; *fields != DEBUG_FIELD_NULL; fields++)
5215
                {
5216
                  debug_type ft;
5217
                  const char *dn;
5218
 
5219
                  ft = debug_get_field_type (dhandle, *fields);
5220
                  if (ft == NULL)
5221
                    return NULL;
5222
                  dn = debug_get_type_name (dhandle, ft);
5223
                  if (dn != NULL
5224
                      && (int) strlen (dn) == dc->u.s_name.len
5225
                      && strncmp (dn, dc->u.s_name.s, dc->u.s_name.len) == 0)
5226
                    return ft;
5227
                }
5228
            }
5229
        }
5230
      return stab_find_tagged_type (dhandle, info, dc->u.s_name.s,
5231
                                    dc->u.s_name.len, DEBUG_KIND_ILLEGAL);
5232
 
5233
    case DEMANGLE_COMPONENT_QUAL_NAME:
5234
      context = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left,
5235
                                      context, NULL);
5236
      if (context == NULL)
5237
        return NULL;
5238
      return stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.right,
5239
                                   context, NULL);
5240
 
5241
    case DEMANGLE_COMPONENT_TEMPLATE:
5242
      {
5243
        char *p;
5244
        size_t alc;
5245
 
5246
        /* We print this component to get a class name which we can
5247
           use.  FIXME: This probably won't work if the template uses
5248
           template parameters which refer to an outer template.  */
5249
        p = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, dc, 20, &alc);
5250
        if (p == NULL)
5251
          {
5252
            fprintf (stderr, _("Failed to print demangled template\n"));
5253
            return NULL;
5254
          }
5255
        dt = stab_find_tagged_type (dhandle, info, p, strlen (p),
5256
                                    DEBUG_KIND_CLASS);
5257
        free (p);
5258
        return dt;
5259
      }
5260
 
5261
    case DEMANGLE_COMPONENT_SUB_STD:
5262
      return stab_find_tagged_type (dhandle, info, dc->u.s_string.string,
5263
                                    dc->u.s_string.len, DEBUG_KIND_ILLEGAL);
5264
 
5265
    case DEMANGLE_COMPONENT_RESTRICT:
5266
    case DEMANGLE_COMPONENT_VOLATILE:
5267
    case DEMANGLE_COMPONENT_CONST:
5268
    case DEMANGLE_COMPONENT_POINTER:
5269
    case DEMANGLE_COMPONENT_REFERENCE:
5270
      dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL,
5271
                                 NULL);
5272
      if (dt == NULL)
5273
        return NULL;
5274
 
5275
      switch (dc->type)
5276
        {
5277
        default:
5278
          abort ();
5279
        case DEMANGLE_COMPONENT_RESTRICT:
5280
          /* FIXME: We have no way to represent restrict.  */
5281
          return dt;
5282
        case DEMANGLE_COMPONENT_VOLATILE:
5283
          return debug_make_volatile_type (dhandle, dt);
5284
        case DEMANGLE_COMPONENT_CONST:
5285
          return debug_make_const_type (dhandle, dt);
5286
        case DEMANGLE_COMPONENT_POINTER:
5287
          return debug_make_pointer_type (dhandle, dt);
5288
        case DEMANGLE_COMPONENT_REFERENCE:
5289
          return debug_make_reference_type (dhandle, dt);
5290
        }
5291
 
5292
    case DEMANGLE_COMPONENT_FUNCTION_TYPE:
5293
      {
5294
        debug_type *pargs;
5295
        bfd_boolean varargs;
5296
 
5297
        if (dc->u.s_binary.left == NULL)
5298
          {
5299
            /* In this case the return type is actually unknown.
5300
               However, I'm not sure this will ever arise in practice;
5301
               normally an unknown return type would only appear at
5302
               the top level, which is handled above.  */
5303
            dt = debug_make_void_type (dhandle);
5304
          }
5305
        else
5306
          dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL,
5307
                                     NULL);
5308
        if (dt == NULL)
5309
          return NULL;
5310
 
5311
        pargs = stab_demangle_v3_arglist (dhandle, info,
5312
                                          dc->u.s_binary.right,
5313
                                          &varargs);
5314
        if (pargs == NULL)
5315
          return NULL;
5316
 
5317
        return debug_make_function_type (dhandle, dt, pargs, varargs);
5318
      }
5319
 
5320
    case DEMANGLE_COMPONENT_BUILTIN_TYPE:
5321
      {
5322
        char *p;
5323
        size_t alc;
5324
        debug_type ret;
5325
 
5326
        /* We print this component in order to find out the type name.
5327
           FIXME: Should we instead expose the
5328
           demangle_builtin_type_info structure?  */
5329
        p = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, dc, 20, &alc);
5330
        if (p == NULL)
5331
          {
5332
            fprintf (stderr, _("Couldn't get demangled builtin type\n"));
5333
            return NULL;
5334
          }
5335
 
5336
        /* The mangling is based on the type, but does not itself
5337
           indicate what the sizes are.  So we have to guess.  */
5338
        if (strcmp (p, "signed char") == 0)
5339
          ret = debug_make_int_type (dhandle, 1, FALSE);
5340
        else if (strcmp (p, "bool") == 0)
5341
          ret = debug_make_bool_type (dhandle, 1);
5342
        else if (strcmp (p, "char") == 0)
5343
          ret = debug_make_int_type (dhandle, 1, FALSE);
5344
        else if (strcmp (p, "double") == 0)
5345
          ret = debug_make_float_type (dhandle, 8);
5346
        else if (strcmp (p, "long double") == 0)
5347
          ret = debug_make_float_type (dhandle, 8);
5348
        else if (strcmp (p, "float") == 0)
5349
          ret = debug_make_float_type (dhandle, 4);
5350
        else if (strcmp (p, "__float128") == 0)
5351
          ret = debug_make_float_type (dhandle, 16);
5352
        else if (strcmp (p, "unsigned char") == 0)
5353
          ret = debug_make_int_type (dhandle, 1, TRUE);
5354
        else if (strcmp (p, "int") == 0)
5355
          ret = debug_make_int_type (dhandle, 4, FALSE);
5356
        else if (strcmp (p, "unsigned int") == 0)
5357
          ret = debug_make_int_type (dhandle, 4, TRUE);
5358
        else if (strcmp (p, "long") == 0)
5359
          ret = debug_make_int_type (dhandle, 4, FALSE);
5360
        else if (strcmp (p, "unsigned long") == 0)
5361
          ret = debug_make_int_type (dhandle, 4, TRUE);
5362
        else if (strcmp (p, "__int128") == 0)
5363
          ret = debug_make_int_type (dhandle, 16, FALSE);
5364
        else if (strcmp (p, "unsigned __int128") == 0)
5365
          ret = debug_make_int_type (dhandle, 16, TRUE);
5366
        else if (strcmp (p, "short") == 0)
5367
          ret = debug_make_int_type (dhandle, 2, FALSE);
5368
        else if (strcmp (p, "unsigned short") == 0)
5369
          ret = debug_make_int_type (dhandle, 2, TRUE);
5370
        else if (strcmp (p, "void") == 0)
5371
          ret = debug_make_void_type (dhandle);
5372
        else if (strcmp (p, "wchar_t") == 0)
5373
          ret = debug_make_int_type (dhandle, 4, TRUE);
5374
        else if (strcmp (p, "long long") == 0)
5375
          ret = debug_make_int_type (dhandle, 8, FALSE);
5376
        else if (strcmp (p, "unsigned long long") == 0)
5377
          ret = debug_make_int_type (dhandle, 8, TRUE);
5378
        else if (strcmp (p, "...") == 0)
5379
          {
5380
            if (pvarargs == NULL)
5381
              fprintf (stderr, _("Unexpected demangled varargs\n"));
5382
            else
5383
              *pvarargs = TRUE;
5384
            ret = NULL;
5385
          }
5386
        else
5387
          {
5388
            fprintf (stderr, _("Unrecognized demangled builtin type\n"));
5389
            ret = NULL;
5390
          }
5391
 
5392
        free (p);
5393
 
5394
        return ret;
5395
      }
5396
    }
5397
}

powered by: WebSVN 2.1.0

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