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