projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* dwarf.c (dwarf_vmatoa): Rename to dwarf_vmatoa_1 and add a
[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. */
cb566e3a
AM		 2761 physname = argtypes;
2762 if (stub)
252b5132
RH		 2763 {
2764 debug_type class_type, return_type;
2765
2766 class_type = stab_find_type (dhandle, info, typenums);
2767 if (class_type == DEBUG_TYPE_NULL)
1fcab1af 2768 goto fail;
252b5132
RH		 2769 return_type = debug_get_return_type (dhandle, type);
2770 if (return_type == DEBUG_TYPE_NULL)
2771 {
2772 bad_stab (orig);
1fcab1af 2773 goto fail;
252b5132
RH		 2774 }
2775 type = parse_stab_argtypes (dhandle, info, class_type, name,
2776 tagname, return_type, argtypes,
2777 constp, volatilep, &physname);
2778 if (type == DEBUG_TYPE_NULL)
1fcab1af 2779 goto fail;
252b5132
RH		 2780 }
2781
2782 if (cvars + 1 >= allocvars)
2783 {
2784 allocvars += 10;
2785 variants = ((debug_method_variant *)
2da42df6 2786 xrealloc (variants,
252b5132
RH		 2787 allocvars * sizeof *variants));
2788 }
2789
2790 if (! staticp)
2791 variants[cvars] = debug_make_method_variant (dhandle, physname,
2792 type, visibility,
2793 constp, volatilep,
2794 voffset, context);
2795 else
2796 variants[cvars] = debug_make_static_method_variant (dhandle,
2797 physname,
2798 type,
2799 visibility,
2800 constp,
2801 volatilep);
2802 if (variants[cvars] == DEBUG_METHOD_VARIANT_NULL)
1fcab1af 2803 goto fail;
252b5132
RH		 2804
2805 ++cvars;
2806 }
2807 while (**pp != ';' && **pp != '\0');
2808
2809 variants[cvars] = DEBUG_METHOD_VARIANT_NULL;
2810
2811 if (**pp != '\0')
2812 ++*pp;
2813
2814 if (c + 1 >= alloc)
2815 {
2816 alloc += 10;
2817 methods = ((debug_method *)
2da42df6 2818 xrealloc (methods, alloc * sizeof *methods));
252b5132
RH		 2819 }
2820
2821 methods[c] = debug_make_method (dhandle, name, variants);
2822
2823 ++c;
2824 }
2825
2826 if (methods != NULL)
2827 methods[c] = DEBUG_METHOD_NULL;
2828
2829 *retp = methods;
2830
b34976b6 2831 return TRUE;
1fcab1af
NC		 2832
2833 fail:
2834 if (name != NULL)
2835 free (name);
2836 if (variants != NULL)
2837 free (variants);
2838 if (argtypes != NULL)
2839 free (argtypes);
2840 return FALSE;
252b5132
RH		 2841}
2842
2843/* Parse a string representing argument types for a method. Stabs
2844 tries to save space by packing argument types into a mangled
2845 string. This string should give us enough information to extract
2846 both argument types and the physical name of the function, given
2847 the tag name. */
2848
2849static debug_type
2da42df6
AJ		 2850parse_stab_argtypes (void *dhandle, struct stab_handle *info,
2851 debug_type class_type, const char *fieldname,
2852 const char *tagname, debug_type return_type,
2853 const char *argtypes, bfd_boolean constp,
2854 bfd_boolean volatilep, const char **pphysname)
252b5132 2855{
b34976b6
AM		 2856 bfd_boolean is_full_physname_constructor;
2857 bfd_boolean is_constructor;
2858 bfd_boolean is_destructor;
041821e6 2859 bfd_boolean is_v3;
252b5132 2860 debug_type *args;
b34976b6 2861 bfd_boolean varargs;
4b73ca92 2862 unsigned int physname_len = 0;
252b5132
RH		 2863
2864 /* Constructors are sometimes handled specially. */
2865 is_full_physname_constructor = ((argtypes[0] == '_'
2866 && argtypes[1] == '_'
3882b010 2867 && (ISDIGIT (argtypes[2])
252b5132
RH		 2868 || argtypes[2] == 'Q'
2869 || argtypes[2] == 't'))
0112cd26 2870 || CONST_STRNEQ (argtypes, "__ct"));
252b5132
RH		 2871
2872 is_constructor = (is_full_physname_constructor
2873 || (tagname != NULL
2874 && strcmp (fieldname, tagname) == 0));
2875 is_destructor = ((argtypes[0] == '_'
2876 && (argtypes[1] == '$' || argtypes[1] == '.')
2877 && argtypes[2] == '_')
0112cd26 2878 || CONST_STRNEQ (argtypes, "__dt"));
041821e6 2879 is_v3 = argtypes[0] == '_' && argtypes[1] == 'Z';
252b5132 2880
cb566e3a 2881 if (!(is_destructor || is_full_physname_constructor || is_v3))
252b5132
RH		 2882 {
2883 unsigned int len;
2884 const char *const_prefix;
2885 const char *volatile_prefix;
2886 char buf[20];
2887 unsigned int mangled_name_len;
2888 char *physname;
2889
2890 len = tagname == NULL ? 0 : strlen (tagname);
2891 const_prefix = constp ? "C" : "";
2892 volatile_prefix = volatilep ? "V" : "";
2893
2894 if (len == 0)
2895 sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
2896 else if (tagname != NULL && strchr (tagname, '<') != NULL)
2897 {
2898 /* Template methods are fully mangled. */
2899 sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
2900 tagname = NULL;
2901 len = 0;
2902 }
2903 else
2904 sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
2905
2906 mangled_name_len = ((is_constructor ? 0 : strlen (fieldname))
2907 + strlen (buf)
2908 + len
2909 + strlen (argtypes)
2910 + 1);
2911
2912 if (fieldname[0] == 'o'
2913 && fieldname[1] == 'p'
2914 && (fieldname[2] == '$' || fieldname[2] == '.'))
2915 {
2916 const char *opname;
2917
2918 opname = cplus_mangle_opname (fieldname + 3, 0);
2919 if (opname == NULL)
2920 {
2921 fprintf (stderr, _("No mangling for \"%s\"\n"), fieldname);
2922 return DEBUG_TYPE_NULL;
2923 }
2924 mangled_name_len += strlen (opname);
2925 physname = (char *) xmalloc (mangled_name_len);
2926 strncpy (physname, fieldname, 3);
2927 strcpy (physname + 3, opname);
2928 }
2929 else
2930 {
2931 physname = (char *) xmalloc (mangled_name_len);
2932 if (is_constructor)
2933 physname[0] = '\0';
2934 else
2935 strcpy (physname, fieldname);
2936 }
2937
4b73ca92 2938 physname_len = strlen (physname);
252b5132
RH		 2939 strcat (physname, buf);
2940 if (tagname != NULL)
2941 strcat (physname, tagname);
2942 strcat (physname, argtypes);
2943
2944 *pphysname = physname;
2945 }
2946
2947 if (*argtypes == '\0' || is_destructor)
2948 {
2949 args = (debug_type *) xmalloc (sizeof *args);
2950 *args = NULL;
2951 return debug_make_method_type (dhandle, return_type, class_type, args,
b34976b6 2952 FALSE);
252b5132
RH		 2953 }
2954
4b73ca92 2955 args = stab_demangle_argtypes (dhandle, info, *pphysname, &varargs, physname_len);
252b5132
RH		 2956 if (args == NULL)
2957 return DEBUG_TYPE_NULL;
2958
2959 return debug_make_method_type (dhandle, return_type, class_type, args,
2960 varargs);
2961}
2962
2963/* The tail end of stabs for C++ classes that contain a virtual function
2964 pointer contains a tilde, a %, and a type number.
2965 The type number refers to the base class (possibly this class itself) which
2966 contains the vtable pointer for the current class.
2967
2968 This function is called when we have parsed all the method declarations,
2969 so we can look for the vptr base class info. */
2970
b34976b6 2971static bfd_boolean
2da42df6
AJ		 2972parse_stab_tilde_field (void *dhandle, struct stab_handle *info,
2973 const char **pp, const int *typenums,
2974 debug_type *retvptrbase, bfd_boolean *retownvptr)
252b5132
RH		 2975{
2976 const char *orig;
2977 const char *hold;
2978 int vtypenums[2];
2979
2980 *retvptrbase = DEBUG_TYPE_NULL;
b34976b6 2981 *retownvptr = FALSE;
252b5132
RH		 2982
2983 orig = *pp;
2984
9f66665a 2985 /* If we are positioned at a ';', then skip it. */
252b5132
RH		 2986 if (**pp == ';')
2987 ++*pp;
2988
2989 if (**pp != '~')
b34976b6 2990 return TRUE;
252b5132
RH		 2991
2992 ++*pp;
2993
2994 if (**pp == '=' || **pp == '+' || **pp == '-')
2995 {
2996 /* Obsolete flags that used to indicate the presence of
9f66665a 2997 constructors and/or destructors. */
252b5132
RH		 2998 ++*pp;
2999 }
3000
3001 if (**pp != '%')
b34976b6 3002 return TRUE;
252b5132
RH		 3003
3004 ++*pp;
3005
3006 hold = *pp;
3007
3008 /* The next number is the type number of the base class (possibly
3009 our own class) which supplies the vtable for this class. */
3010 if (! parse_stab_type_number (pp, vtypenums))
b34976b6 3011 return FALSE;
252b5132
RH		 3012
3013 if (vtypenums[0] == typenums[0]
3014 && vtypenums[1] == typenums[1])
b34976b6 3015 *retownvptr = TRUE;
252b5132
RH		 3016 else
3017 {
3018 debug_type vtype;
3019 const char *p;
3020
3021 *pp = hold;
3022
3023 vtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3024 (debug_type **) NULL);
3025 for (p = *pp; *p != ';' && *p != '\0'; p++)
3026 ;
3027 if (*p != ';')
3028 {
3029 bad_stab (orig);
b34976b6 3030 return FALSE;
252b5132
RH		 3031 }
3032
3033 *retvptrbase = vtype;
3034
3035 *pp = p + 1;
3036 }
3037
b34976b6 3038 return TRUE;
252b5132
RH		 3039}
3040
3041/* Read a definition of an array type. */
3042
3043static debug_type
2da42df6
AJ		 3044parse_stab_array_type (void *dhandle, struct stab_handle *info,
3045 const char **pp, bfd_boolean stringp)
252b5132
RH		 3046{
3047 const char *orig;
3048 const char *p;
3049 int typenums[2];
3050 debug_type index_type;
b34976b6 3051 bfd_boolean adjustable;
252b5132
RH		 3052 bfd_signed_vma lower, upper;
3053 debug_type element_type;
3054
3055 /* Format of an array type:
3056 "ar<index type>;lower;upper;<array_contents_type>".
3057 OS9000: "arlower,upper;<array_contents_type>".
3058
3059 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3060 for these, produce a type like float[][]. */
3061
3062 orig = *pp;
3063
3064 /* FIXME: gdb checks os9k_stabs here. */
3065
3066 /* If the index type is type 0, we take it as int. */
3067 p = *pp;
3068 if (! parse_stab_type_number (&p, typenums))
3dceb55b 3069 return DEBUG_TYPE_NULL;
252b5132
RH		 3070 if (typenums[0] == 0 && typenums[1] == 0 && **pp != '=')
3071 {
3072 index_type = debug_find_named_type (dhandle, "int");
3073 if (index_type == DEBUG_TYPE_NULL)
3074 {
b34976b6 3075 index_type = debug_make_int_type (dhandle, 4, FALSE);
252b5132 3076 if (index_type == DEBUG_TYPE_NULL)
3dceb55b 3077 return DEBUG_TYPE_NULL;
252b5132
RH		 3078 }
3079 *pp = p;
3080 }
3081 else
3082 {
3083 index_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3084 (debug_type **) NULL);
3085 }
3086
3087 if (**pp != ';')
3088 {
3089 bad_stab (orig);
3090 return DEBUG_TYPE_NULL;
3091 }
3092 ++*pp;
3093
b34976b6 3094 adjustable = FALSE;
252b5132 3095
3882b010 3096 if (! ISDIGIT (**pp) && **pp != '-')
252b5132
RH		 3097 {
3098 ++*pp;
b34976b6 3099 adjustable = TRUE;
252b5132
RH		 3100 }
3101
b34976b6 3102 lower = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
252b5132
RH		 3103 if (**pp != ';')
3104 {
3105 bad_stab (orig);
3dceb55b 3106 return DEBUG_TYPE_NULL;
252b5132
RH		 3107 }
3108 ++*pp;
3109
3882b010 3110 if (! ISDIGIT (**pp) && **pp != '-')
252b5132
RH		 3111 {
3112 ++*pp;
b34976b6 3113 adjustable = TRUE;
252b5132
RH		 3114 }
3115
b34976b6 3116 upper = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
252b5132
RH		 3117 if (**pp != ';')
3118 {
3119 bad_stab (orig);
3dceb55b 3120 return DEBUG_TYPE_NULL;
252b5132
RH		 3121 }
3122 ++*pp;
3123
3124 element_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3125 (debug_type **) NULL);
3126 if (element_type == DEBUG_TYPE_NULL)
3dceb55b 3127 return DEBUG_TYPE_NULL;
252b5132
RH		 3128
3129 if (adjustable)
3130 {
3131 lower = 0;
3132 upper = -1;
3133 }
3134
3135 return debug_make_array_type (dhandle, element_type, index_type, lower,
3136 upper, stringp);
3137}
3138
3139/* This struct holds information about files we have seen using
3140 N_BINCL. */
3141
3142struct bincl_file
3143{
3144 /* The next N_BINCL file. */
3145 struct bincl_file *next;
3146 /* The next N_BINCL on the stack. */
3147 struct bincl_file *next_stack;
3148 /* The file name. */
3149 const char *name;
3150 /* The hash value. */
3151 bfd_vma hash;
3152 /* The file index. */
3153 unsigned int file;
3154 /* The list of types defined in this file. */
3155 struct stab_types *file_types;
3156};
3157
3158/* Start a new N_BINCL file, pushing it onto the stack. */
3159
3160static void
2da42df6 3161push_bincl (struct stab_handle *info, const char *name, bfd_vma hash)
252b5132
RH		 3162{
3163 struct bincl_file *n;
3164
3165 n = (struct bincl_file *) xmalloc (sizeof *n);
3166 n->next = info->bincl_list;
3167 n->next_stack = info->bincl_stack;
3168 n->name = name;
3169 n->hash = hash;
3170 n->file = info->files;
3171 n->file_types = NULL;
3172 info->bincl_list = n;
3173 info->bincl_stack = n;
3174
3175 ++info->files;
3176 info->file_types = ((struct stab_types **)
2da42df6 3177 xrealloc (info->file_types,
252b5132
RH		 3178 (info->files
3179 * sizeof *info->file_types)));
3180 info->file_types[n->file] = NULL;
3181}
3182
3183/* Finish an N_BINCL file, at an N_EINCL, popping the name off the
3184 stack. */
3185
3186static const char *
2da42df6 3187pop_bincl (struct stab_handle *info)
252b5132
RH		 3188{
3189 struct bincl_file *o;
3190
3191 o = info->bincl_stack;
3192 if (o == NULL)
3193 return info->main_filename;
3194 info->bincl_stack = o->next_stack;
3195
3196 o->file_types = info->file_types[o->file];
3197
3198 if (info->bincl_stack == NULL)
3199 return info->main_filename;
3200 return info->bincl_stack->name;
3201}
3202
3203/* Handle an N_EXCL: get the types from the corresponding N_BINCL. */
3204
b34976b6 3205static bfd_boolean
2da42df6 3206find_excl (struct stab_handle *info, const char *name, bfd_vma hash)
252b5132
RH		 3207{
3208 struct bincl_file *l;
3209
3210 ++info->files;
3211 info->file_types = ((struct stab_types **)
2da42df6 3212 xrealloc (info->file_types,
252b5132
RH		 3213 (info->files
3214 * sizeof *info->file_types)));
3215
3216 for (l = info->bincl_list; l != NULL; l = l->next)
3217 if (l->hash == hash && strcmp (l->name, name) == 0)
3218 break;
3219 if (l == NULL)
3220 {
3221 warn_stab (name, _("Undefined N_EXCL"));
3222 info->file_types[info->files - 1] = NULL;
b34976b6 3223 return TRUE;
252b5132
RH		 3224 }
3225
3226 info->file_types[info->files - 1] = l->file_types;
3227
b34976b6 3228 return TRUE;
252b5132
RH		 3229}
3230
3231/* Handle a variable definition. gcc emits variable definitions for a
3232 block before the N_LBRAC, so we must hold onto them until we see
3233 it. The SunPRO compiler emits variable definitions after the
3234 N_LBRAC, so we can call debug_record_variable immediately. */
3235
b34976b6 3236static bfd_boolean
2da42df6
AJ		 3237stab_record_variable (void *dhandle, struct stab_handle *info,
3238 const char *name, debug_type type,
3239 enum debug_var_kind kind, bfd_vma val)
252b5132
RH		 3240{
3241 struct stab_pending_var *v;
3242
3243 if ((kind == DEBUG_GLOBAL || kind == DEBUG_STATIC)
3244 || ! info->within_function
3245 || (info->gcc_compiled == 0 && info->n_opt_found))
3246 return debug_record_variable (dhandle, name, type, kind, val);
3247
3248 v = (struct stab_pending_var *) xmalloc (sizeof *v);
3249 memset (v, 0, sizeof *v);
3250
3251 v->next = info->pending;
3252 v->name = name;
3253 v->type = type;
3254 v->kind = kind;
3255 v->val = val;
3256 info->pending = v;
3257
b34976b6 3258 return TRUE;
252b5132
RH		 3259}
3260
3261/* Emit pending variable definitions. This is called after we see the
3262 N_LBRAC that starts the block. */
3263
b34976b6 3264static bfd_boolean
2da42df6 3265stab_emit_pending_vars (void *dhandle, struct stab_handle *info)
252b5132
RH		 3266{
3267 struct stab_pending_var *v;
3268
3269 v = info->pending;
3270 while (v != NULL)
3271 {
3272 struct stab_pending_var *next;
3273
3274 if (! debug_record_variable (dhandle, v->name, v->type, v->kind, v->val))
b34976b6 3275 return FALSE;
252b5132
RH		 3276
3277 next = v->next;
3278 free (v);
3279 v = next;
3280 }
3281
3282 info->pending = NULL;
3283
b34976b6 3284 return TRUE;
252b5132
RH		 3285}
3286
3287/* Find the slot for a type in the database. */
3288
3289static debug_type *
2da42df6 3290stab_find_slot (struct stab_handle *info, const int *typenums)
252b5132
RH		 3291{
3292 int filenum;
91d6fa6a 3293 int tindex;
252b5132
RH		 3294 struct stab_types **ps;
3295
3296 filenum = typenums[0];
91d6fa6a 3297 tindex = typenums[1];
252b5132
RH		 3298
3299 if (filenum < 0 || (unsigned int) filenum >= info->files)
3300 {
3301 fprintf (stderr, _("Type file number %d out of range\n"), filenum);
3302 return NULL;
3303 }
91d6fa6a 3304 if (tindex < 0)
252b5132 3305 {
91d6fa6a 3306 fprintf (stderr, _("Type index number %d out of range\n"), tindex);
252b5132
RH		 3307 return NULL;
3308 }
3309
3310 ps = info->file_types + filenum;
3311
91d6fa6a 3312 while (tindex >= STAB_TYPES_SLOTS)
252b5132
RH		 3313 {
3314 if (*ps == NULL)
3315 {
3316 *ps = (struct stab_types *) xmalloc (sizeof **ps);
3317 memset (*ps, 0, sizeof **ps);
3318 }
3319 ps = &(*ps)->next;
91d6fa6a 3320 tindex -= STAB_TYPES_SLOTS;
252b5132
RH		 3321 }
3322 if (*ps == NULL)
3323 {
3324 *ps = (struct stab_types *) xmalloc (sizeof **ps);
3325 memset (*ps, 0, sizeof **ps);
3326 }
3327
91d6fa6a 3328 return (*ps)->types + tindex;
252b5132
RH		 3329}
3330
3331/* Find a type given a type number. If the type has not been
3332 allocated yet, create an indirect type. */
3333
3334static debug_type
2da42df6 3335stab_find_type (void *dhandle, struct stab_handle *info, const int *typenums)
252b5132
RH		 3336{
3337 debug_type *slot;
3338
3339 if (typenums[0] == 0 && typenums[1] < 0)
3340 {
3341 /* A negative type number indicates an XCOFF builtin type. */
3342 return stab_xcoff_builtin_type (dhandle, info, typenums[1]);
3343 }
3344
3345 slot = stab_find_slot (info, typenums);
3346 if (slot == NULL)
3347 return DEBUG_TYPE_NULL;
3348
3349 if (*slot == DEBUG_TYPE_NULL)
3350 return debug_make_indirect_type (dhandle, slot, (const char *) NULL);
3351
3352 return *slot;
3353}
3354
3355/* Record that a given type number refers to a given type. */
3356
b34976b6 3357static bfd_boolean
2da42df6
AJ		 3358stab_record_type (void *dhandle ATTRIBUTE_UNUSED, struct stab_handle *info,
3359 const int *typenums, debug_type type)
252b5132
RH		 3360{
3361 debug_type *slot;
3362
3363 slot = stab_find_slot (info, typenums);
3364 if (slot == NULL)
b34976b6 3365 return FALSE;
252b5132
RH		 3366
3367 /* gdb appears to ignore type redefinitions, so we do as well. */
3368
3369 *slot = type;
3370
b34976b6 3371 return TRUE;
252b5132
RH		 3372}
3373
3374/* Return an XCOFF builtin type. */
3375
3376static debug_type
2da42df6
AJ		 3377stab_xcoff_builtin_type (void *dhandle, struct stab_handle *info,
3378 int typenum)
252b5132
RH		 3379{
3380 debug_type rettype;
3381 const char *name;
3382
3383 if (typenum >= 0 || typenum < -XCOFF_TYPE_COUNT)
3384 {
3385 fprintf (stderr, _("Unrecognized XCOFF type %d\n"), typenum);
3386 return DEBUG_TYPE_NULL;
3387 }
3388 if (info->xcoff_types[-typenum] != NULL)
3389 return info->xcoff_types[-typenum];
3390
3391 switch (-typenum)
3392 {
3393 case 1:
3394 /* The size of this and all the other types are fixed, defined
3395 by the debugging format. */
3396 name = "int";
b34976b6 3397 rettype = debug_make_int_type (dhandle, 4, FALSE);
252b5132
RH		 3398 break;
3399 case 2:
3400 name = "char";
b34976b6 3401 rettype = debug_make_int_type (dhandle, 1, FALSE);
252b5132
RH		 3402 break;
3403 case 3:
3404 name = "short";
b34976b6 3405 rettype = debug_make_int_type (dhandle, 2, FALSE);
252b5132
RH		 3406 break;
3407 case 4:
3408 name = "long";
b34976b6 3409 rettype = debug_make_int_type (dhandle, 4, FALSE);
252b5132
RH		 3410 break;
3411 case 5:
3412 name = "unsigned char";
b34976b6 3413 rettype = debug_make_int_type (dhandle, 1, TRUE);
252b5132
RH		 3414 break;
3415 case 6:
3416 name = "signed char";
b34976b6 3417 rettype = debug_make_int_type (dhandle, 1, FALSE);
252b5132
RH		 3418 break;
3419 case 7:
3420 name = "unsigned short";
b34976b6 3421 rettype = debug_make_int_type (dhandle, 2, TRUE);
252b5132
RH		 3422 break;
3423 case 8:
3424 name = "unsigned int";
b34976b6 3425 rettype = debug_make_int_type (dhandle, 4, TRUE);
252b5132
RH		 3426 break;
3427 case 9:
3428 name = "unsigned";
b34976b6 3429 rettype = debug_make_int_type (dhandle, 4, TRUE);
252b5132
RH		 3430 case 10:
3431 name = "unsigned long";
b34976b6 3432 rettype = debug_make_int_type (dhandle, 4, TRUE);
252b5132
RH		 3433 break;
3434 case 11:
3435 name = "void";
3436 rettype = debug_make_void_type (dhandle);
3437 break;
3438 case 12:
3439 /* IEEE single precision (32 bit). */
3440 name = "float";
3441 rettype = debug_make_float_type (dhandle, 4);
3442 break;
3443 case 13:
3444 /* IEEE double precision (64 bit). */
3445 name = "double";
3446 rettype = debug_make_float_type (dhandle, 8);
3447 break;
3448 case 14:
3449 /* This is an IEEE double on the RS/6000, and different machines
3450 with different sizes for "long double" should use different
3451 negative type numbers. See stabs.texinfo. */
3452 name = "long double";
3453 rettype = debug_make_float_type (dhandle, 8);
3454 break;
3455 case 15:
3456 name = "integer";
b34976b6 3457 rettype = debug_make_int_type (dhandle, 4, FALSE);
252b5132
RH		 3458 break;
3459 case 16:
3460 name = "boolean";
3461 rettype = debug_make_bool_type (dhandle, 4);
3462 break;
3463 case 17:
3464 name = "short real";
3465 rettype = debug_make_float_type (dhandle, 4);
3466 break;
3467 case 18:
3468 name = "real";
3469 rettype = debug_make_float_type (dhandle, 8);
3470 break;
3471 case 19:
3472 /* FIXME */
3473 name = "stringptr";
3474 rettype = NULL;
3475 break;
3476 case 20:
3477 /* FIXME */
3478 name = "character";
b34976b6 3479 rettype = debug_make_int_type (dhandle, 1, TRUE);
252b5132
RH		 3480 break;
3481 case 21:
3482 name = "logical*1";
3483 rettype = debug_make_bool_type (dhandle, 1);
3484 break;
3485 case 22:
3486 name = "logical*2";
3487 rettype = debug_make_bool_type (dhandle, 2);
3488 break;
3489 case 23:
3490 name = "logical*4";
3491 rettype = debug_make_bool_type (dhandle, 4);
3492 break;
3493 case 24:
3494 name = "logical";
3495 rettype = debug_make_bool_type (dhandle, 4);
3496 break;
3497 case 25:
3498 /* Complex type consisting of two IEEE single precision values. */
3499 name = "complex";
3500 rettype = debug_make_complex_type (dhandle, 8);
3501 break;
3502 case 26:
3503 /* Complex type consisting of two IEEE double precision values. */
3504 name = "double complex";
3505 rettype = debug_make_complex_type (dhandle, 16);
3506 break;
3507 case 27:
3508 name = "integer*1";
b34976b6 3509 rettype = debug_make_int_type (dhandle, 1, FALSE);
252b5132
RH		 3510 break;
3511 case 28:
3512 name = "integer*2";
b34976b6 3513 rettype = debug_make_int_type (dhandle, 2, FALSE);
252b5132
RH		 3514 break;
3515 case 29:
3516 name = "integer*4";
b34976b6 3517 rettype = debug_make_int_type (dhandle, 4, FALSE);
252b5132
RH		 3518 break;
3519 case 30:
3520 /* FIXME */
3521 name = "wchar";
b34976b6 3522 rettype = debug_make_int_type (dhandle, 2, FALSE);
252b5132
RH		 3523 break;
3524 case 31:
3525 name = "long long";
b34976b6 3526 rettype = debug_make_int_type (dhandle, 8, FALSE);
252b5132
RH		 3527 break;
3528 case 32:
3529 name = "unsigned long long";
b34976b6 3530 rettype = debug_make_int_type (dhandle, 8, TRUE);
252b5132
RH		 3531 break;
3532 case 33:
3533 name = "logical*8";
3534 rettype = debug_make_bool_type (dhandle, 8);
3535 break;
3536 case 34:
3537 name = "integer*8";
b34976b6 3538 rettype = debug_make_int_type (dhandle, 8, FALSE);
252b5132
RH		 3539 break;
3540 default:
3541 abort ();
3542 }
3543
3544 rettype = debug_name_type (dhandle, name, rettype);
3545
3546 info->xcoff_types[-typenum] = rettype;
3547
3548 return rettype;
3549}
3550
3551/* Find or create a tagged type. */
3552
3553static debug_type
2da42df6
AJ		 3554stab_find_tagged_type (void *dhandle, struct stab_handle *info,
3555 const char *p, int len, enum debug_type_kind kind)
252b5132
RH		 3556{
3557 char *name;
3558 debug_type dtype;
3559 struct stab_tag *st;
3560
3561 name = savestring (p, len);
3562
3563 /* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same
3564 namespace. This is right for C, and I don't know how to handle
3565 other languages. FIXME. */
3566 dtype = debug_find_tagged_type (dhandle, name, DEBUG_KIND_ILLEGAL);
3567 if (dtype != DEBUG_TYPE_NULL)
3568 {
3569 free (name);
3570 return dtype;
3571 }
3572
3573 /* We need to allocate an entry on the undefined tag list. */
3574 for (st = info->tags; st != NULL; st = st->next)
3575 {
3576 if (st->name[0] == name[0]
3577 && strcmp (st->name, name) == 0)
3578 {
3579 if (st->kind == DEBUG_KIND_ILLEGAL)
3580 st->kind = kind;
3581 free (name);
3582 break;
3583 }
3584 }
3585 if (st == NULL)
3586 {
3587 st = (struct stab_tag *) xmalloc (sizeof *st);
3588 memset (st, 0, sizeof *st);
3589
3590 st->next = info->tags;
3591 st->name = name;
3592 st->kind = kind;
3593 st->slot = DEBUG_TYPE_NULL;
3594 st->type = debug_make_indirect_type (dhandle, &st->slot, name);
3595 info->tags = st;
3596 }
3597
3598 return st->type;
3599}
3600\f
3601/* In order to get the correct argument types for a stubbed method, we
3602 need to extract the argument types from a C++ mangled string.
3603 Since the argument types can refer back to the return type, this
3604 means that we must demangle the entire physical name. In gdb this
3605 is done by calling cplus_demangle and running the results back
3606 through the C++ expression parser. Since we have no expression
3607 parser, we must duplicate much of the work of cplus_demangle here.
3608
3609 We assume that GNU style demangling is used, since this is only
3610 done for method stubs, and only g++ should output that form of
3611 debugging information. */
3612
3613/* This structure is used to hold a pointer to type information which
3614 demangling a string. */
3615
3616struct stab_demangle_typestring
3617{
3618 /* The start of the type. This is not null terminated. */
3619 const char *typestring;
3620 /* The length of the type. */
3621 unsigned int len;
3622};
3623
3624/* This structure is used to hold information while demangling a
3625 string. */
3626
3627struct stab_demangle_info
3628{
3629 /* The debugging information handle. */
2da42df6 3630 void *dhandle;
252b5132
RH		 3631 /* The stab information handle. */
3632 struct stab_handle *info;
3633 /* The array of arguments we are building. */
3634 debug_type *args;
3635 /* Whether the method takes a variable number of arguments. */
b34976b6 3636 bfd_boolean varargs;
252b5132
RH		 3637 /* The array of types we have remembered. */
3638 struct stab_demangle_typestring *typestrings;
3639 /* The number of typestrings. */
3640 unsigned int typestring_count;
3641 /* The number of typestring slots we have allocated. */
3642 unsigned int typestring_alloc;
3643};
3644
2da42df6
AJ		 3645static void stab_bad_demangle (const char *);
3646static unsigned int stab_demangle_count (const char **);
3647static bfd_boolean stab_demangle_get_count (const char **, unsigned int *);
b34976b6 3648static bfd_boolean stab_demangle_prefix
2da42df6 3649 (struct stab_demangle_info *, const char **, unsigned int);
b34976b6 3650static bfd_boolean stab_demangle_function_name
2da42df6 3651 (struct stab_demangle_info *, const char **, const char *);
b34976b6 3652static bfd_boolean stab_demangle_signature
2da42df6 3653 (struct stab_demangle_info *, const char **);
b34976b6 3654static bfd_boolean stab_demangle_qualified
2da42df6 3655 (struct stab_demangle_info *, const char **, debug_type *);
b34976b6 3656static bfd_boolean stab_demangle_template
2da42df6 3657 (struct stab_demangle_info *, const char **, char **);
b34976b6 3658static bfd_boolean stab_demangle_class
2da42df6 3659 (struct stab_demangle_info *, const char **, const char **);
b34976b6 3660static bfd_boolean stab_demangle_args
2da42df6 3661 (struct stab_demangle_info *, const char **, debug_type **, bfd_boolean *);
b34976b6 3662static bfd_boolean stab_demangle_arg
2da42df6
AJ		 3663 (struct stab_demangle_info *, const char **, debug_type **,
3664 unsigned int *, unsigned int *);
b34976b6 3665static bfd_boolean stab_demangle_type
2da42df6 3666 (struct stab_demangle_info *, const char **, debug_type *);
b34976b6 3667static bfd_boolean stab_demangle_fund_type
2da42df6 3668 (struct stab_demangle_info *, const char **, debug_type *);
b34976b6 3669static bfd_boolean stab_demangle_remember_type
2da42df6 3670 (struct stab_demangle_info *, const char *, int);
252b5132
RH		 3671
3672/* Warn about a bad demangling. */
3673
3674static void
2da42df6 3675stab_bad_demangle (const char *s)
252b5132
RH		 3676{
3677 fprintf (stderr, _("bad mangled name `%s'\n"), s);
3678}
3679
3680/* Get a count from a stab string. */
3681
3682static unsigned int
2da42df6 3683stab_demangle_count (const char **pp)
252b5132
RH		 3684{
3685 unsigned int count;
3686
3687 count = 0;
3882b010 3688 while (ISDIGIT (**pp))
252b5132
RH		 3689 {
3690 count *= 10;
3691 count += **pp - '0';
3692 ++*pp;
3693 }
3694 return count;
3695}
3696
3697/* Require a count in a string. The count may be multiple digits, in
3698 which case it must end in an underscore. */
3699
b34976b6 3700static bfd_boolean
2da42df6 3701stab_demangle_get_count (const char **pp, unsigned int *pi)
252b5132 3702{
3882b010 3703 if (! ISDIGIT (**pp))
b34976b6 3704 return FALSE;
252b5132
RH		 3705
3706 *pi = **pp - '0';
3707 ++*pp;
3882b010 3708 if (ISDIGIT (**pp))
252b5132
RH		 3709 {
3710 unsigned int count;
3711 const char *p;
3712
3713 count = *pi;
3714 p = *pp;
3715 do
3716 {
3717 count *= 10;
3718 count += *p - '0';
3719 ++p;
3720 }
3882b010 3721 while (ISDIGIT (*p));
252b5132
RH		 3722 if (*p == '_')
3723 {
3724 *pp = p + 1;
3725 *pi = count;
3726 }
3727 }
3728
b34976b6 3729 return TRUE;
252b5132
RH		 3730}
3731
3732/* This function demangles a physical name, returning a NULL
3733 terminated array of argument types. */
3734
3735static debug_type *
2da42df6
AJ		 3736stab_demangle_argtypes (void *dhandle, struct stab_handle *info,
3737 const char *physname, bfd_boolean *pvarargs,
3738 unsigned int physname_len)
252b5132
RH		 3739{
3740 struct stab_demangle_info minfo;
3741
041821e6
ILT		 3742 /* Check for the g++ V3 ABI. */
3743 if (physname[0] == '_' && physname[1] == 'Z')
3744 return stab_demangle_v3_argtypes (dhandle, info, physname, pvarargs);
3745
252b5132
RH		 3746 minfo.dhandle = dhandle;
3747 minfo.info = info;
3748 minfo.args = NULL;
b34976b6 3749 minfo.varargs = FALSE;
252b5132
RH		 3750 minfo.typestring_alloc = 10;
3751 minfo.typestrings = ((struct stab_demangle_typestring *)
3752 xmalloc (minfo.typestring_alloc
3753 * sizeof *minfo.typestrings));
3754 minfo.typestring_count = 0;
3755
3756 /* cplus_demangle checks for special GNU mangled forms, but we can't
3757 see any of them in mangled method argument types. */
3758
4b73ca92 3759 if (! stab_demangle_prefix (&minfo, &physname, physname_len))
252b5132
RH		 3760 goto error_return;
3761
3762 if (*physname != '\0')
3763 {
3764 if (! stab_demangle_signature (&minfo, &physname))
3765 goto error_return;
3766 }
3767
3768 free (minfo.typestrings);
3769 minfo.typestrings = NULL;
3770
3771 if (minfo.args == NULL)
3772 fprintf (stderr, _("no argument types in mangled string\n"));
3773
3774 *pvarargs = minfo.varargs;
3775 return minfo.args;
3776
3777 error_return:
3778 if (minfo.typestrings != NULL)
3779 free (minfo.typestrings);
3780 return NULL;
3781}
3782
3783/* Demangle the prefix of the mangled name. */
3784
b34976b6 3785static bfd_boolean
2da42df6
AJ		 3786stab_demangle_prefix (struct stab_demangle_info *minfo, const char **pp,
3787 unsigned int physname_len)
252b5132
RH		 3788{
3789 const char *scan;
3790 unsigned int i;
3791
3792 /* cplus_demangle checks for global constructors and destructors,
3793 but we can't see them in mangled argument types. */
3794
4b73ca92
NC		 3795 if (physname_len)
3796 scan = *pp + physname_len;
3797 else
252b5132 3798 {
4b73ca92
NC		 3799 /* Look for `__'. */
3800 scan = *pp;
3801 do
3802 scan = strchr (scan, '_');
3803 while (scan != NULL && *++scan != '_');
252b5132 3804
4b73ca92
NC		 3805 if (scan == NULL)
3806 {
3807 stab_bad_demangle (*pp);
b34976b6 3808 return FALSE;
4b73ca92 3809 }
252b5132 3810
4b73ca92 3811 --scan;
252b5132 3812
4b73ca92
NC		 3813 /* We found `__'; move ahead to the last contiguous `__' pair. */
3814 i = strspn (scan, "_");
3815 if (i > 2)
3816 scan += i - 2;
3817 }
252b5132
RH		 3818
3819 if (scan == *pp
3882b010 3820 && (ISDIGIT (scan[2])
252b5132
RH		 3821 || scan[2] == 'Q'
3822 || scan[2] == 't'))
3823 {
3824 /* This is a GNU style constructor name. */
3825 *pp = scan + 2;
b34976b6 3826 return TRUE;
252b5132
RH		 3827 }
3828 else if (scan == *pp
3882b010 3829 && ! ISDIGIT (scan[2])
252b5132
RH		 3830 && scan[2] != 't')
3831 {
3832 /* Look for the `__' that separates the prefix from the
3833 signature. */
3834 while (*scan == '_')
3835 ++scan;
3836 scan = strstr (scan, "__");
3837 if (scan == NULL || scan[2] == '\0')
3838 {
3839 stab_bad_demangle (*pp);
b34976b6 3840 return FALSE;
252b5132
RH		 3841 }
3842
3843 return stab_demangle_function_name (minfo, pp, scan);
3844 }
3845 else if (scan[2] != '\0')
3846 {
3847 /* The name doesn't start with `__', but it does contain `__'. */
3848 return stab_demangle_function_name (minfo, pp, scan);
3849 }
3850 else
3851 {
3852 stab_bad_demangle (*pp);
b34976b6 3853 return FALSE;
252b5132
RH		 3854 }
3855 /*NOTREACHED*/
3856}
3857
3858/* Demangle a function name prefix. The scan argument points to the
3859 double underscore which separates the function name from the
3860 signature. */
3861
b34976b6 3862static bfd_boolean
2da42df6
AJ		 3863stab_demangle_function_name (struct stab_demangle_info *minfo,
3864 const char **pp, const char *scan)
252b5132
RH		 3865{
3866 const char *name;
3867
3868 /* The string from *pp to scan is the name of the function. We
3869 don't care about the name, since we just looking for argument
3870 types. However, for conversion operators, the name may include a
3871 type which we must remember in order to handle backreferences. */
3872
3873 name = *pp;
3874 *pp = scan + 2;
3875
3876 if (*pp - name >= 5
0112cd26 3877 && CONST_STRNEQ (name, "type")
252b5132
RH		 3878 && (name[4] == '$' || name[4] == '.'))
3879 {
3880 const char *tem;
3881
3882 /* This is a type conversion operator. */
3883 tem = name + 5;
3884 if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
b34976b6 3885 return FALSE;
252b5132
RH		 3886 }
3887 else if (name[0] == '_'
3888 && name[1] == '_'
3889 && name[2] == 'o'
3890 && name[3] == 'p')
3891 {
3892 const char *tem;
3893
3894 /* This is a type conversion operator. */
3895 tem = name + 4;
3896 if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
b34976b6 3897 return FALSE;
252b5132
RH		 3898 }
3899
b34976b6 3900 return TRUE;
252b5132
RH		 3901}
3902
3903/* Demangle the signature. This is where the argument types are
3904 found. */
3905
b34976b6 3906static bfd_boolean
2da42df6 3907stab_demangle_signature (struct stab_demangle_info *minfo, const char **pp)
252b5132
RH		 3908{
3909 const char *orig;
b34976b6 3910 bfd_boolean expect_func, func_done;
252b5132
RH		 3911 const char *hold;
3912
3913 orig = *pp;
3914
b34976b6
AM		 3915 expect_func = FALSE;
3916 func_done = FALSE;
252b5132
RH		 3917 hold = NULL;
3918
3919 while (**pp != '\0')
3920 {
3921 switch (**pp)
3922 {
3923 case 'Q':
3924 hold = *pp;
3925 if (! stab_demangle_qualified (minfo, pp, (debug_type *) NULL)
3926 || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
b34976b6
AM		 3927 return FALSE;
3928 expect_func = TRUE;
252b5132
RH		 3929 hold = NULL;
3930 break;
3931
3932 case 'S':
3933 /* Static member function. FIXME: Can this happen? */
3934 if (hold == NULL)
3935 hold = *pp;
3936 ++*pp;
3937 break;
3938
3939 case 'C':
3940 /* Const member function. */
3941 if (hold == NULL)
3942 hold = *pp;
3943 ++*pp;
3944 break;
3945
3946 case '0': case '1': case '2': case '3': case '4':
3947 case '5': case '6': case '7': case '8': case '9':
3948 if (hold == NULL)
3949 hold = *pp;
3950 if (! stab_demangle_class (minfo, pp, (const char **) NULL)
3951 || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
b34976b6
AM		 3952 return FALSE;
3953 expect_func = TRUE;
252b5132
RH		 3954 hold = NULL;
3955 break;
3956
3957 case 'F':
3958 /* Function. I don't know if this actually happens with g++
3959 output. */
3960 hold = NULL;
b34976b6 3961 func_done = TRUE;
252b5132
RH		 3962 ++*pp;
3963 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
b34976b6 3964 return FALSE;
252b5132
RH		 3965 break;
3966
3967 case 't':
3968 /* Template. */
3969 if (hold == NULL)
3970 hold = *pp;
3971 if (! stab_demangle_template (minfo, pp, (char **) NULL)
3972 || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
b34976b6 3973 return FALSE;
252b5132 3974 hold = NULL;
b34976b6 3975 expect_func = TRUE;
252b5132
RH		 3976 break;
3977
3978 case '_':
3979 /* At the outermost level, we cannot have a return type
3980 specified, so if we run into another '_' at this point we
3981 are dealing with a mangled name that is either bogus, or
3982 has been mangled by some algorithm we don't know how to
3983 deal with. So just reject the entire demangling. */
3984 stab_bad_demangle (orig);
b34976b6 3985 return FALSE;
252b5132
RH		 3986
3987 default:
3988 /* Assume we have stumbled onto the first outermost function
3989 argument token, and start processing args. */
b34976b6 3990 func_done = TRUE;
252b5132 3991 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
b34976b6 3992 return FALSE;
252b5132
RH		 3993 break;
3994 }
3995
3996 if (expect_func)
3997 {
b34976b6 3998 func_done = TRUE;
252b5132 3999 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
b34976b6 4000 return FALSE;
252b5132
RH		 4001 }
4002 }
4003
4004 if (! func_done)
4005 {
4006 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
4007 bar__3fooi is 'foo::bar(int)'. We get here when we find the
4008 first case, and need to ensure that the '(void)' gets added
4009 to the current declp. */
4010 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
b34976b6 4011 return FALSE;
252b5132
RH		 4012 }
4013
b34976b6 4014 return TRUE;
252b5132
RH		 4015}
4016
4017/* Demangle a qualified name, such as "Q25Outer5Inner" which is the
4018 mangled form of "Outer::Inner". */
4019
b34976b6 4020static bfd_boolean
2da42df6
AJ		 4021stab_demangle_qualified (struct stab_demangle_info *minfo, const char **pp,
4022 debug_type *ptype)
252b5132
RH		 4023{
4024 const char *orig;
4025 const char *p;
4026 unsigned int qualifiers;
4027 debug_type context;
4028
4029 orig = *pp;
4030
4031 switch ((*pp)[1])
4032 {
4033 case '_':
4034 /* GNU mangled name with more than 9 classes. The count is
4035 preceded by an underscore (to distinguish it from the <= 9
4036 case) and followed by an underscore. */
4037 p = *pp + 2;
3882b010 4038 if (! ISDIGIT (*p) || *p == '0')
252b5132
RH		 4039 {
4040 stab_bad_demangle (orig);
b34976b6 4041 return FALSE;
252b5132
RH		 4042 }
4043 qualifiers = atoi (p);
3882b010 4044 while (ISDIGIT (*p))
252b5132
RH		 4045 ++p;
4046 if (*p != '_')
4047 {
4048 stab_bad_demangle (orig);
b34976b6 4049 return FALSE;
252b5132
RH		 4050 }
4051 *pp = p + 1;
4052 break;
4053
4054 case '1': case '2': case '3': case '4': case '5':
4055 case '6': case '7': case '8': case '9':
4056 qualifiers = (*pp)[1] - '0';
4057 /* Skip an optional underscore after the count. */
4058 if ((*pp)[2] == '_')
4059 ++*pp;
4060 *pp += 2;
4061 break;
4062
4063 case '0':
4064 default:
4065 stab_bad_demangle (orig);
b34976b6 4066 return FALSE;
252b5132
RH		 4067 }
4068
4069 context = DEBUG_TYPE_NULL;
4070
4071 /* Pick off the names. */
4072 while (qualifiers-- > 0)
4073 {
4074 if (**pp == '_')
4075 ++*pp;
4076 if (**pp == 't')
4077 {
4078 char *name;
4079
4080 if (! stab_demangle_template (minfo, pp,
4081 ptype != NULL ? &name : NULL))
b34976b6 4082 return FALSE;
252b5132
RH		 4083
4084 if (ptype != NULL)
4085 {
4086 context = stab_find_tagged_type (minfo->dhandle, minfo->info,
4087 name, strlen (name),
4088 DEBUG_KIND_CLASS);
4089 free (name);
4090 if (context == DEBUG_TYPE_NULL)
b34976b6 4091 return FALSE;
252b5132
RH		 4092 }
4093 }
4094 else
4095 {
4096 unsigned int len;
4097
4098 len = stab_demangle_count (pp);
4099 if (strlen (*pp) < len)
4100 {
4101 stab_bad_demangle (orig);
b34976b6 4102 return FALSE;
252b5132
RH		 4103 }
4104
4105 if (ptype != NULL)
4106 {
4107 const debug_field *fields;
4108
4109 fields = NULL;
4110 if (context != DEBUG_TYPE_NULL)
4111 fields = debug_get_fields (minfo->dhandle, context);
4112
4113 context = DEBUG_TYPE_NULL;
4114
4115 if (fields != NULL)
4116 {
4117 char *name;
4118
4119 /* Try to find the type by looking through the
4120 fields of context until we find a field with the
4121 same type. This ought to work for a class
4122 defined within a class, but it won't work for,
4123 e.g., an enum defined within a class. stabs does
4124 not give us enough information to figure out the
4125 latter case. */
4126
4127 name = savestring (*pp, len);
4128
4129 for (; *fields != DEBUG_FIELD_NULL; fields++)
4130 {
4131 debug_type ft;
4132 const char *dn;
4133
4134 ft = debug_get_field_type (minfo->dhandle, *fields);
4135 if (ft == NULL)
1fcab1af
NC		 4136 {
4137 free (name);
4138 return FALSE;
4139 }
252b5132
RH		 4140 dn = debug_get_type_name (minfo->dhandle, ft);
4141 if (dn != NULL && strcmp (dn, name) == 0)
4142 {
4143 context = ft;
4144 break;
4145 }
4146 }
4147
4148 free (name);
4149 }
4150
4151 if (context == DEBUG_TYPE_NULL)
4152 {
4153 /* We have to fall back on finding the type by name.
4154 If there are more types to come, then this must
4155 be a class. Otherwise, it could be anything. */
4156
4157 if (qualifiers == 0)
4158 {
4159 char *name;
4160
4161 name = savestring (*pp, len);
4162 context = debug_find_named_type (minfo->dhandle,
4163 name);
4164 free (name);
4165 }
4166
4167 if (context == DEBUG_TYPE_NULL)
4168 {
4169 context = stab_find_tagged_type (minfo->dhandle,
4170 minfo->info,
4171 *pp, len,
4172 (qualifiers == 0
4173 ? DEBUG_KIND_ILLEGAL
4174 : DEBUG_KIND_CLASS));
4175 if (context == DEBUG_TYPE_NULL)
b34976b6 4176 return FALSE;
252b5132
RH		 4177 }
4178 }
4179 }
4180
4181 *pp += len;
4182 }
4183 }
4184
4185 if (ptype != NULL)
4186 *ptype = context;
4187
b34976b6 4188 return TRUE;
252b5132
RH		 4189}
4190
4191/* Demangle a template. If PNAME is not NULL, this sets *PNAME to a
4192 string representation of the template. */
4193
b34976b6 4194static bfd_boolean
2da42df6
AJ		 4195stab_demangle_template (struct stab_demangle_info *minfo, const char **pp,
4196 char **pname)
252b5132
RH		 4197{
4198 const char *orig;
4199 unsigned int r, i;
4200
4201 orig = *pp;
4202
4203 ++*pp;
4204
4205 /* Skip the template name. */
4206 r = stab_demangle_count (pp);
4207 if (r == 0 || strlen (*pp) < r)
4208 {
4209 stab_bad_demangle (orig);
b34976b6 4210 return FALSE;
252b5132
RH		 4211 }
4212 *pp += r;
4213
4214 /* Get the size of the parameter list. */
4215 if (stab_demangle_get_count (pp, &r) == 0)
4216 {
4217 stab_bad_demangle (orig);
b34976b6 4218 return FALSE;
252b5132
RH		 4219 }
4220
4221 for (i = 0; i < r; i++)
4222 {
4223 if (**pp == 'Z')
4224 {
4225 /* This is a type parameter. */
4226 ++*pp;
4227 if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
b34976b6 4228 return FALSE;
252b5132
RH		 4229 }
4230 else
4231 {
4232 const char *old_p;
b34976b6
AM		 4233 bfd_boolean pointerp, realp, integralp, charp, boolp;
4234 bfd_boolean done;
252b5132
RH		 4235
4236 old_p = *pp;
b34976b6
AM		 4237 pointerp = FALSE;
4238 realp = FALSE;
4239 integralp = FALSE;
4240 charp = FALSE;
4241 boolp = FALSE;
4242 done = FALSE;
252b5132
RH		 4243
4244 /* This is a value parameter. */
4245
4246 if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
b34976b6 4247 return FALSE;
252b5132
RH		 4248
4249 while (*old_p != '\0' && ! done)
4250 {
4251 switch (*old_p)
4252 {
4253 case 'P':
4254 case 'p':
4255 case 'R':
b34976b6
AM		 4256 pointerp = TRUE;
4257 done = TRUE;
252b5132
RH		 4258 break;
4259 case 'C': /* Const. */
4260 case 'S': /* Signed. */
4261 case 'U': /* Unsigned. */
4262 case 'V': /* Volatile. */
4263 case 'F': /* Function. */
4264 case 'M': /* Member function. */
4265 case 'O': /* ??? */
4266 ++old_p;
4267 break;
4268 case 'Q': /* Qualified name. */
b34976b6
AM		 4269 integralp = TRUE;
4270 done = TRUE;
252b5132
RH		 4271 break;
4272 case 'T': /* Remembered type. */
4273 abort ();
4274 case 'v': /* Void. */
4275 abort ();
4276 case 'x': /* Long long. */
4277 case 'l': /* Long. */
4278 case 'i': /* Int. */
4279 case 's': /* Short. */
4280 case 'w': /* Wchar_t. */
b34976b6
AM		 4281 integralp = TRUE;
4282 done = TRUE;
252b5132
RH		 4283 break;
4284 case 'b': /* Bool. */
b34976b6
AM		 4285 boolp = TRUE;
4286 done = TRUE;
252b5132
RH		 4287 break;
4288 case 'c': /* Char. */
b34976b6
AM		 4289 charp = TRUE;
4290 done = TRUE;
252b5132
RH		 4291 break;
4292 case 'r': /* Long double. */
4293 case 'd': /* Double. */
4294 case 'f': /* Float. */
b34976b6
AM		 4295 realp = TRUE;
4296 done = TRUE;
252b5132
RH		 4297 break;
4298 default:
4299 /* Assume it's a user defined integral type. */
b34976b6
AM		 4300 integralp = TRUE;
4301 done = TRUE;
252b5132
RH		 4302 break;
4303 }
4304 }
4305
4306 if (integralp)
4307 {
4308 if (**pp == 'm')
4309 ++*pp;
3882b010 4310 while (ISDIGIT (**pp))
252b5132
RH		 4311 ++*pp;
4312 }
4313 else if (charp)
4314 {
4315 unsigned int val;
4316
4317 if (**pp == 'm')
4318 ++*pp;
4319 val = stab_demangle_count (pp);
4320 if (val == 0)
4321 {
4322 stab_bad_demangle (orig);
b34976b6 4323 return FALSE;
252b5132
RH		 4324 }
4325 }
4326 else if (boolp)
4327 {
4328 unsigned int val;
4329
4330 val = stab_demangle_count (pp);
4331 if (val != 0 && val != 1)
4332 {
4333 stab_bad_demangle (orig);
b34976b6 4334 return FALSE;
252b5132
RH		 4335 }
4336 }
4337 else if (realp)
4338 {
4339 if (**pp == 'm')
4340 ++*pp;
3882b010 4341 while (ISDIGIT (**pp))
252b5132
RH		 4342 ++*pp;
4343 if (**pp == '.')
4344 {
4345 ++*pp;
3882b010 4346 while (ISDIGIT (**pp))
252b5132
RH		 4347 ++*pp;
4348 }
4349 if (**pp == 'e')
4350 {
4351 ++*pp;
3882b010 4352 while (ISDIGIT (**pp))
252b5132
RH		 4353 ++*pp;
4354 }
4355 }
4356 else if (pointerp)
4357 {
4358 unsigned int len;
4359
2b25cacb
ILT		 4360 len = stab_demangle_count (pp);
4361 if (len == 0)
252b5132
RH		 4362 {
4363 stab_bad_demangle (orig);
b34976b6 4364 return FALSE;
252b5132
RH		 4365 }
4366 *pp += len;
4367 }
4368 }
4369 }
4370
4371 /* We can translate this to a string fairly easily by invoking the
4372 regular demangling routine. */
4373 if (pname != NULL)
4374 {
d81d6584 4375 char *s1, *s2, *s3, *s4 = NULL;
252b5132
RH		 4376 char *from, *to;
4377
4378 s1 = savestring (orig, *pp - orig);
4379
4380 s2 = concat ("NoSuchStrinG__", s1, (const char *) NULL);
4381
4382 free (s1);
4383
4384 s3 = cplus_demangle (s2, DMGL_ANSI);
4385
4386 free (s2);
4387
4388 if (s3 != NULL)
4389 s4 = strstr (s3, "::NoSuchStrinG");
4390 if (s3 == NULL || s4 == NULL)
4391 {
4392 stab_bad_demangle (orig);
4393 if (s3 != NULL)
4394 free (s3);
b34976b6 4395 return FALSE;
252b5132
RH		 4396 }
4397
4398 /* Eliminating all spaces, except those between > characters,
4399 makes it more likely that the demangled name will match the
4400 name which g++ used as the structure name. */
4401 for (from = to = s3; from != s4; ++from)
4402 if (*from != ' '
4403 || (from[1] == '>' && from > s3 && from[-1] == '>'))
4404 *to++ = *from;
4405
4406 *pname = savestring (s3, to - s3);
4407
4408 free (s3);
4409 }
4410
b34976b6 4411 return TRUE;
252b5132
RH		 4412}
4413
4414/* Demangle a class name. */
4415
b34976b6 4416static bfd_boolean
2da42df6
AJ		 4417stab_demangle_class (struct stab_demangle_info *minfo ATTRIBUTE_UNUSED,
4418 const char **pp, const char **pstart)
252b5132
RH		 4419{
4420 const char *orig;
4421 unsigned int n;
4422
4423 orig = *pp;
4424
4425 n = stab_demangle_count (pp);
4426 if (strlen (*pp) < n)
4427 {
4428 stab_bad_demangle (orig);
b34976b6 4429 return FALSE;
252b5132
RH		 4430 }
4431
4432 if (pstart != NULL)
4433 *pstart = *pp;
4434
4435 *pp += n;
4436
b34976b6 4437 return TRUE;
252b5132
RH		 4438}
4439
4440/* Demangle function arguments. If the pargs argument is not NULL, it
4441 is set to a NULL terminated array holding the arguments. */
4442
b34976b6 4443static bfd_boolean
2da42df6
AJ		 4444stab_demangle_args (struct stab_demangle_info *minfo, const char **pp,
4445 debug_type **pargs, bfd_boolean *pvarargs)
252b5132
RH		 4446{
4447 const char *orig;
4448 unsigned int alloc, count;
4449
4450 orig = *pp;
4451
4452 alloc = 10;
4453 if (pargs != NULL)
4454 {
4455 *pargs = (debug_type *) xmalloc (alloc * sizeof **pargs);
b34976b6 4456 *pvarargs = FALSE;
252b5132
RH		 4457 }
4458 count = 0;
4459
4460 while (**pp != '_' && **pp != '\0' && **pp != 'e')
4461 {
4462 if (**pp == 'N' || **pp == 'T')
4463 {
4464 char temptype;
4465 unsigned int r, t;
4466
4467 temptype = **pp;
4468 ++*pp;
4469
4470 if (temptype == 'T')
4471 r = 1;
4472 else
4473 {
4474 if (! stab_demangle_get_count (pp, &r))
4475 {
4476 stab_bad_demangle (orig);
b34976b6 4477 return FALSE;
252b5132
RH		 4478 }
4479 }
4480
4481 if (! stab_demangle_get_count (pp, &t))
4482 {
4483 stab_bad_demangle (orig);
b34976b6 4484 return FALSE;
252b5132
RH		 4485 }
4486
4487 if (t >= minfo->typestring_count)
4488 {
4489 stab_bad_demangle (orig);
b34976b6 4490 return FALSE;
252b5132
RH		 4491 }
4492 while (r-- > 0)
4493 {
4494 const char *tem;
4495
4496 tem = minfo->typestrings[t].typestring;
4497 if (! stab_demangle_arg (minfo, &tem, pargs, &count, &alloc))
b34976b6 4498 return FALSE;
252b5132
RH		 4499 }
4500 }
4501 else
4502 {
4503 if (! stab_demangle_arg (minfo, pp, pargs, &count, &alloc))
b34976b6 4504 return FALSE;
252b5132
RH		 4505 }
4506 }
4507
4508 if (pargs != NULL)
4509 (*pargs)[count] = DEBUG_TYPE_NULL;
4510
4511 if (**pp == 'e')
4512 {
4513 if (pargs != NULL)
b34976b6 4514 *pvarargs = TRUE;
252b5132
RH		 4515 ++*pp;
4516 }
4517
b34976b6 4518 return TRUE;
252b5132
RH		 4519}
4520
4521/* Demangle a single argument. */
4522
b34976b6 4523static bfd_boolean
2da42df6
AJ		 4524stab_demangle_arg (struct stab_demangle_info *minfo, const char **pp,
4525 debug_type **pargs, unsigned int *pcount,
4526 unsigned int *palloc)
252b5132
RH		 4527{
4528 const char *start;
4529 debug_type type;
4530
4531 start = *pp;
4532 if (! stab_demangle_type (minfo, pp,
4533 pargs == NULL ? (debug_type *) NULL : &type)
4534 || ! stab_demangle_remember_type (minfo, start, *pp - start))
b34976b6 4535 return FALSE;
252b5132
RH		 4536
4537 if (pargs != NULL)
4538 {
4539 if (type == DEBUG_TYPE_NULL)
b34976b6 4540 return FALSE;
252b5132
RH		 4541
4542 if (*pcount + 1 >= *palloc)
4543 {
4544 *palloc += 10;
4545 *pargs = ((debug_type *)
4546 xrealloc (*pargs, *palloc * sizeof **pargs));
4547 }
4548 (*pargs)[*pcount] = type;
4549 ++*pcount;
4550 }
4551
b34976b6 4552 return TRUE;
252b5132
RH		 4553}
4554
4555/* Demangle a type. If the ptype argument is not NULL, *ptype is set
4556 to the newly allocated type. */
4557
b34976b6 4558static bfd_boolean
2da42df6
AJ		 4559stab_demangle_type (struct stab_demangle_info *minfo, const char **pp,
4560 debug_type *ptype)
252b5132
RH		 4561{
4562 const char *orig;
4563
4564 orig = *pp;
4565
4566 switch (**pp)
4567 {
4568 case 'P':
4569 case 'p':
4570 /* A pointer type. */
4571 ++*pp;
4572 if (! stab_demangle_type (minfo, pp, ptype))
b34976b6 4573 return FALSE;
252b5132
RH		 4574 if (ptype != NULL)
4575 *ptype = debug_make_pointer_type (minfo->dhandle, *ptype);
4576 break;
4577
4578 case 'R':
4579 /* A reference type. */
4580 ++*pp;
4581 if (! stab_demangle_type (minfo, pp, ptype))
b34976b6 4582 return FALSE;
252b5132
RH		 4583 if (ptype != NULL)
4584 *ptype = debug_make_reference_type (minfo->dhandle, *ptype);
4585 break;
4586
4587 case 'A':
4588 /* An array. */
4589 {
4590 unsigned long high;
4591
4592 ++*pp;
4593 high = 0;
4594 while (**pp != '\0' && **pp != '_')
4595 {
3882b010 4596 if (! ISDIGIT (**pp))
252b5132
RH		 4597 {
4598 stab_bad_demangle (orig);
b34976b6 4599 return FALSE;
252b5132
RH		 4600 }
4601 high *= 10;
4602 high += **pp - '0';
4603 ++*pp;
4604 }
4605 if (**pp != '_')
4606 {
4607 stab_bad_demangle (orig);
b34976b6 4608 return FALSE;
252b5132
RH		 4609 }
4610 ++*pp;
4611
4612 if (! stab_demangle_type (minfo, pp, ptype))
b34976b6 4613 return FALSE;
252b5132
RH		 4614 if (ptype != NULL)
4615 {
4616 debug_type int_type;
4617
4618 int_type = debug_find_named_type (minfo->dhandle, "int");
4619 if (int_type == NULL)
b34976b6 4620 int_type = debug_make_int_type (minfo->dhandle, 4, FALSE);
252b5132 4621 *ptype = debug_make_array_type (minfo->dhandle, *ptype, int_type,
b34976b6 4622 0, high, FALSE);
252b5132
RH		 4623 }
4624 }
4625 break;
4626
4627 case 'T':
4628 /* A back reference to a remembered type. */
4629 {
4630 unsigned int i;
4631 const char *p;
4632
4633 ++*pp;
4634 if (! stab_demangle_get_count (pp, &i))
4635 {
4636 stab_bad_demangle (orig);
b34976b6 4637 return FALSE;
252b5132
RH		 4638 }
4639 if (i >= minfo->typestring_count)
4640 {
4641 stab_bad_demangle (orig);
b34976b6 4642 return FALSE;
252b5132
RH		 4643 }
4644 p = minfo->typestrings[i].typestring;
4645 if (! stab_demangle_type (minfo, &p, ptype))
b34976b6 4646 return FALSE;
252b5132
RH		 4647 }
4648 break;
4649
4650 case 'F':
4651 /* A function. */
4652 {
4653 debug_type *args;
b34976b6 4654 bfd_boolean varargs;
252b5132
RH		 4655
4656 ++*pp;
4657 if (! stab_demangle_args (minfo, pp,
4658 (ptype == NULL
4659 ? (debug_type **) NULL
4660 : &args),
4661 (ptype == NULL
b34976b6 4662 ? (bfd_boolean *) NULL
252b5132 4663 : &varargs)))
b34976b6 4664 return FALSE;
252b5132
RH		 4665 if (**pp != '_')
4666 {
4667 /* cplus_demangle will accept a function without a return
4668 type, but I don't know when that will happen, or what
4669 to do if it does. */
4670 stab_bad_demangle (orig);
b34976b6 4671 return FALSE;
252b5132
RH		 4672 }
4673 ++*pp;
4674 if (! stab_demangle_type (minfo, pp, ptype))
b34976b6 4675 return FALSE;
252b5132
RH		 4676 if (ptype != NULL)
4677 *ptype = debug_make_function_type (minfo->dhandle, *ptype, args,
4678 varargs);
4679
4680 }
4681 break;
4682
4683 case 'M':
4684 case 'O':
4685 {
3d540e93 4686 bfd_boolean memberp;
c602a165 4687 debug_type class_type = DEBUG_TYPE_NULL;
252b5132 4688 debug_type *args;
b34976b6 4689 bfd_boolean varargs;
252b5132
RH		 4690 unsigned int n;
4691 const char *name;
4692
4693 memberp = **pp == 'M';
252b5132 4694 args = NULL;
b34976b6 4695 varargs = FALSE;
252b5132
RH		 4696
4697 ++*pp;
3882b010 4698 if (ISDIGIT (**pp))
252b5132 4699 {
c602a165
ILT		 4700 n = stab_demangle_count (pp);
4701 if (strlen (*pp) < n)
4702 {
4703 stab_bad_demangle (orig);
b34976b6 4704 return FALSE;
c602a165
ILT		 4705 }
4706 name = *pp;
4707 *pp += n;
4708
4709 if (ptype != NULL)
4710 {
4711 class_type = stab_find_tagged_type (minfo->dhandle,
4712 minfo->info,
4713 name, (int) n,
4714 DEBUG_KIND_CLASS);
4715 if (class_type == DEBUG_TYPE_NULL)
b34976b6 4716 return FALSE;
c602a165 4717 }
252b5132 4718 }
c602a165
ILT		 4719 else if (**pp == 'Q')
4720 {
4721 if (! stab_demangle_qualified (minfo, pp,
4722 (ptype == NULL
4723 ? (debug_type *) NULL
4724 : &class_type)))
b34976b6 4725 return FALSE;
c602a165
ILT		 4726 }
4727 else
252b5132
RH		 4728 {
4729 stab_bad_demangle (orig);
b34976b6 4730 return FALSE;
252b5132 4731 }
252b5132
RH		 4732
4733 if (memberp)
4734 {
4735 if (**pp == 'C')
4736 {
252b5132
RH		 4737 ++*pp;
4738 }
4739 else if (**pp == 'V')
4740 {
252b5132
RH		 4741 ++*pp;
4742 }
4743 if (**pp != 'F')
4744 {
4745 stab_bad_demangle (orig);
b34976b6 4746 return FALSE;
252b5132
RH		 4747 }
4748 ++*pp;
4749 if (! stab_demangle_args (minfo, pp,
4750 (ptype == NULL
4751 ? (debug_type **) NULL
4752 : &args),
4753 (ptype == NULL
b34976b6 4754 ? (bfd_boolean *) NULL
252b5132 4755 : &varargs)))
b34976b6 4756 return FALSE;
252b5132
RH		 4757 }
4758
4759 if (**pp != '_')
4760 {
4761 stab_bad_demangle (orig);
b34976b6 4762 return FALSE;
252b5132
RH		 4763 }
4764 ++*pp;
4765
4766 if (! stab_demangle_type (minfo, pp, ptype))
b34976b6 4767 return FALSE;
252b5132
RH		 4768
4769 if (ptype != NULL)
4770 {
252b5132
RH		 4771 if (! memberp)
4772 *ptype = debug_make_offset_type (minfo->dhandle, class_type,
4773 *ptype);
4774 else
4775 {
4776 /* FIXME: We have no way to record constp or
4777 volatilep. */
4778 *ptype = debug_make_method_type (minfo->dhandle, *ptype,
4779 class_type, args, varargs);
4780 }
4781 }
4782 }
4783 break;
4784
4785 case 'G':
4786 ++*pp;
4787 if (! stab_demangle_type (minfo, pp, ptype))
b34976b6 4788 return FALSE;
252b5132
RH		 4789 break;
4790
4791 case 'C':
4792 ++*pp;
4793 if (! stab_demangle_type (minfo, pp, ptype))
b34976b6 4794 return FALSE;
252b5132
RH		 4795 if (ptype != NULL)
4796 *ptype = debug_make_const_type (minfo->dhandle, *ptype);
4797 break;
4798
4799 case 'Q':
4800 {
252b5132 4801 if (! stab_demangle_qualified (minfo, pp, ptype))
b34976b6 4802 return FALSE;
252b5132
RH		 4803 }
4804 break;
4805
4806 default:
4807 if (! stab_demangle_fund_type (minfo, pp, ptype))
b34976b6 4808 return FALSE;
252b5132
RH		 4809 break;
4810 }
4811
b34976b6 4812 return TRUE;
252b5132
RH		 4813}
4814
4815/* Demangle a fundamental type. If the ptype argument is not NULL,
4816 *ptype is set to the newly allocated type. */
4817
b34976b6 4818static bfd_boolean
2da42df6
AJ		 4819stab_demangle_fund_type (struct stab_demangle_info *minfo, const char **pp,
4820 debug_type *ptype)
252b5132
RH		 4821{
4822 const char *orig;
b34976b6
AM		 4823 bfd_boolean constp, volatilep, unsignedp, signedp;
4824 bfd_boolean done;
252b5132
RH		 4825
4826 orig = *pp;
4827
b34976b6
AM		 4828 constp = FALSE;
4829 volatilep = FALSE;
4830 unsignedp = FALSE;
4831 signedp = FALSE;
252b5132 4832
b34976b6 4833 done = FALSE;
252b5132
RH		 4834 while (! done)
4835 {
4836 switch (**pp)
4837 {
4838 case 'C':
b34976b6 4839 constp = TRUE;
252b5132
RH		 4840 ++*pp;
4841 break;
4842
4843 case 'U':
b34976b6 4844 unsignedp = TRUE;
252b5132
RH		 4845 ++*pp;
4846 break;
4847
4848 case 'S':
b34976b6 4849 signedp = TRUE;
252b5132
RH		 4850 ++*pp;
4851 break;
4852
4853 case 'V':
b34976b6 4854 volatilep = TRUE;
252b5132
RH		 4855 ++*pp;
4856 break;
4857
4858 default:
b34976b6 4859 done = TRUE;
252b5132
RH		 4860 break;
4861 }
4862 }
4863
4864 switch (**pp)
4865 {
4866 case '\0':
4867 case '_':
4868 /* cplus_demangle permits this, but I don't know what it means. */
4869 stab_bad_demangle (orig);
4870 break;
4871
4872 case 'v': /* void */
4873 if (ptype != NULL)
4874 {
4875 *ptype = debug_find_named_type (minfo->dhandle, "void");
4876 if (*ptype == DEBUG_TYPE_NULL)
4877 *ptype = debug_make_void_type (minfo->dhandle);
4878 }
4879 ++*pp;
4880 break;
4881
4882 case 'x': /* long long */
4883 if (ptype != NULL)
4884 {
4885 *ptype = debug_find_named_type (minfo->dhandle,
4886 (unsignedp
4887 ? "long long unsigned int"
4888 : "long long int"));
4889 if (*ptype == DEBUG_TYPE_NULL)
4890 *ptype = debug_make_int_type (minfo->dhandle, 8, unsignedp);
4891 }
4892 ++*pp;
4893 break;
4894
4895 case 'l': /* long */
4896 if (ptype != NULL)
4897 {
4898 *ptype = debug_find_named_type (minfo->dhandle,
4899 (unsignedp
4900 ? "long unsigned int"
4901 : "long int"));
4902 if (*ptype == DEBUG_TYPE_NULL)
4903 *ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp);
4904 }
4905 ++*pp;
4906 break;
4907
4908 case 'i': /* int */
4909 if (ptype != NULL)
4910 {
4911 *ptype = debug_find_named_type (minfo->dhandle,
4912 (unsignedp
4913 ? "unsigned int"
4914 : "int"));
4915 if (*ptype == DEBUG_TYPE_NULL)
4916 *ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp);
4917 }
4918 ++*pp;
4919 break;
4920
4921 case 's': /* short */
4922 if (ptype != NULL)
4923 {
4924 *ptype = debug_find_named_type (minfo->dhandle,
4925 (unsignedp
4926 ? "short unsigned int"
4927 : "short int"));
4928 if (*ptype == DEBUG_TYPE_NULL)
4929 *ptype = debug_make_int_type (minfo->dhandle, 2, unsignedp);
4930 }
4931 ++*pp;
4932 break;
4933
4934 case 'b': /* bool */
4935 if (ptype != NULL)
4936 {
4937 *ptype = debug_find_named_type (minfo->dhandle, "bool");
4938 if (*ptype == DEBUG_TYPE_NULL)
4939 *ptype = debug_make_bool_type (minfo->dhandle, 4);
4940 }
4941 ++*pp;
4942 break;
4943
4944 case 'c': /* char */
4945 if (ptype != NULL)
4946 {
4947 *ptype = debug_find_named_type (minfo->dhandle,
4948 (unsignedp
4949 ? "unsigned char"
4950 : (signedp
4951 ? "signed char"
4952 : "char")));
4953 if (*ptype == DEBUG_TYPE_NULL)
4954 *ptype = debug_make_int_type (minfo->dhandle, 1, unsignedp);
4955 }
4956 ++*pp;
4957 break;
4958
4959 case 'w': /* wchar_t */
4960 if (ptype != NULL)
4961 {
4962 *ptype = debug_find_named_type (minfo->dhandle, "__wchar_t");
4963 if (*ptype == DEBUG_TYPE_NULL)
b34976b6 4964 *ptype = debug_make_int_type (minfo->dhandle, 2, TRUE);
252b5132
RH		 4965 }
4966 ++*pp;
4967 break;
4968
4969 case 'r': /* long double */
4970 if (ptype != NULL)
4971 {
4972 *ptype = debug_find_named_type (minfo->dhandle, "long double");
4973 if (*ptype == DEBUG_TYPE_NULL)
4974 *ptype = debug_make_float_type (minfo->dhandle, 8);
4975 }
4976 ++*pp;
4977 break;
4978
4979 case 'd': /* double */
4980 if (ptype != NULL)
4981 {
4982 *ptype = debug_find_named_type (minfo->dhandle, "double");
4983 if (*ptype == DEBUG_TYPE_NULL)
4984 *ptype = debug_make_float_type (minfo->dhandle, 8);
4985 }
4986 ++*pp;
4987 break;
4988
4989 case 'f': /* float */
4990 if (ptype != NULL)
4991 {
4992 *ptype = debug_find_named_type (minfo->dhandle, "float");
4993 if (*ptype == DEBUG_TYPE_NULL)
4994 *ptype = debug_make_float_type (minfo->dhandle, 4);
4995 }
4996 ++*pp;
4997 break;
4998
4999 case 'G':
5000 ++*pp;
3882b010 5001 if (! ISDIGIT (**pp))
252b5132
RH		 5002 {
5003 stab_bad_demangle (orig);
b34976b6 5004 return FALSE;
252b5132
RH		 5005 }
5006 /* Fall through. */
5007 case '0': case '1': case '2': case '3': case '4':
5008 case '5': case '6': case '7': case '8': case '9':
5009 {
5010 const char *hold;
5011
5012 if (! stab_demangle_class (minfo, pp, &hold))
b34976b6 5013 return FALSE;
252b5132
RH		 5014 if (ptype != NULL)
5015 {
5016 char *name;
5017
5018 name = savestring (hold, *pp - hold);
5019 *ptype = debug_find_named_type (minfo->dhandle, name);
5020 free (name);
5021 if (*ptype == DEBUG_TYPE_NULL)
5022 {
5023 /* FIXME: It is probably incorrect to assume that
5024 undefined types are tagged types. */
5025 *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
5026 hold, *pp - hold,
5027 DEBUG_KIND_ILLEGAL);
5028 if (*ptype == DEBUG_TYPE_NULL)
b34976b6 5029 return FALSE;
252b5132
RH		 5030 }
5031 }
5032 }
5033 break;
5034
5035 case 't':
5036 {
5037 char *name;
5038
5039 if (! stab_demangle_template (minfo, pp,
5040 ptype != NULL ? &name : NULL))
b34976b6 5041 return FALSE;
252b5132
RH		 5042 if (ptype != NULL)
5043 {
5044 *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
5045 name, strlen (name),
5046 DEBUG_KIND_CLASS);
5047 free (name);
5048 if (*ptype == DEBUG_TYPE_NULL)
b34976b6 5049 return FALSE;
252b5132
RH		 5050 }
5051 }
5052 break;
5053
5054 default:
5055 stab_bad_demangle (orig);
b34976b6 5056 return FALSE;
252b5132
RH		 5057 }
5058
5059 if (ptype != NULL)
5060 {
5061 if (constp)
5062 *ptype = debug_make_const_type (minfo->dhandle, *ptype);
5063 if (volatilep)
5064 *ptype = debug_make_volatile_type (minfo->dhandle, *ptype);
5065 }
5066
b34976b6 5067 return TRUE;
252b5132
RH		 5068}
5069
5070/* Remember a type string in a demangled string. */
5071
b34976b6 5072static bfd_boolean
2da42df6
AJ		 5073stab_demangle_remember_type (struct stab_demangle_info *minfo,
5074 const char *p, int len)
252b5132
RH		 5075{
5076 if (minfo->typestring_count >= minfo->typestring_alloc)
5077 {
5078 minfo->typestring_alloc += 10;
5079 minfo->typestrings = ((struct stab_demangle_typestring *)
5080 xrealloc (minfo->typestrings,
5081 (minfo->typestring_alloc
5082 * sizeof *minfo->typestrings)));
5083 }
5084
5085 minfo->typestrings[minfo->typestring_count].typestring = p;
5086 minfo->typestrings[minfo->typestring_count].len = (unsigned int) len;
5087 ++minfo->typestring_count;
5088
b34976b6 5089 return TRUE;
252b5132 5090}
041821e6
ILT		 5091\f
5092/* Demangle names encoded using the g++ V3 ABI. The newer versions of
5093 g++ which use this ABI do not encode ordinary method argument types
5094 in a mangled name; they simply output the argument types. However,
5095 for a static method, g++ simply outputs the return type and the
5096 physical name. So in that case we need to demangle the name here.
5097 Here PHYSNAME is the physical name of the function, and we set the
5098 variable pointed at by PVARARGS to indicate whether this function
5099 is varargs. This returns NULL, or a NULL terminated array of
5100 argument types. */
5101
5102static debug_type *
5103stab_demangle_v3_argtypes (void *dhandle, struct stab_handle *info,
5104 const char *physname, bfd_boolean *pvarargs)
5105{
5106 struct demangle_component *dc;
5107 void *mem;
041821e6
ILT		 5108 debug_type *pargs;
5109
5110 dc = cplus_demangle_v3_components (physname, DMGL_PARAMS | DMGL_ANSI, &mem);
5111 if (dc == NULL)
5112 {
5113 stab_bad_demangle (physname);
5114 return NULL;
5115 }
5116
5117 /* We expect to see TYPED_NAME, and the right subtree describes the
5118 function type. */
5119 if (dc->type != DEMANGLE_COMPONENT_TYPED_NAME
5120 || dc->u.s_binary.right->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
5121 {
5122 fprintf (stderr, _("Demangled name is not a function\n"));
5123 free (mem);
5124 return NULL;
5125 }
5126
2b4c4cc4
ILT		 5127 pargs = stab_demangle_v3_arglist (dhandle, info,
5128 dc->u.s_binary.right->u.s_binary.right,
5129 pvarargs);
5130
5131 free (mem);
5132
5133 return pargs;
5134}
5135
5136/* Demangle an argument list in a struct demangle_component tree.
5137 Returns a DEBUG_TYPE_NULL terminated array of argument types, and
5138 sets *PVARARGS to indicate whether this is a varargs function. */
5139
5140static debug_type *
5141stab_demangle_v3_arglist (void *dhandle, struct stab_handle *info,
5142 struct demangle_component *arglist,
5143 bfd_boolean *pvarargs)
5144{
5145 struct demangle_component *dc;
5146 unsigned int alloc, count;
5147 debug_type *pargs;
5148
041821e6
ILT		 5149 alloc = 10;
5150 pargs = (debug_type *) xmalloc (alloc * sizeof *pargs);
5151 *pvarargs = FALSE;
5152
5153 count = 0;
5154
2b4c4cc4 5155 for (dc = arglist;
041821e6
ILT		 5156 dc != NULL;
5157 dc = dc->u.s_binary.right)
5158 {
5159 debug_type arg;
5160 bfd_boolean varargs;
5161
5162 if (dc->type != DEMANGLE_COMPONENT_ARGLIST)
5163 {
2b4c4cc4
ILT		 5164 fprintf (stderr, _("Unexpected type in v3 arglist demangling\n"));
5165 free (pargs);
041821e6
ILT		 5166 return NULL;
5167 }
5168
b149968f
NC		 5169 /* PR 13925: Cope if the demangler returns an empty
5170 context for a function with no arguments. */
5171 if (dc->u.s_binary.left == NULL)
5172 break;
5173
041821e6
ILT		 5174 arg = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left,
5175 NULL, &varargs);
5176 if (arg == NULL)
5177 {
5178 if (varargs)
5179 {
5180 *pvarargs = TRUE;
5181 continue;
5182 }
2b4c4cc4 5183 free (pargs);
041821e6
ILT		 5184 return NULL;
5185 }
5186
5187 if (count + 1 >= alloc)
5188 {
5189 alloc += 10;
5190 pargs = (debug_type *) xrealloc (pargs, alloc * sizeof *pargs);
5191 }
5192
5193 pargs[count] = arg;
5194 ++count;
5195 }
5196
5197 pargs[count] = DEBUG_TYPE_NULL;
5198
041821e6
ILT		 5199 return pargs;
5200}
5201
5202/* Convert a struct demangle_component tree describing an argument
5203 type into a debug_type. */
5204
5205static debug_type
5206stab_demangle_v3_arg (void *dhandle, struct stab_handle *info,
5207 struct demangle_component *dc, debug_type context,
5208 bfd_boolean *pvarargs)
5209{
5210 debug_type dt;
5211
5212 if (pvarargs != NULL)
5213 *pvarargs = FALSE;
5214
5215 switch (dc->type)
5216 {
5217 /* FIXME: These are demangle component types which we probably
5218 need to handle one way or another. */
5219 case DEMANGLE_COMPONENT_LOCAL_NAME:
5220 case DEMANGLE_COMPONENT_TYPED_NAME:
5221 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
5222 case DEMANGLE_COMPONENT_CTOR:
5223 case DEMANGLE_COMPONENT_DTOR:
5224 case DEMANGLE_COMPONENT_JAVA_CLASS:
5225 case DEMANGLE_COMPONENT_RESTRICT_THIS:
5226 case DEMANGLE_COMPONENT_VOLATILE_THIS:
5227 case DEMANGLE_COMPONENT_CONST_THIS:
5228 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5229 case DEMANGLE_COMPONENT_COMPLEX:
5230 case DEMANGLE_COMPONENT_IMAGINARY:
5231 case DEMANGLE_COMPONENT_VENDOR_TYPE:
041821e6
ILT		 5232 case DEMANGLE_COMPONENT_ARRAY_TYPE:
5233 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5234 case DEMANGLE_COMPONENT_ARGLIST:
5235 default:
2b4c4cc4
ILT		 5236 fprintf (stderr, _("Unrecognized demangle component %d\n"),
5237 (int) dc->type);
041821e6
ILT		 5238 return NULL;
5239
5240 case DEMANGLE_COMPONENT_NAME:
5241 if (context != NULL)
5242 {
5243 const debug_field *fields;
5244
5245 fields = debug_get_fields (dhandle, context);
5246 if (fields != NULL)
5247 {
5248 /* Try to find this type by looking through the context
5249 class. */
5250 for (; *fields != DEBUG_FIELD_NULL; fields++)
5251 {
5252 debug_type ft;
5253 const char *dn;
5254
5255 ft = debug_get_field_type (dhandle, *fields);
5256 if (ft == NULL)
5257 return NULL;
5258 dn = debug_get_type_name (dhandle, ft);
5259 if (dn != NULL
5260 && (int) strlen (dn) == dc->u.s_name.len
5261 && strncmp (dn, dc->u.s_name.s, dc->u.s_name.len) == 0)
5262 return ft;
5263 }
5264 }
5265 }
5266 return stab_find_tagged_type (dhandle, info, dc->u.s_name.s,
5267 dc->u.s_name.len, DEBUG_KIND_ILLEGAL);
5268
5269 case DEMANGLE_COMPONENT_QUAL_NAME:
5270 context = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left,
5271 context, NULL);
5272 if (context == NULL)
5273 return NULL;
5274 return stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.right,
5275 context, NULL);
5276
5277 case DEMANGLE_COMPONENT_TEMPLATE:
5278 {
5279 char *p;
5280 size_t alc;
5281
5282 /* We print this component to get a class name which we can
5283 use. FIXME: This probably won't work if the template uses
5284 template parameters which refer to an outer template. */
5285 p = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, dc, 20, &alc);
5286 if (p == NULL)
5287 {
5288 fprintf (stderr, _("Failed to print demangled template\n"));
5289 return NULL;
5290 }
5291 dt = stab_find_tagged_type (dhandle, info, p, strlen (p),
5292 DEBUG_KIND_CLASS);
5293 free (p);
5294 return dt;
5295 }
5296
5297 case DEMANGLE_COMPONENT_SUB_STD:
5298 return stab_find_tagged_type (dhandle, info, dc->u.s_string.string,
5299 dc->u.s_string.len, DEBUG_KIND_ILLEGAL);
5300
5301 case DEMANGLE_COMPONENT_RESTRICT:
5302 case DEMANGLE_COMPONENT_VOLATILE:
5303 case DEMANGLE_COMPONENT_CONST:
5304 case DEMANGLE_COMPONENT_POINTER:
5305 case DEMANGLE_COMPONENT_REFERENCE:
5306 dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL,
5307 NULL);
5308 if (dt == NULL)
5309 return NULL;
5310
5311 switch (dc->type)
5312 {
5313 default:
5314 abort ();
5315 case DEMANGLE_COMPONENT_RESTRICT:
5316 /* FIXME: We have no way to represent restrict. */
5317 return dt;
5318 case DEMANGLE_COMPONENT_VOLATILE:
5319 return debug_make_volatile_type (dhandle, dt);
5320 case DEMANGLE_COMPONENT_CONST:
5321 return debug_make_const_type (dhandle, dt);
5322 case DEMANGLE_COMPONENT_POINTER:
5323 return debug_make_pointer_type (dhandle, dt);
5324 case DEMANGLE_COMPONENT_REFERENCE:
5325 return debug_make_reference_type (dhandle, dt);
5326 }
5327
2b4c4cc4
ILT		 5328 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
5329 {
5330 debug_type *pargs;
5331 bfd_boolean varargs;
5332
5333 if (dc->u.s_binary.left == NULL)
5334 {
5335 /* In this case the return type is actually unknown.
5336 However, I'm not sure this will ever arise in practice;
5337 normally an unknown return type would only appear at
5338 the top level, which is handled above. */
5339 dt = debug_make_void_type (dhandle);
5340 }
5341 else
5342 dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL,
5343 NULL);
5344 if (dt == NULL)
5345 return NULL;
5346
5347 pargs = stab_demangle_v3_arglist (dhandle, info,
5348 dc->u.s_binary.right,
5349 &varargs);
5350 if (pargs == NULL)
5351 return NULL;
5352
5353 return debug_make_function_type (dhandle, dt, pargs, varargs);
5354 }
5355
041821e6
ILT		 5356 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
5357 {
5358 char *p;
5359 size_t alc;
5360 debug_type ret;
5361
5362 /* We print this component in order to find out the type name.
5363 FIXME: Should we instead expose the
5364 demangle_builtin_type_info structure? */
5365 p = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, dc, 20, &alc);
5366 if (p == NULL)
5367 {
5368 fprintf (stderr, _("Couldn't get demangled builtin type\n"));
5369 return NULL;
5370 }
5371
5372 /* The mangling is based on the type, but does not itself
5373 indicate what the sizes are. So we have to guess. */
5374 if (strcmp (p, "signed char") == 0)
5375 ret = debug_make_int_type (dhandle, 1, FALSE);
5376 else if (strcmp (p, "bool") == 0)
5377 ret = debug_make_bool_type (dhandle, 1);
5378 else if (strcmp (p, "char") == 0)
5379 ret = debug_make_int_type (dhandle, 1, FALSE);
5380 else if (strcmp (p, "double") == 0)
5381 ret = debug_make_float_type (dhandle, 8);
5382 else if (strcmp (p, "long double") == 0)
5383 ret = debug_make_float_type (dhandle, 8);
5384 else if (strcmp (p, "float") == 0)
5385 ret = debug_make_float_type (dhandle, 4);
5386 else if (strcmp (p, "__float128") == 0)
5387 ret = debug_make_float_type (dhandle, 16);
5388 else if (strcmp (p, "unsigned char") == 0)
5389 ret = debug_make_int_type (dhandle, 1, TRUE);
5390 else if (strcmp (p, "int") == 0)
5391 ret = debug_make_int_type (dhandle, 4, FALSE);
5392 else if (strcmp (p, "unsigned int") == 0)
5393 ret = debug_make_int_type (dhandle, 4, TRUE);
5394 else if (strcmp (p, "long") == 0)
5395 ret = debug_make_int_type (dhandle, 4, FALSE);
5396 else if (strcmp (p, "unsigned long") == 0)
5397 ret = debug_make_int_type (dhandle, 4, TRUE);
5398 else if (strcmp (p, "__int128") == 0)
5399 ret = debug_make_int_type (dhandle, 16, FALSE);
5400 else if (strcmp (p, "unsigned __int128") == 0)
5401 ret = debug_make_int_type (dhandle, 16, TRUE);
5402 else if (strcmp (p, "short") == 0)
5403 ret = debug_make_int_type (dhandle, 2, FALSE);
5404 else if (strcmp (p, "unsigned short") == 0)
5405 ret = debug_make_int_type (dhandle, 2, TRUE);
5406 else if (strcmp (p, "void") == 0)
5407 ret = debug_make_void_type (dhandle);
5408 else if (strcmp (p, "wchar_t") == 0)
5409 ret = debug_make_int_type (dhandle, 4, TRUE);
5410 else if (strcmp (p, "long long") == 0)
5411 ret = debug_make_int_type (dhandle, 8, FALSE);
5412 else if (strcmp (p, "unsigned long long") == 0)
5413 ret = debug_make_int_type (dhandle, 8, TRUE);
5414 else if (strcmp (p, "...") == 0)
5415 {
5416 if (pvarargs == NULL)
5417 fprintf (stderr, _("Unexpected demangled varargs\n"));
5418 else
5419 *pvarargs = TRUE;
5420 ret = NULL;
5421 }
5422 else
5423 {
5424 fprintf (stderr, _("Unrecognized demangled builtin type\n"));
5425 ret = NULL;
5426 }
5427
5428 free (p);
5429
5430 return ret;
5431 }
5432 }
5433}
GDB Binutils - Deliverables
This page took 0.785105 seconds and 4 git commands to generate.