~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to pstack/stabs.c

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

Show diffs side-by-side

added added

removed removed

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