1 /* stabs.c -- Parse stabs debugging information
2 Copyright (C) 1995-2022 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. */
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. */
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. */
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);
149 static void bad_stab (const char *);
150 static void warn_stab (const char *, const char *);
151 static bool parse_stab_string
152 (void *, struct stab_handle
*, int, int, bfd_vma
,
153 const char *, const char *);
154 static debug_type parse_stab_type
155 (void *, struct stab_handle
*, const char *, const char **,
156 debug_type
**, const char *);
157 static bool parse_stab_type_number
158 (const char **, int *, const char *);
159 static debug_type parse_stab_range_type
160 (void *, struct stab_handle
*, const char *, const char **,
161 const int *, const char *);
162 static debug_type parse_stab_sun_builtin_type
163 (void *, const char **, const char *);
164 static debug_type parse_stab_sun_floating_type
165 (void *, const char **, const char *);
166 static debug_type parse_stab_enum_type
167 (void *, const char **, const char *);
168 static debug_type parse_stab_struct_type
169 (void *, struct stab_handle
*, const char *, const char **,
170 bool, const int *, const char *);
171 static bool parse_stab_baseclasses
172 (void *, struct stab_handle
*, const char **, debug_baseclass
**,
174 static bool parse_stab_struct_fields
175 (void *, struct stab_handle
*, const char **, debug_field
**,
176 bool *, const char *);
177 static bool parse_stab_cpp_abbrev
178 (void *, struct stab_handle
*, const char **, debug_field
*, const char *);
179 static bool parse_stab_one_struct_field
180 (void *, struct stab_handle
*, const char **, const char *,
181 debug_field
*, bool *, const char *);
182 static bool parse_stab_members
183 (void *, struct stab_handle
*, const char *, const char **, const int *,
184 debug_method
**, const char *);
185 static debug_type parse_stab_argtypes
186 (void *, struct stab_handle
*, debug_type
, const char *, const char *,
187 debug_type
, const char *, bool, bool, const char **);
188 static bool parse_stab_tilde_field
189 (void *, struct stab_handle
*, const char **, const int *, debug_type
*,
190 bool *, const char *);
191 static debug_type parse_stab_array_type
192 (void *, struct stab_handle
*, const char **, bool, const char *);
193 static void push_bincl (struct stab_handle
*, const char *, bfd_vma
);
194 static const char *pop_bincl (struct stab_handle
*);
195 static bool find_excl (struct stab_handle
*, const char *, bfd_vma
);
196 static bool stab_record_variable
197 (void *, struct stab_handle
*, const char *, debug_type
,
198 enum debug_var_kind
, bfd_vma
);
199 static bool stab_emit_pending_vars (void *, struct stab_handle
*);
200 static debug_type
*stab_find_slot (struct stab_handle
*, const int *);
201 static debug_type
stab_find_type (void *, struct stab_handle
*, const int *);
202 static bool stab_record_type
203 (void *, struct stab_handle
*, const int *, debug_type
);
204 static debug_type stab_xcoff_builtin_type
205 (void *, struct stab_handle
*, unsigned int);
206 static debug_type stab_find_tagged_type
207 (void *, struct stab_handle
*, const char *, int, enum debug_type_kind
);
208 static debug_type
*stab_demangle_argtypes
209 (void *, struct stab_handle
*, const char *, bool *, unsigned int);
210 static debug_type
*stab_demangle_v3_argtypes
211 (void *, struct stab_handle
*, const char *, bool *);
212 static debug_type
*stab_demangle_v3_arglist
213 (void *, struct stab_handle
*, struct demangle_component
*, bool *);
214 static debug_type stab_demangle_v3_arg
215 (void *, struct stab_handle
*, struct demangle_component
*, debug_type
,
218 static int demangle_flags
= DMGL_ANSI
;
220 /* Save a string in memory. */
223 savestring (const char *start
, int len
)
227 ret
= (char *) xmalloc (len
+ 1);
228 memcpy (ret
, start
, len
);
233 /* Read a number from a string. */
236 parse_number (const char **pp
, bool *poverflow
, const char *p_end
)
241 if (poverflow
!= NULL
)
248 /* Stop early if we are passed an empty string. */
253 ul
= strtoul (*pp
, (char **) pp
, 0);
254 if (ul
+ 1 != 0 || errno
== 0)
256 /* If bfd_vma is larger than unsigned long, and the number is
257 meant to be negative, we have to make sure that we sign
260 return (bfd_vma
) (bfd_signed_vma
) (long) ul
;
264 /* Note that even though strtoul overflowed, it should have set *pp
265 to the end of the number, which is where we want it. */
266 if (sizeof (bfd_vma
) > sizeof (unsigned long))
271 bfd_vma over
, lastdig
;
275 /* Our own version of strtoul, for a bfd_vma. */
290 if (p
[1] == 'x' || p
[1] == 'X')
302 over
= ((bfd_vma
) (bfd_signed_vma
) -1) / (bfd_vma
) base
;
303 lastdig
= ((bfd_vma
) (bfd_signed_vma
) -1) % (bfd_vma
) base
;
314 else if (ISUPPER (d
))
316 else if (ISLOWER (d
))
324 if (v
> over
|| (v
== over
&& (bfd_vma
) d
> lastdig
))
339 /* If we get here, the number is too large to represent in a
341 if (poverflow
!= NULL
)
344 warn_stab (orig
, _("numeric overflow"));
349 /* Give an error for a bad stab string. */
352 bad_stab (const char *p
)
354 fprintf (stderr
, _("Bad stab: %s\n"), p
);
357 /* Warn about something in a stab string. */
360 warn_stab (const char *p
, const char *err
)
362 fprintf (stderr
, _("Warning: %s: %s\n"), err
, p
);
365 /* Create a handle to parse stabs symbols with. */
368 start_stab (void *dhandle ATTRIBUTE_UNUSED
, bfd
*abfd
, bool sections
,
369 asymbol
**syms
, long symcount
)
371 struct stab_handle
*ret
;
373 ret
= (struct stab_handle
*) xmalloc (sizeof *ret
);
374 memset (ret
, 0, sizeof *ret
);
376 ret
->sections
= sections
;
378 ret
->symcount
= symcount
;
380 ret
->file_types
= (struct stab_types
**) xmalloc (sizeof *ret
->file_types
);
381 ret
->file_types
[0] = NULL
;
382 ret
->function_end
= (bfd_vma
) -1;
386 /* When we have processed all the stabs information, we need to go
387 through and fill in all the undefined tags. */
390 finish_stab (void *dhandle
, void *handle
)
392 struct stab_handle
*info
= (struct stab_handle
*) handle
;
395 if (info
->within_function
)
397 if (! stab_emit_pending_vars (dhandle
, info
)
398 || ! debug_end_function (dhandle
, info
->function_end
))
400 info
->within_function
= false;
401 info
->function_end
= (bfd_vma
) -1;
404 for (st
= info
->tags
; st
!= NULL
; st
= st
->next
)
406 enum debug_type_kind kind
;
409 if (kind
== DEBUG_KIND_ILLEGAL
)
410 kind
= DEBUG_KIND_STRUCT
;
411 st
->slot
= debug_make_undefined_tagged_type (dhandle
, st
->name
, kind
);
412 if (st
->slot
== DEBUG_TYPE_NULL
)
419 /* Handle a single stabs symbol. */
422 parse_stab (void *dhandle
, void *handle
, int type
, int desc
, bfd_vma value
,
425 const char * string_end
;
426 struct stab_handle
*info
= (struct stab_handle
*) handle
;
428 /* gcc will emit two N_SO strings per compilation unit, one for the
429 directory name and one for the file name. We just collect N_SO
430 strings as we see them, and start the new compilation unit when
431 we see a non N_SO symbol. */
432 if (info
->so_string
!= NULL
433 && (type
!= N_SO
|| *string
== '\0' || value
!= info
->so_value
))
435 if (! debug_set_filename (dhandle
, info
->so_string
))
437 info
->main_filename
= info
->so_string
;
439 info
->gcc_compiled
= 0;
440 info
->n_opt_found
= false;
442 /* Generally, for stabs in the symbol table, the N_LBRAC and
443 N_RBRAC symbols are relative to the N_SO symbol value. */
444 if (! info
->sections
)
445 info
->file_start_offset
= info
->so_value
;
447 /* We need to reset the mapping from type numbers to types. We
448 can't free the old mapping, because of the use of
449 debug_make_indirect_type. */
451 info
->file_types
= ((struct stab_types
**)
452 xmalloc (sizeof *info
->file_types
));
453 info
->file_types
[0] = NULL
;
454 info
->so_string
= NULL
;
456 /* Now process whatever type we just got. */
459 string_end
= string
+ strlen (string
);
468 /* Ignore extra outermost context from SunPRO cc and acc. */
469 if (info
->n_opt_found
&& desc
== 1)
472 if (! info
->within_function
)
474 fprintf (stderr
, _("N_LBRAC not within function\n"));
478 /* Start an inner lexical block. */
479 if (! debug_start_block (dhandle
,
481 + info
->file_start_offset
482 + info
->function_start_offset
)))
485 /* Emit any pending variable definitions. */
486 if (! stab_emit_pending_vars (dhandle
, info
))
493 /* Ignore extra outermost context from SunPRO cc and acc. */
494 if (info
->n_opt_found
&& desc
== 1)
497 /* We shouldn't have any pending variable definitions here, but,
498 if we do, we probably need to emit them before closing the
500 if (! stab_emit_pending_vars (dhandle
, info
))
503 /* End an inner lexical block. */
504 if (! debug_end_block (dhandle
,
506 + info
->file_start_offset
507 + info
->function_start_offset
)))
511 if (info
->block_depth
< 0)
513 fprintf (stderr
, _("Too many N_RBRACs\n"));
519 /* This always ends a function. */
520 if (info
->within_function
)
526 && info
->function_end
!= (bfd_vma
) -1
527 && info
->function_end
< endval
)
528 endval
= info
->function_end
;
529 if (! stab_emit_pending_vars (dhandle
, info
)
530 || ! debug_end_function (dhandle
, endval
))
532 info
->within_function
= false;
533 info
->function_end
= (bfd_vma
) -1;
536 /* An empty string is emitted by gcc at the end of a compilation
541 /* Just accumulate strings until we see a non N_SO symbol. If
542 the string starts with a directory separator or some other
543 form of absolute path specification, we discard the previously
544 accumulated strings. */
545 if (info
->so_string
== NULL
)
546 info
->so_string
= xstrdup (string
);
553 if (IS_ABSOLUTE_PATH (string
))
554 info
->so_string
= xstrdup (string
);
556 info
->so_string
= concat (info
->so_string
, string
,
557 (const char *) NULL
);
561 info
->so_value
= value
;
566 /* Start an include file. */
567 if (! debug_start_source (dhandle
, string
))
572 /* Start an include file which may be replaced. */
573 push_bincl (info
, string
, value
);
574 if (! debug_start_source (dhandle
, string
))
579 /* End an N_BINCL include. */
580 if (! debug_start_source (dhandle
, pop_bincl (info
)))
585 /* This is a duplicate of a header file named by N_BINCL which
586 was eliminated by the linker. */
587 if (! find_excl (info
, string
, value
))
592 if (! debug_record_line (dhandle
, desc
,
593 value
+ (info
->within_function
594 ? info
->function_start_offset
: 0)))
599 if (! debug_start_common_block (dhandle
, string
))
604 if (! debug_end_common_block (dhandle
, string
))
611 if (info
->within_function
)
613 /* This always marks the end of a function; we don't
614 need to worry about info->function_end. */
616 value
+= info
->function_start_offset
;
617 if (! stab_emit_pending_vars (dhandle
, info
)
618 || ! debug_end_function (dhandle
, value
))
620 info
->within_function
= false;
621 info
->function_end
= (bfd_vma
) -1;
626 /* A const static symbol in the .text section will have an N_FUN
627 entry. We need to use these to mark the end of the function,
628 in case we are looking at gcc output before it was changed to
629 always emit an empty N_FUN. We can't call debug_end_function
630 here, because it might be a local static symbol. */
631 if (info
->within_function
632 && (info
->function_end
== (bfd_vma
) -1
633 || value
< info
->function_end
))
634 info
->function_end
= value
;
637 /* FIXME: gdb checks the string for N_STSYM, N_LCSYM or N_ROSYM
638 symbols, and if it does not start with :S, gdb relocates the
639 value to the start of the section. gcc always seems to use
640 :S, so we don't worry about this. */
646 colon
= strchr (string
, ':');
648 && (colon
[1] == 'f' || colon
[1] == 'F'))
650 if (info
->within_function
)
655 if (info
->function_end
!= (bfd_vma
) -1
656 && info
->function_end
< endval
)
657 endval
= info
->function_end
;
658 if (! stab_emit_pending_vars (dhandle
, info
)
659 || ! debug_end_function (dhandle
, endval
))
661 info
->function_end
= (bfd_vma
) -1;
663 /* For stabs in sections, line numbers and block addresses
664 are offsets from the start of the function. */
666 info
->function_start_offset
= value
;
667 info
->within_function
= true;
670 if (! parse_stab_string (dhandle
, info
, type
, desc
, value
, string
, string_end
))
676 if (string
!= NULL
&& strcmp (string
, "gcc2_compiled.") == 0)
677 info
->gcc_compiled
= 2;
678 else if (string
!= NULL
&& strcmp (string
, "gcc_compiled.") == 0)
679 info
->gcc_compiled
= 1;
681 info
->n_opt_found
= true;
694 /* Parse the stabs string. */
697 parse_stab_string (void *dhandle
, struct stab_handle
*info
, int stabtype
,
698 int desc ATTRIBUTE_UNUSED
, bfd_vma value
,
699 const char *string
, const char * string_end
)
709 p
= strchr (string
, ':');
724 /* FIXME: Sometimes the special C++ names start with '.'. */
726 if (string
[0] == '$')
734 /* Was: name = "vptr"; */
740 /* This was an anonymous type that was never fixed up. */
743 /* SunPRO (3.0 at least) static variable encoding. */
746 warn_stab (string
, _("unknown C++ encoded name"));
753 if (p
== string
|| (string
[0] == ' ' && p
== string
+ 1))
756 name
= savestring (string
, p
- string
);
760 if (ISDIGIT (*p
) || *p
== '(' || *p
== '-')
773 /* c is a special case, not followed by a type-number.
774 SYMBOL:c=iVALUE for an integer constant symbol.
775 SYMBOL:c=rVALUE for a floating constant symbol.
776 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
777 e.g. "b:c=e6,0" for "const b = blob1"
778 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
788 /* Floating point constant. */
789 if (! debug_record_float_const (dhandle
, name
, atof (p
)))
793 /* Integer constant. */
794 /* Defining integer constants this way is kind of silly,
795 since 'e' constants allows the compiler to give not only
796 the value, but the type as well. C has at least int,
797 long, unsigned int, and long long as constant types;
798 other languages probably should have at least unsigned as
799 well as signed constants. */
800 if (! debug_record_int_const (dhandle
, name
, atoi (p
)))
804 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
805 can be represented as integral.
806 e.g. "b:c=e6,0" for "const b = blob1"
807 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
808 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
809 &p
, (debug_type
**) NULL
, string_end
);
810 if (dtype
== DEBUG_TYPE_NULL
)
817 if (! debug_record_typed_const (dhandle
, name
, dtype
, atoi (p
)))
828 /* The name of a caught exception. */
829 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
830 &p
, (debug_type
**) NULL
, string_end
);
831 if (dtype
== DEBUG_TYPE_NULL
)
833 if (! debug_record_label (dhandle
, name
, dtype
, value
))
839 /* A function definition. */
840 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
841 (debug_type
**) NULL
, string_end
);
842 if (dtype
== DEBUG_TYPE_NULL
)
844 if (! debug_record_function (dhandle
, name
, dtype
, type
== 'F', value
))
847 /* Sun acc puts declared types of arguments here. We don't care
848 about their actual types (FIXME -- we should remember the whole
849 function prototype), but the list may define some new types
850 that we have to remember, so we must scan it now. */
854 if (parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
855 (debug_type
**) NULL
, string_end
)
866 /* A global symbol. The value must be extracted from the
868 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
869 (debug_type
**) NULL
, string_end
);
870 if (dtype
== DEBUG_TYPE_NULL
)
877 leading
= bfd_get_symbol_leading_char (info
->abfd
);
878 for (c
= info
->symcount
, ps
= info
->syms
; c
> 0; --c
, ++ps
)
882 n
= bfd_asymbol_name (*ps
);
883 if (leading
!= '\0' && *n
== leading
)
885 if (*n
== *name
&& strcmp (n
, name
) == 0)
890 value
= bfd_asymbol_value (*ps
);
893 if (! stab_record_variable (dhandle
, info
, name
, dtype
, DEBUG_GLOBAL
,
899 /* This case is faked by a conditional above, when there is no
900 code letter in the dbx data. Dbx data never actually
904 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
905 (debug_type
**) NULL
, string_end
);
906 if (dtype
== DEBUG_TYPE_NULL
)
908 if (! stab_record_variable (dhandle
, info
, name
, dtype
, DEBUG_LOCAL
,
914 /* A function parameter. */
916 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
917 (debug_type
**) NULL
, string_end
);
920 /* pF is a two-letter code that means a function parameter in
921 Fortran. The type-number specifies the type of the return
922 value. Translate it into a pointer-to-function type. */
924 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
925 (debug_type
**) NULL
, string_end
);
926 if (dtype
!= DEBUG_TYPE_NULL
)
930 ftype
= debug_make_function_type (dhandle
, dtype
,
931 (debug_type
*) NULL
, false);
932 dtype
= debug_make_pointer_type (dhandle
, ftype
);
935 if (dtype
== DEBUG_TYPE_NULL
)
937 if (! debug_record_parameter (dhandle
, name
, dtype
, DEBUG_PARM_STACK
,
941 /* FIXME: At this point gdb considers rearranging the parameter
942 address on a big endian machine if it is smaller than an int.
943 We have no way to do that, since we don't really know much
948 if (stabtype
== N_FUN
)
950 /* Prototype of a function referenced by this file. */
954 if (parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
955 (debug_type
**) NULL
, string_end
)
963 /* Parameter which is in a register. */
964 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
965 (debug_type
**) NULL
, string_end
);
966 if (dtype
== DEBUG_TYPE_NULL
)
968 if (! debug_record_parameter (dhandle
, name
, dtype
, DEBUG_PARM_REG
,
974 /* Register variable (either global or local). */
975 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
976 (debug_type
**) NULL
, string_end
);
977 if (dtype
== DEBUG_TYPE_NULL
)
979 if (! stab_record_variable (dhandle
, info
, name
, dtype
, DEBUG_REGISTER
,
983 /* FIXME: At this point gdb checks to combine pairs of 'p' and
984 'r' stabs into a single 'P' stab. */
988 /* Static symbol at top level of file. */
989 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
990 (debug_type
**) NULL
, string_end
);
991 if (dtype
== DEBUG_TYPE_NULL
)
993 if (! stab_record_variable (dhandle
, info
, name
, dtype
, DEBUG_STATIC
,
1000 dtype
= parse_stab_type (dhandle
, info
, name
, &p
, &slot
, string_end
);
1001 if (dtype
== DEBUG_TYPE_NULL
)
1005 /* A nameless type. Nothing to do. */
1009 dtype
= debug_name_type (dhandle
, name
, dtype
);
1010 if (dtype
== DEBUG_TYPE_NULL
)
1019 /* Struct, union, or enum tag. For GNU C++, this can be followed
1020 by 't' which means we are typedef'ing it as well. */
1024 /* FIXME: gdb sets synonym to TRUE if the current language
1033 dtype
= parse_stab_type (dhandle
, info
, name
, &p
, &slot
, string_end
);
1034 if (dtype
== DEBUG_TYPE_NULL
)
1039 /* INFO->SELF_CROSSREF is set by parse_stab_type if this type is
1040 a cross reference to itself. These are generated by some
1042 self_crossref
= info
->self_crossref
;
1044 dtype
= debug_tag_type (dhandle
, name
, dtype
);
1045 if (dtype
== DEBUG_TYPE_NULL
)
1050 /* See if we have a cross reference to this tag which we can now
1051 fill in. Avoid filling in a cross reference to ourselves,
1052 because that would lead to circular debugging information. */
1053 if (! self_crossref
)
1055 register struct stab_tag
**pst
;
1057 for (pst
= &info
->tags
; *pst
!= NULL
; pst
= &(*pst
)->next
)
1059 if ((*pst
)->name
[0] == name
[0]
1060 && strcmp ((*pst
)->name
, name
) == 0)
1062 (*pst
)->slot
= dtype
;
1063 *pst
= (*pst
)->next
;
1071 dtype
= debug_name_type (dhandle
, name
, dtype
);
1072 if (dtype
== DEBUG_TYPE_NULL
)
1082 /* Static symbol of local scope */
1083 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
1084 (debug_type
**) NULL
, string_end
);
1085 if (dtype
== DEBUG_TYPE_NULL
)
1087 /* FIXME: gdb checks os9k_stabs here. */
1088 if (! stab_record_variable (dhandle
, info
, name
, dtype
,
1089 DEBUG_LOCAL_STATIC
, value
))
1094 /* Reference parameter. */
1095 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
1096 (debug_type
**) NULL
, string_end
);
1097 if (dtype
== DEBUG_TYPE_NULL
)
1099 if (! debug_record_parameter (dhandle
, name
, dtype
, DEBUG_PARM_REFERENCE
,
1105 /* Reference parameter which is in a register. */
1106 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
1107 (debug_type
**) NULL
, string_end
);
1108 if (dtype
== DEBUG_TYPE_NULL
)
1110 if (! debug_record_parameter (dhandle
, name
, dtype
, DEBUG_PARM_REF_REG
,
1116 /* This is used by Sun FORTRAN for "function result value".
1117 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1118 that Pascal uses it too, but when I tried it Pascal used
1119 "x:3" (local symbol) instead. */
1120 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
1121 (debug_type
**) NULL
, string_end
);
1122 if (dtype
== DEBUG_TYPE_NULL
)
1124 if (! stab_record_variable (dhandle
, info
, name
, dtype
, DEBUG_LOCAL
,
1130 /* SUNPro C++ Namespace =Yn0. */
1131 /* Skip the namespace mapping, as it is not used now. */
1132 if (*p
++ != 0 && *p
++ == 'n' && *p
++ == '0')
1135 while (*p
&& *p
!= ';')
1140 /* TODO SUNPro C++ support:
1141 Support default arguments after F,P parameters
1142 Ya = Anonymous unions
1143 YM,YD = Pointers to class members
1145 YR = Run-time type information (RTTI) */
1154 /* FIXME: gdb converts structure values to structure pointers in a
1155 couple of cases, depending upon the target. */
1160 /* Parse a stabs type. The typename argument is non-NULL if this is a
1161 typedef or a tag definition. The pp argument points to the stab
1162 string, and is updated. The slotp argument points to a place to
1163 store the slot used if the type is being defined. */
1166 parse_stab_type (void * dhandle
,
1167 struct stab_handle
* info
,
1168 const char * type_name
,
1170 debug_type
** slotp
,
1185 return DEBUG_TYPE_NULL
;
1190 info
->self_crossref
= false;
1192 /* Read type number if present. The type number may be omitted.
1193 for instance in a two-dimensional array declared with type
1194 "ar1;1;10;ar1;1;10;4". */
1195 if (! ISDIGIT (**pp
) && **pp
!= '(' && **pp
!= '-')
1197 /* 'typenums=' not present, type is anonymous. Read and return
1198 the definition, but don't put it in the type vector. */
1199 typenums
[0] = typenums
[1] = -1;
1203 if (! parse_stab_type_number (pp
, typenums
, p_end
))
1204 return DEBUG_TYPE_NULL
;
1207 /* Type is not being defined here. Either it already
1208 exists, or this is a forward reference to it. */
1209 return stab_find_type (dhandle
, info
, typenums
);
1211 /* Only set the slot if the type is being defined. This means
1212 that the mapping from type numbers to types will only record
1213 the name of the typedef which defines a type. If we don't do
1214 this, then something like
1217 will record that i is of type foo. Unfortunately, stabs
1218 information is ambiguous about variable types. For this code,
1222 the stabs information records both i and j as having the same
1223 type. This could be fixed by patching the compiler. */
1224 if (slotp
!= NULL
&& typenums
[0] >= 0 && typenums
[1] >= 0)
1225 *slotp
= stab_find_slot (info
, typenums
);
1227 /* Type is being defined here. */
1233 const char *p
= *pp
+ 1;
1236 if (ISDIGIT (*p
) || *p
== '(' || *p
== '-')
1240 /* Type attributes. */
1243 for (; *p
!= ';'; ++p
)
1248 return DEBUG_TYPE_NULL
;
1256 size
= atoi (attr
+ 1);
1257 size
/= 8; /* Size is in bits. We store it in bytes. */
1268 return DEBUG_TYPE_NULL
;
1271 /* Ignore unrecognized type attributes, so future
1272 compilers can invent new ones. */
1285 enum debug_type_kind code
;
1286 const char *q1
, *q2
, *p
;
1288 /* A cross reference to another type. */
1292 code
= DEBUG_KIND_STRUCT
;
1295 code
= DEBUG_KIND_UNION
;
1298 code
= DEBUG_KIND_ENUM
;
1302 return DEBUG_TYPE_NULL
;
1305 /* Complain and keep going, so compilers can invent new
1306 cross-reference types. */
1307 warn_stab (orig
, _("unrecognized cross reference type"));
1308 code
= DEBUG_KIND_STRUCT
;
1313 q1
= strchr (*pp
, '<');
1314 p
= strchr (*pp
, ':');
1318 return DEBUG_TYPE_NULL
;
1320 if (q1
!= NULL
&& p
> q1
&& p
[1] == ':')
1324 for (q2
= q1
; *q2
!= '\0'; ++q2
)
1328 else if (*q2
== '>')
1330 else if (*q2
== ':' && nest
== 0)
1337 return DEBUG_TYPE_NULL
;
1341 /* Some versions of g++ can emit stabs like
1343 which define structures in terms of themselves. We need to
1344 tell the caller to avoid building a circular structure. */
1345 if (type_name
!= NULL
1346 && strncmp (type_name
, *pp
, p
- *pp
) == 0
1347 && type_name
[p
- *pp
] == '\0')
1348 info
->self_crossref
= true;
1350 dtype
= stab_find_tagged_type (dhandle
, info
, *pp
, p
- *pp
, code
);
1372 /* This type is defined as another type. */
1376 /* Peek ahead at the number to detect void. */
1377 if (! parse_stab_type_number (pp
, xtypenums
, p_end
))
1378 return DEBUG_TYPE_NULL
;
1380 if (typenums
[0] == xtypenums
[0] && typenums
[1] == xtypenums
[1])
1382 /* This type is being defined as itself, which means that
1384 dtype
= debug_make_void_type (dhandle
);
1390 /* Go back to the number and have parse_stab_type get it.
1391 This means that we can deal with something like
1392 t(1,2)=(3,4)=... which the Lucid compiler uses. */
1393 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
1394 pp
, (debug_type
**) NULL
, p_end
);
1395 if (dtype
== DEBUG_TYPE_NULL
)
1396 return DEBUG_TYPE_NULL
;
1399 if (typenums
[0] != -1)
1401 if (! stab_record_type (dhandle
, info
, typenums
, dtype
))
1402 return DEBUG_TYPE_NULL
;
1409 dtype
= debug_make_pointer_type (dhandle
,
1410 parse_stab_type (dhandle
, info
,
1411 (const char *) NULL
,
1413 (debug_type
**) NULL
,
1418 /* Reference to another type. */
1419 dtype
= (debug_make_reference_type
1421 parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
1422 (debug_type
**) NULL
, p_end
)));
1426 /* Function returning another type. */
1427 /* FIXME: gdb checks os9k_stabs here. */
1428 dtype
= (debug_make_function_type
1430 parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
1431 (debug_type
**) NULL
, p_end
),
1432 (debug_type
*) NULL
, false));
1436 /* Const qualifier on some type (Sun). */
1437 /* FIXME: gdb accepts 'c' here if os9k_stabs. */
1438 dtype
= debug_make_const_type (dhandle
,
1439 parse_stab_type (dhandle
, info
,
1440 (const char *) NULL
,
1442 (debug_type
**) NULL
,
1447 /* Volatile qual on some type (Sun). */
1448 /* FIXME: gdb accepts 'i' here if os9k_stabs. */
1449 dtype
= (debug_make_volatile_type
1451 parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
1452 (debug_type
**) NULL
, p_end
)));
1456 /* Offset (class & variable) type. This is used for a pointer
1457 relative to an object. */
1464 domain
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
1465 (debug_type
**) NULL
, p_end
);
1466 if (domain
== DEBUG_TYPE_NULL
)
1467 return DEBUG_TYPE_NULL
;
1472 return DEBUG_TYPE_NULL
;
1476 memtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
1477 (debug_type
**) NULL
, p_end
);
1478 if (memtype
== DEBUG_TYPE_NULL
)
1479 return DEBUG_TYPE_NULL
;
1481 dtype
= debug_make_offset_type (dhandle
, domain
, memtype
);
1486 /* Method (class & fn) type. */
1489 debug_type return_type
;
1492 return_type
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
1493 pp
, (debug_type
**) NULL
, p_end
);
1494 if (return_type
== DEBUG_TYPE_NULL
)
1495 return DEBUG_TYPE_NULL
;
1499 return DEBUG_TYPE_NULL
;
1502 dtype
= debug_make_method_type (dhandle
, return_type
,
1504 (debug_type
*) NULL
, false);
1509 debug_type return_type
;
1515 domain
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
1516 pp
, (debug_type
**) NULL
, p_end
);
1517 if (domain
== DEBUG_TYPE_NULL
)
1518 return DEBUG_TYPE_NULL
;
1523 return DEBUG_TYPE_NULL
;
1527 return_type
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
1528 pp
, (debug_type
**) NULL
, p_end
);
1529 if (return_type
== DEBUG_TYPE_NULL
)
1530 return DEBUG_TYPE_NULL
;
1533 args
= (debug_type
*) xmalloc (alloc
* sizeof *args
);
1540 return DEBUG_TYPE_NULL
;
1547 args
= ((debug_type
*)
1548 xrealloc (args
, alloc
* sizeof *args
));
1551 args
[n
] = parse_stab_type (dhandle
, info
, (const char *) NULL
,
1552 pp
, (debug_type
**) NULL
, p_end
);
1553 if (args
[n
] == DEBUG_TYPE_NULL
)
1554 return DEBUG_TYPE_NULL
;
1559 /* If the last type is not void, then this function takes a
1560 variable number of arguments. Otherwise, we must strip
1563 || debug_get_type_kind (dhandle
, args
[n
- 1]) != DEBUG_KIND_VOID
)
1571 args
[n
] = DEBUG_TYPE_NULL
;
1573 dtype
= debug_make_method_type (dhandle
, return_type
, domain
, args
,
1580 dtype
= parse_stab_range_type (dhandle
, info
, type_name
, pp
, typenums
, p_end
);
1584 /* FIXME: gdb checks os9k_stabs here. */
1585 /* Sun ACC builtin int type. */
1586 dtype
= parse_stab_sun_builtin_type (dhandle
, pp
, p_end
);
1590 /* Sun ACC builtin float type. */
1591 dtype
= parse_stab_sun_floating_type (dhandle
, pp
, p_end
);
1595 /* Enumeration type. */
1596 dtype
= parse_stab_enum_type (dhandle
, pp
, p_end
);
1601 /* Struct or union type. */
1602 dtype
= parse_stab_struct_type (dhandle
, info
, type_name
, pp
,
1603 descriptor
== 's', typenums
, p_end
);
1611 return DEBUG_TYPE_NULL
;
1615 dtype
= parse_stab_array_type (dhandle
, info
, pp
, stringp
, p_end
);
1619 dtype
= debug_make_set_type (dhandle
,
1620 parse_stab_type (dhandle
, info
,
1621 (const char *) NULL
,
1623 (debug_type
**) NULL
,
1630 return DEBUG_TYPE_NULL
;
1633 if (dtype
== DEBUG_TYPE_NULL
)
1634 return DEBUG_TYPE_NULL
;
1636 if (typenums
[0] != -1)
1638 if (! stab_record_type (dhandle
, info
, typenums
, dtype
))
1639 return DEBUG_TYPE_NULL
;
1644 if (! debug_record_type_size (dhandle
, dtype
, (unsigned int) size
))
1645 return DEBUG_TYPE_NULL
;
1651 /* Read a number by which a type is referred to in dbx data, or
1652 perhaps read a pair (FILENUM, TYPENUM) in parentheses. Just a
1653 single number N is equivalent to (0,N). Return the two numbers by
1654 storing them in the vector TYPENUMS. */
1657 parse_stab_type_number (const char **pp
, int *typenums
, const char *p_end
)
1666 typenums
[1] = (int) parse_number (pp
, (bool *) NULL
, p_end
);
1671 typenums
[0] = (int) parse_number (pp
, (bool *) NULL
, p_end
);
1679 typenums
[1] = (int) parse_number (pp
, (bool *) NULL
, p_end
);
1690 /* Parse a range type. */
1693 parse_stab_range_type (void * dhandle
,
1694 struct stab_handle
* info
,
1695 const char * type_name
,
1697 const int * typenums
,
1703 debug_type index_type
;
1704 const char *s2
, *s3
;
1705 bfd_signed_vma n2
, n3
;
1710 return DEBUG_TYPE_NULL
;
1712 index_type
= DEBUG_TYPE_NULL
;
1714 /* First comes a type we are a subrange of.
1715 In C it is usually 0, 1 or the type being defined. */
1716 if (! parse_stab_type_number (pp
, rangenums
, p_end
))
1717 return DEBUG_TYPE_NULL
;
1719 self_subrange
= (rangenums
[0] == typenums
[0]
1720 && rangenums
[1] == typenums
[1]);
1725 index_type
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
1726 pp
, (debug_type
**) NULL
, p_end
);
1727 if (index_type
== DEBUG_TYPE_NULL
)
1728 return DEBUG_TYPE_NULL
;
1734 /* The remaining two operands are usually lower and upper bounds of
1735 the range. But in some special cases they mean something else. */
1737 n2
= parse_number (pp
, &ov2
, p_end
);
1741 return DEBUG_TYPE_NULL
;
1746 n3
= parse_number (pp
, &ov3
, p_end
);
1750 return DEBUG_TYPE_NULL
;
1756 /* gcc will emit range stabs for long long types. Handle this
1757 as a special case. FIXME: This needs to be more general. */
1758 #define LLLOW "01000000000000000000000;"
1759 #define LLHIGH "0777777777777777777777;"
1760 #define ULLHIGH "01777777777777777777777;"
1761 if (index_type
== DEBUG_TYPE_NULL
)
1763 if (startswith (s2
, LLLOW
)
1764 && startswith (s3
, LLHIGH
))
1765 return debug_make_int_type (dhandle
, 8, false);
1768 && startswith (s3
, ULLHIGH
))
1769 return debug_make_int_type (dhandle
, 8, true);
1772 warn_stab (orig
, _("numeric overflow"));
1775 if (index_type
== DEBUG_TYPE_NULL
)
1777 /* A type defined as a subrange of itself, with both bounds 0,
1779 if (self_subrange
&& n2
== 0 && n3
== 0)
1780 return debug_make_void_type (dhandle
);
1782 /* A type defined as a subrange of itself, with n2 positive and
1783 n3 zero, is a complex type, and n2 is the number of bytes. */
1784 if (self_subrange
&& n3
== 0 && n2
> 0)
1785 return debug_make_complex_type (dhandle
, n2
);
1787 /* If n3 is zero and n2 is positive, this is a floating point
1788 type, and n2 is the number of bytes. */
1789 if (n3
== 0 && n2
> 0)
1790 return debug_make_float_type (dhandle
, n2
);
1792 /* If the upper bound is -1, this is an unsigned int. */
1793 if (n2
== 0 && n3
== -1)
1795 /* When gcc is used with -gstabs, but not -gstabs+, it will emit
1796 long long int:t6=r1;0;-1;
1797 long long unsigned int:t7=r1;0;-1;
1798 We hack here to handle this reasonably. */
1799 if (type_name
!= NULL
)
1801 if (strcmp (type_name
, "long long int") == 0)
1802 return debug_make_int_type (dhandle
, 8, false);
1803 else if (strcmp (type_name
, "long long unsigned int") == 0)
1804 return debug_make_int_type (dhandle
, 8, true);
1806 /* FIXME: The size here really depends upon the target. */
1807 return debug_make_int_type (dhandle
, 4, true);
1810 /* A range of 0 to 127 is char. */
1811 if (self_subrange
&& n2
== 0 && n3
== 127)
1812 return debug_make_int_type (dhandle
, 1, false);
1814 /* FIXME: gdb checks for the language CHILL here. */
1819 return debug_make_int_type (dhandle
, - n3
, true);
1820 else if (n3
== 0xff)
1821 return debug_make_int_type (dhandle
, 1, true);
1822 else if (n3
== 0xffff)
1823 return debug_make_int_type (dhandle
, 2, true);
1824 else if (n3
== (bfd_signed_vma
) 0xffffffff)
1825 return debug_make_int_type (dhandle
, 4, true);
1827 else if (n3
== (bfd_signed_vma
) 0xffffffffffffffffLL
)
1828 return debug_make_int_type (dhandle
, 8, true);
1833 && (self_subrange
|| n2
== -8))
1834 return debug_make_int_type (dhandle
, - n2
, true);
1835 else if (n2
== - n3
- 1 || n2
== n3
+ 1)
1838 return debug_make_int_type (dhandle
, 1, false);
1839 else if (n3
== 0x7fff)
1840 return debug_make_int_type (dhandle
, 2, false);
1841 else if (n3
== 0x7fffffff)
1842 return debug_make_int_type (dhandle
, 4, false);
1844 else if (n3
== ((((bfd_vma
) 0x7fffffff) << 32) | 0xffffffff))
1845 return debug_make_int_type (dhandle
, 8, false);
1850 /* At this point I don't have the faintest idea how to deal with a
1851 self_subrange type; I'm going to assume that this is used as an
1852 idiom, and that all of them are special cases. So . . . */
1856 return DEBUG_TYPE_NULL
;
1859 index_type
= stab_find_type (dhandle
, info
, rangenums
);
1860 if (index_type
== DEBUG_TYPE_NULL
)
1862 /* Does this actually ever happen? Is that why we are worrying
1863 about dealing with it rather than just calling error_type? */
1864 warn_stab (orig
, _("missing index type"));
1865 index_type
= debug_make_int_type (dhandle
, 4, false);
1868 return debug_make_range_type (dhandle
, index_type
, n2
, n3
);
1871 /* Sun's ACC uses a somewhat saner method for specifying the builtin
1872 typedefs in every file (for int, long, etc):
1874 type = b <signed> <width>; <offset>; <nbits>
1875 signed = u or s. Possible c in addition to u or s (for char?).
1876 offset = offset from high order bit to start bit of type.
1877 width is # bytes in object of this type, nbits is # bits in type.
1879 The width/offset stuff appears to be for small objects stored in
1880 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
1884 parse_stab_sun_builtin_type (void *dhandle
, const char **pp
, const char * p_end
)
1892 return DEBUG_TYPE_NULL
;
1904 return DEBUG_TYPE_NULL
;
1908 /* OpenSolaris source code indicates that one of "cbv" characters
1909 can come next and specify the intrinsic 'iformat' encoding.
1910 'c' is character encoding, 'b' is boolean encoding, and 'v' is
1911 varargs encoding. This field can be safely ignored because
1912 the type of the field is determined from the bitwidth extracted
1914 if (**pp
== 'c' || **pp
== 'b' || **pp
== 'v')
1917 /* The first number appears to be the number of bytes occupied
1918 by this type, except that unsigned short is 4 instead of 2.
1919 Since this information is redundant with the third number,
1920 we will ignore it. */
1921 (void) parse_number (pp
, (bool *) NULL
, p_end
);
1925 return DEBUG_TYPE_NULL
;
1929 /* The second number is always 0, so ignore it too. */
1930 (void) parse_number (pp
, (bool *) NULL
, p_end
);
1934 return DEBUG_TYPE_NULL
;
1938 /* The third number is the number of bits for this type. */
1939 bits
= parse_number (pp
, (bool *) NULL
, p_end
);
1941 /* The type *should* end with a semicolon. If it are embedded
1942 in a larger type the semicolon may be the only way to know where
1943 the type ends. If this type is at the end of the stabstring we
1944 can deal with the omitted semicolon (but we don't have to like
1945 it). Don't bother to complain(), Sun's compiler omits the semicolon
1951 return debug_make_void_type (dhandle
);
1953 return debug_make_int_type (dhandle
, bits
/ 8, unsignedp
);
1956 /* Parse a builtin floating type generated by the Sun compiler. */
1959 parse_stab_sun_floating_type (void *dhandle
, const char **pp
, const char *p_end
)
1967 return DEBUG_TYPE_NULL
;
1969 /* The first number has more details about the type, for example
1971 details
= parse_number (pp
, (bool *) NULL
, p_end
);
1975 return DEBUG_TYPE_NULL
;
1978 /* The second number is the number of bytes occupied by this type */
1979 bytes
= parse_number (pp
, (bool *) NULL
, p_end
);
1983 return DEBUG_TYPE_NULL
;
1986 if (details
== NF_COMPLEX
1987 || details
== NF_COMPLEX16
1988 || details
== NF_COMPLEX32
)
1989 return debug_make_complex_type (dhandle
, bytes
);
1991 return debug_make_float_type (dhandle
, bytes
);
1994 /* Handle an enum type. */
1997 parse_stab_enum_type (void *dhandle
, const char **pp
, const char * p_end
)
2001 bfd_signed_vma
*values
;
2007 return DEBUG_TYPE_NULL
;
2009 /* FIXME: gdb checks os9k_stabs here. */
2011 /* The aix4 compiler emits an extra field before the enum members;
2012 my guess is it's a type of some sort. Just ignore it. */
2015 while (**pp
!= ':' && **pp
!= 0)
2021 return DEBUG_TYPE_NULL
;
2026 /* Read the value-names and their values.
2027 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
2028 A semicolon or comma instead of a NAME means the end. */
2030 names
= (const char **) xmalloc (alloc
* sizeof *names
);
2031 values
= (bfd_signed_vma
*) xmalloc (alloc
* sizeof *values
);
2033 while (**pp
!= '\0' && **pp
!= ';' && **pp
!= ',')
2040 while (*p
!= ':' && *p
!= 0)
2048 return DEBUG_TYPE_NULL
;
2051 name
= savestring (*pp
, p
- *pp
);
2054 val
= (bfd_signed_vma
) parse_number (pp
, (bool *) NULL
, p_end
);
2061 return DEBUG_TYPE_NULL
;
2068 names
= ((const char **)
2069 xrealloc (names
, alloc
* sizeof *names
));
2070 values
= ((bfd_signed_vma
*)
2071 xrealloc (values
, alloc
* sizeof *values
));
2085 return debug_make_enum_type (dhandle
, names
, values
);
2088 /* Read the description of a structure (or union type) and return an object
2089 describing the type.
2091 PP points to a character pointer that points to the next unconsumed token
2092 in the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
2093 *PP will point to "4a:1,0,32;;". */
2096 parse_stab_struct_type (void *dhandle
,
2097 struct stab_handle
*info
,
2098 const char *tagname
,
2101 const int *typenums
,
2105 debug_baseclass
*baseclasses
;
2106 debug_field
*fields
= NULL
;
2108 debug_method
*methods
;
2109 debug_type vptrbase
;
2113 size
= parse_number (pp
, (bool *) NULL
, p_end
);
2115 /* Get the other information. */
2116 if (! parse_stab_baseclasses (dhandle
, info
, pp
, &baseclasses
, p_end
)
2117 || ! parse_stab_struct_fields (dhandle
, info
, pp
, &fields
, &statics
, p_end
)
2118 || ! parse_stab_members (dhandle
, info
, tagname
, pp
, typenums
, &methods
, p_end
)
2119 || ! parse_stab_tilde_field (dhandle
, info
, pp
, typenums
, &vptrbase
,
2123 return DEBUG_TYPE_NULL
;
2127 && baseclasses
== NULL
2129 && vptrbase
== DEBUG_TYPE_NULL
2131 return debug_make_struct_type (dhandle
, structp
, size
, fields
);
2133 return debug_make_object_type (dhandle
, structp
, size
, fields
, baseclasses
,
2134 methods
, vptrbase
, ownvptr
);
2137 /* The stabs for C++ derived classes contain baseclass information which
2138 is marked by a '!' character after the total size. This function is
2139 called when we encounter the baseclass marker, and slurps up all the
2140 baseclass information.
2142 Immediately following the '!' marker is the number of base classes that
2143 the class is derived from, followed by information for each base class.
2144 For each base class, there are two visibility specifiers, a bit offset
2145 to the base class information within the derived class, a reference to
2146 the type for the base class, and a terminating semicolon.
2148 A typical example, with two base classes, would be "!2,020,19;0264,21;".
2150 Baseclass information marker __________________|| | | | | | |
2151 Number of baseclasses __________________________| | | | | | |
2152 Visibility specifiers (2) ________________________| | | | | |
2153 Offset in bits from start of class _________________| | | | |
2154 Type number for base class ___________________________| | | |
2155 Visibility specifiers (2) _______________________________| | |
2156 Offset in bits from start of class ________________________| |
2157 Type number of base class ____________________________________|
2159 Return TRUE for success, FALSE for failure. */
2162 parse_stab_baseclasses (void * dhandle
,
2163 struct stab_handle
* info
,
2165 debug_baseclass
** retp
,
2170 debug_baseclass
*classes
;
2180 /* No base classes. */
2185 c
= (unsigned int) parse_number (pp
, (bool *) NULL
, p_end
);
2194 classes
= (debug_baseclass
*) xmalloc ((c
+ 1) * sizeof (**retp
));
2196 for (i
= 0; i
< c
; i
++)
2199 enum debug_visibility visibility
;
2215 warn_stab (orig
, _("unknown virtual character for baseclass"));
2224 visibility
= DEBUG_VISIBILITY_PRIVATE
;
2227 visibility
= DEBUG_VISIBILITY_PROTECTED
;
2230 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2236 warn_stab (orig
, _("unknown visibility character for baseclass"));
2237 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2242 /* The remaining value is the bit offset of the portion of the
2243 object corresponding to this baseclass. Always zero in the
2244 absence of multiple inheritance. */
2245 bitpos
= parse_number (pp
, (bool *) NULL
, p_end
);
2253 type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2254 (debug_type
**) NULL
, p_end
);
2255 if (type
== DEBUG_TYPE_NULL
)
2258 classes
[i
] = debug_make_baseclass (dhandle
, type
, bitpos
, is_virtual
,
2260 if (classes
[i
] == DEBUG_BASECLASS_NULL
)
2268 classes
[i
] = DEBUG_BASECLASS_NULL
;
2275 /* Read struct or class data fields. They have the form:
2277 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2279 At the end, we see a semicolon instead of a field.
2281 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2284 The optional VISIBILITY is one of:
2286 '/0' (VISIBILITY_PRIVATE)
2287 '/1' (VISIBILITY_PROTECTED)
2288 '/2' (VISIBILITY_PUBLIC)
2289 '/9' (VISIBILITY_IGNORE)
2291 or nothing, for C style fields with public visibility.
2293 Returns 1 for success, 0 for failure. */
2296 parse_stab_struct_fields (void *dhandle
,
2297 struct stab_handle
*info
,
2305 debug_field
*fields
;
2318 fields
= (debug_field
*) xmalloc (alloc
* sizeof *fields
);
2321 /* FIXME: gdb checks os9k_stabs here. */
2325 /* Add 1 to c to leave room for NULL pointer at end. */
2329 fields
= ((debug_field
*)
2330 xrealloc (fields
, alloc
* sizeof *fields
));
2333 /* If it starts with CPLUS_MARKER it is a special abbreviation,
2334 unless the CPLUS_MARKER is followed by an underscore, in
2335 which case it is just the name of an anonymous type, which we
2336 should handle like any other type name. We accept either '$'
2337 or '.', because a field name can never contain one of these
2338 characters except as a CPLUS_MARKER. */
2340 if ((*p
== '$' || *p
== '.') && p
[1] != '_')
2343 if (! parse_stab_cpp_abbrev (dhandle
, info
, pp
, fields
+ c
, p_end
))
2352 /* Look for the ':' that separates the field name from the field
2353 values. Data members are delimited by a single ':', while member
2354 functions are delimited by a pair of ':'s. When we hit the member
2355 functions (if any), terminate scan loop and return. */
2357 p
= strchr (p
, ':');
2368 if (! parse_stab_one_struct_field (dhandle
, info
, pp
, p
, fields
+ c
,
2378 fields
[c
] = DEBUG_FIELD_NULL
;
2385 /* Special GNU C++ name. */
2388 parse_stab_cpp_abbrev (void * dhandle
,
2389 struct stab_handle
* info
,
2398 const char *type_name
;
2402 *retp
= DEBUG_FIELD_NULL
;
2416 if (cpp_abbrev
== 0)
2423 /* At this point, *pp points to something like "22:23=*22...", where
2424 the type number before the ':' is the "context" and everything
2425 after is a regular type definition. Lookup the type, find it's
2426 name, and construct the field name. */
2428 context
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2429 (debug_type
**) NULL
, p_end
);
2430 if (context
== DEBUG_TYPE_NULL
)
2436 /* $vf -- a virtual function table pointer. */
2440 /* $vb -- a virtual bsomethingorother */
2441 type_name
= debug_get_type_name (dhandle
, context
);
2442 if (type_name
== NULL
)
2444 warn_stab (orig
, _("unnamed $vb type"));
2447 name
= concat ("_vb$", type_name
, (const char *) NULL
);
2450 warn_stab (orig
, _("unrecognized C++ abbreviation"));
2451 name
= "INVALID_CPLUSPLUS_ABBREV";
2462 type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2463 (debug_type
**) NULL
, p_end
);
2471 bitpos
= parse_number (pp
, (bool *) NULL
, p_end
);
2479 *retp
= debug_make_field (dhandle
, name
, type
, bitpos
, 0,
2480 DEBUG_VISIBILITY_PRIVATE
);
2481 if (*retp
== DEBUG_FIELD_NULL
)
2487 /* Parse a single field in a struct or union. */
2490 parse_stab_one_struct_field (void *dhandle
,
2491 struct stab_handle
*info
,
2500 enum debug_visibility visibility
;
2509 /* FIXME: gdb checks ARM_DEMANGLING here. */
2511 name
= savestring (*pp
, p
- *pp
);
2516 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2523 visibility
= DEBUG_VISIBILITY_PRIVATE
;
2526 visibility
= DEBUG_VISIBILITY_PROTECTED
;
2529 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2535 warn_stab (orig
, _("unknown visibility character for field"));
2536 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2542 type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2543 (debug_type
**) NULL
, p_end
);
2544 if (type
== DEBUG_TYPE_NULL
)
2554 /* This is a static class member. */
2556 p
= strchr (*pp
, ';');
2564 varname
= savestring (*pp
, p
- *pp
);
2568 *retp
= debug_make_static_member (dhandle
, name
, type
, varname
,
2583 bitpos
= parse_number (pp
, (bool *) NULL
, p_end
);
2592 bitsize
= parse_number (pp
, (bool *) NULL
, p_end
);
2601 if (bitpos
== 0 && bitsize
== 0)
2603 /* This can happen in two cases: (1) at least for gcc 2.4.5 or
2604 so, it is a field which has been optimized out. The correct
2605 stab for this case is to use VISIBILITY_IGNORE, but that is a
2606 recent invention. (2) It is a 0-size array. For example
2607 union { int num; char str[0]; } foo. Printing "<no value>"
2608 for str in "p foo" is OK, since foo.str (and thus foo.str[3])
2609 will continue to work, and a 0-size array as a whole doesn't
2610 have any contents to print.
2612 I suspect this probably could also happen with gcc -gstabs
2613 (not -gstabs+) for static fields, and perhaps other C++
2614 extensions. Hopefully few people use -gstabs with gdb, since
2615 it is intended for dbx compatibility. */
2616 visibility
= DEBUG_VISIBILITY_IGNORE
;
2619 /* FIXME: gdb does some stuff here to mark fields as unpacked. */
2621 *retp
= debug_make_field (dhandle
, name
, type
, bitpos
, bitsize
, visibility
);
2626 /* Read member function stabs info for C++ classes. The form of each member
2629 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2631 An example with two member functions is:
2633 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2635 For the case of overloaded operators, the format is op$::*.funcs, where
2636 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2637 name (such as `+=') and `.' marks the end of the operator name. */
2640 parse_stab_members (void * dhandle
,
2641 struct stab_handle
* info
,
2642 const char * tagname
,
2644 const int * typenums
,
2645 debug_method
** retp
,
2649 debug_method
*methods
;
2653 debug_method_variant
*variants
= NULL
;
2654 char *argtypes
= NULL
;
2670 unsigned int allocvars
;
2671 debug_type look_ahead_type
;
2673 p
= strchr (*pp
, ':');
2674 if (p
== NULL
|| p
[1] != ':')
2677 /* FIXME: Some systems use something other than '$' here. */
2678 if ((*pp
)[0] != 'o' || (*pp
)[1] != 'p' || (*pp
)[2] != '$')
2680 name
= savestring (*pp
, p
- *pp
);
2685 /* This is a completely weird case. In order to stuff in the
2686 names that might contain colons (the usual name delimiter),
2687 Mike Tiemann defined a different name format which is
2688 signalled if the identifier is "op$". In that case, the
2689 format is "op$::XXXX." where XXXX is the name. This is
2690 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2692 for (p
= *pp
; *p
!= '.' && *p
!= '\0'; p
++)
2699 name
= savestring (*pp
, p
- *pp
);
2704 variants
= ((debug_method_variant
*)
2705 xmalloc (allocvars
* sizeof *variants
));
2708 look_ahead_type
= DEBUG_TYPE_NULL
;
2714 enum debug_visibility visibility
;
2715 bool constp
, volatilep
, staticp
;
2718 const char *physname
;
2721 if (look_ahead_type
!= DEBUG_TYPE_NULL
)
2723 /* g++ version 1 kludge */
2724 type
= look_ahead_type
;
2725 look_ahead_type
= DEBUG_TYPE_NULL
;
2729 type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2730 (debug_type
**) NULL
, p_end
);
2731 if (type
== DEBUG_TYPE_NULL
)
2742 p
= strchr (*pp
, ';');
2750 if (debug_get_type_kind (dhandle
, type
) == DEBUG_KIND_METHOD
2751 && debug_get_parameter_types (dhandle
, type
, &varargs
) == NULL
)
2754 argtypes
= savestring (*pp
, p
- *pp
);
2760 visibility
= DEBUG_VISIBILITY_PRIVATE
;
2763 visibility
= DEBUG_VISIBILITY_PROTECTED
;
2769 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2779 /* Normal function. */
2783 /* const member function. */
2788 /* volatile member function. */
2793 /* const volatile member function. */
2801 /* File compiled with g++ version 1; no information. */
2804 warn_stab (orig
, _("const/volatile indicator missing"));
2812 /* virtual member function, followed by index. The sign
2813 bit is supposedly set to distinguish
2814 pointers-to-methods from virtual function indices. */
2816 voffset
= parse_number (pp
, (bool *) NULL
, p_end
);
2823 voffset
&= 0x7fffffff;
2825 if (**pp
== ';' || **pp
== '\0')
2827 /* Must be g++ version 1. */
2828 context
= DEBUG_TYPE_NULL
;
2832 /* Figure out from whence this virtual function
2833 came. It may belong to virtual function table of
2834 one of its baseclasses. */
2835 look_ahead_type
= parse_stab_type (dhandle
, info
,
2836 (const char *) NULL
,
2838 (debug_type
**) NULL
,
2842 /* g++ version 1 overloaded methods. */
2843 context
= DEBUG_TYPE_NULL
;
2847 context
= look_ahead_type
;
2848 look_ahead_type
= DEBUG_TYPE_NULL
;
2860 /* static member function. */
2864 context
= DEBUG_TYPE_NULL
;
2865 if (strncmp (argtypes
, name
, strlen (name
)) != 0)
2870 warn_stab (orig
, "member function type missing");
2872 context
= DEBUG_TYPE_NULL
;
2878 context
= DEBUG_TYPE_NULL
;
2882 /* If the type is not a stub, then the argtypes string is
2883 the physical name of the function. Otherwise the
2884 argtypes string is the mangled form of the argument
2885 types, and the full type and the physical name must be
2886 extracted from them. */
2887 physname
= argtypes
;
2890 debug_type class_type
, return_type
;
2892 class_type
= stab_find_type (dhandle
, info
, typenums
);
2893 if (class_type
== DEBUG_TYPE_NULL
)
2895 return_type
= debug_get_return_type (dhandle
, type
);
2896 if (return_type
== DEBUG_TYPE_NULL
)
2901 type
= parse_stab_argtypes (dhandle
, info
, class_type
, name
,
2902 tagname
, return_type
, argtypes
,
2903 constp
, volatilep
, &physname
);
2904 if (type
== DEBUG_TYPE_NULL
)
2908 if (cvars
+ 1 >= allocvars
)
2911 variants
= ((debug_method_variant
*)
2913 allocvars
* sizeof *variants
));
2917 variants
[cvars
] = debug_make_method_variant (dhandle
, physname
,
2922 variants
[cvars
] = debug_make_static_method_variant (dhandle
,
2928 if (variants
[cvars
] == DEBUG_METHOD_VARIANT_NULL
)
2933 while (**pp
!= ';' && **pp
!= '\0');
2935 variants
[cvars
] = DEBUG_METHOD_VARIANT_NULL
;
2943 methods
= ((debug_method
*)
2944 xrealloc (methods
, alloc
* sizeof *methods
));
2947 methods
[c
] = debug_make_method (dhandle
, name
, variants
);
2952 if (methods
!= NULL
)
2953 methods
[c
] = DEBUG_METHOD_NULL
;
2966 /* Parse a string representing argument types for a method. Stabs
2967 tries to save space by packing argument types into a mangled
2968 string. This string should give us enough information to extract
2969 both argument types and the physical name of the function, given
2973 parse_stab_argtypes (void *dhandle
, struct stab_handle
*info
,
2974 debug_type class_type
, const char *fieldname
,
2975 const char *tagname
, debug_type return_type
,
2976 const char *argtypes
, bool constp
,
2977 bool volatilep
, const char **pphysname
)
2979 bool is_full_physname_constructor
;
2980 bool is_constructor
;
2985 unsigned int physname_len
= 0;
2987 /* Constructors are sometimes handled specially. */
2988 is_full_physname_constructor
= ((argtypes
[0] == '_'
2989 && argtypes
[1] == '_'
2990 && (ISDIGIT (argtypes
[2])
2991 || argtypes
[2] == 'Q'
2992 || argtypes
[2] == 't'))
2993 || startswith (argtypes
, "__ct"));
2995 is_constructor
= (is_full_physname_constructor
2997 && strcmp (fieldname
, tagname
) == 0));
2998 is_destructor
= ((argtypes
[0] == '_'
2999 && (argtypes
[1] == '$' || argtypes
[1] == '.')
3000 && argtypes
[2] == '_')
3001 || startswith (argtypes
, "__dt"));
3002 is_v3
= argtypes
[0] == '_' && argtypes
[1] == 'Z';
3004 if (!(is_destructor
|| is_full_physname_constructor
|| is_v3
))
3007 const char *const_prefix
;
3008 const char *volatile_prefix
;
3010 unsigned int mangled_name_len
;
3013 len
= tagname
== NULL
? 0 : strlen (tagname
);
3014 const_prefix
= constp
? "C" : "";
3015 volatile_prefix
= volatilep
? "V" : "";
3018 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
3019 else if (tagname
!= NULL
&& strchr (tagname
, '<') != NULL
)
3021 /* Template methods are fully mangled. */
3022 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
3027 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
3029 mangled_name_len
= ((is_constructor
? 0 : strlen (fieldname
))
3035 if (fieldname
[0] == 'o'
3036 && fieldname
[1] == 'p'
3037 && (fieldname
[2] == '$' || fieldname
[2] == '.'))
3039 /* Opname selection is no longer supported by libiberty's demangler. */
3040 return DEBUG_TYPE_NULL
;
3043 physname
= (char *) xmalloc (mangled_name_len
);
3047 strcpy (physname
, fieldname
);
3049 physname_len
= strlen (physname
);
3050 strcat (physname
, buf
);
3051 if (tagname
!= NULL
)
3052 strcat (physname
, tagname
);
3053 strcat (physname
, argtypes
);
3055 *pphysname
= physname
;
3058 if (*argtypes
== '\0' || is_destructor
)
3060 args
= (debug_type
*) xmalloc (sizeof *args
);
3062 return debug_make_method_type (dhandle
, return_type
, class_type
, args
,
3066 args
= stab_demangle_argtypes (dhandle
, info
, *pphysname
, &varargs
, physname_len
);
3068 return DEBUG_TYPE_NULL
;
3070 return debug_make_method_type (dhandle
, return_type
, class_type
, args
,
3074 /* The tail end of stabs for C++ classes that contain a virtual function
3075 pointer contains a tilde, a %, and a type number.
3076 The type number refers to the base class (possibly this class itself) which
3077 contains the vtable pointer for the current class.
3079 This function is called when we have parsed all the method declarations,
3080 so we can look for the vptr base class info. */
3083 parse_stab_tilde_field (void *dhandle
,
3084 struct stab_handle
*info
,
3086 const int *typenums
,
3087 debug_type
*retvptrbase
,
3095 *retvptrbase
= DEBUG_TYPE_NULL
;
3096 *retownvptr
= false;
3102 /* If we are positioned at a ';', then skip it. */
3110 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
3112 /* Obsolete flags that used to indicate the presence of
3113 constructors and/or destructors. */
3123 /* The next number is the type number of the base class (possibly
3124 our own class) which supplies the vtable for this class. */
3125 if (! parse_stab_type_number (pp
, vtypenums
, p_end
))
3128 if (vtypenums
[0] == typenums
[0]
3129 && vtypenums
[1] == typenums
[1])
3138 vtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
3139 (debug_type
**) NULL
, p_end
);
3140 for (p
= *pp
; *p
!= ';' && *p
!= '\0'; p
++)
3148 *retvptrbase
= vtype
;
3156 /* Read a definition of an array type. */
3159 parse_stab_array_type (void *dhandle
,
3160 struct stab_handle
*info
,
3168 debug_type index_type
;
3170 bfd_signed_vma lower
, upper
;
3171 debug_type element_type
;
3173 /* Format of an array type:
3174 "ar<index type>;lower;upper;<array_contents_type>".
3175 OS9000: "arlower,upper;<array_contents_type>".
3177 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3178 for these, produce a type like float[][]. */
3182 return DEBUG_TYPE_NULL
;
3184 /* FIXME: gdb checks os9k_stabs here. */
3186 /* If the index type is type 0, we take it as int. */
3188 if (! parse_stab_type_number (&p
, typenums
, p_end
))
3189 return DEBUG_TYPE_NULL
;
3191 if (typenums
[0] == 0 && typenums
[1] == 0 && **pp
!= '=')
3193 index_type
= debug_find_named_type (dhandle
, "int");
3194 if (index_type
== DEBUG_TYPE_NULL
)
3196 index_type
= debug_make_int_type (dhandle
, 4, false);
3197 if (index_type
== DEBUG_TYPE_NULL
)
3198 return DEBUG_TYPE_NULL
;
3204 index_type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
3205 (debug_type
**) NULL
, p_end
);
3211 return DEBUG_TYPE_NULL
;
3217 if (! ISDIGIT (**pp
) && **pp
!= '-' && **pp
!= 0)
3223 lower
= (bfd_signed_vma
) parse_number (pp
, (bool *) NULL
, p_end
);
3227 return DEBUG_TYPE_NULL
;
3231 if (! ISDIGIT (**pp
) && **pp
!= '-' && **pp
!= 0)
3237 upper
= (bfd_signed_vma
) parse_number (pp
, (bool *) NULL
, p_end
);
3241 return DEBUG_TYPE_NULL
;
3245 element_type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
3246 (debug_type
**) NULL
, p_end
);
3247 if (element_type
== DEBUG_TYPE_NULL
)
3248 return DEBUG_TYPE_NULL
;
3256 return debug_make_array_type (dhandle
, element_type
, index_type
, lower
,
3260 /* This struct holds information about files we have seen using
3265 /* The next N_BINCL file. */
3266 struct bincl_file
*next
;
3267 /* The next N_BINCL on the stack. */
3268 struct bincl_file
*next_stack
;
3269 /* The file name. */
3271 /* The hash value. */
3273 /* The file index. */
3275 /* The list of types defined in this file. */
3276 struct stab_types
*file_types
;
3279 /* Start a new N_BINCL file, pushing it onto the stack. */
3282 push_bincl (struct stab_handle
*info
, const char *name
, bfd_vma hash
)
3284 struct bincl_file
*n
;
3286 n
= (struct bincl_file
*) xmalloc (sizeof *n
);
3287 n
->next
= info
->bincl_list
;
3288 n
->next_stack
= info
->bincl_stack
;
3291 n
->file
= info
->files
;
3292 n
->file_types
= NULL
;
3293 info
->bincl_list
= n
;
3294 info
->bincl_stack
= n
;
3297 info
->file_types
= ((struct stab_types
**)
3298 xrealloc (info
->file_types
,
3300 * sizeof *info
->file_types
)));
3301 info
->file_types
[n
->file
] = NULL
;
3304 /* Finish an N_BINCL file, at an N_EINCL, popping the name off the
3308 pop_bincl (struct stab_handle
*info
)
3310 struct bincl_file
*o
;
3312 o
= info
->bincl_stack
;
3314 return info
->main_filename
;
3315 info
->bincl_stack
= o
->next_stack
;
3317 if (o
->file
>= info
->files
)
3318 return info
->main_filename
;
3320 o
->file_types
= info
->file_types
[o
->file
];
3322 if (info
->bincl_stack
== NULL
)
3323 return info
->main_filename
;
3324 return info
->bincl_stack
->name
;
3327 /* Handle an N_EXCL: get the types from the corresponding N_BINCL. */
3330 find_excl (struct stab_handle
*info
, const char *name
, bfd_vma hash
)
3332 struct bincl_file
*l
;
3335 info
->file_types
= ((struct stab_types
**)
3336 xrealloc (info
->file_types
,
3338 * sizeof *info
->file_types
)));
3340 for (l
= info
->bincl_list
; l
!= NULL
; l
= l
->next
)
3341 if (l
->hash
== hash
&& strcmp (l
->name
, name
) == 0)
3345 warn_stab (name
, _("Undefined N_EXCL"));
3346 info
->file_types
[info
->files
- 1] = NULL
;
3350 info
->file_types
[info
->files
- 1] = l
->file_types
;
3355 /* Handle a variable definition. gcc emits variable definitions for a
3356 block before the N_LBRAC, so we must hold onto them until we see
3357 it. The SunPRO compiler emits variable definitions after the
3358 N_LBRAC, so we can call debug_record_variable immediately. */
3361 stab_record_variable (void *dhandle
, struct stab_handle
*info
,
3362 const char *name
, debug_type type
,
3363 enum debug_var_kind kind
, bfd_vma val
)
3365 struct stab_pending_var
*v
;
3367 if ((kind
== DEBUG_GLOBAL
|| kind
== DEBUG_STATIC
)
3368 || ! info
->within_function
3369 || (info
->gcc_compiled
== 0 && info
->n_opt_found
))
3370 return debug_record_variable (dhandle
, name
, type
, kind
, val
);
3372 v
= (struct stab_pending_var
*) xmalloc (sizeof *v
);
3373 memset (v
, 0, sizeof *v
);
3375 v
->next
= info
->pending
;
3385 /* Emit pending variable definitions. This is called after we see the
3386 N_LBRAC that starts the block. */
3389 stab_emit_pending_vars (void *dhandle
, struct stab_handle
*info
)
3391 struct stab_pending_var
*v
;
3396 struct stab_pending_var
*next
;
3398 if (! debug_record_variable (dhandle
, v
->name
, v
->type
, v
->kind
, v
->val
))
3406 info
->pending
= NULL
;
3411 /* Find the slot for a type in the database. */
3414 stab_find_slot (struct stab_handle
*info
, const int *typenums
)
3418 struct stab_types
**ps
;
3420 filenum
= typenums
[0];
3421 tindex
= typenums
[1];
3423 if (filenum
< 0 || (unsigned int) filenum
>= info
->files
)
3425 fprintf (stderr
, _("Type file number %d out of range\n"), filenum
);
3430 fprintf (stderr
, _("Type index number %d out of range\n"), tindex
);
3434 ps
= info
->file_types
+ filenum
;
3436 while (tindex
>= STAB_TYPES_SLOTS
)
3440 *ps
= (struct stab_types
*) xmalloc (sizeof **ps
);
3441 memset (*ps
, 0, sizeof **ps
);
3444 tindex
-= STAB_TYPES_SLOTS
;
3448 *ps
= (struct stab_types
*) xmalloc (sizeof **ps
);
3449 memset (*ps
, 0, sizeof **ps
);
3452 return (*ps
)->types
+ tindex
;
3455 /* Find a type given a type number. If the type has not been
3456 allocated yet, create an indirect type. */
3459 stab_find_type (void *dhandle
, struct stab_handle
*info
, const int *typenums
)
3463 if (typenums
[0] == 0 && typenums
[1] < 0)
3465 /* A negative type number indicates an XCOFF builtin type. */
3466 return stab_xcoff_builtin_type (dhandle
, info
, typenums
[1]);
3469 slot
= stab_find_slot (info
, typenums
);
3471 return DEBUG_TYPE_NULL
;
3473 if (*slot
== DEBUG_TYPE_NULL
)
3474 return debug_make_indirect_type (dhandle
, slot
, (const char *) NULL
);
3479 /* Record that a given type number refers to a given type. */
3482 stab_record_type (void *dhandle ATTRIBUTE_UNUSED
, struct stab_handle
*info
,
3483 const int *typenums
, debug_type type
)
3487 slot
= stab_find_slot (info
, typenums
);
3491 /* gdb appears to ignore type redefinitions, so we do as well. */
3498 /* Return an XCOFF builtin type. */
3501 stab_xcoff_builtin_type (void *dhandle
, struct stab_handle
*info
,
3502 unsigned int typenum
)
3507 typenum
= -typenum
- 1;
3508 if (typenum
>= XCOFF_TYPE_COUNT
)
3510 fprintf (stderr
, _("Unrecognized XCOFF type %d\n"), -typenum
- 1);
3511 return DEBUG_TYPE_NULL
;
3513 if (info
->xcoff_types
[typenum
] != NULL
)
3514 return info
->xcoff_types
[typenum
];
3519 /* The size of this and all the other types are fixed, defined
3520 by the debugging format. */
3522 rettype
= debug_make_int_type (dhandle
, 4, false);
3526 rettype
= debug_make_int_type (dhandle
, 1, false);
3530 rettype
= debug_make_int_type (dhandle
, 2, false);
3534 rettype
= debug_make_int_type (dhandle
, 4, false);
3537 name
= "unsigned char";
3538 rettype
= debug_make_int_type (dhandle
, 1, true);
3541 name
= "signed char";
3542 rettype
= debug_make_int_type (dhandle
, 1, false);
3545 name
= "unsigned short";
3546 rettype
= debug_make_int_type (dhandle
, 2, true);
3549 name
= "unsigned int";
3550 rettype
= debug_make_int_type (dhandle
, 4, true);
3554 rettype
= debug_make_int_type (dhandle
, 4, true);
3557 name
= "unsigned long";
3558 rettype
= debug_make_int_type (dhandle
, 4, true);
3562 rettype
= debug_make_void_type (dhandle
);
3565 /* IEEE single precision (32 bit). */
3567 rettype
= debug_make_float_type (dhandle
, 4);
3570 /* IEEE double precision (64 bit). */
3572 rettype
= debug_make_float_type (dhandle
, 8);
3575 /* This is an IEEE double on the RS/6000, and different machines
3576 with different sizes for "long double" should use different
3577 negative type numbers. See stabs.texinfo. */
3578 name
= "long double";
3579 rettype
= debug_make_float_type (dhandle
, 8);
3583 rettype
= debug_make_int_type (dhandle
, 4, false);
3587 rettype
= debug_make_bool_type (dhandle
, 4);
3590 name
= "short real";
3591 rettype
= debug_make_float_type (dhandle
, 4);
3595 rettype
= debug_make_float_type (dhandle
, 8);
3605 rettype
= debug_make_int_type (dhandle
, 1, true);
3609 rettype
= debug_make_bool_type (dhandle
, 1);
3613 rettype
= debug_make_bool_type (dhandle
, 2);
3617 rettype
= debug_make_bool_type (dhandle
, 4);
3621 rettype
= debug_make_bool_type (dhandle
, 4);
3624 /* Complex type consisting of two IEEE single precision values. */
3626 rettype
= debug_make_complex_type (dhandle
, 8);
3629 /* Complex type consisting of two IEEE double precision values. */
3630 name
= "double complex";
3631 rettype
= debug_make_complex_type (dhandle
, 16);
3635 rettype
= debug_make_int_type (dhandle
, 1, false);
3639 rettype
= debug_make_int_type (dhandle
, 2, false);
3643 rettype
= debug_make_int_type (dhandle
, 4, false);
3648 rettype
= debug_make_int_type (dhandle
, 2, false);
3652 rettype
= debug_make_int_type (dhandle
, 8, false);
3655 name
= "unsigned long long";
3656 rettype
= debug_make_int_type (dhandle
, 8, true);
3660 rettype
= debug_make_bool_type (dhandle
, 8);
3664 rettype
= debug_make_int_type (dhandle
, 8, false);
3670 rettype
= debug_name_type (dhandle
, name
, rettype
);
3671 info
->xcoff_types
[typenum
] = rettype
;
3675 /* Find or create a tagged type. */
3678 stab_find_tagged_type (void *dhandle
, struct stab_handle
*info
,
3679 const char *p
, int len
, enum debug_type_kind kind
)
3683 struct stab_tag
*st
;
3685 name
= savestring (p
, len
);
3687 /* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same
3688 namespace. This is right for C, and I don't know how to handle
3689 other languages. FIXME. */
3690 dtype
= debug_find_tagged_type (dhandle
, name
, DEBUG_KIND_ILLEGAL
);
3691 if (dtype
!= DEBUG_TYPE_NULL
)
3697 /* We need to allocate an entry on the undefined tag list. */
3698 for (st
= info
->tags
; st
!= NULL
; st
= st
->next
)
3700 if (st
->name
[0] == name
[0]
3701 && strcmp (st
->name
, name
) == 0)
3703 if (st
->kind
== DEBUG_KIND_ILLEGAL
)
3711 st
= (struct stab_tag
*) xmalloc (sizeof *st
);
3712 memset (st
, 0, sizeof *st
);
3714 st
->next
= info
->tags
;
3717 st
->slot
= DEBUG_TYPE_NULL
;
3718 st
->type
= debug_make_indirect_type (dhandle
, &st
->slot
, name
);
3725 /* In order to get the correct argument types for a stubbed method, we
3726 need to extract the argument types from a C++ mangled string.
3727 Since the argument types can refer back to the return type, this
3728 means that we must demangle the entire physical name. In gdb this
3729 is done by calling cplus_demangle and running the results back
3730 through the C++ expression parser. Since we have no expression
3731 parser, we must duplicate much of the work of cplus_demangle here.
3733 We assume that GNU style demangling is used, since this is only
3734 done for method stubs, and only g++ should output that form of
3735 debugging information. */
3737 /* This structure is used to hold a pointer to type information which
3738 demangling a string. */
3740 struct stab_demangle_typestring
3742 /* The start of the type. This is not null terminated. */
3743 const char *typestring
;
3744 /* The length of the type. */
3748 /* This structure is used to hold information while demangling a
3751 struct stab_demangle_info
3753 /* The debugging information handle. */
3755 /* The stab information handle. */
3756 struct stab_handle
*info
;
3757 /* The array of arguments we are building. */
3759 /* Whether the method takes a variable number of arguments. */
3761 /* The array of types we have remembered. */
3762 struct stab_demangle_typestring
*typestrings
;
3763 /* The number of typestrings. */
3764 unsigned int typestring_count
;
3765 /* The number of typestring slots we have allocated. */
3766 unsigned int typestring_alloc
;
3769 static void stab_bad_demangle (const char *);
3770 static unsigned int stab_demangle_count (const char **);
3771 static bool stab_demangle_get_count (const char **, unsigned int *);
3772 static bool stab_demangle_prefix
3773 (struct stab_demangle_info
*, const char **, unsigned int);
3774 static bool stab_demangle_function_name
3775 (struct stab_demangle_info
*, const char **, const char *);
3776 static bool stab_demangle_signature
3777 (struct stab_demangle_info
*, const char **);
3778 static bool stab_demangle_qualified
3779 (struct stab_demangle_info
*, const char **, debug_type
*);
3780 static bool stab_demangle_template
3781 (struct stab_demangle_info
*, const char **, char **);
3782 static bool stab_demangle_class
3783 (struct stab_demangle_info
*, const char **, const char **);
3784 static bool stab_demangle_args
3785 (struct stab_demangle_info
*, const char **, debug_type
**, bool *);
3786 static bool stab_demangle_arg
3787 (struct stab_demangle_info
*, const char **, debug_type
**,
3788 unsigned int *, unsigned int *);
3789 static bool stab_demangle_type
3790 (struct stab_demangle_info
*, const char **, debug_type
*);
3791 static bool stab_demangle_fund_type
3792 (struct stab_demangle_info
*, const char **, debug_type
*);
3793 static bool stab_demangle_remember_type
3794 (struct stab_demangle_info
*, const char *, int);
3796 /* Warn about a bad demangling. */
3799 stab_bad_demangle (const char *s
)
3801 fprintf (stderr
, _("bad mangled name `%s'\n"), s
);
3804 /* Get a count from a stab string. */
3807 stab_demangle_count (const char **pp
)
3812 while (ISDIGIT (**pp
))
3815 count
+= **pp
- '0';
3821 /* Require a count in a string. The count may be multiple digits, in
3822 which case it must end in an underscore. */
3825 stab_demangle_get_count (const char **pp
, unsigned int *pi
)
3827 if (! ISDIGIT (**pp
))
3845 while (ISDIGIT (*p
));
3856 /* This function demangles a physical name, returning a NULL
3857 terminated array of argument types. */
3860 stab_demangle_argtypes (void *dhandle
, struct stab_handle
*info
,
3861 const char *physname
, bool *pvarargs
,
3862 unsigned int physname_len
)
3864 struct stab_demangle_info minfo
;
3866 /* Check for the g++ V3 ABI. */
3867 if (physname
[0] == '_' && physname
[1] == 'Z')
3868 return stab_demangle_v3_argtypes (dhandle
, info
, physname
, pvarargs
);
3870 minfo
.dhandle
= dhandle
;
3873 minfo
.varargs
= false;
3874 minfo
.typestring_alloc
= 10;
3875 minfo
.typestrings
= ((struct stab_demangle_typestring
*)
3876 xmalloc (minfo
.typestring_alloc
3877 * sizeof *minfo
.typestrings
));
3878 minfo
.typestring_count
= 0;
3880 /* cplus_demangle checks for special GNU mangled forms, but we can't
3881 see any of them in mangled method argument types. */
3883 if (! stab_demangle_prefix (&minfo
, &physname
, physname_len
))
3886 if (*physname
!= '\0')
3888 if (! stab_demangle_signature (&minfo
, &physname
))
3892 free (minfo
.typestrings
);
3893 minfo
.typestrings
= NULL
;
3895 if (minfo
.args
== NULL
)
3896 fprintf (stderr
, _("no argument types in mangled string\n"));
3898 *pvarargs
= minfo
.varargs
;
3902 free (minfo
.typestrings
);
3906 /* Demangle the prefix of the mangled name. */
3909 stab_demangle_prefix (struct stab_demangle_info
*minfo
, const char **pp
,
3910 unsigned int physname_len
)
3915 /* cplus_demangle checks for global constructors and destructors,
3916 but we can't see them in mangled argument types. */
3919 scan
= *pp
+ physname_len
;
3922 /* Look for `__'. */
3925 scan
= strchr (scan
, '_');
3926 while (scan
!= NULL
&& *++scan
!= '_');
3930 stab_bad_demangle (*pp
);
3936 /* We found `__'; move ahead to the last contiguous `__' pair. */
3937 i
= strspn (scan
, "_");
3943 && (ISDIGIT (scan
[2])
3947 /* This is a GNU style constructor name. */
3951 else if (scan
== *pp
3952 && ! ISDIGIT (scan
[2])
3955 /* Look for the `__' that separates the prefix from the
3957 while (*scan
== '_')
3959 scan
= strstr (scan
, "__");
3960 if (scan
== NULL
|| scan
[2] == '\0')
3962 stab_bad_demangle (*pp
);
3966 return stab_demangle_function_name (minfo
, pp
, scan
);
3968 else if (scan
[2] != '\0')
3970 /* The name doesn't start with `__', but it does contain `__'. */
3971 return stab_demangle_function_name (minfo
, pp
, scan
);
3975 stab_bad_demangle (*pp
);
3981 /* Demangle a function name prefix. The scan argument points to the
3982 double underscore which separates the function name from the
3986 stab_demangle_function_name (struct stab_demangle_info
*minfo
,
3987 const char **pp
, const char *scan
)
3991 /* The string from *pp to scan is the name of the function. We
3992 don't care about the name, since we just looking for argument
3993 types. However, for conversion operators, the name may include a
3994 type which we must remember in order to handle backreferences. */
4000 && startswith (name
, "type")
4001 && (name
[4] == '$' || name
[4] == '.'))
4005 /* This is a type conversion operator. */
4007 if (! stab_demangle_type (minfo
, &tem
, (debug_type
*) NULL
))
4010 else if (name
[0] == '_'
4017 /* This is a type conversion operator. */
4019 if (! stab_demangle_type (minfo
, &tem
, (debug_type
*) NULL
))
4026 /* Demangle the signature. This is where the argument types are
4030 stab_demangle_signature (struct stab_demangle_info
*minfo
, const char **pp
)
4033 bool expect_func
, func_done
;
4038 expect_func
= false;
4042 while (**pp
!= '\0')
4048 if (! stab_demangle_qualified (minfo
, pp
, (debug_type
*) NULL
)
4049 || ! stab_demangle_remember_type (minfo
, hold
, *pp
- hold
))
4056 /* Static member function. FIXME: Can this happen? */
4063 /* Const member function. */
4069 case '0': case '1': case '2': case '3': case '4':
4070 case '5': case '6': case '7': case '8': case '9':
4073 if (! stab_demangle_class (minfo
, pp
, (const char **) NULL
)
4074 || ! stab_demangle_remember_type (minfo
, hold
, *pp
- hold
))
4081 /* Function. I don't know if this actually happens with g++
4086 if (! stab_demangle_args (minfo
, pp
, &minfo
->args
, &minfo
->varargs
))
4094 if (! stab_demangle_template (minfo
, pp
, (char **) NULL
)
4095 || ! stab_demangle_remember_type (minfo
, hold
, *pp
- hold
))
4102 /* At the outermost level, we cannot have a return type
4103 specified, so if we run into another '_' at this point we
4104 are dealing with a mangled name that is either bogus, or
4105 has been mangled by some algorithm we don't know how to
4106 deal with. So just reject the entire demangling. */
4107 stab_bad_demangle (orig
);
4111 /* Assume we have stumbled onto the first outermost function
4112 argument token, and start processing args. */
4114 if (! stab_demangle_args (minfo
, pp
, &minfo
->args
, &minfo
->varargs
))
4122 if (! stab_demangle_args (minfo
, pp
, &minfo
->args
, &minfo
->varargs
))
4129 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
4130 bar__3fooi is 'foo::bar(int)'. We get here when we find the
4131 first case, and need to ensure that the '(void)' gets added
4132 to the current declp. */
4133 if (! stab_demangle_args (minfo
, pp
, &minfo
->args
, &minfo
->varargs
))
4140 /* Demangle a qualified name, such as "Q25Outer5Inner" which is the
4141 mangled form of "Outer::Inner". */
4144 stab_demangle_qualified (struct stab_demangle_info
*minfo
, const char **pp
,
4149 unsigned int qualifiers
;
4157 /* GNU mangled name with more than 9 classes. The count is
4158 preceded by an underscore (to distinguish it from the <= 9
4159 case) and followed by an underscore. */
4161 if (! ISDIGIT (*p
) || *p
== '0')
4163 stab_bad_demangle (orig
);
4166 qualifiers
= atoi (p
);
4167 while (ISDIGIT (*p
))
4171 stab_bad_demangle (orig
);
4177 case '1': case '2': case '3': case '4': case '5':
4178 case '6': case '7': case '8': case '9':
4179 qualifiers
= (*pp
)[1] - '0';
4180 /* Skip an optional underscore after the count. */
4181 if ((*pp
)[2] == '_')
4188 stab_bad_demangle (orig
);
4192 context
= DEBUG_TYPE_NULL
;
4194 /* Pick off the names. */
4195 while (qualifiers
-- > 0)
4203 if (! stab_demangle_template (minfo
, pp
,
4204 ptype
!= NULL
? &name
: NULL
))
4209 context
= stab_find_tagged_type (minfo
->dhandle
, minfo
->info
,
4210 name
, strlen (name
),
4213 if (context
== DEBUG_TYPE_NULL
)
4221 len
= stab_demangle_count (pp
);
4222 if (strlen (*pp
) < len
)
4224 stab_bad_demangle (orig
);
4230 const debug_field
*fields
;
4233 if (context
!= DEBUG_TYPE_NULL
)
4234 fields
= debug_get_fields (minfo
->dhandle
, context
);
4236 context
= DEBUG_TYPE_NULL
;
4242 /* Try to find the type by looking through the
4243 fields of context until we find a field with the
4244 same type. This ought to work for a class
4245 defined within a class, but it won't work for,
4246 e.g., an enum defined within a class. stabs does
4247 not give us enough information to figure out the
4250 name
= savestring (*pp
, len
);
4252 for (; *fields
!= DEBUG_FIELD_NULL
; fields
++)
4257 ft
= debug_get_field_type (minfo
->dhandle
, *fields
);
4263 dn
= debug_get_type_name (minfo
->dhandle
, ft
);
4264 if (dn
!= NULL
&& strcmp (dn
, name
) == 0)
4274 if (context
== DEBUG_TYPE_NULL
)
4276 /* We have to fall back on finding the type by name.
4277 If there are more types to come, then this must
4278 be a class. Otherwise, it could be anything. */
4280 if (qualifiers
== 0)
4284 name
= savestring (*pp
, len
);
4285 context
= debug_find_named_type (minfo
->dhandle
,
4290 if (context
== DEBUG_TYPE_NULL
)
4292 context
= stab_find_tagged_type (minfo
->dhandle
,
4296 ? DEBUG_KIND_ILLEGAL
4297 : DEBUG_KIND_CLASS
));
4298 if (context
== DEBUG_TYPE_NULL
)
4314 /* Demangle a template. If PNAME is not NULL, this sets *PNAME to a
4315 string representation of the template. */
4318 stab_demangle_template (struct stab_demangle_info
*minfo
, const char **pp
,
4328 /* Skip the template name. */
4329 r
= stab_demangle_count (pp
);
4330 if (r
== 0 || strlen (*pp
) < r
)
4332 stab_bad_demangle (orig
);
4337 /* Get the size of the parameter list. */
4338 if (stab_demangle_get_count (pp
, &r
) == 0)
4340 stab_bad_demangle (orig
);
4344 for (i
= 0; i
< r
; i
++)
4348 /* This is a type parameter. */
4350 if (! stab_demangle_type (minfo
, pp
, (debug_type
*) NULL
))
4356 bool pointerp
, realp
, integralp
, charp
, boolp
;
4367 /* This is a value parameter. */
4369 if (! stab_demangle_type (minfo
, pp
, (debug_type
*) NULL
))
4372 while (*old_p
!= '\0' && ! done
)
4382 case 'C': /* Const. */
4383 case 'S': /* Signed. */
4384 case 'U': /* Unsigned. */
4385 case 'V': /* Volatile. */
4386 case 'F': /* Function. */
4387 case 'M': /* Member function. */
4391 case 'Q': /* Qualified name. */
4395 case 'T': /* Remembered type. */
4397 case 'v': /* Void. */
4399 case 'x': /* Long long. */
4400 case 'l': /* Long. */
4401 case 'i': /* Int. */
4402 case 's': /* Short. */
4403 case 'w': /* Wchar_t. */
4407 case 'b': /* Bool. */
4411 case 'c': /* Char. */
4415 case 'r': /* Long double. */
4416 case 'd': /* Double. */
4417 case 'f': /* Float. */
4422 /* Assume it's a user defined integral type. */
4433 while (ISDIGIT (**pp
))
4442 val
= stab_demangle_count (pp
);
4445 stab_bad_demangle (orig
);
4453 val
= stab_demangle_count (pp
);
4454 if (val
!= 0 && val
!= 1)
4456 stab_bad_demangle (orig
);
4464 while (ISDIGIT (**pp
))
4469 while (ISDIGIT (**pp
))
4475 while (ISDIGIT (**pp
))
4483 len
= stab_demangle_count (pp
);
4486 stab_bad_demangle (orig
);
4494 /* We can translate this to a string fairly easily by invoking the
4495 regular demangling routine. */
4498 char *s1
, *s2
, *s3
, *s4
= NULL
;
4501 s1
= savestring (orig
, *pp
- orig
);
4503 s2
= concat ("NoSuchStrinG__", s1
, (const char *) NULL
);
4507 s3
= cplus_demangle (s2
, demangle_flags
);
4512 s4
= strstr (s3
, "::NoSuchStrinG");
4513 if (s3
== NULL
|| s4
== NULL
)
4515 stab_bad_demangle (orig
);
4520 /* Eliminating all spaces, except those between > characters,
4521 makes it more likely that the demangled name will match the
4522 name which g++ used as the structure name. */
4523 for (from
= to
= s3
; from
!= s4
; ++from
)
4525 || (from
[1] == '>' && from
> s3
&& from
[-1] == '>'))
4528 *pname
= savestring (s3
, to
- s3
);
4536 /* Demangle a class name. */
4539 stab_demangle_class (struct stab_demangle_info
*minfo ATTRIBUTE_UNUSED
,
4540 const char **pp
, const char **pstart
)
4547 n
= stab_demangle_count (pp
);
4548 if (strlen (*pp
) < n
)
4550 stab_bad_demangle (orig
);
4562 /* Demangle function arguments. If the pargs argument is not NULL, it
4563 is set to a NULL terminated array holding the arguments. */
4566 stab_demangle_args (struct stab_demangle_info
*minfo
, const char **pp
,
4567 debug_type
**pargs
, bool *pvarargs
)
4570 unsigned int alloc
, count
;
4577 *pargs
= (debug_type
*) xmalloc (alloc
* sizeof **pargs
);
4582 while (**pp
!= '_' && **pp
!= '\0' && **pp
!= 'e')
4584 if (**pp
== 'N' || **pp
== 'T')
4592 if (temptype
== 'T')
4596 if (! stab_demangle_get_count (pp
, &r
))
4598 stab_bad_demangle (orig
);
4603 if (! stab_demangle_get_count (pp
, &t
))
4605 stab_bad_demangle (orig
);
4609 if (t
>= minfo
->typestring_count
)
4611 stab_bad_demangle (orig
);
4618 tem
= minfo
->typestrings
[t
].typestring
;
4619 if (! stab_demangle_arg (minfo
, &tem
, pargs
, &count
, &alloc
))
4625 if (! stab_demangle_arg (minfo
, pp
, pargs
, &count
, &alloc
))
4631 (*pargs
)[count
] = DEBUG_TYPE_NULL
;
4643 /* Demangle a single argument. */
4646 stab_demangle_arg (struct stab_demangle_info
*minfo
, const char **pp
,
4647 debug_type
**pargs
, unsigned int *pcount
,
4648 unsigned int *palloc
)
4654 if (! stab_demangle_type (minfo
, pp
,
4655 pargs
== NULL
? (debug_type
*) NULL
: &type
)
4656 || ! stab_demangle_remember_type (minfo
, start
, *pp
- start
))
4661 if (type
== DEBUG_TYPE_NULL
)
4664 if (*pcount
+ 1 >= *palloc
)
4667 *pargs
= ((debug_type
*)
4668 xrealloc (*pargs
, *palloc
* sizeof **pargs
));
4670 (*pargs
)[*pcount
] = type
;
4677 /* Demangle a type. If the ptype argument is not NULL, *ptype is set
4678 to the newly allocated type. */
4681 stab_demangle_type (struct stab_demangle_info
*minfo
, const char **pp
,
4692 /* A pointer type. */
4694 if (! stab_demangle_type (minfo
, pp
, ptype
))
4697 *ptype
= debug_make_pointer_type (minfo
->dhandle
, *ptype
);
4701 /* A reference type. */
4703 if (! stab_demangle_type (minfo
, pp
, ptype
))
4706 *ptype
= debug_make_reference_type (minfo
->dhandle
, *ptype
);
4716 while (**pp
!= '\0' && **pp
!= '_')
4718 if (! ISDIGIT (**pp
))
4720 stab_bad_demangle (orig
);
4729 stab_bad_demangle (orig
);
4734 if (! stab_demangle_type (minfo
, pp
, ptype
))
4738 debug_type int_type
;
4740 int_type
= debug_find_named_type (minfo
->dhandle
, "int");
4741 if (int_type
== NULL
)
4742 int_type
= debug_make_int_type (minfo
->dhandle
, 4, false);
4743 *ptype
= debug_make_array_type (minfo
->dhandle
, *ptype
, int_type
,
4750 /* A back reference to a remembered type. */
4756 if (! stab_demangle_get_count (pp
, &i
))
4758 stab_bad_demangle (orig
);
4761 if (i
>= minfo
->typestring_count
)
4763 stab_bad_demangle (orig
);
4766 p
= minfo
->typestrings
[i
].typestring
;
4767 if (! stab_demangle_type (minfo
, &p
, ptype
))
4779 if (! stab_demangle_args (minfo
, pp
,
4781 ? (debug_type
**) NULL
4789 /* cplus_demangle will accept a function without a return
4790 type, but I don't know when that will happen, or what
4791 to do if it does. */
4792 stab_bad_demangle (orig
);
4796 if (! stab_demangle_type (minfo
, pp
, ptype
))
4799 *ptype
= debug_make_function_type (minfo
->dhandle
, *ptype
, args
,
4809 debug_type class_type
= DEBUG_TYPE_NULL
;
4815 memberp
= **pp
== 'M';
4822 n
= stab_demangle_count (pp
);
4823 if (strlen (*pp
) < n
)
4825 stab_bad_demangle (orig
);
4833 class_type
= stab_find_tagged_type (minfo
->dhandle
,
4837 if (class_type
== DEBUG_TYPE_NULL
)
4841 else if (**pp
== 'Q')
4843 if (! stab_demangle_qualified (minfo
, pp
,
4845 ? (debug_type
*) NULL
4851 stab_bad_demangle (orig
);
4861 else if (**pp
== 'V')
4867 stab_bad_demangle (orig
);
4871 if (! stab_demangle_args (minfo
, pp
,
4873 ? (debug_type
**) NULL
4883 stab_bad_demangle (orig
);
4888 if (! stab_demangle_type (minfo
, pp
, ptype
))
4894 *ptype
= debug_make_offset_type (minfo
->dhandle
, class_type
,
4898 /* FIXME: We have no way to record constp or
4900 *ptype
= debug_make_method_type (minfo
->dhandle
, *ptype
,
4901 class_type
, args
, varargs
);
4909 if (! stab_demangle_type (minfo
, pp
, ptype
))
4915 if (! stab_demangle_type (minfo
, pp
, ptype
))
4918 *ptype
= debug_make_const_type (minfo
->dhandle
, *ptype
);
4923 if (! stab_demangle_qualified (minfo
, pp
, ptype
))
4929 if (! stab_demangle_fund_type (minfo
, pp
, ptype
))
4937 /* Demangle a fundamental type. If the ptype argument is not NULL,
4938 *ptype is set to the newly allocated type. */
4941 stab_demangle_fund_type (struct stab_demangle_info
*minfo
, const char **pp
,
4945 bool constp
, volatilep
, unsignedp
, signedp
;
4990 /* cplus_demangle permits this, but I don't know what it means. */
4991 stab_bad_demangle (orig
);
4994 case 'v': /* void */
4997 *ptype
= debug_find_named_type (minfo
->dhandle
, "void");
4998 if (*ptype
== DEBUG_TYPE_NULL
)
4999 *ptype
= debug_make_void_type (minfo
->dhandle
);
5004 case 'x': /* long long */
5007 *ptype
= debug_find_named_type (minfo
->dhandle
,
5009 ? "long long unsigned int"
5010 : "long long int"));
5011 if (*ptype
== DEBUG_TYPE_NULL
)
5012 *ptype
= debug_make_int_type (minfo
->dhandle
, 8, unsignedp
);
5017 case 'l': /* long */
5020 *ptype
= debug_find_named_type (minfo
->dhandle
,
5022 ? "long unsigned int"
5024 if (*ptype
== DEBUG_TYPE_NULL
)
5025 *ptype
= debug_make_int_type (minfo
->dhandle
, 4, unsignedp
);
5033 *ptype
= debug_find_named_type (minfo
->dhandle
,
5037 if (*ptype
== DEBUG_TYPE_NULL
)
5038 *ptype
= debug_make_int_type (minfo
->dhandle
, 4, unsignedp
);
5043 case 's': /* short */
5046 *ptype
= debug_find_named_type (minfo
->dhandle
,
5048 ? "short unsigned int"
5050 if (*ptype
== DEBUG_TYPE_NULL
)
5051 *ptype
= debug_make_int_type (minfo
->dhandle
, 2, unsignedp
);
5056 case 'b': /* bool */
5059 *ptype
= debug_find_named_type (minfo
->dhandle
, "bool");
5060 if (*ptype
== DEBUG_TYPE_NULL
)
5061 *ptype
= debug_make_bool_type (minfo
->dhandle
, 4);
5066 case 'c': /* char */
5069 *ptype
= debug_find_named_type (minfo
->dhandle
,
5075 if (*ptype
== DEBUG_TYPE_NULL
)
5076 *ptype
= debug_make_int_type (minfo
->dhandle
, 1, unsignedp
);
5081 case 'w': /* wchar_t */
5084 *ptype
= debug_find_named_type (minfo
->dhandle
, "__wchar_t");
5085 if (*ptype
== DEBUG_TYPE_NULL
)
5086 *ptype
= debug_make_int_type (minfo
->dhandle
, 2, true);
5091 case 'r': /* long double */
5094 *ptype
= debug_find_named_type (minfo
->dhandle
, "long double");
5095 if (*ptype
== DEBUG_TYPE_NULL
)
5096 *ptype
= debug_make_float_type (minfo
->dhandle
, 8);
5101 case 'd': /* double */
5104 *ptype
= debug_find_named_type (minfo
->dhandle
, "double");
5105 if (*ptype
== DEBUG_TYPE_NULL
)
5106 *ptype
= debug_make_float_type (minfo
->dhandle
, 8);
5111 case 'f': /* float */
5114 *ptype
= debug_find_named_type (minfo
->dhandle
, "float");
5115 if (*ptype
== DEBUG_TYPE_NULL
)
5116 *ptype
= debug_make_float_type (minfo
->dhandle
, 4);
5123 if (! ISDIGIT (**pp
))
5125 stab_bad_demangle (orig
);
5129 case '0': case '1': case '2': case '3': case '4':
5130 case '5': case '6': case '7': case '8': case '9':
5134 if (! stab_demangle_class (minfo
, pp
, &hold
))
5140 name
= savestring (hold
, *pp
- hold
);
5141 *ptype
= debug_find_named_type (minfo
->dhandle
, name
);
5143 if (*ptype
== DEBUG_TYPE_NULL
)
5145 /* FIXME: It is probably incorrect to assume that
5146 undefined types are tagged types. */
5147 *ptype
= stab_find_tagged_type (minfo
->dhandle
, minfo
->info
,
5149 DEBUG_KIND_ILLEGAL
);
5150 if (*ptype
== DEBUG_TYPE_NULL
)
5161 if (! stab_demangle_template (minfo
, pp
,
5162 ptype
!= NULL
? &name
: NULL
))
5166 *ptype
= stab_find_tagged_type (minfo
->dhandle
, minfo
->info
,
5167 name
, strlen (name
),
5170 if (*ptype
== DEBUG_TYPE_NULL
)
5177 stab_bad_demangle (orig
);
5184 *ptype
= debug_make_const_type (minfo
->dhandle
, *ptype
);
5186 *ptype
= debug_make_volatile_type (minfo
->dhandle
, *ptype
);
5192 /* Remember a type string in a demangled string. */
5195 stab_demangle_remember_type (struct stab_demangle_info
*minfo
,
5196 const char *p
, int len
)
5198 if (minfo
->typestring_count
>= minfo
->typestring_alloc
)
5200 minfo
->typestring_alloc
+= 10;
5201 minfo
->typestrings
= ((struct stab_demangle_typestring
*)
5202 xrealloc (minfo
->typestrings
,
5203 (minfo
->typestring_alloc
5204 * sizeof *minfo
->typestrings
)));
5207 minfo
->typestrings
[minfo
->typestring_count
].typestring
= p
;
5208 minfo
->typestrings
[minfo
->typestring_count
].len
= (unsigned int) len
;
5209 ++minfo
->typestring_count
;
5214 /* Demangle names encoded using the g++ V3 ABI. The newer versions of
5215 g++ which use this ABI do not encode ordinary method argument types
5216 in a mangled name; they simply output the argument types. However,
5217 for a static method, g++ simply outputs the return type and the
5218 physical name. So in that case we need to demangle the name here.
5219 Here PHYSNAME is the physical name of the function, and we set the
5220 variable pointed at by PVARARGS to indicate whether this function
5221 is varargs. This returns NULL, or a NULL terminated array of
5225 stab_demangle_v3_argtypes (void *dhandle
, struct stab_handle
*info
,
5226 const char *physname
, bool *pvarargs
)
5228 struct demangle_component
*dc
;
5232 dc
= cplus_demangle_v3_components (physname
, DMGL_PARAMS
| demangle_flags
, &mem
);
5235 stab_bad_demangle (physname
);
5239 /* We expect to see TYPED_NAME, and the right subtree describes the
5241 if (dc
->type
!= DEMANGLE_COMPONENT_TYPED_NAME
5242 || dc
->u
.s_binary
.right
->type
!= DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5244 fprintf (stderr
, _("Demangled name is not a function\n"));
5249 pargs
= stab_demangle_v3_arglist (dhandle
, info
,
5250 dc
->u
.s_binary
.right
->u
.s_binary
.right
,
5258 /* Demangle an argument list in a struct demangle_component tree.
5259 Returns a DEBUG_TYPE_NULL terminated array of argument types, and
5260 sets *PVARARGS to indicate whether this is a varargs function. */
5263 stab_demangle_v3_arglist (void *dhandle
, struct stab_handle
*info
,
5264 struct demangle_component
*arglist
,
5267 struct demangle_component
*dc
;
5268 unsigned int alloc
, count
;
5272 pargs
= (debug_type
*) xmalloc (alloc
* sizeof *pargs
);
5279 dc
= dc
->u
.s_binary
.right
)
5284 if (dc
->type
!= DEMANGLE_COMPONENT_ARGLIST
)
5286 fprintf (stderr
, _("Unexpected type in v3 arglist demangling\n"));
5291 /* PR 13925: Cope if the demangler returns an empty
5292 context for a function with no arguments. */
5293 if (dc
->u
.s_binary
.left
== NULL
)
5296 arg
= stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.left
,
5309 if (count
+ 1 >= alloc
)
5312 pargs
= (debug_type
*) xrealloc (pargs
, alloc
* sizeof *pargs
);
5319 pargs
[count
] = DEBUG_TYPE_NULL
;
5324 /* Convert a struct demangle_component tree describing an argument
5325 type into a debug_type. */
5328 stab_demangle_v3_arg (void *dhandle
, struct stab_handle
*info
,
5329 struct demangle_component
*dc
, debug_type context
,
5334 if (pvarargs
!= NULL
)
5339 /* FIXME: These are demangle component types which we probably
5340 need to handle one way or another. */
5341 case DEMANGLE_COMPONENT_LOCAL_NAME
:
5342 case DEMANGLE_COMPONENT_TYPED_NAME
:
5343 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
5344 case DEMANGLE_COMPONENT_CTOR
:
5345 case DEMANGLE_COMPONENT_DTOR
:
5346 case DEMANGLE_COMPONENT_JAVA_CLASS
:
5347 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
5348 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
5349 case DEMANGLE_COMPONENT_CONST_THIS
:
5350 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5351 case DEMANGLE_COMPONENT_COMPLEX
:
5352 case DEMANGLE_COMPONENT_IMAGINARY
:
5353 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
5354 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
5355 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
5356 case DEMANGLE_COMPONENT_ARGLIST
:
5358 fprintf (stderr
, _("Unrecognized demangle component %d\n"),
5362 case DEMANGLE_COMPONENT_NAME
:
5363 if (context
!= NULL
)
5365 const debug_field
*fields
;
5367 fields
= debug_get_fields (dhandle
, context
);
5370 /* Try to find this type by looking through the context
5372 for (; *fields
!= DEBUG_FIELD_NULL
; fields
++)
5377 ft
= debug_get_field_type (dhandle
, *fields
);
5380 dn
= debug_get_type_name (dhandle
, ft
);
5382 && (int) strlen (dn
) == dc
->u
.s_name
.len
5383 && strncmp (dn
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
) == 0)
5388 return stab_find_tagged_type (dhandle
, info
, dc
->u
.s_name
.s
,
5389 dc
->u
.s_name
.len
, DEBUG_KIND_ILLEGAL
);
5391 case DEMANGLE_COMPONENT_QUAL_NAME
:
5392 context
= stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.left
,
5394 if (context
== NULL
)
5396 return stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.right
,
5399 case DEMANGLE_COMPONENT_TEMPLATE
:
5404 /* We print this component to get a class name which we can
5405 use. FIXME: This probably won't work if the template uses
5406 template parameters which refer to an outer template. */
5407 p
= cplus_demangle_print (DMGL_PARAMS
| demangle_flags
, dc
, 20, &alc
);
5410 fprintf (stderr
, _("Failed to print demangled template\n"));
5413 dt
= stab_find_tagged_type (dhandle
, info
, p
, strlen (p
),
5419 case DEMANGLE_COMPONENT_SUB_STD
:
5420 return stab_find_tagged_type (dhandle
, info
, dc
->u
.s_string
.string
,
5421 dc
->u
.s_string
.len
, DEBUG_KIND_ILLEGAL
);
5423 case DEMANGLE_COMPONENT_RESTRICT
:
5424 case DEMANGLE_COMPONENT_VOLATILE
:
5425 case DEMANGLE_COMPONENT_CONST
:
5426 case DEMANGLE_COMPONENT_POINTER
:
5427 case DEMANGLE_COMPONENT_REFERENCE
:
5428 dt
= stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.left
, NULL
,
5437 case DEMANGLE_COMPONENT_RESTRICT
:
5438 /* FIXME: We have no way to represent restrict. */
5440 case DEMANGLE_COMPONENT_VOLATILE
:
5441 return debug_make_volatile_type (dhandle
, dt
);
5442 case DEMANGLE_COMPONENT_CONST
:
5443 return debug_make_const_type (dhandle
, dt
);
5444 case DEMANGLE_COMPONENT_POINTER
:
5445 return debug_make_pointer_type (dhandle
, dt
);
5446 case DEMANGLE_COMPONENT_REFERENCE
:
5447 return debug_make_reference_type (dhandle
, dt
);
5450 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
5455 if (dc
->u
.s_binary
.left
== NULL
)
5457 /* In this case the return type is actually unknown.
5458 However, I'm not sure this will ever arise in practice;
5459 normally an unknown return type would only appear at
5460 the top level, which is handled above. */
5461 dt
= debug_make_void_type (dhandle
);
5464 dt
= stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.left
, NULL
,
5469 pargs
= stab_demangle_v3_arglist (dhandle
, info
,
5470 dc
->u
.s_binary
.right
,
5478 return debug_make_function_type (dhandle
, dt
, pargs
, varargs
);
5481 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
5487 /* We print this component in order to find out the type name.
5488 FIXME: Should we instead expose the
5489 demangle_builtin_type_info structure? */
5490 p
= cplus_demangle_print (DMGL_PARAMS
| demangle_flags
, dc
, 20, &alc
);
5493 fprintf (stderr
, _("Couldn't get demangled builtin type\n"));
5497 /* The mangling is based on the type, but does not itself
5498 indicate what the sizes are. So we have to guess. */
5499 if (strcmp (p
, "signed char") == 0)
5500 ret
= debug_make_int_type (dhandle
, 1, false);
5501 else if (strcmp (p
, "bool") == 0)
5502 ret
= debug_make_bool_type (dhandle
, 1);
5503 else if (strcmp (p
, "char") == 0)
5504 ret
= debug_make_int_type (dhandle
, 1, false);
5505 else if (strcmp (p
, "double") == 0)
5506 ret
= debug_make_float_type (dhandle
, 8);
5507 else if (strcmp (p
, "long double") == 0)
5508 ret
= debug_make_float_type (dhandle
, 8);
5509 else if (strcmp (p
, "float") == 0)
5510 ret
= debug_make_float_type (dhandle
, 4);
5511 else if (strcmp (p
, "__float128") == 0)
5512 ret
= debug_make_float_type (dhandle
, 16);
5513 else if (strcmp (p
, "unsigned char") == 0)
5514 ret
= debug_make_int_type (dhandle
, 1, true);
5515 else if (strcmp (p
, "int") == 0)
5516 ret
= debug_make_int_type (dhandle
, 4, false);
5517 else if (strcmp (p
, "unsigned int") == 0)
5518 ret
= debug_make_int_type (dhandle
, 4, true);
5519 else if (strcmp (p
, "long") == 0)
5520 ret
= debug_make_int_type (dhandle
, 4, false);
5521 else if (strcmp (p
, "unsigned long") == 0)
5522 ret
= debug_make_int_type (dhandle
, 4, true);
5523 else if (strcmp (p
, "__int128") == 0)
5524 ret
= debug_make_int_type (dhandle
, 16, false);
5525 else if (strcmp (p
, "unsigned __int128") == 0)
5526 ret
= debug_make_int_type (dhandle
, 16, true);
5527 else if (strcmp (p
, "short") == 0)
5528 ret
= debug_make_int_type (dhandle
, 2, false);
5529 else if (strcmp (p
, "unsigned short") == 0)
5530 ret
= debug_make_int_type (dhandle
, 2, true);
5531 else if (strcmp (p
, "void") == 0)
5532 ret
= debug_make_void_type (dhandle
);
5533 else if (strcmp (p
, "wchar_t") == 0)
5534 ret
= debug_make_int_type (dhandle
, 4, true);
5535 else if (strcmp (p
, "long long") == 0)
5536 ret
= debug_make_int_type (dhandle
, 8, false);
5537 else if (strcmp (p
, "unsigned long long") == 0)
5538 ret
= debug_make_int_type (dhandle
, 8, true);
5539 else if (strcmp (p
, "...") == 0)
5541 if (pvarargs
== NULL
)
5542 fprintf (stderr
, _("Unexpected demangled varargs\n"));
5549 fprintf (stderr
, _("Unrecognized demangled builtin type\n"));