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