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