1 /* stabs.c -- Parse stabs debugging information
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2006, 2007, 2008 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor <ian@cygnus.com>.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
23 /* This file contains code which parses stabs debugging information.
24 The organization of this code is based on the gdb stabs reading
25 code. The job it does is somewhat different, because it is not
26 trying to identify the correct address for anything. */
30 #include "libiberty.h"
31 #include "safe-ctype.h"
35 #include "filenames.h"
36 #include "aout/aout64.h"
37 #include "aout/stab_gnu.h"
39 /* The number of predefined XCOFF types. */
41 #define XCOFF_TYPE_COUNT 34
43 /* This structure is used as a handle so that the stab parsing doesn't
44 need to use any static variables. */
50 /* TRUE if this is stabs in sections. */
52 /* The symbol table. */
54 /* The number of symbols. */
56 /* The accumulated file name string. */
58 /* The value of the last N_SO symbol. */
60 /* The value of the start of the file, so that we can handle file
61 relative N_LBRAC and N_RBRAC symbols. */
62 bfd_vma file_start_offset;
63 /* The offset of the start of the function, so that we can handle
64 function relative N_LBRAC and N_RBRAC symbols. */
65 bfd_vma function_start_offset;
66 /* The version number of gcc which compiled the current compilation
67 unit, 0 if not compiled by gcc. */
69 /* Whether an N_OPT symbol was seen that was not generated by gcc,
70 so that we can detect the SunPRO compiler. */
71 bfd_boolean n_opt_found;
72 /* The main file name. */
74 /* A stack of unfinished N_BINCL files. */
75 struct bincl_file *bincl_stack;
76 /* A list of finished N_BINCL files. */
77 struct bincl_file *bincl_list;
78 /* Whether we are inside a function or not. */
79 bfd_boolean within_function;
80 /* The address of the end of the function, used if we have seen an
81 N_FUN symbol while in a function. This is -1 if we have not seen
82 an N_FUN (the normal case). */
84 /* The depth of block nesting. */
86 /* List of pending variable definitions. */
87 struct stab_pending_var *pending;
88 /* Number of files for which we have types. */
90 /* Lists of types per file. */
91 struct stab_types **file_types;
92 /* Predefined XCOFF types. */
93 debug_type xcoff_types[XCOFF_TYPE_COUNT];
95 struct stab_tag *tags;
96 /* Set by parse_stab_type if it sees a structure defined as a cross
97 reference to itself. Reset by parse_stab_type otherwise. */
98 bfd_boolean self_crossref;
101 /* A list of these structures is used to hold pending variable
102 definitions seen before the N_LBRAC of a block. */
104 struct stab_pending_var
106 /* Next pending variable definition. */
107 struct stab_pending_var *next;
113 enum debug_var_kind kind;
118 /* A list of these structures is used to hold the types for a single
123 /* Next set of slots for this file. */
124 struct stab_types *next;
125 /* Types indexed by type number. */
126 #define STAB_TYPES_SLOTS (16)
127 debug_type types[STAB_TYPES_SLOTS];
130 /* We keep a list of undefined tags that we encounter, so that we can
131 fill them in if the tag is later defined. */
135 /* Next undefined tag. */
136 struct stab_tag *next;
140 enum debug_type_kind kind;
141 /* Slot to hold real type when we discover it. If we don't, we fill
142 in an undefined tag type. */
144 /* Indirect type we have created to point at slot. */
148 static char *savestring (const char *, int);
149 static bfd_vma parse_number (const char **, bfd_boolean *);
150 static void bad_stab (const char *);
151 static void warn_stab (const char *, const char *);
152 static bfd_boolean parse_stab_string
153 (void *, struct stab_handle *, int, int, bfd_vma, const char *);
154 static debug_type parse_stab_type
155 (void *, struct stab_handle *, const char *, const char **, debug_type **);
156 static bfd_boolean parse_stab_type_number (const char **, int *);
157 static debug_type parse_stab_range_type
158 (void *, struct stab_handle *, const char *, const char **, const int *);
159 static debug_type parse_stab_sun_builtin_type (void *, const char **);
160 static debug_type parse_stab_sun_floating_type (void *, const char **);
161 static debug_type parse_stab_enum_type (void *, const char **);
162 static debug_type parse_stab_struct_type
163 (void *, struct stab_handle *, const char *, const char **,
164 bfd_boolean, const int *);
165 static bfd_boolean parse_stab_baseclasses
166 (void *, struct stab_handle *, const char **, debug_baseclass **);
167 static bfd_boolean parse_stab_struct_fields
168 (void *, struct stab_handle *, const char **, debug_field **, bfd_boolean *);
169 static bfd_boolean parse_stab_cpp_abbrev
170 (void *, struct stab_handle *, const char **, debug_field *);
171 static bfd_boolean parse_stab_one_struct_field
172 (void *, struct stab_handle *, const char **, const char *,
173 debug_field *, bfd_boolean *);
174 static bfd_boolean parse_stab_members
175 (void *, struct stab_handle *, const char *, const char **, const int *,
177 static debug_type parse_stab_argtypes
178 (void *, struct stab_handle *, debug_type, const char *, const char *,
179 debug_type, const char *, bfd_boolean, bfd_boolean, const char **);
180 static bfd_boolean parse_stab_tilde_field
181 (void *, struct stab_handle *, const char **, const int *, debug_type *,
183 static debug_type parse_stab_array_type
184 (void *, struct stab_handle *, const char **, bfd_boolean);
185 static void push_bincl (struct stab_handle *, const char *, bfd_vma);
186 static const char *pop_bincl (struct stab_handle *);
187 static bfd_boolean find_excl (struct stab_handle *, const char *, bfd_vma);
188 static bfd_boolean stab_record_variable
189 (void *, struct stab_handle *, const char *, debug_type,
190 enum debug_var_kind, bfd_vma);
191 static bfd_boolean stab_emit_pending_vars (void *, struct stab_handle *);
192 static debug_type *stab_find_slot (struct stab_handle *, const int *);
193 static debug_type stab_find_type (void *, struct stab_handle *, const int *);
194 static bfd_boolean stab_record_type
195 (void *, struct stab_handle *, const int *, debug_type);
196 static debug_type stab_xcoff_builtin_type
197 (void *, struct stab_handle *, int);
198 static debug_type stab_find_tagged_type
199 (void *, struct stab_handle *, const char *, int, enum debug_type_kind);
200 static debug_type *stab_demangle_argtypes
201 (void *, struct stab_handle *, const char *, bfd_boolean *, unsigned int);
202 static debug_type *stab_demangle_v3_argtypes
203 (void *, struct stab_handle *, const char *, bfd_boolean *);
204 static debug_type *stab_demangle_v3_arglist
205 (void *, struct stab_handle *, struct demangle_component *, bfd_boolean *);
206 static debug_type stab_demangle_v3_arg
207 (void *, struct stab_handle *, struct demangle_component *, debug_type,
210 /* Save a string in memory. */
213 savestring (const char *start, int len)
217 ret = (char *) xmalloc (len + 1);
218 memcpy (ret, start, len);
223 /* Read a number from a string. */
226 parse_number (const char **pp, bfd_boolean *poverflow)
231 if (poverflow != NULL)
237 ul = strtoul (*pp, (char **) pp, 0);
238 if (ul + 1 != 0 || errno == 0)
240 /* If bfd_vma is larger than unsigned long, and the number is
241 meant to be negative, we have to make sure that we sign
244 return (bfd_vma) (bfd_signed_vma) (long) ul;
248 /* Note that even though strtoul overflowed, it should have set *pp
249 to the end of the number, which is where we want it. */
250 if (sizeof (bfd_vma) > sizeof (unsigned long))
255 bfd_vma over, lastdig;
256 bfd_boolean overflow;
259 /* Our own version of strtoul, for a bfd_vma. */
274 if (p[1] == 'x' || p[1] == 'X')
286 over = ((bfd_vma) (bfd_signed_vma) -1) / (bfd_vma) base;
287 lastdig = ((bfd_vma) (bfd_signed_vma) -1) % (bfd_vma) base;
298 else if (ISUPPER (d))
300 else if (ISLOWER (d))
308 if (v > over || (v == over && (bfd_vma) d > lastdig))
323 /* If we get here, the number is too large to represent in a
325 if (poverflow != NULL)
328 warn_stab (orig, _("numeric overflow"));
333 /* Give an error for a bad stab string. */
336 bad_stab (const char *p)
338 fprintf (stderr, _("Bad stab: %s\n"), p);
341 /* Warn about something in a stab string. */
344 warn_stab (const char *p, const char *err)
346 fprintf (stderr, _("Warning: %s: %s\n"), err, p);
349 /* Create a handle to parse stabs symbols with. */
352 start_stab (void *dhandle ATTRIBUTE_UNUSED, bfd *abfd, bfd_boolean sections,
353 asymbol **syms, long symcount)
355 struct stab_handle *ret;
357 ret = (struct stab_handle *) xmalloc (sizeof *ret);
358 memset (ret, 0, sizeof *ret);
360 ret->sections = sections;
362 ret->symcount = symcount;
364 ret->file_types = (struct stab_types **) xmalloc (sizeof *ret->file_types);
365 ret->file_types[0] = NULL;
366 ret->function_end = (bfd_vma) -1;
370 /* When we have processed all the stabs information, we need to go
371 through and fill in all the undefined tags. */
374 finish_stab (void *dhandle, void *handle)
376 struct stab_handle *info = (struct stab_handle *) handle;
379 if (info->within_function)
381 if (! stab_emit_pending_vars (dhandle, info)
382 || ! debug_end_function (dhandle, info->function_end))
384 info->within_function = FALSE;
385 info->function_end = (bfd_vma) -1;
388 for (st = info->tags; st != NULL; st = st->next)
390 enum debug_type_kind kind;
393 if (kind == DEBUG_KIND_ILLEGAL)
394 kind = DEBUG_KIND_STRUCT;
395 st->slot = debug_make_undefined_tagged_type (dhandle, st->name, kind);
396 if (st->slot == DEBUG_TYPE_NULL)
403 /* Handle a single stabs symbol. */
406 parse_stab (void *dhandle, void *handle, int type, int desc, bfd_vma value,
409 struct stab_handle *info = (struct stab_handle *) handle;
411 /* gcc will emit two N_SO strings per compilation unit, one for the
412 directory name and one for the file name. We just collect N_SO
413 strings as we see them, and start the new compilation unit when
414 we see a non N_SO symbol. */
415 if (info->so_string != NULL
416 && (type != N_SO || *string == '\0' || value != info->so_value))
418 if (! debug_set_filename (dhandle, info->so_string))
420 info->main_filename = info->so_string;
422 info->gcc_compiled = 0;
423 info->n_opt_found = FALSE;
425 /* Generally, for stabs in the symbol table, the N_LBRAC and
426 N_RBRAC symbols are relative to the N_SO symbol value. */
427 if (! info->sections)
428 info->file_start_offset = info->so_value;
430 /* We need to reset the mapping from type numbers to types. We
431 can't free the old mapping, because of the use of
432 debug_make_indirect_type. */
434 info->file_types = ((struct stab_types **)
435 xmalloc (sizeof *info->file_types));
436 info->file_types[0] = NULL;
438 info->so_string = NULL;
440 /* Now process whatever type we just got. */
450 /* Ignore extra outermost context from SunPRO cc and acc. */
451 if (info->n_opt_found && desc == 1)
454 if (! info->within_function)
456 fprintf (stderr, _("N_LBRAC not within function\n"));
460 /* Start an inner lexical block. */
461 if (! debug_start_block (dhandle,
463 + info->file_start_offset
464 + info->function_start_offset)))
467 /* Emit any pending variable definitions. */
468 if (! stab_emit_pending_vars (dhandle, info))
475 /* Ignore extra outermost context from SunPRO cc and acc. */
476 if (info->n_opt_found && desc == 1)
479 /* We shouldn't have any pending variable definitions here, but,
480 if we do, we probably need to emit them before closing the
482 if (! stab_emit_pending_vars (dhandle, info))
485 /* End an inner lexical block. */
486 if (! debug_end_block (dhandle,
488 + info->file_start_offset
489 + info->function_start_offset)))
493 if (info->block_depth < 0)
495 fprintf (stderr, _("Too many N_RBRACs\n"));
501 /* This always ends a function. */
502 if (info->within_function)
508 && info->function_end != (bfd_vma) -1
509 && info->function_end < endval)
510 endval = info->function_end;
511 if (! stab_emit_pending_vars (dhandle, info)
512 || ! debug_end_function (dhandle, endval))
514 info->within_function = FALSE;
515 info->function_end = (bfd_vma) -1;
518 /* An empty string is emitted by gcc at the end of a compilation
523 /* Just accumulate strings until we see a non N_SO symbol. If
524 the string starts with a directory separator or some other
525 form of absolute path specification, we discard the previously
526 accumulated strings. */
527 if (info->so_string == NULL)
528 info->so_string = xstrdup (string);
535 if (IS_ABSOLUTE_PATH (string))
536 info->so_string = xstrdup (string);
538 info->so_string = concat (info->so_string, string,
539 (const char *) NULL);
543 info->so_value = value;
548 /* Start an include file. */
549 if (! debug_start_source (dhandle, string))
554 /* Start an include file which may be replaced. */
555 push_bincl (info, string, value);
556 if (! debug_start_source (dhandle, string))
561 /* End an N_BINCL include. */
562 if (! debug_start_source (dhandle, pop_bincl (info)))
567 /* This is a duplicate of a header file named by N_BINCL which
568 was eliminated by the linker. */
569 if (! find_excl (info, string, value))
574 if (! debug_record_line (dhandle, desc,
575 value + (info->within_function
576 ? info->function_start_offset : 0)))
581 if (! debug_start_common_block (dhandle, string))
586 if (! debug_end_common_block (dhandle, string))
593 if (info->within_function)
595 /* This always marks the end of a function; we don't
596 need to worry about info->function_end. */
598 value += info->function_start_offset;
599 if (! stab_emit_pending_vars (dhandle, info)
600 || ! debug_end_function (dhandle, value))
602 info->within_function = FALSE;
603 info->function_end = (bfd_vma) -1;
608 /* A const static symbol in the .text section will have an N_FUN
609 entry. We need to use these to mark the end of the function,
610 in case we are looking at gcc output before it was changed to
611 always emit an empty N_FUN. We can't call debug_end_function
612 here, because it might be a local static symbol. */
613 if (info->within_function
614 && (info->function_end == (bfd_vma) -1
615 || value < info->function_end))
616 info->function_end = value;
619 /* FIXME: gdb checks the string for N_STSYM, N_LCSYM or N_ROSYM
620 symbols, and if it does not start with :S, gdb relocates the
621 value to the start of the section. gcc always seems to use
622 :S, so we don't worry about this. */
628 colon = strchr (string, ':');
630 && (colon[1] == 'f' || colon[1] == 'F'))
632 if (info->within_function)
637 if (info->function_end != (bfd_vma) -1
638 && info->function_end < endval)
639 endval = info->function_end;
640 if (! stab_emit_pending_vars (dhandle, info)
641 || ! debug_end_function (dhandle, endval))
643 info->function_end = (bfd_vma) -1;
645 /* For stabs in sections, line numbers and block addresses
646 are offsets from the start of the function. */
648 info->function_start_offset = value;
649 info->within_function = TRUE;
652 if (! parse_stab_string (dhandle, info, type, desc, value, string))
658 if (string != NULL && strcmp (string, "gcc2_compiled.") == 0)
659 info->gcc_compiled = 2;
660 else if (string != NULL && strcmp (string, "gcc_compiled.") == 0)
661 info->gcc_compiled = 1;
663 info->n_opt_found = TRUE;
676 /* Parse the stabs string. */
679 parse_stab_string (void *dhandle, struct stab_handle *info, int stabtype,
680 int desc, bfd_vma value, const char *string)
687 bfd_boolean self_crossref;
691 p = strchr (string, ':');
706 /* GCC 2.x puts the line number in desc. SunOS apparently puts in
707 the number of bytes occupied by a type or object, which we
709 if (info->gcc_compiled >= 2)
714 /* FIXME: Sometimes the special C++ names start with '.'. */
716 if (string[0] == '$')
724 /* Was: name = "vptr"; */
730 /* This was an anonymous type that was never fixed up. */
733 /* SunPRO (3.0 at least) static variable encoding. */
736 warn_stab (string, _("unknown C++ encoded name"));
743 if (p == string || (string[0] == ' ' && p == string + 1))
746 name = savestring (string, p - string);
750 if (ISDIGIT (*p) || *p == '(' || *p == '-')
758 /* c is a special case, not followed by a type-number.
759 SYMBOL:c=iVALUE for an integer constant symbol.
760 SYMBOL:c=rVALUE for a floating constant symbol.
761 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
762 e.g. "b:c=e6,0" for "const b = blob1"
763 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
773 /* Floating point constant. */
774 if (! debug_record_float_const (dhandle, name, atof (p)))
778 /* Integer constant. */
779 /* Defining integer constants this way is kind of silly,
780 since 'e' constants allows the compiler to give not only
781 the value, but the type as well. C has at least int,
782 long, unsigned int, and long long as constant types;
783 other languages probably should have at least unsigned as
784 well as signed constants. */
785 if (! debug_record_int_const (dhandle, name, atoi (p)))
789 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
790 can be represented as integral.
791 e.g. "b:c=e6,0" for "const b = blob1"
792 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
793 dtype = parse_stab_type (dhandle, info, (const char *) NULL,
794 &p, (debug_type **) NULL);
795 if (dtype == DEBUG_TYPE_NULL)
802 if (! debug_record_typed_const (dhandle, name, dtype, atoi (p)))
813 /* The name of a caught exception. */
814 dtype = parse_stab_type (dhandle, info, (const char *) NULL,
815 &p, (debug_type **) NULL);
816 if (dtype == DEBUG_TYPE_NULL)
818 if (! debug_record_label (dhandle, name, dtype, value))
824 /* A function definition. */
825 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
826 (debug_type **) NULL);
827 if (dtype == DEBUG_TYPE_NULL)
829 if (! debug_record_function (dhandle, name, dtype, type == 'F', value))
832 /* Sun acc puts declared types of arguments here. We don't care
833 about their actual types (FIXME -- we should remember the whole
834 function prototype), but the list may define some new types
835 that we have to remember, so we must scan it now. */
839 if (parse_stab_type (dhandle, info, (const char *) NULL, &p,
840 (debug_type **) NULL)
853 /* A global symbol. The value must be extracted from the
855 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
856 (debug_type **) NULL);
857 if (dtype == DEBUG_TYPE_NULL)
859 leading = bfd_get_symbol_leading_char (info->abfd);
860 for (c = info->symcount, ps = info->syms; c > 0; --c, ++ps)
864 n = bfd_asymbol_name (*ps);
865 if (leading != '\0' && *n == leading)
867 if (*n == *name && strcmp (n, name) == 0)
871 value = bfd_asymbol_value (*ps);
872 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_GLOBAL,
878 /* This case is faked by a conditional above, when there is no
879 code letter in the dbx data. Dbx data never actually
883 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
884 (debug_type **) NULL);
885 if (dtype == DEBUG_TYPE_NULL)
887 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL,
893 /* A function parameter. */
895 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
896 (debug_type **) NULL);
899 /* pF is a two-letter code that means a function parameter in
900 Fortran. The type-number specifies the type of the return
901 value. Translate it into a pointer-to-function type. */
903 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
904 (debug_type **) NULL);
905 if (dtype != DEBUG_TYPE_NULL)
909 ftype = debug_make_function_type (dhandle, dtype,
910 (debug_type *) NULL, FALSE);
911 dtype = debug_make_pointer_type (dhandle, ftype);
914 if (dtype == DEBUG_TYPE_NULL)
916 if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_STACK,
920 /* FIXME: At this point gdb considers rearranging the parameter
921 address on a big endian machine if it is smaller than an int.
922 We have no way to do that, since we don't really know much
927 if (stabtype == N_FUN)
929 /* Prototype of a function referenced by this file. */
933 if (parse_stab_type (dhandle, info, (const char *) NULL, &p,
934 (debug_type **) NULL)
942 /* Parameter which is in a register. */
943 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
944 (debug_type **) NULL);
945 if (dtype == DEBUG_TYPE_NULL)
947 if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REG,
953 /* Register variable (either global or local). */
954 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
955 (debug_type **) NULL);
956 if (dtype == DEBUG_TYPE_NULL)
958 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_REGISTER,
962 /* FIXME: At this point gdb checks to combine pairs of 'p' and
963 'r' stabs into a single 'P' stab. */
967 /* Static symbol at top level of file. */
968 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
969 (debug_type **) NULL);
970 if (dtype == DEBUG_TYPE_NULL)
972 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_STATIC,
979 dtype = parse_stab_type (dhandle, info, name, &p, &slot);
980 if (dtype == DEBUG_TYPE_NULL)
984 /* A nameless type. Nothing to do. */
988 dtype = debug_name_type (dhandle, name, dtype);
989 if (dtype == DEBUG_TYPE_NULL)
998 /* Struct, union, or enum tag. For GNU C++, this can be be followed
999 by 't' which means we are typedef'ing it as well. */
1003 /* FIXME: gdb sets synonym to TRUE if the current language
1012 dtype = parse_stab_type (dhandle, info, name, &p, &slot);
1013 if (dtype == DEBUG_TYPE_NULL)
1018 /* INFO->SELF_CROSSREF is set by parse_stab_type if this type is
1019 a cross reference to itself. These are generated by some
1021 self_crossref = info->self_crossref;
1023 dtype = debug_tag_type (dhandle, name, dtype);
1024 if (dtype == DEBUG_TYPE_NULL)
1029 /* See if we have a cross reference to this tag which we can now
1030 fill in. Avoid filling in a cross reference to ourselves,
1031 because that would lead to circular debugging information. */
1032 if (! self_crossref)
1034 register struct stab_tag **pst;
1036 for (pst = &info->tags; *pst != NULL; pst = &(*pst)->next)
1038 if ((*pst)->name[0] == name[0]
1039 && strcmp ((*pst)->name, name) == 0)
1041 (*pst)->slot = dtype;
1042 *pst = (*pst)->next;
1050 dtype = debug_name_type (dhandle, name, dtype);
1051 if (dtype == DEBUG_TYPE_NULL)
1061 /* Static symbol of local scope */
1062 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1063 (debug_type **) NULL);
1064 if (dtype == DEBUG_TYPE_NULL)
1066 /* FIXME: gdb checks os9k_stabs here. */
1067 if (! stab_record_variable (dhandle, info, name, dtype,
1068 DEBUG_LOCAL_STATIC, value))
1073 /* Reference parameter. */
1074 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1075 (debug_type **) NULL);
1076 if (dtype == DEBUG_TYPE_NULL)
1078 if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REFERENCE,
1084 /* Reference parameter which is in a register. */
1085 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1086 (debug_type **) NULL);
1087 if (dtype == DEBUG_TYPE_NULL)
1089 if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REF_REG,
1095 /* This is used by Sun FORTRAN for "function result value".
1096 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1097 that Pascal uses it too, but when I tried it Pascal used
1098 "x:3" (local symbol) instead. */
1099 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1100 (debug_type **) NULL);
1101 if (dtype == DEBUG_TYPE_NULL)
1103 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL,
1109 /* SUNPro C++ Namespace =Yn0. */
1110 /* Skip the namespace mapping, as it is not used now. */
1111 if (*(++p) == 'n' && *(++p) == '0')
1119 /* TODO SUNPro C++ support:
1120 Support default arguments after F,P parameters
1121 Ya = Anonymous unions
1122 YM,YD = Pointers to class members
1124 YR = Run-time type information (RTTI) */
1133 /* FIXME: gdb converts structure values to structure pointers in a
1134 couple of cases, depending upon the target. */
1139 /* Parse a stabs type. The typename argument is non-NULL if this is a
1140 typedef or a tag definition. The pp argument points to the stab
1141 string, and is updated. The slotp argument points to a place to
1142 store the slot used if the type is being defined. */
1145 parse_stab_type (void *dhandle, struct stab_handle *info, const char *typename, const char **pp, debug_type **slotp)
1150 bfd_boolean stringp;
1162 info->self_crossref = FALSE;
1164 /* Read type number if present. The type number may be omitted.
1165 for instance in a two-dimensional array declared with type
1166 "ar1;1;10;ar1;1;10;4". */
1167 if (! ISDIGIT (**pp) && **pp != '(' && **pp != '-')
1169 /* 'typenums=' not present, type is anonymous. Read and return
1170 the definition, but don't put it in the type vector. */
1171 typenums[0] = typenums[1] = -1;
1175 if (! parse_stab_type_number (pp, typenums))
1176 return DEBUG_TYPE_NULL;
1179 /* Type is not being defined here. Either it already
1180 exists, or this is a forward reference to it. */
1181 return stab_find_type (dhandle, info, typenums);
1183 /* Only set the slot if the type is being defined. This means
1184 that the mapping from type numbers to types will only record
1185 the name of the typedef which defines a type. If we don't do
1186 this, then something like
1189 will record that i is of type foo. Unfortunately, stabs
1190 information is ambiguous about variable types. For this code,
1194 the stabs information records both i and j as having the same
1195 type. This could be fixed by patching the compiler. */
1196 if (slotp != NULL && typenums[0] >= 0 && typenums[1] >= 0)
1197 *slotp = stab_find_slot (info, typenums);
1199 /* Type is being defined here. */
1205 const char *p = *pp + 1;
1208 if (ISDIGIT (*p) || *p == '(' || *p == '-')
1212 /* Type attributes. */
1215 for (; *p != ';'; ++p)
1220 return DEBUG_TYPE_NULL;
1228 size = atoi (attr + 1);
1229 size /= 8; /* Size is in bits. We store it in bytes. */
1239 /* Ignore unrecognized type attributes, so future
1240 compilers can invent new ones. */
1253 enum debug_type_kind code;
1254 const char *q1, *q2, *p;
1256 /* A cross reference to another type. */
1260 code = DEBUG_KIND_STRUCT;
1263 code = DEBUG_KIND_UNION;
1266 code = DEBUG_KIND_ENUM;
1269 /* Complain and keep going, so compilers can invent new
1270 cross-reference types. */
1271 warn_stab (orig, _("unrecognized cross reference type"));
1272 code = DEBUG_KIND_STRUCT;
1277 q1 = strchr (*pp, '<');
1278 p = strchr (*pp, ':');
1282 return DEBUG_TYPE_NULL;
1284 if (q1 != NULL && p > q1 && p[1] == ':')
1288 for (q2 = q1; *q2 != '\0'; ++q2)
1292 else if (*q2 == '>')
1294 else if (*q2 == ':' && nest == 0)
1301 return DEBUG_TYPE_NULL;
1305 /* Some versions of g++ can emit stabs like
1307 which define structures in terms of themselves. We need to
1308 tell the caller to avoid building a circular structure. */
1309 if (typename != NULL
1310 && strncmp (typename, *pp, p - *pp) == 0
1311 && typename[p - *pp] == '\0')
1312 info->self_crossref = TRUE;
1314 dtype = stab_find_tagged_type (dhandle, info, *pp, p - *pp, code);
1336 /* This type is defined as another type. */
1340 /* Peek ahead at the number to detect void. */
1341 if (! parse_stab_type_number (pp, xtypenums))
1342 return DEBUG_TYPE_NULL;
1344 if (typenums[0] == xtypenums[0] && typenums[1] == xtypenums[1])
1346 /* This type is being defined as itself, which means that
1348 dtype = debug_make_void_type (dhandle);
1354 /* Go back to the number and have parse_stab_type get it.
1355 This means that we can deal with something like
1356 t(1,2)=(3,4)=... which the Lucid compiler uses. */
1357 dtype = parse_stab_type (dhandle, info, (const char *) NULL,
1358 pp, (debug_type **) NULL);
1359 if (dtype == DEBUG_TYPE_NULL)
1360 return DEBUG_TYPE_NULL;
1363 if (typenums[0] != -1)
1365 if (! stab_record_type (dhandle, info, typenums, dtype))
1366 return DEBUG_TYPE_NULL;
1373 dtype = debug_make_pointer_type (dhandle,
1374 parse_stab_type (dhandle, info,
1375 (const char *) NULL,
1377 (debug_type **) NULL));
1381 /* Reference to another type. */
1382 dtype = (debug_make_reference_type
1384 parse_stab_type (dhandle, info, (const char *) NULL, pp,
1385 (debug_type **) NULL)));
1389 /* Function returning another type. */
1390 /* FIXME: gdb checks os9k_stabs here. */
1391 dtype = (debug_make_function_type
1393 parse_stab_type (dhandle, info, (const char *) NULL, pp,
1394 (debug_type **) NULL),
1395 (debug_type *) NULL, FALSE));
1399 /* Const qualifier on some type (Sun). */
1400 /* FIXME: gdb accepts 'c' here if os9k_stabs. */
1401 dtype = debug_make_const_type (dhandle,
1402 parse_stab_type (dhandle, info,
1403 (const char *) NULL,
1405 (debug_type **) NULL));
1409 /* Volatile qual on some type (Sun). */
1410 /* FIXME: gdb accepts 'i' here if os9k_stabs. */
1411 dtype = (debug_make_volatile_type
1413 parse_stab_type (dhandle, info, (const char *) NULL, pp,
1414 (debug_type **) NULL)));
1418 /* Offset (class & variable) type. This is used for a pointer
1419 relative to an object. */
1426 domain = parse_stab_type (dhandle, info, (const char *) NULL, pp,
1427 (debug_type **) NULL);
1428 if (domain == DEBUG_TYPE_NULL)
1429 return DEBUG_TYPE_NULL;
1434 return DEBUG_TYPE_NULL;
1438 memtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
1439 (debug_type **) NULL);
1440 if (memtype == DEBUG_TYPE_NULL)
1441 return DEBUG_TYPE_NULL;
1443 dtype = debug_make_offset_type (dhandle, domain, memtype);
1448 /* Method (class & fn) type. */
1451 debug_type return_type;
1454 return_type = parse_stab_type (dhandle, info, (const char *) NULL,
1455 pp, (debug_type **) NULL);
1456 if (return_type == DEBUG_TYPE_NULL)
1457 return DEBUG_TYPE_NULL;
1461 return DEBUG_TYPE_NULL;
1464 dtype = debug_make_method_type (dhandle, return_type,
1466 (debug_type *) NULL, FALSE);
1471 debug_type return_type;
1475 bfd_boolean varargs;
1477 domain = parse_stab_type (dhandle, info, (const char *) NULL,
1478 pp, (debug_type **) NULL);
1479 if (domain == DEBUG_TYPE_NULL)
1480 return DEBUG_TYPE_NULL;
1485 return DEBUG_TYPE_NULL;
1489 return_type = parse_stab_type (dhandle, info, (const char *) NULL,
1490 pp, (debug_type **) NULL);
1491 if (return_type == DEBUG_TYPE_NULL)
1492 return DEBUG_TYPE_NULL;
1495 args = (debug_type *) xmalloc (alloc * sizeof *args);
1502 return DEBUG_TYPE_NULL;
1509 args = ((debug_type *)
1510 xrealloc (args, alloc * sizeof *args));
1513 args[n] = parse_stab_type (dhandle, info, (const char *) NULL,
1514 pp, (debug_type **) NULL);
1515 if (args[n] == DEBUG_TYPE_NULL)
1516 return DEBUG_TYPE_NULL;
1521 /* If the last type is not void, then this function takes a
1522 variable number of arguments. Otherwise, we must strip
1525 || debug_get_type_kind (dhandle, args[n - 1]) != DEBUG_KIND_VOID)
1533 args[n] = DEBUG_TYPE_NULL;
1535 dtype = debug_make_method_type (dhandle, return_type, domain, args,
1542 dtype = parse_stab_range_type (dhandle, info, typename, pp, typenums);
1546 /* FIXME: gdb checks os9k_stabs here. */
1547 /* Sun ACC builtin int type. */
1548 dtype = parse_stab_sun_builtin_type (dhandle, pp);
1552 /* Sun ACC builtin float type. */
1553 dtype = parse_stab_sun_floating_type (dhandle, pp);
1557 /* Enumeration type. */
1558 dtype = parse_stab_enum_type (dhandle, pp);
1563 /* Struct or union type. */
1564 dtype = parse_stab_struct_type (dhandle, info, typename, pp,
1565 descriptor == 's', typenums);
1573 return DEBUG_TYPE_NULL;
1577 dtype = parse_stab_array_type (dhandle, info, pp, stringp);
1581 dtype = debug_make_set_type (dhandle,
1582 parse_stab_type (dhandle, info,
1583 (const char *) NULL,
1585 (debug_type **) NULL),
1591 return DEBUG_TYPE_NULL;
1594 if (dtype == DEBUG_TYPE_NULL)
1595 return DEBUG_TYPE_NULL;
1597 if (typenums[0] != -1)
1599 if (! stab_record_type (dhandle, info, typenums, dtype))
1600 return DEBUG_TYPE_NULL;
1605 if (! debug_record_type_size (dhandle, dtype, (unsigned int) size))
1606 return DEBUG_TYPE_NULL;
1612 /* Read a number by which a type is referred to in dbx data, or
1613 perhaps read a pair (FILENUM, TYPENUM) in parentheses. Just a
1614 single number N is equivalent to (0,N). Return the two numbers by
1615 storing them in the vector TYPENUMS. */
1618 parse_stab_type_number (const char **pp, int *typenums)
1627 typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL);
1632 typenums[0] = (int) parse_number (pp, (bfd_boolean *) NULL);
1639 typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL);
1651 /* Parse a range type. */
1654 parse_stab_range_type (void *dhandle, struct stab_handle *info, const char *typename, const char **pp, const int *typenums)
1658 bfd_boolean self_subrange;
1659 debug_type index_type;
1660 const char *s2, *s3;
1661 bfd_signed_vma n2, n3;
1662 bfd_boolean ov2, ov3;
1666 index_type = DEBUG_TYPE_NULL;
1668 /* First comes a type we are a subrange of.
1669 In C it is usually 0, 1 or the type being defined. */
1670 if (! parse_stab_type_number (pp, rangenums))
1671 return DEBUG_TYPE_NULL;
1673 self_subrange = (rangenums[0] == typenums[0]
1674 && rangenums[1] == typenums[1]);
1679 index_type = parse_stab_type (dhandle, info, (const char *) NULL,
1680 pp, (debug_type **) NULL);
1681 if (index_type == DEBUG_TYPE_NULL)
1682 return DEBUG_TYPE_NULL;
1688 /* The remaining two operands are usually lower and upper bounds of
1689 the range. But in some special cases they mean something else. */
1691 n2 = parse_number (pp, &ov2);
1695 return DEBUG_TYPE_NULL;
1700 n3 = parse_number (pp, &ov3);
1704 return DEBUG_TYPE_NULL;
1710 /* gcc will emit range stabs for long long types. Handle this
1711 as a special case. FIXME: This needs to be more general. */
1712 #define LLLOW "01000000000000000000000;"
1713 #define LLHIGH "0777777777777777777777;"
1714 #define ULLHIGH "01777777777777777777777;"
1715 if (index_type == DEBUG_TYPE_NULL)
1717 if (CONST_STRNEQ (s2, LLLOW)
1718 && CONST_STRNEQ (s3, LLHIGH))
1719 return debug_make_int_type (dhandle, 8, FALSE);
1722 && CONST_STRNEQ (s3, ULLHIGH))
1723 return debug_make_int_type (dhandle, 8, TRUE);
1726 warn_stab (orig, _("numeric overflow"));
1729 if (index_type == DEBUG_TYPE_NULL)
1731 /* A type defined as a subrange of itself, with both bounds 0,
1733 if (self_subrange && n2 == 0 && n3 == 0)
1734 return debug_make_void_type (dhandle);
1736 /* A type defined as a subrange of itself, with n2 positive and
1737 n3 zero, is a complex type, and n2 is the number of bytes. */
1738 if (self_subrange && n3 == 0 && n2 > 0)
1739 return debug_make_complex_type (dhandle, n2);
1741 /* If n3 is zero and n2 is positive, this is a floating point
1742 type, and n2 is the number of bytes. */
1743 if (n3 == 0 && n2 > 0)
1744 return debug_make_float_type (dhandle, n2);
1746 /* If the upper bound is -1, this is an unsigned int. */
1747 if (n2 == 0 && n3 == -1)
1749 /* When gcc is used with -gstabs, but not -gstabs+, it will emit
1750 long long int:t6=r1;0;-1;
1751 long long unsigned int:t7=r1;0;-1;
1752 We hack here to handle this reasonably. */
1753 if (typename != NULL)
1755 if (strcmp (typename, "long long int") == 0)
1756 return debug_make_int_type (dhandle, 8, FALSE);
1757 else if (strcmp (typename, "long long unsigned int") == 0)
1758 return debug_make_int_type (dhandle, 8, TRUE);
1760 /* FIXME: The size here really depends upon the target. */
1761 return debug_make_int_type (dhandle, 4, TRUE);
1764 /* A range of 0 to 127 is char. */
1765 if (self_subrange && n2 == 0 && n3 == 127)
1766 return debug_make_int_type (dhandle, 1, FALSE);
1768 /* FIXME: gdb checks for the language CHILL here. */
1773 return debug_make_int_type (dhandle, - n3, TRUE);
1774 else if (n3 == 0xff)
1775 return debug_make_int_type (dhandle, 1, TRUE);
1776 else if (n3 == 0xffff)
1777 return debug_make_int_type (dhandle, 2, TRUE);
1778 else if (n3 == (bfd_signed_vma) 0xffffffff)
1779 return debug_make_int_type (dhandle, 4, TRUE);
1781 else if (n3 == ((((bfd_signed_vma) 0xffffffff) << 32) | 0xffffffff))
1782 return debug_make_int_type (dhandle, 8, TRUE);
1787 && (self_subrange || n2 == -8))
1788 return debug_make_int_type (dhandle, - n2, TRUE);
1789 else if (n2 == - n3 - 1 || n2 == n3 + 1)
1792 return debug_make_int_type (dhandle, 1, FALSE);
1793 else if (n3 == 0x7fff)
1794 return debug_make_int_type (dhandle, 2, FALSE);
1795 else if (n3 == 0x7fffffff)
1796 return debug_make_int_type (dhandle, 4, FALSE);
1798 else if (n3 == ((((bfd_vma) 0x7fffffff) << 32) | 0xffffffff))
1799 return debug_make_int_type (dhandle, 8, FALSE);
1804 /* At this point I don't have the faintest idea how to deal with a
1805 self_subrange type; I'm going to assume that this is used as an
1806 idiom, and that all of them are special cases. So . . . */
1810 return DEBUG_TYPE_NULL;
1813 index_type = stab_find_type (dhandle, info, rangenums);
1814 if (index_type == DEBUG_TYPE_NULL)
1816 /* Does this actually ever happen? Is that why we are worrying
1817 about dealing with it rather than just calling error_type? */
1818 warn_stab (orig, _("missing index type"));
1819 index_type = debug_make_int_type (dhandle, 4, FALSE);
1822 return debug_make_range_type (dhandle, index_type, n2, n3);
1825 /* Sun's ACC uses a somewhat saner method for specifying the builtin
1826 typedefs in every file (for int, long, etc):
1828 type = b <signed> <width>; <offset>; <nbits>
1829 signed = u or s. Possible c in addition to u or s (for char?).
1830 offset = offset from high order bit to start bit of type.
1831 width is # bytes in object of this type, nbits is # bits in type.
1833 The width/offset stuff appears to be for small objects stored in
1834 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
1838 parse_stab_sun_builtin_type (void *dhandle, const char **pp)
1841 bfd_boolean unsignedp;
1856 return DEBUG_TYPE_NULL;
1860 /* OpenSolaris source code indicates that one of "cbv" characters
1861 can come next and specify the intrinsic 'iformat' encoding.
1862 'c' is character encoding, 'b' is boolean encoding, and 'v' is
1863 varargs encoding. This field can be safely ignored because
1864 the type of the field is determined from the bitwidth extracted
1866 if (**pp == 'c' || **pp == 'b' || **pp == 'v')
1869 /* The first number appears to be the number of bytes occupied
1870 by this type, except that unsigned short is 4 instead of 2.
1871 Since this information is redundant with the third number,
1872 we will ignore it. */
1873 (void) parse_number (pp, (bfd_boolean *) NULL);
1877 return DEBUG_TYPE_NULL;
1881 /* The second number is always 0, so ignore it too. */
1882 (void) parse_number (pp, (bfd_boolean *) NULL);
1886 return DEBUG_TYPE_NULL;
1890 /* The third number is the number of bits for this type. */
1891 bits = parse_number (pp, (bfd_boolean *) NULL);
1893 /* The type *should* end with a semicolon. If it are embedded
1894 in a larger type the semicolon may be the only way to know where
1895 the type ends. If this type is at the end of the stabstring we
1896 can deal with the omitted semicolon (but we don't have to like
1897 it). Don't bother to complain(), Sun's compiler omits the semicolon
1903 return debug_make_void_type (dhandle);
1905 return debug_make_int_type (dhandle, bits / 8, unsignedp);
1908 /* Parse a builtin floating type generated by the Sun compiler. */
1911 parse_stab_sun_floating_type (void *dhandle, const char **pp)
1919 /* The first number has more details about the type, for example
1921 details = parse_number (pp, (bfd_boolean *) NULL);
1925 return DEBUG_TYPE_NULL;
1928 /* The second number is the number of bytes occupied by this type */
1929 bytes = parse_number (pp, (bfd_boolean *) NULL);
1933 return DEBUG_TYPE_NULL;
1936 if (details == NF_COMPLEX
1937 || details == NF_COMPLEX16
1938 || details == NF_COMPLEX32)
1939 return debug_make_complex_type (dhandle, bytes);
1941 return debug_make_float_type (dhandle, bytes);
1944 /* Handle an enum type. */
1947 parse_stab_enum_type (void *dhandle, const char **pp)
1951 bfd_signed_vma *values;
1957 /* FIXME: gdb checks os9k_stabs here. */
1959 /* The aix4 compiler emits an extra field before the enum members;
1960 my guess is it's a type of some sort. Just ignore it. */
1968 /* Read the value-names and their values.
1969 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
1970 A semicolon or comma instead of a NAME means the end. */
1972 names = (const char **) xmalloc (alloc * sizeof *names);
1973 values = (bfd_signed_vma *) xmalloc (alloc * sizeof *values);
1975 while (**pp != '\0' && **pp != ';' && **pp != ',')
1985 name = savestring (*pp, p - *pp);
1988 val = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
1992 return DEBUG_TYPE_NULL;
1999 names = ((const char **)
2000 xrealloc (names, alloc * sizeof *names));
2001 values = ((bfd_signed_vma *)
2002 xrealloc (values, alloc * sizeof *values));
2016 return debug_make_enum_type (dhandle, names, values);
2019 /* Read the description of a structure (or union type) and return an object
2020 describing the type.
2022 PP points to a character pointer that points to the next unconsumed token
2023 in the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
2024 *PP will point to "4a:1,0,32;;". */
2027 parse_stab_struct_type (void *dhandle, struct stab_handle *info,
2028 const char *tagname, const char **pp,
2029 bfd_boolean structp, const int *typenums)
2033 debug_baseclass *baseclasses;
2034 debug_field *fields;
2035 bfd_boolean statics;
2036 debug_method *methods;
2037 debug_type vptrbase;
2038 bfd_boolean ownvptr;
2043 size = parse_number (pp, (bfd_boolean *) NULL);
2045 /* Get the other information. */
2046 if (! parse_stab_baseclasses (dhandle, info, pp, &baseclasses)
2047 || ! parse_stab_struct_fields (dhandle, info, pp, &fields, &statics)
2048 || ! parse_stab_members (dhandle, info, tagname, pp, typenums, &methods)
2049 || ! parse_stab_tilde_field (dhandle, info, pp, typenums, &vptrbase,
2051 return DEBUG_TYPE_NULL;
2054 && baseclasses == NULL
2056 && vptrbase == DEBUG_TYPE_NULL
2058 return debug_make_struct_type (dhandle, structp, size, fields);
2060 return debug_make_object_type (dhandle, structp, size, fields, baseclasses,
2061 methods, vptrbase, ownvptr);
2064 /* The stabs for C++ derived classes contain baseclass information which
2065 is marked by a '!' character after the total size. This function is
2066 called when we encounter the baseclass marker, and slurps up all the
2067 baseclass information.
2069 Immediately following the '!' marker is the number of base classes that
2070 the class is derived from, followed by information for each base class.
2071 For each base class, there are two visibility specifiers, a bit offset
2072 to the base class information within the derived class, a reference to
2073 the type for the base class, and a terminating semicolon.
2075 A typical example, with two base classes, would be "!2,020,19;0264,21;".
2077 Baseclass information marker __________________|| | | | | | |
2078 Number of baseclasses __________________________| | | | | | |
2079 Visibility specifiers (2) ________________________| | | | | |
2080 Offset in bits from start of class _________________| | | | |
2081 Type number for base class ___________________________| | | |
2082 Visibility specifiers (2) _______________________________| | |
2083 Offset in bits from start of class ________________________| |
2084 Type number of base class ____________________________________|
2086 Return TRUE for success, FALSE for failure. */
2089 parse_stab_baseclasses (void *dhandle, struct stab_handle *info,
2090 const char **pp, debug_baseclass **retp)
2094 debug_baseclass *classes;
2102 /* No base classes. */
2107 c = (unsigned int) parse_number (pp, (bfd_boolean *) NULL);
2116 classes = (debug_baseclass *) xmalloc ((c + 1) * sizeof (**retp));
2118 for (i = 0; i < c; i++)
2120 bfd_boolean virtual;
2121 enum debug_visibility visibility;
2134 warn_stab (orig, _("unknown virtual character for baseclass"));
2143 visibility = DEBUG_VISIBILITY_PRIVATE;
2146 visibility = DEBUG_VISIBILITY_PROTECTED;
2149 visibility = DEBUG_VISIBILITY_PUBLIC;
2152 warn_stab (orig, _("unknown visibility character for baseclass"));
2153 visibility = DEBUG_VISIBILITY_PUBLIC;
2158 /* The remaining value is the bit offset of the portion of the
2159 object corresponding to this baseclass. Always zero in the
2160 absence of multiple inheritance. */
2161 bitpos = parse_number (pp, (bfd_boolean *) NULL);
2169 type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2170 (debug_type **) NULL);
2171 if (type == DEBUG_TYPE_NULL)
2174 classes[i] = debug_make_baseclass (dhandle, type, bitpos, virtual,
2176 if (classes[i] == DEBUG_BASECLASS_NULL)
2184 classes[i] = DEBUG_BASECLASS_NULL;
2191 /* Read struct or class data fields. They have the form:
2193 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2195 At the end, we see a semicolon instead of a field.
2197 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2200 The optional VISIBILITY is one of:
2202 '/0' (VISIBILITY_PRIVATE)
2203 '/1' (VISIBILITY_PROTECTED)
2204 '/2' (VISIBILITY_PUBLIC)
2205 '/9' (VISIBILITY_IGNORE)
2207 or nothing, for C style fields with public visibility.
2209 Returns 1 for success, 0 for failure. */
2212 parse_stab_struct_fields (void *dhandle, struct stab_handle *info,
2213 const char **pp, debug_field **retp,
2214 bfd_boolean *staticsp)
2218 debug_field *fields;
2229 fields = (debug_field *) xmalloc (alloc * sizeof *fields);
2232 /* FIXME: gdb checks os9k_stabs here. */
2236 /* Add 1 to c to leave room for NULL pointer at end. */
2240 fields = ((debug_field *)
2241 xrealloc (fields, alloc * sizeof *fields));
2244 /* If it starts with CPLUS_MARKER it is a special abbreviation,
2245 unless the CPLUS_MARKER is followed by an underscore, in
2246 which case it is just the name of an anonymous type, which we
2247 should handle like any other type name. We accept either '$'
2248 or '.', because a field name can never contain one of these
2249 characters except as a CPLUS_MARKER. */
2251 if ((*p == '$' || *p == '.') && p[1] != '_')
2254 if (! parse_stab_cpp_abbrev (dhandle, info, pp, fields + c))
2260 /* Look for the ':' that separates the field name from the field
2261 values. Data members are delimited by a single ':', while member
2262 functions are delimited by a pair of ':'s. When we hit the member
2263 functions (if any), terminate scan loop and return. */
2265 p = strchr (p, ':');
2275 if (! parse_stab_one_struct_field (dhandle, info, pp, p, fields + c,
2282 fields[c] = DEBUG_FIELD_NULL;
2289 /* Special GNU C++ name. */
2292 parse_stab_cpp_abbrev (void *dhandle, struct stab_handle *info,
2293 const char **pp, debug_field *retp)
2299 const char *typename;
2303 *retp = DEBUG_FIELD_NULL;
2317 /* At this point, *pp points to something like "22:23=*22...", where
2318 the type number before the ':' is the "context" and everything
2319 after is a regular type definition. Lookup the type, find it's
2320 name, and construct the field name. */
2322 context = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2323 (debug_type **) NULL);
2324 if (context == DEBUG_TYPE_NULL)
2330 /* $vf -- a virtual function table pointer. */
2334 /* $vb -- a virtual bsomethingorother */
2335 typename = debug_get_type_name (dhandle, context);
2336 if (typename == NULL)
2338 warn_stab (orig, _("unnamed $vb type"));
2341 name = concat ("_vb$", typename, (const char *) NULL);
2344 warn_stab (orig, _("unrecognized C++ abbreviation"));
2345 name = "INVALID_CPLUSPLUS_ABBREV";
2356 type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2357 (debug_type **) NULL);
2365 bitpos = parse_number (pp, (bfd_boolean *) NULL);
2373 *retp = debug_make_field (dhandle, name, type, bitpos, 0,
2374 DEBUG_VISIBILITY_PRIVATE);
2375 if (*retp == DEBUG_FIELD_NULL)
2381 /* Parse a single field in a struct or union. */
2384 parse_stab_one_struct_field (void *dhandle, struct stab_handle *info,
2385 const char **pp, const char *p,
2386 debug_field *retp, bfd_boolean *staticsp)
2390 enum debug_visibility visibility;
2397 /* FIXME: gdb checks ARM_DEMANGLING here. */
2399 name = savestring (*pp, p - *pp);
2404 visibility = DEBUG_VISIBILITY_PUBLIC;
2411 visibility = DEBUG_VISIBILITY_PRIVATE;
2414 visibility = DEBUG_VISIBILITY_PROTECTED;
2417 visibility = DEBUG_VISIBILITY_PUBLIC;
2420 warn_stab (orig, _("unknown visibility character for field"));
2421 visibility = DEBUG_VISIBILITY_PUBLIC;
2427 type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2428 (debug_type **) NULL);
2429 if (type == DEBUG_TYPE_NULL)
2436 /* This is a static class member. */
2438 p = strchr (*pp, ';');
2445 varname = savestring (*pp, p - *pp);
2449 *retp = debug_make_static_member (dhandle, name, type, varname,
2463 bitpos = parse_number (pp, (bfd_boolean *) NULL);
2471 bitsize = parse_number (pp, (bfd_boolean *) NULL);
2479 if (bitpos == 0 && bitsize == 0)
2481 /* This can happen in two cases: (1) at least for gcc 2.4.5 or
2482 so, it is a field which has been optimized out. The correct
2483 stab for this case is to use VISIBILITY_IGNORE, but that is a
2484 recent invention. (2) It is a 0-size array. For example
2485 union { int num; char str[0]; } foo. Printing "<no value>"
2486 for str in "p foo" is OK, since foo.str (and thus foo.str[3])
2487 will continue to work, and a 0-size array as a whole doesn't
2488 have any contents to print.
2490 I suspect this probably could also happen with gcc -gstabs
2491 (not -gstabs+) for static fields, and perhaps other C++
2492 extensions. Hopefully few people use -gstabs with gdb, since
2493 it is intended for dbx compatibility. */
2494 visibility = DEBUG_VISIBILITY_IGNORE;
2497 /* FIXME: gdb does some stuff here to mark fields as unpacked. */
2499 *retp = debug_make_field (dhandle, name, type, bitpos, bitsize, visibility);
2504 /* Read member function stabs info for C++ classes. The form of each member
2507 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2509 An example with two member functions is:
2511 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2513 For the case of overloaded operators, the format is op$::*.funcs, where
2514 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2515 name (such as `+=') and `.' marks the end of the operator name. */
2518 parse_stab_members (void *dhandle, struct stab_handle *info,
2519 const char *tagname, const char **pp,
2520 const int *typenums, debug_method **retp)
2523 debug_method *methods;
2539 debug_method_variant *variants;
2541 unsigned int allocvars;
2542 debug_type look_ahead_type;
2544 p = strchr (*pp, ':');
2545 if (p == NULL || p[1] != ':')
2548 /* FIXME: Some systems use something other than '$' here. */
2549 if ((*pp)[0] != 'o' || (*pp)[1] != 'p' || (*pp)[2] != '$')
2551 name = savestring (*pp, p - *pp);
2556 /* This is a completely weird case. In order to stuff in the
2557 names that might contain colons (the usual name delimiter),
2558 Mike Tiemann defined a different name format which is
2559 signalled if the identifier is "op$". In that case, the
2560 format is "op$::XXXX." where XXXX is the name. This is
2561 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2563 for (p = *pp; *p != '.' && *p != '\0'; p++)
2570 name = savestring (*pp, p - *pp);
2575 variants = ((debug_method_variant *)
2576 xmalloc (allocvars * sizeof *variants));
2579 look_ahead_type = DEBUG_TYPE_NULL;
2586 enum debug_visibility visibility;
2587 bfd_boolean constp, volatilep, staticp;
2590 const char *physname;
2591 bfd_boolean varargs;
2593 if (look_ahead_type != DEBUG_TYPE_NULL)
2595 /* g++ version 1 kludge */
2596 type = look_ahead_type;
2597 look_ahead_type = DEBUG_TYPE_NULL;
2601 type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2602 (debug_type **) NULL);
2603 if (type == DEBUG_TYPE_NULL)
2613 p = strchr (*pp, ';');
2621 if (debug_get_type_kind (dhandle, type) == DEBUG_KIND_METHOD
2622 && debug_get_parameter_types (dhandle, type, &varargs) == NULL)
2625 argtypes = savestring (*pp, p - *pp);
2631 visibility = DEBUG_VISIBILITY_PRIVATE;
2634 visibility = DEBUG_VISIBILITY_PROTECTED;
2637 visibility = DEBUG_VISIBILITY_PUBLIC;
2647 /* Normal function. */
2651 /* const member function. */
2656 /* volatile member function. */
2661 /* const volatile member function. */
2669 /* File compiled with g++ version 1; no information. */
2672 warn_stab (orig, _("const/volatile indicator missing"));
2680 /* virtual member function, followed by index. The sign
2681 bit is supposedly set to distinguish
2682 pointers-to-methods from virtual function indicies. */
2684 voffset = parse_number (pp, (bfd_boolean *) NULL);
2691 voffset &= 0x7fffffff;
2693 if (**pp == ';' || *pp == '\0')
2695 /* Must be g++ version 1. */
2696 context = DEBUG_TYPE_NULL;
2700 /* Figure out from whence this virtual function
2701 came. It may belong to virtual function table of
2702 one of its baseclasses. */
2703 look_ahead_type = parse_stab_type (dhandle, info,
2704 (const char *) NULL,
2706 (debug_type **) NULL);
2709 /* g++ version 1 overloaded methods. */
2710 context = DEBUG_TYPE_NULL;
2714 context = look_ahead_type;
2715 look_ahead_type = DEBUG_TYPE_NULL;
2727 /* static member function. */
2731 context = DEBUG_TYPE_NULL;
2732 if (strncmp (argtypes, name, strlen (name)) != 0)
2737 warn_stab (orig, "member function type missing");
2739 context = DEBUG_TYPE_NULL;
2745 context = DEBUG_TYPE_NULL;
2749 /* If the type is not a stub, then the argtypes string is
2750 the physical name of the function. Otherwise the
2751 argtypes string is the mangled form of the argument
2752 types, and the full type and the physical name must be
2753 extracted from them. */
2755 physname = argtypes;
2758 debug_type class_type, return_type;
2760 class_type = stab_find_type (dhandle, info, typenums);
2761 if (class_type == DEBUG_TYPE_NULL)
2763 return_type = debug_get_return_type (dhandle, type);
2764 if (return_type == DEBUG_TYPE_NULL)
2769 type = parse_stab_argtypes (dhandle, info, class_type, name,
2770 tagname, return_type, argtypes,
2771 constp, volatilep, &physname);
2772 if (type == DEBUG_TYPE_NULL)
2776 if (cvars + 1 >= allocvars)
2779 variants = ((debug_method_variant *)
2781 allocvars * sizeof *variants));
2785 variants[cvars] = debug_make_method_variant (dhandle, physname,
2790 variants[cvars] = debug_make_static_method_variant (dhandle,
2796 if (variants[cvars] == DEBUG_METHOD_VARIANT_NULL)
2801 while (**pp != ';' && **pp != '\0');
2803 variants[cvars] = DEBUG_METHOD_VARIANT_NULL;
2811 methods = ((debug_method *)
2812 xrealloc (methods, alloc * sizeof *methods));
2815 methods[c] = debug_make_method (dhandle, name, variants);
2820 if (methods != NULL)
2821 methods[c] = DEBUG_METHOD_NULL;
2828 /* Parse a string representing argument types for a method. Stabs
2829 tries to save space by packing argument types into a mangled
2830 string. This string should give us enough information to extract
2831 both argument types and the physical name of the function, given
2835 parse_stab_argtypes (void *dhandle, struct stab_handle *info,
2836 debug_type class_type, const char *fieldname,
2837 const char *tagname, debug_type return_type,
2838 const char *argtypes, bfd_boolean constp,
2839 bfd_boolean volatilep, const char **pphysname)
2841 bfd_boolean is_full_physname_constructor;
2842 bfd_boolean is_constructor;
2843 bfd_boolean is_destructor;
2846 bfd_boolean varargs;
2847 unsigned int physname_len = 0;
2849 /* Constructors are sometimes handled specially. */
2850 is_full_physname_constructor = ((argtypes[0] == '_'
2851 && argtypes[1] == '_'
2852 && (ISDIGIT (argtypes[2])
2853 || argtypes[2] == 'Q'
2854 || argtypes[2] == 't'))
2855 || CONST_STRNEQ (argtypes, "__ct"));
2857 is_constructor = (is_full_physname_constructor
2859 && strcmp (fieldname, tagname) == 0));
2860 is_destructor = ((argtypes[0] == '_'
2861 && (argtypes[1] == '$' || argtypes[1] == '.')
2862 && argtypes[2] == '_')
2863 || CONST_STRNEQ (argtypes, "__dt"));
2864 is_v3 = argtypes[0] == '_' && argtypes[1] == 'Z';
2866 if (is_destructor || is_full_physname_constructor || is_v3)
2867 *pphysname = argtypes;
2871 const char *const_prefix;
2872 const char *volatile_prefix;
2874 unsigned int mangled_name_len;
2877 len = tagname == NULL ? 0 : strlen (tagname);
2878 const_prefix = constp ? "C" : "";
2879 volatile_prefix = volatilep ? "V" : "";
2882 sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
2883 else if (tagname != NULL && strchr (tagname, '<') != NULL)
2885 /* Template methods are fully mangled. */
2886 sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
2891 sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
2893 mangled_name_len = ((is_constructor ? 0 : strlen (fieldname))
2899 if (fieldname[0] == 'o'
2900 && fieldname[1] == 'p'
2901 && (fieldname[2] == '$' || fieldname[2] == '.'))
2905 opname = cplus_mangle_opname (fieldname + 3, 0);
2908 fprintf (stderr, _("No mangling for \"%s\"\n"), fieldname);
2909 return DEBUG_TYPE_NULL;
2911 mangled_name_len += strlen (opname);
2912 physname = (char *) xmalloc (mangled_name_len);
2913 strncpy (physname, fieldname, 3);
2914 strcpy (physname + 3, opname);
2918 physname = (char *) xmalloc (mangled_name_len);
2922 strcpy (physname, fieldname);
2925 physname_len = strlen (physname);
2926 strcat (physname, buf);
2927 if (tagname != NULL)
2928 strcat (physname, tagname);
2929 strcat (physname, argtypes);
2931 *pphysname = physname;
2934 if (*argtypes == '\0' || is_destructor)
2936 args = (debug_type *) xmalloc (sizeof *args);
2938 return debug_make_method_type (dhandle, return_type, class_type, args,
2942 args = stab_demangle_argtypes (dhandle, info, *pphysname, &varargs, physname_len);
2944 return DEBUG_TYPE_NULL;
2946 return debug_make_method_type (dhandle, return_type, class_type, args,
2950 /* The tail end of stabs for C++ classes that contain a virtual function
2951 pointer contains a tilde, a %, and a type number.
2952 The type number refers to the base class (possibly this class itself) which
2953 contains the vtable pointer for the current class.
2955 This function is called when we have parsed all the method declarations,
2956 so we can look for the vptr base class info. */
2959 parse_stab_tilde_field (void *dhandle, struct stab_handle *info,
2960 const char **pp, const int *typenums,
2961 debug_type *retvptrbase, bfd_boolean *retownvptr)
2967 *retvptrbase = DEBUG_TYPE_NULL;
2968 *retownvptr = FALSE;
2972 /* If we are positioned at a ';', then skip it. */
2981 if (**pp == '=' || **pp == '+' || **pp == '-')
2983 /* Obsolete flags that used to indicate the presence of
2984 constructors and/or destructors. */
2995 /* The next number is the type number of the base class (possibly
2996 our own class) which supplies the vtable for this class. */
2997 if (! parse_stab_type_number (pp, vtypenums))
3000 if (vtypenums[0] == typenums[0]
3001 && vtypenums[1] == typenums[1])
3010 vtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3011 (debug_type **) NULL);
3012 for (p = *pp; *p != ';' && *p != '\0'; p++)
3020 *retvptrbase = vtype;
3028 /* Read a definition of an array type. */
3031 parse_stab_array_type (void *dhandle, struct stab_handle *info,
3032 const char **pp, bfd_boolean stringp)
3037 debug_type index_type;
3038 bfd_boolean adjustable;
3039 bfd_signed_vma lower, upper;
3040 debug_type element_type;
3042 /* Format of an array type:
3043 "ar<index type>;lower;upper;<array_contents_type>".
3044 OS9000: "arlower,upper;<array_contents_type>".
3046 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3047 for these, produce a type like float[][]. */
3051 /* FIXME: gdb checks os9k_stabs here. */
3053 /* If the index type is type 0, we take it as int. */
3055 if (! parse_stab_type_number (&p, typenums))
3056 return DEBUG_TYPE_NULL;
3057 if (typenums[0] == 0 && typenums[1] == 0 && **pp != '=')
3059 index_type = debug_find_named_type (dhandle, "int");
3060 if (index_type == DEBUG_TYPE_NULL)
3062 index_type = debug_make_int_type (dhandle, 4, FALSE);
3063 if (index_type == DEBUG_TYPE_NULL)
3064 return DEBUG_TYPE_NULL;
3070 index_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3071 (debug_type **) NULL);
3077 return DEBUG_TYPE_NULL;
3083 if (! ISDIGIT (**pp) && **pp != '-')
3089 lower = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
3093 return DEBUG_TYPE_NULL;
3097 if (! ISDIGIT (**pp) && **pp != '-')
3103 upper = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
3107 return DEBUG_TYPE_NULL;
3111 element_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3112 (debug_type **) NULL);
3113 if (element_type == DEBUG_TYPE_NULL)
3114 return DEBUG_TYPE_NULL;
3122 return debug_make_array_type (dhandle, element_type, index_type, lower,
3126 /* This struct holds information about files we have seen using
3131 /* The next N_BINCL file. */
3132 struct bincl_file *next;
3133 /* The next N_BINCL on the stack. */
3134 struct bincl_file *next_stack;
3135 /* The file name. */
3137 /* The hash value. */
3139 /* The file index. */
3141 /* The list of types defined in this file. */
3142 struct stab_types *file_types;
3145 /* Start a new N_BINCL file, pushing it onto the stack. */
3148 push_bincl (struct stab_handle *info, const char *name, bfd_vma hash)
3150 struct bincl_file *n;
3152 n = (struct bincl_file *) xmalloc (sizeof *n);
3153 n->next = info->bincl_list;
3154 n->next_stack = info->bincl_stack;
3157 n->file = info->files;
3158 n->file_types = NULL;
3159 info->bincl_list = n;
3160 info->bincl_stack = n;
3163 info->file_types = ((struct stab_types **)
3164 xrealloc (info->file_types,
3166 * sizeof *info->file_types)));
3167 info->file_types[n->file] = NULL;
3170 /* Finish an N_BINCL file, at an N_EINCL, popping the name off the
3174 pop_bincl (struct stab_handle *info)
3176 struct bincl_file *o;
3178 o = info->bincl_stack;
3180 return info->main_filename;
3181 info->bincl_stack = o->next_stack;
3183 o->file_types = info->file_types[o->file];
3185 if (info->bincl_stack == NULL)
3186 return info->main_filename;
3187 return info->bincl_stack->name;
3190 /* Handle an N_EXCL: get the types from the corresponding N_BINCL. */
3193 find_excl (struct stab_handle *info, const char *name, bfd_vma hash)
3195 struct bincl_file *l;
3198 info->file_types = ((struct stab_types **)
3199 xrealloc (info->file_types,
3201 * sizeof *info->file_types)));
3203 for (l = info->bincl_list; l != NULL; l = l->next)
3204 if (l->hash == hash && strcmp (l->name, name) == 0)
3208 warn_stab (name, _("Undefined N_EXCL"));
3209 info->file_types[info->files - 1] = NULL;
3213 info->file_types[info->files - 1] = l->file_types;
3218 /* Handle a variable definition. gcc emits variable definitions for a
3219 block before the N_LBRAC, so we must hold onto them until we see
3220 it. The SunPRO compiler emits variable definitions after the
3221 N_LBRAC, so we can call debug_record_variable immediately. */
3224 stab_record_variable (void *dhandle, struct stab_handle *info,
3225 const char *name, debug_type type,
3226 enum debug_var_kind kind, bfd_vma val)
3228 struct stab_pending_var *v;
3230 if ((kind == DEBUG_GLOBAL || kind == DEBUG_STATIC)
3231 || ! info->within_function
3232 || (info->gcc_compiled == 0 && info->n_opt_found))
3233 return debug_record_variable (dhandle, name, type, kind, val);
3235 v = (struct stab_pending_var *) xmalloc (sizeof *v);
3236 memset (v, 0, sizeof *v);
3238 v->next = info->pending;
3248 /* Emit pending variable definitions. This is called after we see the
3249 N_LBRAC that starts the block. */
3252 stab_emit_pending_vars (void *dhandle, struct stab_handle *info)
3254 struct stab_pending_var *v;
3259 struct stab_pending_var *next;
3261 if (! debug_record_variable (dhandle, v->name, v->type, v->kind, v->val))
3269 info->pending = NULL;
3274 /* Find the slot for a type in the database. */
3277 stab_find_slot (struct stab_handle *info, const int *typenums)
3281 struct stab_types **ps;
3283 filenum = typenums[0];
3284 index = typenums[1];
3286 if (filenum < 0 || (unsigned int) filenum >= info->files)
3288 fprintf (stderr, _("Type file number %d out of range\n"), filenum);
3293 fprintf (stderr, _("Type index number %d out of range\n"), index);
3297 ps = info->file_types + filenum;
3299 while (index >= STAB_TYPES_SLOTS)
3303 *ps = (struct stab_types *) xmalloc (sizeof **ps);
3304 memset (*ps, 0, sizeof **ps);
3307 index -= STAB_TYPES_SLOTS;
3311 *ps = (struct stab_types *) xmalloc (sizeof **ps);
3312 memset (*ps, 0, sizeof **ps);
3315 return (*ps)->types + index;
3318 /* Find a type given a type number. If the type has not been
3319 allocated yet, create an indirect type. */
3322 stab_find_type (void *dhandle, struct stab_handle *info, const int *typenums)
3326 if (typenums[0] == 0 && typenums[1] < 0)
3328 /* A negative type number indicates an XCOFF builtin type. */
3329 return stab_xcoff_builtin_type (dhandle, info, typenums[1]);
3332 slot = stab_find_slot (info, typenums);
3334 return DEBUG_TYPE_NULL;
3336 if (*slot == DEBUG_TYPE_NULL)
3337 return debug_make_indirect_type (dhandle, slot, (const char *) NULL);
3342 /* Record that a given type number refers to a given type. */
3345 stab_record_type (void *dhandle ATTRIBUTE_UNUSED, struct stab_handle *info,
3346 const int *typenums, debug_type type)
3350 slot = stab_find_slot (info, typenums);
3354 /* gdb appears to ignore type redefinitions, so we do as well. */
3361 /* Return an XCOFF builtin type. */
3364 stab_xcoff_builtin_type (void *dhandle, struct stab_handle *info,
3370 if (typenum >= 0 || typenum < -XCOFF_TYPE_COUNT)
3372 fprintf (stderr, _("Unrecognized XCOFF type %d\n"), typenum);
3373 return DEBUG_TYPE_NULL;
3375 if (info->xcoff_types[-typenum] != NULL)
3376 return info->xcoff_types[-typenum];
3381 /* The size of this and all the other types are fixed, defined
3382 by the debugging format. */
3384 rettype = debug_make_int_type (dhandle, 4, FALSE);
3388 rettype = debug_make_int_type (dhandle, 1, FALSE);
3392 rettype = debug_make_int_type (dhandle, 2, FALSE);
3396 rettype = debug_make_int_type (dhandle, 4, FALSE);
3399 name = "unsigned char";
3400 rettype = debug_make_int_type (dhandle, 1, TRUE);
3403 name = "signed char";
3404 rettype = debug_make_int_type (dhandle, 1, FALSE);
3407 name = "unsigned short";
3408 rettype = debug_make_int_type (dhandle, 2, TRUE);
3411 name = "unsigned int";
3412 rettype = debug_make_int_type (dhandle, 4, TRUE);
3416 rettype = debug_make_int_type (dhandle, 4, TRUE);
3418 name = "unsigned long";
3419 rettype = debug_make_int_type (dhandle, 4, TRUE);
3423 rettype = debug_make_void_type (dhandle);
3426 /* IEEE single precision (32 bit). */
3428 rettype = debug_make_float_type (dhandle, 4);
3431 /* IEEE double precision (64 bit). */
3433 rettype = debug_make_float_type (dhandle, 8);
3436 /* This is an IEEE double on the RS/6000, and different machines
3437 with different sizes for "long double" should use different
3438 negative type numbers. See stabs.texinfo. */
3439 name = "long double";
3440 rettype = debug_make_float_type (dhandle, 8);
3444 rettype = debug_make_int_type (dhandle, 4, FALSE);
3448 rettype = debug_make_bool_type (dhandle, 4);
3451 name = "short real";
3452 rettype = debug_make_float_type (dhandle, 4);
3456 rettype = debug_make_float_type (dhandle, 8);
3466 rettype = debug_make_int_type (dhandle, 1, TRUE);
3470 rettype = debug_make_bool_type (dhandle, 1);
3474 rettype = debug_make_bool_type (dhandle, 2);
3478 rettype = debug_make_bool_type (dhandle, 4);
3482 rettype = debug_make_bool_type (dhandle, 4);
3485 /* Complex type consisting of two IEEE single precision values. */
3487 rettype = debug_make_complex_type (dhandle, 8);
3490 /* Complex type consisting of two IEEE double precision values. */
3491 name = "double complex";
3492 rettype = debug_make_complex_type (dhandle, 16);
3496 rettype = debug_make_int_type (dhandle, 1, FALSE);
3500 rettype = debug_make_int_type (dhandle, 2, FALSE);
3504 rettype = debug_make_int_type (dhandle, 4, FALSE);
3509 rettype = debug_make_int_type (dhandle, 2, FALSE);
3513 rettype = debug_make_int_type (dhandle, 8, FALSE);
3516 name = "unsigned long long";
3517 rettype = debug_make_int_type (dhandle, 8, TRUE);
3521 rettype = debug_make_bool_type (dhandle, 8);
3525 rettype = debug_make_int_type (dhandle, 8, FALSE);
3531 rettype = debug_name_type (dhandle, name, rettype);
3533 info->xcoff_types[-typenum] = rettype;
3538 /* Find or create a tagged type. */
3541 stab_find_tagged_type (void *dhandle, struct stab_handle *info,
3542 const char *p, int len, enum debug_type_kind kind)
3546 struct stab_tag *st;
3548 name = savestring (p, len);
3550 /* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same
3551 namespace. This is right for C, and I don't know how to handle
3552 other languages. FIXME. */
3553 dtype = debug_find_tagged_type (dhandle, name, DEBUG_KIND_ILLEGAL);
3554 if (dtype != DEBUG_TYPE_NULL)
3560 /* We need to allocate an entry on the undefined tag list. */
3561 for (st = info->tags; st != NULL; st = st->next)
3563 if (st->name[0] == name[0]
3564 && strcmp (st->name, name) == 0)
3566 if (st->kind == DEBUG_KIND_ILLEGAL)
3574 st = (struct stab_tag *) xmalloc (sizeof *st);
3575 memset (st, 0, sizeof *st);
3577 st->next = info->tags;
3580 st->slot = DEBUG_TYPE_NULL;
3581 st->type = debug_make_indirect_type (dhandle, &st->slot, name);
3588 /* In order to get the correct argument types for a stubbed method, we
3589 need to extract the argument types from a C++ mangled string.
3590 Since the argument types can refer back to the return type, this
3591 means that we must demangle the entire physical name. In gdb this
3592 is done by calling cplus_demangle and running the results back
3593 through the C++ expression parser. Since we have no expression
3594 parser, we must duplicate much of the work of cplus_demangle here.
3596 We assume that GNU style demangling is used, since this is only
3597 done for method stubs, and only g++ should output that form of
3598 debugging information. */
3600 /* This structure is used to hold a pointer to type information which
3601 demangling a string. */
3603 struct stab_demangle_typestring
3605 /* The start of the type. This is not null terminated. */
3606 const char *typestring;
3607 /* The length of the type. */
3611 /* This structure is used to hold information while demangling a
3614 struct stab_demangle_info
3616 /* The debugging information handle. */
3618 /* The stab information handle. */
3619 struct stab_handle *info;
3620 /* The array of arguments we are building. */
3622 /* Whether the method takes a variable number of arguments. */
3623 bfd_boolean varargs;
3624 /* The array of types we have remembered. */
3625 struct stab_demangle_typestring *typestrings;
3626 /* The number of typestrings. */
3627 unsigned int typestring_count;
3628 /* The number of typestring slots we have allocated. */
3629 unsigned int typestring_alloc;
3632 static void stab_bad_demangle (const char *);
3633 static unsigned int stab_demangle_count (const char **);
3634 static bfd_boolean stab_demangle_get_count (const char **, unsigned int *);
3635 static bfd_boolean stab_demangle_prefix
3636 (struct stab_demangle_info *, const char **, unsigned int);
3637 static bfd_boolean stab_demangle_function_name
3638 (struct stab_demangle_info *, const char **, const char *);
3639 static bfd_boolean stab_demangle_signature
3640 (struct stab_demangle_info *, const char **);
3641 static bfd_boolean stab_demangle_qualified
3642 (struct stab_demangle_info *, const char **, debug_type *);
3643 static bfd_boolean stab_demangle_template
3644 (struct stab_demangle_info *, const char **, char **);
3645 static bfd_boolean stab_demangle_class
3646 (struct stab_demangle_info *, const char **, const char **);
3647 static bfd_boolean stab_demangle_args
3648 (struct stab_demangle_info *, const char **, debug_type **, bfd_boolean *);
3649 static bfd_boolean stab_demangle_arg
3650 (struct stab_demangle_info *, const char **, debug_type **,
3651 unsigned int *, unsigned int *);
3652 static bfd_boolean stab_demangle_type
3653 (struct stab_demangle_info *, const char **, debug_type *);
3654 static bfd_boolean stab_demangle_fund_type
3655 (struct stab_demangle_info *, const char **, debug_type *);
3656 static bfd_boolean stab_demangle_remember_type
3657 (struct stab_demangle_info *, const char *, int);
3659 /* Warn about a bad demangling. */
3662 stab_bad_demangle (const char *s)
3664 fprintf (stderr, _("bad mangled name `%s'\n"), s);
3667 /* Get a count from a stab string. */
3670 stab_demangle_count (const char **pp)
3675 while (ISDIGIT (**pp))
3678 count += **pp - '0';
3684 /* Require a count in a string. The count may be multiple digits, in
3685 which case it must end in an underscore. */
3688 stab_demangle_get_count (const char **pp, unsigned int *pi)
3690 if (! ISDIGIT (**pp))
3708 while (ISDIGIT (*p));
3719 /* This function demangles a physical name, returning a NULL
3720 terminated array of argument types. */
3723 stab_demangle_argtypes (void *dhandle, struct stab_handle *info,
3724 const char *physname, bfd_boolean *pvarargs,
3725 unsigned int physname_len)
3727 struct stab_demangle_info minfo;
3729 /* Check for the g++ V3 ABI. */
3730 if (physname[0] == '_' && physname[1] == 'Z')
3731 return stab_demangle_v3_argtypes (dhandle, info, physname, pvarargs);
3733 minfo.dhandle = dhandle;
3736 minfo.varargs = FALSE;
3737 minfo.typestring_alloc = 10;
3738 minfo.typestrings = ((struct stab_demangle_typestring *)
3739 xmalloc (minfo.typestring_alloc
3740 * sizeof *minfo.typestrings));
3741 minfo.typestring_count = 0;
3743 /* cplus_demangle checks for special GNU mangled forms, but we can't
3744 see any of them in mangled method argument types. */
3746 if (! stab_demangle_prefix (&minfo, &physname, physname_len))
3749 if (*physname != '\0')
3751 if (! stab_demangle_signature (&minfo, &physname))
3755 free (minfo.typestrings);
3756 minfo.typestrings = NULL;
3758 if (minfo.args == NULL)
3759 fprintf (stderr, _("no argument types in mangled string\n"));
3761 *pvarargs = minfo.varargs;
3765 if (minfo.typestrings != NULL)
3766 free (minfo.typestrings);
3770 /* Demangle the prefix of the mangled name. */
3773 stab_demangle_prefix (struct stab_demangle_info *minfo, const char **pp,
3774 unsigned int physname_len)
3779 /* cplus_demangle checks for global constructors and destructors,
3780 but we can't see them in mangled argument types. */
3783 scan = *pp + physname_len;
3786 /* Look for `__'. */
3789 scan = strchr (scan, '_');
3790 while (scan != NULL && *++scan != '_');
3794 stab_bad_demangle (*pp);
3800 /* We found `__'; move ahead to the last contiguous `__' pair. */
3801 i = strspn (scan, "_");
3807 && (ISDIGIT (scan[2])
3811 /* This is a GNU style constructor name. */
3815 else if (scan == *pp
3816 && ! ISDIGIT (scan[2])
3819 /* Look for the `__' that separates the prefix from the
3821 while (*scan == '_')
3823 scan = strstr (scan, "__");
3824 if (scan == NULL || scan[2] == '\0')
3826 stab_bad_demangle (*pp);
3830 return stab_demangle_function_name (minfo, pp, scan);
3832 else if (scan[2] != '\0')
3834 /* The name doesn't start with `__', but it does contain `__'. */
3835 return stab_demangle_function_name (minfo, pp, scan);
3839 stab_bad_demangle (*pp);
3845 /* Demangle a function name prefix. The scan argument points to the
3846 double underscore which separates the function name from the
3850 stab_demangle_function_name (struct stab_demangle_info *minfo,
3851 const char **pp, const char *scan)
3855 /* The string from *pp to scan is the name of the function. We
3856 don't care about the name, since we just looking for argument
3857 types. However, for conversion operators, the name may include a
3858 type which we must remember in order to handle backreferences. */
3864 && CONST_STRNEQ (name, "type")
3865 && (name[4] == '$' || name[4] == '.'))
3869 /* This is a type conversion operator. */
3871 if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
3874 else if (name[0] == '_'
3881 /* This is a type conversion operator. */
3883 if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
3890 /* Demangle the signature. This is where the argument types are
3894 stab_demangle_signature (struct stab_demangle_info *minfo, const char **pp)
3897 bfd_boolean expect_func, func_done;
3902 expect_func = FALSE;
3906 while (**pp != '\0')
3912 if (! stab_demangle_qualified (minfo, pp, (debug_type *) NULL)
3913 || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
3920 /* Static member function. FIXME: Can this happen? */
3927 /* Const member function. */
3933 case '0': case '1': case '2': case '3': case '4':
3934 case '5': case '6': case '7': case '8': case '9':
3937 if (! stab_demangle_class (minfo, pp, (const char **) NULL)
3938 || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
3945 /* Function. I don't know if this actually happens with g++
3950 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3958 if (! stab_demangle_template (minfo, pp, (char **) NULL)
3959 || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
3966 /* At the outermost level, we cannot have a return type
3967 specified, so if we run into another '_' at this point we
3968 are dealing with a mangled name that is either bogus, or
3969 has been mangled by some algorithm we don't know how to
3970 deal with. So just reject the entire demangling. */
3971 stab_bad_demangle (orig);
3975 /* Assume we have stumbled onto the first outermost function
3976 argument token, and start processing args. */
3978 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3986 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3993 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
3994 bar__3fooi is 'foo::bar(int)'. We get here when we find the
3995 first case, and need to ensure that the '(void)' gets added
3996 to the current declp. */
3997 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
4004 /* Demangle a qualified name, such as "Q25Outer5Inner" which is the
4005 mangled form of "Outer::Inner". */
4008 stab_demangle_qualified (struct stab_demangle_info *minfo, const char **pp,
4013 unsigned int qualifiers;
4021 /* GNU mangled name with more than 9 classes. The count is
4022 preceded by an underscore (to distinguish it from the <= 9
4023 case) and followed by an underscore. */
4025 if (! ISDIGIT (*p) || *p == '0')
4027 stab_bad_demangle (orig);
4030 qualifiers = atoi (p);
4031 while (ISDIGIT (*p))
4035 stab_bad_demangle (orig);
4041 case '1': case '2': case '3': case '4': case '5':
4042 case '6': case '7': case '8': case '9':
4043 qualifiers = (*pp)[1] - '0';
4044 /* Skip an optional underscore after the count. */
4045 if ((*pp)[2] == '_')
4052 stab_bad_demangle (orig);
4056 context = DEBUG_TYPE_NULL;
4058 /* Pick off the names. */
4059 while (qualifiers-- > 0)
4067 if (! stab_demangle_template (minfo, pp,
4068 ptype != NULL ? &name : NULL))
4073 context = stab_find_tagged_type (minfo->dhandle, minfo->info,
4074 name, strlen (name),
4077 if (context == DEBUG_TYPE_NULL)
4085 len = stab_demangle_count (pp);
4086 if (strlen (*pp) < len)
4088 stab_bad_demangle (orig);
4094 const debug_field *fields;
4097 if (context != DEBUG_TYPE_NULL)
4098 fields = debug_get_fields (minfo->dhandle, context);
4100 context = DEBUG_TYPE_NULL;
4106 /* Try to find the type by looking through the
4107 fields of context until we find a field with the
4108 same type. This ought to work for a class
4109 defined within a class, but it won't work for,
4110 e.g., an enum defined within a class. stabs does
4111 not give us enough information to figure out the
4114 name = savestring (*pp, len);
4116 for (; *fields != DEBUG_FIELD_NULL; fields++)
4121 ft = debug_get_field_type (minfo->dhandle, *fields);
4124 dn = debug_get_type_name (minfo->dhandle, ft);
4125 if (dn != NULL && strcmp (dn, name) == 0)
4135 if (context == DEBUG_TYPE_NULL)
4137 /* We have to fall back on finding the type by name.
4138 If there are more types to come, then this must
4139 be a class. Otherwise, it could be anything. */
4141 if (qualifiers == 0)
4145 name = savestring (*pp, len);
4146 context = debug_find_named_type (minfo->dhandle,
4151 if (context == DEBUG_TYPE_NULL)
4153 context = stab_find_tagged_type (minfo->dhandle,
4157 ? DEBUG_KIND_ILLEGAL
4158 : DEBUG_KIND_CLASS));
4159 if (context == DEBUG_TYPE_NULL)
4175 /* Demangle a template. If PNAME is not NULL, this sets *PNAME to a
4176 string representation of the template. */
4179 stab_demangle_template (struct stab_demangle_info *minfo, const char **pp,
4189 /* Skip the template name. */
4190 r = stab_demangle_count (pp);
4191 if (r == 0 || strlen (*pp) < r)
4193 stab_bad_demangle (orig);
4198 /* Get the size of the parameter list. */
4199 if (stab_demangle_get_count (pp, &r) == 0)
4201 stab_bad_demangle (orig);
4205 for (i = 0; i < r; i++)
4209 /* This is a type parameter. */
4211 if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
4217 bfd_boolean pointerp, realp, integralp, charp, boolp;
4228 /* This is a value parameter. */
4230 if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
4233 while (*old_p != '\0' && ! done)
4243 case 'C': /* Const. */
4244 case 'S': /* Signed. */
4245 case 'U': /* Unsigned. */
4246 case 'V': /* Volatile. */
4247 case 'F': /* Function. */
4248 case 'M': /* Member function. */
4252 case 'Q': /* Qualified name. */
4256 case 'T': /* Remembered type. */
4258 case 'v': /* Void. */
4260 case 'x': /* Long long. */
4261 case 'l': /* Long. */
4262 case 'i': /* Int. */
4263 case 's': /* Short. */
4264 case 'w': /* Wchar_t. */
4268 case 'b': /* Bool. */
4272 case 'c': /* Char. */
4276 case 'r': /* Long double. */
4277 case 'd': /* Double. */
4278 case 'f': /* Float. */
4283 /* Assume it's a user defined integral type. */
4294 while (ISDIGIT (**pp))
4303 val = stab_demangle_count (pp);
4306 stab_bad_demangle (orig);
4314 val = stab_demangle_count (pp);
4315 if (val != 0 && val != 1)
4317 stab_bad_demangle (orig);
4325 while (ISDIGIT (**pp))
4330 while (ISDIGIT (**pp))
4336 while (ISDIGIT (**pp))
4344 len = stab_demangle_count (pp);
4347 stab_bad_demangle (orig);
4355 /* We can translate this to a string fairly easily by invoking the
4356 regular demangling routine. */
4359 char *s1, *s2, *s3, *s4 = NULL;
4362 s1 = savestring (orig, *pp - orig);
4364 s2 = concat ("NoSuchStrinG__", s1, (const char *) NULL);
4368 s3 = cplus_demangle (s2, DMGL_ANSI);
4373 s4 = strstr (s3, "::NoSuchStrinG");
4374 if (s3 == NULL || s4 == NULL)
4376 stab_bad_demangle (orig);
4382 /* Eliminating all spaces, except those between > characters,
4383 makes it more likely that the demangled name will match the
4384 name which g++ used as the structure name. */
4385 for (from = to = s3; from != s4; ++from)
4387 || (from[1] == '>' && from > s3 && from[-1] == '>'))
4390 *pname = savestring (s3, to - s3);
4398 /* Demangle a class name. */
4401 stab_demangle_class (struct stab_demangle_info *minfo ATTRIBUTE_UNUSED,
4402 const char **pp, const char **pstart)
4409 n = stab_demangle_count (pp);
4410 if (strlen (*pp) < n)
4412 stab_bad_demangle (orig);
4424 /* Demangle function arguments. If the pargs argument is not NULL, it
4425 is set to a NULL terminated array holding the arguments. */
4428 stab_demangle_args (struct stab_demangle_info *minfo, const char **pp,
4429 debug_type **pargs, bfd_boolean *pvarargs)
4432 unsigned int alloc, count;
4439 *pargs = (debug_type *) xmalloc (alloc * sizeof **pargs);
4444 while (**pp != '_' && **pp != '\0' && **pp != 'e')
4446 if (**pp == 'N' || **pp == 'T')
4454 if (temptype == 'T')
4458 if (! stab_demangle_get_count (pp, &r))
4460 stab_bad_demangle (orig);
4465 if (! stab_demangle_get_count (pp, &t))
4467 stab_bad_demangle (orig);
4471 if (t >= minfo->typestring_count)
4473 stab_bad_demangle (orig);
4480 tem = minfo->typestrings[t].typestring;
4481 if (! stab_demangle_arg (minfo, &tem, pargs, &count, &alloc))
4487 if (! stab_demangle_arg (minfo, pp, pargs, &count, &alloc))
4493 (*pargs)[count] = DEBUG_TYPE_NULL;
4505 /* Demangle a single argument. */
4508 stab_demangle_arg (struct stab_demangle_info *minfo, const char **pp,
4509 debug_type **pargs, unsigned int *pcount,
4510 unsigned int *palloc)
4516 if (! stab_demangle_type (minfo, pp,
4517 pargs == NULL ? (debug_type *) NULL : &type)
4518 || ! stab_demangle_remember_type (minfo, start, *pp - start))
4523 if (type == DEBUG_TYPE_NULL)
4526 if (*pcount + 1 >= *palloc)
4529 *pargs = ((debug_type *)
4530 xrealloc (*pargs, *palloc * sizeof **pargs));
4532 (*pargs)[*pcount] = type;
4539 /* Demangle a type. If the ptype argument is not NULL, *ptype is set
4540 to the newly allocated type. */
4543 stab_demangle_type (struct stab_demangle_info *minfo, const char **pp,
4554 /* A pointer type. */
4556 if (! stab_demangle_type (minfo, pp, ptype))
4559 *ptype = debug_make_pointer_type (minfo->dhandle, *ptype);
4563 /* A reference type. */
4565 if (! stab_demangle_type (minfo, pp, ptype))
4568 *ptype = debug_make_reference_type (minfo->dhandle, *ptype);
4578 while (**pp != '\0' && **pp != '_')
4580 if (! ISDIGIT (**pp))
4582 stab_bad_demangle (orig);
4591 stab_bad_demangle (orig);
4596 if (! stab_demangle_type (minfo, pp, ptype))
4600 debug_type int_type;
4602 int_type = debug_find_named_type (minfo->dhandle, "int");
4603 if (int_type == NULL)
4604 int_type = debug_make_int_type (minfo->dhandle, 4, FALSE);
4605 *ptype = debug_make_array_type (minfo->dhandle, *ptype, int_type,
4612 /* A back reference to a remembered type. */
4618 if (! stab_demangle_get_count (pp, &i))
4620 stab_bad_demangle (orig);
4623 if (i >= minfo->typestring_count)
4625 stab_bad_demangle (orig);
4628 p = minfo->typestrings[i].typestring;
4629 if (! stab_demangle_type (minfo, &p, ptype))
4638 bfd_boolean varargs;
4641 if (! stab_demangle_args (minfo, pp,
4643 ? (debug_type **) NULL
4646 ? (bfd_boolean *) NULL
4651 /* cplus_demangle will accept a function without a return
4652 type, but I don't know when that will happen, or what
4653 to do if it does. */
4654 stab_bad_demangle (orig);
4658 if (! stab_demangle_type (minfo, pp, ptype))
4661 *ptype = debug_make_function_type (minfo->dhandle, *ptype, args,
4670 bfd_boolean memberp, constp, volatilep;
4671 debug_type class_type = DEBUG_TYPE_NULL;
4673 bfd_boolean varargs;
4677 memberp = **pp == 'M';
4686 n = stab_demangle_count (pp);
4687 if (strlen (*pp) < n)
4689 stab_bad_demangle (orig);
4697 class_type = stab_find_tagged_type (minfo->dhandle,
4701 if (class_type == DEBUG_TYPE_NULL)
4705 else if (**pp == 'Q')
4707 if (! stab_demangle_qualified (minfo, pp,
4709 ? (debug_type *) NULL
4715 stab_bad_demangle (orig);
4726 else if (**pp == 'V')
4733 stab_bad_demangle (orig);
4737 if (! stab_demangle_args (minfo, pp,
4739 ? (debug_type **) NULL
4742 ? (bfd_boolean *) NULL
4749 stab_bad_demangle (orig);
4754 if (! stab_demangle_type (minfo, pp, ptype))
4760 *ptype = debug_make_offset_type (minfo->dhandle, class_type,
4764 /* FIXME: We have no way to record constp or
4766 *ptype = debug_make_method_type (minfo->dhandle, *ptype,
4767 class_type, args, varargs);
4775 if (! stab_demangle_type (minfo, pp, ptype))
4781 if (! stab_demangle_type (minfo, pp, ptype))
4784 *ptype = debug_make_const_type (minfo->dhandle, *ptype);
4792 if (! stab_demangle_qualified (minfo, pp, ptype))
4798 if (! stab_demangle_fund_type (minfo, pp, ptype))
4806 /* Demangle a fundamental type. If the ptype argument is not NULL,
4807 *ptype is set to the newly allocated type. */
4810 stab_demangle_fund_type (struct stab_demangle_info *minfo, const char **pp,
4814 bfd_boolean constp, volatilep, unsignedp, signedp;
4859 /* cplus_demangle permits this, but I don't know what it means. */
4860 stab_bad_demangle (orig);
4863 case 'v': /* void */
4866 *ptype = debug_find_named_type (minfo->dhandle, "void");
4867 if (*ptype == DEBUG_TYPE_NULL)
4868 *ptype = debug_make_void_type (minfo->dhandle);
4873 case 'x': /* long long */
4876 *ptype = debug_find_named_type (minfo->dhandle,
4878 ? "long long unsigned int"
4879 : "long long int"));
4880 if (*ptype == DEBUG_TYPE_NULL)
4881 *ptype = debug_make_int_type (minfo->dhandle, 8, unsignedp);
4886 case 'l': /* long */
4889 *ptype = debug_find_named_type (minfo->dhandle,
4891 ? "long unsigned int"
4893 if (*ptype == DEBUG_TYPE_NULL)
4894 *ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp);
4902 *ptype = debug_find_named_type (minfo->dhandle,
4906 if (*ptype == DEBUG_TYPE_NULL)
4907 *ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp);
4912 case 's': /* short */
4915 *ptype = debug_find_named_type (minfo->dhandle,
4917 ? "short unsigned int"
4919 if (*ptype == DEBUG_TYPE_NULL)
4920 *ptype = debug_make_int_type (minfo->dhandle, 2, unsignedp);
4925 case 'b': /* bool */
4928 *ptype = debug_find_named_type (minfo->dhandle, "bool");
4929 if (*ptype == DEBUG_TYPE_NULL)
4930 *ptype = debug_make_bool_type (minfo->dhandle, 4);
4935 case 'c': /* char */
4938 *ptype = debug_find_named_type (minfo->dhandle,
4944 if (*ptype == DEBUG_TYPE_NULL)
4945 *ptype = debug_make_int_type (minfo->dhandle, 1, unsignedp);
4950 case 'w': /* wchar_t */
4953 *ptype = debug_find_named_type (minfo->dhandle, "__wchar_t");
4954 if (*ptype == DEBUG_TYPE_NULL)
4955 *ptype = debug_make_int_type (minfo->dhandle, 2, TRUE);
4960 case 'r': /* long double */
4963 *ptype = debug_find_named_type (minfo->dhandle, "long double");
4964 if (*ptype == DEBUG_TYPE_NULL)
4965 *ptype = debug_make_float_type (minfo->dhandle, 8);
4970 case 'd': /* double */
4973 *ptype = debug_find_named_type (minfo->dhandle, "double");
4974 if (*ptype == DEBUG_TYPE_NULL)
4975 *ptype = debug_make_float_type (minfo->dhandle, 8);
4980 case 'f': /* float */
4983 *ptype = debug_find_named_type (minfo->dhandle, "float");
4984 if (*ptype == DEBUG_TYPE_NULL)
4985 *ptype = debug_make_float_type (minfo->dhandle, 4);
4992 if (! ISDIGIT (**pp))
4994 stab_bad_demangle (orig);
4998 case '0': case '1': case '2': case '3': case '4':
4999 case '5': case '6': case '7': case '8': case '9':
5003 if (! stab_demangle_class (minfo, pp, &hold))
5009 name = savestring (hold, *pp - hold);
5010 *ptype = debug_find_named_type (minfo->dhandle, name);
5012 if (*ptype == DEBUG_TYPE_NULL)
5014 /* FIXME: It is probably incorrect to assume that
5015 undefined types are tagged types. */
5016 *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
5018 DEBUG_KIND_ILLEGAL);
5019 if (*ptype == DEBUG_TYPE_NULL)
5030 if (! stab_demangle_template (minfo, pp,
5031 ptype != NULL ? &name : NULL))
5035 *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
5036 name, strlen (name),
5039 if (*ptype == DEBUG_TYPE_NULL)
5046 stab_bad_demangle (orig);
5053 *ptype = debug_make_const_type (minfo->dhandle, *ptype);
5055 *ptype = debug_make_volatile_type (minfo->dhandle, *ptype);
5061 /* Remember a type string in a demangled string. */
5064 stab_demangle_remember_type (struct stab_demangle_info *minfo,
5065 const char *p, int len)
5067 if (minfo->typestring_count >= minfo->typestring_alloc)
5069 minfo->typestring_alloc += 10;
5070 minfo->typestrings = ((struct stab_demangle_typestring *)
5071 xrealloc (minfo->typestrings,
5072 (minfo->typestring_alloc
5073 * sizeof *minfo->typestrings)));
5076 minfo->typestrings[minfo->typestring_count].typestring = p;
5077 minfo->typestrings[minfo->typestring_count].len = (unsigned int) len;
5078 ++minfo->typestring_count;
5083 /* Demangle names encoded using the g++ V3 ABI. The newer versions of
5084 g++ which use this ABI do not encode ordinary method argument types
5085 in a mangled name; they simply output the argument types. However,
5086 for a static method, g++ simply outputs the return type and the
5087 physical name. So in that case we need to demangle the name here.
5088 Here PHYSNAME is the physical name of the function, and we set the
5089 variable pointed at by PVARARGS to indicate whether this function
5090 is varargs. This returns NULL, or a NULL terminated array of
5094 stab_demangle_v3_argtypes (void *dhandle, struct stab_handle *info,
5095 const char *physname, bfd_boolean *pvarargs)
5097 struct demangle_component *dc;
5101 dc = cplus_demangle_v3_components (physname, DMGL_PARAMS | DMGL_ANSI, &mem);
5104 stab_bad_demangle (physname);
5108 /* We expect to see TYPED_NAME, and the right subtree describes the
5110 if (dc->type != DEMANGLE_COMPONENT_TYPED_NAME
5111 || dc->u.s_binary.right->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
5113 fprintf (stderr, _("Demangled name is not a function\n"));
5118 pargs = stab_demangle_v3_arglist (dhandle, info,
5119 dc->u.s_binary.right->u.s_binary.right,
5127 /* Demangle an argument list in a struct demangle_component tree.
5128 Returns a DEBUG_TYPE_NULL terminated array of argument types, and
5129 sets *PVARARGS to indicate whether this is a varargs function. */
5132 stab_demangle_v3_arglist (void *dhandle, struct stab_handle *info,
5133 struct demangle_component *arglist,
5134 bfd_boolean *pvarargs)
5136 struct demangle_component *dc;
5137 unsigned int alloc, count;
5141 pargs = (debug_type *) xmalloc (alloc * sizeof *pargs);
5148 dc = dc->u.s_binary.right)
5151 bfd_boolean varargs;
5153 if (dc->type != DEMANGLE_COMPONENT_ARGLIST)
5155 fprintf (stderr, _("Unexpected type in v3 arglist demangling\n"));
5160 arg = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left,
5173 if (count + 1 >= alloc)
5176 pargs = (debug_type *) xrealloc (pargs, alloc * sizeof *pargs);
5183 pargs[count] = DEBUG_TYPE_NULL;
5188 /* Convert a struct demangle_component tree describing an argument
5189 type into a debug_type. */
5192 stab_demangle_v3_arg (void *dhandle, struct stab_handle *info,
5193 struct demangle_component *dc, debug_type context,
5194 bfd_boolean *pvarargs)
5198 if (pvarargs != NULL)
5203 /* FIXME: These are demangle component types which we probably
5204 need to handle one way or another. */
5205 case DEMANGLE_COMPONENT_LOCAL_NAME:
5206 case DEMANGLE_COMPONENT_TYPED_NAME:
5207 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
5208 case DEMANGLE_COMPONENT_CTOR:
5209 case DEMANGLE_COMPONENT_DTOR:
5210 case DEMANGLE_COMPONENT_JAVA_CLASS:
5211 case DEMANGLE_COMPONENT_RESTRICT_THIS:
5212 case DEMANGLE_COMPONENT_VOLATILE_THIS:
5213 case DEMANGLE_COMPONENT_CONST_THIS:
5214 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5215 case DEMANGLE_COMPONENT_COMPLEX:
5216 case DEMANGLE_COMPONENT_IMAGINARY:
5217 case DEMANGLE_COMPONENT_VENDOR_TYPE:
5218 case DEMANGLE_COMPONENT_ARRAY_TYPE:
5219 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5220 case DEMANGLE_COMPONENT_ARGLIST:
5222 fprintf (stderr, _("Unrecognized demangle component %d\n"),
5226 case DEMANGLE_COMPONENT_NAME:
5227 if (context != NULL)
5229 const debug_field *fields;
5231 fields = debug_get_fields (dhandle, context);
5234 /* Try to find this type by looking through the context
5236 for (; *fields != DEBUG_FIELD_NULL; fields++)
5241 ft = debug_get_field_type (dhandle, *fields);
5244 dn = debug_get_type_name (dhandle, ft);
5246 && (int) strlen (dn) == dc->u.s_name.len
5247 && strncmp (dn, dc->u.s_name.s, dc->u.s_name.len) == 0)
5252 return stab_find_tagged_type (dhandle, info, dc->u.s_name.s,
5253 dc->u.s_name.len, DEBUG_KIND_ILLEGAL);
5255 case DEMANGLE_COMPONENT_QUAL_NAME:
5256 context = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left,
5258 if (context == NULL)
5260 return stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.right,
5263 case DEMANGLE_COMPONENT_TEMPLATE:
5268 /* We print this component to get a class name which we can
5269 use. FIXME: This probably won't work if the template uses
5270 template parameters which refer to an outer template. */
5271 p = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, dc, 20, &alc);
5274 fprintf (stderr, _("Failed to print demangled template\n"));
5277 dt = stab_find_tagged_type (dhandle, info, p, strlen (p),
5283 case DEMANGLE_COMPONENT_SUB_STD:
5284 return stab_find_tagged_type (dhandle, info, dc->u.s_string.string,
5285 dc->u.s_string.len, DEBUG_KIND_ILLEGAL);
5287 case DEMANGLE_COMPONENT_RESTRICT:
5288 case DEMANGLE_COMPONENT_VOLATILE:
5289 case DEMANGLE_COMPONENT_CONST:
5290 case DEMANGLE_COMPONENT_POINTER:
5291 case DEMANGLE_COMPONENT_REFERENCE:
5292 dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL,
5301 case DEMANGLE_COMPONENT_RESTRICT:
5302 /* FIXME: We have no way to represent restrict. */
5304 case DEMANGLE_COMPONENT_VOLATILE:
5305 return debug_make_volatile_type (dhandle, dt);
5306 case DEMANGLE_COMPONENT_CONST:
5307 return debug_make_const_type (dhandle, dt);
5308 case DEMANGLE_COMPONENT_POINTER:
5309 return debug_make_pointer_type (dhandle, dt);
5310 case DEMANGLE_COMPONENT_REFERENCE:
5311 return debug_make_reference_type (dhandle, dt);
5314 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
5317 bfd_boolean varargs;
5319 if (dc->u.s_binary.left == NULL)
5321 /* In this case the return type is actually unknown.
5322 However, I'm not sure this will ever arise in practice;
5323 normally an unknown return type would only appear at
5324 the top level, which is handled above. */
5325 dt = debug_make_void_type (dhandle);
5328 dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL,
5333 pargs = stab_demangle_v3_arglist (dhandle, info,
5334 dc->u.s_binary.right,
5339 return debug_make_function_type (dhandle, dt, pargs, varargs);
5342 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
5348 /* We print this component in order to find out the type name.
5349 FIXME: Should we instead expose the
5350 demangle_builtin_type_info structure? */
5351 p = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, dc, 20, &alc);
5354 fprintf (stderr, _("Couldn't get demangled builtin type\n"));
5358 /* The mangling is based on the type, but does not itself
5359 indicate what the sizes are. So we have to guess. */
5360 if (strcmp (p, "signed char") == 0)
5361 ret = debug_make_int_type (dhandle, 1, FALSE);
5362 else if (strcmp (p, "bool") == 0)
5363 ret = debug_make_bool_type (dhandle, 1);
5364 else if (strcmp (p, "char") == 0)
5365 ret = debug_make_int_type (dhandle, 1, FALSE);
5366 else if (strcmp (p, "double") == 0)
5367 ret = debug_make_float_type (dhandle, 8);
5368 else if (strcmp (p, "long double") == 0)
5369 ret = debug_make_float_type (dhandle, 8);
5370 else if (strcmp (p, "float") == 0)
5371 ret = debug_make_float_type (dhandle, 4);
5372 else if (strcmp (p, "__float128") == 0)
5373 ret = debug_make_float_type (dhandle, 16);
5374 else if (strcmp (p, "unsigned char") == 0)
5375 ret = debug_make_int_type (dhandle, 1, TRUE);
5376 else if (strcmp (p, "int") == 0)
5377 ret = debug_make_int_type (dhandle, 4, FALSE);
5378 else if (strcmp (p, "unsigned int") == 0)
5379 ret = debug_make_int_type (dhandle, 4, TRUE);
5380 else if (strcmp (p, "long") == 0)
5381 ret = debug_make_int_type (dhandle, 4, FALSE);
5382 else if (strcmp (p, "unsigned long") == 0)
5383 ret = debug_make_int_type (dhandle, 4, TRUE);
5384 else if (strcmp (p, "__int128") == 0)
5385 ret = debug_make_int_type (dhandle, 16, FALSE);
5386 else if (strcmp (p, "unsigned __int128") == 0)
5387 ret = debug_make_int_type (dhandle, 16, TRUE);
5388 else if (strcmp (p, "short") == 0)
5389 ret = debug_make_int_type (dhandle, 2, FALSE);
5390 else if (strcmp (p, "unsigned short") == 0)
5391 ret = debug_make_int_type (dhandle, 2, TRUE);
5392 else if (strcmp (p, "void") == 0)
5393 ret = debug_make_void_type (dhandle);
5394 else if (strcmp (p, "wchar_t") == 0)
5395 ret = debug_make_int_type (dhandle, 4, TRUE);
5396 else if (strcmp (p, "long long") == 0)
5397 ret = debug_make_int_type (dhandle, 8, FALSE);
5398 else if (strcmp (p, "unsigned long long") == 0)
5399 ret = debug_make_int_type (dhandle, 8, TRUE);
5400 else if (strcmp (p, "...") == 0)
5402 if (pvarargs == NULL)
5403 fprintf (stderr, _("Unexpected demangled varargs\n"));
5410 fprintf (stderr, _("Unrecognized demangled builtin type\n"));