1 /* stabs.c -- Parse stabs debugging information
2 Copyright (C) 1995-2023 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@cygnus.com>.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 /* This file contains code which parses stabs debugging information.
23 The organization of this code is based on the gdb stabs reading
24 code. The job it does is somewhat different, because it is not
25 trying to identify the correct address for anything. */
29 #include "libiberty.h"
30 #include "safe-ctype.h"
34 #include "filenames.h"
35 #include "aout/aout64.h"
36 #include "aout/stab_gnu.h"
38 /* The number of predefined XCOFF types. */
40 #define XCOFF_TYPE_COUNT 34
42 /* This structure is used as a handle so that the stab parsing doesn't
43 need to use any static variables. */
49 /* TRUE if this is stabs in sections. */
51 /* The symbol table. */
53 /* The number of symbols. */
55 /* The accumulated file name string. */
57 /* The value of the last N_SO symbol. */
59 /* The value of the start of the file, so that we can handle file
60 relative N_LBRAC and N_RBRAC symbols. */
61 bfd_vma file_start_offset
;
62 /* The offset of the start of the function, so that we can handle
63 function relative N_LBRAC and N_RBRAC symbols. */
64 bfd_vma function_start_offset
;
65 /* The version number of gcc which compiled the current compilation
66 unit, 0 if not compiled by gcc. */
68 /* Whether an N_OPT symbol was seen that was not generated by gcc,
69 so that we can detect the SunPRO compiler. */
71 /* The main file name. */
73 /* A stack of unfinished N_BINCL files. */
74 struct bincl_file
*bincl_stack
;
75 /* A list of finished N_BINCL files. */
76 struct bincl_file
*bincl_list
;
77 /* Whether we are inside a function or not. */
79 /* The address of the end of the function, used if we have seen an
80 N_FUN symbol while in a function. This is -1 if we have not seen
81 an N_FUN (the normal case). */
83 /* The depth of block nesting. */
85 /* List of pending variable definitions. */
86 struct stab_pending_var
*pending
;
87 /* Number of files for which we have types. */
89 /* Lists of types per file. */
90 struct stab_types
**file_types
;
91 /* Predefined XCOFF types. */
92 debug_type xcoff_types
[XCOFF_TYPE_COUNT
];
94 struct stab_tag
*tags
;
95 /* Set by parse_stab_type if it sees a structure defined as a cross
96 reference to itself. Reset by parse_stab_type otherwise. */
100 /* A list of these structures is used to hold pending variable
101 definitions seen before the N_LBRAC of a block. */
103 struct stab_pending_var
105 /* Next pending variable definition. */
106 struct stab_pending_var
*next
;
112 enum debug_var_kind kind
;
117 /* A list of these structures is used to hold the types for a single
122 /* Next set of slots for this file. */
123 struct stab_types
*next
;
124 /* Where the TYPES array starts. */
125 unsigned int base_index
;
126 /* Types indexed by type number. */
127 #define STAB_TYPES_SLOTS (16)
128 debug_type types
[STAB_TYPES_SLOTS
];
131 /* We keep a list of undefined tags that we encounter, so that we can
132 fill them in if the tag is later defined. */
136 /* Next undefined tag. */
137 struct stab_tag
*next
;
141 enum debug_type_kind kind
;
142 /* Slot to hold real type when we discover it. If we don't, we fill
143 in an undefined tag type. */
145 /* Indirect type we have created to point at slot. */
149 static char *savestring (const char *, int);
151 static void bad_stab (const char *);
152 static void warn_stab (const char *, const char *);
153 static bool parse_stab_string
154 (void *, struct stab_handle
*, int, int, bfd_vma
,
155 const char *, const char *);
156 static debug_type parse_stab_type
157 (void *, struct stab_handle
*, const char *, const char **,
158 debug_type
**, const char *);
159 static bool parse_stab_type_number
160 (const char **, int *, const char *);
161 static debug_type parse_stab_range_type
162 (void *, struct stab_handle
*, const char *, const char **,
163 const int *, const char *);
164 static debug_type parse_stab_sun_builtin_type
165 (void *, const char **, const char *);
166 static debug_type parse_stab_sun_floating_type
167 (void *, const char **, const char *);
168 static debug_type parse_stab_enum_type
169 (void *, const char **, const char *);
170 static debug_type parse_stab_struct_type
171 (void *, struct stab_handle
*, const char *, const char **,
172 bool, const int *, const char *);
173 static bool parse_stab_baseclasses
174 (void *, struct stab_handle
*, const char **, debug_baseclass
**,
176 static bool parse_stab_struct_fields
177 (void *, struct stab_handle
*, const char **, debug_field
**,
178 bool *, const char *);
179 static bool parse_stab_cpp_abbrev
180 (void *, struct stab_handle
*, const char **, debug_field
*, const char *);
181 static bool parse_stab_one_struct_field
182 (void *, struct stab_handle
*, const char **, const char *,
183 debug_field
*, bool *, const char *);
184 static bool parse_stab_members
185 (void *, struct stab_handle
*, const char *, const char **, const int *,
186 debug_method
**, const char *);
187 static debug_type parse_stab_argtypes
188 (void *, struct stab_handle
*, debug_type
, const char *, const char *,
189 debug_type
, const char *, bool, bool, const char **);
190 static bool parse_stab_tilde_field
191 (void *, struct stab_handle
*, const char **, const int *, debug_type
*,
192 bool *, const char *);
193 static debug_type parse_stab_array_type
194 (void *, struct stab_handle
*, const char **, bool, const char *);
195 static void push_bincl (struct stab_handle
*, const char *, bfd_vma
);
196 static const char *pop_bincl (struct stab_handle
*);
197 static bool find_excl (struct stab_handle
*, const char *, bfd_vma
);
198 static bool stab_record_variable
199 (void *, struct stab_handle
*, const char *, debug_type
,
200 enum debug_var_kind
, bfd_vma
);
201 static bool stab_emit_pending_vars (void *, struct stab_handle
*);
202 static debug_type
*stab_find_slot (struct stab_handle
*, const int *);
203 static debug_type
stab_find_type (void *, struct stab_handle
*, const int *);
204 static bool stab_record_type
205 (void *, struct stab_handle
*, const int *, debug_type
);
206 static debug_type stab_xcoff_builtin_type
207 (void *, struct stab_handle
*, unsigned int);
208 static debug_type stab_find_tagged_type
209 (void *, struct stab_handle
*, const char *, int, enum debug_type_kind
);
210 static debug_type
*stab_demangle_argtypes
211 (void *, struct stab_handle
*, const char *, bool *, unsigned int);
212 static debug_type
*stab_demangle_v3_argtypes
213 (void *, struct stab_handle
*, const char *, bool *);
214 static debug_type
*stab_demangle_v3_arglist
215 (void *, struct stab_handle
*, struct demangle_component
*, bool *);
216 static debug_type stab_demangle_v3_arg
217 (void *, struct stab_handle
*, struct demangle_component
*, debug_type
,
220 static int demangle_flags
= DMGL_ANSI
;
222 /* Save a string in memory. */
225 savestring (const char *start
, int len
)
229 ret
= (char *) xmalloc (len
+ 1);
230 memcpy (ret
, start
, len
);
235 /* Read a number from a string. */
238 parse_number (const char **pp
, bool *poverflow
, const char *p_end
)
243 if (poverflow
!= NULL
)
250 /* Stop early if we are passed an empty string. */
255 ul
= strtoul (*pp
, (char **) pp
, 0);
256 if (ul
+ 1 != 0 || errno
== 0)
258 /* If bfd_vma is larger than unsigned long, and the number is
259 meant to be negative, we have to make sure that we sign
262 return (bfd_vma
) (bfd_signed_vma
) (long) ul
;
266 /* Note that even though strtoul overflowed, it should have set *pp
267 to the end of the number, which is where we want it. */
268 if (sizeof (bfd_vma
) > sizeof (unsigned long))
273 bfd_vma over
, lastdig
;
277 /* Our own version of strtoul, for a bfd_vma. */
292 if (p
[1] == 'x' || p
[1] == 'X')
304 over
= ((bfd_vma
) (bfd_signed_vma
) -1) / (bfd_vma
) base
;
305 lastdig
= ((bfd_vma
) (bfd_signed_vma
) -1) % (bfd_vma
) base
;
316 else if (ISUPPER (d
))
318 else if (ISLOWER (d
))
326 if (v
> over
|| (v
== over
&& (bfd_vma
) d
> lastdig
))
341 /* If we get here, the number is too large to represent in a
343 if (poverflow
!= NULL
)
346 warn_stab (orig
, _("numeric overflow"));
351 /* Give an error for a bad stab string. */
354 bad_stab (const char *p
)
356 fprintf (stderr
, _("Bad stab: %s\n"), p
);
359 /* Warn about something in a stab string. */
362 warn_stab (const char *p
, const char *err
)
364 fprintf (stderr
, _("Warning: %s: %s\n"), err
, p
);
367 /* Create a handle to parse stabs symbols with. */
370 start_stab (void *dhandle ATTRIBUTE_UNUSED
, bfd
*abfd
, bool sections
,
371 asymbol
**syms
, long symcount
)
373 struct stab_handle
*ret
;
375 ret
= (struct stab_handle
*) xmalloc (sizeof *ret
);
376 memset (ret
, 0, sizeof *ret
);
378 ret
->sections
= sections
;
380 ret
->symcount
= symcount
;
382 ret
->file_types
= (struct stab_types
**) xmalloc (sizeof *ret
->file_types
);
383 ret
->file_types
[0] = NULL
;
384 ret
->function_end
= (bfd_vma
) -1;
388 /* When we have processed all the stabs information, we need to go
389 through and fill in all the undefined tags. */
392 finish_stab (void *dhandle
, void *handle
)
394 struct stab_handle
*info
= (struct stab_handle
*) handle
;
397 if (info
->within_function
)
399 if (! stab_emit_pending_vars (dhandle
, info
)
400 || ! debug_end_function (dhandle
, info
->function_end
))
402 info
->within_function
= false;
403 info
->function_end
= (bfd_vma
) -1;
406 for (st
= info
->tags
; st
!= NULL
; st
= st
->next
)
408 enum debug_type_kind kind
;
411 if (kind
== DEBUG_KIND_ILLEGAL
)
412 kind
= DEBUG_KIND_STRUCT
;
413 st
->slot
= debug_make_undefined_tagged_type (dhandle
, st
->name
, kind
);
414 if (st
->slot
== DEBUG_TYPE_NULL
)
421 /* Handle a single stabs symbol. */
424 parse_stab (void *dhandle
, void *handle
, int type
, int desc
, bfd_vma value
,
425 const char *string
, bool *string_used
)
427 const char * string_end
;
428 struct stab_handle
*info
= (struct stab_handle
*) handle
;
430 *string_used
= false;
431 /* gcc will emit two N_SO strings per compilation unit, one for the
432 directory name and one for the file name. We just collect N_SO
433 strings as we see them, and start the new compilation unit when
434 we see a non N_SO symbol. */
435 if (info
->so_string
!= NULL
436 && (type
!= N_SO
|| *string
== '\0' || value
!= info
->so_value
))
438 if (! debug_set_filename (dhandle
, info
->so_string
))
440 info
->main_filename
= info
->so_string
;
442 info
->gcc_compiled
= 0;
443 info
->n_opt_found
= false;
445 /* Generally, for stabs in the symbol table, the N_LBRAC and
446 N_RBRAC symbols are relative to the N_SO symbol value. */
447 if (! info
->sections
)
448 info
->file_start_offset
= info
->so_value
;
450 /* We need to reset the mapping from type numbers to types. We
451 can only free the file_types array, not the stab_types
452 list entries due to the use of debug_make_indirect_type. */
454 info
->file_types
= ((struct stab_types
**)
455 xrealloc (info
->file_types
, sizeof *info
->file_types
));
456 info
->file_types
[0] = NULL
;
457 info
->so_string
= NULL
;
459 /* Now process whatever type we just got. */
462 string_end
= string
+ strlen (string
);
471 /* Ignore extra outermost context from SunPRO cc and acc. */
472 if (info
->n_opt_found
&& desc
== 1)
475 if (! info
->within_function
)
477 fprintf (stderr
, _("N_LBRAC not within function\n"));
481 /* Start an inner lexical block. */
482 if (! debug_start_block (dhandle
,
484 + info
->file_start_offset
485 + info
->function_start_offset
)))
488 /* Emit any pending variable definitions. */
489 if (! stab_emit_pending_vars (dhandle
, info
))
496 /* Ignore extra outermost context from SunPRO cc and acc. */
497 if (info
->n_opt_found
&& desc
== 1)
500 /* We shouldn't have any pending variable definitions here, but,
501 if we do, we probably need to emit them before closing the
503 if (! stab_emit_pending_vars (dhandle
, info
))
506 /* End an inner lexical block. */
507 if (! debug_end_block (dhandle
,
509 + info
->file_start_offset
510 + info
->function_start_offset
)))
514 if (info
->block_depth
< 0)
516 fprintf (stderr
, _("Too many N_RBRACs\n"));
522 /* This always ends a function. */
523 if (info
->within_function
)
529 && info
->function_end
!= (bfd_vma
) -1
530 && info
->function_end
< endval
)
531 endval
= info
->function_end
;
532 if (! stab_emit_pending_vars (dhandle
, info
)
533 || ! debug_end_function (dhandle
, endval
))
535 info
->within_function
= false;
536 info
->function_end
= (bfd_vma
) -1;
539 /* An empty string is emitted by gcc at the end of a compilation
544 /* Just accumulate strings until we see a non N_SO symbol. If
545 the string starts with a directory separator or some other
546 form of absolute path specification, we discard the previously
547 accumulated strings. */
548 if (info
->so_string
== NULL
)
549 info
->so_string
= xstrdup (string
);
556 if (IS_ABSOLUTE_PATH (string
))
557 info
->so_string
= xstrdup (string
);
559 info
->so_string
= concat (info
->so_string
, string
,
560 (const char *) NULL
);
564 info
->so_value
= value
;
569 /* Start an include file. */
570 if (! debug_start_source (dhandle
, string
, string_used
))
575 /* Start an include file which may be replaced. */
577 push_bincl (info
, string
, value
);
578 if (! debug_start_source (dhandle
, string
, string_used
))
583 /* End an N_BINCL include. */
584 string
= pop_bincl (info
);
585 if (! debug_start_source (dhandle
, string
, string_used
))
587 free ((char *) string
);
591 free ((char *) string
);
592 *string_used
= false;
596 /* This is a duplicate of a header file named by N_BINCL which
597 was eliminated by the linker. */
598 if (! find_excl (info
, string
, value
))
603 if (! debug_record_line (dhandle
, desc
,
604 value
+ (info
->within_function
605 ? info
->function_start_offset
: 0)))
610 if (! debug_start_common_block (dhandle
, string
))
615 if (! debug_end_common_block (dhandle
, string
))
622 if (info
->within_function
)
624 /* This always marks the end of a function; we don't
625 need to worry about info->function_end. */
627 value
+= info
->function_start_offset
;
628 if (! stab_emit_pending_vars (dhandle
, info
)
629 || ! debug_end_function (dhandle
, value
))
631 info
->within_function
= false;
632 info
->function_end
= (bfd_vma
) -1;
637 /* A const static symbol in the .text section will have an N_FUN
638 entry. We need to use these to mark the end of the function,
639 in case we are looking at gcc output before it was changed to
640 always emit an empty N_FUN. We can't call debug_end_function
641 here, because it might be a local static symbol. */
642 if (info
->within_function
643 && (info
->function_end
== (bfd_vma
) -1
644 || value
< info
->function_end
))
645 info
->function_end
= value
;
648 /* FIXME: gdb checks the string for N_STSYM, N_LCSYM or N_ROSYM
649 symbols, and if it does not start with :S, gdb relocates the
650 value to the start of the section. gcc always seems to use
651 :S, so we don't worry about this. */
657 colon
= strchr (string
, ':');
659 && (colon
[1] == 'f' || colon
[1] == 'F'))
661 if (info
->within_function
)
666 if (info
->function_end
!= (bfd_vma
) -1
667 && info
->function_end
< endval
)
668 endval
= info
->function_end
;
669 if (! stab_emit_pending_vars (dhandle
, info
)
670 || ! debug_end_function (dhandle
, endval
))
672 info
->function_end
= (bfd_vma
) -1;
674 /* For stabs in sections, line numbers and block addresses
675 are offsets from the start of the function. */
677 info
->function_start_offset
= value
;
678 info
->within_function
= true;
681 if (! parse_stab_string (dhandle
, info
, type
, desc
, value
, string
, string_end
))
687 if (string
!= NULL
&& strcmp (string
, "gcc2_compiled.") == 0)
688 info
->gcc_compiled
= 2;
689 else if (string
!= NULL
&& strcmp (string
, "gcc_compiled.") == 0)
690 info
->gcc_compiled
= 1;
692 info
->n_opt_found
= true;
705 /* Parse the stabs string. */
708 parse_stab_string (void *dhandle
, struct stab_handle
*info
, int stabtype
,
709 int desc ATTRIBUTE_UNUSED
, bfd_vma value
,
710 const char *string
, const char * string_end
)
720 p
= strchr (string
, ':');
735 /* FIXME: Sometimes the special C++ names start with '.'. */
737 if (string
[0] == '$')
745 /* Was: name = "vptr"; */
751 /* This was an anonymous type that was never fixed up. */
754 /* SunPRO (3.0 at least) static variable encoding. */
757 warn_stab (string
, _("unknown C++ encoded name"));
764 if (p
== string
|| (string
[0] == ' ' && p
== string
+ 1))
767 name
= savestring (string
, p
- string
);
771 if (ISDIGIT (*p
) || *p
== '(' || *p
== '-')
784 /* c is a special case, not followed by a type-number.
785 SYMBOL:c=iVALUE for an integer constant symbol.
786 SYMBOL:c=rVALUE for a floating constant symbol.
787 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
788 e.g. "b:c=e6,0" for "const b = blob1"
789 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
799 /* Floating point constant. */
800 if (! debug_record_float_const (dhandle
, name
, atof (p
)))
804 /* Integer constant. */
805 /* Defining integer constants this way is kind of silly,
806 since 'e' constants allows the compiler to give not only
807 the value, but the type as well. C has at least int,
808 long, unsigned int, and long long as constant types;
809 other languages probably should have at least unsigned as
810 well as signed constants. */
811 if (! debug_record_int_const (dhandle
, name
, atoi (p
)))
815 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
816 can be represented as integral.
817 e.g. "b:c=e6,0" for "const b = blob1"
818 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
819 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
820 &p
, (debug_type
**) NULL
, string_end
);
821 if (dtype
== DEBUG_TYPE_NULL
)
828 if (! debug_record_typed_const (dhandle
, name
, dtype
, atoi (p
)))
839 /* The name of a caught exception. */
840 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
841 &p
, (debug_type
**) NULL
, string_end
);
842 if (dtype
== DEBUG_TYPE_NULL
)
844 if (! debug_record_label (dhandle
, name
, dtype
, value
))
850 /* A function definition. */
851 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
852 (debug_type
**) NULL
, string_end
);
853 if (dtype
== DEBUG_TYPE_NULL
)
855 if (! debug_record_function (dhandle
, name
, dtype
, type
== 'F', value
))
858 /* Sun acc puts declared types of arguments here. We don't care
859 about their actual types (FIXME -- we should remember the whole
860 function prototype), but the list may define some new types
861 that we have to remember, so we must scan it now. */
865 if (parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
866 (debug_type
**) NULL
, string_end
)
877 /* A global symbol. The value must be extracted from the
879 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
880 (debug_type
**) NULL
, string_end
);
881 if (dtype
== DEBUG_TYPE_NULL
)
888 leading
= bfd_get_symbol_leading_char (info
->abfd
);
889 for (c
= info
->symcount
, ps
= info
->syms
; c
> 0; --c
, ++ps
)
893 n
= bfd_asymbol_name (*ps
);
894 if (leading
!= '\0' && *n
== leading
)
896 if (*n
== *name
&& strcmp (n
, name
) == 0)
901 value
= bfd_asymbol_value (*ps
);
904 if (! stab_record_variable (dhandle
, info
, name
, dtype
, DEBUG_GLOBAL
,
910 /* This case is faked by a conditional above, when there is no
911 code letter in the dbx data. Dbx data never actually
915 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
916 (debug_type
**) NULL
, string_end
);
917 if (dtype
== DEBUG_TYPE_NULL
)
919 if (! stab_record_variable (dhandle
, info
, name
, dtype
, DEBUG_LOCAL
,
925 /* A function parameter. */
927 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
928 (debug_type
**) NULL
, string_end
);
931 /* pF is a two-letter code that means a function parameter in
932 Fortran. The type-number specifies the type of the return
933 value. Translate it into a pointer-to-function type. */
935 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
936 (debug_type
**) NULL
, string_end
);
937 if (dtype
!= DEBUG_TYPE_NULL
)
941 ftype
= debug_make_function_type (dhandle
, dtype
,
942 (debug_type
*) NULL
, false);
943 dtype
= debug_make_pointer_type (dhandle
, ftype
);
946 if (dtype
== DEBUG_TYPE_NULL
)
948 if (! debug_record_parameter (dhandle
, name
, dtype
, DEBUG_PARM_STACK
,
952 /* FIXME: At this point gdb considers rearranging the parameter
953 address on a big endian machine if it is smaller than an int.
954 We have no way to do that, since we don't really know much
959 if (stabtype
== N_FUN
)
961 /* Prototype of a function referenced by this file. */
965 if (parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
966 (debug_type
**) NULL
, string_end
)
974 /* Parameter which is in a register. */
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 (! debug_record_parameter (dhandle
, name
, dtype
, DEBUG_PARM_REG
,
985 /* Register variable (either global or local). */
986 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
987 (debug_type
**) NULL
, string_end
);
988 if (dtype
== DEBUG_TYPE_NULL
)
990 if (! stab_record_variable (dhandle
, info
, name
, dtype
, DEBUG_REGISTER
,
994 /* FIXME: At this point gdb checks to combine pairs of 'p' and
995 'r' stabs into a single 'P' stab. */
999 /* Static symbol at top level of file. */
1000 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
1001 (debug_type
**) NULL
, string_end
);
1002 if (dtype
== DEBUG_TYPE_NULL
)
1004 if (! stab_record_variable (dhandle
, info
, name
, dtype
, DEBUG_STATIC
,
1011 dtype
= parse_stab_type (dhandle
, info
, name
, &p
, &slot
, string_end
);
1012 if (dtype
== DEBUG_TYPE_NULL
)
1016 /* A nameless type. Nothing to do. */
1020 dtype
= debug_name_type (dhandle
, name
, dtype
);
1021 if (dtype
== DEBUG_TYPE_NULL
)
1030 /* Struct, union, or enum tag. For GNU C++, this can be followed
1031 by 't' which means we are typedef'ing it as well. */
1035 /* FIXME: gdb sets synonym to TRUE if the current language
1044 dtype
= parse_stab_type (dhandle
, info
, name
, &p
, &slot
, string_end
);
1045 if (dtype
== DEBUG_TYPE_NULL
)
1050 /* INFO->SELF_CROSSREF is set by parse_stab_type if this type is
1051 a cross reference to itself. These are generated by some
1053 self_crossref
= info
->self_crossref
;
1055 dtype
= debug_tag_type (dhandle
, name
, dtype
);
1056 if (dtype
== DEBUG_TYPE_NULL
)
1061 /* See if we have a cross reference to this tag which we can now
1062 fill in. Avoid filling in a cross reference to ourselves,
1063 because that would lead to circular debugging information. */
1064 if (! self_crossref
)
1066 register struct stab_tag
**pst
;
1068 for (pst
= &info
->tags
; *pst
!= NULL
; pst
= &(*pst
)->next
)
1070 if ((*pst
)->name
[0] == name
[0]
1071 && strcmp ((*pst
)->name
, name
) == 0)
1073 (*pst
)->slot
= dtype
;
1074 *pst
= (*pst
)->next
;
1082 dtype
= debug_name_type (dhandle
, name
, dtype
);
1083 if (dtype
== DEBUG_TYPE_NULL
)
1093 /* Static symbol of local scope */
1094 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
1095 (debug_type
**) NULL
, string_end
);
1096 if (dtype
== DEBUG_TYPE_NULL
)
1098 /* FIXME: gdb checks os9k_stabs here. */
1099 if (! stab_record_variable (dhandle
, info
, name
, dtype
,
1100 DEBUG_LOCAL_STATIC
, value
))
1105 /* Reference parameter. */
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_REFERENCE
,
1116 /* Reference parameter which is in a register. */
1117 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
1118 (debug_type
**) NULL
, string_end
);
1119 if (dtype
== DEBUG_TYPE_NULL
)
1121 if (! debug_record_parameter (dhandle
, name
, dtype
, DEBUG_PARM_REF_REG
,
1127 /* This is used by Sun FORTRAN for "function result value".
1128 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1129 that Pascal uses it too, but when I tried it Pascal used
1130 "x:3" (local symbol) instead. */
1131 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
1132 (debug_type
**) NULL
, string_end
);
1133 if (dtype
== DEBUG_TYPE_NULL
)
1135 if (! stab_record_variable (dhandle
, info
, name
, dtype
, DEBUG_LOCAL
,
1141 /* SUNPro C++ Namespace =Yn0. */
1142 /* Skip the namespace mapping, as it is not used now. */
1143 if (*p
++ != 0 && *p
++ == 'n' && *p
++ == '0')
1146 while (*p
&& *p
!= ';')
1151 /* TODO SUNPro C++ support:
1152 Support default arguments after F,P parameters
1153 Ya = Anonymous unions
1154 YM,YD = Pointers to class members
1156 YR = Run-time type information (RTTI) */
1165 /* FIXME: gdb converts structure values to structure pointers in a
1166 couple of cases, depending upon the target. */
1171 /* Parse a stabs type. The typename argument is non-NULL if this is a
1172 typedef or a tag definition. The pp argument points to the stab
1173 string, and is updated. The slotp argument points to a place to
1174 store the slot used if the type is being defined. */
1177 parse_stab_type (void * dhandle
,
1178 struct stab_handle
* info
,
1179 const char * type_name
,
1181 debug_type
** slotp
,
1196 return DEBUG_TYPE_NULL
;
1201 info
->self_crossref
= false;
1203 /* Read type number if present. The type number may be omitted.
1204 for instance in a two-dimensional array declared with type
1205 "ar1;1;10;ar1;1;10;4". */
1206 if (! ISDIGIT (**pp
) && **pp
!= '(' && **pp
!= '-')
1208 /* 'typenums=' not present, type is anonymous. Read and return
1209 the definition, but don't put it in the type vector. */
1210 typenums
[0] = typenums
[1] = -1;
1214 if (! parse_stab_type_number (pp
, typenums
, p_end
))
1215 return DEBUG_TYPE_NULL
;
1218 /* Type is not being defined here. Either it already
1219 exists, or this is a forward reference to it. */
1220 return stab_find_type (dhandle
, info
, typenums
);
1222 /* Only set the slot if the type is being defined. This means
1223 that the mapping from type numbers to types will only record
1224 the name of the typedef which defines a type. If we don't do
1225 this, then something like
1228 will record that i is of type foo. Unfortunately, stabs
1229 information is ambiguous about variable types. For this code,
1233 the stabs information records both i and j as having the same
1234 type. This could be fixed by patching the compiler. */
1235 if (slotp
!= NULL
&& typenums
[0] >= 0 && typenums
[1] >= 0)
1236 *slotp
= stab_find_slot (info
, typenums
);
1238 /* Type is being defined here. */
1244 const char *p
= *pp
+ 1;
1247 if (ISDIGIT (*p
) || *p
== '(' || *p
== '-')
1251 /* Type attributes. */
1254 for (; *p
!= ';'; ++p
)
1259 return DEBUG_TYPE_NULL
;
1267 size
= atoi (attr
+ 1);
1268 size
/= 8; /* Size is in bits. We store it in bytes. */
1279 return DEBUG_TYPE_NULL
;
1282 /* Ignore unrecognized type attributes, so future
1283 compilers can invent new ones. */
1296 enum debug_type_kind code
;
1297 const char *q1
, *q2
, *p
;
1299 /* A cross reference to another type. */
1303 code
= DEBUG_KIND_STRUCT
;
1306 code
= DEBUG_KIND_UNION
;
1309 code
= DEBUG_KIND_ENUM
;
1313 return DEBUG_TYPE_NULL
;
1316 /* Complain and keep going, so compilers can invent new
1317 cross-reference types. */
1318 warn_stab (orig
, _("unrecognized cross reference type"));
1319 code
= DEBUG_KIND_STRUCT
;
1324 q1
= strchr (*pp
, '<');
1325 p
= strchr (*pp
, ':');
1329 return DEBUG_TYPE_NULL
;
1331 if (q1
!= NULL
&& p
> q1
&& p
[1] == ':')
1335 for (q2
= q1
; *q2
!= '\0'; ++q2
)
1339 else if (*q2
== '>')
1341 else if (*q2
== ':' && nest
== 0)
1348 return DEBUG_TYPE_NULL
;
1352 /* Some versions of g++ can emit stabs like
1354 which define structures in terms of themselves. We need to
1355 tell the caller to avoid building a circular structure. */
1356 if (type_name
!= NULL
1357 && strncmp (type_name
, *pp
, p
- *pp
) == 0
1358 && type_name
[p
- *pp
] == '\0')
1359 info
->self_crossref
= true;
1361 dtype
= stab_find_tagged_type (dhandle
, info
, *pp
, p
- *pp
, code
);
1383 /* This type is defined as another type. */
1387 /* Peek ahead at the number to detect void. */
1388 if (! parse_stab_type_number (pp
, xtypenums
, p_end
))
1389 return DEBUG_TYPE_NULL
;
1391 if (typenums
[0] == xtypenums
[0] && typenums
[1] == xtypenums
[1])
1393 /* This type is being defined as itself, which means that
1395 dtype
= debug_make_void_type (dhandle
);
1401 /* Go back to the number and have parse_stab_type get it.
1402 This means that we can deal with something like
1403 t(1,2)=(3,4)=... which the Lucid compiler uses. */
1404 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
1405 pp
, (debug_type
**) NULL
, p_end
);
1406 if (dtype
== DEBUG_TYPE_NULL
)
1407 return DEBUG_TYPE_NULL
;
1410 if (typenums
[0] != -1)
1412 if (! stab_record_type (dhandle
, info
, typenums
, dtype
))
1413 return DEBUG_TYPE_NULL
;
1420 dtype
= debug_make_pointer_type (dhandle
,
1421 parse_stab_type (dhandle
, info
,
1422 (const char *) NULL
,
1424 (debug_type
**) NULL
,
1429 /* Reference to another type. */
1430 dtype
= (debug_make_reference_type
1432 parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
1433 (debug_type
**) NULL
, p_end
)));
1437 /* Function returning another type. */
1438 /* FIXME: gdb checks os9k_stabs here. */
1439 dtype
= (debug_make_function_type
1441 parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
1442 (debug_type
**) NULL
, p_end
),
1443 (debug_type
*) NULL
, false));
1447 /* Const qualifier on some type (Sun). */
1448 /* FIXME: gdb accepts 'c' here if os9k_stabs. */
1449 dtype
= debug_make_const_type (dhandle
,
1450 parse_stab_type (dhandle
, info
,
1451 (const char *) NULL
,
1453 (debug_type
**) NULL
,
1458 /* Volatile qual on some type (Sun). */
1459 /* FIXME: gdb accepts 'i' here if os9k_stabs. */
1460 dtype
= (debug_make_volatile_type
1462 parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
1463 (debug_type
**) NULL
, p_end
)));
1467 /* Offset (class & variable) type. This is used for a pointer
1468 relative to an object. */
1475 domain
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
1476 (debug_type
**) NULL
, p_end
);
1477 if (domain
== DEBUG_TYPE_NULL
)
1478 return DEBUG_TYPE_NULL
;
1483 return DEBUG_TYPE_NULL
;
1487 memtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
1488 (debug_type
**) NULL
, p_end
);
1489 if (memtype
== DEBUG_TYPE_NULL
)
1490 return DEBUG_TYPE_NULL
;
1492 dtype
= debug_make_offset_type (dhandle
, domain
, memtype
);
1497 /* Method (class & fn) type. */
1500 debug_type return_type
;
1503 return_type
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
1504 pp
, (debug_type
**) NULL
, p_end
);
1505 if (return_type
== DEBUG_TYPE_NULL
)
1506 return DEBUG_TYPE_NULL
;
1510 return DEBUG_TYPE_NULL
;
1513 dtype
= debug_make_method_type (dhandle
, return_type
,
1515 (debug_type
*) NULL
, false);
1520 debug_type return_type
;
1526 domain
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
1527 pp
, (debug_type
**) NULL
, p_end
);
1528 if (domain
== DEBUG_TYPE_NULL
)
1529 return DEBUG_TYPE_NULL
;
1534 return DEBUG_TYPE_NULL
;
1538 return_type
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
1539 pp
, (debug_type
**) NULL
, p_end
);
1540 if (return_type
== DEBUG_TYPE_NULL
)
1541 return DEBUG_TYPE_NULL
;
1544 args
= (debug_type
*) xmalloc (alloc
* sizeof *args
);
1551 return DEBUG_TYPE_NULL
;
1558 args
= ((debug_type
*)
1559 xrealloc (args
, alloc
* sizeof *args
));
1562 args
[n
] = parse_stab_type (dhandle
, info
, (const char *) NULL
,
1563 pp
, (debug_type
**) NULL
, p_end
);
1564 if (args
[n
] == DEBUG_TYPE_NULL
)
1565 return DEBUG_TYPE_NULL
;
1570 /* If the last type is not void, then this function takes a
1571 variable number of arguments. Otherwise, we must strip
1574 || debug_get_type_kind (dhandle
, args
[n
- 1]) != DEBUG_KIND_VOID
)
1582 args
[n
] = DEBUG_TYPE_NULL
;
1584 dtype
= debug_make_method_type (dhandle
, return_type
, domain
, args
,
1591 dtype
= parse_stab_range_type (dhandle
, info
, type_name
, pp
, typenums
, p_end
);
1595 /* FIXME: gdb checks os9k_stabs here. */
1596 /* Sun ACC builtin int type. */
1597 dtype
= parse_stab_sun_builtin_type (dhandle
, pp
, p_end
);
1601 /* Sun ACC builtin float type. */
1602 dtype
= parse_stab_sun_floating_type (dhandle
, pp
, p_end
);
1606 /* Enumeration type. */
1607 dtype
= parse_stab_enum_type (dhandle
, pp
, p_end
);
1612 /* Struct or union type. */
1613 dtype
= parse_stab_struct_type (dhandle
, info
, type_name
, pp
,
1614 descriptor
== 's', typenums
, p_end
);
1622 return DEBUG_TYPE_NULL
;
1626 dtype
= parse_stab_array_type (dhandle
, info
, pp
, stringp
, p_end
);
1630 dtype
= debug_make_set_type (dhandle
,
1631 parse_stab_type (dhandle
, info
,
1632 (const char *) NULL
,
1634 (debug_type
**) NULL
,
1641 return DEBUG_TYPE_NULL
;
1644 if (dtype
== DEBUG_TYPE_NULL
)
1645 return DEBUG_TYPE_NULL
;
1647 if (typenums
[0] != -1)
1649 if (! stab_record_type (dhandle
, info
, typenums
, dtype
))
1650 return DEBUG_TYPE_NULL
;
1655 if (! debug_record_type_size (dhandle
, dtype
, (unsigned int) size
))
1656 return DEBUG_TYPE_NULL
;
1662 /* Read a number by which a type is referred to in dbx data, or
1663 perhaps read a pair (FILENUM, TYPENUM) in parentheses. Just a
1664 single number N is equivalent to (0,N). Return the two numbers by
1665 storing them in the vector TYPENUMS. */
1668 parse_stab_type_number (const char **pp
, int *typenums
, const char *p_end
)
1677 typenums
[1] = (int) parse_number (pp
, (bool *) NULL
, p_end
);
1682 typenums
[0] = (int) parse_number (pp
, (bool *) NULL
, p_end
);
1690 typenums
[1] = (int) parse_number (pp
, (bool *) NULL
, p_end
);
1701 /* Parse a range type. */
1704 parse_stab_range_type (void * dhandle
,
1705 struct stab_handle
* info
,
1706 const char * type_name
,
1708 const int * typenums
,
1714 debug_type index_type
;
1715 const char *s2
, *s3
;
1716 bfd_signed_vma n2
, n3
;
1721 return DEBUG_TYPE_NULL
;
1723 index_type
= DEBUG_TYPE_NULL
;
1725 /* First comes a type we are a subrange of.
1726 In C it is usually 0, 1 or the type being defined. */
1727 if (! parse_stab_type_number (pp
, rangenums
, p_end
))
1728 return DEBUG_TYPE_NULL
;
1730 self_subrange
= (rangenums
[0] == typenums
[0]
1731 && rangenums
[1] == typenums
[1]);
1736 index_type
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
1737 pp
, (debug_type
**) NULL
, p_end
);
1738 if (index_type
== DEBUG_TYPE_NULL
)
1739 return DEBUG_TYPE_NULL
;
1745 /* The remaining two operands are usually lower and upper bounds of
1746 the range. But in some special cases they mean something else. */
1748 n2
= parse_number (pp
, &ov2
, p_end
);
1752 return DEBUG_TYPE_NULL
;
1757 n3
= parse_number (pp
, &ov3
, p_end
);
1761 return DEBUG_TYPE_NULL
;
1767 /* gcc will emit range stabs for long long types. Handle this
1768 as a special case. FIXME: This needs to be more general. */
1769 #define LLLOW "01000000000000000000000;"
1770 #define LLHIGH "0777777777777777777777;"
1771 #define ULLHIGH "01777777777777777777777;"
1772 if (index_type
== DEBUG_TYPE_NULL
)
1774 if (startswith (s2
, LLLOW
)
1775 && startswith (s3
, LLHIGH
))
1776 return debug_make_int_type (dhandle
, 8, false);
1779 && startswith (s3
, ULLHIGH
))
1780 return debug_make_int_type (dhandle
, 8, true);
1783 warn_stab (orig
, _("numeric overflow"));
1786 if (index_type
== DEBUG_TYPE_NULL
)
1788 /* A type defined as a subrange of itself, with both bounds 0,
1790 if (self_subrange
&& n2
== 0 && n3
== 0)
1791 return debug_make_void_type (dhandle
);
1793 /* A type defined as a subrange of itself, with n2 positive and
1794 n3 zero, is a complex type, and n2 is the number of bytes. */
1795 if (self_subrange
&& n3
== 0 && n2
> 0)
1796 return debug_make_complex_type (dhandle
, n2
);
1798 /* If n3 is zero and n2 is positive, this is a floating point
1799 type, and n2 is the number of bytes. */
1800 if (n3
== 0 && n2
> 0)
1801 return debug_make_float_type (dhandle
, n2
);
1803 /* If the upper bound is -1, this is an unsigned int. */
1804 if (n2
== 0 && n3
== -1)
1806 /* When gcc is used with -gstabs, but not -gstabs+, it will emit
1807 long long int:t6=r1;0;-1;
1808 long long unsigned int:t7=r1;0;-1;
1809 We hack here to handle this reasonably. */
1810 if (type_name
!= NULL
)
1812 if (strcmp (type_name
, "long long int") == 0)
1813 return debug_make_int_type (dhandle
, 8, false);
1814 else if (strcmp (type_name
, "long long unsigned int") == 0)
1815 return debug_make_int_type (dhandle
, 8, true);
1817 /* FIXME: The size here really depends upon the target. */
1818 return debug_make_int_type (dhandle
, 4, true);
1821 /* A range of 0 to 127 is char. */
1822 if (self_subrange
&& n2
== 0 && n3
== 127)
1823 return debug_make_int_type (dhandle
, 1, false);
1825 /* FIXME: gdb checks for the language CHILL here. */
1830 return debug_make_int_type (dhandle
, - n3
, true);
1831 else if (n3
== 0xff)
1832 return debug_make_int_type (dhandle
, 1, true);
1833 else if (n3
== 0xffff)
1834 return debug_make_int_type (dhandle
, 2, true);
1835 else if (n3
== (bfd_signed_vma
) 0xffffffff)
1836 return debug_make_int_type (dhandle
, 4, true);
1838 else if (n3
== (bfd_signed_vma
) 0xffffffffffffffffLL
)
1839 return debug_make_int_type (dhandle
, 8, true);
1844 && (self_subrange
|| n2
== -8))
1845 return debug_make_int_type (dhandle
, - n2
, true);
1846 else if (n2
== - n3
- 1 || n2
== n3
+ 1)
1849 return debug_make_int_type (dhandle
, 1, false);
1850 else if (n3
== 0x7fff)
1851 return debug_make_int_type (dhandle
, 2, false);
1852 else if (n3
== 0x7fffffff)
1853 return debug_make_int_type (dhandle
, 4, false);
1855 else if (n3
== ((((bfd_vma
) 0x7fffffff) << 32) | 0xffffffff))
1856 return debug_make_int_type (dhandle
, 8, false);
1861 /* At this point I don't have the faintest idea how to deal with a
1862 self_subrange type; I'm going to assume that this is used as an
1863 idiom, and that all of them are special cases. So . . . */
1867 return DEBUG_TYPE_NULL
;
1870 index_type
= stab_find_type (dhandle
, info
, rangenums
);
1871 if (index_type
== DEBUG_TYPE_NULL
)
1873 /* Does this actually ever happen? Is that why we are worrying
1874 about dealing with it rather than just calling error_type? */
1875 warn_stab (orig
, _("missing index type"));
1876 index_type
= debug_make_int_type (dhandle
, 4, false);
1879 return debug_make_range_type (dhandle
, index_type
, n2
, n3
);
1882 /* Sun's ACC uses a somewhat saner method for specifying the builtin
1883 typedefs in every file (for int, long, etc):
1885 type = b <signed> <width>; <offset>; <nbits>
1886 signed = u or s. Possible c in addition to u or s (for char?).
1887 offset = offset from high order bit to start bit of type.
1888 width is # bytes in object of this type, nbits is # bits in type.
1890 The width/offset stuff appears to be for small objects stored in
1891 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
1895 parse_stab_sun_builtin_type (void *dhandle
, const char **pp
, const char * p_end
)
1903 return DEBUG_TYPE_NULL
;
1915 return DEBUG_TYPE_NULL
;
1919 /* OpenSolaris source code indicates that one of "cbv" characters
1920 can come next and specify the intrinsic 'iformat' encoding.
1921 'c' is character encoding, 'b' is boolean encoding, and 'v' is
1922 varargs encoding. This field can be safely ignored because
1923 the type of the field is determined from the bitwidth extracted
1925 if (**pp
== 'c' || **pp
== 'b' || **pp
== 'v')
1928 /* The first number appears to be the number of bytes occupied
1929 by this type, except that unsigned short is 4 instead of 2.
1930 Since this information is redundant with the third number,
1931 we will ignore it. */
1932 (void) parse_number (pp
, (bool *) NULL
, p_end
);
1936 return DEBUG_TYPE_NULL
;
1940 /* The second number is always 0, so ignore it too. */
1941 (void) parse_number (pp
, (bool *) NULL
, p_end
);
1945 return DEBUG_TYPE_NULL
;
1949 /* The third number is the number of bits for this type. */
1950 bits
= parse_number (pp
, (bool *) NULL
, p_end
);
1952 /* The type *should* end with a semicolon. If it are embedded
1953 in a larger type the semicolon may be the only way to know where
1954 the type ends. If this type is at the end of the stabstring we
1955 can deal with the omitted semicolon (but we don't have to like
1956 it). Don't bother to complain(), Sun's compiler omits the semicolon
1962 return debug_make_void_type (dhandle
);
1964 return debug_make_int_type (dhandle
, bits
/ 8, unsignedp
);
1967 /* Parse a builtin floating type generated by the Sun compiler. */
1970 parse_stab_sun_floating_type (void *dhandle
, const char **pp
, const char *p_end
)
1978 return DEBUG_TYPE_NULL
;
1980 /* The first number has more details about the type, for example
1982 details
= parse_number (pp
, (bool *) NULL
, p_end
);
1986 return DEBUG_TYPE_NULL
;
1989 /* The second number is the number of bytes occupied by this type */
1990 bytes
= parse_number (pp
, (bool *) NULL
, p_end
);
1994 return DEBUG_TYPE_NULL
;
1997 if (details
== NF_COMPLEX
1998 || details
== NF_COMPLEX16
1999 || details
== NF_COMPLEX32
)
2000 return debug_make_complex_type (dhandle
, bytes
);
2002 return debug_make_float_type (dhandle
, bytes
);
2005 /* Handle an enum type. */
2008 parse_stab_enum_type (void *dhandle
, const char **pp
, const char * p_end
)
2012 bfd_signed_vma
*values
;
2018 return DEBUG_TYPE_NULL
;
2020 /* FIXME: gdb checks os9k_stabs here. */
2022 /* The aix4 compiler emits an extra field before the enum members;
2023 my guess is it's a type of some sort. Just ignore it. */
2026 while (**pp
!= ':' && **pp
!= 0)
2032 return DEBUG_TYPE_NULL
;
2037 /* Read the value-names and their values.
2038 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
2039 A semicolon or comma instead of a NAME means the end. */
2041 names
= (const char **) xmalloc (alloc
* sizeof *names
);
2042 values
= (bfd_signed_vma
*) xmalloc (alloc
* sizeof *values
);
2044 while (**pp
!= '\0' && **pp
!= ';' && **pp
!= ',')
2051 while (*p
!= ':' && *p
!= 0)
2059 return DEBUG_TYPE_NULL
;
2062 name
= savestring (*pp
, p
- *pp
);
2065 val
= (bfd_signed_vma
) parse_number (pp
, (bool *) NULL
, p_end
);
2072 return DEBUG_TYPE_NULL
;
2079 names
= ((const char **)
2080 xrealloc (names
, alloc
* sizeof *names
));
2081 values
= ((bfd_signed_vma
*)
2082 xrealloc (values
, alloc
* sizeof *values
));
2096 return debug_make_enum_type (dhandle
, names
, values
);
2099 /* Read the description of a structure (or union type) and return an object
2100 describing the type.
2102 PP points to a character pointer that points to the next unconsumed token
2103 in the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
2104 *PP will point to "4a:1,0,32;;". */
2107 parse_stab_struct_type (void *dhandle
,
2108 struct stab_handle
*info
,
2109 const char *tagname
,
2112 const int *typenums
,
2116 debug_baseclass
*baseclasses
;
2117 debug_field
*fields
= NULL
;
2119 debug_method
*methods
;
2120 debug_type vptrbase
;
2124 size
= parse_number (pp
, (bool *) NULL
, p_end
);
2126 /* Get the other information. */
2127 if (! parse_stab_baseclasses (dhandle
, info
, pp
, &baseclasses
, p_end
)
2128 || ! parse_stab_struct_fields (dhandle
, info
, pp
, &fields
, &statics
, p_end
)
2129 || ! parse_stab_members (dhandle
, info
, tagname
, pp
, typenums
, &methods
, p_end
)
2130 || ! parse_stab_tilde_field (dhandle
, info
, pp
, typenums
, &vptrbase
,
2134 return DEBUG_TYPE_NULL
;
2138 && baseclasses
== NULL
2140 && vptrbase
== DEBUG_TYPE_NULL
2142 return debug_make_struct_type (dhandle
, structp
, size
, fields
);
2144 return debug_make_object_type (dhandle
, structp
, size
, fields
, baseclasses
,
2145 methods
, vptrbase
, ownvptr
);
2148 /* The stabs for C++ derived classes contain baseclass information which
2149 is marked by a '!' character after the total size. This function is
2150 called when we encounter the baseclass marker, and slurps up all the
2151 baseclass information.
2153 Immediately following the '!' marker is the number of base classes that
2154 the class is derived from, followed by information for each base class.
2155 For each base class, there are two visibility specifiers, a bit offset
2156 to the base class information within the derived class, a reference to
2157 the type for the base class, and a terminating semicolon.
2159 A typical example, with two base classes, would be "!2,020,19;0264,21;".
2161 Baseclass information marker __________________|| | | | | | |
2162 Number of baseclasses __________________________| | | | | | |
2163 Visibility specifiers (2) ________________________| | | | | |
2164 Offset in bits from start of class _________________| | | | |
2165 Type number for base class ___________________________| | | |
2166 Visibility specifiers (2) _______________________________| | |
2167 Offset in bits from start of class ________________________| |
2168 Type number of base class ____________________________________|
2170 Return TRUE for success, FALSE for failure. */
2173 parse_stab_baseclasses (void * dhandle
,
2174 struct stab_handle
* info
,
2176 debug_baseclass
** retp
,
2181 debug_baseclass
*classes
;
2191 /* No base classes. */
2196 c
= (unsigned int) parse_number (pp
, (bool *) NULL
, p_end
);
2205 classes
= (debug_baseclass
*) xmalloc ((c
+ 1) * sizeof (**retp
));
2207 for (i
= 0; i
< c
; i
++)
2210 enum debug_visibility visibility
;
2226 warn_stab (orig
, _("unknown virtual character for baseclass"));
2235 visibility
= DEBUG_VISIBILITY_PRIVATE
;
2238 visibility
= DEBUG_VISIBILITY_PROTECTED
;
2241 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2247 warn_stab (orig
, _("unknown visibility character for baseclass"));
2248 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2253 /* The remaining value is the bit offset of the portion of the
2254 object corresponding to this baseclass. Always zero in the
2255 absence of multiple inheritance. */
2256 bitpos
= parse_number (pp
, (bool *) NULL
, p_end
);
2264 type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2265 (debug_type
**) NULL
, p_end
);
2266 if (type
== DEBUG_TYPE_NULL
)
2269 classes
[i
] = debug_make_baseclass (dhandle
, type
, bitpos
, is_virtual
,
2271 if (classes
[i
] == DEBUG_BASECLASS_NULL
)
2279 classes
[i
] = DEBUG_BASECLASS_NULL
;
2286 /* Read struct or class data fields. They have the form:
2288 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2290 At the end, we see a semicolon instead of a field.
2292 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2295 The optional VISIBILITY is one of:
2297 '/0' (VISIBILITY_PRIVATE)
2298 '/1' (VISIBILITY_PROTECTED)
2299 '/2' (VISIBILITY_PUBLIC)
2300 '/9' (VISIBILITY_IGNORE)
2302 or nothing, for C style fields with public visibility.
2304 Returns 1 for success, 0 for failure. */
2307 parse_stab_struct_fields (void *dhandle
,
2308 struct stab_handle
*info
,
2316 debug_field
*fields
;
2329 fields
= (debug_field
*) xmalloc (alloc
* sizeof *fields
);
2332 /* FIXME: gdb checks os9k_stabs here. */
2336 /* Add 1 to c to leave room for NULL pointer at end. */
2340 fields
= ((debug_field
*)
2341 xrealloc (fields
, alloc
* sizeof *fields
));
2344 /* If it starts with CPLUS_MARKER it is a special abbreviation,
2345 unless the CPLUS_MARKER is followed by an underscore, in
2346 which case it is just the name of an anonymous type, which we
2347 should handle like any other type name. We accept either '$'
2348 or '.', because a field name can never contain one of these
2349 characters except as a CPLUS_MARKER. */
2351 if ((*p
== '$' || *p
== '.') && p
[1] != '_')
2354 if (! parse_stab_cpp_abbrev (dhandle
, info
, pp
, fields
+ c
, p_end
))
2363 /* Look for the ':' that separates the field name from the field
2364 values. Data members are delimited by a single ':', while member
2365 functions are delimited by a pair of ':'s. When we hit the member
2366 functions (if any), terminate scan loop and return. */
2368 p
= strchr (p
, ':');
2379 if (! parse_stab_one_struct_field (dhandle
, info
, pp
, p
, fields
+ c
,
2389 fields
[c
] = DEBUG_FIELD_NULL
;
2396 /* Special GNU C++ name. */
2399 parse_stab_cpp_abbrev (void * dhandle
,
2400 struct stab_handle
* info
,
2409 const char *type_name
;
2413 *retp
= DEBUG_FIELD_NULL
;
2427 if (cpp_abbrev
== 0)
2434 /* At this point, *pp points to something like "22:23=*22...", where
2435 the type number before the ':' is the "context" and everything
2436 after is a regular type definition. Lookup the type, find it's
2437 name, and construct the field name. */
2439 context
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2440 (debug_type
**) NULL
, p_end
);
2441 if (context
== DEBUG_TYPE_NULL
)
2447 /* $vf -- a virtual function table pointer. */
2451 /* $vb -- a virtual bsomethingorother */
2452 type_name
= debug_get_type_name (dhandle
, context
);
2453 if (type_name
== NULL
)
2455 warn_stab (orig
, _("unnamed $vb type"));
2458 name
= concat ("_vb$", type_name
, (const char *) NULL
);
2461 warn_stab (orig
, _("unrecognized C++ abbreviation"));
2462 name
= "INVALID_CPLUSPLUS_ABBREV";
2473 type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2474 (debug_type
**) NULL
, p_end
);
2482 bitpos
= parse_number (pp
, (bool *) NULL
, p_end
);
2490 *retp
= debug_make_field (dhandle
, name
, type
, bitpos
, 0,
2491 DEBUG_VISIBILITY_PRIVATE
);
2492 if (*retp
== DEBUG_FIELD_NULL
)
2498 /* Parse a single field in a struct or union. */
2501 parse_stab_one_struct_field (void *dhandle
,
2502 struct stab_handle
*info
,
2511 enum debug_visibility visibility
;
2520 /* FIXME: gdb checks ARM_DEMANGLING here. */
2522 name
= savestring (*pp
, p
- *pp
);
2527 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2534 visibility
= DEBUG_VISIBILITY_PRIVATE
;
2537 visibility
= DEBUG_VISIBILITY_PROTECTED
;
2540 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2546 warn_stab (orig
, _("unknown visibility character for field"));
2547 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2553 type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2554 (debug_type
**) NULL
, p_end
);
2555 if (type
== DEBUG_TYPE_NULL
)
2565 /* This is a static class member. */
2567 p
= strchr (*pp
, ';');
2575 varname
= savestring (*pp
, p
- *pp
);
2579 *retp
= debug_make_static_member (dhandle
, name
, type
, varname
,
2594 bitpos
= parse_number (pp
, (bool *) NULL
, p_end
);
2603 bitsize
= parse_number (pp
, (bool *) NULL
, p_end
);
2612 if (bitpos
== 0 && bitsize
== 0)
2614 /* This can happen in two cases: (1) at least for gcc 2.4.5 or
2615 so, it is a field which has been optimized out. The correct
2616 stab for this case is to use VISIBILITY_IGNORE, but that is a
2617 recent invention. (2) It is a 0-size array. For example
2618 union { int num; char str[0]; } foo. Printing "<no value>"
2619 for str in "p foo" is OK, since foo.str (and thus foo.str[3])
2620 will continue to work, and a 0-size array as a whole doesn't
2621 have any contents to print.
2623 I suspect this probably could also happen with gcc -gstabs
2624 (not -gstabs+) for static fields, and perhaps other C++
2625 extensions. Hopefully few people use -gstabs with gdb, since
2626 it is intended for dbx compatibility. */
2627 visibility
= DEBUG_VISIBILITY_IGNORE
;
2630 /* FIXME: gdb does some stuff here to mark fields as unpacked. */
2632 *retp
= debug_make_field (dhandle
, name
, type
, bitpos
, bitsize
, visibility
);
2637 /* Read member function stabs info for C++ classes. The form of each member
2640 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2642 An example with two member functions is:
2644 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2646 For the case of overloaded operators, the format is op$::*.funcs, where
2647 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2648 name (such as `+=') and `.' marks the end of the operator name. */
2651 parse_stab_members (void * dhandle
,
2652 struct stab_handle
* info
,
2653 const char * tagname
,
2655 const int * typenums
,
2656 debug_method
** retp
,
2660 debug_method
*methods
;
2664 debug_method_variant
*variants
= NULL
;
2665 char *argtypes
= NULL
;
2681 unsigned int allocvars
;
2682 debug_type look_ahead_type
;
2684 p
= strchr (*pp
, ':');
2685 if (p
== NULL
|| p
[1] != ':')
2688 /* FIXME: Some systems use something other than '$' here. */
2689 if ((*pp
)[0] != 'o' || (*pp
)[1] != 'p' || (*pp
)[2] != '$')
2691 name
= savestring (*pp
, p
- *pp
);
2696 /* This is a completely weird case. In order to stuff in the
2697 names that might contain colons (the usual name delimiter),
2698 Mike Tiemann defined a different name format which is
2699 signalled if the identifier is "op$". In that case, the
2700 format is "op$::XXXX." where XXXX is the name. This is
2701 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2703 for (p
= *pp
; *p
!= '.' && *p
!= '\0'; p
++)
2710 name
= savestring (*pp
, p
- *pp
);
2715 variants
= ((debug_method_variant
*)
2716 xmalloc (allocvars
* sizeof *variants
));
2719 look_ahead_type
= DEBUG_TYPE_NULL
;
2725 enum debug_visibility visibility
;
2726 bool constp
, volatilep
, staticp
;
2729 const char *physname
;
2732 if (look_ahead_type
!= DEBUG_TYPE_NULL
)
2734 /* g++ version 1 kludge */
2735 type
= look_ahead_type
;
2736 look_ahead_type
= DEBUG_TYPE_NULL
;
2740 type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2741 (debug_type
**) NULL
, p_end
);
2742 if (type
== DEBUG_TYPE_NULL
)
2753 p
= strchr (*pp
, ';');
2761 if (debug_get_type_kind (dhandle
, type
) == DEBUG_KIND_METHOD
2762 && debug_get_parameter_types (dhandle
, type
, &varargs
) == NULL
)
2765 argtypes
= savestring (*pp
, p
- *pp
);
2771 visibility
= DEBUG_VISIBILITY_PRIVATE
;
2774 visibility
= DEBUG_VISIBILITY_PROTECTED
;
2780 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2790 /* Normal function. */
2794 /* const member function. */
2799 /* volatile member function. */
2804 /* const volatile member function. */
2812 /* File compiled with g++ version 1; no information. */
2815 warn_stab (orig
, _("const/volatile indicator missing"));
2823 /* virtual member function, followed by index. The sign
2824 bit is supposedly set to distinguish
2825 pointers-to-methods from virtual function indices. */
2827 voffset
= parse_number (pp
, (bool *) NULL
, p_end
);
2834 voffset
&= 0x7fffffff;
2836 if (**pp
== ';' || **pp
== '\0')
2838 /* Must be g++ version 1. */
2839 context
= DEBUG_TYPE_NULL
;
2843 /* Figure out from whence this virtual function
2844 came. It may belong to virtual function table of
2845 one of its baseclasses. */
2846 look_ahead_type
= parse_stab_type (dhandle
, info
,
2847 (const char *) NULL
,
2849 (debug_type
**) NULL
,
2853 /* g++ version 1 overloaded methods. */
2854 context
= DEBUG_TYPE_NULL
;
2858 context
= look_ahead_type
;
2859 look_ahead_type
= DEBUG_TYPE_NULL
;
2871 /* static member function. */
2875 context
= DEBUG_TYPE_NULL
;
2876 if (strncmp (argtypes
, name
, strlen (name
)) != 0)
2881 warn_stab (orig
, "member function type missing");
2883 context
= DEBUG_TYPE_NULL
;
2889 context
= DEBUG_TYPE_NULL
;
2893 /* If the type is not a stub, then the argtypes string is
2894 the physical name of the function. Otherwise the
2895 argtypes string is the mangled form of the argument
2896 types, and the full type and the physical name must be
2897 extracted from them. */
2898 physname
= argtypes
;
2901 debug_type class_type
, return_type
;
2903 class_type
= stab_find_type (dhandle
, info
, typenums
);
2904 if (class_type
== DEBUG_TYPE_NULL
)
2906 return_type
= debug_get_return_type (dhandle
, type
);
2907 if (return_type
== DEBUG_TYPE_NULL
)
2912 type
= parse_stab_argtypes (dhandle
, info
, class_type
, name
,
2913 tagname
, return_type
, argtypes
,
2914 constp
, volatilep
, &physname
);
2915 if (type
== DEBUG_TYPE_NULL
)
2919 if (cvars
+ 1 >= allocvars
)
2922 variants
= ((debug_method_variant
*)
2924 allocvars
* sizeof *variants
));
2928 variants
[cvars
] = debug_make_method_variant (dhandle
, physname
,
2933 variants
[cvars
] = debug_make_static_method_variant (dhandle
,
2939 if (variants
[cvars
] == DEBUG_METHOD_VARIANT_NULL
)
2944 while (**pp
!= ';' && **pp
!= '\0');
2946 variants
[cvars
] = DEBUG_METHOD_VARIANT_NULL
;
2954 methods
= ((debug_method
*)
2955 xrealloc (methods
, alloc
* sizeof *methods
));
2958 methods
[c
] = debug_make_method (dhandle
, name
, variants
);
2963 if (methods
!= NULL
)
2964 methods
[c
] = DEBUG_METHOD_NULL
;
2977 /* Parse a string representing argument types for a method. Stabs
2978 tries to save space by packing argument types into a mangled
2979 string. This string should give us enough information to extract
2980 both argument types and the physical name of the function, given
2984 parse_stab_argtypes (void *dhandle
, struct stab_handle
*info
,
2985 debug_type class_type
, const char *fieldname
,
2986 const char *tagname
, debug_type return_type
,
2987 const char *argtypes
, bool constp
,
2988 bool volatilep
, const char **pphysname
)
2990 bool is_full_physname_constructor
;
2991 bool is_constructor
;
2996 unsigned int physname_len
= 0;
2998 /* Constructors are sometimes handled specially. */
2999 is_full_physname_constructor
= ((argtypes
[0] == '_'
3000 && argtypes
[1] == '_'
3001 && (ISDIGIT (argtypes
[2])
3002 || argtypes
[2] == 'Q'
3003 || argtypes
[2] == 't'))
3004 || startswith (argtypes
, "__ct"));
3006 is_constructor
= (is_full_physname_constructor
3008 && strcmp (fieldname
, tagname
) == 0));
3009 is_destructor
= ((argtypes
[0] == '_'
3010 && (argtypes
[1] == '$' || argtypes
[1] == '.')
3011 && argtypes
[2] == '_')
3012 || startswith (argtypes
, "__dt"));
3013 is_v3
= argtypes
[0] == '_' && argtypes
[1] == 'Z';
3015 if (!(is_destructor
|| is_full_physname_constructor
|| is_v3
))
3018 const char *const_prefix
;
3019 const char *volatile_prefix
;
3021 unsigned int mangled_name_len
;
3024 len
= tagname
== NULL
? 0 : strlen (tagname
);
3025 const_prefix
= constp
? "C" : "";
3026 volatile_prefix
= volatilep
? "V" : "";
3029 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
3030 else if (tagname
!= NULL
&& strchr (tagname
, '<') != NULL
)
3032 /* Template methods are fully mangled. */
3033 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
3038 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
3040 mangled_name_len
= ((is_constructor
? 0 : strlen (fieldname
))
3046 if (fieldname
[0] == 'o'
3047 && fieldname
[1] == 'p'
3048 && (fieldname
[2] == '$' || fieldname
[2] == '.'))
3050 /* Opname selection is no longer supported by libiberty's demangler. */
3051 return DEBUG_TYPE_NULL
;
3054 physname
= (char *) xmalloc (mangled_name_len
);
3058 strcpy (physname
, fieldname
);
3060 physname_len
= strlen (physname
);
3061 strcat (physname
, buf
);
3062 if (tagname
!= NULL
)
3063 strcat (physname
, tagname
);
3064 strcat (physname
, argtypes
);
3066 *pphysname
= physname
;
3069 if (*argtypes
== '\0' || is_destructor
)
3071 args
= (debug_type
*) xmalloc (sizeof *args
);
3073 return debug_make_method_type (dhandle
, return_type
, class_type
, args
,
3077 args
= stab_demangle_argtypes (dhandle
, info
, *pphysname
, &varargs
, physname_len
);
3079 return DEBUG_TYPE_NULL
;
3081 return debug_make_method_type (dhandle
, return_type
, class_type
, args
,
3085 /* The tail end of stabs for C++ classes that contain a virtual function
3086 pointer contains a tilde, a %, and a type number.
3087 The type number refers to the base class (possibly this class itself) which
3088 contains the vtable pointer for the current class.
3090 This function is called when we have parsed all the method declarations,
3091 so we can look for the vptr base class info. */
3094 parse_stab_tilde_field (void *dhandle
,
3095 struct stab_handle
*info
,
3097 const int *typenums
,
3098 debug_type
*retvptrbase
,
3106 *retvptrbase
= DEBUG_TYPE_NULL
;
3107 *retownvptr
= false;
3113 /* If we are positioned at a ';', then skip it. */
3121 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
3123 /* Obsolete flags that used to indicate the presence of
3124 constructors and/or destructors. */
3134 /* The next number is the type number of the base class (possibly
3135 our own class) which supplies the vtable for this class. */
3136 if (! parse_stab_type_number (pp
, vtypenums
, p_end
))
3139 if (vtypenums
[0] == typenums
[0]
3140 && vtypenums
[1] == typenums
[1])
3149 vtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
3150 (debug_type
**) NULL
, p_end
);
3151 for (p
= *pp
; *p
!= ';' && *p
!= '\0'; p
++)
3159 *retvptrbase
= vtype
;
3167 /* Read a definition of an array type. */
3170 parse_stab_array_type (void *dhandle
,
3171 struct stab_handle
*info
,
3179 debug_type index_type
;
3181 bfd_signed_vma lower
, upper
;
3182 debug_type element_type
;
3184 /* Format of an array type:
3185 "ar<index type>;lower;upper;<array_contents_type>".
3186 OS9000: "arlower,upper;<array_contents_type>".
3188 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3189 for these, produce a type like float[][]. */
3193 return DEBUG_TYPE_NULL
;
3195 /* FIXME: gdb checks os9k_stabs here. */
3197 /* If the index type is type 0, we take it as int. */
3199 if (! parse_stab_type_number (&p
, typenums
, p_end
))
3200 return DEBUG_TYPE_NULL
;
3202 if (typenums
[0] == 0 && typenums
[1] == 0 && **pp
!= '=')
3204 index_type
= debug_find_named_type (dhandle
, "int");
3205 if (index_type
== DEBUG_TYPE_NULL
)
3207 index_type
= debug_make_int_type (dhandle
, 4, false);
3208 if (index_type
== DEBUG_TYPE_NULL
)
3209 return DEBUG_TYPE_NULL
;
3215 index_type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
3216 (debug_type
**) NULL
, p_end
);
3222 return DEBUG_TYPE_NULL
;
3228 if (! ISDIGIT (**pp
) && **pp
!= '-' && **pp
!= 0)
3234 lower
= (bfd_signed_vma
) parse_number (pp
, (bool *) NULL
, p_end
);
3238 return DEBUG_TYPE_NULL
;
3242 if (! ISDIGIT (**pp
) && **pp
!= '-' && **pp
!= 0)
3248 upper
= (bfd_signed_vma
) parse_number (pp
, (bool *) NULL
, p_end
);
3252 return DEBUG_TYPE_NULL
;
3256 element_type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
3257 (debug_type
**) NULL
, p_end
);
3258 if (element_type
== DEBUG_TYPE_NULL
)
3259 return DEBUG_TYPE_NULL
;
3267 return debug_make_array_type (dhandle
, element_type
, index_type
, lower
,
3271 /* This struct holds information about files we have seen using
3276 /* The next N_BINCL file. */
3277 struct bincl_file
*next
;
3278 /* The next N_BINCL on the stack. */
3279 struct bincl_file
*next_stack
;
3280 /* The file name. */
3282 /* The hash value. */
3284 /* The file index. */
3286 /* The list of types defined in this file. */
3287 struct stab_types
*file_types
;
3290 /* Start a new N_BINCL file, pushing it onto the stack. */
3293 push_bincl (struct stab_handle
*info
, const char *name
, bfd_vma hash
)
3295 struct bincl_file
*n
;
3297 n
= (struct bincl_file
*) xmalloc (sizeof *n
);
3298 n
->next
= info
->bincl_list
;
3299 n
->next_stack
= info
->bincl_stack
;
3302 n
->file
= info
->files
;
3303 n
->file_types
= NULL
;
3304 info
->bincl_list
= n
;
3305 info
->bincl_stack
= n
;
3308 info
->file_types
= ((struct stab_types
**)
3309 xrealloc (info
->file_types
,
3311 * sizeof *info
->file_types
)));
3312 info
->file_types
[n
->file
] = NULL
;
3315 /* Finish an N_BINCL file, at an N_EINCL, popping the name off the
3319 pop_bincl (struct stab_handle
*info
)
3321 struct bincl_file
*o
;
3323 o
= info
->bincl_stack
;
3325 return info
->main_filename
;
3326 info
->bincl_stack
= o
->next_stack
;
3328 if (o
->file
>= info
->files
)
3329 return info
->main_filename
;
3331 o
->file_types
= info
->file_types
[o
->file
];
3333 if (info
->bincl_stack
== NULL
)
3334 return info
->main_filename
;
3335 return info
->bincl_stack
->name
;
3338 /* Handle an N_EXCL: get the types from the corresponding N_BINCL. */
3341 find_excl (struct stab_handle
*info
, const char *name
, bfd_vma hash
)
3343 struct bincl_file
*l
;
3346 info
->file_types
= ((struct stab_types
**)
3347 xrealloc (info
->file_types
,
3349 * sizeof *info
->file_types
)));
3351 for (l
= info
->bincl_list
; l
!= NULL
; l
= l
->next
)
3352 if (l
->hash
== hash
&& strcmp (l
->name
, name
) == 0)
3356 warn_stab (name
, _("Undefined N_EXCL"));
3357 info
->file_types
[info
->files
- 1] = NULL
;
3361 info
->file_types
[info
->files
- 1] = l
->file_types
;
3366 /* Handle a variable definition. gcc emits variable definitions for a
3367 block before the N_LBRAC, so we must hold onto them until we see
3368 it. The SunPRO compiler emits variable definitions after the
3369 N_LBRAC, so we can call debug_record_variable immediately. */
3372 stab_record_variable (void *dhandle
, struct stab_handle
*info
,
3373 const char *name
, debug_type type
,
3374 enum debug_var_kind kind
, bfd_vma val
)
3376 struct stab_pending_var
*v
;
3378 if ((kind
== DEBUG_GLOBAL
|| kind
== DEBUG_STATIC
)
3379 || ! info
->within_function
3380 || (info
->gcc_compiled
== 0 && info
->n_opt_found
))
3381 return debug_record_variable (dhandle
, name
, type
, kind
, val
);
3383 v
= (struct stab_pending_var
*) xmalloc (sizeof *v
);
3384 memset (v
, 0, sizeof *v
);
3386 v
->next
= info
->pending
;
3396 /* Emit pending variable definitions. This is called after we see the
3397 N_LBRAC that starts the block. */
3400 stab_emit_pending_vars (void *dhandle
, struct stab_handle
*info
)
3402 struct stab_pending_var
*v
;
3407 struct stab_pending_var
*next
;
3409 if (! debug_record_variable (dhandle
, v
->name
, v
->type
, v
->kind
, v
->val
))
3417 info
->pending
= NULL
;
3422 /* Find the slot for a type in the database. */
3425 stab_find_slot (struct stab_handle
*info
, const int *typenums
)
3427 unsigned int filenum
;
3428 unsigned int tindex
;
3429 unsigned int base_index
;
3430 struct stab_types
**ps
;
3432 filenum
= typenums
[0];
3433 tindex
= typenums
[1];
3435 if (filenum
>= info
->files
)
3437 fprintf (stderr
, _("Type file number %d out of range\n"), filenum
);
3441 ps
= info
->file_types
+ filenum
;
3442 base_index
= tindex
/ STAB_TYPES_SLOTS
* STAB_TYPES_SLOTS
;
3443 tindex
-= base_index
;
3444 while (*ps
&& (*ps
)->base_index
< base_index
)
3447 if (*ps
== NULL
|| (*ps
)->base_index
!= base_index
)
3449 struct stab_types
*n
= xcalloc (1, sizeof (*n
));
3451 n
->base_index
= base_index
;
3455 return (*ps
)->types
+ tindex
;
3458 /* Find a type given a type number. If the type has not been
3459 allocated yet, create an indirect type. */
3462 stab_find_type (void *dhandle
, struct stab_handle
*info
, const int *typenums
)
3466 if (typenums
[0] == 0 && typenums
[1] < 0)
3468 /* A negative type number indicates an XCOFF builtin type. */
3469 return stab_xcoff_builtin_type (dhandle
, info
, typenums
[1]);
3472 slot
= stab_find_slot (info
, typenums
);
3474 return DEBUG_TYPE_NULL
;
3476 if (*slot
== DEBUG_TYPE_NULL
)
3477 return debug_make_indirect_type (dhandle
, slot
, (const char *) NULL
);
3482 /* Record that a given type number refers to a given type. */
3485 stab_record_type (void *dhandle ATTRIBUTE_UNUSED
, struct stab_handle
*info
,
3486 const int *typenums
, debug_type type
)
3490 slot
= stab_find_slot (info
, typenums
);
3494 /* gdb appears to ignore type redefinitions, so we do as well. */
3501 /* Return an XCOFF builtin type. */
3504 stab_xcoff_builtin_type (void *dhandle
, struct stab_handle
*info
,
3505 unsigned int typenum
)
3510 typenum
= -typenum
- 1;
3511 if (typenum
>= XCOFF_TYPE_COUNT
)
3513 fprintf (stderr
, _("Unrecognized XCOFF type %d\n"), -typenum
- 1);
3514 return DEBUG_TYPE_NULL
;
3516 if (info
->xcoff_types
[typenum
] != NULL
)
3517 return info
->xcoff_types
[typenum
];
3522 /* The size of this and all the other types are fixed, defined
3523 by the debugging format. */
3525 rettype
= debug_make_int_type (dhandle
, 4, false);
3529 rettype
= debug_make_int_type (dhandle
, 1, false);
3533 rettype
= debug_make_int_type (dhandle
, 2, false);
3537 rettype
= debug_make_int_type (dhandle
, 4, false);
3540 name
= "unsigned char";
3541 rettype
= debug_make_int_type (dhandle
, 1, true);
3544 name
= "signed char";
3545 rettype
= debug_make_int_type (dhandle
, 1, false);
3548 name
= "unsigned short";
3549 rettype
= debug_make_int_type (dhandle
, 2, true);
3552 name
= "unsigned int";
3553 rettype
= debug_make_int_type (dhandle
, 4, true);
3557 rettype
= debug_make_int_type (dhandle
, 4, true);
3560 name
= "unsigned long";
3561 rettype
= debug_make_int_type (dhandle
, 4, true);
3565 rettype
= debug_make_void_type (dhandle
);
3568 /* IEEE single precision (32 bit). */
3570 rettype
= debug_make_float_type (dhandle
, 4);
3573 /* IEEE double precision (64 bit). */
3575 rettype
= debug_make_float_type (dhandle
, 8);
3578 /* This is an IEEE double on the RS/6000, and different machines
3579 with different sizes for "long double" should use different
3580 negative type numbers. See stabs.texinfo. */
3581 name
= "long double";
3582 rettype
= debug_make_float_type (dhandle
, 8);
3586 rettype
= debug_make_int_type (dhandle
, 4, false);
3590 rettype
= debug_make_bool_type (dhandle
, 4);
3593 name
= "short real";
3594 rettype
= debug_make_float_type (dhandle
, 4);
3598 rettype
= debug_make_float_type (dhandle
, 8);
3608 rettype
= debug_make_int_type (dhandle
, 1, true);
3612 rettype
= debug_make_bool_type (dhandle
, 1);
3616 rettype
= debug_make_bool_type (dhandle
, 2);
3620 rettype
= debug_make_bool_type (dhandle
, 4);
3624 rettype
= debug_make_bool_type (dhandle
, 4);
3627 /* Complex type consisting of two IEEE single precision values. */
3629 rettype
= debug_make_complex_type (dhandle
, 8);
3632 /* Complex type consisting of two IEEE double precision values. */
3633 name
= "double complex";
3634 rettype
= debug_make_complex_type (dhandle
, 16);
3638 rettype
= debug_make_int_type (dhandle
, 1, false);
3642 rettype
= debug_make_int_type (dhandle
, 2, false);
3646 rettype
= debug_make_int_type (dhandle
, 4, false);
3651 rettype
= debug_make_int_type (dhandle
, 2, false);
3655 rettype
= debug_make_int_type (dhandle
, 8, false);
3658 name
= "unsigned long long";
3659 rettype
= debug_make_int_type (dhandle
, 8, true);
3663 rettype
= debug_make_bool_type (dhandle
, 8);
3667 rettype
= debug_make_int_type (dhandle
, 8, false);
3673 rettype
= debug_name_type (dhandle
, name
, rettype
);
3674 info
->xcoff_types
[typenum
] = rettype
;
3678 /* Find or create a tagged type. */
3681 stab_find_tagged_type (void *dhandle
, struct stab_handle
*info
,
3682 const char *p
, int len
, enum debug_type_kind kind
)
3686 struct stab_tag
*st
;
3688 name
= savestring (p
, len
);
3690 /* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same
3691 namespace. This is right for C, and I don't know how to handle
3692 other languages. FIXME. */
3693 dtype
= debug_find_tagged_type (dhandle
, name
, DEBUG_KIND_ILLEGAL
);
3694 if (dtype
!= DEBUG_TYPE_NULL
)
3700 /* We need to allocate an entry on the undefined tag list. */
3701 for (st
= info
->tags
; st
!= NULL
; st
= st
->next
)
3703 if (st
->name
[0] == name
[0]
3704 && strcmp (st
->name
, name
) == 0)
3706 if (st
->kind
== DEBUG_KIND_ILLEGAL
)
3714 st
= (struct stab_tag
*) xmalloc (sizeof *st
);
3715 memset (st
, 0, sizeof *st
);
3717 st
->next
= info
->tags
;
3720 st
->slot
= DEBUG_TYPE_NULL
;
3721 st
->type
= debug_make_indirect_type (dhandle
, &st
->slot
, name
);
3728 /* In order to get the correct argument types for a stubbed method, we
3729 need to extract the argument types from a C++ mangled string.
3730 Since the argument types can refer back to the return type, this
3731 means that we must demangle the entire physical name. In gdb this
3732 is done by calling cplus_demangle and running the results back
3733 through the C++ expression parser. Since we have no expression
3734 parser, we must duplicate much of the work of cplus_demangle here.
3736 We assume that GNU style demangling is used, since this is only
3737 done for method stubs, and only g++ should output that form of
3738 debugging information. */
3740 /* This structure is used to hold a pointer to type information which
3741 demangling a string. */
3743 struct stab_demangle_typestring
3745 /* The start of the type. This is not null terminated. */
3746 const char *typestring
;
3747 /* The length of the type. */
3751 /* This structure is used to hold information while demangling a
3754 struct stab_demangle_info
3756 /* The debugging information handle. */
3758 /* The stab information handle. */
3759 struct stab_handle
*info
;
3760 /* The array of arguments we are building. */
3762 /* Whether the method takes a variable number of arguments. */
3764 /* The array of types we have remembered. */
3765 struct stab_demangle_typestring
*typestrings
;
3766 /* The number of typestrings. */
3767 unsigned int typestring_count
;
3768 /* The number of typestring slots we have allocated. */
3769 unsigned int typestring_alloc
;
3772 static void stab_bad_demangle (const char *);
3773 static unsigned int stab_demangle_count (const char **);
3774 static bool stab_demangle_get_count (const char **, unsigned int *);
3775 static bool stab_demangle_prefix
3776 (struct stab_demangle_info
*, const char **, unsigned int);
3777 static bool stab_demangle_function_name
3778 (struct stab_demangle_info
*, const char **, const char *);
3779 static bool stab_demangle_signature
3780 (struct stab_demangle_info
*, const char **);
3781 static bool stab_demangle_qualified
3782 (struct stab_demangle_info
*, const char **, debug_type
*);
3783 static bool stab_demangle_template
3784 (struct stab_demangle_info
*, const char **, char **);
3785 static bool stab_demangle_class
3786 (struct stab_demangle_info
*, const char **, const char **);
3787 static bool stab_demangle_args
3788 (struct stab_demangle_info
*, const char **, debug_type
**, bool *);
3789 static bool stab_demangle_arg
3790 (struct stab_demangle_info
*, const char **, debug_type
**,
3791 unsigned int *, unsigned int *);
3792 static bool stab_demangle_type
3793 (struct stab_demangle_info
*, const char **, debug_type
*);
3794 static bool stab_demangle_fund_type
3795 (struct stab_demangle_info
*, const char **, debug_type
*);
3796 static bool stab_demangle_remember_type
3797 (struct stab_demangle_info
*, const char *, int);
3799 /* Warn about a bad demangling. */
3802 stab_bad_demangle (const char *s
)
3804 fprintf (stderr
, _("bad mangled name `%s'\n"), s
);
3807 /* Get a count from a stab string. */
3810 stab_demangle_count (const char **pp
)
3815 while (ISDIGIT (**pp
))
3818 count
+= **pp
- '0';
3824 /* Require a count in a string. The count may be multiple digits, in
3825 which case it must end in an underscore. */
3828 stab_demangle_get_count (const char **pp
, unsigned int *pi
)
3830 if (! ISDIGIT (**pp
))
3848 while (ISDIGIT (*p
));
3859 /* This function demangles a physical name, returning a NULL
3860 terminated array of argument types. */
3863 stab_demangle_argtypes (void *dhandle
, struct stab_handle
*info
,
3864 const char *physname
, bool *pvarargs
,
3865 unsigned int physname_len
)
3867 struct stab_demangle_info minfo
;
3869 /* Check for the g++ V3 ABI. */
3870 if (physname
[0] == '_' && physname
[1] == 'Z')
3871 return stab_demangle_v3_argtypes (dhandle
, info
, physname
, pvarargs
);
3873 minfo
.dhandle
= dhandle
;
3876 minfo
.varargs
= false;
3877 minfo
.typestring_alloc
= 10;
3878 minfo
.typestrings
= ((struct stab_demangle_typestring
*)
3879 xmalloc (minfo
.typestring_alloc
3880 * sizeof *minfo
.typestrings
));
3881 minfo
.typestring_count
= 0;
3883 /* cplus_demangle checks for special GNU mangled forms, but we can't
3884 see any of them in mangled method argument types. */
3886 if (! stab_demangle_prefix (&minfo
, &physname
, physname_len
))
3889 if (*physname
!= '\0')
3891 if (! stab_demangle_signature (&minfo
, &physname
))
3895 free (minfo
.typestrings
);
3896 minfo
.typestrings
= NULL
;
3898 if (minfo
.args
== NULL
)
3899 fprintf (stderr
, _("no argument types in mangled string\n"));
3901 *pvarargs
= minfo
.varargs
;
3905 free (minfo
.typestrings
);
3909 /* Demangle the prefix of the mangled name. */
3912 stab_demangle_prefix (struct stab_demangle_info
*minfo
, const char **pp
,
3913 unsigned int physname_len
)
3918 /* cplus_demangle checks for global constructors and destructors,
3919 but we can't see them in mangled argument types. */
3922 scan
= *pp
+ physname_len
;
3925 /* Look for `__'. */
3928 scan
= strchr (scan
, '_');
3929 while (scan
!= NULL
&& *++scan
!= '_');
3933 stab_bad_demangle (*pp
);
3939 /* We found `__'; move ahead to the last contiguous `__' pair. */
3940 i
= strspn (scan
, "_");
3946 && (ISDIGIT (scan
[2])
3950 /* This is a GNU style constructor name. */
3954 else if (scan
== *pp
3955 && ! ISDIGIT (scan
[2])
3958 /* Look for the `__' that separates the prefix from the
3960 while (*scan
== '_')
3962 scan
= strstr (scan
, "__");
3963 if (scan
== NULL
|| scan
[2] == '\0')
3965 stab_bad_demangle (*pp
);
3969 return stab_demangle_function_name (minfo
, pp
, scan
);
3971 else if (scan
[2] != '\0')
3973 /* The name doesn't start with `__', but it does contain `__'. */
3974 return stab_demangle_function_name (minfo
, pp
, scan
);
3978 stab_bad_demangle (*pp
);
3984 /* Demangle a function name prefix. The scan argument points to the
3985 double underscore which separates the function name from the
3989 stab_demangle_function_name (struct stab_demangle_info
*minfo
,
3990 const char **pp
, const char *scan
)
3994 /* The string from *pp to scan is the name of the function. We
3995 don't care about the name, since we just looking for argument
3996 types. However, for conversion operators, the name may include a
3997 type which we must remember in order to handle backreferences. */
4003 && startswith (name
, "type")
4004 && (name
[4] == '$' || name
[4] == '.'))
4008 /* This is a type conversion operator. */
4010 if (! stab_demangle_type (minfo
, &tem
, (debug_type
*) NULL
))
4013 else if (name
[0] == '_'
4020 /* This is a type conversion operator. */
4022 if (! stab_demangle_type (minfo
, &tem
, (debug_type
*) NULL
))
4029 /* Demangle the signature. This is where the argument types are
4033 stab_demangle_signature (struct stab_demangle_info
*minfo
, const char **pp
)
4036 bool expect_func
, func_done
;
4041 expect_func
= false;
4045 while (**pp
!= '\0')
4051 if (! stab_demangle_qualified (minfo
, pp
, (debug_type
*) NULL
)
4052 || ! stab_demangle_remember_type (minfo
, hold
, *pp
- hold
))
4059 /* Static member function. FIXME: Can this happen? */
4066 /* Const member function. */
4072 case '0': case '1': case '2': case '3': case '4':
4073 case '5': case '6': case '7': case '8': case '9':
4076 if (! stab_demangle_class (minfo
, pp
, (const char **) NULL
)
4077 || ! stab_demangle_remember_type (minfo
, hold
, *pp
- hold
))
4084 /* Function. I don't know if this actually happens with g++
4089 if (! stab_demangle_args (minfo
, pp
, &minfo
->args
, &minfo
->varargs
))
4097 if (! stab_demangle_template (minfo
, pp
, (char **) NULL
)
4098 || ! stab_demangle_remember_type (minfo
, hold
, *pp
- hold
))
4105 /* At the outermost level, we cannot have a return type
4106 specified, so if we run into another '_' at this point we
4107 are dealing with a mangled name that is either bogus, or
4108 has been mangled by some algorithm we don't know how to
4109 deal with. So just reject the entire demangling. */
4110 stab_bad_demangle (orig
);
4114 /* Assume we have stumbled onto the first outermost function
4115 argument token, and start processing args. */
4117 if (! stab_demangle_args (minfo
, pp
, &minfo
->args
, &minfo
->varargs
))
4125 if (! stab_demangle_args (minfo
, pp
, &minfo
->args
, &minfo
->varargs
))
4132 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
4133 bar__3fooi is 'foo::bar(int)'. We get here when we find the
4134 first case, and need to ensure that the '(void)' gets added
4135 to the current declp. */
4136 if (! stab_demangle_args (minfo
, pp
, &minfo
->args
, &minfo
->varargs
))
4143 /* Demangle a qualified name, such as "Q25Outer5Inner" which is the
4144 mangled form of "Outer::Inner". */
4147 stab_demangle_qualified (struct stab_demangle_info
*minfo
, const char **pp
,
4152 unsigned int qualifiers
;
4160 /* GNU mangled name with more than 9 classes. The count is
4161 preceded by an underscore (to distinguish it from the <= 9
4162 case) and followed by an underscore. */
4164 if (! ISDIGIT (*p
) || *p
== '0')
4166 stab_bad_demangle (orig
);
4169 qualifiers
= atoi (p
);
4170 while (ISDIGIT (*p
))
4174 stab_bad_demangle (orig
);
4180 case '1': case '2': case '3': case '4': case '5':
4181 case '6': case '7': case '8': case '9':
4182 qualifiers
= (*pp
)[1] - '0';
4183 /* Skip an optional underscore after the count. */
4184 if ((*pp
)[2] == '_')
4191 stab_bad_demangle (orig
);
4195 context
= DEBUG_TYPE_NULL
;
4197 /* Pick off the names. */
4198 while (qualifiers
-- > 0)
4206 if (! stab_demangle_template (minfo
, pp
,
4207 ptype
!= NULL
? &name
: NULL
))
4212 context
= stab_find_tagged_type (minfo
->dhandle
, minfo
->info
,
4213 name
, strlen (name
),
4216 if (context
== DEBUG_TYPE_NULL
)
4224 len
= stab_demangle_count (pp
);
4225 if (strlen (*pp
) < len
)
4227 stab_bad_demangle (orig
);
4233 const debug_field
*fields
;
4236 if (context
!= DEBUG_TYPE_NULL
)
4237 fields
= debug_get_fields (minfo
->dhandle
, context
);
4239 context
= DEBUG_TYPE_NULL
;
4245 /* Try to find the type by looking through the
4246 fields of context until we find a field with the
4247 same type. This ought to work for a class
4248 defined within a class, but it won't work for,
4249 e.g., an enum defined within a class. stabs does
4250 not give us enough information to figure out the
4253 name
= savestring (*pp
, len
);
4255 for (; *fields
!= DEBUG_FIELD_NULL
; fields
++)
4260 ft
= debug_get_field_type (minfo
->dhandle
, *fields
);
4266 dn
= debug_get_type_name (minfo
->dhandle
, ft
);
4267 if (dn
!= NULL
&& strcmp (dn
, name
) == 0)
4277 if (context
== DEBUG_TYPE_NULL
)
4279 /* We have to fall back on finding the type by name.
4280 If there are more types to come, then this must
4281 be a class. Otherwise, it could be anything. */
4283 if (qualifiers
== 0)
4287 name
= savestring (*pp
, len
);
4288 context
= debug_find_named_type (minfo
->dhandle
,
4293 if (context
== DEBUG_TYPE_NULL
)
4295 context
= stab_find_tagged_type (minfo
->dhandle
,
4299 ? DEBUG_KIND_ILLEGAL
4300 : DEBUG_KIND_CLASS
));
4301 if (context
== DEBUG_TYPE_NULL
)
4317 /* Demangle a template. If PNAME is not NULL, this sets *PNAME to a
4318 string representation of the template. */
4321 stab_demangle_template (struct stab_demangle_info
*minfo
, const char **pp
,
4331 /* Skip the template name. */
4332 r
= stab_demangle_count (pp
);
4333 if (r
== 0 || strlen (*pp
) < r
)
4335 stab_bad_demangle (orig
);
4340 /* Get the size of the parameter list. */
4341 if (stab_demangle_get_count (pp
, &r
) == 0)
4343 stab_bad_demangle (orig
);
4347 for (i
= 0; i
< r
; i
++)
4351 /* This is a type parameter. */
4353 if (! stab_demangle_type (minfo
, pp
, (debug_type
*) NULL
))
4359 bool pointerp
, realp
, integralp
, charp
, boolp
;
4370 /* This is a value parameter. */
4372 if (! stab_demangle_type (minfo
, pp
, (debug_type
*) NULL
))
4375 while (*old_p
!= '\0' && ! done
)
4385 case 'C': /* Const. */
4386 case 'S': /* Signed. */
4387 case 'U': /* Unsigned. */
4388 case 'V': /* Volatile. */
4389 case 'F': /* Function. */
4390 case 'M': /* Member function. */
4394 case 'Q': /* Qualified name. */
4398 case 'T': /* Remembered type. */
4400 case 'v': /* Void. */
4402 case 'x': /* Long long. */
4403 case 'l': /* Long. */
4404 case 'i': /* Int. */
4405 case 's': /* Short. */
4406 case 'w': /* Wchar_t. */
4410 case 'b': /* Bool. */
4414 case 'c': /* Char. */
4418 case 'r': /* Long double. */
4419 case 'd': /* Double. */
4420 case 'f': /* Float. */
4425 /* Assume it's a user defined integral type. */
4436 while (ISDIGIT (**pp
))
4445 val
= stab_demangle_count (pp
);
4448 stab_bad_demangle (orig
);
4456 val
= stab_demangle_count (pp
);
4457 if (val
!= 0 && val
!= 1)
4459 stab_bad_demangle (orig
);
4467 while (ISDIGIT (**pp
))
4472 while (ISDIGIT (**pp
))
4478 while (ISDIGIT (**pp
))
4486 len
= stab_demangle_count (pp
);
4489 stab_bad_demangle (orig
);
4497 /* We can translate this to a string fairly easily by invoking the
4498 regular demangling routine. */
4501 char *s1
, *s2
, *s3
, *s4
= NULL
;
4504 s1
= savestring (orig
, *pp
- orig
);
4506 s2
= concat ("NoSuchStrinG__", s1
, (const char *) NULL
);
4510 s3
= cplus_demangle (s2
, demangle_flags
);
4515 s4
= strstr (s3
, "::NoSuchStrinG");
4516 if (s3
== NULL
|| s4
== NULL
)
4518 stab_bad_demangle (orig
);
4523 /* Eliminating all spaces, except those between > characters,
4524 makes it more likely that the demangled name will match the
4525 name which g++ used as the structure name. */
4526 for (from
= to
= s3
; from
!= s4
; ++from
)
4528 || (from
[1] == '>' && from
> s3
&& from
[-1] == '>'))
4531 *pname
= savestring (s3
, to
- s3
);
4539 /* Demangle a class name. */
4542 stab_demangle_class (struct stab_demangle_info
*minfo ATTRIBUTE_UNUSED
,
4543 const char **pp
, const char **pstart
)
4550 n
= stab_demangle_count (pp
);
4551 if (strlen (*pp
) < n
)
4553 stab_bad_demangle (orig
);
4565 /* Demangle function arguments. If the pargs argument is not NULL, it
4566 is set to a NULL terminated array holding the arguments. */
4569 stab_demangle_args (struct stab_demangle_info
*minfo
, const char **pp
,
4570 debug_type
**pargs
, bool *pvarargs
)
4573 unsigned int alloc
, count
;
4580 *pargs
= (debug_type
*) xmalloc (alloc
* sizeof **pargs
);
4585 while (**pp
!= '_' && **pp
!= '\0' && **pp
!= 'e')
4587 if (**pp
== 'N' || **pp
== 'T')
4595 if (temptype
== 'T')
4599 if (! stab_demangle_get_count (pp
, &r
))
4601 stab_bad_demangle (orig
);
4606 if (! stab_demangle_get_count (pp
, &t
))
4608 stab_bad_demangle (orig
);
4612 if (t
>= minfo
->typestring_count
)
4614 stab_bad_demangle (orig
);
4621 tem
= minfo
->typestrings
[t
].typestring
;
4622 if (! stab_demangle_arg (minfo
, &tem
, pargs
, &count
, &alloc
))
4628 if (! stab_demangle_arg (minfo
, pp
, pargs
, &count
, &alloc
))
4634 (*pargs
)[count
] = DEBUG_TYPE_NULL
;
4646 /* Demangle a single argument. */
4649 stab_demangle_arg (struct stab_demangle_info
*minfo
, const char **pp
,
4650 debug_type
**pargs
, unsigned int *pcount
,
4651 unsigned int *palloc
)
4657 if (! stab_demangle_type (minfo
, pp
,
4658 pargs
== NULL
? (debug_type
*) NULL
: &type
)
4659 || ! stab_demangle_remember_type (minfo
, start
, *pp
- start
))
4664 if (type
== DEBUG_TYPE_NULL
)
4667 if (*pcount
+ 1 >= *palloc
)
4670 *pargs
= ((debug_type
*)
4671 xrealloc (*pargs
, *palloc
* sizeof **pargs
));
4673 (*pargs
)[*pcount
] = type
;
4680 /* Demangle a type. If the ptype argument is not NULL, *ptype is set
4681 to the newly allocated type. */
4684 stab_demangle_type (struct stab_demangle_info
*minfo
, const char **pp
,
4695 /* A pointer type. */
4697 if (! stab_demangle_type (minfo
, pp
, ptype
))
4700 *ptype
= debug_make_pointer_type (minfo
->dhandle
, *ptype
);
4704 /* A reference type. */
4706 if (! stab_demangle_type (minfo
, pp
, ptype
))
4709 *ptype
= debug_make_reference_type (minfo
->dhandle
, *ptype
);
4719 while (**pp
!= '\0' && **pp
!= '_')
4721 if (! ISDIGIT (**pp
))
4723 stab_bad_demangle (orig
);
4732 stab_bad_demangle (orig
);
4737 if (! stab_demangle_type (minfo
, pp
, ptype
))
4741 debug_type int_type
;
4743 int_type
= debug_find_named_type (minfo
->dhandle
, "int");
4744 if (int_type
== NULL
)
4745 int_type
= debug_make_int_type (minfo
->dhandle
, 4, false);
4746 *ptype
= debug_make_array_type (minfo
->dhandle
, *ptype
, int_type
,
4753 /* A back reference to a remembered type. */
4759 if (! stab_demangle_get_count (pp
, &i
))
4761 stab_bad_demangle (orig
);
4764 if (i
>= minfo
->typestring_count
)
4766 stab_bad_demangle (orig
);
4769 p
= minfo
->typestrings
[i
].typestring
;
4770 if (! stab_demangle_type (minfo
, &p
, ptype
))
4782 if (! stab_demangle_args (minfo
, pp
,
4784 ? (debug_type
**) NULL
4792 /* cplus_demangle will accept a function without a return
4793 type, but I don't know when that will happen, or what
4794 to do if it does. */
4795 stab_bad_demangle (orig
);
4799 if (! stab_demangle_type (minfo
, pp
, ptype
))
4802 *ptype
= debug_make_function_type (minfo
->dhandle
, *ptype
, args
,
4812 debug_type class_type
= DEBUG_TYPE_NULL
;
4818 memberp
= **pp
== 'M';
4825 n
= stab_demangle_count (pp
);
4826 if (strlen (*pp
) < n
)
4828 stab_bad_demangle (orig
);
4836 class_type
= stab_find_tagged_type (minfo
->dhandle
,
4840 if (class_type
== DEBUG_TYPE_NULL
)
4844 else if (**pp
== 'Q')
4846 if (! stab_demangle_qualified (minfo
, pp
,
4848 ? (debug_type
*) NULL
4854 stab_bad_demangle (orig
);
4864 else if (**pp
== 'V')
4870 stab_bad_demangle (orig
);
4874 if (! stab_demangle_args (minfo
, pp
,
4876 ? (debug_type
**) NULL
4886 stab_bad_demangle (orig
);
4891 if (! stab_demangle_type (minfo
, pp
, ptype
))
4897 *ptype
= debug_make_offset_type (minfo
->dhandle
, class_type
,
4901 /* FIXME: We have no way to record constp or
4903 *ptype
= debug_make_method_type (minfo
->dhandle
, *ptype
,
4904 class_type
, args
, varargs
);
4912 if (! stab_demangle_type (minfo
, pp
, ptype
))
4918 if (! stab_demangle_type (minfo
, pp
, ptype
))
4921 *ptype
= debug_make_const_type (minfo
->dhandle
, *ptype
);
4926 if (! stab_demangle_qualified (minfo
, pp
, ptype
))
4932 if (! stab_demangle_fund_type (minfo
, pp
, ptype
))
4940 /* Demangle a fundamental type. If the ptype argument is not NULL,
4941 *ptype is set to the newly allocated type. */
4944 stab_demangle_fund_type (struct stab_demangle_info
*minfo
, const char **pp
,
4948 bool constp
, volatilep
, unsignedp
, signedp
;
4993 /* cplus_demangle permits this, but I don't know what it means. */
4994 stab_bad_demangle (orig
);
4997 case 'v': /* void */
5000 *ptype
= debug_find_named_type (minfo
->dhandle
, "void");
5001 if (*ptype
== DEBUG_TYPE_NULL
)
5002 *ptype
= debug_make_void_type (minfo
->dhandle
);
5007 case 'x': /* long long */
5010 *ptype
= debug_find_named_type (minfo
->dhandle
,
5012 ? "long long unsigned int"
5013 : "long long int"));
5014 if (*ptype
== DEBUG_TYPE_NULL
)
5015 *ptype
= debug_make_int_type (minfo
->dhandle
, 8, unsignedp
);
5020 case 'l': /* long */
5023 *ptype
= debug_find_named_type (minfo
->dhandle
,
5025 ? "long unsigned int"
5027 if (*ptype
== DEBUG_TYPE_NULL
)
5028 *ptype
= debug_make_int_type (minfo
->dhandle
, 4, unsignedp
);
5036 *ptype
= debug_find_named_type (minfo
->dhandle
,
5040 if (*ptype
== DEBUG_TYPE_NULL
)
5041 *ptype
= debug_make_int_type (minfo
->dhandle
, 4, unsignedp
);
5046 case 's': /* short */
5049 *ptype
= debug_find_named_type (minfo
->dhandle
,
5051 ? "short unsigned int"
5053 if (*ptype
== DEBUG_TYPE_NULL
)
5054 *ptype
= debug_make_int_type (minfo
->dhandle
, 2, unsignedp
);
5059 case 'b': /* bool */
5062 *ptype
= debug_find_named_type (minfo
->dhandle
, "bool");
5063 if (*ptype
== DEBUG_TYPE_NULL
)
5064 *ptype
= debug_make_bool_type (minfo
->dhandle
, 4);
5069 case 'c': /* char */
5072 *ptype
= debug_find_named_type (minfo
->dhandle
,
5078 if (*ptype
== DEBUG_TYPE_NULL
)
5079 *ptype
= debug_make_int_type (minfo
->dhandle
, 1, unsignedp
);
5084 case 'w': /* wchar_t */
5087 *ptype
= debug_find_named_type (minfo
->dhandle
, "__wchar_t");
5088 if (*ptype
== DEBUG_TYPE_NULL
)
5089 *ptype
= debug_make_int_type (minfo
->dhandle
, 2, true);
5094 case 'r': /* long double */
5097 *ptype
= debug_find_named_type (minfo
->dhandle
, "long double");
5098 if (*ptype
== DEBUG_TYPE_NULL
)
5099 *ptype
= debug_make_float_type (minfo
->dhandle
, 8);
5104 case 'd': /* double */
5107 *ptype
= debug_find_named_type (minfo
->dhandle
, "double");
5108 if (*ptype
== DEBUG_TYPE_NULL
)
5109 *ptype
= debug_make_float_type (minfo
->dhandle
, 8);
5114 case 'f': /* float */
5117 *ptype
= debug_find_named_type (minfo
->dhandle
, "float");
5118 if (*ptype
== DEBUG_TYPE_NULL
)
5119 *ptype
= debug_make_float_type (minfo
->dhandle
, 4);
5126 if (! ISDIGIT (**pp
))
5128 stab_bad_demangle (orig
);
5132 case '0': case '1': case '2': case '3': case '4':
5133 case '5': case '6': case '7': case '8': case '9':
5137 if (! stab_demangle_class (minfo
, pp
, &hold
))
5143 name
= savestring (hold
, *pp
- hold
);
5144 *ptype
= debug_find_named_type (minfo
->dhandle
, name
);
5146 if (*ptype
== DEBUG_TYPE_NULL
)
5148 /* FIXME: It is probably incorrect to assume that
5149 undefined types are tagged types. */
5150 *ptype
= stab_find_tagged_type (minfo
->dhandle
, minfo
->info
,
5152 DEBUG_KIND_ILLEGAL
);
5153 if (*ptype
== DEBUG_TYPE_NULL
)
5164 if (! stab_demangle_template (minfo
, pp
,
5165 ptype
!= NULL
? &name
: NULL
))
5169 *ptype
= stab_find_tagged_type (minfo
->dhandle
, minfo
->info
,
5170 name
, strlen (name
),
5173 if (*ptype
== DEBUG_TYPE_NULL
)
5180 stab_bad_demangle (orig
);
5187 *ptype
= debug_make_const_type (minfo
->dhandle
, *ptype
);
5189 *ptype
= debug_make_volatile_type (minfo
->dhandle
, *ptype
);
5195 /* Remember a type string in a demangled string. */
5198 stab_demangle_remember_type (struct stab_demangle_info
*minfo
,
5199 const char *p
, int len
)
5201 if (minfo
->typestring_count
>= minfo
->typestring_alloc
)
5203 minfo
->typestring_alloc
+= 10;
5204 minfo
->typestrings
= ((struct stab_demangle_typestring
*)
5205 xrealloc (minfo
->typestrings
,
5206 (minfo
->typestring_alloc
5207 * sizeof *minfo
->typestrings
)));
5210 minfo
->typestrings
[minfo
->typestring_count
].typestring
= p
;
5211 minfo
->typestrings
[minfo
->typestring_count
].len
= (unsigned int) len
;
5212 ++minfo
->typestring_count
;
5217 /* Demangle names encoded using the g++ V3 ABI. The newer versions of
5218 g++ which use this ABI do not encode ordinary method argument types
5219 in a mangled name; they simply output the argument types. However,
5220 for a static method, g++ simply outputs the return type and the
5221 physical name. So in that case we need to demangle the name here.
5222 Here PHYSNAME is the physical name of the function, and we set the
5223 variable pointed at by PVARARGS to indicate whether this function
5224 is varargs. This returns NULL, or a NULL terminated array of
5228 stab_demangle_v3_argtypes (void *dhandle
, struct stab_handle
*info
,
5229 const char *physname
, bool *pvarargs
)
5231 struct demangle_component
*dc
;
5235 dc
= cplus_demangle_v3_components (physname
, DMGL_PARAMS
| demangle_flags
, &mem
);
5238 stab_bad_demangle (physname
);
5242 /* We expect to see TYPED_NAME, and the right subtree describes the
5244 if (dc
->type
!= DEMANGLE_COMPONENT_TYPED_NAME
5245 || dc
->u
.s_binary
.right
->type
!= DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5247 fprintf (stderr
, _("Demangled name is not a function\n"));
5252 pargs
= stab_demangle_v3_arglist (dhandle
, info
,
5253 dc
->u
.s_binary
.right
->u
.s_binary
.right
,
5261 /* Demangle an argument list in a struct demangle_component tree.
5262 Returns a DEBUG_TYPE_NULL terminated array of argument types, and
5263 sets *PVARARGS to indicate whether this is a varargs function. */
5266 stab_demangle_v3_arglist (void *dhandle
, struct stab_handle
*info
,
5267 struct demangle_component
*arglist
,
5270 struct demangle_component
*dc
;
5271 unsigned int alloc
, count
;
5275 pargs
= (debug_type
*) xmalloc (alloc
* sizeof *pargs
);
5282 dc
= dc
->u
.s_binary
.right
)
5287 if (dc
->type
!= DEMANGLE_COMPONENT_ARGLIST
)
5289 fprintf (stderr
, _("Unexpected type in v3 arglist demangling\n"));
5294 /* PR 13925: Cope if the demangler returns an empty
5295 context for a function with no arguments. */
5296 if (dc
->u
.s_binary
.left
== NULL
)
5299 arg
= stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.left
,
5312 if (count
+ 1 >= alloc
)
5315 pargs
= (debug_type
*) xrealloc (pargs
, alloc
* sizeof *pargs
);
5322 pargs
[count
] = DEBUG_TYPE_NULL
;
5327 /* Convert a struct demangle_component tree describing an argument
5328 type into a debug_type. */
5331 stab_demangle_v3_arg (void *dhandle
, struct stab_handle
*info
,
5332 struct demangle_component
*dc
, debug_type context
,
5337 if (pvarargs
!= NULL
)
5342 /* FIXME: These are demangle component types which we probably
5343 need to handle one way or another. */
5344 case DEMANGLE_COMPONENT_LOCAL_NAME
:
5345 case DEMANGLE_COMPONENT_TYPED_NAME
:
5346 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
5347 case DEMANGLE_COMPONENT_CTOR
:
5348 case DEMANGLE_COMPONENT_DTOR
:
5349 case DEMANGLE_COMPONENT_JAVA_CLASS
:
5350 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
5351 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
5352 case DEMANGLE_COMPONENT_CONST_THIS
:
5353 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5354 case DEMANGLE_COMPONENT_COMPLEX
:
5355 case DEMANGLE_COMPONENT_IMAGINARY
:
5356 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
5357 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
5358 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
5359 case DEMANGLE_COMPONENT_ARGLIST
:
5361 fprintf (stderr
, _("Unrecognized demangle component %d\n"),
5365 case DEMANGLE_COMPONENT_NAME
:
5366 if (context
!= NULL
)
5368 const debug_field
*fields
;
5370 fields
= debug_get_fields (dhandle
, context
);
5373 /* Try to find this type by looking through the context
5375 for (; *fields
!= DEBUG_FIELD_NULL
; fields
++)
5380 ft
= debug_get_field_type (dhandle
, *fields
);
5383 dn
= debug_get_type_name (dhandle
, ft
);
5385 && (int) strlen (dn
) == dc
->u
.s_name
.len
5386 && strncmp (dn
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
) == 0)
5391 return stab_find_tagged_type (dhandle
, info
, dc
->u
.s_name
.s
,
5392 dc
->u
.s_name
.len
, DEBUG_KIND_ILLEGAL
);
5394 case DEMANGLE_COMPONENT_QUAL_NAME
:
5395 context
= stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.left
,
5397 if (context
== NULL
)
5399 return stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.right
,
5402 case DEMANGLE_COMPONENT_TEMPLATE
:
5407 /* We print this component to get a class name which we can
5408 use. FIXME: This probably won't work if the template uses
5409 template parameters which refer to an outer template. */
5410 p
= cplus_demangle_print (DMGL_PARAMS
| demangle_flags
, dc
, 20, &alc
);
5413 fprintf (stderr
, _("Failed to print demangled template\n"));
5416 dt
= stab_find_tagged_type (dhandle
, info
, p
, strlen (p
),
5422 case DEMANGLE_COMPONENT_SUB_STD
:
5423 return stab_find_tagged_type (dhandle
, info
, dc
->u
.s_string
.string
,
5424 dc
->u
.s_string
.len
, DEBUG_KIND_ILLEGAL
);
5426 case DEMANGLE_COMPONENT_RESTRICT
:
5427 case DEMANGLE_COMPONENT_VOLATILE
:
5428 case DEMANGLE_COMPONENT_CONST
:
5429 case DEMANGLE_COMPONENT_POINTER
:
5430 case DEMANGLE_COMPONENT_REFERENCE
:
5431 dt
= stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.left
, NULL
,
5440 case DEMANGLE_COMPONENT_RESTRICT
:
5441 /* FIXME: We have no way to represent restrict. */
5443 case DEMANGLE_COMPONENT_VOLATILE
:
5444 return debug_make_volatile_type (dhandle
, dt
);
5445 case DEMANGLE_COMPONENT_CONST
:
5446 return debug_make_const_type (dhandle
, dt
);
5447 case DEMANGLE_COMPONENT_POINTER
:
5448 return debug_make_pointer_type (dhandle
, dt
);
5449 case DEMANGLE_COMPONENT_REFERENCE
:
5450 return debug_make_reference_type (dhandle
, dt
);
5453 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
5458 if (dc
->u
.s_binary
.left
== NULL
)
5460 /* In this case the return type is actually unknown.
5461 However, I'm not sure this will ever arise in practice;
5462 normally an unknown return type would only appear at
5463 the top level, which is handled above. */
5464 dt
= debug_make_void_type (dhandle
);
5467 dt
= stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.left
, NULL
,
5472 pargs
= stab_demangle_v3_arglist (dhandle
, info
,
5473 dc
->u
.s_binary
.right
,
5481 return debug_make_function_type (dhandle
, dt
, pargs
, varargs
);
5484 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
5490 /* We print this component in order to find out the type name.
5491 FIXME: Should we instead expose the
5492 demangle_builtin_type_info structure? */
5493 p
= cplus_demangle_print (DMGL_PARAMS
| demangle_flags
, dc
, 20, &alc
);
5496 fprintf (stderr
, _("Couldn't get demangled builtin type\n"));
5500 /* The mangling is based on the type, but does not itself
5501 indicate what the sizes are. So we have to guess. */
5502 if (strcmp (p
, "signed char") == 0)
5503 ret
= debug_make_int_type (dhandle
, 1, false);
5504 else if (strcmp (p
, "bool") == 0)
5505 ret
= debug_make_bool_type (dhandle
, 1);
5506 else if (strcmp (p
, "char") == 0)
5507 ret
= debug_make_int_type (dhandle
, 1, false);
5508 else if (strcmp (p
, "double") == 0)
5509 ret
= debug_make_float_type (dhandle
, 8);
5510 else if (strcmp (p
, "long double") == 0)
5511 ret
= debug_make_float_type (dhandle
, 8);
5512 else if (strcmp (p
, "float") == 0)
5513 ret
= debug_make_float_type (dhandle
, 4);
5514 else if (strcmp (p
, "__float128") == 0)
5515 ret
= debug_make_float_type (dhandle
, 16);
5516 else if (strcmp (p
, "unsigned char") == 0)
5517 ret
= debug_make_int_type (dhandle
, 1, true);
5518 else if (strcmp (p
, "int") == 0)
5519 ret
= debug_make_int_type (dhandle
, 4, false);
5520 else if (strcmp (p
, "unsigned int") == 0)
5521 ret
= debug_make_int_type (dhandle
, 4, true);
5522 else if (strcmp (p
, "long") == 0)
5523 ret
= debug_make_int_type (dhandle
, 4, false);
5524 else if (strcmp (p
, "unsigned long") == 0)
5525 ret
= debug_make_int_type (dhandle
, 4, true);
5526 else if (strcmp (p
, "__int128") == 0)
5527 ret
= debug_make_int_type (dhandle
, 16, false);
5528 else if (strcmp (p
, "unsigned __int128") == 0)
5529 ret
= debug_make_int_type (dhandle
, 16, true);
5530 else if (strcmp (p
, "short") == 0)
5531 ret
= debug_make_int_type (dhandle
, 2, false);
5532 else if (strcmp (p
, "unsigned short") == 0)
5533 ret
= debug_make_int_type (dhandle
, 2, true);
5534 else if (strcmp (p
, "void") == 0)
5535 ret
= debug_make_void_type (dhandle
);
5536 else if (strcmp (p
, "wchar_t") == 0)
5537 ret
= debug_make_int_type (dhandle
, 4, true);
5538 else if (strcmp (p
, "long long") == 0)
5539 ret
= debug_make_int_type (dhandle
, 8, false);
5540 else if (strcmp (p
, "unsigned long long") == 0)
5541 ret
= debug_make_int_type (dhandle
, 8, true);
5542 else if (strcmp (p
, "...") == 0)
5544 if (pvarargs
== NULL
)
5545 fprintf (stderr
, _("Unexpected demangled varargs\n"));
5552 fprintf (stderr
, _("Unrecognized demangled builtin type\n"));