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