1 /* stabs.c -- Parse stabs debugging information
2 Copyright (C) 1995-2014 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@cygnus.com>.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 /* This file contains code which parses stabs debugging information.
23 The organization of this code is based on the gdb stabs reading
24 code. The job it does is somewhat different, because it is not
25 trying to identify the correct address for anything. */
29 #include "libiberty.h"
30 #include "safe-ctype.h"
34 #include "filenames.h"
35 #include "aout/aout64.h"
36 #include "aout/stab_gnu.h"
38 /* The number of predefined XCOFF types. */
40 #define XCOFF_TYPE_COUNT 34
42 /* This structure is used as a handle so that the stab parsing doesn't
43 need to use any static variables. */
49 /* TRUE if this is stabs in sections. */
51 /* The symbol table. */
53 /* The number of symbols. */
55 /* The accumulated file name string. */
57 /* The value of the last N_SO symbol. */
59 /* The value of the start of the file, so that we can handle file
60 relative N_LBRAC and N_RBRAC symbols. */
61 bfd_vma file_start_offset;
62 /* The offset of the start of the function, so that we can handle
63 function relative N_LBRAC and N_RBRAC symbols. */
64 bfd_vma function_start_offset;
65 /* The version number of gcc which compiled the current compilation
66 unit, 0 if not compiled by gcc. */
68 /* Whether an N_OPT symbol was seen that was not generated by gcc,
69 so that we can detect the SunPRO compiler. */
70 bfd_boolean n_opt_found;
71 /* The main file name. */
73 /* A stack of unfinished N_BINCL files. */
74 struct bincl_file *bincl_stack;
75 /* A list of finished N_BINCL files. */
76 struct bincl_file *bincl_list;
77 /* Whether we are inside a function or not. */
78 bfd_boolean within_function;
79 /* The address of the end of the function, used if we have seen an
80 N_FUN symbol while in a function. This is -1 if we have not seen
81 an N_FUN (the normal case). */
83 /* The depth of block nesting. */
85 /* List of pending variable definitions. */
86 struct stab_pending_var *pending;
87 /* Number of files for which we have types. */
89 /* Lists of types per file. */
90 struct stab_types **file_types;
91 /* Predefined XCOFF types. */
92 debug_type xcoff_types[XCOFF_TYPE_COUNT];
94 struct stab_tag *tags;
95 /* Set by parse_stab_type if it sees a structure defined as a cross
96 reference to itself. Reset by parse_stab_type otherwise. */
97 bfd_boolean self_crossref;
100 /* A list of these structures is used to hold pending variable
101 definitions seen before the N_LBRAC of a block. */
103 struct stab_pending_var
105 /* Next pending variable definition. */
106 struct stab_pending_var *next;
112 enum debug_var_kind kind;
117 /* A list of these structures is used to hold the types for a single
122 /* Next set of slots for this file. */
123 struct stab_types *next;
124 /* Types indexed by type number. */
125 #define STAB_TYPES_SLOTS (16)
126 debug_type types[STAB_TYPES_SLOTS];
129 /* We keep a list of undefined tags that we encounter, so that we can
130 fill them in if the tag is later defined. */
134 /* Next undefined tag. */
135 struct stab_tag *next;
139 enum debug_type_kind kind;
140 /* Slot to hold real type when we discover it. If we don't, we fill
141 in an undefined tag type. */
143 /* Indirect type we have created to point at slot. */
147 static char *savestring (const char *, int);
148 static bfd_vma parse_number (const char **, bfd_boolean *);
149 static void bad_stab (const char *);
150 static void warn_stab (const char *, const char *);
151 static bfd_boolean parse_stab_string
152 (void *, struct stab_handle *, int, int, bfd_vma, const char *);
153 static debug_type parse_stab_type
154 (void *, struct stab_handle *, const char *, const char **, debug_type **);
155 static bfd_boolean parse_stab_type_number (const char **, int *);
156 static debug_type parse_stab_range_type
157 (void *, struct stab_handle *, const char *, const char **, const int *);
158 static debug_type parse_stab_sun_builtin_type (void *, const char **);
159 static debug_type parse_stab_sun_floating_type (void *, const char **);
160 static debug_type parse_stab_enum_type (void *, const char **);
161 static debug_type parse_stab_struct_type
162 (void *, struct stab_handle *, const char *, const char **,
163 bfd_boolean, const int *);
164 static bfd_boolean parse_stab_baseclasses
165 (void *, struct stab_handle *, const char **, debug_baseclass **);
166 static bfd_boolean parse_stab_struct_fields
167 (void *, struct stab_handle *, const char **, debug_field **, bfd_boolean *);
168 static bfd_boolean parse_stab_cpp_abbrev
169 (void *, struct stab_handle *, const char **, debug_field *);
170 static bfd_boolean parse_stab_one_struct_field
171 (void *, struct stab_handle *, const char **, const char *,
172 debug_field *, bfd_boolean *);
173 static bfd_boolean parse_stab_members
174 (void *, struct stab_handle *, const char *, const char **, const int *,
176 static debug_type parse_stab_argtypes
177 (void *, struct stab_handle *, debug_type, const char *, const char *,
178 debug_type, const char *, bfd_boolean, bfd_boolean, const char **);
179 static bfd_boolean parse_stab_tilde_field
180 (void *, struct stab_handle *, const char **, const int *, debug_type *,
182 static debug_type parse_stab_array_type
183 (void *, struct stab_handle *, const char **, bfd_boolean);
184 static void push_bincl (struct stab_handle *, const char *, bfd_vma);
185 static const char *pop_bincl (struct stab_handle *);
186 static bfd_boolean find_excl (struct stab_handle *, const char *, bfd_vma);
187 static bfd_boolean stab_record_variable
188 (void *, struct stab_handle *, const char *, debug_type,
189 enum debug_var_kind, bfd_vma);
190 static bfd_boolean stab_emit_pending_vars (void *, struct stab_handle *);
191 static debug_type *stab_find_slot (struct stab_handle *, const int *);
192 static debug_type stab_find_type (void *, struct stab_handle *, const int *);
193 static bfd_boolean stab_record_type
194 (void *, struct stab_handle *, const int *, debug_type);
195 static debug_type stab_xcoff_builtin_type
196 (void *, struct stab_handle *, int);
197 static debug_type stab_find_tagged_type
198 (void *, struct stab_handle *, const char *, int, enum debug_type_kind);
199 static debug_type *stab_demangle_argtypes
200 (void *, struct stab_handle *, const char *, bfd_boolean *, unsigned int);
201 static debug_type *stab_demangle_v3_argtypes
202 (void *, struct stab_handle *, const char *, bfd_boolean *);
203 static debug_type *stab_demangle_v3_arglist
204 (void *, struct stab_handle *, struct demangle_component *, bfd_boolean *);
205 static debug_type stab_demangle_v3_arg
206 (void *, struct stab_handle *, struct demangle_component *, debug_type,
209 /* Save a string in memory. */
212 savestring (const char *start, int len)
216 ret = (char *) xmalloc (len + 1);
217 memcpy (ret, start, len);
222 /* Read a number from a string. */
225 parse_number (const char **pp, bfd_boolean *poverflow)
230 if (poverflow != NULL)
236 ul = strtoul (*pp, (char **) pp, 0);
237 if (ul + 1 != 0 || errno == 0)
239 /* If bfd_vma is larger than unsigned long, and the number is
240 meant to be negative, we have to make sure that we sign
243 return (bfd_vma) (bfd_signed_vma) (long) ul;
247 /* Note that even though strtoul overflowed, it should have set *pp
248 to the end of the number, which is where we want it. */
249 if (sizeof (bfd_vma) > sizeof (unsigned long))
254 bfd_vma over, lastdig;
255 bfd_boolean overflow;
258 /* Our own version of strtoul, for a bfd_vma. */
273 if (p[1] == 'x' || p[1] == 'X')
285 over = ((bfd_vma) (bfd_signed_vma) -1) / (bfd_vma) base;
286 lastdig = ((bfd_vma) (bfd_signed_vma) -1) % (bfd_vma) base;
297 else if (ISUPPER (d))
299 else if (ISLOWER (d))
307 if (v > over || (v == over && (bfd_vma) d > lastdig))
322 /* If we get here, the number is too large to represent in a
324 if (poverflow != NULL)
327 warn_stab (orig, _("numeric overflow"));
332 /* Give an error for a bad stab string. */
335 bad_stab (const char *p)
337 fprintf (stderr, _("Bad stab: %s\n"), p);
340 /* Warn about something in a stab string. */
343 warn_stab (const char *p, const char *err)
345 fprintf (stderr, _("Warning: %s: %s\n"), err, p);
348 /* Create a handle to parse stabs symbols with. */
351 start_stab (void *dhandle ATTRIBUTE_UNUSED, bfd *abfd, bfd_boolean sections,
352 asymbol **syms, long symcount)
354 struct stab_handle *ret;
356 ret = (struct stab_handle *) xmalloc (sizeof *ret);
357 memset (ret, 0, sizeof *ret);
359 ret->sections = sections;
361 ret->symcount = symcount;
363 ret->file_types = (struct stab_types **) xmalloc (sizeof *ret->file_types);
364 ret->file_types[0] = NULL;
365 ret->function_end = (bfd_vma) -1;
369 /* When we have processed all the stabs information, we need to go
370 through and fill in all the undefined tags. */
373 finish_stab (void *dhandle, void *handle)
375 struct stab_handle *info = (struct stab_handle *) handle;
378 if (info->within_function)
380 if (! stab_emit_pending_vars (dhandle, info)
381 || ! debug_end_function (dhandle, info->function_end))
383 info->within_function = FALSE;
384 info->function_end = (bfd_vma) -1;
387 for (st = info->tags; st != NULL; st = st->next)
389 enum debug_type_kind kind;
392 if (kind == DEBUG_KIND_ILLEGAL)
393 kind = DEBUG_KIND_STRUCT;
394 st->slot = debug_make_undefined_tagged_type (dhandle, st->name, kind);
395 if (st->slot == DEBUG_TYPE_NULL)
402 /* Handle a single stabs symbol. */
405 parse_stab (void *dhandle, void *handle, int type, int desc, bfd_vma value,
408 struct stab_handle *info = (struct stab_handle *) handle;
410 /* gcc will emit two N_SO strings per compilation unit, one for the
411 directory name and one for the file name. We just collect N_SO
412 strings as we see them, and start the new compilation unit when
413 we see a non N_SO symbol. */
414 if (info->so_string != NULL
415 && (type != N_SO || *string == '\0' || value != info->so_value))
417 if (! debug_set_filename (dhandle, info->so_string))
419 info->main_filename = info->so_string;
421 info->gcc_compiled = 0;
422 info->n_opt_found = FALSE;
424 /* Generally, for stabs in the symbol table, the N_LBRAC and
425 N_RBRAC symbols are relative to the N_SO symbol value. */
426 if (! info->sections)
427 info->file_start_offset = info->so_value;
429 /* We need to reset the mapping from type numbers to types. We
430 can't free the old mapping, because of the use of
431 debug_make_indirect_type. */
433 info->file_types = ((struct stab_types **)
434 xmalloc (sizeof *info->file_types));
435 info->file_types[0] = NULL;
437 info->so_string = NULL;
439 /* Now process whatever type we just got. */
449 /* Ignore extra outermost context from SunPRO cc and acc. */
450 if (info->n_opt_found && desc == 1)
453 if (! info->within_function)
455 fprintf (stderr, _("N_LBRAC not within function\n"));
459 /* Start an inner lexical block. */
460 if (! debug_start_block (dhandle,
462 + info->file_start_offset
463 + info->function_start_offset)))
466 /* Emit any pending variable definitions. */
467 if (! stab_emit_pending_vars (dhandle, info))
474 /* Ignore extra outermost context from SunPRO cc and acc. */
475 if (info->n_opt_found && desc == 1)
478 /* We shouldn't have any pending variable definitions here, but,
479 if we do, we probably need to emit them before closing the
481 if (! stab_emit_pending_vars (dhandle, info))
484 /* End an inner lexical block. */
485 if (! debug_end_block (dhandle,
487 + info->file_start_offset
488 + info->function_start_offset)))
492 if (info->block_depth < 0)
494 fprintf (stderr, _("Too many N_RBRACs\n"));
500 /* This always ends a function. */
501 if (info->within_function)
507 && info->function_end != (bfd_vma) -1
508 && info->function_end < endval)
509 endval = info->function_end;
510 if (! stab_emit_pending_vars (dhandle, info)
511 || ! debug_end_function (dhandle, endval))
513 info->within_function = FALSE;
514 info->function_end = (bfd_vma) -1;
517 /* An empty string is emitted by gcc at the end of a compilation
522 /* Just accumulate strings until we see a non N_SO symbol. If
523 the string starts with a directory separator or some other
524 form of absolute path specification, we discard the previously
525 accumulated strings. */
526 if (info->so_string == NULL)
527 info->so_string = xstrdup (string);
534 if (IS_ABSOLUTE_PATH (string))
535 info->so_string = xstrdup (string);
537 info->so_string = concat (info->so_string, string,
538 (const char *) NULL);
542 info->so_value = value;
547 /* Start an include file. */
548 if (! debug_start_source (dhandle, string))
553 /* Start an include file which may be replaced. */
554 push_bincl (info, string, value);
555 if (! debug_start_source (dhandle, string))
560 /* End an N_BINCL include. */
561 if (! debug_start_source (dhandle, pop_bincl (info)))
566 /* This is a duplicate of a header file named by N_BINCL which
567 was eliminated by the linker. */
568 if (! find_excl (info, string, value))
573 if (! debug_record_line (dhandle, desc,
574 value + (info->within_function
575 ? info->function_start_offset : 0)))
580 if (! debug_start_common_block (dhandle, string))
585 if (! debug_end_common_block (dhandle, string))
592 if (info->within_function)
594 /* This always marks the end of a function; we don't
595 need to worry about info->function_end. */
597 value += info->function_start_offset;
598 if (! stab_emit_pending_vars (dhandle, info)
599 || ! debug_end_function (dhandle, value))
601 info->within_function = FALSE;
602 info->function_end = (bfd_vma) -1;
607 /* A const static symbol in the .text section will have an N_FUN
608 entry. We need to use these to mark the end of the function,
609 in case we are looking at gcc output before it was changed to
610 always emit an empty N_FUN. We can't call debug_end_function
611 here, because it might be a local static symbol. */
612 if (info->within_function
613 && (info->function_end == (bfd_vma) -1
614 || value < info->function_end))
615 info->function_end = value;
618 /* FIXME: gdb checks the string for N_STSYM, N_LCSYM or N_ROSYM
619 symbols, and if it does not start with :S, gdb relocates the
620 value to the start of the section. gcc always seems to use
621 :S, so we don't worry about this. */
627 colon = strchr (string, ':');
629 && (colon[1] == 'f' || colon[1] == 'F'))
631 if (info->within_function)
636 if (info->function_end != (bfd_vma) -1
637 && info->function_end < endval)
638 endval = info->function_end;
639 if (! stab_emit_pending_vars (dhandle, info)
640 || ! debug_end_function (dhandle, endval))
642 info->function_end = (bfd_vma) -1;
644 /* For stabs in sections, line numbers and block addresses
645 are offsets from the start of the function. */
647 info->function_start_offset = value;
648 info->within_function = TRUE;
651 if (! parse_stab_string (dhandle, info, type, desc, value, string))
657 if (string != NULL && strcmp (string, "gcc2_compiled.") == 0)
658 info->gcc_compiled = 2;
659 else if (string != NULL && strcmp (string, "gcc_compiled.") == 0)
660 info->gcc_compiled = 1;
662 info->n_opt_found = TRUE;
675 /* Parse the stabs string. */
678 parse_stab_string (void *dhandle, struct stab_handle *info, int stabtype,
679 int desc ATTRIBUTE_UNUSED, bfd_vma value, const char *string)
686 bfd_boolean self_crossref;
689 p = strchr (string, ':');
704 /* FIXME: Sometimes the special C++ names start with '.'. */
706 if (string[0] == '$')
714 /* Was: name = "vptr"; */
720 /* This was an anonymous type that was never fixed up. */
723 /* SunPRO (3.0 at least) static variable encoding. */
726 warn_stab (string, _("unknown C++ encoded name"));
733 if (p == string || (string[0] == ' ' && p == string + 1))
736 name = savestring (string, p - string);
740 if (ISDIGIT (*p) || *p == '(' || *p == '-')
748 /* c is a special case, not followed by a type-number.
749 SYMBOL:c=iVALUE for an integer constant symbol.
750 SYMBOL:c=rVALUE for a floating constant symbol.
751 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
752 e.g. "b:c=e6,0" for "const b = blob1"
753 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
763 /* Floating point constant. */
764 if (! debug_record_float_const (dhandle, name, atof (p)))
768 /* Integer constant. */
769 /* Defining integer constants this way is kind of silly,
770 since 'e' constants allows the compiler to give not only
771 the value, but the type as well. C has at least int,
772 long, unsigned int, and long long as constant types;
773 other languages probably should have at least unsigned as
774 well as signed constants. */
775 if (! debug_record_int_const (dhandle, name, atoi (p)))
779 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
780 can be represented as integral.
781 e.g. "b:c=e6,0" for "const b = blob1"
782 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
783 dtype = parse_stab_type (dhandle, info, (const char *) NULL,
784 &p, (debug_type **) NULL);
785 if (dtype == DEBUG_TYPE_NULL)
792 if (! debug_record_typed_const (dhandle, name, dtype, atoi (p)))
803 /* The name of a caught exception. */
804 dtype = parse_stab_type (dhandle, info, (const char *) NULL,
805 &p, (debug_type **) NULL);
806 if (dtype == DEBUG_TYPE_NULL)
808 if (! debug_record_label (dhandle, name, dtype, value))
814 /* A function definition. */
815 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
816 (debug_type **) NULL);
817 if (dtype == DEBUG_TYPE_NULL)
819 if (! debug_record_function (dhandle, name, dtype, type == 'F', value))
822 /* Sun acc puts declared types of arguments here. We don't care
823 about their actual types (FIXME -- we should remember the whole
824 function prototype), but the list may define some new types
825 that we have to remember, so we must scan it now. */
829 if (parse_stab_type (dhandle, info, (const char *) NULL, &p,
830 (debug_type **) NULL)
843 /* A global symbol. The value must be extracted from the
845 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
846 (debug_type **) NULL);
847 if (dtype == DEBUG_TYPE_NULL)
849 leading = bfd_get_symbol_leading_char (info->abfd);
850 for (c = info->symcount, ps = info->syms; c > 0; --c, ++ps)
854 n = bfd_asymbol_name (*ps);
855 if (leading != '\0' && *n == leading)
857 if (*n == *name && strcmp (n, name) == 0)
861 value = bfd_asymbol_value (*ps);
862 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_GLOBAL,
868 /* This case is faked by a conditional above, when there is no
869 code letter in the dbx data. Dbx data never actually
873 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
874 (debug_type **) NULL);
875 if (dtype == DEBUG_TYPE_NULL)
877 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL,
883 /* A function parameter. */
885 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
886 (debug_type **) NULL);
889 /* pF is a two-letter code that means a function parameter in
890 Fortran. The type-number specifies the type of the return
891 value. Translate it into a pointer-to-function type. */
893 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
894 (debug_type **) NULL);
895 if (dtype != DEBUG_TYPE_NULL)
899 ftype = debug_make_function_type (dhandle, dtype,
900 (debug_type *) NULL, FALSE);
901 dtype = debug_make_pointer_type (dhandle, ftype);
904 if (dtype == DEBUG_TYPE_NULL)
906 if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_STACK,
910 /* FIXME: At this point gdb considers rearranging the parameter
911 address on a big endian machine if it is smaller than an int.
912 We have no way to do that, since we don't really know much
917 if (stabtype == N_FUN)
919 /* Prototype of a function referenced by this file. */
923 if (parse_stab_type (dhandle, info, (const char *) NULL, &p,
924 (debug_type **) NULL)
932 /* Parameter which is in a register. */
933 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
934 (debug_type **) NULL);
935 if (dtype == DEBUG_TYPE_NULL)
937 if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REG,
943 /* Register variable (either global or local). */
944 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
945 (debug_type **) NULL);
946 if (dtype == DEBUG_TYPE_NULL)
948 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_REGISTER,
952 /* FIXME: At this point gdb checks to combine pairs of 'p' and
953 'r' stabs into a single 'P' stab. */
957 /* Static symbol at top level of file. */
958 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
959 (debug_type **) NULL);
960 if (dtype == DEBUG_TYPE_NULL)
962 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_STATIC,
969 dtype = parse_stab_type (dhandle, info, name, &p, &slot);
970 if (dtype == DEBUG_TYPE_NULL)
974 /* A nameless type. Nothing to do. */
978 dtype = debug_name_type (dhandle, name, dtype);
979 if (dtype == DEBUG_TYPE_NULL)
988 /* Struct, union, or enum tag. For GNU C++, this can be be followed
989 by 't' which means we are typedef'ing it as well. */
993 /* FIXME: gdb sets synonym to TRUE if the current language
1002 dtype = parse_stab_type (dhandle, info, name, &p, &slot);
1003 if (dtype == DEBUG_TYPE_NULL)
1008 /* INFO->SELF_CROSSREF is set by parse_stab_type if this type is
1009 a cross reference to itself. These are generated by some
1011 self_crossref = info->self_crossref;
1013 dtype = debug_tag_type (dhandle, name, dtype);
1014 if (dtype == DEBUG_TYPE_NULL)
1019 /* See if we have a cross reference to this tag which we can now
1020 fill in. Avoid filling in a cross reference to ourselves,
1021 because that would lead to circular debugging information. */
1022 if (! self_crossref)
1024 register struct stab_tag **pst;
1026 for (pst = &info->tags; *pst != NULL; pst = &(*pst)->next)
1028 if ((*pst)->name[0] == name[0]
1029 && strcmp ((*pst)->name, name) == 0)
1031 (*pst)->slot = dtype;
1032 *pst = (*pst)->next;
1040 dtype = debug_name_type (dhandle, name, dtype);
1041 if (dtype == DEBUG_TYPE_NULL)
1051 /* Static symbol of local scope */
1052 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1053 (debug_type **) NULL);
1054 if (dtype == DEBUG_TYPE_NULL)
1056 /* FIXME: gdb checks os9k_stabs here. */
1057 if (! stab_record_variable (dhandle, info, name, dtype,
1058 DEBUG_LOCAL_STATIC, value))
1063 /* Reference parameter. */
1064 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1065 (debug_type **) NULL);
1066 if (dtype == DEBUG_TYPE_NULL)
1068 if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REFERENCE,
1074 /* Reference parameter which is in a register. */
1075 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1076 (debug_type **) NULL);
1077 if (dtype == DEBUG_TYPE_NULL)
1079 if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REF_REG,
1085 /* This is used by Sun FORTRAN for "function result value".
1086 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1087 that Pascal uses it too, but when I tried it Pascal used
1088 "x:3" (local symbol) instead. */
1089 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1090 (debug_type **) NULL);
1091 if (dtype == DEBUG_TYPE_NULL)
1093 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL,
1099 /* SUNPro C++ Namespace =Yn0. */
1100 /* Skip the namespace mapping, as it is not used now. */
1101 if (*(++p) == 'n' && *(++p) == '0')
1109 /* TODO SUNPro C++ support:
1110 Support default arguments after F,P parameters
1111 Ya = Anonymous unions
1112 YM,YD = Pointers to class members
1114 YR = Run-time type information (RTTI) */
1123 /* FIXME: gdb converts structure values to structure pointers in a
1124 couple of cases, depending upon the target. */
1129 /* Parse a stabs type. The typename argument is non-NULL if this is a
1130 typedef or a tag definition. The pp argument points to the stab
1131 string, and is updated. The slotp argument points to a place to
1132 store the slot used if the type is being defined. */
1135 parse_stab_type (void *dhandle, struct stab_handle *info, const char *type_name, const char **pp, debug_type **slotp)
1140 bfd_boolean stringp;
1152 info->self_crossref = FALSE;
1154 /* Read type number if present. The type number may be omitted.
1155 for instance in a two-dimensional array declared with type
1156 "ar1;1;10;ar1;1;10;4". */
1157 if (! ISDIGIT (**pp) && **pp != '(' && **pp != '-')
1159 /* 'typenums=' not present, type is anonymous. Read and return
1160 the definition, but don't put it in the type vector. */
1161 typenums[0] = typenums[1] = -1;
1165 if (! parse_stab_type_number (pp, typenums))
1166 return DEBUG_TYPE_NULL;
1169 /* Type is not being defined here. Either it already
1170 exists, or this is a forward reference to it. */
1171 return stab_find_type (dhandle, info, typenums);
1173 /* Only set the slot if the type is being defined. This means
1174 that the mapping from type numbers to types will only record
1175 the name of the typedef which defines a type. If we don't do
1176 this, then something like
1179 will record that i is of type foo. Unfortunately, stabs
1180 information is ambiguous about variable types. For this code,
1184 the stabs information records both i and j as having the same
1185 type. This could be fixed by patching the compiler. */
1186 if (slotp != NULL && typenums[0] >= 0 && typenums[1] >= 0)
1187 *slotp = stab_find_slot (info, typenums);
1189 /* Type is being defined here. */
1195 const char *p = *pp + 1;
1198 if (ISDIGIT (*p) || *p == '(' || *p == '-')
1202 /* Type attributes. */
1205 for (; *p != ';'; ++p)
1210 return DEBUG_TYPE_NULL;
1218 size = atoi (attr + 1);
1219 size /= 8; /* Size is in bits. We store it in bytes. */
1229 /* Ignore unrecognized type attributes, so future
1230 compilers can invent new ones. */
1243 enum debug_type_kind code;
1244 const char *q1, *q2, *p;
1246 /* A cross reference to another type. */
1250 code = DEBUG_KIND_STRUCT;
1253 code = DEBUG_KIND_UNION;
1256 code = DEBUG_KIND_ENUM;
1259 /* Complain and keep going, so compilers can invent new
1260 cross-reference types. */
1261 warn_stab (orig, _("unrecognized cross reference type"));
1262 code = DEBUG_KIND_STRUCT;
1267 q1 = strchr (*pp, '<');
1268 p = strchr (*pp, ':');
1272 return DEBUG_TYPE_NULL;
1274 if (q1 != NULL && p > q1 && p[1] == ':')
1278 for (q2 = q1; *q2 != '\0'; ++q2)
1282 else if (*q2 == '>')
1284 else if (*q2 == ':' && nest == 0)
1291 return DEBUG_TYPE_NULL;
1295 /* Some versions of g++ can emit stabs like
1297 which define structures in terms of themselves. We need to
1298 tell the caller to avoid building a circular structure. */
1299 if (type_name != NULL
1300 && strncmp (type_name, *pp, p - *pp) == 0
1301 && type_name[p - *pp] == '\0')
1302 info->self_crossref = TRUE;
1304 dtype = stab_find_tagged_type (dhandle, info, *pp, p - *pp, code);
1326 /* This type is defined as another type. */
1330 /* Peek ahead at the number to detect void. */
1331 if (! parse_stab_type_number (pp, xtypenums))
1332 return DEBUG_TYPE_NULL;
1334 if (typenums[0] == xtypenums[0] && typenums[1] == xtypenums[1])
1336 /* This type is being defined as itself, which means that
1338 dtype = debug_make_void_type (dhandle);
1344 /* Go back to the number and have parse_stab_type get it.
1345 This means that we can deal with something like
1346 t(1,2)=(3,4)=... which the Lucid compiler uses. */
1347 dtype = parse_stab_type (dhandle, info, (const char *) NULL,
1348 pp, (debug_type **) NULL);
1349 if (dtype == DEBUG_TYPE_NULL)
1350 return DEBUG_TYPE_NULL;
1353 if (typenums[0] != -1)
1355 if (! stab_record_type (dhandle, info, typenums, dtype))
1356 return DEBUG_TYPE_NULL;
1363 dtype = debug_make_pointer_type (dhandle,
1364 parse_stab_type (dhandle, info,
1365 (const char *) NULL,
1367 (debug_type **) NULL));
1371 /* Reference to another type. */
1372 dtype = (debug_make_reference_type
1374 parse_stab_type (dhandle, info, (const char *) NULL, pp,
1375 (debug_type **) NULL)));
1379 /* Function returning another type. */
1380 /* FIXME: gdb checks os9k_stabs here. */
1381 dtype = (debug_make_function_type
1383 parse_stab_type (dhandle, info, (const char *) NULL, pp,
1384 (debug_type **) NULL),
1385 (debug_type *) NULL, FALSE));
1389 /* Const qualifier on some type (Sun). */
1390 /* FIXME: gdb accepts 'c' here if os9k_stabs. */
1391 dtype = debug_make_const_type (dhandle,
1392 parse_stab_type (dhandle, info,
1393 (const char *) NULL,
1395 (debug_type **) NULL));
1399 /* Volatile qual on some type (Sun). */
1400 /* FIXME: gdb accepts 'i' here if os9k_stabs. */
1401 dtype = (debug_make_volatile_type
1403 parse_stab_type (dhandle, info, (const char *) NULL, pp,
1404 (debug_type **) NULL)));
1408 /* Offset (class & variable) type. This is used for a pointer
1409 relative to an object. */
1416 domain = parse_stab_type (dhandle, info, (const char *) NULL, pp,
1417 (debug_type **) NULL);
1418 if (domain == DEBUG_TYPE_NULL)
1419 return DEBUG_TYPE_NULL;
1424 return DEBUG_TYPE_NULL;
1428 memtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
1429 (debug_type **) NULL);
1430 if (memtype == DEBUG_TYPE_NULL)
1431 return DEBUG_TYPE_NULL;
1433 dtype = debug_make_offset_type (dhandle, domain, memtype);
1438 /* Method (class & fn) type. */
1441 debug_type return_type;
1444 return_type = parse_stab_type (dhandle, info, (const char *) NULL,
1445 pp, (debug_type **) NULL);
1446 if (return_type == DEBUG_TYPE_NULL)
1447 return DEBUG_TYPE_NULL;
1451 return DEBUG_TYPE_NULL;
1454 dtype = debug_make_method_type (dhandle, return_type,
1456 (debug_type *) NULL, FALSE);
1461 debug_type return_type;
1465 bfd_boolean varargs;
1467 domain = parse_stab_type (dhandle, info, (const char *) NULL,
1468 pp, (debug_type **) NULL);
1469 if (domain == DEBUG_TYPE_NULL)
1470 return DEBUG_TYPE_NULL;
1475 return DEBUG_TYPE_NULL;
1479 return_type = parse_stab_type (dhandle, info, (const char *) NULL,
1480 pp, (debug_type **) NULL);
1481 if (return_type == DEBUG_TYPE_NULL)
1482 return DEBUG_TYPE_NULL;
1485 args = (debug_type *) xmalloc (alloc * sizeof *args);
1492 return DEBUG_TYPE_NULL;
1499 args = ((debug_type *)
1500 xrealloc (args, alloc * sizeof *args));
1503 args[n] = parse_stab_type (dhandle, info, (const char *) NULL,
1504 pp, (debug_type **) NULL);
1505 if (args[n] == DEBUG_TYPE_NULL)
1506 return DEBUG_TYPE_NULL;
1511 /* If the last type is not void, then this function takes a
1512 variable number of arguments. Otherwise, we must strip
1515 || debug_get_type_kind (dhandle, args[n - 1]) != DEBUG_KIND_VOID)
1523 args[n] = DEBUG_TYPE_NULL;
1525 dtype = debug_make_method_type (dhandle, return_type, domain, args,
1532 dtype = parse_stab_range_type (dhandle, info, type_name, pp, typenums);
1536 /* FIXME: gdb checks os9k_stabs here. */
1537 /* Sun ACC builtin int type. */
1538 dtype = parse_stab_sun_builtin_type (dhandle, pp);
1542 /* Sun ACC builtin float type. */
1543 dtype = parse_stab_sun_floating_type (dhandle, pp);
1547 /* Enumeration type. */
1548 dtype = parse_stab_enum_type (dhandle, pp);
1553 /* Struct or union type. */
1554 dtype = parse_stab_struct_type (dhandle, info, type_name, pp,
1555 descriptor == 's', typenums);
1563 return DEBUG_TYPE_NULL;
1567 dtype = parse_stab_array_type (dhandle, info, pp, stringp);
1571 dtype = debug_make_set_type (dhandle,
1572 parse_stab_type (dhandle, info,
1573 (const char *) NULL,
1575 (debug_type **) NULL),
1581 return DEBUG_TYPE_NULL;
1584 if (dtype == DEBUG_TYPE_NULL)
1585 return DEBUG_TYPE_NULL;
1587 if (typenums[0] != -1)
1589 if (! stab_record_type (dhandle, info, typenums, dtype))
1590 return DEBUG_TYPE_NULL;
1595 if (! debug_record_type_size (dhandle, dtype, (unsigned int) size))
1596 return DEBUG_TYPE_NULL;
1602 /* Read a number by which a type is referred to in dbx data, or
1603 perhaps read a pair (FILENUM, TYPENUM) in parentheses. Just a
1604 single number N is equivalent to (0,N). Return the two numbers by
1605 storing them in the vector TYPENUMS. */
1608 parse_stab_type_number (const char **pp, int *typenums)
1617 typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL);
1622 typenums[0] = (int) parse_number (pp, (bfd_boolean *) NULL);
1629 typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL);
1641 /* Parse a range type. */
1644 parse_stab_range_type (void *dhandle, struct stab_handle *info, const char *type_name, const char **pp, const int *typenums)
1648 bfd_boolean self_subrange;
1649 debug_type index_type;
1650 const char *s2, *s3;
1651 bfd_signed_vma n2, n3;
1652 bfd_boolean ov2, ov3;
1656 index_type = DEBUG_TYPE_NULL;
1658 /* First comes a type we are a subrange of.
1659 In C it is usually 0, 1 or the type being defined. */
1660 if (! parse_stab_type_number (pp, rangenums))
1661 return DEBUG_TYPE_NULL;
1663 self_subrange = (rangenums[0] == typenums[0]
1664 && rangenums[1] == typenums[1]);
1669 index_type = parse_stab_type (dhandle, info, (const char *) NULL,
1670 pp, (debug_type **) NULL);
1671 if (index_type == DEBUG_TYPE_NULL)
1672 return DEBUG_TYPE_NULL;
1678 /* The remaining two operands are usually lower and upper bounds of
1679 the range. But in some special cases they mean something else. */
1681 n2 = parse_number (pp, &ov2);
1685 return DEBUG_TYPE_NULL;
1690 n3 = parse_number (pp, &ov3);
1694 return DEBUG_TYPE_NULL;
1700 /* gcc will emit range stabs for long long types. Handle this
1701 as a special case. FIXME: This needs to be more general. */
1702 #define LLLOW "01000000000000000000000;"
1703 #define LLHIGH "0777777777777777777777;"
1704 #define ULLHIGH "01777777777777777777777;"
1705 if (index_type == DEBUG_TYPE_NULL)
1707 if (CONST_STRNEQ (s2, LLLOW)
1708 && CONST_STRNEQ (s3, LLHIGH))
1709 return debug_make_int_type (dhandle, 8, FALSE);
1712 && CONST_STRNEQ (s3, ULLHIGH))
1713 return debug_make_int_type (dhandle, 8, TRUE);
1716 warn_stab (orig, _("numeric overflow"));
1719 if (index_type == DEBUG_TYPE_NULL)
1721 /* A type defined as a subrange of itself, with both bounds 0,
1723 if (self_subrange && n2 == 0 && n3 == 0)
1724 return debug_make_void_type (dhandle);
1726 /* A type defined as a subrange of itself, with n2 positive and
1727 n3 zero, is a complex type, and n2 is the number of bytes. */
1728 if (self_subrange && n3 == 0 && n2 > 0)
1729 return debug_make_complex_type (dhandle, n2);
1731 /* If n3 is zero and n2 is positive, this is a floating point
1732 type, and n2 is the number of bytes. */
1733 if (n3 == 0 && n2 > 0)
1734 return debug_make_float_type (dhandle, n2);
1736 /* If the upper bound is -1, this is an unsigned int. */
1737 if (n2 == 0 && n3 == -1)
1739 /* When gcc is used with -gstabs, but not -gstabs+, it will emit
1740 long long int:t6=r1;0;-1;
1741 long long unsigned int:t7=r1;0;-1;
1742 We hack here to handle this reasonably. */
1743 if (type_name != NULL)
1745 if (strcmp (type_name, "long long int") == 0)
1746 return debug_make_int_type (dhandle, 8, FALSE);
1747 else if (strcmp (type_name, "long long unsigned int") == 0)
1748 return debug_make_int_type (dhandle, 8, TRUE);
1750 /* FIXME: The size here really depends upon the target. */
1751 return debug_make_int_type (dhandle, 4, TRUE);
1754 /* A range of 0 to 127 is char. */
1755 if (self_subrange && n2 == 0 && n3 == 127)
1756 return debug_make_int_type (dhandle, 1, FALSE);
1758 /* FIXME: gdb checks for the language CHILL here. */
1763 return debug_make_int_type (dhandle, - n3, TRUE);
1764 else if (n3 == 0xff)
1765 return debug_make_int_type (dhandle, 1, TRUE);
1766 else if (n3 == 0xffff)
1767 return debug_make_int_type (dhandle, 2, TRUE);
1768 else if (n3 == (bfd_signed_vma) 0xffffffff)
1769 return debug_make_int_type (dhandle, 4, TRUE);
1771 else if (n3 == ((((bfd_signed_vma) 0xffffffff) << 32) | 0xffffffff))
1772 return debug_make_int_type (dhandle, 8, TRUE);
1777 && (self_subrange || n2 == -8))
1778 return debug_make_int_type (dhandle, - n2, TRUE);
1779 else if (n2 == - n3 - 1 || n2 == n3 + 1)
1782 return debug_make_int_type (dhandle, 1, FALSE);
1783 else if (n3 == 0x7fff)
1784 return debug_make_int_type (dhandle, 2, FALSE);
1785 else if (n3 == 0x7fffffff)
1786 return debug_make_int_type (dhandle, 4, FALSE);
1788 else if (n3 == ((((bfd_vma) 0x7fffffff) << 32) | 0xffffffff))
1789 return debug_make_int_type (dhandle, 8, FALSE);
1794 /* At this point I don't have the faintest idea how to deal with a
1795 self_subrange type; I'm going to assume that this is used as an
1796 idiom, and that all of them are special cases. So . . . */
1800 return DEBUG_TYPE_NULL;
1803 index_type = stab_find_type (dhandle, info, rangenums);
1804 if (index_type == DEBUG_TYPE_NULL)
1806 /* Does this actually ever happen? Is that why we are worrying
1807 about dealing with it rather than just calling error_type? */
1808 warn_stab (orig, _("missing index type"));
1809 index_type = debug_make_int_type (dhandle, 4, FALSE);
1812 return debug_make_range_type (dhandle, index_type, n2, n3);
1815 /* Sun's ACC uses a somewhat saner method for specifying the builtin
1816 typedefs in every file (for int, long, etc):
1818 type = b <signed> <width>; <offset>; <nbits>
1819 signed = u or s. Possible c in addition to u or s (for char?).
1820 offset = offset from high order bit to start bit of type.
1821 width is # bytes in object of this type, nbits is # bits in type.
1823 The width/offset stuff appears to be for small objects stored in
1824 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
1828 parse_stab_sun_builtin_type (void *dhandle, const char **pp)
1831 bfd_boolean unsignedp;
1846 return DEBUG_TYPE_NULL;
1850 /* OpenSolaris source code indicates that one of "cbv" characters
1851 can come next and specify the intrinsic 'iformat' encoding.
1852 'c' is character encoding, 'b' is boolean encoding, and 'v' is
1853 varargs encoding. This field can be safely ignored because
1854 the type of the field is determined from the bitwidth extracted
1856 if (**pp == 'c' || **pp == 'b' || **pp == 'v')
1859 /* The first number appears to be the number of bytes occupied
1860 by this type, except that unsigned short is 4 instead of 2.
1861 Since this information is redundant with the third number,
1862 we will ignore it. */
1863 (void) parse_number (pp, (bfd_boolean *) NULL);
1867 return DEBUG_TYPE_NULL;
1871 /* The second number is always 0, so ignore it too. */
1872 (void) parse_number (pp, (bfd_boolean *) NULL);
1876 return DEBUG_TYPE_NULL;
1880 /* The third number is the number of bits for this type. */
1881 bits = parse_number (pp, (bfd_boolean *) NULL);
1883 /* The type *should* end with a semicolon. If it are embedded
1884 in a larger type the semicolon may be the only way to know where
1885 the type ends. If this type is at the end of the stabstring we
1886 can deal with the omitted semicolon (but we don't have to like
1887 it). Don't bother to complain(), Sun's compiler omits the semicolon
1893 return debug_make_void_type (dhandle);
1895 return debug_make_int_type (dhandle, bits / 8, unsignedp);
1898 /* Parse a builtin floating type generated by the Sun compiler. */
1901 parse_stab_sun_floating_type (void *dhandle, const char **pp)
1909 /* The first number has more details about the type, for example
1911 details = parse_number (pp, (bfd_boolean *) NULL);
1915 return DEBUG_TYPE_NULL;
1918 /* The second number is the number of bytes occupied by this type */
1919 bytes = parse_number (pp, (bfd_boolean *) NULL);
1923 return DEBUG_TYPE_NULL;
1926 if (details == NF_COMPLEX
1927 || details == NF_COMPLEX16
1928 || details == NF_COMPLEX32)
1929 return debug_make_complex_type (dhandle, bytes);
1931 return debug_make_float_type (dhandle, bytes);
1934 /* Handle an enum type. */
1937 parse_stab_enum_type (void *dhandle, const char **pp)
1941 bfd_signed_vma *values;
1947 /* FIXME: gdb checks os9k_stabs here. */
1949 /* The aix4 compiler emits an extra field before the enum members;
1950 my guess is it's a type of some sort. Just ignore it. */
1958 /* Read the value-names and their values.
1959 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
1960 A semicolon or comma instead of a NAME means the end. */
1962 names = (const char **) xmalloc (alloc * sizeof *names);
1963 values = (bfd_signed_vma *) xmalloc (alloc * sizeof *values);
1965 while (**pp != '\0' && **pp != ';' && **pp != ',')
1975 name = savestring (*pp, p - *pp);
1978 val = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
1985 return DEBUG_TYPE_NULL;
1992 names = ((const char **)
1993 xrealloc (names, alloc * sizeof *names));
1994 values = ((bfd_signed_vma *)
1995 xrealloc (values, alloc * sizeof *values));
2009 return debug_make_enum_type (dhandle, names, values);
2012 /* Read the description of a structure (or union type) and return an object
2013 describing the type.
2015 PP points to a character pointer that points to the next unconsumed token
2016 in the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
2017 *PP will point to "4a:1,0,32;;". */
2020 parse_stab_struct_type (void *dhandle, struct stab_handle *info,
2021 const char *tagname, const char **pp,
2022 bfd_boolean structp, const int *typenums)
2025 debug_baseclass *baseclasses;
2026 debug_field *fields = NULL;
2027 bfd_boolean statics;
2028 debug_method *methods;
2029 debug_type vptrbase;
2030 bfd_boolean ownvptr;
2033 size = parse_number (pp, (bfd_boolean *) NULL);
2035 /* Get the other information. */
2036 if (! parse_stab_baseclasses (dhandle, info, pp, &baseclasses)
2037 || ! parse_stab_struct_fields (dhandle, info, pp, &fields, &statics)
2038 || ! parse_stab_members (dhandle, info, tagname, pp, typenums, &methods)
2039 || ! parse_stab_tilde_field (dhandle, info, pp, typenums, &vptrbase,
2044 return DEBUG_TYPE_NULL;
2048 && baseclasses == NULL
2050 && vptrbase == DEBUG_TYPE_NULL
2052 return debug_make_struct_type (dhandle, structp, size, fields);
2054 return debug_make_object_type (dhandle, structp, size, fields, baseclasses,
2055 methods, vptrbase, ownvptr);
2058 /* The stabs for C++ derived classes contain baseclass information which
2059 is marked by a '!' character after the total size. This function is
2060 called when we encounter the baseclass marker, and slurps up all the
2061 baseclass information.
2063 Immediately following the '!' marker is the number of base classes that
2064 the class is derived from, followed by information for each base class.
2065 For each base class, there are two visibility specifiers, a bit offset
2066 to the base class information within the derived class, a reference to
2067 the type for the base class, and a terminating semicolon.
2069 A typical example, with two base classes, would be "!2,020,19;0264,21;".
2071 Baseclass information marker __________________|| | | | | | |
2072 Number of baseclasses __________________________| | | | | | |
2073 Visibility specifiers (2) ________________________| | | | | |
2074 Offset in bits from start of class _________________| | | | |
2075 Type number for base class ___________________________| | | |
2076 Visibility specifiers (2) _______________________________| | |
2077 Offset in bits from start of class ________________________| |
2078 Type number of base class ____________________________________|
2080 Return TRUE for success, FALSE for failure. */
2083 parse_stab_baseclasses (void *dhandle, struct stab_handle *info,
2084 const char **pp, debug_baseclass **retp)
2088 debug_baseclass *classes;
2096 /* No base classes. */
2101 c = (unsigned int) parse_number (pp, (bfd_boolean *) NULL);
2110 classes = (debug_baseclass *) xmalloc ((c + 1) * sizeof (**retp));
2112 for (i = 0; i < c; i++)
2114 bfd_boolean is_virtual;
2115 enum debug_visibility visibility;
2128 warn_stab (orig, _("unknown virtual character for baseclass"));
2137 visibility = DEBUG_VISIBILITY_PRIVATE;
2140 visibility = DEBUG_VISIBILITY_PROTECTED;
2143 visibility = DEBUG_VISIBILITY_PUBLIC;
2146 warn_stab (orig, _("unknown visibility character for baseclass"));
2147 visibility = DEBUG_VISIBILITY_PUBLIC;
2152 /* The remaining value is the bit offset of the portion of the
2153 object corresponding to this baseclass. Always zero in the
2154 absence of multiple inheritance. */
2155 bitpos = parse_number (pp, (bfd_boolean *) NULL);
2163 type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2164 (debug_type **) NULL);
2165 if (type == DEBUG_TYPE_NULL)
2168 classes[i] = debug_make_baseclass (dhandle, type, bitpos, is_virtual,
2170 if (classes[i] == DEBUG_BASECLASS_NULL)
2178 classes[i] = DEBUG_BASECLASS_NULL;
2185 /* Read struct or class data fields. They have the form:
2187 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2189 At the end, we see a semicolon instead of a field.
2191 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2194 The optional VISIBILITY is one of:
2196 '/0' (VISIBILITY_PRIVATE)
2197 '/1' (VISIBILITY_PROTECTED)
2198 '/2' (VISIBILITY_PUBLIC)
2199 '/9' (VISIBILITY_IGNORE)
2201 or nothing, for C style fields with public visibility.
2203 Returns 1 for success, 0 for failure. */
2206 parse_stab_struct_fields (void *dhandle, struct stab_handle *info,
2207 const char **pp, debug_field **retp,
2208 bfd_boolean *staticsp)
2212 debug_field *fields;
2223 fields = (debug_field *) xmalloc (alloc * sizeof *fields);
2226 /* FIXME: gdb checks os9k_stabs here. */
2230 /* Add 1 to c to leave room for NULL pointer at end. */
2234 fields = ((debug_field *)
2235 xrealloc (fields, alloc * sizeof *fields));
2238 /* If it starts with CPLUS_MARKER it is a special abbreviation,
2239 unless the CPLUS_MARKER is followed by an underscore, in
2240 which case it is just the name of an anonymous type, which we
2241 should handle like any other type name. We accept either '$'
2242 or '.', because a field name can never contain one of these
2243 characters except as a CPLUS_MARKER. */
2245 if ((*p == '$' || *p == '.') && p[1] != '_')
2248 if (! parse_stab_cpp_abbrev (dhandle, info, pp, fields + c))
2257 /* Look for the ':' that separates the field name from the field
2258 values. Data members are delimited by a single ':', while member
2259 functions are delimited by a pair of ':'s. When we hit the member
2260 functions (if any), terminate scan loop and return. */
2262 p = strchr (p, ':');
2273 if (! parse_stab_one_struct_field (dhandle, info, pp, p, fields + c,
2280 fields[c] = DEBUG_FIELD_NULL;
2287 /* Special GNU C++ name. */
2290 parse_stab_cpp_abbrev (void *dhandle, struct stab_handle *info,
2291 const char **pp, debug_field *retp)
2297 const char *type_name;
2301 *retp = DEBUG_FIELD_NULL;
2315 /* At this point, *pp points to something like "22:23=*22...", where
2316 the type number before the ':' is the "context" and everything
2317 after is a regular type definition. Lookup the type, find it's
2318 name, and construct the field name. */
2320 context = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2321 (debug_type **) NULL);
2322 if (context == DEBUG_TYPE_NULL)
2328 /* $vf -- a virtual function table pointer. */
2332 /* $vb -- a virtual bsomethingorother */
2333 type_name = debug_get_type_name (dhandle, context);
2334 if (type_name == NULL)
2336 warn_stab (orig, _("unnamed $vb type"));
2339 name = concat ("_vb$", type_name, (const char *) NULL);
2342 warn_stab (orig, _("unrecognized C++ abbreviation"));
2343 name = "INVALID_CPLUSPLUS_ABBREV";
2354 type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2355 (debug_type **) NULL);
2363 bitpos = parse_number (pp, (bfd_boolean *) NULL);
2371 *retp = debug_make_field (dhandle, name, type, bitpos, 0,
2372 DEBUG_VISIBILITY_PRIVATE);
2373 if (*retp == DEBUG_FIELD_NULL)
2379 /* Parse a single field in a struct or union. */
2382 parse_stab_one_struct_field (void *dhandle, struct stab_handle *info,
2383 const char **pp, const char *p,
2384 debug_field *retp, bfd_boolean *staticsp)
2388 enum debug_visibility visibility;
2395 /* FIXME: gdb checks ARM_DEMANGLING here. */
2397 name = savestring (*pp, p - *pp);
2402 visibility = DEBUG_VISIBILITY_PUBLIC;
2409 visibility = DEBUG_VISIBILITY_PRIVATE;
2412 visibility = DEBUG_VISIBILITY_PROTECTED;
2415 visibility = DEBUG_VISIBILITY_PUBLIC;
2418 warn_stab (orig, _("unknown visibility character for field"));
2419 visibility = DEBUG_VISIBILITY_PUBLIC;
2425 type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2426 (debug_type **) NULL);
2427 if (type == DEBUG_TYPE_NULL)
2437 /* This is a static class member. */
2439 p = strchr (*pp, ';');
2447 varname = savestring (*pp, p - *pp);
2451 *retp = debug_make_static_member (dhandle, name, type, varname,
2466 bitpos = parse_number (pp, (bfd_boolean *) NULL);
2475 bitsize = parse_number (pp, (bfd_boolean *) NULL);
2484 if (bitpos == 0 && bitsize == 0)
2486 /* This can happen in two cases: (1) at least for gcc 2.4.5 or
2487 so, it is a field which has been optimized out. The correct
2488 stab for this case is to use VISIBILITY_IGNORE, but that is a
2489 recent invention. (2) It is a 0-size array. For example
2490 union { int num; char str[0]; } foo. Printing "<no value>"
2491 for str in "p foo" is OK, since foo.str (and thus foo.str[3])
2492 will continue to work, and a 0-size array as a whole doesn't
2493 have any contents to print.
2495 I suspect this probably could also happen with gcc -gstabs
2496 (not -gstabs+) for static fields, and perhaps other C++
2497 extensions. Hopefully few people use -gstabs with gdb, since
2498 it is intended for dbx compatibility. */
2499 visibility = DEBUG_VISIBILITY_IGNORE;
2502 /* FIXME: gdb does some stuff here to mark fields as unpacked. */
2504 *retp = debug_make_field (dhandle, name, type, bitpos, bitsize, visibility);
2509 /* Read member function stabs info for C++ classes. The form of each member
2512 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2514 An example with two member functions is:
2516 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2518 For the case of overloaded operators, the format is op$::*.funcs, where
2519 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2520 name (such as `+=') and `.' marks the end of the operator name. */
2523 parse_stab_members (void *dhandle, struct stab_handle *info,
2524 const char *tagname, const char **pp,
2525 const int *typenums, debug_method **retp)
2528 debug_method *methods;
2532 debug_method_variant *variants = NULL;
2533 char *argtypes = NULL;
2547 unsigned int allocvars;
2548 debug_type look_ahead_type;
2550 p = strchr (*pp, ':');
2551 if (p == NULL || p[1] != ':')
2554 /* FIXME: Some systems use something other than '$' here. */
2555 if ((*pp)[0] != 'o' || (*pp)[1] != 'p' || (*pp)[2] != '$')
2557 name = savestring (*pp, p - *pp);
2562 /* This is a completely weird case. In order to stuff in the
2563 names that might contain colons (the usual name delimiter),
2564 Mike Tiemann defined a different name format which is
2565 signalled if the identifier is "op$". In that case, the
2566 format is "op$::XXXX." where XXXX is the name. This is
2567 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2569 for (p = *pp; *p != '.' && *p != '\0'; p++)
2576 name = savestring (*pp, p - *pp);
2581 variants = ((debug_method_variant *)
2582 xmalloc (allocvars * sizeof *variants));
2585 look_ahead_type = DEBUG_TYPE_NULL;
2591 enum debug_visibility visibility;
2592 bfd_boolean constp, volatilep, staticp;
2595 const char *physname;
2596 bfd_boolean varargs;
2598 if (look_ahead_type != DEBUG_TYPE_NULL)
2600 /* g++ version 1 kludge */
2601 type = look_ahead_type;
2602 look_ahead_type = DEBUG_TYPE_NULL;
2606 type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2607 (debug_type **) NULL);
2608 if (type == DEBUG_TYPE_NULL)
2619 p = strchr (*pp, ';');
2627 if (debug_get_type_kind (dhandle, type) == DEBUG_KIND_METHOD
2628 && debug_get_parameter_types (dhandle, type, &varargs) == NULL)
2631 argtypes = savestring (*pp, p - *pp);
2637 visibility = DEBUG_VISIBILITY_PRIVATE;
2640 visibility = DEBUG_VISIBILITY_PROTECTED;
2643 visibility = DEBUG_VISIBILITY_PUBLIC;
2653 /* Normal function. */
2657 /* const member function. */
2662 /* volatile member function. */
2667 /* const volatile member function. */
2675 /* File compiled with g++ version 1; no information. */
2678 warn_stab (orig, _("const/volatile indicator missing"));
2686 /* virtual member function, followed by index. The sign
2687 bit is supposedly set to distinguish
2688 pointers-to-methods from virtual function indicies. */
2690 voffset = parse_number (pp, (bfd_boolean *) NULL);
2697 voffset &= 0x7fffffff;
2699 if (**pp == ';' || *pp == '\0')
2701 /* Must be g++ version 1. */
2702 context = DEBUG_TYPE_NULL;
2706 /* Figure out from whence this virtual function
2707 came. It may belong to virtual function table of
2708 one of its baseclasses. */
2709 look_ahead_type = parse_stab_type (dhandle, info,
2710 (const char *) NULL,
2712 (debug_type **) NULL);
2715 /* g++ version 1 overloaded methods. */
2716 context = DEBUG_TYPE_NULL;
2720 context = look_ahead_type;
2721 look_ahead_type = DEBUG_TYPE_NULL;
2733 /* static member function. */
2737 context = DEBUG_TYPE_NULL;
2738 if (strncmp (argtypes, name, strlen (name)) != 0)
2743 warn_stab (orig, "member function type missing");
2745 context = DEBUG_TYPE_NULL;
2751 context = DEBUG_TYPE_NULL;
2755 /* If the type is not a stub, then the argtypes string is
2756 the physical name of the function. Otherwise the
2757 argtypes string is the mangled form of the argument
2758 types, and the full type and the physical name must be
2759 extracted from them. */
2760 physname = argtypes;
2763 debug_type class_type, return_type;
2765 class_type = stab_find_type (dhandle, info, typenums);
2766 if (class_type == DEBUG_TYPE_NULL)
2768 return_type = debug_get_return_type (dhandle, type);
2769 if (return_type == DEBUG_TYPE_NULL)
2774 type = parse_stab_argtypes (dhandle, info, class_type, name,
2775 tagname, return_type, argtypes,
2776 constp, volatilep, &physname);
2777 if (type == DEBUG_TYPE_NULL)
2781 if (cvars + 1 >= allocvars)
2784 variants = ((debug_method_variant *)
2786 allocvars * sizeof *variants));
2790 variants[cvars] = debug_make_method_variant (dhandle, physname,
2795 variants[cvars] = debug_make_static_method_variant (dhandle,
2801 if (variants[cvars] == DEBUG_METHOD_VARIANT_NULL)
2806 while (**pp != ';' && **pp != '\0');
2808 variants[cvars] = DEBUG_METHOD_VARIANT_NULL;
2816 methods = ((debug_method *)
2817 xrealloc (methods, alloc * sizeof *methods));
2820 methods[c] = debug_make_method (dhandle, name, variants);
2825 if (methods != NULL)
2826 methods[c] = DEBUG_METHOD_NULL;
2835 if (variants != NULL)
2837 if (argtypes != NULL)
2842 /* Parse a string representing argument types for a method. Stabs
2843 tries to save space by packing argument types into a mangled
2844 string. This string should give us enough information to extract
2845 both argument types and the physical name of the function, given
2849 parse_stab_argtypes (void *dhandle, struct stab_handle *info,
2850 debug_type class_type, const char *fieldname,
2851 const char *tagname, debug_type return_type,
2852 const char *argtypes, bfd_boolean constp,
2853 bfd_boolean volatilep, const char **pphysname)
2855 bfd_boolean is_full_physname_constructor;
2856 bfd_boolean is_constructor;
2857 bfd_boolean is_destructor;
2860 bfd_boolean varargs;
2861 unsigned int physname_len = 0;
2863 /* Constructors are sometimes handled specially. */
2864 is_full_physname_constructor = ((argtypes[0] == '_'
2865 && argtypes[1] == '_'
2866 && (ISDIGIT (argtypes[2])
2867 || argtypes[2] == 'Q'
2868 || argtypes[2] == 't'))
2869 || CONST_STRNEQ (argtypes, "__ct"));
2871 is_constructor = (is_full_physname_constructor
2873 && strcmp (fieldname, tagname) == 0));
2874 is_destructor = ((argtypes[0] == '_'
2875 && (argtypes[1] == '$' || argtypes[1] == '.')
2876 && argtypes[2] == '_')
2877 || CONST_STRNEQ (argtypes, "__dt"));
2878 is_v3 = argtypes[0] == '_' && argtypes[1] == 'Z';
2880 if (!(is_destructor || is_full_physname_constructor || is_v3))
2883 const char *const_prefix;
2884 const char *volatile_prefix;
2886 unsigned int mangled_name_len;
2889 len = tagname == NULL ? 0 : strlen (tagname);
2890 const_prefix = constp ? "C" : "";
2891 volatile_prefix = volatilep ? "V" : "";
2894 sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
2895 else if (tagname != NULL && strchr (tagname, '<') != NULL)
2897 /* Template methods are fully mangled. */
2898 sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
2903 sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
2905 mangled_name_len = ((is_constructor ? 0 : strlen (fieldname))
2911 if (fieldname[0] == 'o'
2912 && fieldname[1] == 'p'
2913 && (fieldname[2] == '$' || fieldname[2] == '.'))
2917 opname = cplus_mangle_opname (fieldname + 3, 0);
2920 fprintf (stderr, _("No mangling for \"%s\"\n"), fieldname);
2921 return DEBUG_TYPE_NULL;
2923 mangled_name_len += strlen (opname);
2924 physname = (char *) xmalloc (mangled_name_len);
2925 strncpy (physname, fieldname, 3);
2926 strcpy (physname + 3, opname);
2930 physname = (char *) xmalloc (mangled_name_len);
2934 strcpy (physname, fieldname);
2937 physname_len = strlen (physname);
2938 strcat (physname, buf);
2939 if (tagname != NULL)
2940 strcat (physname, tagname);
2941 strcat (physname, argtypes);
2943 *pphysname = physname;
2946 if (*argtypes == '\0' || is_destructor)
2948 args = (debug_type *) xmalloc (sizeof *args);
2950 return debug_make_method_type (dhandle, return_type, class_type, args,
2954 args = stab_demangle_argtypes (dhandle, info, *pphysname, &varargs, physname_len);
2956 return DEBUG_TYPE_NULL;
2958 return debug_make_method_type (dhandle, return_type, class_type, args,
2962 /* The tail end of stabs for C++ classes that contain a virtual function
2963 pointer contains a tilde, a %, and a type number.
2964 The type number refers to the base class (possibly this class itself) which
2965 contains the vtable pointer for the current class.
2967 This function is called when we have parsed all the method declarations,
2968 so we can look for the vptr base class info. */
2971 parse_stab_tilde_field (void *dhandle, struct stab_handle *info,
2972 const char **pp, const int *typenums,
2973 debug_type *retvptrbase, bfd_boolean *retownvptr)
2979 *retvptrbase = DEBUG_TYPE_NULL;
2980 *retownvptr = FALSE;
2984 /* If we are positioned at a ';', then skip it. */
2993 if (**pp == '=' || **pp == '+' || **pp == '-')
2995 /* Obsolete flags that used to indicate the presence of
2996 constructors and/or destructors. */
3007 /* The next number is the type number of the base class (possibly
3008 our own class) which supplies the vtable for this class. */
3009 if (! parse_stab_type_number (pp, vtypenums))
3012 if (vtypenums[0] == typenums[0]
3013 && vtypenums[1] == typenums[1])
3022 vtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3023 (debug_type **) NULL);
3024 for (p = *pp; *p != ';' && *p != '\0'; p++)
3032 *retvptrbase = vtype;
3040 /* Read a definition of an array type. */
3043 parse_stab_array_type (void *dhandle, struct stab_handle *info,
3044 const char **pp, bfd_boolean stringp)
3049 debug_type index_type;
3050 bfd_boolean adjustable;
3051 bfd_signed_vma lower, upper;
3052 debug_type element_type;
3054 /* Format of an array type:
3055 "ar<index type>;lower;upper;<array_contents_type>".
3056 OS9000: "arlower,upper;<array_contents_type>".
3058 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3059 for these, produce a type like float[][]. */
3063 /* FIXME: gdb checks os9k_stabs here. */
3065 /* If the index type is type 0, we take it as int. */
3067 if (! parse_stab_type_number (&p, typenums))
3068 return DEBUG_TYPE_NULL;
3069 if (typenums[0] == 0 && typenums[1] == 0 && **pp != '=')
3071 index_type = debug_find_named_type (dhandle, "int");
3072 if (index_type == DEBUG_TYPE_NULL)
3074 index_type = debug_make_int_type (dhandle, 4, FALSE);
3075 if (index_type == DEBUG_TYPE_NULL)
3076 return DEBUG_TYPE_NULL;
3082 index_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3083 (debug_type **) NULL);
3089 return DEBUG_TYPE_NULL;
3095 if (! ISDIGIT (**pp) && **pp != '-')
3101 lower = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
3105 return DEBUG_TYPE_NULL;
3109 if (! ISDIGIT (**pp) && **pp != '-')
3115 upper = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
3119 return DEBUG_TYPE_NULL;
3123 element_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3124 (debug_type **) NULL);
3125 if (element_type == DEBUG_TYPE_NULL)
3126 return DEBUG_TYPE_NULL;
3134 return debug_make_array_type (dhandle, element_type, index_type, lower,
3138 /* This struct holds information about files we have seen using
3143 /* The next N_BINCL file. */
3144 struct bincl_file *next;
3145 /* The next N_BINCL on the stack. */
3146 struct bincl_file *next_stack;
3147 /* The file name. */
3149 /* The hash value. */
3151 /* The file index. */
3153 /* The list of types defined in this file. */
3154 struct stab_types *file_types;
3157 /* Start a new N_BINCL file, pushing it onto the stack. */
3160 push_bincl (struct stab_handle *info, const char *name, bfd_vma hash)
3162 struct bincl_file *n;
3164 n = (struct bincl_file *) xmalloc (sizeof *n);
3165 n->next = info->bincl_list;
3166 n->next_stack = info->bincl_stack;
3169 n->file = info->files;
3170 n->file_types = NULL;
3171 info->bincl_list = n;
3172 info->bincl_stack = n;
3175 info->file_types = ((struct stab_types **)
3176 xrealloc (info->file_types,
3178 * sizeof *info->file_types)));
3179 info->file_types[n->file] = NULL;
3182 /* Finish an N_BINCL file, at an N_EINCL, popping the name off the
3186 pop_bincl (struct stab_handle *info)
3188 struct bincl_file *o;
3190 o = info->bincl_stack;
3192 return info->main_filename;
3193 info->bincl_stack = o->next_stack;
3195 o->file_types = info->file_types[o->file];
3197 if (info->bincl_stack == NULL)
3198 return info->main_filename;
3199 return info->bincl_stack->name;
3202 /* Handle an N_EXCL: get the types from the corresponding N_BINCL. */
3205 find_excl (struct stab_handle *info, const char *name, bfd_vma hash)
3207 struct bincl_file *l;
3210 info->file_types = ((struct stab_types **)
3211 xrealloc (info->file_types,
3213 * sizeof *info->file_types)));
3215 for (l = info->bincl_list; l != NULL; l = l->next)
3216 if (l->hash == hash && strcmp (l->name, name) == 0)
3220 warn_stab (name, _("Undefined N_EXCL"));
3221 info->file_types[info->files - 1] = NULL;
3225 info->file_types[info->files - 1] = l->file_types;
3230 /* Handle a variable definition. gcc emits variable definitions for a
3231 block before the N_LBRAC, so we must hold onto them until we see
3232 it. The SunPRO compiler emits variable definitions after the
3233 N_LBRAC, so we can call debug_record_variable immediately. */
3236 stab_record_variable (void *dhandle, struct stab_handle *info,
3237 const char *name, debug_type type,
3238 enum debug_var_kind kind, bfd_vma val)
3240 struct stab_pending_var *v;
3242 if ((kind == DEBUG_GLOBAL || kind == DEBUG_STATIC)
3243 || ! info->within_function
3244 || (info->gcc_compiled == 0 && info->n_opt_found))
3245 return debug_record_variable (dhandle, name, type, kind, val);
3247 v = (struct stab_pending_var *) xmalloc (sizeof *v);
3248 memset (v, 0, sizeof *v);
3250 v->next = info->pending;
3260 /* Emit pending variable definitions. This is called after we see the
3261 N_LBRAC that starts the block. */
3264 stab_emit_pending_vars (void *dhandle, struct stab_handle *info)
3266 struct stab_pending_var *v;
3271 struct stab_pending_var *next;
3273 if (! debug_record_variable (dhandle, v->name, v->type, v->kind, v->val))
3281 info->pending = NULL;
3286 /* Find the slot for a type in the database. */
3289 stab_find_slot (struct stab_handle *info, const int *typenums)
3293 struct stab_types **ps;
3295 filenum = typenums[0];
3296 tindex = typenums[1];
3298 if (filenum < 0 || (unsigned int) filenum >= info->files)
3300 fprintf (stderr, _("Type file number %d out of range\n"), filenum);
3305 fprintf (stderr, _("Type index number %d out of range\n"), tindex);
3309 ps = info->file_types + filenum;
3311 while (tindex >= STAB_TYPES_SLOTS)
3315 *ps = (struct stab_types *) xmalloc (sizeof **ps);
3316 memset (*ps, 0, sizeof **ps);
3319 tindex -= STAB_TYPES_SLOTS;
3323 *ps = (struct stab_types *) xmalloc (sizeof **ps);
3324 memset (*ps, 0, sizeof **ps);
3327 return (*ps)->types + tindex;
3330 /* Find a type given a type number. If the type has not been
3331 allocated yet, create an indirect type. */
3334 stab_find_type (void *dhandle, struct stab_handle *info, const int *typenums)
3338 if (typenums[0] == 0 && typenums[1] < 0)
3340 /* A negative type number indicates an XCOFF builtin type. */
3341 return stab_xcoff_builtin_type (dhandle, info, typenums[1]);
3344 slot = stab_find_slot (info, typenums);
3346 return DEBUG_TYPE_NULL;
3348 if (*slot == DEBUG_TYPE_NULL)
3349 return debug_make_indirect_type (dhandle, slot, (const char *) NULL);
3354 /* Record that a given type number refers to a given type. */
3357 stab_record_type (void *dhandle ATTRIBUTE_UNUSED, struct stab_handle *info,
3358 const int *typenums, debug_type type)
3362 slot = stab_find_slot (info, typenums);
3366 /* gdb appears to ignore type redefinitions, so we do as well. */
3373 /* Return an XCOFF builtin type. */
3376 stab_xcoff_builtin_type (void *dhandle, struct stab_handle *info,
3382 if (typenum >= 0 || typenum < -XCOFF_TYPE_COUNT)
3384 fprintf (stderr, _("Unrecognized XCOFF type %d\n"), typenum);
3385 return DEBUG_TYPE_NULL;
3387 if (info->xcoff_types[-typenum] != NULL)
3388 return info->xcoff_types[-typenum];
3393 /* The size of this and all the other types are fixed, defined
3394 by the debugging format. */
3396 rettype = debug_make_int_type (dhandle, 4, FALSE);
3400 rettype = debug_make_int_type (dhandle, 1, FALSE);
3404 rettype = debug_make_int_type (dhandle, 2, FALSE);
3408 rettype = debug_make_int_type (dhandle, 4, FALSE);
3411 name = "unsigned char";
3412 rettype = debug_make_int_type (dhandle, 1, TRUE);
3415 name = "signed char";
3416 rettype = debug_make_int_type (dhandle, 1, FALSE);
3419 name = "unsigned short";
3420 rettype = debug_make_int_type (dhandle, 2, TRUE);
3423 name = "unsigned int";
3424 rettype = debug_make_int_type (dhandle, 4, TRUE);
3428 rettype = debug_make_int_type (dhandle, 4, TRUE);
3430 name = "unsigned long";
3431 rettype = debug_make_int_type (dhandle, 4, TRUE);
3435 rettype = debug_make_void_type (dhandle);
3438 /* IEEE single precision (32 bit). */
3440 rettype = debug_make_float_type (dhandle, 4);
3443 /* IEEE double precision (64 bit). */
3445 rettype = debug_make_float_type (dhandle, 8);
3448 /* This is an IEEE double on the RS/6000, and different machines
3449 with different sizes for "long double" should use different
3450 negative type numbers. See stabs.texinfo. */
3451 name = "long double";
3452 rettype = debug_make_float_type (dhandle, 8);
3456 rettype = debug_make_int_type (dhandle, 4, FALSE);
3460 rettype = debug_make_bool_type (dhandle, 4);
3463 name = "short real";
3464 rettype = debug_make_float_type (dhandle, 4);
3468 rettype = debug_make_float_type (dhandle, 8);
3478 rettype = debug_make_int_type (dhandle, 1, TRUE);
3482 rettype = debug_make_bool_type (dhandle, 1);
3486 rettype = debug_make_bool_type (dhandle, 2);
3490 rettype = debug_make_bool_type (dhandle, 4);
3494 rettype = debug_make_bool_type (dhandle, 4);
3497 /* Complex type consisting of two IEEE single precision values. */
3499 rettype = debug_make_complex_type (dhandle, 8);
3502 /* Complex type consisting of two IEEE double precision values. */
3503 name = "double complex";
3504 rettype = debug_make_complex_type (dhandle, 16);
3508 rettype = debug_make_int_type (dhandle, 1, FALSE);
3512 rettype = debug_make_int_type (dhandle, 2, FALSE);
3516 rettype = debug_make_int_type (dhandle, 4, FALSE);
3521 rettype = debug_make_int_type (dhandle, 2, FALSE);
3525 rettype = debug_make_int_type (dhandle, 8, FALSE);
3528 name = "unsigned long long";
3529 rettype = debug_make_int_type (dhandle, 8, TRUE);
3533 rettype = debug_make_bool_type (dhandle, 8);
3537 rettype = debug_make_int_type (dhandle, 8, FALSE);
3543 rettype = debug_name_type (dhandle, name, rettype);
3545 info->xcoff_types[-typenum] = rettype;
3550 /* Find or create a tagged type. */
3553 stab_find_tagged_type (void *dhandle, struct stab_handle *info,
3554 const char *p, int len, enum debug_type_kind kind)
3558 struct stab_tag *st;
3560 name = savestring (p, len);
3562 /* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same
3563 namespace. This is right for C, and I don't know how to handle
3564 other languages. FIXME. */
3565 dtype = debug_find_tagged_type (dhandle, name, DEBUG_KIND_ILLEGAL);
3566 if (dtype != DEBUG_TYPE_NULL)
3572 /* We need to allocate an entry on the undefined tag list. */
3573 for (st = info->tags; st != NULL; st = st->next)
3575 if (st->name[0] == name[0]
3576 && strcmp (st->name, name) == 0)
3578 if (st->kind == DEBUG_KIND_ILLEGAL)
3586 st = (struct stab_tag *) xmalloc (sizeof *st);
3587 memset (st, 0, sizeof *st);
3589 st->next = info->tags;
3592 st->slot = DEBUG_TYPE_NULL;
3593 st->type = debug_make_indirect_type (dhandle, &st->slot, name);
3600 /* In order to get the correct argument types for a stubbed method, we
3601 need to extract the argument types from a C++ mangled string.
3602 Since the argument types can refer back to the return type, this
3603 means that we must demangle the entire physical name. In gdb this
3604 is done by calling cplus_demangle and running the results back
3605 through the C++ expression parser. Since we have no expression
3606 parser, we must duplicate much of the work of cplus_demangle here.
3608 We assume that GNU style demangling is used, since this is only
3609 done for method stubs, and only g++ should output that form of
3610 debugging information. */
3612 /* This structure is used to hold a pointer to type information which
3613 demangling a string. */
3615 struct stab_demangle_typestring
3617 /* The start of the type. This is not null terminated. */
3618 const char *typestring;
3619 /* The length of the type. */
3623 /* This structure is used to hold information while demangling a
3626 struct stab_demangle_info
3628 /* The debugging information handle. */
3630 /* The stab information handle. */
3631 struct stab_handle *info;
3632 /* The array of arguments we are building. */
3634 /* Whether the method takes a variable number of arguments. */
3635 bfd_boolean varargs;
3636 /* The array of types we have remembered. */
3637 struct stab_demangle_typestring *typestrings;
3638 /* The number of typestrings. */
3639 unsigned int typestring_count;
3640 /* The number of typestring slots we have allocated. */
3641 unsigned int typestring_alloc;
3644 static void stab_bad_demangle (const char *);
3645 static unsigned int stab_demangle_count (const char **);
3646 static bfd_boolean stab_demangle_get_count (const char **, unsigned int *);
3647 static bfd_boolean stab_demangle_prefix
3648 (struct stab_demangle_info *, const char **, unsigned int);
3649 static bfd_boolean stab_demangle_function_name
3650 (struct stab_demangle_info *, const char **, const char *);
3651 static bfd_boolean stab_demangle_signature
3652 (struct stab_demangle_info *, const char **);
3653 static bfd_boolean stab_demangle_qualified
3654 (struct stab_demangle_info *, const char **, debug_type *);
3655 static bfd_boolean stab_demangle_template
3656 (struct stab_demangle_info *, const char **, char **);
3657 static bfd_boolean stab_demangle_class
3658 (struct stab_demangle_info *, const char **, const char **);
3659 static bfd_boolean stab_demangle_args
3660 (struct stab_demangle_info *, const char **, debug_type **, bfd_boolean *);
3661 static bfd_boolean stab_demangle_arg
3662 (struct stab_demangle_info *, const char **, debug_type **,
3663 unsigned int *, unsigned int *);
3664 static bfd_boolean stab_demangle_type
3665 (struct stab_demangle_info *, const char **, debug_type *);
3666 static bfd_boolean stab_demangle_fund_type
3667 (struct stab_demangle_info *, const char **, debug_type *);
3668 static bfd_boolean stab_demangle_remember_type
3669 (struct stab_demangle_info *, const char *, int);
3671 /* Warn about a bad demangling. */
3674 stab_bad_demangle (const char *s)
3676 fprintf (stderr, _("bad mangled name `%s'\n"), s);
3679 /* Get a count from a stab string. */
3682 stab_demangle_count (const char **pp)
3687 while (ISDIGIT (**pp))
3690 count += **pp - '0';
3696 /* Require a count in a string. The count may be multiple digits, in
3697 which case it must end in an underscore. */
3700 stab_demangle_get_count (const char **pp, unsigned int *pi)
3702 if (! ISDIGIT (**pp))
3720 while (ISDIGIT (*p));
3731 /* This function demangles a physical name, returning a NULL
3732 terminated array of argument types. */
3735 stab_demangle_argtypes (void *dhandle, struct stab_handle *info,
3736 const char *physname, bfd_boolean *pvarargs,
3737 unsigned int physname_len)
3739 struct stab_demangle_info minfo;
3741 /* Check for the g++ V3 ABI. */
3742 if (physname[0] == '_' && physname[1] == 'Z')
3743 return stab_demangle_v3_argtypes (dhandle, info, physname, pvarargs);
3745 minfo.dhandle = dhandle;
3748 minfo.varargs = FALSE;
3749 minfo.typestring_alloc = 10;
3750 minfo.typestrings = ((struct stab_demangle_typestring *)
3751 xmalloc (minfo.typestring_alloc
3752 * sizeof *minfo.typestrings));
3753 minfo.typestring_count = 0;
3755 /* cplus_demangle checks for special GNU mangled forms, but we can't
3756 see any of them in mangled method argument types. */
3758 if (! stab_demangle_prefix (&minfo, &physname, physname_len))
3761 if (*physname != '\0')
3763 if (! stab_demangle_signature (&minfo, &physname))
3767 free (minfo.typestrings);
3768 minfo.typestrings = NULL;
3770 if (minfo.args == NULL)
3771 fprintf (stderr, _("no argument types in mangled string\n"));
3773 *pvarargs = minfo.varargs;
3777 if (minfo.typestrings != NULL)
3778 free (minfo.typestrings);
3782 /* Demangle the prefix of the mangled name. */
3785 stab_demangle_prefix (struct stab_demangle_info *minfo, const char **pp,
3786 unsigned int physname_len)
3791 /* cplus_demangle checks for global constructors and destructors,
3792 but we can't see them in mangled argument types. */
3795 scan = *pp + physname_len;
3798 /* Look for `__'. */
3801 scan = strchr (scan, '_');
3802 while (scan != NULL && *++scan != '_');
3806 stab_bad_demangle (*pp);
3812 /* We found `__'; move ahead to the last contiguous `__' pair. */
3813 i = strspn (scan, "_");
3819 && (ISDIGIT (scan[2])
3823 /* This is a GNU style constructor name. */
3827 else if (scan == *pp
3828 && ! ISDIGIT (scan[2])
3831 /* Look for the `__' that separates the prefix from the
3833 while (*scan == '_')
3835 scan = strstr (scan, "__");
3836 if (scan == NULL || scan[2] == '\0')
3838 stab_bad_demangle (*pp);
3842 return stab_demangle_function_name (minfo, pp, scan);
3844 else if (scan[2] != '\0')
3846 /* The name doesn't start with `__', but it does contain `__'. */
3847 return stab_demangle_function_name (minfo, pp, scan);
3851 stab_bad_demangle (*pp);
3857 /* Demangle a function name prefix. The scan argument points to the
3858 double underscore which separates the function name from the
3862 stab_demangle_function_name (struct stab_demangle_info *minfo,
3863 const char **pp, const char *scan)
3867 /* The string from *pp to scan is the name of the function. We
3868 don't care about the name, since we just looking for argument
3869 types. However, for conversion operators, the name may include a
3870 type which we must remember in order to handle backreferences. */
3876 && CONST_STRNEQ (name, "type")
3877 && (name[4] == '$' || name[4] == '.'))
3881 /* This is a type conversion operator. */
3883 if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
3886 else if (name[0] == '_'
3893 /* This is a type conversion operator. */
3895 if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
3902 /* Demangle the signature. This is where the argument types are
3906 stab_demangle_signature (struct stab_demangle_info *minfo, const char **pp)
3909 bfd_boolean expect_func, func_done;
3914 expect_func = FALSE;
3918 while (**pp != '\0')
3924 if (! stab_demangle_qualified (minfo, pp, (debug_type *) NULL)
3925 || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
3932 /* Static member function. FIXME: Can this happen? */
3939 /* Const member function. */
3945 case '0': case '1': case '2': case '3': case '4':
3946 case '5': case '6': case '7': case '8': case '9':
3949 if (! stab_demangle_class (minfo, pp, (const char **) NULL)
3950 || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
3957 /* Function. I don't know if this actually happens with g++
3962 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3970 if (! stab_demangle_template (minfo, pp, (char **) NULL)
3971 || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
3978 /* At the outermost level, we cannot have a return type
3979 specified, so if we run into another '_' at this point we
3980 are dealing with a mangled name that is either bogus, or
3981 has been mangled by some algorithm we don't know how to
3982 deal with. So just reject the entire demangling. */
3983 stab_bad_demangle (orig);
3987 /* Assume we have stumbled onto the first outermost function
3988 argument token, and start processing args. */
3990 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3998 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
4005 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
4006 bar__3fooi is 'foo::bar(int)'. We get here when we find the
4007 first case, and need to ensure that the '(void)' gets added
4008 to the current declp. */
4009 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
4016 /* Demangle a qualified name, such as "Q25Outer5Inner" which is the
4017 mangled form of "Outer::Inner". */
4020 stab_demangle_qualified (struct stab_demangle_info *minfo, const char **pp,
4025 unsigned int qualifiers;
4033 /* GNU mangled name with more than 9 classes. The count is
4034 preceded by an underscore (to distinguish it from the <= 9
4035 case) and followed by an underscore. */
4037 if (! ISDIGIT (*p) || *p == '0')
4039 stab_bad_demangle (orig);
4042 qualifiers = atoi (p);
4043 while (ISDIGIT (*p))
4047 stab_bad_demangle (orig);
4053 case '1': case '2': case '3': case '4': case '5':
4054 case '6': case '7': case '8': case '9':
4055 qualifiers = (*pp)[1] - '0';
4056 /* Skip an optional underscore after the count. */
4057 if ((*pp)[2] == '_')
4064 stab_bad_demangle (orig);
4068 context = DEBUG_TYPE_NULL;
4070 /* Pick off the names. */
4071 while (qualifiers-- > 0)
4079 if (! stab_demangle_template (minfo, pp,
4080 ptype != NULL ? &name : NULL))
4085 context = stab_find_tagged_type (minfo->dhandle, minfo->info,
4086 name, strlen (name),
4089 if (context == DEBUG_TYPE_NULL)
4097 len = stab_demangle_count (pp);
4098 if (strlen (*pp) < len)
4100 stab_bad_demangle (orig);
4106 const debug_field *fields;
4109 if (context != DEBUG_TYPE_NULL)
4110 fields = debug_get_fields (minfo->dhandle, context);
4112 context = DEBUG_TYPE_NULL;
4118 /* Try to find the type by looking through the
4119 fields of context until we find a field with the
4120 same type. This ought to work for a class
4121 defined within a class, but it won't work for,
4122 e.g., an enum defined within a class. stabs does
4123 not give us enough information to figure out the
4126 name = savestring (*pp, len);
4128 for (; *fields != DEBUG_FIELD_NULL; fields++)
4133 ft = debug_get_field_type (minfo->dhandle, *fields);
4139 dn = debug_get_type_name (minfo->dhandle, ft);
4140 if (dn != NULL && strcmp (dn, name) == 0)
4150 if (context == DEBUG_TYPE_NULL)
4152 /* We have to fall back on finding the type by name.
4153 If there are more types to come, then this must
4154 be a class. Otherwise, it could be anything. */
4156 if (qualifiers == 0)
4160 name = savestring (*pp, len);
4161 context = debug_find_named_type (minfo->dhandle,
4166 if (context == DEBUG_TYPE_NULL)
4168 context = stab_find_tagged_type (minfo->dhandle,
4172 ? DEBUG_KIND_ILLEGAL
4173 : DEBUG_KIND_CLASS));
4174 if (context == DEBUG_TYPE_NULL)
4190 /* Demangle a template. If PNAME is not NULL, this sets *PNAME to a
4191 string representation of the template. */
4194 stab_demangle_template (struct stab_demangle_info *minfo, const char **pp,
4204 /* Skip the template name. */
4205 r = stab_demangle_count (pp);
4206 if (r == 0 || strlen (*pp) < r)
4208 stab_bad_demangle (orig);
4213 /* Get the size of the parameter list. */
4214 if (stab_demangle_get_count (pp, &r) == 0)
4216 stab_bad_demangle (orig);
4220 for (i = 0; i < r; i++)
4224 /* This is a type parameter. */
4226 if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
4232 bfd_boolean pointerp, realp, integralp, charp, boolp;
4243 /* This is a value parameter. */
4245 if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
4248 while (*old_p != '\0' && ! done)
4258 case 'C': /* Const. */
4259 case 'S': /* Signed. */
4260 case 'U': /* Unsigned. */
4261 case 'V': /* Volatile. */
4262 case 'F': /* Function. */
4263 case 'M': /* Member function. */
4267 case 'Q': /* Qualified name. */
4271 case 'T': /* Remembered type. */
4273 case 'v': /* Void. */
4275 case 'x': /* Long long. */
4276 case 'l': /* Long. */
4277 case 'i': /* Int. */
4278 case 's': /* Short. */
4279 case 'w': /* Wchar_t. */
4283 case 'b': /* Bool. */
4287 case 'c': /* Char. */
4291 case 'r': /* Long double. */
4292 case 'd': /* Double. */
4293 case 'f': /* Float. */
4298 /* Assume it's a user defined integral type. */
4309 while (ISDIGIT (**pp))
4318 val = stab_demangle_count (pp);
4321 stab_bad_demangle (orig);
4329 val = stab_demangle_count (pp);
4330 if (val != 0 && val != 1)
4332 stab_bad_demangle (orig);
4340 while (ISDIGIT (**pp))
4345 while (ISDIGIT (**pp))
4351 while (ISDIGIT (**pp))
4359 len = stab_demangle_count (pp);
4362 stab_bad_demangle (orig);
4370 /* We can translate this to a string fairly easily by invoking the
4371 regular demangling routine. */
4374 char *s1, *s2, *s3, *s4 = NULL;
4377 s1 = savestring (orig, *pp - orig);
4379 s2 = concat ("NoSuchStrinG__", s1, (const char *) NULL);
4383 s3 = cplus_demangle (s2, DMGL_ANSI);
4388 s4 = strstr (s3, "::NoSuchStrinG");
4389 if (s3 == NULL || s4 == NULL)
4391 stab_bad_demangle (orig);
4397 /* Eliminating all spaces, except those between > characters,
4398 makes it more likely that the demangled name will match the
4399 name which g++ used as the structure name. */
4400 for (from = to = s3; from != s4; ++from)
4402 || (from[1] == '>' && from > s3 && from[-1] == '>'))
4405 *pname = savestring (s3, to - s3);
4413 /* Demangle a class name. */
4416 stab_demangle_class (struct stab_demangle_info *minfo ATTRIBUTE_UNUSED,
4417 const char **pp, const char **pstart)
4424 n = stab_demangle_count (pp);
4425 if (strlen (*pp) < n)
4427 stab_bad_demangle (orig);
4439 /* Demangle function arguments. If the pargs argument is not NULL, it
4440 is set to a NULL terminated array holding the arguments. */
4443 stab_demangle_args (struct stab_demangle_info *minfo, const char **pp,
4444 debug_type **pargs, bfd_boolean *pvarargs)
4447 unsigned int alloc, count;
4454 *pargs = (debug_type *) xmalloc (alloc * sizeof **pargs);
4459 while (**pp != '_' && **pp != '\0' && **pp != 'e')
4461 if (**pp == 'N' || **pp == 'T')
4469 if (temptype == 'T')
4473 if (! stab_demangle_get_count (pp, &r))
4475 stab_bad_demangle (orig);
4480 if (! stab_demangle_get_count (pp, &t))
4482 stab_bad_demangle (orig);
4486 if (t >= minfo->typestring_count)
4488 stab_bad_demangle (orig);
4495 tem = minfo->typestrings[t].typestring;
4496 if (! stab_demangle_arg (minfo, &tem, pargs, &count, &alloc))
4502 if (! stab_demangle_arg (minfo, pp, pargs, &count, &alloc))
4508 (*pargs)[count] = DEBUG_TYPE_NULL;
4520 /* Demangle a single argument. */
4523 stab_demangle_arg (struct stab_demangle_info *minfo, const char **pp,
4524 debug_type **pargs, unsigned int *pcount,
4525 unsigned int *palloc)
4531 if (! stab_demangle_type (minfo, pp,
4532 pargs == NULL ? (debug_type *) NULL : &type)
4533 || ! stab_demangle_remember_type (minfo, start, *pp - start))
4538 if (type == DEBUG_TYPE_NULL)
4541 if (*pcount + 1 >= *palloc)
4544 *pargs = ((debug_type *)
4545 xrealloc (*pargs, *palloc * sizeof **pargs));
4547 (*pargs)[*pcount] = type;
4554 /* Demangle a type. If the ptype argument is not NULL, *ptype is set
4555 to the newly allocated type. */
4558 stab_demangle_type (struct stab_demangle_info *minfo, const char **pp,
4569 /* A pointer type. */
4571 if (! stab_demangle_type (minfo, pp, ptype))
4574 *ptype = debug_make_pointer_type (minfo->dhandle, *ptype);
4578 /* A reference type. */
4580 if (! stab_demangle_type (minfo, pp, ptype))
4583 *ptype = debug_make_reference_type (minfo->dhandle, *ptype);
4593 while (**pp != '\0' && **pp != '_')
4595 if (! ISDIGIT (**pp))
4597 stab_bad_demangle (orig);
4606 stab_bad_demangle (orig);
4611 if (! stab_demangle_type (minfo, pp, ptype))
4615 debug_type int_type;
4617 int_type = debug_find_named_type (minfo->dhandle, "int");
4618 if (int_type == NULL)
4619 int_type = debug_make_int_type (minfo->dhandle, 4, FALSE);
4620 *ptype = debug_make_array_type (minfo->dhandle, *ptype, int_type,
4627 /* A back reference to a remembered type. */
4633 if (! stab_demangle_get_count (pp, &i))
4635 stab_bad_demangle (orig);
4638 if (i >= minfo->typestring_count)
4640 stab_bad_demangle (orig);
4643 p = minfo->typestrings[i].typestring;
4644 if (! stab_demangle_type (minfo, &p, ptype))
4653 bfd_boolean varargs;
4656 if (! stab_demangle_args (minfo, pp,
4658 ? (debug_type **) NULL
4661 ? (bfd_boolean *) NULL
4666 /* cplus_demangle will accept a function without a return
4667 type, but I don't know when that will happen, or what
4668 to do if it does. */
4669 stab_bad_demangle (orig);
4673 if (! stab_demangle_type (minfo, pp, ptype))
4676 *ptype = debug_make_function_type (minfo->dhandle, *ptype, args,
4685 bfd_boolean memberp;
4686 debug_type class_type = DEBUG_TYPE_NULL;
4688 bfd_boolean varargs;
4692 memberp = **pp == 'M';
4699 n = stab_demangle_count (pp);
4700 if (strlen (*pp) < n)
4702 stab_bad_demangle (orig);
4710 class_type = stab_find_tagged_type (minfo->dhandle,
4714 if (class_type == DEBUG_TYPE_NULL)
4718 else if (**pp == 'Q')
4720 if (! stab_demangle_qualified (minfo, pp,
4722 ? (debug_type *) NULL
4728 stab_bad_demangle (orig);
4738 else if (**pp == 'V')
4744 stab_bad_demangle (orig);
4748 if (! stab_demangle_args (minfo, pp,
4750 ? (debug_type **) NULL
4753 ? (bfd_boolean *) NULL
4760 stab_bad_demangle (orig);
4765 if (! stab_demangle_type (minfo, pp, ptype))
4771 *ptype = debug_make_offset_type (minfo->dhandle, class_type,
4775 /* FIXME: We have no way to record constp or
4777 *ptype = debug_make_method_type (minfo->dhandle, *ptype,
4778 class_type, args, varargs);
4786 if (! stab_demangle_type (minfo, pp, ptype))
4792 if (! stab_demangle_type (minfo, pp, ptype))
4795 *ptype = debug_make_const_type (minfo->dhandle, *ptype);
4800 if (! stab_demangle_qualified (minfo, pp, ptype))
4806 if (! stab_demangle_fund_type (minfo, pp, ptype))
4814 /* Demangle a fundamental type. If the ptype argument is not NULL,
4815 *ptype is set to the newly allocated type. */
4818 stab_demangle_fund_type (struct stab_demangle_info *minfo, const char **pp,
4822 bfd_boolean constp, volatilep, unsignedp, signedp;
4867 /* cplus_demangle permits this, but I don't know what it means. */
4868 stab_bad_demangle (orig);
4871 case 'v': /* void */
4874 *ptype = debug_find_named_type (minfo->dhandle, "void");
4875 if (*ptype == DEBUG_TYPE_NULL)
4876 *ptype = debug_make_void_type (minfo->dhandle);
4881 case 'x': /* long long */
4884 *ptype = debug_find_named_type (minfo->dhandle,
4886 ? "long long unsigned int"
4887 : "long long int"));
4888 if (*ptype == DEBUG_TYPE_NULL)
4889 *ptype = debug_make_int_type (minfo->dhandle, 8, unsignedp);
4894 case 'l': /* long */
4897 *ptype = debug_find_named_type (minfo->dhandle,
4899 ? "long unsigned int"
4901 if (*ptype == DEBUG_TYPE_NULL)
4902 *ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp);
4910 *ptype = debug_find_named_type (minfo->dhandle,
4914 if (*ptype == DEBUG_TYPE_NULL)
4915 *ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp);
4920 case 's': /* short */
4923 *ptype = debug_find_named_type (minfo->dhandle,
4925 ? "short unsigned int"
4927 if (*ptype == DEBUG_TYPE_NULL)
4928 *ptype = debug_make_int_type (minfo->dhandle, 2, unsignedp);
4933 case 'b': /* bool */
4936 *ptype = debug_find_named_type (minfo->dhandle, "bool");
4937 if (*ptype == DEBUG_TYPE_NULL)
4938 *ptype = debug_make_bool_type (minfo->dhandle, 4);
4943 case 'c': /* char */
4946 *ptype = debug_find_named_type (minfo->dhandle,
4952 if (*ptype == DEBUG_TYPE_NULL)
4953 *ptype = debug_make_int_type (minfo->dhandle, 1, unsignedp);
4958 case 'w': /* wchar_t */
4961 *ptype = debug_find_named_type (minfo->dhandle, "__wchar_t");
4962 if (*ptype == DEBUG_TYPE_NULL)
4963 *ptype = debug_make_int_type (minfo->dhandle, 2, TRUE);
4968 case 'r': /* long double */
4971 *ptype = debug_find_named_type (minfo->dhandle, "long double");
4972 if (*ptype == DEBUG_TYPE_NULL)
4973 *ptype = debug_make_float_type (minfo->dhandle, 8);
4978 case 'd': /* double */
4981 *ptype = debug_find_named_type (minfo->dhandle, "double");
4982 if (*ptype == DEBUG_TYPE_NULL)
4983 *ptype = debug_make_float_type (minfo->dhandle, 8);
4988 case 'f': /* float */
4991 *ptype = debug_find_named_type (minfo->dhandle, "float");
4992 if (*ptype == DEBUG_TYPE_NULL)
4993 *ptype = debug_make_float_type (minfo->dhandle, 4);
5000 if (! ISDIGIT (**pp))
5002 stab_bad_demangle (orig);
5006 case '0': case '1': case '2': case '3': case '4':
5007 case '5': case '6': case '7': case '8': case '9':
5011 if (! stab_demangle_class (minfo, pp, &hold))
5017 name = savestring (hold, *pp - hold);
5018 *ptype = debug_find_named_type (minfo->dhandle, name);
5020 if (*ptype == DEBUG_TYPE_NULL)
5022 /* FIXME: It is probably incorrect to assume that
5023 undefined types are tagged types. */
5024 *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
5026 DEBUG_KIND_ILLEGAL);
5027 if (*ptype == DEBUG_TYPE_NULL)
5038 if (! stab_demangle_template (minfo, pp,
5039 ptype != NULL ? &name : NULL))
5043 *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
5044 name, strlen (name),
5047 if (*ptype == DEBUG_TYPE_NULL)
5054 stab_bad_demangle (orig);
5061 *ptype = debug_make_const_type (minfo->dhandle, *ptype);
5063 *ptype = debug_make_volatile_type (minfo->dhandle, *ptype);
5069 /* Remember a type string in a demangled string. */
5072 stab_demangle_remember_type (struct stab_demangle_info *minfo,
5073 const char *p, int len)
5075 if (minfo->typestring_count >= minfo->typestring_alloc)
5077 minfo->typestring_alloc += 10;
5078 minfo->typestrings = ((struct stab_demangle_typestring *)
5079 xrealloc (minfo->typestrings,
5080 (minfo->typestring_alloc
5081 * sizeof *minfo->typestrings)));
5084 minfo->typestrings[minfo->typestring_count].typestring = p;
5085 minfo->typestrings[minfo->typestring_count].len = (unsigned int) len;
5086 ++minfo->typestring_count;
5091 /* Demangle names encoded using the g++ V3 ABI. The newer versions of
5092 g++ which use this ABI do not encode ordinary method argument types
5093 in a mangled name; they simply output the argument types. However,
5094 for a static method, g++ simply outputs the return type and the
5095 physical name. So in that case we need to demangle the name here.
5096 Here PHYSNAME is the physical name of the function, and we set the
5097 variable pointed at by PVARARGS to indicate whether this function
5098 is varargs. This returns NULL, or a NULL terminated array of
5102 stab_demangle_v3_argtypes (void *dhandle, struct stab_handle *info,
5103 const char *physname, bfd_boolean *pvarargs)
5105 struct demangle_component *dc;
5109 dc = cplus_demangle_v3_components (physname, DMGL_PARAMS | DMGL_ANSI, &mem);
5112 stab_bad_demangle (physname);
5116 /* We expect to see TYPED_NAME, and the right subtree describes the
5118 if (dc->type != DEMANGLE_COMPONENT_TYPED_NAME
5119 || dc->u.s_binary.right->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
5121 fprintf (stderr, _("Demangled name is not a function\n"));
5126 pargs = stab_demangle_v3_arglist (dhandle, info,
5127 dc->u.s_binary.right->u.s_binary.right,
5135 /* Demangle an argument list in a struct demangle_component tree.
5136 Returns a DEBUG_TYPE_NULL terminated array of argument types, and
5137 sets *PVARARGS to indicate whether this is a varargs function. */
5140 stab_demangle_v3_arglist (void *dhandle, struct stab_handle *info,
5141 struct demangle_component *arglist,
5142 bfd_boolean *pvarargs)
5144 struct demangle_component *dc;
5145 unsigned int alloc, count;
5149 pargs = (debug_type *) xmalloc (alloc * sizeof *pargs);
5156 dc = dc->u.s_binary.right)
5159 bfd_boolean varargs;
5161 if (dc->type != DEMANGLE_COMPONENT_ARGLIST)
5163 fprintf (stderr, _("Unexpected type in v3 arglist demangling\n"));
5168 /* PR 13925: Cope if the demangler returns an empty
5169 context for a function with no arguments. */
5170 if (dc->u.s_binary.left == NULL)
5173 arg = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left,
5186 if (count + 1 >= alloc)
5189 pargs = (debug_type *) xrealloc (pargs, alloc * sizeof *pargs);
5196 pargs[count] = DEBUG_TYPE_NULL;
5201 /* Convert a struct demangle_component tree describing an argument
5202 type into a debug_type. */
5205 stab_demangle_v3_arg (void *dhandle, struct stab_handle *info,
5206 struct demangle_component *dc, debug_type context,
5207 bfd_boolean *pvarargs)
5211 if (pvarargs != NULL)
5216 /* FIXME: These are demangle component types which we probably
5217 need to handle one way or another. */
5218 case DEMANGLE_COMPONENT_LOCAL_NAME:
5219 case DEMANGLE_COMPONENT_TYPED_NAME:
5220 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
5221 case DEMANGLE_COMPONENT_CTOR:
5222 case DEMANGLE_COMPONENT_DTOR:
5223 case DEMANGLE_COMPONENT_JAVA_CLASS:
5224 case DEMANGLE_COMPONENT_RESTRICT_THIS:
5225 case DEMANGLE_COMPONENT_VOLATILE_THIS:
5226 case DEMANGLE_COMPONENT_CONST_THIS:
5227 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5228 case DEMANGLE_COMPONENT_COMPLEX:
5229 case DEMANGLE_COMPONENT_IMAGINARY:
5230 case DEMANGLE_COMPONENT_VENDOR_TYPE:
5231 case DEMANGLE_COMPONENT_ARRAY_TYPE:
5232 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5233 case DEMANGLE_COMPONENT_ARGLIST:
5235 fprintf (stderr, _("Unrecognized demangle component %d\n"),
5239 case DEMANGLE_COMPONENT_NAME:
5240 if (context != NULL)
5242 const debug_field *fields;
5244 fields = debug_get_fields (dhandle, context);
5247 /* Try to find this type by looking through the context
5249 for (; *fields != DEBUG_FIELD_NULL; fields++)
5254 ft = debug_get_field_type (dhandle, *fields);
5257 dn = debug_get_type_name (dhandle, ft);
5259 && (int) strlen (dn) == dc->u.s_name.len
5260 && strncmp (dn, dc->u.s_name.s, dc->u.s_name.len) == 0)
5265 return stab_find_tagged_type (dhandle, info, dc->u.s_name.s,
5266 dc->u.s_name.len, DEBUG_KIND_ILLEGAL);
5268 case DEMANGLE_COMPONENT_QUAL_NAME:
5269 context = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left,
5271 if (context == NULL)
5273 return stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.right,
5276 case DEMANGLE_COMPONENT_TEMPLATE:
5281 /* We print this component to get a class name which we can
5282 use. FIXME: This probably won't work if the template uses
5283 template parameters which refer to an outer template. */
5284 p = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, dc, 20, &alc);
5287 fprintf (stderr, _("Failed to print demangled template\n"));
5290 dt = stab_find_tagged_type (dhandle, info, p, strlen (p),
5296 case DEMANGLE_COMPONENT_SUB_STD:
5297 return stab_find_tagged_type (dhandle, info, dc->u.s_string.string,
5298 dc->u.s_string.len, DEBUG_KIND_ILLEGAL);
5300 case DEMANGLE_COMPONENT_RESTRICT:
5301 case DEMANGLE_COMPONENT_VOLATILE:
5302 case DEMANGLE_COMPONENT_CONST:
5303 case DEMANGLE_COMPONENT_POINTER:
5304 case DEMANGLE_COMPONENT_REFERENCE:
5305 dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL,
5314 case DEMANGLE_COMPONENT_RESTRICT:
5315 /* FIXME: We have no way to represent restrict. */
5317 case DEMANGLE_COMPONENT_VOLATILE:
5318 return debug_make_volatile_type (dhandle, dt);
5319 case DEMANGLE_COMPONENT_CONST:
5320 return debug_make_const_type (dhandle, dt);
5321 case DEMANGLE_COMPONENT_POINTER:
5322 return debug_make_pointer_type (dhandle, dt);
5323 case DEMANGLE_COMPONENT_REFERENCE:
5324 return debug_make_reference_type (dhandle, dt);
5327 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
5330 bfd_boolean varargs;
5332 if (dc->u.s_binary.left == NULL)
5334 /* In this case the return type is actually unknown.
5335 However, I'm not sure this will ever arise in practice;
5336 normally an unknown return type would only appear at
5337 the top level, which is handled above. */
5338 dt = debug_make_void_type (dhandle);
5341 dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL,
5346 pargs = stab_demangle_v3_arglist (dhandle, info,
5347 dc->u.s_binary.right,
5352 return debug_make_function_type (dhandle, dt, pargs, varargs);
5355 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
5361 /* We print this component in order to find out the type name.
5362 FIXME: Should we instead expose the
5363 demangle_builtin_type_info structure? */
5364 p = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, dc, 20, &alc);
5367 fprintf (stderr, _("Couldn't get demangled builtin type\n"));
5371 /* The mangling is based on the type, but does not itself
5372 indicate what the sizes are. So we have to guess. */
5373 if (strcmp (p, "signed char") == 0)
5374 ret = debug_make_int_type (dhandle, 1, FALSE);
5375 else if (strcmp (p, "bool") == 0)
5376 ret = debug_make_bool_type (dhandle, 1);
5377 else if (strcmp (p, "char") == 0)
5378 ret = debug_make_int_type (dhandle, 1, FALSE);
5379 else if (strcmp (p, "double") == 0)
5380 ret = debug_make_float_type (dhandle, 8);
5381 else if (strcmp (p, "long double") == 0)
5382 ret = debug_make_float_type (dhandle, 8);
5383 else if (strcmp (p, "float") == 0)
5384 ret = debug_make_float_type (dhandle, 4);
5385 else if (strcmp (p, "__float128") == 0)
5386 ret = debug_make_float_type (dhandle, 16);
5387 else if (strcmp (p, "unsigned char") == 0)
5388 ret = debug_make_int_type (dhandle, 1, TRUE);
5389 else if (strcmp (p, "int") == 0)
5390 ret = debug_make_int_type (dhandle, 4, FALSE);
5391 else if (strcmp (p, "unsigned int") == 0)
5392 ret = debug_make_int_type (dhandle, 4, TRUE);
5393 else if (strcmp (p, "long") == 0)
5394 ret = debug_make_int_type (dhandle, 4, FALSE);
5395 else if (strcmp (p, "unsigned long") == 0)
5396 ret = debug_make_int_type (dhandle, 4, TRUE);
5397 else if (strcmp (p, "__int128") == 0)
5398 ret = debug_make_int_type (dhandle, 16, FALSE);
5399 else if (strcmp (p, "unsigned __int128") == 0)
5400 ret = debug_make_int_type (dhandle, 16, TRUE);
5401 else if (strcmp (p, "short") == 0)
5402 ret = debug_make_int_type (dhandle, 2, FALSE);
5403 else if (strcmp (p, "unsigned short") == 0)
5404 ret = debug_make_int_type (dhandle, 2, TRUE);
5405 else if (strcmp (p, "void") == 0)
5406 ret = debug_make_void_type (dhandle);
5407 else if (strcmp (p, "wchar_t") == 0)
5408 ret = debug_make_int_type (dhandle, 4, TRUE);
5409 else if (strcmp (p, "long long") == 0)
5410 ret = debug_make_int_type (dhandle, 8, FALSE);
5411 else if (strcmp (p, "unsigned long long") == 0)
5412 ret = debug_make_int_type (dhandle, 8, TRUE);
5413 else if (strcmp (p, "...") == 0)
5415 if (pvarargs == NULL)
5416 fprintf (stderr, _("Unexpected demangled varargs\n"));
5423 fprintf (stderr, _("Unrecognized demangled builtin type\n"));