1 /* stabs.c -- Parse stabs debugging information
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2006, 2007, 2008 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor <ian@cygnus.com>.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
23 /* This file contains code which parses stabs debugging information.
24 The organization of this code is based on the gdb stabs reading
25 code. The job it does is somewhat different, because it is not
26 trying to identify the correct address for anything. */
30 #include "libiberty.h"
31 #include "safe-ctype.h"
35 #include "filenames.h"
36 #include "aout/aout64.h"
37 #include "aout/stab_gnu.h"
39 /* The number of predefined XCOFF types. */
41 #define XCOFF_TYPE_COUNT 34
43 /* This structure is used as a handle so that the stab parsing doesn't
44 need to use any static variables. */
50 /* TRUE if this is stabs in sections. */
52 /* The symbol table. */
54 /* The number of symbols. */
56 /* The accumulated file name string. */
58 /* The value of the last N_SO symbol. */
60 /* The value of the start of the file, so that we can handle file
61 relative N_LBRAC and N_RBRAC symbols. */
62 bfd_vma file_start_offset
;
63 /* The offset of the start of the function, so that we can handle
64 function relative N_LBRAC and N_RBRAC symbols. */
65 bfd_vma function_start_offset
;
66 /* The version number of gcc which compiled the current compilation
67 unit, 0 if not compiled by gcc. */
69 /* Whether an N_OPT symbol was seen that was not generated by gcc,
70 so that we can detect the SunPRO compiler. */
71 bfd_boolean n_opt_found
;
72 /* The main file name. */
74 /* A stack of unfinished N_BINCL files. */
75 struct bincl_file
*bincl_stack
;
76 /* A list of finished N_BINCL files. */
77 struct bincl_file
*bincl_list
;
78 /* Whether we are inside a function or not. */
79 bfd_boolean within_function
;
80 /* The address of the end of the function, used if we have seen an
81 N_FUN symbol while in a function. This is -1 if we have not seen
82 an N_FUN (the normal case). */
84 /* The depth of block nesting. */
86 /* List of pending variable definitions. */
87 struct stab_pending_var
*pending
;
88 /* Number of files for which we have types. */
90 /* Lists of types per file. */
91 struct stab_types
**file_types
;
92 /* Predefined XCOFF types. */
93 debug_type xcoff_types
[XCOFF_TYPE_COUNT
];
95 struct stab_tag
*tags
;
96 /* Set by parse_stab_type if it sees a structure defined as a cross
97 reference to itself. Reset by parse_stab_type otherwise. */
98 bfd_boolean self_crossref
;
101 /* A list of these structures is used to hold pending variable
102 definitions seen before the N_LBRAC of a block. */
104 struct stab_pending_var
106 /* Next pending variable definition. */
107 struct stab_pending_var
*next
;
113 enum debug_var_kind kind
;
118 /* A list of these structures is used to hold the types for a single
123 /* Next set of slots for this file. */
124 struct stab_types
*next
;
125 /* Types indexed by type number. */
126 #define STAB_TYPES_SLOTS (16)
127 debug_type types
[STAB_TYPES_SLOTS
];
130 /* We keep a list of undefined tags that we encounter, so that we can
131 fill them in if the tag is later defined. */
135 /* Next undefined tag. */
136 struct stab_tag
*next
;
140 enum debug_type_kind kind
;
141 /* Slot to hold real type when we discover it. If we don't, we fill
142 in an undefined tag type. */
144 /* Indirect type we have created to point at slot. */
148 static char *savestring (const char *, int);
149 static bfd_vma
parse_number (const char **, bfd_boolean
*);
150 static void bad_stab (const char *);
151 static void warn_stab (const char *, const char *);
152 static bfd_boolean parse_stab_string
153 (void *, struct stab_handle
*, int, int, bfd_vma
, const char *);
154 static debug_type parse_stab_type
155 (void *, struct stab_handle
*, const char *, const char **, debug_type
**);
156 static bfd_boolean
parse_stab_type_number (const char **, int *);
157 static debug_type parse_stab_range_type
158 (void *, struct stab_handle
*, const char *, const char **, const int *);
159 static debug_type
parse_stab_sun_builtin_type (void *, const char **);
160 static debug_type
parse_stab_sun_floating_type (void *, const char **);
161 static debug_type
parse_stab_enum_type (void *, const char **);
162 static debug_type parse_stab_struct_type
163 (void *, struct stab_handle
*, const char *, const char **,
164 bfd_boolean
, const int *);
165 static bfd_boolean parse_stab_baseclasses
166 (void *, struct stab_handle
*, const char **, debug_baseclass
**);
167 static bfd_boolean parse_stab_struct_fields
168 (void *, struct stab_handle
*, const char **, debug_field
**, bfd_boolean
*);
169 static bfd_boolean parse_stab_cpp_abbrev
170 (void *, struct stab_handle
*, const char **, debug_field
*);
171 static bfd_boolean parse_stab_one_struct_field
172 (void *, struct stab_handle
*, const char **, const char *,
173 debug_field
*, bfd_boolean
*);
174 static bfd_boolean parse_stab_members
175 (void *, struct stab_handle
*, const char *, const char **, const int *,
177 static debug_type parse_stab_argtypes
178 (void *, struct stab_handle
*, debug_type
, const char *, const char *,
179 debug_type
, const char *, bfd_boolean
, bfd_boolean
, const char **);
180 static bfd_boolean parse_stab_tilde_field
181 (void *, struct stab_handle
*, const char **, const int *, debug_type
*,
183 static debug_type parse_stab_array_type
184 (void *, struct stab_handle
*, const char **, bfd_boolean
);
185 static void push_bincl (struct stab_handle
*, const char *, bfd_vma
);
186 static const char *pop_bincl (struct stab_handle
*);
187 static bfd_boolean
find_excl (struct stab_handle
*, const char *, bfd_vma
);
188 static bfd_boolean stab_record_variable
189 (void *, struct stab_handle
*, const char *, debug_type
,
190 enum debug_var_kind
, bfd_vma
);
191 static bfd_boolean
stab_emit_pending_vars (void *, struct stab_handle
*);
192 static debug_type
*stab_find_slot (struct stab_handle
*, const int *);
193 static debug_type
stab_find_type (void *, struct stab_handle
*, const int *);
194 static bfd_boolean stab_record_type
195 (void *, struct stab_handle
*, const int *, debug_type
);
196 static debug_type stab_xcoff_builtin_type
197 (void *, struct stab_handle
*, int);
198 static debug_type stab_find_tagged_type
199 (void *, struct stab_handle
*, const char *, int, enum debug_type_kind
);
200 static debug_type
*stab_demangle_argtypes
201 (void *, struct stab_handle
*, const char *, bfd_boolean
*, unsigned int);
202 static debug_type
*stab_demangle_v3_argtypes
203 (void *, struct stab_handle
*, const char *, bfd_boolean
*);
204 static debug_type
*stab_demangle_v3_arglist
205 (void *, struct stab_handle
*, struct demangle_component
*, bfd_boolean
*);
206 static debug_type stab_demangle_v3_arg
207 (void *, struct stab_handle
*, struct demangle_component
*, debug_type
,
210 /* Save a string in memory. */
213 savestring (const char *start
, int len
)
217 ret
= (char *) xmalloc (len
+ 1);
218 memcpy (ret
, start
, len
);
223 /* Read a number from a string. */
226 parse_number (const char **pp
, bfd_boolean
*poverflow
)
231 if (poverflow
!= NULL
)
237 ul
= strtoul (*pp
, (char **) pp
, 0);
238 if (ul
+ 1 != 0 || errno
== 0)
240 /* If bfd_vma is larger than unsigned long, and the number is
241 meant to be negative, we have to make sure that we sign
244 return (bfd_vma
) (bfd_signed_vma
) (long) ul
;
248 /* Note that even though strtoul overflowed, it should have set *pp
249 to the end of the number, which is where we want it. */
250 if (sizeof (bfd_vma
) > sizeof (unsigned long))
255 bfd_vma over
, lastdig
;
256 bfd_boolean overflow
;
259 /* Our own version of strtoul, for a bfd_vma. */
274 if (p
[1] == 'x' || p
[1] == 'X')
286 over
= ((bfd_vma
) (bfd_signed_vma
) -1) / (bfd_vma
) base
;
287 lastdig
= ((bfd_vma
) (bfd_signed_vma
) -1) % (bfd_vma
) base
;
298 else if (ISUPPER (d
))
300 else if (ISLOWER (d
))
308 if (v
> over
|| (v
== over
&& (bfd_vma
) d
> lastdig
))
323 /* If we get here, the number is too large to represent in a
325 if (poverflow
!= NULL
)
328 warn_stab (orig
, _("numeric overflow"));
333 /* Give an error for a bad stab string. */
336 bad_stab (const char *p
)
338 fprintf (stderr
, _("Bad stab: %s\n"), p
);
341 /* Warn about something in a stab string. */
344 warn_stab (const char *p
, const char *err
)
346 fprintf (stderr
, _("Warning: %s: %s\n"), err
, p
);
349 /* Create a handle to parse stabs symbols with. */
352 start_stab (void *dhandle ATTRIBUTE_UNUSED
, bfd
*abfd
, bfd_boolean sections
,
353 asymbol
**syms
, long symcount
)
355 struct stab_handle
*ret
;
357 ret
= (struct stab_handle
*) xmalloc (sizeof *ret
);
358 memset (ret
, 0, sizeof *ret
);
360 ret
->sections
= sections
;
362 ret
->symcount
= symcount
;
364 ret
->file_types
= (struct stab_types
**) xmalloc (sizeof *ret
->file_types
);
365 ret
->file_types
[0] = NULL
;
366 ret
->function_end
= (bfd_vma
) -1;
370 /* When we have processed all the stabs information, we need to go
371 through and fill in all the undefined tags. */
374 finish_stab (void *dhandle
, void *handle
)
376 struct stab_handle
*info
= (struct stab_handle
*) handle
;
379 if (info
->within_function
)
381 if (! stab_emit_pending_vars (dhandle
, info
)
382 || ! debug_end_function (dhandle
, info
->function_end
))
384 info
->within_function
= FALSE
;
385 info
->function_end
= (bfd_vma
) -1;
388 for (st
= info
->tags
; st
!= NULL
; st
= st
->next
)
390 enum debug_type_kind kind
;
393 if (kind
== DEBUG_KIND_ILLEGAL
)
394 kind
= DEBUG_KIND_STRUCT
;
395 st
->slot
= debug_make_undefined_tagged_type (dhandle
, st
->name
, kind
);
396 if (st
->slot
== DEBUG_TYPE_NULL
)
403 /* Handle a single stabs symbol. */
406 parse_stab (void *dhandle
, void *handle
, int type
, int desc
, bfd_vma value
,
409 struct stab_handle
*info
= (struct stab_handle
*) handle
;
411 /* gcc will emit two N_SO strings per compilation unit, one for the
412 directory name and one for the file name. We just collect N_SO
413 strings as we see them, and start the new compilation unit when
414 we see a non N_SO symbol. */
415 if (info
->so_string
!= NULL
416 && (type
!= N_SO
|| *string
== '\0' || value
!= info
->so_value
))
418 if (! debug_set_filename (dhandle
, info
->so_string
))
420 info
->main_filename
= info
->so_string
;
422 info
->gcc_compiled
= 0;
423 info
->n_opt_found
= FALSE
;
425 /* Generally, for stabs in the symbol table, the N_LBRAC and
426 N_RBRAC symbols are relative to the N_SO symbol value. */
427 if (! info
->sections
)
428 info
->file_start_offset
= info
->so_value
;
430 /* We need to reset the mapping from type numbers to types. We
431 can't free the old mapping, because of the use of
432 debug_make_indirect_type. */
434 info
->file_types
= ((struct stab_types
**)
435 xmalloc (sizeof *info
->file_types
));
436 info
->file_types
[0] = NULL
;
438 info
->so_string
= NULL
;
440 /* Now process whatever type we just got. */
450 /* Ignore extra outermost context from SunPRO cc and acc. */
451 if (info
->n_opt_found
&& desc
== 1)
454 if (! info
->within_function
)
456 fprintf (stderr
, _("N_LBRAC not within function\n"));
460 /* Start an inner lexical block. */
461 if (! debug_start_block (dhandle
,
463 + info
->file_start_offset
464 + info
->function_start_offset
)))
467 /* Emit any pending variable definitions. */
468 if (! stab_emit_pending_vars (dhandle
, info
))
475 /* Ignore extra outermost context from SunPRO cc and acc. */
476 if (info
->n_opt_found
&& desc
== 1)
479 /* We shouldn't have any pending variable definitions here, but,
480 if we do, we probably need to emit them before closing the
482 if (! stab_emit_pending_vars (dhandle
, info
))
485 /* End an inner lexical block. */
486 if (! debug_end_block (dhandle
,
488 + info
->file_start_offset
489 + info
->function_start_offset
)))
493 if (info
->block_depth
< 0)
495 fprintf (stderr
, _("Too many N_RBRACs\n"));
501 /* This always ends a function. */
502 if (info
->within_function
)
508 && info
->function_end
!= (bfd_vma
) -1
509 && info
->function_end
< endval
)
510 endval
= info
->function_end
;
511 if (! stab_emit_pending_vars (dhandle
, info
)
512 || ! debug_end_function (dhandle
, endval
))
514 info
->within_function
= FALSE
;
515 info
->function_end
= (bfd_vma
) -1;
518 /* An empty string is emitted by gcc at the end of a compilation
523 /* Just accumulate strings until we see a non N_SO symbol. If
524 the string starts with a directory separator or some other
525 form of absolute path specification, we discard the previously
526 accumulated strings. */
527 if (info
->so_string
== NULL
)
528 info
->so_string
= xstrdup (string
);
535 if (IS_ABSOLUTE_PATH (string
))
536 info
->so_string
= xstrdup (string
);
538 info
->so_string
= concat (info
->so_string
, string
,
539 (const char *) NULL
);
543 info
->so_value
= value
;
548 /* Start an include file. */
549 if (! debug_start_source (dhandle
, string
))
554 /* Start an include file which may be replaced. */
555 push_bincl (info
, string
, value
);
556 if (! debug_start_source (dhandle
, string
))
561 /* End an N_BINCL include. */
562 if (! debug_start_source (dhandle
, pop_bincl (info
)))
567 /* This is a duplicate of a header file named by N_BINCL which
568 was eliminated by the linker. */
569 if (! find_excl (info
, string
, value
))
574 if (! debug_record_line (dhandle
, desc
,
575 value
+ (info
->within_function
576 ? info
->function_start_offset
: 0)))
581 if (! debug_start_common_block (dhandle
, string
))
586 if (! debug_end_common_block (dhandle
, string
))
593 if (info
->within_function
)
595 /* This always marks the end of a function; we don't
596 need to worry about info->function_end. */
598 value
+= info
->function_start_offset
;
599 if (! stab_emit_pending_vars (dhandle
, info
)
600 || ! debug_end_function (dhandle
, value
))
602 info
->within_function
= FALSE
;
603 info
->function_end
= (bfd_vma
) -1;
608 /* A const static symbol in the .text section will have an N_FUN
609 entry. We need to use these to mark the end of the function,
610 in case we are looking at gcc output before it was changed to
611 always emit an empty N_FUN. We can't call debug_end_function
612 here, because it might be a local static symbol. */
613 if (info
->within_function
614 && (info
->function_end
== (bfd_vma
) -1
615 || value
< info
->function_end
))
616 info
->function_end
= value
;
619 /* FIXME: gdb checks the string for N_STSYM, N_LCSYM or N_ROSYM
620 symbols, and if it does not start with :S, gdb relocates the
621 value to the start of the section. gcc always seems to use
622 :S, so we don't worry about this. */
628 colon
= strchr (string
, ':');
630 && (colon
[1] == 'f' || colon
[1] == 'F'))
632 if (info
->within_function
)
637 if (info
->function_end
!= (bfd_vma
) -1
638 && info
->function_end
< endval
)
639 endval
= info
->function_end
;
640 if (! stab_emit_pending_vars (dhandle
, info
)
641 || ! debug_end_function (dhandle
, endval
))
643 info
->function_end
= (bfd_vma
) -1;
645 /* For stabs in sections, line numbers and block addresses
646 are offsets from the start of the function. */
648 info
->function_start_offset
= value
;
649 info
->within_function
= TRUE
;
652 if (! parse_stab_string (dhandle
, info
, type
, desc
, value
, string
))
658 if (string
!= NULL
&& strcmp (string
, "gcc2_compiled.") == 0)
659 info
->gcc_compiled
= 2;
660 else if (string
!= NULL
&& strcmp (string
, "gcc_compiled.") == 0)
661 info
->gcc_compiled
= 1;
663 info
->n_opt_found
= TRUE
;
676 /* Parse the stabs string. */
679 parse_stab_string (void *dhandle
, struct stab_handle
*info
, int stabtype
,
680 int desc
, bfd_vma value
, const char *string
)
687 bfd_boolean self_crossref
;
691 p
= strchr (string
, ':');
706 /* GCC 2.x puts the line number in desc. SunOS apparently puts in
707 the number of bytes occupied by a type or object, which we
709 if (info
->gcc_compiled
>= 2)
714 /* FIXME: Sometimes the special C++ names start with '.'. */
716 if (string
[0] == '$')
724 /* Was: name = "vptr"; */
730 /* This was an anonymous type that was never fixed up. */
733 /* SunPRO (3.0 at least) static variable encoding. */
736 warn_stab (string
, _("unknown C++ encoded name"));
743 if (p
== string
|| (string
[0] == ' ' && p
== string
+ 1))
746 name
= savestring (string
, p
- string
);
750 if (ISDIGIT (*p
) || *p
== '(' || *p
== '-')
758 /* c is a special case, not followed by a type-number.
759 SYMBOL:c=iVALUE for an integer constant symbol.
760 SYMBOL:c=rVALUE for a floating constant symbol.
761 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
762 e.g. "b:c=e6,0" for "const b = blob1"
763 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
773 /* Floating point constant. */
774 if (! debug_record_float_const (dhandle
, name
, atof (p
)))
778 /* Integer constant. */
779 /* Defining integer constants this way is kind of silly,
780 since 'e' constants allows the compiler to give not only
781 the value, but the type as well. C has at least int,
782 long, unsigned int, and long long as constant types;
783 other languages probably should have at least unsigned as
784 well as signed constants. */
785 if (! debug_record_int_const (dhandle
, name
, atoi (p
)))
789 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
790 can be represented as integral.
791 e.g. "b:c=e6,0" for "const b = blob1"
792 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
793 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
794 &p
, (debug_type
**) NULL
);
795 if (dtype
== DEBUG_TYPE_NULL
)
802 if (! debug_record_typed_const (dhandle
, name
, dtype
, atoi (p
)))
813 /* The name of a caught exception. */
814 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
815 &p
, (debug_type
**) NULL
);
816 if (dtype
== DEBUG_TYPE_NULL
)
818 if (! debug_record_label (dhandle
, name
, dtype
, value
))
824 /* A function definition. */
825 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
826 (debug_type
**) NULL
);
827 if (dtype
== DEBUG_TYPE_NULL
)
829 if (! debug_record_function (dhandle
, name
, dtype
, type
== 'F', value
))
832 /* Sun acc puts declared types of arguments here. We don't care
833 about their actual types (FIXME -- we should remember the whole
834 function prototype), but the list may define some new types
835 that we have to remember, so we must scan it now. */
839 if (parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
840 (debug_type
**) NULL
)
853 /* A global symbol. The value must be extracted from the
855 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
856 (debug_type
**) NULL
);
857 if (dtype
== DEBUG_TYPE_NULL
)
859 leading
= bfd_get_symbol_leading_char (info
->abfd
);
860 for (c
= info
->symcount
, ps
= info
->syms
; c
> 0; --c
, ++ps
)
864 n
= bfd_asymbol_name (*ps
);
865 if (leading
!= '\0' && *n
== leading
)
867 if (*n
== *name
&& strcmp (n
, name
) == 0)
871 value
= bfd_asymbol_value (*ps
);
872 if (! stab_record_variable (dhandle
, info
, name
, dtype
, DEBUG_GLOBAL
,
878 /* This case is faked by a conditional above, when there is no
879 code letter in the dbx data. Dbx data never actually
883 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
884 (debug_type
**) NULL
);
885 if (dtype
== DEBUG_TYPE_NULL
)
887 if (! stab_record_variable (dhandle
, info
, name
, dtype
, DEBUG_LOCAL
,
893 /* A function parameter. */
895 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
896 (debug_type
**) NULL
);
899 /* pF is a two-letter code that means a function parameter in
900 Fortran. The type-number specifies the type of the return
901 value. Translate it into a pointer-to-function type. */
903 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
904 (debug_type
**) NULL
);
905 if (dtype
!= DEBUG_TYPE_NULL
)
909 ftype
= debug_make_function_type (dhandle
, dtype
,
910 (debug_type
*) NULL
, FALSE
);
911 dtype
= debug_make_pointer_type (dhandle
, ftype
);
914 if (dtype
== DEBUG_TYPE_NULL
)
916 if (! debug_record_parameter (dhandle
, name
, dtype
, DEBUG_PARM_STACK
,
920 /* FIXME: At this point gdb considers rearranging the parameter
921 address on a big endian machine if it is smaller than an int.
922 We have no way to do that, since we don't really know much
927 if (stabtype
== N_FUN
)
929 /* Prototype of a function referenced by this file. */
933 if (parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
934 (debug_type
**) NULL
)
942 /* Parameter which is in a register. */
943 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
944 (debug_type
**) NULL
);
945 if (dtype
== DEBUG_TYPE_NULL
)
947 if (! debug_record_parameter (dhandle
, name
, dtype
, DEBUG_PARM_REG
,
953 /* Register variable (either global or local). */
954 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
955 (debug_type
**) NULL
);
956 if (dtype
== DEBUG_TYPE_NULL
)
958 if (! stab_record_variable (dhandle
, info
, name
, dtype
, DEBUG_REGISTER
,
962 /* FIXME: At this point gdb checks to combine pairs of 'p' and
963 'r' stabs into a single 'P' stab. */
967 /* Static symbol at top level of file. */
968 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
969 (debug_type
**) NULL
);
970 if (dtype
== DEBUG_TYPE_NULL
)
972 if (! stab_record_variable (dhandle
, info
, name
, dtype
, DEBUG_STATIC
,
979 dtype
= parse_stab_type (dhandle
, info
, name
, &p
, &slot
);
980 if (dtype
== DEBUG_TYPE_NULL
)
984 /* A nameless type. Nothing to do. */
988 dtype
= debug_name_type (dhandle
, name
, dtype
);
989 if (dtype
== DEBUG_TYPE_NULL
)
998 /* Struct, union, or enum tag. For GNU C++, this can be be followed
999 by 't' which means we are typedef'ing it as well. */
1003 /* FIXME: gdb sets synonym to TRUE if the current language
1012 dtype
= parse_stab_type (dhandle
, info
, name
, &p
, &slot
);
1013 if (dtype
== DEBUG_TYPE_NULL
)
1018 /* INFO->SELF_CROSSREF is set by parse_stab_type if this type is
1019 a cross reference to itself. These are generated by some
1021 self_crossref
= info
->self_crossref
;
1023 dtype
= debug_tag_type (dhandle
, name
, dtype
);
1024 if (dtype
== DEBUG_TYPE_NULL
)
1029 /* See if we have a cross reference to this tag which we can now
1030 fill in. Avoid filling in a cross reference to ourselves,
1031 because that would lead to circular debugging information. */
1032 if (! self_crossref
)
1034 register struct stab_tag
**pst
;
1036 for (pst
= &info
->tags
; *pst
!= NULL
; pst
= &(*pst
)->next
)
1038 if ((*pst
)->name
[0] == name
[0]
1039 && strcmp ((*pst
)->name
, name
) == 0)
1041 (*pst
)->slot
= dtype
;
1042 *pst
= (*pst
)->next
;
1050 dtype
= debug_name_type (dhandle
, name
, dtype
);
1051 if (dtype
== DEBUG_TYPE_NULL
)
1061 /* Static symbol of local scope */
1062 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
1063 (debug_type
**) NULL
);
1064 if (dtype
== DEBUG_TYPE_NULL
)
1066 /* FIXME: gdb checks os9k_stabs here. */
1067 if (! stab_record_variable (dhandle
, info
, name
, dtype
,
1068 DEBUG_LOCAL_STATIC
, value
))
1073 /* Reference parameter. */
1074 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
1075 (debug_type
**) NULL
);
1076 if (dtype
== DEBUG_TYPE_NULL
)
1078 if (! debug_record_parameter (dhandle
, name
, dtype
, DEBUG_PARM_REFERENCE
,
1084 /* Reference parameter which is in a register. */
1085 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
1086 (debug_type
**) NULL
);
1087 if (dtype
== DEBUG_TYPE_NULL
)
1089 if (! debug_record_parameter (dhandle
, name
, dtype
, DEBUG_PARM_REF_REG
,
1095 /* This is used by Sun FORTRAN for "function result value".
1096 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1097 that Pascal uses it too, but when I tried it Pascal used
1098 "x:3" (local symbol) instead. */
1099 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, &p
,
1100 (debug_type
**) NULL
);
1101 if (dtype
== DEBUG_TYPE_NULL
)
1103 if (! stab_record_variable (dhandle
, info
, name
, dtype
, DEBUG_LOCAL
,
1113 /* FIXME: gdb converts structure values to structure pointers in a
1114 couple of cases, depending upon the target. */
1119 /* Parse a stabs type. The typename argument is non-NULL if this is a
1120 typedef or a tag definition. The pp argument points to the stab
1121 string, and is updated. The slotp argument points to a place to
1122 store the slot used if the type is being defined. */
1125 parse_stab_type (void *dhandle
, struct stab_handle
*info
, const char *typename
, const char **pp
, debug_type
**slotp
)
1130 bfd_boolean stringp
;
1142 info
->self_crossref
= FALSE
;
1144 /* Read type number if present. The type number may be omitted.
1145 for instance in a two-dimensional array declared with type
1146 "ar1;1;10;ar1;1;10;4". */
1147 if (! ISDIGIT (**pp
) && **pp
!= '(' && **pp
!= '-')
1149 /* 'typenums=' not present, type is anonymous. Read and return
1150 the definition, but don't put it in the type vector. */
1151 typenums
[0] = typenums
[1] = -1;
1155 if (! parse_stab_type_number (pp
, typenums
))
1156 return DEBUG_TYPE_NULL
;
1159 /* Type is not being defined here. Either it already
1160 exists, or this is a forward reference to it. */
1161 return stab_find_type (dhandle
, info
, typenums
);
1163 /* Only set the slot if the type is being defined. This means
1164 that the mapping from type numbers to types will only record
1165 the name of the typedef which defines a type. If we don't do
1166 this, then something like
1169 will record that i is of type foo. Unfortunately, stabs
1170 information is ambiguous about variable types. For this code,
1174 the stabs information records both i and j as having the same
1175 type. This could be fixed by patching the compiler. */
1176 if (slotp
!= NULL
&& typenums
[0] >= 0 && typenums
[1] >= 0)
1177 *slotp
= stab_find_slot (info
, typenums
);
1179 /* Type is being defined here. */
1185 const char *p
= *pp
+ 1;
1188 if (ISDIGIT (*p
) || *p
== '(' || *p
== '-')
1192 /* Type attributes. */
1195 for (; *p
!= ';'; ++p
)
1200 return DEBUG_TYPE_NULL
;
1208 size
= atoi (attr
+ 1);
1209 size
/= 8; /* Size is in bits. We store it in bytes. */
1219 /* Ignore unrecognized type attributes, so future
1220 compilers can invent new ones. */
1233 enum debug_type_kind code
;
1234 const char *q1
, *q2
, *p
;
1236 /* A cross reference to another type. */
1240 code
= DEBUG_KIND_STRUCT
;
1243 code
= DEBUG_KIND_UNION
;
1246 code
= DEBUG_KIND_ENUM
;
1249 /* Complain and keep going, so compilers can invent new
1250 cross-reference types. */
1251 warn_stab (orig
, _("unrecognized cross reference type"));
1252 code
= DEBUG_KIND_STRUCT
;
1257 q1
= strchr (*pp
, '<');
1258 p
= strchr (*pp
, ':');
1262 return DEBUG_TYPE_NULL
;
1264 if (q1
!= NULL
&& p
> q1
&& p
[1] == ':')
1268 for (q2
= q1
; *q2
!= '\0'; ++q2
)
1272 else if (*q2
== '>')
1274 else if (*q2
== ':' && nest
== 0)
1281 return DEBUG_TYPE_NULL
;
1285 /* Some versions of g++ can emit stabs like
1287 which define structures in terms of themselves. We need to
1288 tell the caller to avoid building a circular structure. */
1289 if (typename
!= NULL
1290 && strncmp (typename
, *pp
, p
- *pp
) == 0
1291 && typename
[p
- *pp
] == '\0')
1292 info
->self_crossref
= TRUE
;
1294 dtype
= stab_find_tagged_type (dhandle
, info
, *pp
, p
- *pp
, code
);
1316 /* This type is defined as another type. */
1320 /* Peek ahead at the number to detect void. */
1321 if (! parse_stab_type_number (pp
, xtypenums
))
1322 return DEBUG_TYPE_NULL
;
1324 if (typenums
[0] == xtypenums
[0] && typenums
[1] == xtypenums
[1])
1326 /* This type is being defined as itself, which means that
1328 dtype
= debug_make_void_type (dhandle
);
1334 /* Go back to the number and have parse_stab_type get it.
1335 This means that we can deal with something like
1336 t(1,2)=(3,4)=... which the Lucid compiler uses. */
1337 dtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
1338 pp
, (debug_type
**) NULL
);
1339 if (dtype
== DEBUG_TYPE_NULL
)
1340 return DEBUG_TYPE_NULL
;
1343 if (typenums
[0] != -1)
1345 if (! stab_record_type (dhandle
, info
, typenums
, dtype
))
1346 return DEBUG_TYPE_NULL
;
1353 dtype
= debug_make_pointer_type (dhandle
,
1354 parse_stab_type (dhandle
, info
,
1355 (const char *) NULL
,
1357 (debug_type
**) NULL
));
1361 /* Reference to another type. */
1362 dtype
= (debug_make_reference_type
1364 parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
1365 (debug_type
**) NULL
)));
1369 /* Function returning another type. */
1370 /* FIXME: gdb checks os9k_stabs here. */
1371 dtype
= (debug_make_function_type
1373 parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
1374 (debug_type
**) NULL
),
1375 (debug_type
*) NULL
, FALSE
));
1379 /* Const qualifier on some type (Sun). */
1380 /* FIXME: gdb accepts 'c' here if os9k_stabs. */
1381 dtype
= debug_make_const_type (dhandle
,
1382 parse_stab_type (dhandle
, info
,
1383 (const char *) NULL
,
1385 (debug_type
**) NULL
));
1389 /* Volatile qual on some type (Sun). */
1390 /* FIXME: gdb accepts 'i' here if os9k_stabs. */
1391 dtype
= (debug_make_volatile_type
1393 parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
1394 (debug_type
**) NULL
)));
1398 /* Offset (class & variable) type. This is used for a pointer
1399 relative to an object. */
1406 domain
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
1407 (debug_type
**) NULL
);
1408 if (domain
== DEBUG_TYPE_NULL
)
1409 return DEBUG_TYPE_NULL
;
1414 return DEBUG_TYPE_NULL
;
1418 memtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
1419 (debug_type
**) NULL
);
1420 if (memtype
== DEBUG_TYPE_NULL
)
1421 return DEBUG_TYPE_NULL
;
1423 dtype
= debug_make_offset_type (dhandle
, domain
, memtype
);
1428 /* Method (class & fn) type. */
1431 debug_type return_type
;
1434 return_type
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
1435 pp
, (debug_type
**) NULL
);
1436 if (return_type
== DEBUG_TYPE_NULL
)
1437 return DEBUG_TYPE_NULL
;
1441 return DEBUG_TYPE_NULL
;
1444 dtype
= debug_make_method_type (dhandle
, return_type
,
1446 (debug_type
*) NULL
, FALSE
);
1451 debug_type return_type
;
1455 bfd_boolean varargs
;
1457 domain
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
1458 pp
, (debug_type
**) NULL
);
1459 if (domain
== DEBUG_TYPE_NULL
)
1460 return DEBUG_TYPE_NULL
;
1465 return DEBUG_TYPE_NULL
;
1469 return_type
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
1470 pp
, (debug_type
**) NULL
);
1471 if (return_type
== DEBUG_TYPE_NULL
)
1472 return DEBUG_TYPE_NULL
;
1475 args
= (debug_type
*) xmalloc (alloc
* sizeof *args
);
1482 return DEBUG_TYPE_NULL
;
1489 args
= ((debug_type
*)
1490 xrealloc (args
, alloc
* sizeof *args
));
1493 args
[n
] = parse_stab_type (dhandle
, info
, (const char *) NULL
,
1494 pp
, (debug_type
**) NULL
);
1495 if (args
[n
] == DEBUG_TYPE_NULL
)
1496 return DEBUG_TYPE_NULL
;
1501 /* If the last type is not void, then this function takes a
1502 variable number of arguments. Otherwise, we must strip
1505 || debug_get_type_kind (dhandle
, args
[n
- 1]) != DEBUG_KIND_VOID
)
1513 args
[n
] = DEBUG_TYPE_NULL
;
1515 dtype
= debug_make_method_type (dhandle
, return_type
, domain
, args
,
1522 dtype
= parse_stab_range_type (dhandle
, info
, typename
, pp
, typenums
);
1526 /* FIXME: gdb checks os9k_stabs here. */
1527 /* Sun ACC builtin int type. */
1528 dtype
= parse_stab_sun_builtin_type (dhandle
, pp
);
1532 /* Sun ACC builtin float type. */
1533 dtype
= parse_stab_sun_floating_type (dhandle
, pp
);
1537 /* Enumeration type. */
1538 dtype
= parse_stab_enum_type (dhandle
, pp
);
1543 /* Struct or union type. */
1544 dtype
= parse_stab_struct_type (dhandle
, info
, typename
, pp
,
1545 descriptor
== 's', typenums
);
1553 return DEBUG_TYPE_NULL
;
1557 dtype
= parse_stab_array_type (dhandle
, info
, pp
, stringp
);
1561 dtype
= debug_make_set_type (dhandle
,
1562 parse_stab_type (dhandle
, info
,
1563 (const char *) NULL
,
1565 (debug_type
**) NULL
),
1571 return DEBUG_TYPE_NULL
;
1574 if (dtype
== DEBUG_TYPE_NULL
)
1575 return DEBUG_TYPE_NULL
;
1577 if (typenums
[0] != -1)
1579 if (! stab_record_type (dhandle
, info
, typenums
, dtype
))
1580 return DEBUG_TYPE_NULL
;
1585 if (! debug_record_type_size (dhandle
, dtype
, (unsigned int) size
))
1586 return DEBUG_TYPE_NULL
;
1592 /* Read a number by which a type is referred to in dbx data, or
1593 perhaps read a pair (FILENUM, TYPENUM) in parentheses. Just a
1594 single number N is equivalent to (0,N). Return the two numbers by
1595 storing them in the vector TYPENUMS. */
1598 parse_stab_type_number (const char **pp
, int *typenums
)
1607 typenums
[1] = (int) parse_number (pp
, (bfd_boolean
*) NULL
);
1612 typenums
[0] = (int) parse_number (pp
, (bfd_boolean
*) NULL
);
1619 typenums
[1] = (int) parse_number (pp
, (bfd_boolean
*) NULL
);
1631 /* Parse a range type. */
1634 parse_stab_range_type (void *dhandle
, struct stab_handle
*info
, const char *typename
, const char **pp
, const int *typenums
)
1638 bfd_boolean self_subrange
;
1639 debug_type index_type
;
1640 const char *s2
, *s3
;
1641 bfd_signed_vma n2
, n3
;
1642 bfd_boolean ov2
, ov3
;
1646 index_type
= DEBUG_TYPE_NULL
;
1648 /* First comes a type we are a subrange of.
1649 In C it is usually 0, 1 or the type being defined. */
1650 if (! parse_stab_type_number (pp
, rangenums
))
1651 return DEBUG_TYPE_NULL
;
1653 self_subrange
= (rangenums
[0] == typenums
[0]
1654 && rangenums
[1] == typenums
[1]);
1659 index_type
= parse_stab_type (dhandle
, info
, (const char *) NULL
,
1660 pp
, (debug_type
**) NULL
);
1661 if (index_type
== DEBUG_TYPE_NULL
)
1662 return DEBUG_TYPE_NULL
;
1668 /* The remaining two operands are usually lower and upper bounds of
1669 the range. But in some special cases they mean something else. */
1671 n2
= parse_number (pp
, &ov2
);
1675 return DEBUG_TYPE_NULL
;
1680 n3
= parse_number (pp
, &ov3
);
1684 return DEBUG_TYPE_NULL
;
1690 /* gcc will emit range stabs for long long types. Handle this
1691 as a special case. FIXME: This needs to be more general. */
1692 #define LLLOW "01000000000000000000000;"
1693 #define LLHIGH "0777777777777777777777;"
1694 #define ULLHIGH "01777777777777777777777;"
1695 if (index_type
== DEBUG_TYPE_NULL
)
1697 if (CONST_STRNEQ (s2
, LLLOW
)
1698 && CONST_STRNEQ (s3
, LLHIGH
))
1699 return debug_make_int_type (dhandle
, 8, FALSE
);
1702 && CONST_STRNEQ (s3
, ULLHIGH
))
1703 return debug_make_int_type (dhandle
, 8, TRUE
);
1706 warn_stab (orig
, _("numeric overflow"));
1709 if (index_type
== DEBUG_TYPE_NULL
)
1711 /* A type defined as a subrange of itself, with both bounds 0,
1713 if (self_subrange
&& n2
== 0 && n3
== 0)
1714 return debug_make_void_type (dhandle
);
1716 /* A type defined as a subrange of itself, with n2 positive and
1717 n3 zero, is a complex type, and n2 is the number of bytes. */
1718 if (self_subrange
&& n3
== 0 && n2
> 0)
1719 return debug_make_complex_type (dhandle
, n2
);
1721 /* If n3 is zero and n2 is positive, this is a floating point
1722 type, and n2 is the number of bytes. */
1723 if (n3
== 0 && n2
> 0)
1724 return debug_make_float_type (dhandle
, n2
);
1726 /* If the upper bound is -1, this is an unsigned int. */
1727 if (n2
== 0 && n3
== -1)
1729 /* When gcc is used with -gstabs, but not -gstabs+, it will emit
1730 long long int:t6=r1;0;-1;
1731 long long unsigned int:t7=r1;0;-1;
1732 We hack here to handle this reasonably. */
1733 if (typename
!= NULL
)
1735 if (strcmp (typename
, "long long int") == 0)
1736 return debug_make_int_type (dhandle
, 8, FALSE
);
1737 else if (strcmp (typename
, "long long unsigned int") == 0)
1738 return debug_make_int_type (dhandle
, 8, TRUE
);
1740 /* FIXME: The size here really depends upon the target. */
1741 return debug_make_int_type (dhandle
, 4, TRUE
);
1744 /* A range of 0 to 127 is char. */
1745 if (self_subrange
&& n2
== 0 && n3
== 127)
1746 return debug_make_int_type (dhandle
, 1, FALSE
);
1748 /* FIXME: gdb checks for the language CHILL here. */
1753 return debug_make_int_type (dhandle
, - n3
, TRUE
);
1754 else if (n3
== 0xff)
1755 return debug_make_int_type (dhandle
, 1, TRUE
);
1756 else if (n3
== 0xffff)
1757 return debug_make_int_type (dhandle
, 2, TRUE
);
1758 else if (n3
== (bfd_signed_vma
) 0xffffffff)
1759 return debug_make_int_type (dhandle
, 4, TRUE
);
1761 else if (n3
== ((((bfd_signed_vma
) 0xffffffff) << 32) | 0xffffffff))
1762 return debug_make_int_type (dhandle
, 8, TRUE
);
1767 && (self_subrange
|| n2
== -8))
1768 return debug_make_int_type (dhandle
, - n2
, TRUE
);
1769 else if (n2
== - n3
- 1 || n2
== n3
+ 1)
1772 return debug_make_int_type (dhandle
, 1, FALSE
);
1773 else if (n3
== 0x7fff)
1774 return debug_make_int_type (dhandle
, 2, FALSE
);
1775 else if (n3
== 0x7fffffff)
1776 return debug_make_int_type (dhandle
, 4, FALSE
);
1778 else if (n3
== ((((bfd_vma
) 0x7fffffff) << 32) | 0xffffffff))
1779 return debug_make_int_type (dhandle
, 8, FALSE
);
1784 /* At this point I don't have the faintest idea how to deal with a
1785 self_subrange type; I'm going to assume that this is used as an
1786 idiom, and that all of them are special cases. So . . . */
1790 return DEBUG_TYPE_NULL
;
1793 index_type
= stab_find_type (dhandle
, info
, rangenums
);
1794 if (index_type
== DEBUG_TYPE_NULL
)
1796 /* Does this actually ever happen? Is that why we are worrying
1797 about dealing with it rather than just calling error_type? */
1798 warn_stab (orig
, _("missing index type"));
1799 index_type
= debug_make_int_type (dhandle
, 4, FALSE
);
1802 return debug_make_range_type (dhandle
, index_type
, n2
, n3
);
1805 /* Sun's ACC uses a somewhat saner method for specifying the builtin
1806 typedefs in every file (for int, long, etc):
1808 type = b <signed> <width>; <offset>; <nbits>
1809 signed = u or s. Possible c in addition to u or s (for char?).
1810 offset = offset from high order bit to start bit of type.
1811 width is # bytes in object of this type, nbits is # bits in type.
1813 The width/offset stuff appears to be for small objects stored in
1814 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
1818 parse_stab_sun_builtin_type (void *dhandle
, const char **pp
)
1821 bfd_boolean unsignedp
;
1836 return DEBUG_TYPE_NULL
;
1840 /* OpenSolaris source code indicates that one of "cbv" characters
1841 can come next and specify the intrinsic 'iformat' encoding.
1842 'c' is character encoding, 'b' is boolean encoding, and 'v' is
1843 varargs encoding. This field can be safely ignored because
1844 the type of the field is determined from the bitwidth extracted
1846 if (**pp
== 'c' || **pp
== 'b' || **pp
== 'v')
1849 /* The first number appears to be the number of bytes occupied
1850 by this type, except that unsigned short is 4 instead of 2.
1851 Since this information is redundant with the third number,
1852 we will ignore it. */
1853 (void) parse_number (pp
, (bfd_boolean
*) NULL
);
1857 return DEBUG_TYPE_NULL
;
1861 /* The second number is always 0, so ignore it too. */
1862 (void) parse_number (pp
, (bfd_boolean
*) NULL
);
1866 return DEBUG_TYPE_NULL
;
1870 /* The third number is the number of bits for this type. */
1871 bits
= parse_number (pp
, (bfd_boolean
*) NULL
);
1873 /* The type *should* end with a semicolon. If it are embedded
1874 in a larger type the semicolon may be the only way to know where
1875 the type ends. If this type is at the end of the stabstring we
1876 can deal with the omitted semicolon (but we don't have to like
1877 it). Don't bother to complain(), Sun's compiler omits the semicolon
1883 return debug_make_void_type (dhandle
);
1885 return debug_make_int_type (dhandle
, bits
/ 8, unsignedp
);
1888 /* Parse a builtin floating type generated by the Sun compiler. */
1891 parse_stab_sun_floating_type (void *dhandle
, const char **pp
)
1899 /* The first number has more details about the type, for example
1901 details
= parse_number (pp
, (bfd_boolean
*) NULL
);
1905 return DEBUG_TYPE_NULL
;
1908 /* The second number is the number of bytes occupied by this type */
1909 bytes
= parse_number (pp
, (bfd_boolean
*) NULL
);
1913 return DEBUG_TYPE_NULL
;
1916 if (details
== NF_COMPLEX
1917 || details
== NF_COMPLEX16
1918 || details
== NF_COMPLEX32
)
1919 return debug_make_complex_type (dhandle
, bytes
);
1921 return debug_make_float_type (dhandle
, bytes
);
1924 /* Handle an enum type. */
1927 parse_stab_enum_type (void *dhandle
, const char **pp
)
1931 bfd_signed_vma
*values
;
1937 /* FIXME: gdb checks os9k_stabs here. */
1939 /* The aix4 compiler emits an extra field before the enum members;
1940 my guess is it's a type of some sort. Just ignore it. */
1948 /* Read the value-names and their values.
1949 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
1950 A semicolon or comma instead of a NAME means the end. */
1952 names
= (const char **) xmalloc (alloc
* sizeof *names
);
1953 values
= (bfd_signed_vma
*) xmalloc (alloc
* sizeof *values
);
1955 while (**pp
!= '\0' && **pp
!= ';' && **pp
!= ',')
1965 name
= savestring (*pp
, p
- *pp
);
1968 val
= (bfd_signed_vma
) parse_number (pp
, (bfd_boolean
*) NULL
);
1972 return DEBUG_TYPE_NULL
;
1979 names
= ((const char **)
1980 xrealloc (names
, alloc
* sizeof *names
));
1981 values
= ((bfd_signed_vma
*)
1982 xrealloc (values
, alloc
* sizeof *values
));
1996 return debug_make_enum_type (dhandle
, names
, values
);
1999 /* Read the description of a structure (or union type) and return an object
2000 describing the type.
2002 PP points to a character pointer that points to the next unconsumed token
2003 in the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
2004 *PP will point to "4a:1,0,32;;". */
2007 parse_stab_struct_type (void *dhandle
, struct stab_handle
*info
,
2008 const char *tagname
, const char **pp
,
2009 bfd_boolean structp
, const int *typenums
)
2013 debug_baseclass
*baseclasses
;
2014 debug_field
*fields
;
2015 bfd_boolean statics
;
2016 debug_method
*methods
;
2017 debug_type vptrbase
;
2018 bfd_boolean ownvptr
;
2023 size
= parse_number (pp
, (bfd_boolean
*) NULL
);
2025 /* Get the other information. */
2026 if (! parse_stab_baseclasses (dhandle
, info
, pp
, &baseclasses
)
2027 || ! parse_stab_struct_fields (dhandle
, info
, pp
, &fields
, &statics
)
2028 || ! parse_stab_members (dhandle
, info
, tagname
, pp
, typenums
, &methods
)
2029 || ! parse_stab_tilde_field (dhandle
, info
, pp
, typenums
, &vptrbase
,
2031 return DEBUG_TYPE_NULL
;
2034 && baseclasses
== NULL
2036 && vptrbase
== DEBUG_TYPE_NULL
2038 return debug_make_struct_type (dhandle
, structp
, size
, fields
);
2040 return debug_make_object_type (dhandle
, structp
, size
, fields
, baseclasses
,
2041 methods
, vptrbase
, ownvptr
);
2044 /* The stabs for C++ derived classes contain baseclass information which
2045 is marked by a '!' character after the total size. This function is
2046 called when we encounter the baseclass marker, and slurps up all the
2047 baseclass information.
2049 Immediately following the '!' marker is the number of base classes that
2050 the class is derived from, followed by information for each base class.
2051 For each base class, there are two visibility specifiers, a bit offset
2052 to the base class information within the derived class, a reference to
2053 the type for the base class, and a terminating semicolon.
2055 A typical example, with two base classes, would be "!2,020,19;0264,21;".
2057 Baseclass information marker __________________|| | | | | | |
2058 Number of baseclasses __________________________| | | | | | |
2059 Visibility specifiers (2) ________________________| | | | | |
2060 Offset in bits from start of class _________________| | | | |
2061 Type number for base class ___________________________| | | |
2062 Visibility specifiers (2) _______________________________| | |
2063 Offset in bits from start of class ________________________| |
2064 Type number of base class ____________________________________|
2066 Return TRUE for success, FALSE for failure. */
2069 parse_stab_baseclasses (void *dhandle
, struct stab_handle
*info
,
2070 const char **pp
, debug_baseclass
**retp
)
2074 debug_baseclass
*classes
;
2082 /* No base classes. */
2087 c
= (unsigned int) parse_number (pp
, (bfd_boolean
*) NULL
);
2096 classes
= (debug_baseclass
*) xmalloc ((c
+ 1) * sizeof (**retp
));
2098 for (i
= 0; i
< c
; i
++)
2100 bfd_boolean
virtual;
2101 enum debug_visibility visibility
;
2114 warn_stab (orig
, _("unknown virtual character for baseclass"));
2123 visibility
= DEBUG_VISIBILITY_PRIVATE
;
2126 visibility
= DEBUG_VISIBILITY_PROTECTED
;
2129 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2132 warn_stab (orig
, _("unknown visibility character for baseclass"));
2133 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2138 /* The remaining value is the bit offset of the portion of the
2139 object corresponding to this baseclass. Always zero in the
2140 absence of multiple inheritance. */
2141 bitpos
= parse_number (pp
, (bfd_boolean
*) NULL
);
2149 type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2150 (debug_type
**) NULL
);
2151 if (type
== DEBUG_TYPE_NULL
)
2154 classes
[i
] = debug_make_baseclass (dhandle
, type
, bitpos
, virtual,
2156 if (classes
[i
] == DEBUG_BASECLASS_NULL
)
2164 classes
[i
] = DEBUG_BASECLASS_NULL
;
2171 /* Read struct or class data fields. They have the form:
2173 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2175 At the end, we see a semicolon instead of a field.
2177 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2180 The optional VISIBILITY is one of:
2182 '/0' (VISIBILITY_PRIVATE)
2183 '/1' (VISIBILITY_PROTECTED)
2184 '/2' (VISIBILITY_PUBLIC)
2185 '/9' (VISIBILITY_IGNORE)
2187 or nothing, for C style fields with public visibility.
2189 Returns 1 for success, 0 for failure. */
2192 parse_stab_struct_fields (void *dhandle
, struct stab_handle
*info
,
2193 const char **pp
, debug_field
**retp
,
2194 bfd_boolean
*staticsp
)
2198 debug_field
*fields
;
2209 fields
= (debug_field
*) xmalloc (alloc
* sizeof *fields
);
2212 /* FIXME: gdb checks os9k_stabs here. */
2216 /* Add 1 to c to leave room for NULL pointer at end. */
2220 fields
= ((debug_field
*)
2221 xrealloc (fields
, alloc
* sizeof *fields
));
2224 /* If it starts with CPLUS_MARKER it is a special abbreviation,
2225 unless the CPLUS_MARKER is followed by an underscore, in
2226 which case it is just the name of an anonymous type, which we
2227 should handle like any other type name. We accept either '$'
2228 or '.', because a field name can never contain one of these
2229 characters except as a CPLUS_MARKER. */
2231 if ((*p
== '$' || *p
== '.') && p
[1] != '_')
2234 if (! parse_stab_cpp_abbrev (dhandle
, info
, pp
, fields
+ c
))
2240 /* Look for the ':' that separates the field name from the field
2241 values. Data members are delimited by a single ':', while member
2242 functions are delimited by a pair of ':'s. When we hit the member
2243 functions (if any), terminate scan loop and return. */
2245 p
= strchr (p
, ':');
2255 if (! parse_stab_one_struct_field (dhandle
, info
, pp
, p
, fields
+ c
,
2262 fields
[c
] = DEBUG_FIELD_NULL
;
2269 /* Special GNU C++ name. */
2272 parse_stab_cpp_abbrev (void *dhandle
, struct stab_handle
*info
,
2273 const char **pp
, debug_field
*retp
)
2279 const char *typename
;
2283 *retp
= DEBUG_FIELD_NULL
;
2297 /* At this point, *pp points to something like "22:23=*22...", where
2298 the type number before the ':' is the "context" and everything
2299 after is a regular type definition. Lookup the type, find it's
2300 name, and construct the field name. */
2302 context
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2303 (debug_type
**) NULL
);
2304 if (context
== DEBUG_TYPE_NULL
)
2310 /* $vf -- a virtual function table pointer. */
2314 /* $vb -- a virtual bsomethingorother */
2315 typename
= debug_get_type_name (dhandle
, context
);
2316 if (typename
== NULL
)
2318 warn_stab (orig
, _("unnamed $vb type"));
2321 name
= concat ("_vb$", typename
, (const char *) NULL
);
2324 warn_stab (orig
, _("unrecognized C++ abbreviation"));
2325 name
= "INVALID_CPLUSPLUS_ABBREV";
2336 type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2337 (debug_type
**) NULL
);
2345 bitpos
= parse_number (pp
, (bfd_boolean
*) NULL
);
2353 *retp
= debug_make_field (dhandle
, name
, type
, bitpos
, 0,
2354 DEBUG_VISIBILITY_PRIVATE
);
2355 if (*retp
== DEBUG_FIELD_NULL
)
2361 /* Parse a single field in a struct or union. */
2364 parse_stab_one_struct_field (void *dhandle
, struct stab_handle
*info
,
2365 const char **pp
, const char *p
,
2366 debug_field
*retp
, bfd_boolean
*staticsp
)
2370 enum debug_visibility visibility
;
2377 /* FIXME: gdb checks ARM_DEMANGLING here. */
2379 name
= savestring (*pp
, p
- *pp
);
2384 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2391 visibility
= DEBUG_VISIBILITY_PRIVATE
;
2394 visibility
= DEBUG_VISIBILITY_PROTECTED
;
2397 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2400 warn_stab (orig
, _("unknown visibility character for field"));
2401 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2407 type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2408 (debug_type
**) NULL
);
2409 if (type
== DEBUG_TYPE_NULL
)
2416 /* This is a static class member. */
2418 p
= strchr (*pp
, ';');
2425 varname
= savestring (*pp
, p
- *pp
);
2429 *retp
= debug_make_static_member (dhandle
, name
, type
, varname
,
2443 bitpos
= parse_number (pp
, (bfd_boolean
*) NULL
);
2451 bitsize
= parse_number (pp
, (bfd_boolean
*) NULL
);
2459 if (bitpos
== 0 && bitsize
== 0)
2461 /* This can happen in two cases: (1) at least for gcc 2.4.5 or
2462 so, it is a field which has been optimized out. The correct
2463 stab for this case is to use VISIBILITY_IGNORE, but that is a
2464 recent invention. (2) It is a 0-size array. For example
2465 union { int num; char str[0]; } foo. Printing "<no value>"
2466 for str in "p foo" is OK, since foo.str (and thus foo.str[3])
2467 will continue to work, and a 0-size array as a whole doesn't
2468 have any contents to print.
2470 I suspect this probably could also happen with gcc -gstabs
2471 (not -gstabs+) for static fields, and perhaps other C++
2472 extensions. Hopefully few people use -gstabs with gdb, since
2473 it is intended for dbx compatibility. */
2474 visibility
= DEBUG_VISIBILITY_IGNORE
;
2477 /* FIXME: gdb does some stuff here to mark fields as unpacked. */
2479 *retp
= debug_make_field (dhandle
, name
, type
, bitpos
, bitsize
, visibility
);
2484 /* Read member function stabs info for C++ classes. The form of each member
2487 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2489 An example with two member functions is:
2491 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2493 For the case of overloaded operators, the format is op$::*.funcs, where
2494 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2495 name (such as `+=') and `.' marks the end of the operator name. */
2498 parse_stab_members (void *dhandle
, struct stab_handle
*info
,
2499 const char *tagname
, const char **pp
,
2500 const int *typenums
, debug_method
**retp
)
2503 debug_method
*methods
;
2519 debug_method_variant
*variants
;
2521 unsigned int allocvars
;
2522 debug_type look_ahead_type
;
2524 p
= strchr (*pp
, ':');
2525 if (p
== NULL
|| p
[1] != ':')
2528 /* FIXME: Some systems use something other than '$' here. */
2529 if ((*pp
)[0] != 'o' || (*pp
)[1] != 'p' || (*pp
)[2] != '$')
2531 name
= savestring (*pp
, p
- *pp
);
2536 /* This is a completely weird case. In order to stuff in the
2537 names that might contain colons (the usual name delimiter),
2538 Mike Tiemann defined a different name format which is
2539 signalled if the identifier is "op$". In that case, the
2540 format is "op$::XXXX." where XXXX is the name. This is
2541 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2543 for (p
= *pp
; *p
!= '.' && *p
!= '\0'; p
++)
2550 name
= savestring (*pp
, p
- *pp
);
2555 variants
= ((debug_method_variant
*)
2556 xmalloc (allocvars
* sizeof *variants
));
2559 look_ahead_type
= DEBUG_TYPE_NULL
;
2566 enum debug_visibility visibility
;
2567 bfd_boolean constp
, volatilep
, staticp
;
2570 const char *physname
;
2571 bfd_boolean varargs
;
2573 if (look_ahead_type
!= DEBUG_TYPE_NULL
)
2575 /* g++ version 1 kludge */
2576 type
= look_ahead_type
;
2577 look_ahead_type
= DEBUG_TYPE_NULL
;
2581 type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2582 (debug_type
**) NULL
);
2583 if (type
== DEBUG_TYPE_NULL
)
2593 p
= strchr (*pp
, ';');
2601 if (debug_get_type_kind (dhandle
, type
) == DEBUG_KIND_METHOD
2602 && debug_get_parameter_types (dhandle
, type
, &varargs
) == NULL
)
2605 argtypes
= savestring (*pp
, p
- *pp
);
2611 visibility
= DEBUG_VISIBILITY_PRIVATE
;
2614 visibility
= DEBUG_VISIBILITY_PROTECTED
;
2617 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2627 /* Normal function. */
2631 /* const member function. */
2636 /* volatile member function. */
2641 /* const volatile member function. */
2649 /* File compiled with g++ version 1; no information. */
2652 warn_stab (orig
, _("const/volatile indicator missing"));
2660 /* virtual member function, followed by index. The sign
2661 bit is supposedly set to distinguish
2662 pointers-to-methods from virtual function indicies. */
2664 voffset
= parse_number (pp
, (bfd_boolean
*) NULL
);
2671 voffset
&= 0x7fffffff;
2673 if (**pp
== ';' || *pp
== '\0')
2675 /* Must be g++ version 1. */
2676 context
= DEBUG_TYPE_NULL
;
2680 /* Figure out from whence this virtual function
2681 came. It may belong to virtual function table of
2682 one of its baseclasses. */
2683 look_ahead_type
= parse_stab_type (dhandle
, info
,
2684 (const char *) NULL
,
2686 (debug_type
**) NULL
);
2689 /* g++ version 1 overloaded methods. */
2690 context
= DEBUG_TYPE_NULL
;
2694 context
= look_ahead_type
;
2695 look_ahead_type
= DEBUG_TYPE_NULL
;
2707 /* static member function. */
2711 context
= DEBUG_TYPE_NULL
;
2712 if (strncmp (argtypes
, name
, strlen (name
)) != 0)
2717 warn_stab (orig
, "member function type missing");
2719 context
= DEBUG_TYPE_NULL
;
2725 context
= DEBUG_TYPE_NULL
;
2729 /* If the type is not a stub, then the argtypes string is
2730 the physical name of the function. Otherwise the
2731 argtypes string is the mangled form of the argument
2732 types, and the full type and the physical name must be
2733 extracted from them. */
2735 physname
= argtypes
;
2738 debug_type class_type
, return_type
;
2740 class_type
= stab_find_type (dhandle
, info
, typenums
);
2741 if (class_type
== DEBUG_TYPE_NULL
)
2743 return_type
= debug_get_return_type (dhandle
, type
);
2744 if (return_type
== DEBUG_TYPE_NULL
)
2749 type
= parse_stab_argtypes (dhandle
, info
, class_type
, name
,
2750 tagname
, return_type
, argtypes
,
2751 constp
, volatilep
, &physname
);
2752 if (type
== DEBUG_TYPE_NULL
)
2756 if (cvars
+ 1 >= allocvars
)
2759 variants
= ((debug_method_variant
*)
2761 allocvars
* sizeof *variants
));
2765 variants
[cvars
] = debug_make_method_variant (dhandle
, physname
,
2770 variants
[cvars
] = debug_make_static_method_variant (dhandle
,
2776 if (variants
[cvars
] == DEBUG_METHOD_VARIANT_NULL
)
2781 while (**pp
!= ';' && **pp
!= '\0');
2783 variants
[cvars
] = DEBUG_METHOD_VARIANT_NULL
;
2791 methods
= ((debug_method
*)
2792 xrealloc (methods
, alloc
* sizeof *methods
));
2795 methods
[c
] = debug_make_method (dhandle
, name
, variants
);
2800 if (methods
!= NULL
)
2801 methods
[c
] = DEBUG_METHOD_NULL
;
2808 /* Parse a string representing argument types for a method. Stabs
2809 tries to save space by packing argument types into a mangled
2810 string. This string should give us enough information to extract
2811 both argument types and the physical name of the function, given
2815 parse_stab_argtypes (void *dhandle
, struct stab_handle
*info
,
2816 debug_type class_type
, const char *fieldname
,
2817 const char *tagname
, debug_type return_type
,
2818 const char *argtypes
, bfd_boolean constp
,
2819 bfd_boolean volatilep
, const char **pphysname
)
2821 bfd_boolean is_full_physname_constructor
;
2822 bfd_boolean is_constructor
;
2823 bfd_boolean is_destructor
;
2826 bfd_boolean varargs
;
2827 unsigned int physname_len
= 0;
2829 /* Constructors are sometimes handled specially. */
2830 is_full_physname_constructor
= ((argtypes
[0] == '_'
2831 && argtypes
[1] == '_'
2832 && (ISDIGIT (argtypes
[2])
2833 || argtypes
[2] == 'Q'
2834 || argtypes
[2] == 't'))
2835 || CONST_STRNEQ (argtypes
, "__ct"));
2837 is_constructor
= (is_full_physname_constructor
2839 && strcmp (fieldname
, tagname
) == 0));
2840 is_destructor
= ((argtypes
[0] == '_'
2841 && (argtypes
[1] == '$' || argtypes
[1] == '.')
2842 && argtypes
[2] == '_')
2843 || CONST_STRNEQ (argtypes
, "__dt"));
2844 is_v3
= argtypes
[0] == '_' && argtypes
[1] == 'Z';
2846 if (is_destructor
|| is_full_physname_constructor
|| is_v3
)
2847 *pphysname
= argtypes
;
2851 const char *const_prefix
;
2852 const char *volatile_prefix
;
2854 unsigned int mangled_name_len
;
2857 len
= tagname
== NULL
? 0 : strlen (tagname
);
2858 const_prefix
= constp
? "C" : "";
2859 volatile_prefix
= volatilep
? "V" : "";
2862 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
2863 else if (tagname
!= NULL
&& strchr (tagname
, '<') != NULL
)
2865 /* Template methods are fully mangled. */
2866 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
2871 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
2873 mangled_name_len
= ((is_constructor
? 0 : strlen (fieldname
))
2879 if (fieldname
[0] == 'o'
2880 && fieldname
[1] == 'p'
2881 && (fieldname
[2] == '$' || fieldname
[2] == '.'))
2885 opname
= cplus_mangle_opname (fieldname
+ 3, 0);
2888 fprintf (stderr
, _("No mangling for \"%s\"\n"), fieldname
);
2889 return DEBUG_TYPE_NULL
;
2891 mangled_name_len
+= strlen (opname
);
2892 physname
= (char *) xmalloc (mangled_name_len
);
2893 strncpy (physname
, fieldname
, 3);
2894 strcpy (physname
+ 3, opname
);
2898 physname
= (char *) xmalloc (mangled_name_len
);
2902 strcpy (physname
, fieldname
);
2905 physname_len
= strlen (physname
);
2906 strcat (physname
, buf
);
2907 if (tagname
!= NULL
)
2908 strcat (physname
, tagname
);
2909 strcat (physname
, argtypes
);
2911 *pphysname
= physname
;
2914 if (*argtypes
== '\0' || is_destructor
)
2916 args
= (debug_type
*) xmalloc (sizeof *args
);
2918 return debug_make_method_type (dhandle
, return_type
, class_type
, args
,
2922 args
= stab_demangle_argtypes (dhandle
, info
, *pphysname
, &varargs
, physname_len
);
2924 return DEBUG_TYPE_NULL
;
2926 return debug_make_method_type (dhandle
, return_type
, class_type
, args
,
2930 /* The tail end of stabs for C++ classes that contain a virtual function
2931 pointer contains a tilde, a %, and a type number.
2932 The type number refers to the base class (possibly this class itself) which
2933 contains the vtable pointer for the current class.
2935 This function is called when we have parsed all the method declarations,
2936 so we can look for the vptr base class info. */
2939 parse_stab_tilde_field (void *dhandle
, struct stab_handle
*info
,
2940 const char **pp
, const int *typenums
,
2941 debug_type
*retvptrbase
, bfd_boolean
*retownvptr
)
2947 *retvptrbase
= DEBUG_TYPE_NULL
;
2948 *retownvptr
= FALSE
;
2952 /* If we are positioned at a ';', then skip it. */
2961 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
2963 /* Obsolete flags that used to indicate the presence of
2964 constructors and/or destructors. */
2975 /* The next number is the type number of the base class (possibly
2976 our own class) which supplies the vtable for this class. */
2977 if (! parse_stab_type_number (pp
, vtypenums
))
2980 if (vtypenums
[0] == typenums
[0]
2981 && vtypenums
[1] == typenums
[1])
2990 vtype
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
2991 (debug_type
**) NULL
);
2992 for (p
= *pp
; *p
!= ';' && *p
!= '\0'; p
++)
3000 *retvptrbase
= vtype
;
3008 /* Read a definition of an array type. */
3011 parse_stab_array_type (void *dhandle
, struct stab_handle
*info
,
3012 const char **pp
, bfd_boolean stringp
)
3017 debug_type index_type
;
3018 bfd_boolean adjustable
;
3019 bfd_signed_vma lower
, upper
;
3020 debug_type element_type
;
3022 /* Format of an array type:
3023 "ar<index type>;lower;upper;<array_contents_type>".
3024 OS9000: "arlower,upper;<array_contents_type>".
3026 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3027 for these, produce a type like float[][]. */
3031 /* FIXME: gdb checks os9k_stabs here. */
3033 /* If the index type is type 0, we take it as int. */
3035 if (! parse_stab_type_number (&p
, typenums
))
3036 return DEBUG_TYPE_NULL
;
3037 if (typenums
[0] == 0 && typenums
[1] == 0 && **pp
!= '=')
3039 index_type
= debug_find_named_type (dhandle
, "int");
3040 if (index_type
== DEBUG_TYPE_NULL
)
3042 index_type
= debug_make_int_type (dhandle
, 4, FALSE
);
3043 if (index_type
== DEBUG_TYPE_NULL
)
3044 return DEBUG_TYPE_NULL
;
3050 index_type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
3051 (debug_type
**) NULL
);
3057 return DEBUG_TYPE_NULL
;
3063 if (! ISDIGIT (**pp
) && **pp
!= '-')
3069 lower
= (bfd_signed_vma
) parse_number (pp
, (bfd_boolean
*) NULL
);
3073 return DEBUG_TYPE_NULL
;
3077 if (! ISDIGIT (**pp
) && **pp
!= '-')
3083 upper
= (bfd_signed_vma
) parse_number (pp
, (bfd_boolean
*) NULL
);
3087 return DEBUG_TYPE_NULL
;
3091 element_type
= parse_stab_type (dhandle
, info
, (const char *) NULL
, pp
,
3092 (debug_type
**) NULL
);
3093 if (element_type
== DEBUG_TYPE_NULL
)
3094 return DEBUG_TYPE_NULL
;
3102 return debug_make_array_type (dhandle
, element_type
, index_type
, lower
,
3106 /* This struct holds information about files we have seen using
3111 /* The next N_BINCL file. */
3112 struct bincl_file
*next
;
3113 /* The next N_BINCL on the stack. */
3114 struct bincl_file
*next_stack
;
3115 /* The file name. */
3117 /* The hash value. */
3119 /* The file index. */
3121 /* The list of types defined in this file. */
3122 struct stab_types
*file_types
;
3125 /* Start a new N_BINCL file, pushing it onto the stack. */
3128 push_bincl (struct stab_handle
*info
, const char *name
, bfd_vma hash
)
3130 struct bincl_file
*n
;
3132 n
= (struct bincl_file
*) xmalloc (sizeof *n
);
3133 n
->next
= info
->bincl_list
;
3134 n
->next_stack
= info
->bincl_stack
;
3137 n
->file
= info
->files
;
3138 n
->file_types
= NULL
;
3139 info
->bincl_list
= n
;
3140 info
->bincl_stack
= n
;
3143 info
->file_types
= ((struct stab_types
**)
3144 xrealloc (info
->file_types
,
3146 * sizeof *info
->file_types
)));
3147 info
->file_types
[n
->file
] = NULL
;
3150 /* Finish an N_BINCL file, at an N_EINCL, popping the name off the
3154 pop_bincl (struct stab_handle
*info
)
3156 struct bincl_file
*o
;
3158 o
= info
->bincl_stack
;
3160 return info
->main_filename
;
3161 info
->bincl_stack
= o
->next_stack
;
3163 o
->file_types
= info
->file_types
[o
->file
];
3165 if (info
->bincl_stack
== NULL
)
3166 return info
->main_filename
;
3167 return info
->bincl_stack
->name
;
3170 /* Handle an N_EXCL: get the types from the corresponding N_BINCL. */
3173 find_excl (struct stab_handle
*info
, const char *name
, bfd_vma hash
)
3175 struct bincl_file
*l
;
3178 info
->file_types
= ((struct stab_types
**)
3179 xrealloc (info
->file_types
,
3181 * sizeof *info
->file_types
)));
3183 for (l
= info
->bincl_list
; l
!= NULL
; l
= l
->next
)
3184 if (l
->hash
== hash
&& strcmp (l
->name
, name
) == 0)
3188 warn_stab (name
, _("Undefined N_EXCL"));
3189 info
->file_types
[info
->files
- 1] = NULL
;
3193 info
->file_types
[info
->files
- 1] = l
->file_types
;
3198 /* Handle a variable definition. gcc emits variable definitions for a
3199 block before the N_LBRAC, so we must hold onto them until we see
3200 it. The SunPRO compiler emits variable definitions after the
3201 N_LBRAC, so we can call debug_record_variable immediately. */
3204 stab_record_variable (void *dhandle
, struct stab_handle
*info
,
3205 const char *name
, debug_type type
,
3206 enum debug_var_kind kind
, bfd_vma val
)
3208 struct stab_pending_var
*v
;
3210 if ((kind
== DEBUG_GLOBAL
|| kind
== DEBUG_STATIC
)
3211 || ! info
->within_function
3212 || (info
->gcc_compiled
== 0 && info
->n_opt_found
))
3213 return debug_record_variable (dhandle
, name
, type
, kind
, val
);
3215 v
= (struct stab_pending_var
*) xmalloc (sizeof *v
);
3216 memset (v
, 0, sizeof *v
);
3218 v
->next
= info
->pending
;
3228 /* Emit pending variable definitions. This is called after we see the
3229 N_LBRAC that starts the block. */
3232 stab_emit_pending_vars (void *dhandle
, struct stab_handle
*info
)
3234 struct stab_pending_var
*v
;
3239 struct stab_pending_var
*next
;
3241 if (! debug_record_variable (dhandle
, v
->name
, v
->type
, v
->kind
, v
->val
))
3249 info
->pending
= NULL
;
3254 /* Find the slot for a type in the database. */
3257 stab_find_slot (struct stab_handle
*info
, const int *typenums
)
3261 struct stab_types
**ps
;
3263 filenum
= typenums
[0];
3264 index
= typenums
[1];
3266 if (filenum
< 0 || (unsigned int) filenum
>= info
->files
)
3268 fprintf (stderr
, _("Type file number %d out of range\n"), filenum
);
3273 fprintf (stderr
, _("Type index number %d out of range\n"), index
);
3277 ps
= info
->file_types
+ filenum
;
3279 while (index
>= STAB_TYPES_SLOTS
)
3283 *ps
= (struct stab_types
*) xmalloc (sizeof **ps
);
3284 memset (*ps
, 0, sizeof **ps
);
3287 index
-= STAB_TYPES_SLOTS
;
3291 *ps
= (struct stab_types
*) xmalloc (sizeof **ps
);
3292 memset (*ps
, 0, sizeof **ps
);
3295 return (*ps
)->types
+ index
;
3298 /* Find a type given a type number. If the type has not been
3299 allocated yet, create an indirect type. */
3302 stab_find_type (void *dhandle
, struct stab_handle
*info
, const int *typenums
)
3306 if (typenums
[0] == 0 && typenums
[1] < 0)
3308 /* A negative type number indicates an XCOFF builtin type. */
3309 return stab_xcoff_builtin_type (dhandle
, info
, typenums
[1]);
3312 slot
= stab_find_slot (info
, typenums
);
3314 return DEBUG_TYPE_NULL
;
3316 if (*slot
== DEBUG_TYPE_NULL
)
3317 return debug_make_indirect_type (dhandle
, slot
, (const char *) NULL
);
3322 /* Record that a given type number refers to a given type. */
3325 stab_record_type (void *dhandle ATTRIBUTE_UNUSED
, struct stab_handle
*info
,
3326 const int *typenums
, debug_type type
)
3330 slot
= stab_find_slot (info
, typenums
);
3334 /* gdb appears to ignore type redefinitions, so we do as well. */
3341 /* Return an XCOFF builtin type. */
3344 stab_xcoff_builtin_type (void *dhandle
, struct stab_handle
*info
,
3350 if (typenum
>= 0 || typenum
< -XCOFF_TYPE_COUNT
)
3352 fprintf (stderr
, _("Unrecognized XCOFF type %d\n"), typenum
);
3353 return DEBUG_TYPE_NULL
;
3355 if (info
->xcoff_types
[-typenum
] != NULL
)
3356 return info
->xcoff_types
[-typenum
];
3361 /* The size of this and all the other types are fixed, defined
3362 by the debugging format. */
3364 rettype
= debug_make_int_type (dhandle
, 4, FALSE
);
3368 rettype
= debug_make_int_type (dhandle
, 1, FALSE
);
3372 rettype
= debug_make_int_type (dhandle
, 2, FALSE
);
3376 rettype
= debug_make_int_type (dhandle
, 4, FALSE
);
3379 name
= "unsigned char";
3380 rettype
= debug_make_int_type (dhandle
, 1, TRUE
);
3383 name
= "signed char";
3384 rettype
= debug_make_int_type (dhandle
, 1, FALSE
);
3387 name
= "unsigned short";
3388 rettype
= debug_make_int_type (dhandle
, 2, TRUE
);
3391 name
= "unsigned int";
3392 rettype
= debug_make_int_type (dhandle
, 4, TRUE
);
3396 rettype
= debug_make_int_type (dhandle
, 4, TRUE
);
3398 name
= "unsigned long";
3399 rettype
= debug_make_int_type (dhandle
, 4, TRUE
);
3403 rettype
= debug_make_void_type (dhandle
);
3406 /* IEEE single precision (32 bit). */
3408 rettype
= debug_make_float_type (dhandle
, 4);
3411 /* IEEE double precision (64 bit). */
3413 rettype
= debug_make_float_type (dhandle
, 8);
3416 /* This is an IEEE double on the RS/6000, and different machines
3417 with different sizes for "long double" should use different
3418 negative type numbers. See stabs.texinfo. */
3419 name
= "long double";
3420 rettype
= debug_make_float_type (dhandle
, 8);
3424 rettype
= debug_make_int_type (dhandle
, 4, FALSE
);
3428 rettype
= debug_make_bool_type (dhandle
, 4);
3431 name
= "short real";
3432 rettype
= debug_make_float_type (dhandle
, 4);
3436 rettype
= debug_make_float_type (dhandle
, 8);
3446 rettype
= debug_make_int_type (dhandle
, 1, TRUE
);
3450 rettype
= debug_make_bool_type (dhandle
, 1);
3454 rettype
= debug_make_bool_type (dhandle
, 2);
3458 rettype
= debug_make_bool_type (dhandle
, 4);
3462 rettype
= debug_make_bool_type (dhandle
, 4);
3465 /* Complex type consisting of two IEEE single precision values. */
3467 rettype
= debug_make_complex_type (dhandle
, 8);
3470 /* Complex type consisting of two IEEE double precision values. */
3471 name
= "double complex";
3472 rettype
= debug_make_complex_type (dhandle
, 16);
3476 rettype
= debug_make_int_type (dhandle
, 1, FALSE
);
3480 rettype
= debug_make_int_type (dhandle
, 2, FALSE
);
3484 rettype
= debug_make_int_type (dhandle
, 4, FALSE
);
3489 rettype
= debug_make_int_type (dhandle
, 2, FALSE
);
3493 rettype
= debug_make_int_type (dhandle
, 8, FALSE
);
3496 name
= "unsigned long long";
3497 rettype
= debug_make_int_type (dhandle
, 8, TRUE
);
3501 rettype
= debug_make_bool_type (dhandle
, 8);
3505 rettype
= debug_make_int_type (dhandle
, 8, FALSE
);
3511 rettype
= debug_name_type (dhandle
, name
, rettype
);
3513 info
->xcoff_types
[-typenum
] = rettype
;
3518 /* Find or create a tagged type. */
3521 stab_find_tagged_type (void *dhandle
, struct stab_handle
*info
,
3522 const char *p
, int len
, enum debug_type_kind kind
)
3526 struct stab_tag
*st
;
3528 name
= savestring (p
, len
);
3530 /* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same
3531 namespace. This is right for C, and I don't know how to handle
3532 other languages. FIXME. */
3533 dtype
= debug_find_tagged_type (dhandle
, name
, DEBUG_KIND_ILLEGAL
);
3534 if (dtype
!= DEBUG_TYPE_NULL
)
3540 /* We need to allocate an entry on the undefined tag list. */
3541 for (st
= info
->tags
; st
!= NULL
; st
= st
->next
)
3543 if (st
->name
[0] == name
[0]
3544 && strcmp (st
->name
, name
) == 0)
3546 if (st
->kind
== DEBUG_KIND_ILLEGAL
)
3554 st
= (struct stab_tag
*) xmalloc (sizeof *st
);
3555 memset (st
, 0, sizeof *st
);
3557 st
->next
= info
->tags
;
3560 st
->slot
= DEBUG_TYPE_NULL
;
3561 st
->type
= debug_make_indirect_type (dhandle
, &st
->slot
, name
);
3568 /* In order to get the correct argument types for a stubbed method, we
3569 need to extract the argument types from a C++ mangled string.
3570 Since the argument types can refer back to the return type, this
3571 means that we must demangle the entire physical name. In gdb this
3572 is done by calling cplus_demangle and running the results back
3573 through the C++ expression parser. Since we have no expression
3574 parser, we must duplicate much of the work of cplus_demangle here.
3576 We assume that GNU style demangling is used, since this is only
3577 done for method stubs, and only g++ should output that form of
3578 debugging information. */
3580 /* This structure is used to hold a pointer to type information which
3581 demangling a string. */
3583 struct stab_demangle_typestring
3585 /* The start of the type. This is not null terminated. */
3586 const char *typestring
;
3587 /* The length of the type. */
3591 /* This structure is used to hold information while demangling a
3594 struct stab_demangle_info
3596 /* The debugging information handle. */
3598 /* The stab information handle. */
3599 struct stab_handle
*info
;
3600 /* The array of arguments we are building. */
3602 /* Whether the method takes a variable number of arguments. */
3603 bfd_boolean varargs
;
3604 /* The array of types we have remembered. */
3605 struct stab_demangle_typestring
*typestrings
;
3606 /* The number of typestrings. */
3607 unsigned int typestring_count
;
3608 /* The number of typestring slots we have allocated. */
3609 unsigned int typestring_alloc
;
3612 static void stab_bad_demangle (const char *);
3613 static unsigned int stab_demangle_count (const char **);
3614 static bfd_boolean
stab_demangle_get_count (const char **, unsigned int *);
3615 static bfd_boolean stab_demangle_prefix
3616 (struct stab_demangle_info
*, const char **, unsigned int);
3617 static bfd_boolean stab_demangle_function_name
3618 (struct stab_demangle_info
*, const char **, const char *);
3619 static bfd_boolean stab_demangle_signature
3620 (struct stab_demangle_info
*, const char **);
3621 static bfd_boolean stab_demangle_qualified
3622 (struct stab_demangle_info
*, const char **, debug_type
*);
3623 static bfd_boolean stab_demangle_template
3624 (struct stab_demangle_info
*, const char **, char **);
3625 static bfd_boolean stab_demangle_class
3626 (struct stab_demangle_info
*, const char **, const char **);
3627 static bfd_boolean stab_demangle_args
3628 (struct stab_demangle_info
*, const char **, debug_type
**, bfd_boolean
*);
3629 static bfd_boolean stab_demangle_arg
3630 (struct stab_demangle_info
*, const char **, debug_type
**,
3631 unsigned int *, unsigned int *);
3632 static bfd_boolean stab_demangle_type
3633 (struct stab_demangle_info
*, const char **, debug_type
*);
3634 static bfd_boolean stab_demangle_fund_type
3635 (struct stab_demangle_info
*, const char **, debug_type
*);
3636 static bfd_boolean stab_demangle_remember_type
3637 (struct stab_demangle_info
*, const char *, int);
3639 /* Warn about a bad demangling. */
3642 stab_bad_demangle (const char *s
)
3644 fprintf (stderr
, _("bad mangled name `%s'\n"), s
);
3647 /* Get a count from a stab string. */
3650 stab_demangle_count (const char **pp
)
3655 while (ISDIGIT (**pp
))
3658 count
+= **pp
- '0';
3664 /* Require a count in a string. The count may be multiple digits, in
3665 which case it must end in an underscore. */
3668 stab_demangle_get_count (const char **pp
, unsigned int *pi
)
3670 if (! ISDIGIT (**pp
))
3688 while (ISDIGIT (*p
));
3699 /* This function demangles a physical name, returning a NULL
3700 terminated array of argument types. */
3703 stab_demangle_argtypes (void *dhandle
, struct stab_handle
*info
,
3704 const char *physname
, bfd_boolean
*pvarargs
,
3705 unsigned int physname_len
)
3707 struct stab_demangle_info minfo
;
3709 /* Check for the g++ V3 ABI. */
3710 if (physname
[0] == '_' && physname
[1] == 'Z')
3711 return stab_demangle_v3_argtypes (dhandle
, info
, physname
, pvarargs
);
3713 minfo
.dhandle
= dhandle
;
3716 minfo
.varargs
= FALSE
;
3717 minfo
.typestring_alloc
= 10;
3718 minfo
.typestrings
= ((struct stab_demangle_typestring
*)
3719 xmalloc (minfo
.typestring_alloc
3720 * sizeof *minfo
.typestrings
));
3721 minfo
.typestring_count
= 0;
3723 /* cplus_demangle checks for special GNU mangled forms, but we can't
3724 see any of them in mangled method argument types. */
3726 if (! stab_demangle_prefix (&minfo
, &physname
, physname_len
))
3729 if (*physname
!= '\0')
3731 if (! stab_demangle_signature (&minfo
, &physname
))
3735 free (minfo
.typestrings
);
3736 minfo
.typestrings
= NULL
;
3738 if (minfo
.args
== NULL
)
3739 fprintf (stderr
, _("no argument types in mangled string\n"));
3741 *pvarargs
= minfo
.varargs
;
3745 if (minfo
.typestrings
!= NULL
)
3746 free (minfo
.typestrings
);
3750 /* Demangle the prefix of the mangled name. */
3753 stab_demangle_prefix (struct stab_demangle_info
*minfo
, const char **pp
,
3754 unsigned int physname_len
)
3759 /* cplus_demangle checks for global constructors and destructors,
3760 but we can't see them in mangled argument types. */
3763 scan
= *pp
+ physname_len
;
3766 /* Look for `__'. */
3769 scan
= strchr (scan
, '_');
3770 while (scan
!= NULL
&& *++scan
!= '_');
3774 stab_bad_demangle (*pp
);
3780 /* We found `__'; move ahead to the last contiguous `__' pair. */
3781 i
= strspn (scan
, "_");
3787 && (ISDIGIT (scan
[2])
3791 /* This is a GNU style constructor name. */
3795 else if (scan
== *pp
3796 && ! ISDIGIT (scan
[2])
3799 /* Look for the `__' that separates the prefix from the
3801 while (*scan
== '_')
3803 scan
= strstr (scan
, "__");
3804 if (scan
== NULL
|| scan
[2] == '\0')
3806 stab_bad_demangle (*pp
);
3810 return stab_demangle_function_name (minfo
, pp
, scan
);
3812 else if (scan
[2] != '\0')
3814 /* The name doesn't start with `__', but it does contain `__'. */
3815 return stab_demangle_function_name (minfo
, pp
, scan
);
3819 stab_bad_demangle (*pp
);
3825 /* Demangle a function name prefix. The scan argument points to the
3826 double underscore which separates the function name from the
3830 stab_demangle_function_name (struct stab_demangle_info
*minfo
,
3831 const char **pp
, const char *scan
)
3835 /* The string from *pp to scan is the name of the function. We
3836 don't care about the name, since we just looking for argument
3837 types. However, for conversion operators, the name may include a
3838 type which we must remember in order to handle backreferences. */
3844 && CONST_STRNEQ (name
, "type")
3845 && (name
[4] == '$' || name
[4] == '.'))
3849 /* This is a type conversion operator. */
3851 if (! stab_demangle_type (minfo
, &tem
, (debug_type
*) NULL
))
3854 else if (name
[0] == '_'
3861 /* This is a type conversion operator. */
3863 if (! stab_demangle_type (minfo
, &tem
, (debug_type
*) NULL
))
3870 /* Demangle the signature. This is where the argument types are
3874 stab_demangle_signature (struct stab_demangle_info
*minfo
, const char **pp
)
3877 bfd_boolean expect_func
, func_done
;
3882 expect_func
= FALSE
;
3886 while (**pp
!= '\0')
3892 if (! stab_demangle_qualified (minfo
, pp
, (debug_type
*) NULL
)
3893 || ! stab_demangle_remember_type (minfo
, hold
, *pp
- hold
))
3900 /* Static member function. FIXME: Can this happen? */
3907 /* Const member function. */
3913 case '0': case '1': case '2': case '3': case '4':
3914 case '5': case '6': case '7': case '8': case '9':
3917 if (! stab_demangle_class (minfo
, pp
, (const char **) NULL
)
3918 || ! stab_demangle_remember_type (minfo
, hold
, *pp
- hold
))
3925 /* Function. I don't know if this actually happens with g++
3930 if (! stab_demangle_args (minfo
, pp
, &minfo
->args
, &minfo
->varargs
))
3938 if (! stab_demangle_template (minfo
, pp
, (char **) NULL
)
3939 || ! stab_demangle_remember_type (minfo
, hold
, *pp
- hold
))
3946 /* At the outermost level, we cannot have a return type
3947 specified, so if we run into another '_' at this point we
3948 are dealing with a mangled name that is either bogus, or
3949 has been mangled by some algorithm we don't know how to
3950 deal with. So just reject the entire demangling. */
3951 stab_bad_demangle (orig
);
3955 /* Assume we have stumbled onto the first outermost function
3956 argument token, and start processing args. */
3958 if (! stab_demangle_args (minfo
, pp
, &minfo
->args
, &minfo
->varargs
))
3966 if (! stab_demangle_args (minfo
, pp
, &minfo
->args
, &minfo
->varargs
))
3973 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
3974 bar__3fooi is 'foo::bar(int)'. We get here when we find the
3975 first case, and need to ensure that the '(void)' gets added
3976 to the current declp. */
3977 if (! stab_demangle_args (minfo
, pp
, &minfo
->args
, &minfo
->varargs
))
3984 /* Demangle a qualified name, such as "Q25Outer5Inner" which is the
3985 mangled form of "Outer::Inner". */
3988 stab_demangle_qualified (struct stab_demangle_info
*minfo
, const char **pp
,
3993 unsigned int qualifiers
;
4001 /* GNU mangled name with more than 9 classes. The count is
4002 preceded by an underscore (to distinguish it from the <= 9
4003 case) and followed by an underscore. */
4005 if (! ISDIGIT (*p
) || *p
== '0')
4007 stab_bad_demangle (orig
);
4010 qualifiers
= atoi (p
);
4011 while (ISDIGIT (*p
))
4015 stab_bad_demangle (orig
);
4021 case '1': case '2': case '3': case '4': case '5':
4022 case '6': case '7': case '8': case '9':
4023 qualifiers
= (*pp
)[1] - '0';
4024 /* Skip an optional underscore after the count. */
4025 if ((*pp
)[2] == '_')
4032 stab_bad_demangle (orig
);
4036 context
= DEBUG_TYPE_NULL
;
4038 /* Pick off the names. */
4039 while (qualifiers
-- > 0)
4047 if (! stab_demangle_template (minfo
, pp
,
4048 ptype
!= NULL
? &name
: NULL
))
4053 context
= stab_find_tagged_type (minfo
->dhandle
, minfo
->info
,
4054 name
, strlen (name
),
4057 if (context
== DEBUG_TYPE_NULL
)
4065 len
= stab_demangle_count (pp
);
4066 if (strlen (*pp
) < len
)
4068 stab_bad_demangle (orig
);
4074 const debug_field
*fields
;
4077 if (context
!= DEBUG_TYPE_NULL
)
4078 fields
= debug_get_fields (minfo
->dhandle
, context
);
4080 context
= DEBUG_TYPE_NULL
;
4086 /* Try to find the type by looking through the
4087 fields of context until we find a field with the
4088 same type. This ought to work for a class
4089 defined within a class, but it won't work for,
4090 e.g., an enum defined within a class. stabs does
4091 not give us enough information to figure out the
4094 name
= savestring (*pp
, len
);
4096 for (; *fields
!= DEBUG_FIELD_NULL
; fields
++)
4101 ft
= debug_get_field_type (minfo
->dhandle
, *fields
);
4104 dn
= debug_get_type_name (minfo
->dhandle
, ft
);
4105 if (dn
!= NULL
&& strcmp (dn
, name
) == 0)
4115 if (context
== DEBUG_TYPE_NULL
)
4117 /* We have to fall back on finding the type by name.
4118 If there are more types to come, then this must
4119 be a class. Otherwise, it could be anything. */
4121 if (qualifiers
== 0)
4125 name
= savestring (*pp
, len
);
4126 context
= debug_find_named_type (minfo
->dhandle
,
4131 if (context
== DEBUG_TYPE_NULL
)
4133 context
= stab_find_tagged_type (minfo
->dhandle
,
4137 ? DEBUG_KIND_ILLEGAL
4138 : DEBUG_KIND_CLASS
));
4139 if (context
== DEBUG_TYPE_NULL
)
4155 /* Demangle a template. If PNAME is not NULL, this sets *PNAME to a
4156 string representation of the template. */
4159 stab_demangle_template (struct stab_demangle_info
*minfo
, const char **pp
,
4169 /* Skip the template name. */
4170 r
= stab_demangle_count (pp
);
4171 if (r
== 0 || strlen (*pp
) < r
)
4173 stab_bad_demangle (orig
);
4178 /* Get the size of the parameter list. */
4179 if (stab_demangle_get_count (pp
, &r
) == 0)
4181 stab_bad_demangle (orig
);
4185 for (i
= 0; i
< r
; i
++)
4189 /* This is a type parameter. */
4191 if (! stab_demangle_type (minfo
, pp
, (debug_type
*) NULL
))
4197 bfd_boolean pointerp
, realp
, integralp
, charp
, boolp
;
4208 /* This is a value parameter. */
4210 if (! stab_demangle_type (minfo
, pp
, (debug_type
*) NULL
))
4213 while (*old_p
!= '\0' && ! done
)
4223 case 'C': /* Const. */
4224 case 'S': /* Signed. */
4225 case 'U': /* Unsigned. */
4226 case 'V': /* Volatile. */
4227 case 'F': /* Function. */
4228 case 'M': /* Member function. */
4232 case 'Q': /* Qualified name. */
4236 case 'T': /* Remembered type. */
4238 case 'v': /* Void. */
4240 case 'x': /* Long long. */
4241 case 'l': /* Long. */
4242 case 'i': /* Int. */
4243 case 's': /* Short. */
4244 case 'w': /* Wchar_t. */
4248 case 'b': /* Bool. */
4252 case 'c': /* Char. */
4256 case 'r': /* Long double. */
4257 case 'd': /* Double. */
4258 case 'f': /* Float. */
4263 /* Assume it's a user defined integral type. */
4274 while (ISDIGIT (**pp
))
4283 val
= stab_demangle_count (pp
);
4286 stab_bad_demangle (orig
);
4294 val
= stab_demangle_count (pp
);
4295 if (val
!= 0 && val
!= 1)
4297 stab_bad_demangle (orig
);
4305 while (ISDIGIT (**pp
))
4310 while (ISDIGIT (**pp
))
4316 while (ISDIGIT (**pp
))
4324 len
= stab_demangle_count (pp
);
4327 stab_bad_demangle (orig
);
4335 /* We can translate this to a string fairly easily by invoking the
4336 regular demangling routine. */
4339 char *s1
, *s2
, *s3
, *s4
= NULL
;
4342 s1
= savestring (orig
, *pp
- orig
);
4344 s2
= concat ("NoSuchStrinG__", s1
, (const char *) NULL
);
4348 s3
= cplus_demangle (s2
, DMGL_ANSI
);
4353 s4
= strstr (s3
, "::NoSuchStrinG");
4354 if (s3
== NULL
|| s4
== NULL
)
4356 stab_bad_demangle (orig
);
4362 /* Eliminating all spaces, except those between > characters,
4363 makes it more likely that the demangled name will match the
4364 name which g++ used as the structure name. */
4365 for (from
= to
= s3
; from
!= s4
; ++from
)
4367 || (from
[1] == '>' && from
> s3
&& from
[-1] == '>'))
4370 *pname
= savestring (s3
, to
- s3
);
4378 /* Demangle a class name. */
4381 stab_demangle_class (struct stab_demangle_info
*minfo ATTRIBUTE_UNUSED
,
4382 const char **pp
, const char **pstart
)
4389 n
= stab_demangle_count (pp
);
4390 if (strlen (*pp
) < n
)
4392 stab_bad_demangle (orig
);
4404 /* Demangle function arguments. If the pargs argument is not NULL, it
4405 is set to a NULL terminated array holding the arguments. */
4408 stab_demangle_args (struct stab_demangle_info
*minfo
, const char **pp
,
4409 debug_type
**pargs
, bfd_boolean
*pvarargs
)
4412 unsigned int alloc
, count
;
4419 *pargs
= (debug_type
*) xmalloc (alloc
* sizeof **pargs
);
4424 while (**pp
!= '_' && **pp
!= '\0' && **pp
!= 'e')
4426 if (**pp
== 'N' || **pp
== 'T')
4434 if (temptype
== 'T')
4438 if (! stab_demangle_get_count (pp
, &r
))
4440 stab_bad_demangle (orig
);
4445 if (! stab_demangle_get_count (pp
, &t
))
4447 stab_bad_demangle (orig
);
4451 if (t
>= minfo
->typestring_count
)
4453 stab_bad_demangle (orig
);
4460 tem
= minfo
->typestrings
[t
].typestring
;
4461 if (! stab_demangle_arg (minfo
, &tem
, pargs
, &count
, &alloc
))
4467 if (! stab_demangle_arg (minfo
, pp
, pargs
, &count
, &alloc
))
4473 (*pargs
)[count
] = DEBUG_TYPE_NULL
;
4485 /* Demangle a single argument. */
4488 stab_demangle_arg (struct stab_demangle_info
*minfo
, const char **pp
,
4489 debug_type
**pargs
, unsigned int *pcount
,
4490 unsigned int *palloc
)
4496 if (! stab_demangle_type (minfo
, pp
,
4497 pargs
== NULL
? (debug_type
*) NULL
: &type
)
4498 || ! stab_demangle_remember_type (minfo
, start
, *pp
- start
))
4503 if (type
== DEBUG_TYPE_NULL
)
4506 if (*pcount
+ 1 >= *palloc
)
4509 *pargs
= ((debug_type
*)
4510 xrealloc (*pargs
, *palloc
* sizeof **pargs
));
4512 (*pargs
)[*pcount
] = type
;
4519 /* Demangle a type. If the ptype argument is not NULL, *ptype is set
4520 to the newly allocated type. */
4523 stab_demangle_type (struct stab_demangle_info
*minfo
, const char **pp
,
4534 /* A pointer type. */
4536 if (! stab_demangle_type (minfo
, pp
, ptype
))
4539 *ptype
= debug_make_pointer_type (minfo
->dhandle
, *ptype
);
4543 /* A reference type. */
4545 if (! stab_demangle_type (minfo
, pp
, ptype
))
4548 *ptype
= debug_make_reference_type (minfo
->dhandle
, *ptype
);
4558 while (**pp
!= '\0' && **pp
!= '_')
4560 if (! ISDIGIT (**pp
))
4562 stab_bad_demangle (orig
);
4571 stab_bad_demangle (orig
);
4576 if (! stab_demangle_type (minfo
, pp
, ptype
))
4580 debug_type int_type
;
4582 int_type
= debug_find_named_type (minfo
->dhandle
, "int");
4583 if (int_type
== NULL
)
4584 int_type
= debug_make_int_type (minfo
->dhandle
, 4, FALSE
);
4585 *ptype
= debug_make_array_type (minfo
->dhandle
, *ptype
, int_type
,
4592 /* A back reference to a remembered type. */
4598 if (! stab_demangle_get_count (pp
, &i
))
4600 stab_bad_demangle (orig
);
4603 if (i
>= minfo
->typestring_count
)
4605 stab_bad_demangle (orig
);
4608 p
= minfo
->typestrings
[i
].typestring
;
4609 if (! stab_demangle_type (minfo
, &p
, ptype
))
4618 bfd_boolean varargs
;
4621 if (! stab_demangle_args (minfo
, pp
,
4623 ? (debug_type
**) NULL
4626 ? (bfd_boolean
*) NULL
4631 /* cplus_demangle will accept a function without a return
4632 type, but I don't know when that will happen, or what
4633 to do if it does. */
4634 stab_bad_demangle (orig
);
4638 if (! stab_demangle_type (minfo
, pp
, ptype
))
4641 *ptype
= debug_make_function_type (minfo
->dhandle
, *ptype
, args
,
4650 bfd_boolean memberp
, constp
, volatilep
;
4651 debug_type class_type
= DEBUG_TYPE_NULL
;
4653 bfd_boolean varargs
;
4657 memberp
= **pp
== 'M';
4666 n
= stab_demangle_count (pp
);
4667 if (strlen (*pp
) < n
)
4669 stab_bad_demangle (orig
);
4677 class_type
= stab_find_tagged_type (minfo
->dhandle
,
4681 if (class_type
== DEBUG_TYPE_NULL
)
4685 else if (**pp
== 'Q')
4687 if (! stab_demangle_qualified (minfo
, pp
,
4689 ? (debug_type
*) NULL
4695 stab_bad_demangle (orig
);
4706 else if (**pp
== 'V')
4713 stab_bad_demangle (orig
);
4717 if (! stab_demangle_args (minfo
, pp
,
4719 ? (debug_type
**) NULL
4722 ? (bfd_boolean
*) NULL
4729 stab_bad_demangle (orig
);
4734 if (! stab_demangle_type (minfo
, pp
, ptype
))
4740 *ptype
= debug_make_offset_type (minfo
->dhandle
, class_type
,
4744 /* FIXME: We have no way to record constp or
4746 *ptype
= debug_make_method_type (minfo
->dhandle
, *ptype
,
4747 class_type
, args
, varargs
);
4755 if (! stab_demangle_type (minfo
, pp
, ptype
))
4761 if (! stab_demangle_type (minfo
, pp
, ptype
))
4764 *ptype
= debug_make_const_type (minfo
->dhandle
, *ptype
);
4772 if (! stab_demangle_qualified (minfo
, pp
, ptype
))
4778 if (! stab_demangle_fund_type (minfo
, pp
, ptype
))
4786 /* Demangle a fundamental type. If the ptype argument is not NULL,
4787 *ptype is set to the newly allocated type. */
4790 stab_demangle_fund_type (struct stab_demangle_info
*minfo
, const char **pp
,
4794 bfd_boolean constp
, volatilep
, unsignedp
, signedp
;
4839 /* cplus_demangle permits this, but I don't know what it means. */
4840 stab_bad_demangle (orig
);
4843 case 'v': /* void */
4846 *ptype
= debug_find_named_type (minfo
->dhandle
, "void");
4847 if (*ptype
== DEBUG_TYPE_NULL
)
4848 *ptype
= debug_make_void_type (minfo
->dhandle
);
4853 case 'x': /* long long */
4856 *ptype
= debug_find_named_type (minfo
->dhandle
,
4858 ? "long long unsigned int"
4859 : "long long int"));
4860 if (*ptype
== DEBUG_TYPE_NULL
)
4861 *ptype
= debug_make_int_type (minfo
->dhandle
, 8, unsignedp
);
4866 case 'l': /* long */
4869 *ptype
= debug_find_named_type (minfo
->dhandle
,
4871 ? "long unsigned int"
4873 if (*ptype
== DEBUG_TYPE_NULL
)
4874 *ptype
= debug_make_int_type (minfo
->dhandle
, 4, unsignedp
);
4882 *ptype
= debug_find_named_type (minfo
->dhandle
,
4886 if (*ptype
== DEBUG_TYPE_NULL
)
4887 *ptype
= debug_make_int_type (minfo
->dhandle
, 4, unsignedp
);
4892 case 's': /* short */
4895 *ptype
= debug_find_named_type (minfo
->dhandle
,
4897 ? "short unsigned int"
4899 if (*ptype
== DEBUG_TYPE_NULL
)
4900 *ptype
= debug_make_int_type (minfo
->dhandle
, 2, unsignedp
);
4905 case 'b': /* bool */
4908 *ptype
= debug_find_named_type (minfo
->dhandle
, "bool");
4909 if (*ptype
== DEBUG_TYPE_NULL
)
4910 *ptype
= debug_make_bool_type (minfo
->dhandle
, 4);
4915 case 'c': /* char */
4918 *ptype
= debug_find_named_type (minfo
->dhandle
,
4924 if (*ptype
== DEBUG_TYPE_NULL
)
4925 *ptype
= debug_make_int_type (minfo
->dhandle
, 1, unsignedp
);
4930 case 'w': /* wchar_t */
4933 *ptype
= debug_find_named_type (minfo
->dhandle
, "__wchar_t");
4934 if (*ptype
== DEBUG_TYPE_NULL
)
4935 *ptype
= debug_make_int_type (minfo
->dhandle
, 2, TRUE
);
4940 case 'r': /* long double */
4943 *ptype
= debug_find_named_type (minfo
->dhandle
, "long double");
4944 if (*ptype
== DEBUG_TYPE_NULL
)
4945 *ptype
= debug_make_float_type (minfo
->dhandle
, 8);
4950 case 'd': /* double */
4953 *ptype
= debug_find_named_type (minfo
->dhandle
, "double");
4954 if (*ptype
== DEBUG_TYPE_NULL
)
4955 *ptype
= debug_make_float_type (minfo
->dhandle
, 8);
4960 case 'f': /* float */
4963 *ptype
= debug_find_named_type (minfo
->dhandle
, "float");
4964 if (*ptype
== DEBUG_TYPE_NULL
)
4965 *ptype
= debug_make_float_type (minfo
->dhandle
, 4);
4972 if (! ISDIGIT (**pp
))
4974 stab_bad_demangle (orig
);
4978 case '0': case '1': case '2': case '3': case '4':
4979 case '5': case '6': case '7': case '8': case '9':
4983 if (! stab_demangle_class (minfo
, pp
, &hold
))
4989 name
= savestring (hold
, *pp
- hold
);
4990 *ptype
= debug_find_named_type (minfo
->dhandle
, name
);
4992 if (*ptype
== DEBUG_TYPE_NULL
)
4994 /* FIXME: It is probably incorrect to assume that
4995 undefined types are tagged types. */
4996 *ptype
= stab_find_tagged_type (minfo
->dhandle
, minfo
->info
,
4998 DEBUG_KIND_ILLEGAL
);
4999 if (*ptype
== DEBUG_TYPE_NULL
)
5010 if (! stab_demangle_template (minfo
, pp
,
5011 ptype
!= NULL
? &name
: NULL
))
5015 *ptype
= stab_find_tagged_type (minfo
->dhandle
, minfo
->info
,
5016 name
, strlen (name
),
5019 if (*ptype
== DEBUG_TYPE_NULL
)
5026 stab_bad_demangle (orig
);
5033 *ptype
= debug_make_const_type (minfo
->dhandle
, *ptype
);
5035 *ptype
= debug_make_volatile_type (minfo
->dhandle
, *ptype
);
5041 /* Remember a type string in a demangled string. */
5044 stab_demangle_remember_type (struct stab_demangle_info
*minfo
,
5045 const char *p
, int len
)
5047 if (minfo
->typestring_count
>= minfo
->typestring_alloc
)
5049 minfo
->typestring_alloc
+= 10;
5050 minfo
->typestrings
= ((struct stab_demangle_typestring
*)
5051 xrealloc (minfo
->typestrings
,
5052 (minfo
->typestring_alloc
5053 * sizeof *minfo
->typestrings
)));
5056 minfo
->typestrings
[minfo
->typestring_count
].typestring
= p
;
5057 minfo
->typestrings
[minfo
->typestring_count
].len
= (unsigned int) len
;
5058 ++minfo
->typestring_count
;
5063 /* Demangle names encoded using the g++ V3 ABI. The newer versions of
5064 g++ which use this ABI do not encode ordinary method argument types
5065 in a mangled name; they simply output the argument types. However,
5066 for a static method, g++ simply outputs the return type and the
5067 physical name. So in that case we need to demangle the name here.
5068 Here PHYSNAME is the physical name of the function, and we set the
5069 variable pointed at by PVARARGS to indicate whether this function
5070 is varargs. This returns NULL, or a NULL terminated array of
5074 stab_demangle_v3_argtypes (void *dhandle
, struct stab_handle
*info
,
5075 const char *physname
, bfd_boolean
*pvarargs
)
5077 struct demangle_component
*dc
;
5081 dc
= cplus_demangle_v3_components (physname
, DMGL_PARAMS
| DMGL_ANSI
, &mem
);
5084 stab_bad_demangle (physname
);
5088 /* We expect to see TYPED_NAME, and the right subtree describes the
5090 if (dc
->type
!= DEMANGLE_COMPONENT_TYPED_NAME
5091 || dc
->u
.s_binary
.right
->type
!= DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5093 fprintf (stderr
, _("Demangled name is not a function\n"));
5098 pargs
= stab_demangle_v3_arglist (dhandle
, info
,
5099 dc
->u
.s_binary
.right
->u
.s_binary
.right
,
5107 /* Demangle an argument list in a struct demangle_component tree.
5108 Returns a DEBUG_TYPE_NULL terminated array of argument types, and
5109 sets *PVARARGS to indicate whether this is a varargs function. */
5112 stab_demangle_v3_arglist (void *dhandle
, struct stab_handle
*info
,
5113 struct demangle_component
*arglist
,
5114 bfd_boolean
*pvarargs
)
5116 struct demangle_component
*dc
;
5117 unsigned int alloc
, count
;
5121 pargs
= (debug_type
*) xmalloc (alloc
* sizeof *pargs
);
5128 dc
= dc
->u
.s_binary
.right
)
5131 bfd_boolean varargs
;
5133 if (dc
->type
!= DEMANGLE_COMPONENT_ARGLIST
)
5135 fprintf (stderr
, _("Unexpected type in v3 arglist demangling\n"));
5140 arg
= stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.left
,
5153 if (count
+ 1 >= alloc
)
5156 pargs
= (debug_type
*) xrealloc (pargs
, alloc
* sizeof *pargs
);
5163 pargs
[count
] = DEBUG_TYPE_NULL
;
5168 /* Convert a struct demangle_component tree describing an argument
5169 type into a debug_type. */
5172 stab_demangle_v3_arg (void *dhandle
, struct stab_handle
*info
,
5173 struct demangle_component
*dc
, debug_type context
,
5174 bfd_boolean
*pvarargs
)
5178 if (pvarargs
!= NULL
)
5183 /* FIXME: These are demangle component types which we probably
5184 need to handle one way or another. */
5185 case DEMANGLE_COMPONENT_LOCAL_NAME
:
5186 case DEMANGLE_COMPONENT_TYPED_NAME
:
5187 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
5188 case DEMANGLE_COMPONENT_CTOR
:
5189 case DEMANGLE_COMPONENT_DTOR
:
5190 case DEMANGLE_COMPONENT_JAVA_CLASS
:
5191 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
5192 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
5193 case DEMANGLE_COMPONENT_CONST_THIS
:
5194 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5195 case DEMANGLE_COMPONENT_COMPLEX
:
5196 case DEMANGLE_COMPONENT_IMAGINARY
:
5197 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
5198 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
5199 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
5200 case DEMANGLE_COMPONENT_ARGLIST
:
5202 fprintf (stderr
, _("Unrecognized demangle component %d\n"),
5206 case DEMANGLE_COMPONENT_NAME
:
5207 if (context
!= NULL
)
5209 const debug_field
*fields
;
5211 fields
= debug_get_fields (dhandle
, context
);
5214 /* Try to find this type by looking through the context
5216 for (; *fields
!= DEBUG_FIELD_NULL
; fields
++)
5221 ft
= debug_get_field_type (dhandle
, *fields
);
5224 dn
= debug_get_type_name (dhandle
, ft
);
5226 && (int) strlen (dn
) == dc
->u
.s_name
.len
5227 && strncmp (dn
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
) == 0)
5232 return stab_find_tagged_type (dhandle
, info
, dc
->u
.s_name
.s
,
5233 dc
->u
.s_name
.len
, DEBUG_KIND_ILLEGAL
);
5235 case DEMANGLE_COMPONENT_QUAL_NAME
:
5236 context
= stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.left
,
5238 if (context
== NULL
)
5240 return stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.right
,
5243 case DEMANGLE_COMPONENT_TEMPLATE
:
5248 /* We print this component to get a class name which we can
5249 use. FIXME: This probably won't work if the template uses
5250 template parameters which refer to an outer template. */
5251 p
= cplus_demangle_print (DMGL_PARAMS
| DMGL_ANSI
, dc
, 20, &alc
);
5254 fprintf (stderr
, _("Failed to print demangled template\n"));
5257 dt
= stab_find_tagged_type (dhandle
, info
, p
, strlen (p
),
5263 case DEMANGLE_COMPONENT_SUB_STD
:
5264 return stab_find_tagged_type (dhandle
, info
, dc
->u
.s_string
.string
,
5265 dc
->u
.s_string
.len
, DEBUG_KIND_ILLEGAL
);
5267 case DEMANGLE_COMPONENT_RESTRICT
:
5268 case DEMANGLE_COMPONENT_VOLATILE
:
5269 case DEMANGLE_COMPONENT_CONST
:
5270 case DEMANGLE_COMPONENT_POINTER
:
5271 case DEMANGLE_COMPONENT_REFERENCE
:
5272 dt
= stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.left
, NULL
,
5281 case DEMANGLE_COMPONENT_RESTRICT
:
5282 /* FIXME: We have no way to represent restrict. */
5284 case DEMANGLE_COMPONENT_VOLATILE
:
5285 return debug_make_volatile_type (dhandle
, dt
);
5286 case DEMANGLE_COMPONENT_CONST
:
5287 return debug_make_const_type (dhandle
, dt
);
5288 case DEMANGLE_COMPONENT_POINTER
:
5289 return debug_make_pointer_type (dhandle
, dt
);
5290 case DEMANGLE_COMPONENT_REFERENCE
:
5291 return debug_make_reference_type (dhandle
, dt
);
5294 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
5297 bfd_boolean varargs
;
5299 if (dc
->u
.s_binary
.left
== NULL
)
5301 /* In this case the return type is actually unknown.
5302 However, I'm not sure this will ever arise in practice;
5303 normally an unknown return type would only appear at
5304 the top level, which is handled above. */
5305 dt
= debug_make_void_type (dhandle
);
5308 dt
= stab_demangle_v3_arg (dhandle
, info
, dc
->u
.s_binary
.left
, NULL
,
5313 pargs
= stab_demangle_v3_arglist (dhandle
, info
,
5314 dc
->u
.s_binary
.right
,
5319 return debug_make_function_type (dhandle
, dt
, pargs
, varargs
);
5322 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
5328 /* We print this component in order to find out the type name.
5329 FIXME: Should we instead expose the
5330 demangle_builtin_type_info structure? */
5331 p
= cplus_demangle_print (DMGL_PARAMS
| DMGL_ANSI
, dc
, 20, &alc
);
5334 fprintf (stderr
, _("Couldn't get demangled builtin type\n"));
5338 /* The mangling is based on the type, but does not itself
5339 indicate what the sizes are. So we have to guess. */
5340 if (strcmp (p
, "signed char") == 0)
5341 ret
= debug_make_int_type (dhandle
, 1, FALSE
);
5342 else if (strcmp (p
, "bool") == 0)
5343 ret
= debug_make_bool_type (dhandle
, 1);
5344 else if (strcmp (p
, "char") == 0)
5345 ret
= debug_make_int_type (dhandle
, 1, FALSE
);
5346 else if (strcmp (p
, "double") == 0)
5347 ret
= debug_make_float_type (dhandle
, 8);
5348 else if (strcmp (p
, "long double") == 0)
5349 ret
= debug_make_float_type (dhandle
, 8);
5350 else if (strcmp (p
, "float") == 0)
5351 ret
= debug_make_float_type (dhandle
, 4);
5352 else if (strcmp (p
, "__float128") == 0)
5353 ret
= debug_make_float_type (dhandle
, 16);
5354 else if (strcmp (p
, "unsigned char") == 0)
5355 ret
= debug_make_int_type (dhandle
, 1, TRUE
);
5356 else if (strcmp (p
, "int") == 0)
5357 ret
= debug_make_int_type (dhandle
, 4, FALSE
);
5358 else if (strcmp (p
, "unsigned int") == 0)
5359 ret
= debug_make_int_type (dhandle
, 4, TRUE
);
5360 else if (strcmp (p
, "long") == 0)
5361 ret
= debug_make_int_type (dhandle
, 4, FALSE
);
5362 else if (strcmp (p
, "unsigned long") == 0)
5363 ret
= debug_make_int_type (dhandle
, 4, TRUE
);
5364 else if (strcmp (p
, "__int128") == 0)
5365 ret
= debug_make_int_type (dhandle
, 16, FALSE
);
5366 else if (strcmp (p
, "unsigned __int128") == 0)
5367 ret
= debug_make_int_type (dhandle
, 16, TRUE
);
5368 else if (strcmp (p
, "short") == 0)
5369 ret
= debug_make_int_type (dhandle
, 2, FALSE
);
5370 else if (strcmp (p
, "unsigned short") == 0)
5371 ret
= debug_make_int_type (dhandle
, 2, TRUE
);
5372 else if (strcmp (p
, "void") == 0)
5373 ret
= debug_make_void_type (dhandle
);
5374 else if (strcmp (p
, "wchar_t") == 0)
5375 ret
= debug_make_int_type (dhandle
, 4, TRUE
);
5376 else if (strcmp (p
, "long long") == 0)
5377 ret
= debug_make_int_type (dhandle
, 8, FALSE
);
5378 else if (strcmp (p
, "unsigned long long") == 0)
5379 ret
= debug_make_int_type (dhandle
, 8, TRUE
);
5380 else if (strcmp (p
, "...") == 0)
5382 if (pvarargs
== NULL
)
5383 fprintf (stderr
, _("Unexpected demangled varargs\n"));
5390 fprintf (stderr
, _("Unrecognized demangled builtin type\n"));