1 /* stabs.c -- Parse stabs debugging information
2 Copyright (C) 1995-2018 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@cygnus.com>.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 /* This file contains code which parses stabs debugging information.
23 The organization of this code is based on the gdb stabs reading
24 code. The job it does is somewhat different, because it is not
25 trying to identify the correct address for anything. */
29 #include "libiberty.h"
30 #include "safe-ctype.h"
34 #include "filenames.h"
35 #include "aout/aout64.h"
36 #include "aout/stab_gnu.h"
38 /* The number of predefined XCOFF types. */
40 #define XCOFF_TYPE_COUNT 34
42 /* This structure is used as a handle so that the stab parsing doesn't
43 need to use any static variables. */
49 /* TRUE if this is stabs in sections. */
51 /* The symbol table. */
53 /* The number of symbols. */
55 /* The accumulated file name string. */
57 /* The value of the last N_SO symbol. */
59 /* The value of the start of the file, so that we can handle file
60 relative N_LBRAC and N_RBRAC symbols. */
61 bfd_vma file_start_offset
;
62 /* The offset of the start of the function, so that we can handle
63 function relative N_LBRAC and N_RBRAC symbols. */
64 bfd_vma function_start_offset
;
65 /* The version number of gcc which compiled the current compilation
66 unit, 0 if not compiled by gcc. */
68 /* Whether an N_OPT symbol was seen that was not generated by gcc,
69 so that we can detect the SunPRO compiler. */
70 bfd_boolean n_opt_found
;
71 /* The main file name. */
73 /* A stack of unfinished N_BINCL files. */
74 struct bincl_file
*bincl_stack
;
75 /* A list of finished N_BINCL files. */
76 struct bincl_file
*bincl_list
;
77 /* Whether we are inside a function or not. */
78 bfd_boolean within_function
;
79 /* The address of the end of the function, used if we have seen an
80 N_FUN symbol while in a function. This is -1 if we have not seen
81 an N_FUN (the normal case). */
83 /* The depth of block nesting. */
85 /* List of pending variable definitions. */
86 struct stab_pending_var
*pending
;
87 /* Number of files for which we have types. */
89 /* Lists of types per file. */
90 struct stab_types
**file_types
;
91 /* Predefined XCOFF types. */
92 debug_type xcoff_types
[XCOFF_TYPE_COUNT
];
94 struct stab_tag
*tags
;
95 /* Set by parse_stab_type if it sees a structure defined as a cross
96 reference to itself. Reset by parse_stab_type otherwise. */
97 bfd_boolean self_crossref
;
100 /* A list of these structures is used to hold pending variable
101 definitions seen before the N_LBRAC of a block. */
103 struct stab_pending_var
105 /* Next pending variable definition. */
106 struct stab_pending_var
*next
;
112 enum debug_var_kind kind
;
117 /* A list of these structures is used to hold the types for a single
122 /* Next set of slots for this file. */
123 struct stab_types
*next
;
124 /* Types indexed by type number. */
125 #define STAB_TYPES_SLOTS (16)
126 debug_type types
[STAB_TYPES_SLOTS
];
129 /* We keep a list of undefined tags that we encounter, so that we can
130 fill them in if the tag is later defined. */
134 /* Next undefined tag. */
135 struct stab_tag
*next
;
139 enum debug_type_kind kind
;
140 /* Slot to hold real type when we discover it. If we don't, we fill
141 in an undefined tag type. */
143 /* Indirect type we have created to point at slot. */
147 static char *savestring (const char *, int);
149 static void bad_stab (const char *);
150 static void warn_stab (const char *, const char *);
151 static bfd_boolean parse_stab_string
152 (void *, struct stab_handle
*, int, int, bfd_vma
,
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 bfd_boolean 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 bfd_boolean
, const int *, const char *);
171 static bfd_boolean parse_stab_baseclasses
172 (void *, struct stab_handle
*, const char **, debug_baseclass
**,
174 static bfd_boolean parse_stab_struct_fields
175 (void *, struct stab_handle
*, const char **, debug_field
**,
176 bfd_boolean
*, const char *);
177 static bfd_boolean parse_stab_cpp_abbrev
178 (void *, struct stab_handle
*, const char **, debug_field
*, const char *);
179 static bfd_boolean parse_stab_one_struct_field
180 (void *, struct stab_handle
*, const char **, const char *,
181 debug_field
*, bfd_boolean
*, const char *);
182 static bfd_boolean 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 *, bfd_boolean
, bfd_boolean
, const char **);
188 static bfd_boolean parse_stab_tilde_field
189 (void *, struct stab_handle
*, const char **, const int *, debug_type
*,
190 bfd_boolean
*, const char *);
191 static debug_type parse_stab_array_type
192 (void *, struct stab_handle
*, const char **, bfd_boolean
, 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 bfd_boolean
find_excl (struct stab_handle
*, const char *, bfd_vma
);
196 static bfd_boolean stab_record_variable
197 (void *, struct stab_handle
*, const char *, debug_type
,
198 enum debug_var_kind
, bfd_vma
);
199 static bfd_boolean
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 bfd_boolean 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
*, 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 *, bfd_boolean
*, unsigned int);
210 static debug_type
*stab_demangle_v3_argtypes
211 (void *, struct stab_handle
*, const char *, bfd_boolean
*);
212 static debug_type
*stab_demangle_v3_arglist
213 (void *, struct stab_handle
*, struct demangle_component
*, bfd_boolean
*);
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
, bfd_boolean
*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
;
272 bfd_boolean overflow
;
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
, bfd_boolean 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
)
706 bfd_boolean self_crossref
;
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
) == 'n' && *(++p
) == '0')
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
,
1176 bfd_boolean stringp
;
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
;
1513 bfd_boolean varargs
;
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
, (bfd_boolean
*) NULL
, p_end
);
1671 typenums
[0] = (int) parse_number (pp
, (bfd_boolean
*) NULL
, p_end
);
1679 typenums
[1] = (int) parse_number (pp
, (bfd_boolean
*) 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
,
1702 bfd_boolean self_subrange
;
1703 debug_type index_type
;
1704 const char *s2
, *s3
;
1705 bfd_signed_vma n2
, n3
;
1706 bfd_boolean ov2
, ov3
;
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 (CONST_STRNEQ (s2
, LLLOW
)
1764 && CONST_STRNEQ (s3
, LLHIGH
))
1765 return debug_make_int_type (dhandle
, 8, FALSE
);
1768 && CONST_STRNEQ (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
)
1887 bfd_boolean unsignedp
;
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
, (bfd_boolean
*) NULL
, p_end
);
1925 return DEBUG_TYPE_NULL
;
1929 /* The second number is always 0, so ignore it too. */
1930 (void) parse_number (pp
, (bfd_boolean
*) 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
, (bfd_boolean
*) 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
, (bfd_boolean
*) 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
, (bfd_boolean
*) 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
, (bfd_boolean
*) 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
,
2100 bfd_boolean structp
,
2101 const int * typenums
,
2105 debug_baseclass
*baseclasses
;
2106 debug_field
*fields
= NULL
;
2107 bfd_boolean statics
;
2108 debug_method
*methods
;
2109 debug_type vptrbase
;
2110 bfd_boolean ownvptr
;
2113 size
= parse_number (pp
, (bfd_boolean
*) 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
,
2124 return DEBUG_TYPE_NULL
;
2128 && baseclasses
== NULL
2130 && vptrbase
== DEBUG_TYPE_NULL
2132 return debug_make_struct_type (dhandle
, structp
, size
, fields
);
2134 return debug_make_object_type (dhandle
, structp
, size
, fields
, baseclasses
,
2135 methods
, vptrbase
, ownvptr
);
2138 /* The stabs for C++ derived classes contain baseclass information which
2139 is marked by a '!' character after the total size. This function is
2140 called when we encounter the baseclass marker, and slurps up all the
2141 baseclass information.
2143 Immediately following the '!' marker is the number of base classes that
2144 the class is derived from, followed by information for each base class.
2145 For each base class, there are two visibility specifiers, a bit offset
2146 to the base class information within the derived class, a reference to
2147 the type for the base class, and a terminating semicolon.
2149 A typical example, with two base classes, would be "!2,020,19;0264,21;".
2151 Baseclass information marker __________________|| | | | | | |
2152 Number of baseclasses __________________________| | | | | | |
2153 Visibility specifiers (2) ________________________| | | | | |
2154 Offset in bits from start of class _________________| | | | |
2155 Type number for base class ___________________________| | | |
2156 Visibility specifiers (2) _______________________________| | |
2157 Offset in bits from start of class ________________________| |
2158 Type number of base class ____________________________________|
2160 Return TRUE for success, FALSE for failure. */
2163 parse_stab_baseclasses (void * dhandle
,
2164 struct stab_handle
* info
,
2166 debug_baseclass
** retp
,
2171 debug_baseclass
*classes
;
2181 /* No base classes. */
2186 c
= (unsigned int) parse_number (pp
, (bfd_boolean
*) NULL
, p_end
);
2195 classes
= (debug_baseclass
*) xmalloc ((c
+ 1) * sizeof (**retp
));
2197 for (i
= 0; i
< c
; i
++)
2199 bfd_boolean is_virtual
;
2200 enum debug_visibility visibility
;
2216 warn_stab (orig
, _("unknown virtual character for baseclass"));
2225 visibility
= DEBUG_VISIBILITY_PRIVATE
;
2228 visibility
= DEBUG_VISIBILITY_PROTECTED
;
2231 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2237 warn_stab (orig
, _("unknown visibility character for baseclass"));
2238 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2243 /* The remaining value is the bit offset of the portion of the
2244 object corresponding to this baseclass. Always zero in the
2245 absence of multiple inheritance. */
2246 bitpos
= parse_number (pp
, (bfd_boolean
*) NULL
, p_end
);
2254 type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2255 (debug_type
**) NULL
, p_end
);
2256 if (type
== DEBUG_TYPE_NULL
)
2259 classes
[i
] = debug_make_baseclass (dhandle
, type
, bitpos
, is_virtual
,
2261 if (classes
[i
] == DEBUG_BASECLASS_NULL
)
2269 classes
[i
] = DEBUG_BASECLASS_NULL
;
2276 /* Read struct or class data fields. They have the form:
2278 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2280 At the end, we see a semicolon instead of a field.
2282 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2285 The optional VISIBILITY is one of:
2287 '/0' (VISIBILITY_PRIVATE)
2288 '/1' (VISIBILITY_PROTECTED)
2289 '/2' (VISIBILITY_PUBLIC)
2290 '/9' (VISIBILITY_IGNORE)
2292 or nothing, for C style fields with public visibility.
2294 Returns 1 for success, 0 for failure. */
2297 parse_stab_struct_fields (void * dhandle
,
2298 struct stab_handle
* info
,
2300 debug_field
** retp
,
2301 bfd_boolean
* staticsp
,
2306 debug_field
*fields
;
2319 fields
= (debug_field
*) xmalloc (alloc
* sizeof *fields
);
2322 /* FIXME: gdb checks os9k_stabs here. */
2326 /* Add 1 to c to leave room for NULL pointer at end. */
2330 fields
= ((debug_field
*)
2331 xrealloc (fields
, alloc
* sizeof *fields
));
2334 /* If it starts with CPLUS_MARKER it is a special abbreviation,
2335 unless the CPLUS_MARKER is followed by an underscore, in
2336 which case it is just the name of an anonymous type, which we
2337 should handle like any other type name. We accept either '$'
2338 or '.', because a field name can never contain one of these
2339 characters except as a CPLUS_MARKER. */
2341 if ((*p
== '$' || *p
== '.') && p
[1] != '_')
2344 if (! parse_stab_cpp_abbrev (dhandle
, info
, pp
, fields
+ c
, p_end
))
2353 /* Look for the ':' that separates the field name from the field
2354 values. Data members are delimited by a single ':', while member
2355 functions are delimited by a pair of ':'s. When we hit the member
2356 functions (if any), terminate scan loop and return. */
2358 p
= strchr (p
, ':');
2369 if (! parse_stab_one_struct_field (dhandle
, info
, pp
, p
, fields
+ c
,
2376 fields
[c
] = DEBUG_FIELD_NULL
;
2383 /* Special GNU C++ name. */
2386 parse_stab_cpp_abbrev (void * dhandle
,
2387 struct stab_handle
* info
,
2396 const char *type_name
;
2400 *retp
= DEBUG_FIELD_NULL
;
2414 if (cpp_abbrev
== 0)
2421 /* At this point, *pp points to something like "22:23=*22...", where
2422 the type number before the ':' is the "context" and everything
2423 after is a regular type definition. Lookup the type, find it's
2424 name, and construct the field name. */
2426 context
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2427 (debug_type
**) NULL
, p_end
);
2428 if (context
== DEBUG_TYPE_NULL
)
2434 /* $vf -- a virtual function table pointer. */
2438 /* $vb -- a virtual bsomethingorother */
2439 type_name
= debug_get_type_name (dhandle
, context
);
2440 if (type_name
== NULL
)
2442 warn_stab (orig
, _("unnamed $vb type"));
2445 name
= concat ("_vb$", type_name
, (const char *) NULL
);
2448 warn_stab (orig
, _("unrecognized C++ abbreviation"));
2449 name
= "INVALID_CPLUSPLUS_ABBREV";
2460 type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2461 (debug_type
**) NULL
, p_end
);
2469 bitpos
= parse_number (pp
, (bfd_boolean
*) NULL
, p_end
);
2477 *retp
= debug_make_field (dhandle
, name
, type
, bitpos
, 0,
2478 DEBUG_VISIBILITY_PRIVATE
);
2479 if (*retp
== DEBUG_FIELD_NULL
)
2485 /* Parse a single field in a struct or union. */
2488 parse_stab_one_struct_field (void * dhandle
,
2489 struct stab_handle
* info
,
2493 bfd_boolean
* staticsp
,
2498 enum debug_visibility visibility
;
2507 /* FIXME: gdb checks ARM_DEMANGLING here. */
2509 name
= savestring (*pp
, p
- *pp
);
2514 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2521 visibility
= DEBUG_VISIBILITY_PRIVATE
;
2524 visibility
= DEBUG_VISIBILITY_PROTECTED
;
2527 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2533 warn_stab (orig
, _("unknown visibility character for field"));
2534 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2540 type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2541 (debug_type
**) NULL
, p_end
);
2542 if (type
== DEBUG_TYPE_NULL
)
2552 /* This is a static class member. */
2554 p
= strchr (*pp
, ';');
2562 varname
= savestring (*pp
, p
- *pp
);
2566 *retp
= debug_make_static_member (dhandle
, name
, type
, varname
,
2581 bitpos
= parse_number (pp
, (bfd_boolean
*) NULL
, p_end
);
2590 bitsize
= parse_number (pp
, (bfd_boolean
*) NULL
, p_end
);
2599 if (bitpos
== 0 && bitsize
== 0)
2601 /* This can happen in two cases: (1) at least for gcc 2.4.5 or
2602 so, it is a field which has been optimized out. The correct
2603 stab for this case is to use VISIBILITY_IGNORE, but that is a
2604 recent invention. (2) It is a 0-size array. For example
2605 union { int num; char str[0]; } foo. Printing "<no value>"
2606 for str in "p foo" is OK, since foo.str (and thus foo.str[3])
2607 will continue to work, and a 0-size array as a whole doesn't
2608 have any contents to print.
2610 I suspect this probably could also happen with gcc -gstabs
2611 (not -gstabs+) for static fields, and perhaps other C++
2612 extensions. Hopefully few people use -gstabs with gdb, since
2613 it is intended for dbx compatibility. */
2614 visibility
= DEBUG_VISIBILITY_IGNORE
;
2617 /* FIXME: gdb does some stuff here to mark fields as unpacked. */
2619 *retp
= debug_make_field (dhandle
, name
, type
, bitpos
, bitsize
, visibility
);
2624 /* Read member function stabs info for C++ classes. The form of each member
2627 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2629 An example with two member functions is:
2631 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2633 For the case of overloaded operators, the format is op$::*.funcs, where
2634 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2635 name (such as `+=') and `.' marks the end of the operator name. */
2638 parse_stab_members (void * dhandle
,
2639 struct stab_handle
* info
,
2640 const char * tagname
,
2642 const int * typenums
,
2643 debug_method
** retp
,
2647 debug_method
*methods
;
2651 debug_method_variant
*variants
= NULL
;
2652 char *argtypes
= NULL
;
2668 unsigned int allocvars
;
2669 debug_type look_ahead_type
;
2671 p
= strchr (*pp
, ':');
2672 if (p
== NULL
|| p
[1] != ':')
2675 /* FIXME: Some systems use something other than '$' here. */
2676 if ((*pp
)[0] != 'o' || (*pp
)[1] != 'p' || (*pp
)[2] != '$')
2678 name
= savestring (*pp
, p
- *pp
);
2683 /* This is a completely weird case. In order to stuff in the
2684 names that might contain colons (the usual name delimiter),
2685 Mike Tiemann defined a different name format which is
2686 signalled if the identifier is "op$". In that case, the
2687 format is "op$::XXXX." where XXXX is the name. This is
2688 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2690 for (p
= *pp
; *p
!= '.' && *p
!= '\0'; p
++)
2697 name
= savestring (*pp
, p
- *pp
);
2702 variants
= ((debug_method_variant
*)
2703 xmalloc (allocvars
* sizeof *variants
));
2706 look_ahead_type
= DEBUG_TYPE_NULL
;
2712 enum debug_visibility visibility
;
2713 bfd_boolean constp
, volatilep
, staticp
;
2716 const char *physname
;
2717 bfd_boolean varargs
;
2719 if (look_ahead_type
!= DEBUG_TYPE_NULL
)
2721 /* g++ version 1 kludge */
2722 type
= look_ahead_type
;
2723 look_ahead_type
= DEBUG_TYPE_NULL
;
2727 type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2728 (debug_type
**) NULL
, p_end
);
2729 if (type
== DEBUG_TYPE_NULL
)
2740 p
= strchr (*pp
, ';');
2748 if (debug_get_type_kind (dhandle
, type
) == DEBUG_KIND_METHOD
2749 && debug_get_parameter_types (dhandle
, type
, &varargs
) == NULL
)
2752 argtypes
= savestring (*pp
, p
- *pp
);
2758 visibility
= DEBUG_VISIBILITY_PRIVATE
;
2761 visibility
= DEBUG_VISIBILITY_PROTECTED
;
2767 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2777 /* Normal function. */
2781 /* const member function. */
2786 /* volatile member function. */
2791 /* const volatile member function. */
2799 /* File compiled with g++ version 1; no information. */
2802 warn_stab (orig
, _("const/volatile indicator missing"));
2810 /* virtual member function, followed by index. The sign
2811 bit is supposedly set to distinguish
2812 pointers-to-methods from virtual function indices. */
2814 voffset
= parse_number (pp
, (bfd_boolean
*) NULL
, p_end
);
2821 voffset
&= 0x7fffffff;
2823 if (**pp
== ';' || **pp
== '\0')
2825 /* Must be g++ version 1. */
2826 context
= DEBUG_TYPE_NULL
;
2830 /* Figure out from whence this virtual function
2831 came. It may belong to virtual function table of
2832 one of its baseclasses. */
2833 look_ahead_type
= parse_stab_type (dhandle
, info
,
2834 (const char *) NULL
,
2836 (debug_type
**) NULL
,
2840 /* g++ version 1 overloaded methods. */
2841 context
= DEBUG_TYPE_NULL
;
2845 context
= look_ahead_type
;
2846 look_ahead_type
= DEBUG_TYPE_NULL
;
2858 /* static member function. */
2862 context
= DEBUG_TYPE_NULL
;
2863 if (strncmp (argtypes
, name
, strlen (name
)) != 0)
2868 warn_stab (orig
, "member function type missing");
2870 context
= DEBUG_TYPE_NULL
;
2876 context
= DEBUG_TYPE_NULL
;
2880 /* If the type is not a stub, then the argtypes string is
2881 the physical name of the function. Otherwise the
2882 argtypes string is the mangled form of the argument
2883 types, and the full type and the physical name must be
2884 extracted from them. */
2885 physname
= argtypes
;
2888 debug_type class_type
, return_type
;
2890 class_type
= stab_find_type (dhandle
, info
, typenums
);
2891 if (class_type
== DEBUG_TYPE_NULL
)
2893 return_type
= debug_get_return_type (dhandle
, type
);
2894 if (return_type
== DEBUG_TYPE_NULL
)
2899 type
= parse_stab_argtypes (dhandle
, info
, class_type
, name
,
2900 tagname
, return_type
, argtypes
,
2901 constp
, volatilep
, &physname
);
2902 if (type
== DEBUG_TYPE_NULL
)
2906 if (cvars
+ 1 >= allocvars
)
2909 variants
= ((debug_method_variant
*)
2911 allocvars
* sizeof *variants
));
2915 variants
[cvars
] = debug_make_method_variant (dhandle
, physname
,
2920 variants
[cvars
] = debug_make_static_method_variant (dhandle
,
2926 if (variants
[cvars
] == DEBUG_METHOD_VARIANT_NULL
)
2931 while (**pp
!= ';' && **pp
!= '\0');
2933 variants
[cvars
] = DEBUG_METHOD_VARIANT_NULL
;
2941 methods
= ((debug_method
*)
2942 xrealloc (methods
, alloc
* sizeof *methods
));
2945 methods
[c
] = debug_make_method (dhandle
, name
, variants
);
2950 if (methods
!= NULL
)
2951 methods
[c
] = DEBUG_METHOD_NULL
;
2960 if (variants
!= NULL
)
2962 if (argtypes
!= NULL
)
2967 /* Parse a string representing argument types for a method. Stabs
2968 tries to save space by packing argument types into a mangled
2969 string. This string should give us enough information to extract
2970 both argument types and the physical name of the function, given
2974 parse_stab_argtypes (void *dhandle
, struct stab_handle
*info
,
2975 debug_type class_type
, const char *fieldname
,
2976 const char *tagname
, debug_type return_type
,
2977 const char *argtypes
, bfd_boolean constp
,
2978 bfd_boolean volatilep
, const char **pphysname
)
2980 bfd_boolean is_full_physname_constructor
;
2981 bfd_boolean is_constructor
;
2982 bfd_boolean is_destructor
;
2985 bfd_boolean varargs
;
2986 unsigned int physname_len
= 0;
2988 /* Constructors are sometimes handled specially. */
2989 is_full_physname_constructor
= ((argtypes
[0] == '_'
2990 && argtypes
[1] == '_'
2991 && (ISDIGIT (argtypes
[2])
2992 || argtypes
[2] == 'Q'
2993 || argtypes
[2] == 't'))
2994 || CONST_STRNEQ (argtypes
, "__ct"));
2996 is_constructor
= (is_full_physname_constructor
2998 && strcmp (fieldname
, tagname
) == 0));
2999 is_destructor
= ((argtypes
[0] == '_'
3000 && (argtypes
[1] == '$' || argtypes
[1] == '.')
3001 && argtypes
[2] == '_')
3002 || CONST_STRNEQ (argtypes
, "__dt"));
3003 is_v3
= argtypes
[0] == '_' && argtypes
[1] == 'Z';
3005 if (!(is_destructor
|| is_full_physname_constructor
|| is_v3
))
3008 const char *const_prefix
;
3009 const char *volatile_prefix
;
3011 unsigned int mangled_name_len
;
3014 len
= tagname
== NULL
? 0 : strlen (tagname
);
3015 const_prefix
= constp
? "C" : "";
3016 volatile_prefix
= volatilep
? "V" : "";
3019 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
3020 else if (tagname
!= NULL
&& strchr (tagname
, '<') != NULL
)
3022 /* Template methods are fully mangled. */
3023 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
3028 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
3030 mangled_name_len
= ((is_constructor
? 0 : strlen (fieldname
))
3036 if (fieldname
[0] == 'o'
3037 && fieldname
[1] == 'p'
3038 && (fieldname
[2] == '$' || fieldname
[2] == '.'))
3042 opname
= cplus_mangle_opname (fieldname
+ 3, 0);
3045 fprintf (stderr
, _("No mangling for \"%s\"\n"), fieldname
);
3046 return DEBUG_TYPE_NULL
;
3048 mangled_name_len
+= strlen (opname
);
3049 physname
= (char *) xmalloc (mangled_name_len
);
3050 strncpy (physname
, fieldname
, 3);
3051 strcpy (physname
+ 3, opname
);
3055 physname
= (char *) xmalloc (mangled_name_len
);
3059 strcpy (physname
, fieldname
);
3062 physname_len
= strlen (physname
);
3063 strcat (physname
, buf
);
3064 if (tagname
!= NULL
)
3065 strcat (physname
, tagname
);
3066 strcat (physname
, argtypes
);
3068 *pphysname
= physname
;
3071 if (*argtypes
== '\0' || is_destructor
)
3073 args
= (debug_type
*) xmalloc (sizeof *args
);
3075 return debug_make_method_type (dhandle
, return_type
, class_type
, args
,
3079 args
= stab_demangle_argtypes (dhandle
, info
, *pphysname
, &varargs
, physname_len
);
3081 return DEBUG_TYPE_NULL
;
3083 return debug_make_method_type (dhandle
, return_type
, class_type
, args
,
3087 /* The tail end of stabs for C++ classes that contain a virtual function
3088 pointer contains a tilde, a %, and a type number.
3089 The type number refers to the base class (possibly this class itself) which
3090 contains the vtable pointer for the current class.
3092 This function is called when we have parsed all the method declarations,
3093 so we can look for the vptr base class info. */
3096 parse_stab_tilde_field (void * dhandle
,
3097 struct stab_handle
* info
,
3099 const int * typenums
,
3100 debug_type
* retvptrbase
,
3101 bfd_boolean
* retownvptr
,
3108 *retvptrbase
= DEBUG_TYPE_NULL
;
3109 *retownvptr
= FALSE
;
3115 /* If we are positioned at a ';', then skip it. */
3123 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
3125 /* Obsolete flags that used to indicate the presence of
3126 constructors and/or destructors. */
3136 /* The next number is the type number of the base class (possibly
3137 our own class) which supplies the vtable for this class. */
3138 if (! parse_stab_type_number (pp
, vtypenums
, p_end
))
3141 if (vtypenums
[0] == typenums
[0]
3142 && vtypenums
[1] == typenums
[1])
3151 vtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
3152 (debug_type
**) NULL
, p_end
);
3153 for (p
= *pp
; *p
!= ';' && *p
!= '\0'; p
++)
3161 *retvptrbase
= vtype
;
3169 /* Read a definition of an array type. */
3172 parse_stab_array_type (void * dhandle
,
3173 struct stab_handle
* info
,
3175 bfd_boolean stringp
,
3181 debug_type index_type
;
3182 bfd_boolean adjustable
;
3183 bfd_signed_vma lower
, upper
;
3184 debug_type element_type
;
3186 /* Format of an array type:
3187 "ar<index type>;lower;upper;<array_contents_type>".
3188 OS9000: "arlower,upper;<array_contents_type>".
3190 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3191 for these, produce a type like float[][]. */
3195 return DEBUG_TYPE_NULL
;
3197 /* FIXME: gdb checks os9k_stabs here. */
3199 /* If the index type is type 0, we take it as int. */
3201 if (! parse_stab_type_number (&p
, typenums
, p_end
))
3202 return DEBUG_TYPE_NULL
;
3204 if (typenums
[0] == 0 && typenums
[1] == 0 && **pp
!= '=')
3206 index_type
= debug_find_named_type (dhandle
, "int");
3207 if (index_type
== DEBUG_TYPE_NULL
)
3209 index_type
= debug_make_int_type (dhandle
, 4, FALSE
);
3210 if (index_type
== DEBUG_TYPE_NULL
)
3211 return DEBUG_TYPE_NULL
;
3217 index_type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
3218 (debug_type
**) NULL
, p_end
);
3224 return DEBUG_TYPE_NULL
;
3230 if (! ISDIGIT (**pp
) && **pp
!= '-' && **pp
!= 0)
3236 lower
= (bfd_signed_vma
) parse_number (pp
, (bfd_boolean
*) NULL
, p_end
);
3240 return DEBUG_TYPE_NULL
;
3244 if (! ISDIGIT (**pp
) && **pp
!= '-' && **pp
!= 0)
3250 upper
= (bfd_signed_vma
) parse_number (pp
, (bfd_boolean
*) NULL
, p_end
);
3254 return DEBUG_TYPE_NULL
;
3258 element_type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
3259 (debug_type
**) NULL
, p_end
);
3260 if (element_type
== DEBUG_TYPE_NULL
)
3261 return DEBUG_TYPE_NULL
;
3269 return debug_make_array_type (dhandle
, element_type
, index_type
, lower
,
3273 /* This struct holds information about files we have seen using
3278 /* The next N_BINCL file. */
3279 struct bincl_file
*next
;
3280 /* The next N_BINCL on the stack. */
3281 struct bincl_file
*next_stack
;
3282 /* The file name. */
3284 /* The hash value. */
3286 /* The file index. */
3288 /* The list of types defined in this file. */
3289 struct stab_types
*file_types
;
3292 /* Start a new N_BINCL file, pushing it onto the stack. */
3295 push_bincl (struct stab_handle
*info
, const char *name
, bfd_vma hash
)
3297 struct bincl_file
*n
;
3299 n
= (struct bincl_file
*) xmalloc (sizeof *n
);
3300 n
->next
= info
->bincl_list
;
3301 n
->next_stack
= info
->bincl_stack
;
3304 n
->file
= info
->files
;
3305 n
->file_types
= NULL
;
3306 info
->bincl_list
= n
;
3307 info
->bincl_stack
= n
;
3310 info
->file_types
= ((struct stab_types
**)
3311 xrealloc (info
->file_types
,
3313 * sizeof *info
->file_types
)));
3314 info
->file_types
[n
->file
] = NULL
;
3317 /* Finish an N_BINCL file, at an N_EINCL, popping the name off the
3321 pop_bincl (struct stab_handle
*info
)
3323 struct bincl_file
*o
;
3325 o
= info
->bincl_stack
;
3327 return info
->main_filename
;
3328 info
->bincl_stack
= o
->next_stack
;
3330 if (o
->file
>= info
->files
)
3331 return info
->main_filename
;
3333 o
->file_types
= info
->file_types
[o
->file
];
3335 if (info
->bincl_stack
== NULL
)
3336 return info
->main_filename
;
3337 return info
->bincl_stack
->name
;
3340 /* Handle an N_EXCL: get the types from the corresponding N_BINCL. */
3343 find_excl (struct stab_handle
*info
, const char *name
, bfd_vma hash
)
3345 struct bincl_file
*l
;
3348 info
->file_types
= ((struct stab_types
**)
3349 xrealloc (info
->file_types
,
3351 * sizeof *info
->file_types
)));
3353 for (l
= info
->bincl_list
; l
!= NULL
; l
= l
->next
)
3354 if (l
->hash
== hash
&& strcmp (l
->name
, name
) == 0)
3358 warn_stab (name
, _("Undefined N_EXCL"));
3359 info
->file_types
[info
->files
- 1] = NULL
;
3363 info
->file_types
[info
->files
- 1] = l
->file_types
;
3368 /* Handle a variable definition. gcc emits variable definitions for a
3369 block before the N_LBRAC, so we must hold onto them until we see
3370 it. The SunPRO compiler emits variable definitions after the
3371 N_LBRAC, so we can call debug_record_variable immediately. */
3374 stab_record_variable (void *dhandle
, struct stab_handle
*info
,
3375 const char *name
, debug_type type
,
3376 enum debug_var_kind kind
, bfd_vma val
)
3378 struct stab_pending_var
*v
;
3380 if ((kind
== DEBUG_GLOBAL
|| kind
== DEBUG_STATIC
)
3381 || ! info
->within_function
3382 || (info
->gcc_compiled
== 0 && info
->n_opt_found
))
3383 return debug_record_variable (dhandle
, name
, type
, kind
, val
);
3385 v
= (struct stab_pending_var
*) xmalloc (sizeof *v
);
3386 memset (v
, 0, sizeof *v
);
3388 v
->next
= info
->pending
;
3398 /* Emit pending variable definitions. This is called after we see the
3399 N_LBRAC that starts the block. */
3402 stab_emit_pending_vars (void *dhandle
, struct stab_handle
*info
)
3404 struct stab_pending_var
*v
;
3409 struct stab_pending_var
*next
;
3411 if (! debug_record_variable (dhandle
, v
->name
, v
->type
, v
->kind
, v
->val
))
3419 info
->pending
= NULL
;
3424 /* Find the slot for a type in the database. */
3427 stab_find_slot (struct stab_handle
*info
, const int *typenums
)
3431 struct stab_types
**ps
;
3433 filenum
= typenums
[0];
3434 tindex
= typenums
[1];
3436 if (filenum
< 0 || (unsigned int) filenum
>= info
->files
)
3438 fprintf (stderr
, _("Type file number %d out of range\n"), filenum
);
3443 fprintf (stderr
, _("Type index number %d out of range\n"), tindex
);
3447 ps
= info
->file_types
+ filenum
;
3449 while (tindex
>= STAB_TYPES_SLOTS
)
3453 *ps
= (struct stab_types
*) xmalloc (sizeof **ps
);
3454 memset (*ps
, 0, sizeof **ps
);
3457 tindex
-= STAB_TYPES_SLOTS
;
3461 *ps
= (struct stab_types
*) xmalloc (sizeof **ps
);
3462 memset (*ps
, 0, sizeof **ps
);
3465 return (*ps
)->types
+ tindex
;
3468 /* Find a type given a type number. If the type has not been
3469 allocated yet, create an indirect type. */
3472 stab_find_type (void *dhandle
, struct stab_handle
*info
, const int *typenums
)
3476 if (typenums
[0] == 0 && typenums
[1] < 0)
3478 /* A negative type number indicates an XCOFF builtin type. */
3479 return stab_xcoff_builtin_type (dhandle
, info
, typenums
[1]);
3482 slot
= stab_find_slot (info
, typenums
);
3484 return DEBUG_TYPE_NULL
;
3486 if (*slot
== DEBUG_TYPE_NULL
)
3487 return debug_make_indirect_type (dhandle
, slot
, (const char *) NULL
);
3492 /* Record that a given type number refers to a given type. */
3495 stab_record_type (void *dhandle ATTRIBUTE_UNUSED
, struct stab_handle
*info
,
3496 const int *typenums
, debug_type type
)
3500 slot
= stab_find_slot (info
, typenums
);
3504 /* gdb appears to ignore type redefinitions, so we do as well. */
3511 /* Return an XCOFF builtin type. */
3514 stab_xcoff_builtin_type (void *dhandle
, struct stab_handle
*info
,
3520 if (typenum
>= 0 || typenum
< -XCOFF_TYPE_COUNT
)
3522 fprintf (stderr
, _("Unrecognized XCOFF type %d\n"), typenum
);
3523 return DEBUG_TYPE_NULL
;
3525 if (info
->xcoff_types
[-typenum
] != NULL
)
3526 return info
->xcoff_types
[-typenum
];
3531 /* The size of this and all the other types are fixed, defined
3532 by the debugging format. */
3534 rettype
= debug_make_int_type (dhandle
, 4, FALSE
);
3538 rettype
= debug_make_int_type (dhandle
, 1, FALSE
);
3542 rettype
= debug_make_int_type (dhandle
, 2, FALSE
);
3546 rettype
= debug_make_int_type (dhandle
, 4, FALSE
);
3549 name
= "unsigned char";
3550 rettype
= debug_make_int_type (dhandle
, 1, TRUE
);
3553 name
= "signed char";
3554 rettype
= debug_make_int_type (dhandle
, 1, FALSE
);
3557 name
= "unsigned short";
3558 rettype
= debug_make_int_type (dhandle
, 2, TRUE
);
3561 name
= "unsigned int";
3562 rettype
= debug_make_int_type (dhandle
, 4, TRUE
);
3566 rettype
= debug_make_int_type (dhandle
, 4, TRUE
);
3569 name
= "unsigned long";
3570 rettype
= debug_make_int_type (dhandle
, 4, TRUE
);
3574 rettype
= debug_make_void_type (dhandle
);
3577 /* IEEE single precision (32 bit). */
3579 rettype
= debug_make_float_type (dhandle
, 4);
3582 /* IEEE double precision (64 bit). */
3584 rettype
= debug_make_float_type (dhandle
, 8);
3587 /* This is an IEEE double on the RS/6000, and different machines
3588 with different sizes for "long double" should use different
3589 negative type numbers. See stabs.texinfo. */
3590 name
= "long double";
3591 rettype
= debug_make_float_type (dhandle
, 8);
3595 rettype
= debug_make_int_type (dhandle
, 4, FALSE
);
3599 rettype
= debug_make_bool_type (dhandle
, 4);
3602 name
= "short real";
3603 rettype
= debug_make_float_type (dhandle
, 4);
3607 rettype
= debug_make_float_type (dhandle
, 8);
3617 rettype
= debug_make_int_type (dhandle
, 1, TRUE
);
3621 rettype
= debug_make_bool_type (dhandle
, 1);
3625 rettype
= debug_make_bool_type (dhandle
, 2);
3629 rettype
= debug_make_bool_type (dhandle
, 4);
3633 rettype
= debug_make_bool_type (dhandle
, 4);
3636 /* Complex type consisting of two IEEE single precision values. */
3638 rettype
= debug_make_complex_type (dhandle
, 8);
3641 /* Complex type consisting of two IEEE double precision values. */
3642 name
= "double complex";
3643 rettype
= debug_make_complex_type (dhandle
, 16);
3647 rettype
= debug_make_int_type (dhandle
, 1, FALSE
);
3651 rettype
= debug_make_int_type (dhandle
, 2, FALSE
);
3655 rettype
= debug_make_int_type (dhandle
, 4, FALSE
);
3660 rettype
= debug_make_int_type (dhandle
, 2, FALSE
);
3664 rettype
= debug_make_int_type (dhandle
, 8, FALSE
);
3667 name
= "unsigned long long";
3668 rettype
= debug_make_int_type (dhandle
, 8, TRUE
);
3672 rettype
= debug_make_bool_type (dhandle
, 8);
3676 rettype
= debug_make_int_type (dhandle
, 8, FALSE
);
3682 rettype
= debug_name_type (dhandle
, name
, rettype
);
3684 info
->xcoff_types
[-typenum
] = rettype
;
3689 /* Find or create a tagged type. */
3692 stab_find_tagged_type (void *dhandle
, struct stab_handle
*info
,
3693 const char *p
, int len
, enum debug_type_kind kind
)
3697 struct stab_tag
*st
;
3699 name
= savestring (p
, len
);
3701 /* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same
3702 namespace. This is right for C, and I don't know how to handle
3703 other languages. FIXME. */
3704 dtype
= debug_find_tagged_type (dhandle
, name
, DEBUG_KIND_ILLEGAL
);
3705 if (dtype
!= DEBUG_TYPE_NULL
)
3711 /* We need to allocate an entry on the undefined tag list. */
3712 for (st
= info
->tags
; st
!= NULL
; st
= st
->next
)
3714 if (st
->name
[0] == name
[0]
3715 && strcmp (st
->name
, name
) == 0)
3717 if (st
->kind
== DEBUG_KIND_ILLEGAL
)
3725 st
= (struct stab_tag
*) xmalloc (sizeof *st
);
3726 memset (st
, 0, sizeof *st
);
3728 st
->next
= info
->tags
;
3731 st
->slot
= DEBUG_TYPE_NULL
;
3732 st
->type
= debug_make_indirect_type (dhandle
, &st
->slot
, name
);
3739 /* In order to get the correct argument types for a stubbed method, we
3740 need to extract the argument types from a C++ mangled string.
3741 Since the argument types can refer back to the return type, this
3742 means that we must demangle the entire physical name. In gdb this
3743 is done by calling cplus_demangle and running the results back
3744 through the C++ expression parser. Since we have no expression
3745 parser, we must duplicate much of the work of cplus_demangle here.
3747 We assume that GNU style demangling is used, since this is only
3748 done for method stubs, and only g++ should output that form of
3749 debugging information. */
3751 /* This structure is used to hold a pointer to type information which
3752 demangling a string. */
3754 struct stab_demangle_typestring
3756 /* The start of the type. This is not null terminated. */
3757 const char *typestring
;
3758 /* The length of the type. */
3762 /* This structure is used to hold information while demangling a
3765 struct stab_demangle_info
3767 /* The debugging information handle. */
3769 /* The stab information handle. */
3770 struct stab_handle
*info
;
3771 /* The array of arguments we are building. */
3773 /* Whether the method takes a variable number of arguments. */
3774 bfd_boolean varargs
;
3775 /* The array of types we have remembered. */
3776 struct stab_demangle_typestring
*typestrings
;
3777 /* The number of typestrings. */
3778 unsigned int typestring_count
;
3779 /* The number of typestring slots we have allocated. */
3780 unsigned int typestring_alloc
;
3783 static void stab_bad_demangle (const char *);
3784 static unsigned int stab_demangle_count (const char **);
3785 static bfd_boolean
stab_demangle_get_count (const char **, unsigned int *);
3786 static bfd_boolean stab_demangle_prefix
3787 (struct stab_demangle_info
*, const char **, unsigned int);
3788 static bfd_boolean stab_demangle_function_name
3789 (struct stab_demangle_info
*, const char **, const char *);
3790 static bfd_boolean stab_demangle_signature
3791 (struct stab_demangle_info
*, const char **);
3792 static bfd_boolean stab_demangle_qualified
3793 (struct stab_demangle_info
*, const char **, debug_type
*);
3794 static bfd_boolean stab_demangle_template
3795 (struct stab_demangle_info
*, const char **, char **);
3796 static bfd_boolean stab_demangle_class
3797 (struct stab_demangle_info
*, const char **, const char **);
3798 static bfd_boolean stab_demangle_args
3799 (struct stab_demangle_info
*, const char **, debug_type
**, bfd_boolean
*);
3800 static bfd_boolean stab_demangle_arg
3801 (struct stab_demangle_info
*, const char **, debug_type
**,
3802 unsigned int *, unsigned int *);
3803 static bfd_boolean stab_demangle_type
3804 (struct stab_demangle_info
*, const char **, debug_type
*);
3805 static bfd_boolean stab_demangle_fund_type
3806 (struct stab_demangle_info
*, const char **, debug_type
*);
3807 static bfd_boolean stab_demangle_remember_type
3808 (struct stab_demangle_info
*, const char *, int);
3810 /* Warn about a bad demangling. */
3813 stab_bad_demangle (const char *s
)
3815 fprintf (stderr
, _("bad mangled name `%s'\n"), s
);
3818 /* Get a count from a stab string. */
3821 stab_demangle_count (const char **pp
)
3826 while (ISDIGIT (**pp
))
3829 count
+= **pp
- '0';
3835 /* Require a count in a string. The count may be multiple digits, in
3836 which case it must end in an underscore. */
3839 stab_demangle_get_count (const char **pp
, unsigned int *pi
)
3841 if (! ISDIGIT (**pp
))
3859 while (ISDIGIT (*p
));
3870 /* This function demangles a physical name, returning a NULL
3871 terminated array of argument types. */
3874 stab_demangle_argtypes (void *dhandle
, struct stab_handle
*info
,
3875 const char *physname
, bfd_boolean
*pvarargs
,
3876 unsigned int physname_len
)
3878 struct stab_demangle_info minfo
;
3880 /* Check for the g++ V3 ABI. */
3881 if (physname
[0] == '_' && physname
[1] == 'Z')
3882 return stab_demangle_v3_argtypes (dhandle
, info
, physname
, pvarargs
);
3884 minfo
.dhandle
= dhandle
;
3887 minfo
.varargs
= FALSE
;
3888 minfo
.typestring_alloc
= 10;
3889 minfo
.typestrings
= ((struct stab_demangle_typestring
*)
3890 xmalloc (minfo
.typestring_alloc
3891 * sizeof *minfo
.typestrings
));
3892 minfo
.typestring_count
= 0;
3894 /* cplus_demangle checks for special GNU mangled forms, but we can't
3895 see any of them in mangled method argument types. */
3897 if (! stab_demangle_prefix (&minfo
, &physname
, physname_len
))
3900 if (*physname
!= '\0')
3902 if (! stab_demangle_signature (&minfo
, &physname
))
3906 free (minfo
.typestrings
);
3907 minfo
.typestrings
= NULL
;
3909 if (minfo
.args
== NULL
)
3910 fprintf (stderr
, _("no argument types in mangled string\n"));
3912 *pvarargs
= minfo
.varargs
;
3916 if (minfo
.typestrings
!= NULL
)
3917 free (minfo
.typestrings
);
3921 /* Demangle the prefix of the mangled name. */
3924 stab_demangle_prefix (struct stab_demangle_info
*minfo
, const char **pp
,
3925 unsigned int physname_len
)
3930 /* cplus_demangle checks for global constructors and destructors,
3931 but we can't see them in mangled argument types. */
3934 scan
= *pp
+ physname_len
;
3937 /* Look for `__'. */
3940 scan
= strchr (scan
, '_');
3941 while (scan
!= NULL
&& *++scan
!= '_');
3945 stab_bad_demangle (*pp
);
3951 /* We found `__'; move ahead to the last contiguous `__' pair. */
3952 i
= strspn (scan
, "_");
3958 && (ISDIGIT (scan
[2])
3962 /* This is a GNU style constructor name. */
3966 else if (scan
== *pp
3967 && ! ISDIGIT (scan
[2])
3970 /* Look for the `__' that separates the prefix from the
3972 while (*scan
== '_')
3974 scan
= strstr (scan
, "__");
3975 if (scan
== NULL
|| scan
[2] == '\0')
3977 stab_bad_demangle (*pp
);
3981 return stab_demangle_function_name (minfo
, pp
, scan
);
3983 else if (scan
[2] != '\0')
3985 /* The name doesn't start with `__', but it does contain `__'. */
3986 return stab_demangle_function_name (minfo
, pp
, scan
);
3990 stab_bad_demangle (*pp
);
3996 /* Demangle a function name prefix. The scan argument points to the
3997 double underscore which separates the function name from the
4001 stab_demangle_function_name (struct stab_demangle_info
*minfo
,
4002 const char **pp
, const char *scan
)
4006 /* The string from *pp to scan is the name of the function. We
4007 don't care about the name, since we just looking for argument
4008 types. However, for conversion operators, the name may include a
4009 type which we must remember in order to handle backreferences. */
4015 && CONST_STRNEQ (name
, "type")
4016 && (name
[4] == '$' || name
[4] == '.'))
4020 /* This is a type conversion operator. */
4022 if (! stab_demangle_type (minfo
, &tem
, (debug_type
*) NULL
))
4025 else if (name
[0] == '_'
4032 /* This is a type conversion operator. */
4034 if (! stab_demangle_type (minfo
, &tem
, (debug_type
*) NULL
))
4041 /* Demangle the signature. This is where the argument types are
4045 stab_demangle_signature (struct stab_demangle_info
*minfo
, const char **pp
)
4048 bfd_boolean expect_func
, func_done
;
4053 expect_func
= FALSE
;
4057 while (**pp
!= '\0')
4063 if (! stab_demangle_qualified (minfo
, pp
, (debug_type
*) NULL
)
4064 || ! stab_demangle_remember_type (minfo
, hold
, *pp
- hold
))
4071 /* Static member function. FIXME: Can this happen? */
4078 /* Const member function. */
4084 case '0': case '1': case '2': case '3': case '4':
4085 case '5': case '6': case '7': case '8': case '9':
4088 if (! stab_demangle_class (minfo
, pp
, (const char **) NULL
)
4089 || ! stab_demangle_remember_type (minfo
, hold
, *pp
- hold
))
4096 /* Function. I don't know if this actually happens with g++
4101 if (! stab_demangle_args (minfo
, pp
, &minfo
->args
, &minfo
->varargs
))
4109 if (! stab_demangle_template (minfo
, pp
, (char **) NULL
)
4110 || ! stab_demangle_remember_type (minfo
, hold
, *pp
- hold
))
4117 /* At the outermost level, we cannot have a return type
4118 specified, so if we run into another '_' at this point we
4119 are dealing with a mangled name that is either bogus, or
4120 has been mangled by some algorithm we don't know how to
4121 deal with. So just reject the entire demangling. */
4122 stab_bad_demangle (orig
);
4126 /* Assume we have stumbled onto the first outermost function
4127 argument token, and start processing args. */
4129 if (! stab_demangle_args (minfo
, pp
, &minfo
->args
, &minfo
->varargs
))
4137 if (! stab_demangle_args (minfo
, pp
, &minfo
->args
, &minfo
->varargs
))
4144 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
4145 bar__3fooi is 'foo::bar(int)'. We get here when we find the
4146 first case, and need to ensure that the '(void)' gets added
4147 to the current declp. */
4148 if (! stab_demangle_args (minfo
, pp
, &minfo
->args
, &minfo
->varargs
))
4155 /* Demangle a qualified name, such as "Q25Outer5Inner" which is the
4156 mangled form of "Outer::Inner". */
4159 stab_demangle_qualified (struct stab_demangle_info
*minfo
, const char **pp
,
4164 unsigned int qualifiers
;
4172 /* GNU mangled name with more than 9 classes. The count is
4173 preceded by an underscore (to distinguish it from the <= 9
4174 case) and followed by an underscore. */
4176 if (! ISDIGIT (*p
) || *p
== '0')
4178 stab_bad_demangle (orig
);
4181 qualifiers
= atoi (p
);
4182 while (ISDIGIT (*p
))
4186 stab_bad_demangle (orig
);
4192 case '1': case '2': case '3': case '4': case '5':
4193 case '6': case '7': case '8': case '9':
4194 qualifiers
= (*pp
)[1] - '0';
4195 /* Skip an optional underscore after the count. */
4196 if ((*pp
)[2] == '_')
4203 stab_bad_demangle (orig
);
4207 context
= DEBUG_TYPE_NULL
;
4209 /* Pick off the names. */
4210 while (qualifiers
-- > 0)
4218 if (! stab_demangle_template (minfo
, pp
,
4219 ptype
!= NULL
? &name
: NULL
))
4224 context
= stab_find_tagged_type (minfo
->dhandle
, minfo
->info
,
4225 name
, strlen (name
),
4228 if (context
== DEBUG_TYPE_NULL
)
4236 len
= stab_demangle_count (pp
);
4237 if (strlen (*pp
) < len
)
4239 stab_bad_demangle (orig
);
4245 const debug_field
*fields
;
4248 if (context
!= DEBUG_TYPE_NULL
)
4249 fields
= debug_get_fields (minfo
->dhandle
, context
);
4251 context
= DEBUG_TYPE_NULL
;
4257 /* Try to find the type by looking through the
4258 fields of context until we find a field with the
4259 same type. This ought to work for a class
4260 defined within a class, but it won't work for,
4261 e.g., an enum defined within a class. stabs does
4262 not give us enough information to figure out the
4265 name
= savestring (*pp
, len
);
4267 for (; *fields
!= DEBUG_FIELD_NULL
; fields
++)
4272 ft
= debug_get_field_type (minfo
->dhandle
, *fields
);
4278 dn
= debug_get_type_name (minfo
->dhandle
, ft
);
4279 if (dn
!= NULL
&& strcmp (dn
, name
) == 0)
4289 if (context
== DEBUG_TYPE_NULL
)
4291 /* We have to fall back on finding the type by name.
4292 If there are more types to come, then this must
4293 be a class. Otherwise, it could be anything. */
4295 if (qualifiers
== 0)
4299 name
= savestring (*pp
, len
);
4300 context
= debug_find_named_type (minfo
->dhandle
,
4305 if (context
== DEBUG_TYPE_NULL
)
4307 context
= stab_find_tagged_type (minfo
->dhandle
,
4311 ? DEBUG_KIND_ILLEGAL
4312 : DEBUG_KIND_CLASS
));
4313 if (context
== DEBUG_TYPE_NULL
)
4329 /* Demangle a template. If PNAME is not NULL, this sets *PNAME to a
4330 string representation of the template. */
4333 stab_demangle_template (struct stab_demangle_info
*minfo
, const char **pp
,
4343 /* Skip the template name. */
4344 r
= stab_demangle_count (pp
);
4345 if (r
== 0 || strlen (*pp
) < r
)
4347 stab_bad_demangle (orig
);
4352 /* Get the size of the parameter list. */
4353 if (stab_demangle_get_count (pp
, &r
) == 0)
4355 stab_bad_demangle (orig
);
4359 for (i
= 0; i
< r
; i
++)
4363 /* This is a type parameter. */
4365 if (! stab_demangle_type (minfo
, pp
, (debug_type
*) NULL
))
4371 bfd_boolean pointerp
, realp
, integralp
, charp
, boolp
;
4382 /* This is a value parameter. */
4384 if (! stab_demangle_type (minfo
, pp
, (debug_type
*) NULL
))
4387 while (*old_p
!= '\0' && ! done
)
4397 case 'C': /* Const. */
4398 case 'S': /* Signed. */
4399 case 'U': /* Unsigned. */
4400 case 'V': /* Volatile. */
4401 case 'F': /* Function. */
4402 case 'M': /* Member function. */
4406 case 'Q': /* Qualified name. */
4410 case 'T': /* Remembered type. */
4412 case 'v': /* Void. */
4414 case 'x': /* Long long. */
4415 case 'l': /* Long. */
4416 case 'i': /* Int. */
4417 case 's': /* Short. */
4418 case 'w': /* Wchar_t. */
4422 case 'b': /* Bool. */
4426 case 'c': /* Char. */
4430 case 'r': /* Long double. */
4431 case 'd': /* Double. */
4432 case 'f': /* Float. */
4437 /* Assume it's a user defined integral type. */
4448 while (ISDIGIT (**pp
))
4457 val
= stab_demangle_count (pp
);
4460 stab_bad_demangle (orig
);
4468 val
= stab_demangle_count (pp
);
4469 if (val
!= 0 && val
!= 1)
4471 stab_bad_demangle (orig
);
4479 while (ISDIGIT (**pp
))
4484 while (ISDIGIT (**pp
))
4490 while (ISDIGIT (**pp
))
4498 len
= stab_demangle_count (pp
);
4501 stab_bad_demangle (orig
);
4509 /* We can translate this to a string fairly easily by invoking the
4510 regular demangling routine. */
4513 char *s1
, *s2
, *s3
, *s4
= NULL
;
4516 s1
= savestring (orig
, *pp
- orig
);
4518 s2
= concat ("NoSuchStrinG__", s1
, (const char *) NULL
);
4522 s3
= cplus_demangle (s2
, demangle_flags
);
4527 s4
= strstr (s3
, "::NoSuchStrinG");
4528 if (s3
== NULL
|| s4
== NULL
)
4530 stab_bad_demangle (orig
);
4536 /* Eliminating all spaces, except those between > characters,
4537 makes it more likely that the demangled name will match the
4538 name which g++ used as the structure name. */
4539 for (from
= to
= s3
; from
!= s4
; ++from
)
4541 || (from
[1] == '>' && from
> s3
&& from
[-1] == '>'))
4544 *pname
= savestring (s3
, to
- s3
);
4552 /* Demangle a class name. */
4555 stab_demangle_class (struct stab_demangle_info
*minfo ATTRIBUTE_UNUSED
,
4556 const char **pp
, const char **pstart
)
4563 n
= stab_demangle_count (pp
);
4564 if (strlen (*pp
) < n
)
4566 stab_bad_demangle (orig
);
4578 /* Demangle function arguments. If the pargs argument is not NULL, it
4579 is set to a NULL terminated array holding the arguments. */
4582 stab_demangle_args (struct stab_demangle_info
*minfo
, const char **pp
,
4583 debug_type
**pargs
, bfd_boolean
*pvarargs
)
4586 unsigned int alloc
, count
;
4593 *pargs
= (debug_type
*) xmalloc (alloc
* sizeof **pargs
);
4598 while (**pp
!= '_' && **pp
!= '\0' && **pp
!= 'e')
4600 if (**pp
== 'N' || **pp
== 'T')
4608 if (temptype
== 'T')
4612 if (! stab_demangle_get_count (pp
, &r
))
4614 stab_bad_demangle (orig
);
4619 if (! stab_demangle_get_count (pp
, &t
))
4621 stab_bad_demangle (orig
);
4625 if (t
>= minfo
->typestring_count
)
4627 stab_bad_demangle (orig
);
4634 tem
= minfo
->typestrings
[t
].typestring
;
4635 if (! stab_demangle_arg (minfo
, &tem
, pargs
, &count
, &alloc
))
4641 if (! stab_demangle_arg (minfo
, pp
, pargs
, &count
, &alloc
))
4647 (*pargs
)[count
] = DEBUG_TYPE_NULL
;
4659 /* Demangle a single argument. */
4662 stab_demangle_arg (struct stab_demangle_info
*minfo
, const char **pp
,
4663 debug_type
**pargs
, unsigned int *pcount
,
4664 unsigned int *palloc
)
4670 if (! stab_demangle_type (minfo
, pp
,
4671 pargs
== NULL
? (debug_type
*) NULL
: &type
)
4672 || ! stab_demangle_remember_type (minfo
, start
, *pp
- start
))
4677 if (type
== DEBUG_TYPE_NULL
)
4680 if (*pcount
+ 1 >= *palloc
)
4683 *pargs
= ((debug_type
*)
4684 xrealloc (*pargs
, *palloc
* sizeof **pargs
));
4686 (*pargs
)[*pcount
] = type
;
4693 /* Demangle a type. If the ptype argument is not NULL, *ptype is set
4694 to the newly allocated type. */
4697 stab_demangle_type (struct stab_demangle_info
*minfo
, const char **pp
,
4708 /* A pointer type. */
4710 if (! stab_demangle_type (minfo
, pp
, ptype
))
4713 *ptype
= debug_make_pointer_type (minfo
->dhandle
, *ptype
);
4717 /* A reference type. */
4719 if (! stab_demangle_type (minfo
, pp
, ptype
))
4722 *ptype
= debug_make_reference_type (minfo
->dhandle
, *ptype
);
4732 while (**pp
!= '\0' && **pp
!= '_')
4734 if (! ISDIGIT (**pp
))
4736 stab_bad_demangle (orig
);
4745 stab_bad_demangle (orig
);
4750 if (! stab_demangle_type (minfo
, pp
, ptype
))
4754 debug_type int_type
;
4756 int_type
= debug_find_named_type (minfo
->dhandle
, "int");
4757 if (int_type
== NULL
)
4758 int_type
= debug_make_int_type (minfo
->dhandle
, 4, FALSE
);
4759 *ptype
= debug_make_array_type (minfo
->dhandle
, *ptype
, int_type
,
4766 /* A back reference to a remembered type. */
4772 if (! stab_demangle_get_count (pp
, &i
))
4774 stab_bad_demangle (orig
);
4777 if (i
>= minfo
->typestring_count
)
4779 stab_bad_demangle (orig
);
4782 p
= minfo
->typestrings
[i
].typestring
;
4783 if (! stab_demangle_type (minfo
, &p
, ptype
))
4792 bfd_boolean varargs
;
4795 if (! stab_demangle_args (minfo
, pp
,
4797 ? (debug_type
**) NULL
4800 ? (bfd_boolean
*) NULL
4805 /* cplus_demangle will accept a function without a return
4806 type, but I don't know when that will happen, or what
4807 to do if it does. */
4808 stab_bad_demangle (orig
);
4812 if (! stab_demangle_type (minfo
, pp
, ptype
))
4815 *ptype
= debug_make_function_type (minfo
->dhandle
, *ptype
, args
,
4824 bfd_boolean memberp
;
4825 debug_type class_type
= DEBUG_TYPE_NULL
;
4827 bfd_boolean varargs
;
4831 memberp
= **pp
== 'M';
4838 n
= stab_demangle_count (pp
);
4839 if (strlen (*pp
) < n
)
4841 stab_bad_demangle (orig
);
4849 class_type
= stab_find_tagged_type (minfo
->dhandle
,
4853 if (class_type
== DEBUG_TYPE_NULL
)
4857 else if (**pp
== 'Q')
4859 if (! stab_demangle_qualified (minfo
, pp
,
4861 ? (debug_type
*) NULL
4867 stab_bad_demangle (orig
);
4877 else if (**pp
== 'V')
4883 stab_bad_demangle (orig
);
4887 if (! stab_demangle_args (minfo
, pp
,
4889 ? (debug_type
**) NULL
4892 ? (bfd_boolean
*) NULL
4899 stab_bad_demangle (orig
);
4904 if (! stab_demangle_type (minfo
, pp
, ptype
))
4910 *ptype
= debug_make_offset_type (minfo
->dhandle
, class_type
,
4914 /* FIXME: We have no way to record constp or
4916 *ptype
= debug_make_method_type (minfo
->dhandle
, *ptype
,
4917 class_type
, args
, varargs
);
4925 if (! stab_demangle_type (minfo
, pp
, ptype
))
4931 if (! stab_demangle_type (minfo
, pp
, ptype
))
4934 *ptype
= debug_make_const_type (minfo
->dhandle
, *ptype
);
4939 if (! stab_demangle_qualified (minfo
, pp
, ptype
))
4945 if (! stab_demangle_fund_type (minfo
, pp
, ptype
))
4953 /* Demangle a fundamental type. If the ptype argument is not NULL,
4954 *ptype is set to the newly allocated type. */
4957 stab_demangle_fund_type (struct stab_demangle_info
*minfo
, const char **pp
,
4961 bfd_boolean constp
, volatilep
, unsignedp
, signedp
;
5006 /* cplus_demangle permits this, but I don't know what it means. */
5007 stab_bad_demangle (orig
);
5010 case 'v': /* void */
5013 *ptype
= debug_find_named_type (minfo
->dhandle
, "void");
5014 if (*ptype
== DEBUG_TYPE_NULL
)
5015 *ptype
= debug_make_void_type (minfo
->dhandle
);
5020 case 'x': /* long long */
5023 *ptype
= debug_find_named_type (minfo
->dhandle
,
5025 ? "long long unsigned int"
5026 : "long long int"));
5027 if (*ptype
== DEBUG_TYPE_NULL
)
5028 *ptype
= debug_make_int_type (minfo
->dhandle
, 8, unsignedp
);
5033 case 'l': /* long */
5036 *ptype
= debug_find_named_type (minfo
->dhandle
,
5038 ? "long unsigned int"
5040 if (*ptype
== DEBUG_TYPE_NULL
)
5041 *ptype
= debug_make_int_type (minfo
->dhandle
, 4, unsignedp
);
5049 *ptype
= debug_find_named_type (minfo
->dhandle
,
5053 if (*ptype
== DEBUG_TYPE_NULL
)
5054 *ptype
= debug_make_int_type (minfo
->dhandle
, 4, unsignedp
);
5059 case 's': /* short */
5062 *ptype
= debug_find_named_type (minfo
->dhandle
,
5064 ? "short unsigned int"
5066 if (*ptype
== DEBUG_TYPE_NULL
)
5067 *ptype
= debug_make_int_type (minfo
->dhandle
, 2, unsignedp
);
5072 case 'b': /* bool */
5075 *ptype
= debug_find_named_type (minfo
->dhandle
, "bool");
5076 if (*ptype
== DEBUG_TYPE_NULL
)
5077 *ptype
= debug_make_bool_type (minfo
->dhandle
, 4);
5082 case 'c': /* char */
5085 *ptype
= debug_find_named_type (minfo
->dhandle
,
5091 if (*ptype
== DEBUG_TYPE_NULL
)
5092 *ptype
= debug_make_int_type (minfo
->dhandle
, 1, unsignedp
);
5097 case 'w': /* wchar_t */
5100 *ptype
= debug_find_named_type (minfo
->dhandle
, "__wchar_t");
5101 if (*ptype
== DEBUG_TYPE_NULL
)
5102 *ptype
= debug_make_int_type (minfo
->dhandle
, 2, TRUE
);
5107 case 'r': /* long double */
5110 *ptype
= debug_find_named_type (minfo
->dhandle
, "long double");
5111 if (*ptype
== DEBUG_TYPE_NULL
)
5112 *ptype
= debug_make_float_type (minfo
->dhandle
, 8);
5117 case 'd': /* double */
5120 *ptype
= debug_find_named_type (minfo
->dhandle
, "double");
5121 if (*ptype
== DEBUG_TYPE_NULL
)
5122 *ptype
= debug_make_float_type (minfo
->dhandle
, 8);
5127 case 'f': /* float */
5130 *ptype
= debug_find_named_type (minfo
->dhandle
, "float");
5131 if (*ptype
== DEBUG_TYPE_NULL
)
5132 *ptype
= debug_make_float_type (minfo
->dhandle
, 4);
5139 if (! ISDIGIT (**pp
))
5141 stab_bad_demangle (orig
);
5145 case '0': case '1': case '2': case '3': case '4':
5146 case '5': case '6': case '7': case '8': case '9':
5150 if (! stab_demangle_class (minfo
, pp
, &hold
))
5156 name
= savestring (hold
, *pp
- hold
);
5157 *ptype
= debug_find_named_type (minfo
->dhandle
, name
);
5159 if (*ptype
== DEBUG_TYPE_NULL
)
5161 /* FIXME: It is probably incorrect to assume that
5162 undefined types are tagged types. */
5163 *ptype
= stab_find_tagged_type (minfo
->dhandle
, minfo
->info
,
5165 DEBUG_KIND_ILLEGAL
);
5166 if (*ptype
== DEBUG_TYPE_NULL
)
5177 if (! stab_demangle_template (minfo
, pp
,
5178 ptype
!= NULL
? &name
: NULL
))
5182 *ptype
= stab_find_tagged_type (minfo
->dhandle
, minfo
->info
,
5183 name
, strlen (name
),
5186 if (*ptype
== DEBUG_TYPE_NULL
)
5193 stab_bad_demangle (orig
);
5200 *ptype
= debug_make_const_type (minfo
->dhandle
, *ptype
);
5202 *ptype
= debug_make_volatile_type (minfo
->dhandle
, *ptype
);
5208 /* Remember a type string in a demangled string. */
5211 stab_demangle_remember_type (struct stab_demangle_info
*minfo
,
5212 const char *p
, int len
)
5214 if (minfo
->typestring_count
>= minfo
->typestring_alloc
)
5216 minfo
->typestring_alloc
+= 10;
5217 minfo
->typestrings
= ((struct stab_demangle_typestring
*)
5218 xrealloc (minfo
->typestrings
,
5219 (minfo
->typestring_alloc
5220 * sizeof *minfo
->typestrings
)));
5223 minfo
->typestrings
[minfo
->typestring_count
].typestring
= p
;
5224 minfo
->typestrings
[minfo
->typestring_count
].len
= (unsigned int) len
;
5225 ++minfo
->typestring_count
;
5230 /* Demangle names encoded using the g++ V3 ABI. The newer versions of
5231 g++ which use this ABI do not encode ordinary method argument types
5232 in a mangled name; they simply output the argument types. However,
5233 for a static method, g++ simply outputs the return type and the
5234 physical name. So in that case we need to demangle the name here.
5235 Here PHYSNAME is the physical name of the function, and we set the
5236 variable pointed at by PVARARGS to indicate whether this function
5237 is varargs. This returns NULL, or a NULL terminated array of
5241 stab_demangle_v3_argtypes (void *dhandle
, struct stab_handle
*info
,
5242 const char *physname
, bfd_boolean
*pvarargs
)
5244 struct demangle_component
*dc
;
5248 dc
= cplus_demangle_v3_components (physname
, DMGL_PARAMS
| demangle_flags
, &mem
);
5251 stab_bad_demangle (physname
);
5255 /* We expect to see TYPED_NAME, and the right subtree describes the
5257 if (dc
->type
!= DEMANGLE_COMPONENT_TYPED_NAME
5258 || dc
->u
.s_binary
.right
->type
!= DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5260 fprintf (stderr
, _("Demangled name is not a function\n"));
5265 pargs
= stab_demangle_v3_arglist (dhandle
, info
,
5266 dc
->u
.s_binary
.right
->u
.s_binary
.right
,
5274 /* Demangle an argument list in a struct demangle_component tree.
5275 Returns a DEBUG_TYPE_NULL terminated array of argument types, and
5276 sets *PVARARGS to indicate whether this is a varargs function. */
5279 stab_demangle_v3_arglist (void *dhandle
, struct stab_handle
*info
,
5280 struct demangle_component
*arglist
,
5281 bfd_boolean
*pvarargs
)
5283 struct demangle_component
*dc
;
5284 unsigned int alloc
, count
;
5288 pargs
= (debug_type
*) xmalloc (alloc
* sizeof *pargs
);
5295 dc
= dc
->u
.s_binary
.right
)
5298 bfd_boolean varargs
;
5300 if (dc
->type
!= DEMANGLE_COMPONENT_ARGLIST
)
5302 fprintf (stderr
, _("Unexpected type in v3 arglist demangling\n"));
5307 /* PR 13925: Cope if the demangler returns an empty
5308 context for a function with no arguments. */
5309 if (dc
->u
.s_binary
.left
== NULL
)
5312 arg
= stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.left
,
5325 if (count
+ 1 >= alloc
)
5328 pargs
= (debug_type
*) xrealloc (pargs
, alloc
* sizeof *pargs
);
5335 pargs
[count
] = DEBUG_TYPE_NULL
;
5340 /* Convert a struct demangle_component tree describing an argument
5341 type into a debug_type. */
5344 stab_demangle_v3_arg (void *dhandle
, struct stab_handle
*info
,
5345 struct demangle_component
*dc
, debug_type context
,
5346 bfd_boolean
*pvarargs
)
5350 if (pvarargs
!= NULL
)
5355 /* FIXME: These are demangle component types which we probably
5356 need to handle one way or another. */
5357 case DEMANGLE_COMPONENT_LOCAL_NAME
:
5358 case DEMANGLE_COMPONENT_TYPED_NAME
:
5359 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
5360 case DEMANGLE_COMPONENT_CTOR
:
5361 case DEMANGLE_COMPONENT_DTOR
:
5362 case DEMANGLE_COMPONENT_JAVA_CLASS
:
5363 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
5364 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
5365 case DEMANGLE_COMPONENT_CONST_THIS
:
5366 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5367 case DEMANGLE_COMPONENT_COMPLEX
:
5368 case DEMANGLE_COMPONENT_IMAGINARY
:
5369 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
5370 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
5371 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
5372 case DEMANGLE_COMPONENT_ARGLIST
:
5374 fprintf (stderr
, _("Unrecognized demangle component %d\n"),
5378 case DEMANGLE_COMPONENT_NAME
:
5379 if (context
!= NULL
)
5381 const debug_field
*fields
;
5383 fields
= debug_get_fields (dhandle
, context
);
5386 /* Try to find this type by looking through the context
5388 for (; *fields
!= DEBUG_FIELD_NULL
; fields
++)
5393 ft
= debug_get_field_type (dhandle
, *fields
);
5396 dn
= debug_get_type_name (dhandle
, ft
);
5398 && (int) strlen (dn
) == dc
->u
.s_name
.len
5399 && strncmp (dn
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
) == 0)
5404 return stab_find_tagged_type (dhandle
, info
, dc
->u
.s_name
.s
,
5405 dc
->u
.s_name
.len
, DEBUG_KIND_ILLEGAL
);
5407 case DEMANGLE_COMPONENT_QUAL_NAME
:
5408 context
= stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.left
,
5410 if (context
== NULL
)
5412 return stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.right
,
5415 case DEMANGLE_COMPONENT_TEMPLATE
:
5420 /* We print this component to get a class name which we can
5421 use. FIXME: This probably won't work if the template uses
5422 template parameters which refer to an outer template. */
5423 p
= cplus_demangle_print (DMGL_PARAMS
| demangle_flags
, dc
, 20, &alc
);
5426 fprintf (stderr
, _("Failed to print demangled template\n"));
5429 dt
= stab_find_tagged_type (dhandle
, info
, p
, strlen (p
),
5435 case DEMANGLE_COMPONENT_SUB_STD
:
5436 return stab_find_tagged_type (dhandle
, info
, dc
->u
.s_string
.string
,
5437 dc
->u
.s_string
.len
, DEBUG_KIND_ILLEGAL
);
5439 case DEMANGLE_COMPONENT_RESTRICT
:
5440 case DEMANGLE_COMPONENT_VOLATILE
:
5441 case DEMANGLE_COMPONENT_CONST
:
5442 case DEMANGLE_COMPONENT_POINTER
:
5443 case DEMANGLE_COMPONENT_REFERENCE
:
5444 dt
= stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.left
, NULL
,
5453 case DEMANGLE_COMPONENT_RESTRICT
:
5454 /* FIXME: We have no way to represent restrict. */
5456 case DEMANGLE_COMPONENT_VOLATILE
:
5457 return debug_make_volatile_type (dhandle
, dt
);
5458 case DEMANGLE_COMPONENT_CONST
:
5459 return debug_make_const_type (dhandle
, dt
);
5460 case DEMANGLE_COMPONENT_POINTER
:
5461 return debug_make_pointer_type (dhandle
, dt
);
5462 case DEMANGLE_COMPONENT_REFERENCE
:
5463 return debug_make_reference_type (dhandle
, dt
);
5466 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
5469 bfd_boolean varargs
;
5471 if (dc
->u
.s_binary
.left
== NULL
)
5473 /* In this case the return type is actually unknown.
5474 However, I'm not sure this will ever arise in practice;
5475 normally an unknown return type would only appear at
5476 the top level, which is handled above. */
5477 dt
= debug_make_void_type (dhandle
);
5480 dt
= stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.left
, NULL
,
5485 pargs
= stab_demangle_v3_arglist (dhandle
, info
,
5486 dc
->u
.s_binary
.right
,
5491 return debug_make_function_type (dhandle
, dt
, pargs
, varargs
);
5494 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
5500 /* We print this component in order to find out the type name.
5501 FIXME: Should we instead expose the
5502 demangle_builtin_type_info structure? */
5503 p
= cplus_demangle_print (DMGL_PARAMS
| demangle_flags
, dc
, 20, &alc
);
5506 fprintf (stderr
, _("Couldn't get demangled builtin type\n"));
5510 /* The mangling is based on the type, but does not itself
5511 indicate what the sizes are. So we have to guess. */
5512 if (strcmp (p
, "signed char") == 0)
5513 ret
= debug_make_int_type (dhandle
, 1, FALSE
);
5514 else if (strcmp (p
, "bool") == 0)
5515 ret
= debug_make_bool_type (dhandle
, 1);
5516 else if (strcmp (p
, "char") == 0)
5517 ret
= debug_make_int_type (dhandle
, 1, FALSE
);
5518 else if (strcmp (p
, "double") == 0)
5519 ret
= debug_make_float_type (dhandle
, 8);
5520 else if (strcmp (p
, "long double") == 0)
5521 ret
= debug_make_float_type (dhandle
, 8);
5522 else if (strcmp (p
, "float") == 0)
5523 ret
= debug_make_float_type (dhandle
, 4);
5524 else if (strcmp (p
, "__float128") == 0)
5525 ret
= debug_make_float_type (dhandle
, 16);
5526 else if (strcmp (p
, "unsigned char") == 0)
5527 ret
= debug_make_int_type (dhandle
, 1, TRUE
);
5528 else if (strcmp (p
, "int") == 0)
5529 ret
= debug_make_int_type (dhandle
, 4, FALSE
);
5530 else if (strcmp (p
, "unsigned int") == 0)
5531 ret
= debug_make_int_type (dhandle
, 4, TRUE
);
5532 else if (strcmp (p
, "long") == 0)
5533 ret
= debug_make_int_type (dhandle
, 4, FALSE
);
5534 else if (strcmp (p
, "unsigned long") == 0)
5535 ret
= debug_make_int_type (dhandle
, 4, TRUE
);
5536 else if (strcmp (p
, "__int128") == 0)
5537 ret
= debug_make_int_type (dhandle
, 16, FALSE
);
5538 else if (strcmp (p
, "unsigned __int128") == 0)
5539 ret
= debug_make_int_type (dhandle
, 16, TRUE
);
5540 else if (strcmp (p
, "short") == 0)
5541 ret
= debug_make_int_type (dhandle
, 2, FALSE
);
5542 else if (strcmp (p
, "unsigned short") == 0)
5543 ret
= debug_make_int_type (dhandle
, 2, TRUE
);
5544 else if (strcmp (p
, "void") == 0)
5545 ret
= debug_make_void_type (dhandle
);
5546 else if (strcmp (p
, "wchar_t") == 0)
5547 ret
= debug_make_int_type (dhandle
, 4, TRUE
);
5548 else if (strcmp (p
, "long long") == 0)
5549 ret
= debug_make_int_type (dhandle
, 8, FALSE
);
5550 else if (strcmp (p
, "unsigned long long") == 0)
5551 ret
= debug_make_int_type (dhandle
, 8, TRUE
);
5552 else if (strcmp (p
, "...") == 0)
5554 if (pvarargs
== NULL
)
5555 fprintf (stderr
, _("Unexpected demangled varargs\n"));
5562 fprintf (stderr
, _("Unrecognized demangled builtin type\n"));