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