1
/* stabs.c -- Parse stabs debugging information
2
Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3
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 2 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., 59 Temple Place - Suite 330, 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. */
32
#include "libiberty.h"
33
#include "safe-ctype.h"
37
#include "filenames.h"
38
#include "aout/aout64.h"
39
#include "aout/stab_gnu.h"
41
/* The number of predefined XCOFF types. */
43
#define XCOFF_TYPE_COUNT 34
45
/* This structure is used as a handle so that the stab parsing doesn't
46
need to use any static variables. */
52
/* TRUE if this is stabs in sections. */
54
/* The symbol table. */
56
/* The number of symbols. */
58
/* The accumulated file name string. */
60
/* The value of the last N_SO symbol. */
62
/* The value of the start of the file, so that we can handle file
63
relative N_LBRAC and N_RBRAC symbols. */
64
bfd_vma file_start_offset;
65
/* The offset of the start of the function, so that we can handle
66
function relative N_LBRAC and N_RBRAC symbols. */
67
bfd_vma function_start_offset;
68
/* The version number of gcc which compiled the current compilation
69
unit, 0 if not compiled by gcc. */
71
/* Whether an N_OPT symbol was seen that was not generated by gcc,
72
so that we can detect the SunPRO compiler. */
73
bfd_boolean n_opt_found;
74
/* The main file name. */
76
/* A stack of unfinished N_BINCL files. */
77
struct bincl_file *bincl_stack;
78
/* A list of finished N_BINCL files. */
79
struct bincl_file *bincl_list;
80
/* Whether we are inside a function or not. */
81
bfd_boolean within_function;
82
/* The address of the end of the function, used if we have seen an
83
N_FUN symbol while in a function. This is -1 if we have not seen
84
an N_FUN (the normal case). */
86
/* The depth of block nesting. */
88
/* List of pending variable definitions. */
89
struct stab_pending_var *pending;
90
/* Number of files for which we have types. */
92
/* Lists of types per file. */
93
struct stab_types **file_types;
94
/* Predefined XCOFF types. */
95
debug_type xcoff_types[XCOFF_TYPE_COUNT];
97
struct stab_tag *tags;
98
/* Set by parse_stab_type if it sees a structure defined as a cross
99
reference to itself. Reset by parse_stab_type otherwise. */
100
bfd_boolean self_crossref;
103
/* A list of these structures is used to hold pending variable
104
definitions seen before the N_LBRAC of a block. */
106
struct stab_pending_var
108
/* Next pending variable definition. */
109
struct stab_pending_var *next;
115
enum debug_var_kind kind;
120
/* A list of these structures is used to hold the types for a single
125
/* Next set of slots for this file. */
126
struct stab_types *next;
127
/* Types indexed by type number. */
128
#define STAB_TYPES_SLOTS (16)
129
debug_type types[STAB_TYPES_SLOTS];
132
/* We keep a list of undefined tags that we encounter, so that we can
133
fill them in if the tag is later defined. */
137
/* Next undefined tag. */
138
struct stab_tag *next;
142
enum debug_type_kind kind;
143
/* Slot to hold real type when we discover it. If we don't, we fill
144
in an undefined tag type. */
146
/* Indirect type we have created to point at slot. */
150
static char *savestring (const char *, int);
151
static bfd_vma parse_number (const char **, bfd_boolean *);
152
static void bad_stab (const char *);
153
static void warn_stab (const char *, const char *);
154
static bfd_boolean parse_stab_string
155
(void *, struct stab_handle *, int, int, bfd_vma, const char *);
156
static debug_type parse_stab_type
157
(void *, struct stab_handle *, const char *, const char **, debug_type **);
158
static bfd_boolean parse_stab_type_number (const char **, int *);
159
static debug_type parse_stab_range_type
160
(void *, struct stab_handle *, const char *, const char **, const int *);
161
static debug_type parse_stab_sun_builtin_type (void *, const char **);
162
static debug_type parse_stab_sun_floating_type (void *, const char **);
163
static debug_type parse_stab_enum_type (void *, const char **);
164
static debug_type parse_stab_struct_type
165
(void *, struct stab_handle *, const char *, const char **,
166
bfd_boolean, const int *);
167
static bfd_boolean parse_stab_baseclasses
168
(void *, struct stab_handle *, const char **, debug_baseclass **);
169
static bfd_boolean parse_stab_struct_fields
170
(void *, struct stab_handle *, const char **, debug_field **, bfd_boolean *);
171
static bfd_boolean parse_stab_cpp_abbrev
172
(void *, struct stab_handle *, const char **, debug_field *);
173
static bfd_boolean parse_stab_one_struct_field
174
(void *, struct stab_handle *, const char **, const char *,
175
debug_field *, bfd_boolean *);
176
static bfd_boolean parse_stab_members
177
(void *, struct stab_handle *, const char *, const char **, const int *,
179
static debug_type parse_stab_argtypes
180
(void *, struct stab_handle *, debug_type, const char *, const char *,
181
debug_type, const char *, bfd_boolean, bfd_boolean, const char **);
182
static bfd_boolean parse_stab_tilde_field
183
(void *, struct stab_handle *, const char **, const int *, debug_type *,
185
static debug_type parse_stab_array_type
186
(void *, struct stab_handle *, const char **, bfd_boolean);
187
static void push_bincl (struct stab_handle *, const char *, bfd_vma);
188
static const char *pop_bincl (struct stab_handle *);
189
static bfd_boolean find_excl (struct stab_handle *, const char *, bfd_vma);
190
static bfd_boolean stab_record_variable
191
(void *, struct stab_handle *, const char *, debug_type,
192
enum debug_var_kind, bfd_vma);
193
static bfd_boolean stab_emit_pending_vars (void *, struct stab_handle *);
194
static debug_type *stab_find_slot (struct stab_handle *, const int *);
195
static debug_type stab_find_type (void *, struct stab_handle *, const int *);
196
static bfd_boolean stab_record_type
197
(void *, struct stab_handle *, const int *, debug_type);
198
static debug_type stab_xcoff_builtin_type
199
(void *, struct stab_handle *, int);
200
static debug_type stab_find_tagged_type
201
(void *, struct stab_handle *, const char *, int, enum debug_type_kind);
202
static debug_type *stab_demangle_argtypes
203
(void *, struct stab_handle *, const char *, bfd_boolean *, unsigned int);
205
/* Save a string in memory. */
208
savestring (const char *start, int len)
212
ret = (char *) xmalloc (len + 1);
213
memcpy (ret, start, len);
218
/* Read a number from a string. */
221
parse_number (const char **pp, bfd_boolean *poverflow)
226
if (poverflow != NULL)
232
ul = strtoul (*pp, (char **) pp, 0);
233
if (ul + 1 != 0 || errno == 0)
235
/* If bfd_vma is larger than unsigned long, and the number is
236
meant to be negative, we have to make sure that we sign
239
return (bfd_vma) (bfd_signed_vma) (long) ul;
243
/* Note that even though strtoul overflowed, it should have set *pp
244
to the end of the number, which is where we want it. */
245
if (sizeof (bfd_vma) > sizeof (unsigned long))
250
bfd_vma over, lastdig;
251
bfd_boolean overflow;
254
/* Our own version of strtoul, for a bfd_vma. */
269
if (p[1] == 'x' || p[1] == 'X')
281
over = ((bfd_vma) (bfd_signed_vma) -1) / (bfd_vma) base;
282
lastdig = ((bfd_vma) (bfd_signed_vma) -1) % (bfd_vma) base;
293
else if (ISUPPER (d))
295
else if (ISLOWER (d))
303
if (v > over || (v == over && (bfd_vma) d > lastdig))
318
/* If we get here, the number is too large to represent in a
320
if (poverflow != NULL)
323
warn_stab (orig, _("numeric overflow"));
328
/* Give an error for a bad stab string. */
331
bad_stab (const char *p)
333
fprintf (stderr, _("Bad stab: %s\n"), p);
336
/* Warn about something in a stab string. */
339
warn_stab (const char *p, const char *err)
341
fprintf (stderr, _("Warning: %s: %s\n"), err, p);
344
/* Create a handle to parse stabs symbols with. */
347
start_stab (void *dhandle ATTRIBUTE_UNUSED, bfd *abfd, bfd_boolean sections,
348
asymbol **syms, long symcount)
350
struct stab_handle *ret;
352
ret = (struct stab_handle *) xmalloc (sizeof *ret);
353
memset (ret, 0, sizeof *ret);
355
ret->sections = sections;
357
ret->symcount = symcount;
359
ret->file_types = (struct stab_types **) xmalloc (sizeof *ret->file_types);
360
ret->file_types[0] = NULL;
361
ret->function_end = (bfd_vma) -1;
365
/* When we have processed all the stabs information, we need to go
366
through and fill in all the undefined tags. */
369
finish_stab (void *dhandle, void *handle)
371
struct stab_handle *info = (struct stab_handle *) handle;
374
if (info->within_function)
376
if (! stab_emit_pending_vars (dhandle, info)
377
|| ! debug_end_function (dhandle, info->function_end))
379
info->within_function = FALSE;
380
info->function_end = (bfd_vma) -1;
383
for (st = info->tags; st != NULL; st = st->next)
385
enum debug_type_kind kind;
388
if (kind == DEBUG_KIND_ILLEGAL)
389
kind = DEBUG_KIND_STRUCT;
390
st->slot = debug_make_undefined_tagged_type (dhandle, st->name, kind);
391
if (st->slot == DEBUG_TYPE_NULL)
398
/* Handle a single stabs symbol. */
401
parse_stab (void *dhandle, void *handle, int type, int desc, bfd_vma value,
404
struct stab_handle *info = (struct stab_handle *) handle;
406
/* gcc will emit two N_SO strings per compilation unit, one for the
407
directory name and one for the file name. We just collect N_SO
408
strings as we see them, and start the new compilation unit when
409
we see a non N_SO symbol. */
410
if (info->so_string != NULL
411
&& (type != N_SO || *string == '\0' || value != info->so_value))
413
if (! debug_set_filename (dhandle, info->so_string))
415
info->main_filename = info->so_string;
417
info->gcc_compiled = 0;
418
info->n_opt_found = FALSE;
420
/* Generally, for stabs in the symbol table, the N_LBRAC and
421
N_RBRAC symbols are relative to the N_SO symbol value. */
422
if (! info->sections)
423
info->file_start_offset = info->so_value;
425
/* We need to reset the mapping from type numbers to types. We
426
can't free the old mapping, because of the use of
427
debug_make_indirect_type. */
429
info->file_types = ((struct stab_types **)
430
xmalloc (sizeof *info->file_types));
431
info->file_types[0] = NULL;
433
info->so_string = NULL;
435
/* Now process whatever type we just got. */
445
/* Ignore extra outermost context from SunPRO cc and acc. */
446
if (info->n_opt_found && desc == 1)
449
if (! info->within_function)
451
fprintf (stderr, _("N_LBRAC not within function\n"));
455
/* Start an inner lexical block. */
456
if (! debug_start_block (dhandle,
458
+ info->file_start_offset
459
+ info->function_start_offset)))
462
/* Emit any pending variable definitions. */
463
if (! stab_emit_pending_vars (dhandle, info))
470
/* Ignore extra outermost context from SunPRO cc and acc. */
471
if (info->n_opt_found && desc == 1)
474
/* We shouldn't have any pending variable definitions here, but,
475
if we do, we probably need to emit them before closing the
477
if (! stab_emit_pending_vars (dhandle, info))
480
/* End an inner lexical block. */
481
if (! debug_end_block (dhandle,
483
+ info->file_start_offset
484
+ info->function_start_offset)))
488
if (info->block_depth < 0)
490
fprintf (stderr, _("Too many N_RBRACs\n"));
496
/* This always ends a function. */
497
if (info->within_function)
503
&& info->function_end != (bfd_vma) -1
504
&& info->function_end < endval)
505
endval = info->function_end;
506
if (! stab_emit_pending_vars (dhandle, info)
507
|| ! debug_end_function (dhandle, endval))
509
info->within_function = FALSE;
510
info->function_end = (bfd_vma) -1;
513
/* An empty string is emitted by gcc at the end of a compilation
518
/* Just accumulate strings until we see a non N_SO symbol. If
519
the string starts with a directory separator or some other
520
form of absolute path specification, we discard the previously
521
accumulated strings. */
522
if (info->so_string == NULL)
523
info->so_string = xstrdup (string);
530
if (IS_ABSOLUTE_PATH (string))
531
info->so_string = xstrdup (string);
533
info->so_string = concat (info->so_string, string,
534
(const char *) NULL);
538
info->so_value = value;
543
/* Start an include file. */
544
if (! debug_start_source (dhandle, string))
549
/* Start an include file which may be replaced. */
550
push_bincl (info, string, value);
551
if (! debug_start_source (dhandle, string))
556
/* End an N_BINCL include. */
557
if (! debug_start_source (dhandle, pop_bincl (info)))
562
/* This is a duplicate of a header file named by N_BINCL which
563
was eliminated by the linker. */
564
if (! find_excl (info, string, value))
569
if (! debug_record_line (dhandle, desc,
570
value + (info->within_function
571
? info->function_start_offset : 0)))
576
if (! debug_start_common_block (dhandle, string))
581
if (! debug_end_common_block (dhandle, string))
588
if (info->within_function)
590
/* This always marks the end of a function; we don't
591
need to worry about info->function_end. */
593
value += info->function_start_offset;
594
if (! stab_emit_pending_vars (dhandle, info)
595
|| ! debug_end_function (dhandle, value))
597
info->within_function = FALSE;
598
info->function_end = (bfd_vma) -1;
603
/* A const static symbol in the .text section will have an N_FUN
604
entry. We need to use these to mark the end of the function,
605
in case we are looking at gcc output before it was changed to
606
always emit an empty N_FUN. We can't call debug_end_function
607
here, because it might be a local static symbol. */
608
if (info->within_function
609
&& (info->function_end == (bfd_vma) -1
610
|| value < info->function_end))
611
info->function_end = value;
614
/* FIXME: gdb checks the string for N_STSYM, N_LCSYM or N_ROSYM
615
symbols, and if it does not start with :S, gdb relocates the
616
value to the start of the section. gcc always seems to use
617
:S, so we don't worry about this. */
623
colon = strchr (string, ':');
625
&& (colon[1] == 'f' || colon[1] == 'F'))
627
if (info->within_function)
632
if (info->function_end != (bfd_vma) -1
633
&& info->function_end < endval)
634
endval = info->function_end;
635
if (! stab_emit_pending_vars (dhandle, info)
636
|| ! debug_end_function (dhandle, endval))
638
info->function_end = (bfd_vma) -1;
640
/* For stabs in sections, line numbers and block addresses
641
are offsets from the start of the function. */
643
info->function_start_offset = value;
644
info->within_function = TRUE;
647
if (! parse_stab_string (dhandle, info, type, desc, value, string))
653
if (string != NULL && strcmp (string, "gcc2_compiled.") == 0)
654
info->gcc_compiled = 2;
655
else if (string != NULL && strcmp (string, "gcc_compiled.") == 0)
656
info->gcc_compiled = 1;
658
info->n_opt_found = TRUE;
671
/* Parse the stabs string. */
674
parse_stab_string (void *dhandle, struct stab_handle *info, int stabtype,
675
int desc, bfd_vma value, const char *string)
682
bfd_boolean self_crossref;
686
p = strchr (string, ':');
701
/* GCC 2.x puts the line number in desc. SunOS apparently puts in
702
the number of bytes occupied by a type or object, which we
704
if (info->gcc_compiled >= 2)
709
/* FIXME: Sometimes the special C++ names start with '.'. */
711
if (string[0] == '$')
719
/* Was: name = "vptr"; */
725
/* This was an anonymous type that was never fixed up. */
728
/* SunPRO (3.0 at least) static variable encoding. */
731
warn_stab (string, _("unknown C++ encoded name"));
738
if (p == string || (string[0] == ' ' && p == string + 1))
741
name = savestring (string, p - string);
745
if (ISDIGIT (*p) || *p == '(' || *p == '-')
753
/* c is a special case, not followed by a type-number.
754
SYMBOL:c=iVALUE for an integer constant symbol.
755
SYMBOL:c=rVALUE for a floating constant symbol.
756
SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
757
e.g. "b:c=e6,0" for "const b = blob1"
758
(where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
768
/* Floating point constant. */
769
if (! debug_record_float_const (dhandle, name, atof (p)))
773
/* Integer constant. */
774
/* Defining integer constants this way is kind of silly,
775
since 'e' constants allows the compiler to give not only
776
the value, but the type as well. C has at least int,
777
long, unsigned int, and long long as constant types;
778
other languages probably should have at least unsigned as
779
well as signed constants. */
780
if (! debug_record_int_const (dhandle, name, atoi (p)))
784
/* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
785
can be represented as integral.
786
e.g. "b:c=e6,0" for "const b = blob1"
787
(where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
788
dtype = parse_stab_type (dhandle, info, (const char *) NULL,
789
&p, (debug_type **) NULL);
790
if (dtype == DEBUG_TYPE_NULL)
797
if (! debug_record_typed_const (dhandle, name, dtype, atoi (p)))
808
/* The name of a caught exception. */
809
dtype = parse_stab_type (dhandle, info, (const char *) NULL,
810
&p, (debug_type **) NULL);
811
if (dtype == DEBUG_TYPE_NULL)
813
if (! debug_record_label (dhandle, name, dtype, value))
819
/* A function definition. */
820
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
821
(debug_type **) NULL);
822
if (dtype == DEBUG_TYPE_NULL)
824
if (! debug_record_function (dhandle, name, dtype, type == 'F', value))
827
/* Sun acc puts declared types of arguments here. We don't care
828
about their actual types (FIXME -- we should remember the whole
829
function prototype), but the list may define some new types
830
that we have to remember, so we must scan it now. */
834
if (parse_stab_type (dhandle, info, (const char *) NULL, &p,
835
(debug_type **) NULL)
848
/* A global symbol. The value must be extracted from the
850
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
851
(debug_type **) NULL);
852
if (dtype == DEBUG_TYPE_NULL)
854
leading = bfd_get_symbol_leading_char (info->abfd);
855
for (c = info->symcount, ps = info->syms; c > 0; --c, ++ps)
859
n = bfd_asymbol_name (*ps);
860
if (leading != '\0' && *n == leading)
862
if (*n == *name && strcmp (n, name) == 0)
866
value = bfd_asymbol_value (*ps);
867
if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_GLOBAL,
873
/* This case is faked by a conditional above, when there is no
874
code letter in the dbx data. Dbx data never actually
878
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
879
(debug_type **) NULL);
880
if (dtype == DEBUG_TYPE_NULL)
882
if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL,
888
/* A function parameter. */
890
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
891
(debug_type **) NULL);
894
/* pF is a two-letter code that means a function parameter in
895
Fortran. The type-number specifies the type of the return
896
value. Translate it into a pointer-to-function type. */
898
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
899
(debug_type **) NULL);
900
if (dtype != DEBUG_TYPE_NULL)
904
ftype = debug_make_function_type (dhandle, dtype,
905
(debug_type *) NULL, FALSE);
906
dtype = debug_make_pointer_type (dhandle, ftype);
909
if (dtype == DEBUG_TYPE_NULL)
911
if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_STACK,
915
/* FIXME: At this point gdb considers rearranging the parameter
916
address on a big endian machine if it is smaller than an int.
917
We have no way to do that, since we don't really know much
922
if (stabtype == N_FUN)
924
/* Prototype of a function referenced by this file. */
928
if (parse_stab_type (dhandle, info, (const char *) NULL, &p,
929
(debug_type **) NULL)
937
/* Parameter which is in a register. */
938
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
939
(debug_type **) NULL);
940
if (dtype == DEBUG_TYPE_NULL)
942
if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REG,
948
/* Register variable (either global or local). */
949
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
950
(debug_type **) NULL);
951
if (dtype == DEBUG_TYPE_NULL)
953
if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_REGISTER,
957
/* FIXME: At this point gdb checks to combine pairs of 'p' and
958
'r' stabs into a single 'P' stab. */
962
/* Static symbol at top level of file. */
963
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
964
(debug_type **) NULL);
965
if (dtype == DEBUG_TYPE_NULL)
967
if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_STATIC,
974
dtype = parse_stab_type (dhandle, info, name, &p, &slot);
975
if (dtype == DEBUG_TYPE_NULL)
979
/* A nameless type. Nothing to do. */
983
dtype = debug_name_type (dhandle, name, dtype);
984
if (dtype == DEBUG_TYPE_NULL)
993
/* Struct, union, or enum tag. For GNU C++, this can be be followed
994
by 't' which means we are typedef'ing it as well. */
998
/* FIXME: gdb sets synonym to TRUE if the current language
1007
dtype = parse_stab_type (dhandle, info, name, &p, &slot);
1008
if (dtype == DEBUG_TYPE_NULL)
1013
/* INFO->SELF_CROSSREF is set by parse_stab_type if this type is
1014
a cross reference to itself. These are generated by some
1016
self_crossref = info->self_crossref;
1018
dtype = debug_tag_type (dhandle, name, dtype);
1019
if (dtype == DEBUG_TYPE_NULL)
1024
/* See if we have a cross reference to this tag which we can now
1025
fill in. Avoid filling in a cross reference to ourselves,
1026
because that would lead to circular debugging information. */
1027
if (! self_crossref)
1029
register struct stab_tag **pst;
1031
for (pst = &info->tags; *pst != NULL; pst = &(*pst)->next)
1033
if ((*pst)->name[0] == name[0]
1034
&& strcmp ((*pst)->name, name) == 0)
1036
(*pst)->slot = dtype;
1037
*pst = (*pst)->next;
1045
dtype = debug_name_type (dhandle, name, dtype);
1046
if (dtype == DEBUG_TYPE_NULL)
1056
/* Static symbol of local scope */
1057
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1058
(debug_type **) NULL);
1059
if (dtype == DEBUG_TYPE_NULL)
1061
/* FIXME: gdb checks os9k_stabs here. */
1062
if (! stab_record_variable (dhandle, info, name, dtype,
1063
DEBUG_LOCAL_STATIC, value))
1068
/* Reference parameter. */
1069
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1070
(debug_type **) NULL);
1071
if (dtype == DEBUG_TYPE_NULL)
1073
if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REFERENCE,
1079
/* Reference parameter which is in a register. */
1080
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1081
(debug_type **) NULL);
1082
if (dtype == DEBUG_TYPE_NULL)
1084
if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REF_REG,
1090
/* This is used by Sun FORTRAN for "function result value".
1091
Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1092
that Pascal uses it too, but when I tried it Pascal used
1093
"x:3" (local symbol) instead. */
1094
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1095
(debug_type **) NULL);
1096
if (dtype == DEBUG_TYPE_NULL)
1098
if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL,
1108
/* FIXME: gdb converts structure values to structure pointers in a
1109
couple of cases, depending upon the target. */
1114
/* Parse a stabs type. The typename argument is non-NULL if this is a
1115
typedef or a tag definition. The pp argument points to the stab
1116
string, and is updated. The slotp argument points to a place to
1117
store the slot used if the type is being defined. */
1120
parse_stab_type (void *dhandle, struct stab_handle *info, const char *typename, const char **pp, debug_type **slotp)
1125
bfd_boolean stringp;
1137
info->self_crossref = FALSE;
1139
/* Read type number if present. The type number may be omitted.
1140
for instance in a two-dimensional array declared with type
1141
"ar1;1;10;ar1;1;10;4". */
1142
if (! ISDIGIT (**pp) && **pp != '(' && **pp != '-')
1144
/* 'typenums=' not present, type is anonymous. Read and return
1145
the definition, but don't put it in the type vector. */
1146
typenums[0] = typenums[1] = -1;
1150
if (! parse_stab_type_number (pp, typenums))
1151
return DEBUG_TYPE_NULL;
1154
/* Type is not being defined here. Either it already
1155
exists, or this is a forward reference to it. */
1156
return stab_find_type (dhandle, info, typenums);
1158
/* Only set the slot if the type is being defined. This means
1159
that the mapping from type numbers to types will only record
1160
the name of the typedef which defines a type. If we don't do
1161
this, then something like
1164
will record that i is of type foo. Unfortunately, stabs
1165
information is ambiguous about variable types. For this code,
1169
the stabs information records both i and j as having the same
1170
type. This could be fixed by patching the compiler. */
1171
if (slotp != NULL && typenums[0] >= 0 && typenums[1] >= 0)
1172
*slotp = stab_find_slot (info, typenums);
1174
/* Type is being defined here. */
1180
const char *p = *pp + 1;
1183
if (ISDIGIT (*p) || *p == '(' || *p == '-')
1187
/* Type attributes. */
1190
for (; *p != ';'; ++p)
1195
return DEBUG_TYPE_NULL;
1203
size = atoi (attr + 1);
1204
size /= 8; /* Size is in bits. We store it in bytes. */
1214
/* Ignore unrecognized type attributes, so future
1215
compilers can invent new ones. */
1228
enum debug_type_kind code;
1229
const char *q1, *q2, *p;
1231
/* A cross reference to another type. */
1235
code = DEBUG_KIND_STRUCT;
1238
code = DEBUG_KIND_UNION;
1241
code = DEBUG_KIND_ENUM;
1244
/* Complain and keep going, so compilers can invent new
1245
cross-reference types. */
1246
warn_stab (orig, _("unrecognized cross reference type"));
1247
code = DEBUG_KIND_STRUCT;
1252
q1 = strchr (*pp, '<');
1253
p = strchr (*pp, ':');
1257
return DEBUG_TYPE_NULL;
1259
if (q1 != NULL && p > q1 && p[1] == ':')
1263
for (q2 = q1; *q2 != '\0'; ++q2)
1267
else if (*q2 == '>')
1269
else if (*q2 == ':' && nest == 0)
1276
return DEBUG_TYPE_NULL;
1280
/* Some versions of g++ can emit stabs like
1282
which define structures in terms of themselves. We need to
1283
tell the caller to avoid building a circular structure. */
1284
if (typename != NULL
1285
&& strncmp (typename, *pp, p - *pp) == 0
1286
&& typename[p - *pp] == '\0')
1287
info->self_crossref = TRUE;
1289
dtype = stab_find_tagged_type (dhandle, info, *pp, p - *pp, code);
1311
/* This type is defined as another type. */
1315
/* Peek ahead at the number to detect void. */
1316
if (! parse_stab_type_number (pp, xtypenums))
1317
return DEBUG_TYPE_NULL;
1319
if (typenums[0] == xtypenums[0] && typenums[1] == xtypenums[1])
1321
/* This type is being defined as itself, which means that
1323
dtype = debug_make_void_type (dhandle);
1329
/* Go back to the number and have parse_stab_type get it.
1330
This means that we can deal with something like
1331
t(1,2)=(3,4)=... which the Lucid compiler uses. */
1332
dtype = parse_stab_type (dhandle, info, (const char *) NULL,
1333
pp, (debug_type **) NULL);
1334
if (dtype == DEBUG_TYPE_NULL)
1335
return DEBUG_TYPE_NULL;
1338
if (typenums[0] != -1)
1340
if (! stab_record_type (dhandle, info, typenums, dtype))
1341
return DEBUG_TYPE_NULL;
1348
dtype = debug_make_pointer_type (dhandle,
1349
parse_stab_type (dhandle, info,
1350
(const char *) NULL,
1352
(debug_type **) NULL));
1356
/* Reference to another type. */
1357
dtype = (debug_make_reference_type
1359
parse_stab_type (dhandle, info, (const char *) NULL, pp,
1360
(debug_type **) NULL)));
1364
/* Function returning another type. */
1365
/* FIXME: gdb checks os9k_stabs here. */
1366
dtype = (debug_make_function_type
1368
parse_stab_type (dhandle, info, (const char *) NULL, pp,
1369
(debug_type **) NULL),
1370
(debug_type *) NULL, FALSE));
1374
/* Const qualifier on some type (Sun). */
1375
/* FIXME: gdb accepts 'c' here if os9k_stabs. */
1376
dtype = debug_make_const_type (dhandle,
1377
parse_stab_type (dhandle, info,
1378
(const char *) NULL,
1380
(debug_type **) NULL));
1384
/* Volatile qual on some type (Sun). */
1385
/* FIXME: gdb accepts 'i' here if os9k_stabs. */
1386
dtype = (debug_make_volatile_type
1388
parse_stab_type (dhandle, info, (const char *) NULL, pp,
1389
(debug_type **) NULL)));
1393
/* Offset (class & variable) type. This is used for a pointer
1394
relative to an object. */
1401
domain = parse_stab_type (dhandle, info, (const char *) NULL, pp,
1402
(debug_type **) NULL);
1403
if (domain == DEBUG_TYPE_NULL)
1404
return DEBUG_TYPE_NULL;
1409
return DEBUG_TYPE_NULL;
1413
memtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
1414
(debug_type **) NULL);
1415
if (memtype == DEBUG_TYPE_NULL)
1416
return DEBUG_TYPE_NULL;
1418
dtype = debug_make_offset_type (dhandle, domain, memtype);
1423
/* Method (class & fn) type. */
1426
debug_type return_type;
1429
return_type = parse_stab_type (dhandle, info, (const char *) NULL,
1430
pp, (debug_type **) NULL);
1431
if (return_type == DEBUG_TYPE_NULL)
1432
return DEBUG_TYPE_NULL;
1436
return DEBUG_TYPE_NULL;
1439
dtype = debug_make_method_type (dhandle, return_type,
1441
(debug_type *) NULL, FALSE);
1446
debug_type return_type;
1450
bfd_boolean varargs;
1452
domain = parse_stab_type (dhandle, info, (const char *) NULL,
1453
pp, (debug_type **) NULL);
1454
if (domain == DEBUG_TYPE_NULL)
1455
return DEBUG_TYPE_NULL;
1460
return DEBUG_TYPE_NULL;
1464
return_type = parse_stab_type (dhandle, info, (const char *) NULL,
1465
pp, (debug_type **) NULL);
1466
if (return_type == DEBUG_TYPE_NULL)
1467
return DEBUG_TYPE_NULL;
1470
args = (debug_type *) xmalloc (alloc * sizeof *args);
1477
return DEBUG_TYPE_NULL;
1484
args = ((debug_type *)
1485
xrealloc (args, alloc * sizeof *args));
1488
args[n] = parse_stab_type (dhandle, info, (const char *) NULL,
1489
pp, (debug_type **) NULL);
1490
if (args[n] == DEBUG_TYPE_NULL)
1491
return DEBUG_TYPE_NULL;
1496
/* If the last type is not void, then this function takes a
1497
variable number of arguments. Otherwise, we must strip
1500
|| debug_get_type_kind (dhandle, args[n - 1]) != DEBUG_KIND_VOID)
1508
args[n] = DEBUG_TYPE_NULL;
1510
dtype = debug_make_method_type (dhandle, return_type, domain, args,
1517
dtype = parse_stab_range_type (dhandle, info, typename, pp, typenums);
1521
/* FIXME: gdb checks os9k_stabs here. */
1522
/* Sun ACC builtin int type. */
1523
dtype = parse_stab_sun_builtin_type (dhandle, pp);
1527
/* Sun ACC builtin float type. */
1528
dtype = parse_stab_sun_floating_type (dhandle, pp);
1532
/* Enumeration type. */
1533
dtype = parse_stab_enum_type (dhandle, pp);
1538
/* Struct or union type. */
1539
dtype = parse_stab_struct_type (dhandle, info, typename, pp,
1540
descriptor == 's', typenums);
1548
return DEBUG_TYPE_NULL;
1552
dtype = parse_stab_array_type (dhandle, info, pp, stringp);
1556
dtype = debug_make_set_type (dhandle,
1557
parse_stab_type (dhandle, info,
1558
(const char *) NULL,
1560
(debug_type **) NULL),
1566
return DEBUG_TYPE_NULL;
1569
if (dtype == DEBUG_TYPE_NULL)
1570
return DEBUG_TYPE_NULL;
1572
if (typenums[0] != -1)
1574
if (! stab_record_type (dhandle, info, typenums, dtype))
1575
return DEBUG_TYPE_NULL;
1580
if (! debug_record_type_size (dhandle, dtype, (unsigned int) size))
1581
return DEBUG_TYPE_NULL;
1587
/* Read a number by which a type is referred to in dbx data, or
1588
perhaps read a pair (FILENUM, TYPENUM) in parentheses. Just a
1589
single number N is equivalent to (0,N). Return the two numbers by
1590
storing them in the vector TYPENUMS. */
1593
parse_stab_type_number (const char **pp, int *typenums)
1602
typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL);
1607
typenums[0] = (int) parse_number (pp, (bfd_boolean *) NULL);
1614
typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL);
1626
/* Parse a range type. */
1629
parse_stab_range_type (void *dhandle, struct stab_handle *info, const char *typename, const char **pp, const int *typenums)
1633
bfd_boolean self_subrange;
1634
debug_type index_type;
1635
const char *s2, *s3;
1636
bfd_signed_vma n2, n3;
1637
bfd_boolean ov2, ov3;
1641
index_type = DEBUG_TYPE_NULL;
1643
/* First comes a type we are a subrange of.
1644
In C it is usually 0, 1 or the type being defined. */
1645
if (! parse_stab_type_number (pp, rangenums))
1646
return DEBUG_TYPE_NULL;
1648
self_subrange = (rangenums[0] == typenums[0]
1649
&& rangenums[1] == typenums[1]);
1654
index_type = parse_stab_type (dhandle, info, (const char *) NULL,
1655
pp, (debug_type **) NULL);
1656
if (index_type == DEBUG_TYPE_NULL)
1657
return DEBUG_TYPE_NULL;
1663
/* The remaining two operands are usually lower and upper bounds of
1664
the range. But in some special cases they mean something else. */
1666
n2 = parse_number (pp, &ov2);
1670
return DEBUG_TYPE_NULL;
1675
n3 = parse_number (pp, &ov3);
1679
return DEBUG_TYPE_NULL;
1685
/* gcc will emit range stabs for long long types. Handle this
1686
as a special case. FIXME: This needs to be more general. */
1687
#define LLLOW "01000000000000000000000;"
1688
#define LLHIGH "0777777777777777777777;"
1689
#define ULLHIGH "01777777777777777777777;"
1690
if (index_type == DEBUG_TYPE_NULL)
1692
if (strncmp (s2, LLLOW, sizeof LLLOW - 1) == 0
1693
&& strncmp (s3, LLHIGH, sizeof LLHIGH - 1) == 0)
1694
return debug_make_int_type (dhandle, 8, FALSE);
1697
&& strncmp (s3, ULLHIGH, sizeof ULLHIGH - 1) == 0)
1698
return debug_make_int_type (dhandle, 8, TRUE);
1701
warn_stab (orig, _("numeric overflow"));
1704
if (index_type == DEBUG_TYPE_NULL)
1706
/* A type defined as a subrange of itself, with both bounds 0,
1708
if (self_subrange && n2 == 0 && n3 == 0)
1709
return debug_make_void_type (dhandle);
1711
/* A type defined as a subrange of itself, with n2 positive and
1712
n3 zero, is a complex type, and n2 is the number of bytes. */
1713
if (self_subrange && n3 == 0 && n2 > 0)
1714
return debug_make_complex_type (dhandle, n2);
1716
/* If n3 is zero and n2 is positive, this is a floating point
1717
type, and n2 is the number of bytes. */
1718
if (n3 == 0 && n2 > 0)
1719
return debug_make_float_type (dhandle, n2);
1721
/* If the upper bound is -1, this is an unsigned int. */
1722
if (n2 == 0 && n3 == -1)
1724
/* When gcc is used with -gstabs, but not -gstabs+, it will emit
1725
long long int:t6=r1;0;-1;
1726
long long unsigned int:t7=r1;0;-1;
1727
We hack here to handle this reasonably. */
1728
if (typename != NULL)
1730
if (strcmp (typename, "long long int") == 0)
1731
return debug_make_int_type (dhandle, 8, FALSE);
1732
else if (strcmp (typename, "long long unsigned int") == 0)
1733
return debug_make_int_type (dhandle, 8, TRUE);
1735
/* FIXME: The size here really depends upon the target. */
1736
return debug_make_int_type (dhandle, 4, TRUE);
1739
/* A range of 0 to 127 is char. */
1740
if (self_subrange && n2 == 0 && n3 == 127)
1741
return debug_make_int_type (dhandle, 1, FALSE);
1743
/* FIXME: gdb checks for the language CHILL here. */
1748
return debug_make_int_type (dhandle, - n3, TRUE);
1749
else if (n3 == 0xff)
1750
return debug_make_int_type (dhandle, 1, TRUE);
1751
else if (n3 == 0xffff)
1752
return debug_make_int_type (dhandle, 2, TRUE);
1753
else if (n3 == (bfd_signed_vma) 0xffffffff)
1754
return debug_make_int_type (dhandle, 4, TRUE);
1756
else if (n3 == ((((bfd_signed_vma) 0xffffffff) << 32) | 0xffffffff))
1757
return debug_make_int_type (dhandle, 8, TRUE);
1762
&& (self_subrange || n2 == -8))
1763
return debug_make_int_type (dhandle, - n2, TRUE);
1764
else if (n2 == - n3 - 1 || n2 == n3 + 1)
1767
return debug_make_int_type (dhandle, 1, FALSE);
1768
else if (n3 == 0x7fff)
1769
return debug_make_int_type (dhandle, 2, FALSE);
1770
else if (n3 == 0x7fffffff)
1771
return debug_make_int_type (dhandle, 4, FALSE);
1773
else if (n3 == ((((bfd_vma) 0x7fffffff) << 32) | 0xffffffff))
1774
return debug_make_int_type (dhandle, 8, FALSE);
1779
/* At this point I don't have the faintest idea how to deal with a
1780
self_subrange type; I'm going to assume that this is used as an
1781
idiom, and that all of them are special cases. So . . . */
1785
return DEBUG_TYPE_NULL;
1788
index_type = stab_find_type (dhandle, info, rangenums);
1789
if (index_type == DEBUG_TYPE_NULL)
1791
/* Does this actually ever happen? Is that why we are worrying
1792
about dealing with it rather than just calling error_type? */
1793
warn_stab (orig, _("missing index type"));
1794
index_type = debug_make_int_type (dhandle, 4, FALSE);
1797
return debug_make_range_type (dhandle, index_type, n2, n3);
1800
/* Sun's ACC uses a somewhat saner method for specifying the builtin
1801
typedefs in every file (for int, long, etc):
1803
type = b <signed> <width>; <offset>; <nbits>
1804
signed = u or s. Possible c in addition to u or s (for char?).
1805
offset = offset from high order bit to start bit of type.
1806
width is # bytes in object of this type, nbits is # bits in type.
1808
The width/offset stuff appears to be for small objects stored in
1809
larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
1813
parse_stab_sun_builtin_type (void *dhandle, const char **pp)
1816
bfd_boolean unsignedp;
1831
return DEBUG_TYPE_NULL;
1835
/* For some odd reason, all forms of char put a c here. This is strange
1836
because no other type has this honor. We can safely ignore this because
1837
we actually determine 'char'acterness by the number of bits specified in
1842
/* The first number appears to be the number of bytes occupied
1843
by this type, except that unsigned short is 4 instead of 2.
1844
Since this information is redundant with the third number,
1845
we will ignore it. */
1846
(void) parse_number (pp, (bfd_boolean *) NULL);
1850
return DEBUG_TYPE_NULL;
1854
/* The second number is always 0, so ignore it too. */
1855
(void) parse_number (pp, (bfd_boolean *) NULL);
1859
return DEBUG_TYPE_NULL;
1863
/* The third number is the number of bits for this type. */
1864
bits = parse_number (pp, (bfd_boolean *) NULL);
1866
/* The type *should* end with a semicolon. If it are embedded
1867
in a larger type the semicolon may be the only way to know where
1868
the type ends. If this type is at the end of the stabstring we
1869
can deal with the omitted semicolon (but we don't have to like
1870
it). Don't bother to complain(), Sun's compiler omits the semicolon
1876
return debug_make_void_type (dhandle);
1878
return debug_make_int_type (dhandle, bits / 8, unsignedp);
1881
/* Parse a builtin floating type generated by the Sun compiler. */
1884
parse_stab_sun_floating_type (void *dhandle, const char **pp)
1892
/* The first number has more details about the type, for example
1894
details = parse_number (pp, (bfd_boolean *) NULL);
1898
return DEBUG_TYPE_NULL;
1901
/* The second number is the number of bytes occupied by this type */
1902
bytes = parse_number (pp, (bfd_boolean *) NULL);
1906
return DEBUG_TYPE_NULL;
1909
if (details == NF_COMPLEX
1910
|| details == NF_COMPLEX16
1911
|| details == NF_COMPLEX32)
1912
return debug_make_complex_type (dhandle, bytes);
1914
return debug_make_float_type (dhandle, bytes);
1917
/* Handle an enum type. */
1920
parse_stab_enum_type (void *dhandle, const char **pp)
1924
bfd_signed_vma *values;
1930
/* FIXME: gdb checks os9k_stabs here. */
1932
/* The aix4 compiler emits an extra field before the enum members;
1933
my guess is it's a type of some sort. Just ignore it. */
1941
/* Read the value-names and their values.
1942
The input syntax is NAME:VALUE,NAME:VALUE, and so on.
1943
A semicolon or comma instead of a NAME means the end. */
1945
names = (const char **) xmalloc (alloc * sizeof *names);
1946
values = (bfd_signed_vma *) xmalloc (alloc * sizeof *values);
1948
while (**pp != '\0' && **pp != ';' && **pp != ',')
1958
name = savestring (*pp, p - *pp);
1961
val = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
1965
return DEBUG_TYPE_NULL;
1972
names = ((const char **)
1973
xrealloc (names, alloc * sizeof *names));
1974
values = ((bfd_signed_vma *)
1975
xrealloc (values, alloc * sizeof *values));
1989
return debug_make_enum_type (dhandle, names, values);
1992
/* Read the description of a structure (or union type) and return an object
1993
describing the type.
1995
PP points to a character pointer that points to the next unconsumed token
1996
in the the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
1997
*PP will point to "4a:1,0,32;;". */
2000
parse_stab_struct_type (void *dhandle, struct stab_handle *info,
2001
const char *tagname, const char **pp,
2002
bfd_boolean structp, const int *typenums)
2006
debug_baseclass *baseclasses;
2007
debug_field *fields;
2008
bfd_boolean statics;
2009
debug_method *methods;
2010
debug_type vptrbase;
2011
bfd_boolean ownvptr;
2016
size = parse_number (pp, (bfd_boolean *) NULL);
2018
/* Get the other information. */
2019
if (! parse_stab_baseclasses (dhandle, info, pp, &baseclasses)
2020
|| ! parse_stab_struct_fields (dhandle, info, pp, &fields, &statics)
2021
|| ! parse_stab_members (dhandle, info, tagname, pp, typenums, &methods)
2022
|| ! parse_stab_tilde_field (dhandle, info, pp, typenums, &vptrbase,
2024
return DEBUG_TYPE_NULL;
2027
&& baseclasses == NULL
2029
&& vptrbase == DEBUG_TYPE_NULL
2031
return debug_make_struct_type (dhandle, structp, size, fields);
2033
return debug_make_object_type (dhandle, structp, size, fields, baseclasses,
2034
methods, vptrbase, ownvptr);
2037
/* The stabs for C++ derived classes contain baseclass information which
2038
is marked by a '!' character after the total size. This function is
2039
called when we encounter the baseclass marker, and slurps up all the
2040
baseclass information.
2042
Immediately following the '!' marker is the number of base classes that
2043
the class is derived from, followed by information for each base class.
2044
For each base class, there are two visibility specifiers, a bit offset
2045
to the base class information within the derived class, a reference to
2046
the type for the base class, and a terminating semicolon.
2048
A typical example, with two base classes, would be "!2,020,19;0264,21;".
2050
Baseclass information marker __________________|| | | | | | |
2051
Number of baseclasses __________________________| | | | | | |
2052
Visibility specifiers (2) ________________________| | | | | |
2053
Offset in bits from start of class _________________| | | | |
2054
Type number for base class ___________________________| | | |
2055
Visibility specifiers (2) _______________________________| | |
2056
Offset in bits from start of class ________________________| |
2057
Type number of base class ____________________________________|
2059
Return TRUE for success, FALSE for failure. */
2062
parse_stab_baseclasses (void *dhandle, struct stab_handle *info,
2063
const char **pp, debug_baseclass **retp)
2067
debug_baseclass *classes;
2075
/* No base classes. */
2080
c = (unsigned int) parse_number (pp, (bfd_boolean *) NULL);
2089
classes = (debug_baseclass *) xmalloc ((c + 1) * sizeof (**retp));
2091
for (i = 0; i < c; i++)
2093
bfd_boolean virtual;
2094
enum debug_visibility visibility;
2107
warn_stab (orig, _("unknown virtual character for baseclass"));
2116
visibility = DEBUG_VISIBILITY_PRIVATE;
2119
visibility = DEBUG_VISIBILITY_PROTECTED;
2122
visibility = DEBUG_VISIBILITY_PUBLIC;
2125
warn_stab (orig, _("unknown visibility character for baseclass"));
2126
visibility = DEBUG_VISIBILITY_PUBLIC;
2131
/* The remaining value is the bit offset of the portion of the
2132
object corresponding to this baseclass. Always zero in the
2133
absence of multiple inheritance. */
2134
bitpos = parse_number (pp, (bfd_boolean *) NULL);
2142
type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2143
(debug_type **) NULL);
2144
if (type == DEBUG_TYPE_NULL)
2147
classes[i] = debug_make_baseclass (dhandle, type, bitpos, virtual,
2149
if (classes[i] == DEBUG_BASECLASS_NULL)
2157
classes[i] = DEBUG_BASECLASS_NULL;
2164
/* Read struct or class data fields. They have the form:
2166
NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2168
At the end, we see a semicolon instead of a field.
2170
In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2173
The optional VISIBILITY is one of:
2175
'/0' (VISIBILITY_PRIVATE)
2176
'/1' (VISIBILITY_PROTECTED)
2177
'/2' (VISIBILITY_PUBLIC)
2178
'/9' (VISIBILITY_IGNORE)
2180
or nothing, for C style fields with public visibility.
2182
Returns 1 for success, 0 for failure. */
2185
parse_stab_struct_fields (void *dhandle, struct stab_handle *info,
2186
const char **pp, debug_field **retp,
2187
bfd_boolean *staticsp)
2191
debug_field *fields;
2202
fields = (debug_field *) xmalloc (alloc * sizeof *fields);
2205
/* FIXME: gdb checks os9k_stabs here. */
2209
/* Add 1 to c to leave room for NULL pointer at end. */
2213
fields = ((debug_field *)
2214
xrealloc (fields, alloc * sizeof *fields));
2217
/* If it starts with CPLUS_MARKER it is a special abbreviation,
2218
unless the CPLUS_MARKER is followed by an underscore, in
2219
which case it is just the name of an anonymous type, which we
2220
should handle like any other type name. We accept either '$'
2221
or '.', because a field name can never contain one of these
2222
characters except as a CPLUS_MARKER. */
2224
if ((*p == '$' || *p == '.') && p[1] != '_')
2227
if (! parse_stab_cpp_abbrev (dhandle, info, pp, fields + c))
2233
/* Look for the ':' that separates the field name from the field
2234
values. Data members are delimited by a single ':', while member
2235
functions are delimited by a pair of ':'s. When we hit the member
2236
functions (if any), terminate scan loop and return. */
2238
p = strchr (p, ':');
2248
if (! parse_stab_one_struct_field (dhandle, info, pp, p, fields + c,
2255
fields[c] = DEBUG_FIELD_NULL;
2262
/* Special GNU C++ name. */
2265
parse_stab_cpp_abbrev (void *dhandle, struct stab_handle *info,
2266
const char **pp, debug_field *retp)
2272
const char *typename;
2276
*retp = DEBUG_FIELD_NULL;
2290
/* At this point, *pp points to something like "22:23=*22...", where
2291
the type number before the ':' is the "context" and everything
2292
after is a regular type definition. Lookup the type, find it's
2293
name, and construct the field name. */
2295
context = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2296
(debug_type **) NULL);
2297
if (context == DEBUG_TYPE_NULL)
2303
/* $vf -- a virtual function table pointer. */
2307
/* $vb -- a virtual bsomethingorother */
2308
typename = debug_get_type_name (dhandle, context);
2309
if (typename == NULL)
2311
warn_stab (orig, _("unnamed $vb type"));
2314
name = concat ("_vb$", typename, (const char *) NULL);
2317
warn_stab (orig, _("unrecognized C++ abbreviation"));
2318
name = "INVALID_CPLUSPLUS_ABBREV";
2329
type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2330
(debug_type **) NULL);
2338
bitpos = parse_number (pp, (bfd_boolean *) NULL);
2346
*retp = debug_make_field (dhandle, name, type, bitpos, 0,
2347
DEBUG_VISIBILITY_PRIVATE);
2348
if (*retp == DEBUG_FIELD_NULL)
2354
/* Parse a single field in a struct or union. */
2357
parse_stab_one_struct_field (void *dhandle, struct stab_handle *info,
2358
const char **pp, const char *p,
2359
debug_field *retp, bfd_boolean *staticsp)
2363
enum debug_visibility visibility;
2370
/* FIXME: gdb checks ARM_DEMANGLING here. */
2372
name = savestring (*pp, p - *pp);
2377
visibility = DEBUG_VISIBILITY_PUBLIC;
2384
visibility = DEBUG_VISIBILITY_PRIVATE;
2387
visibility = DEBUG_VISIBILITY_PROTECTED;
2390
visibility = DEBUG_VISIBILITY_PUBLIC;
2393
warn_stab (orig, _("unknown visibility character for field"));
2394
visibility = DEBUG_VISIBILITY_PUBLIC;
2400
type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2401
(debug_type **) NULL);
2402
if (type == DEBUG_TYPE_NULL)
2409
/* This is a static class member. */
2411
p = strchr (*pp, ';');
2418
varname = savestring (*pp, p - *pp);
2422
*retp = debug_make_static_member (dhandle, name, type, varname,
2436
bitpos = parse_number (pp, (bfd_boolean *) NULL);
2444
bitsize = parse_number (pp, (bfd_boolean *) NULL);
2452
if (bitpos == 0 && bitsize == 0)
2454
/* This can happen in two cases: (1) at least for gcc 2.4.5 or
2455
so, it is a field which has been optimized out. The correct
2456
stab for this case is to use VISIBILITY_IGNORE, but that is a
2457
recent invention. (2) It is a 0-size array. For example
2458
union { int num; char str[0]; } foo. Printing "<no value>"
2459
for str in "p foo" is OK, since foo.str (and thus foo.str[3])
2460
will continue to work, and a 0-size array as a whole doesn't
2461
have any contents to print.
2463
I suspect this probably could also happen with gcc -gstabs
2464
(not -gstabs+) for static fields, and perhaps other C++
2465
extensions. Hopefully few people use -gstabs with gdb, since
2466
it is intended for dbx compatibility. */
2467
visibility = DEBUG_VISIBILITY_IGNORE;
2470
/* FIXME: gdb does some stuff here to mark fields as unpacked. */
2472
*retp = debug_make_field (dhandle, name, type, bitpos, bitsize, visibility);
2477
/* Read member function stabs info for C++ classes. The form of each member
2480
NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2482
An example with two member functions is:
2484
afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2486
For the case of overloaded operators, the format is op$::*.funcs, where
2487
$ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2488
name (such as `+=') and `.' marks the end of the operator name. */
2491
parse_stab_members (void *dhandle, struct stab_handle *info,
2492
const char *tagname, const char **pp,
2493
const int *typenums, debug_method **retp)
2496
debug_method *methods;
2512
debug_method_variant *variants;
2514
unsigned int allocvars;
2515
debug_type look_ahead_type;
2517
p = strchr (*pp, ':');
2518
if (p == NULL || p[1] != ':')
2521
/* FIXME: Some systems use something other than '$' here. */
2522
if ((*pp)[0] != 'o' || (*pp)[1] != 'p' || (*pp)[2] != '$')
2524
name = savestring (*pp, p - *pp);
2529
/* This is a completely wierd case. In order to stuff in the
2530
names that might contain colons (the usual name delimiter),
2531
Mike Tiemann defined a different name format which is
2532
signalled if the identifier is "op$". In that case, the
2533
format is "op$::XXXX." where XXXX is the name. This is
2534
used for names like "+" or "=". YUUUUUUUK! FIXME! */
2536
for (p = *pp; *p != '.' && *p != '\0'; p++)
2543
name = savestring (*pp, p - *pp);
2548
variants = ((debug_method_variant *)
2549
xmalloc (allocvars * sizeof *variants));
2552
look_ahead_type = DEBUG_TYPE_NULL;
2559
enum debug_visibility visibility;
2560
bfd_boolean constp, volatilep, staticp;
2563
const char *physname;
2564
bfd_boolean varargs;
2566
if (look_ahead_type != DEBUG_TYPE_NULL)
2568
/* g++ version 1 kludge */
2569
type = look_ahead_type;
2570
look_ahead_type = DEBUG_TYPE_NULL;
2574
type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2575
(debug_type **) NULL);
2576
if (type == DEBUG_TYPE_NULL)
2586
p = strchr (*pp, ';');
2594
if (debug_get_type_kind (dhandle, type) == DEBUG_KIND_METHOD
2595
&& debug_get_parameter_types (dhandle, type, &varargs) == NULL)
2598
argtypes = savestring (*pp, p - *pp);
2604
visibility = DEBUG_VISIBILITY_PRIVATE;
2607
visibility = DEBUG_VISIBILITY_PROTECTED;
2610
visibility = DEBUG_VISIBILITY_PUBLIC;
2620
/* Normal function. */
2624
/* const member function. */
2629
/* volatile member function. */
2634
/* const volatile member function. */
2642
/* File compiled with g++ version 1; no information. */
2645
warn_stab (orig, _("const/volatile indicator missing"));
2653
/* virtual member function, followed by index. The sign
2654
bit is supposedly set to distinguish
2655
pointers-to-methods from virtual function indicies. */
2657
voffset = parse_number (pp, (bfd_boolean *) NULL);
2664
voffset &= 0x7fffffff;
2666
if (**pp == ';' || *pp == '\0')
2668
/* Must be g++ version 1. */
2669
context = DEBUG_TYPE_NULL;
2673
/* Figure out from whence this virtual function
2674
came. It may belong to virtual function table of
2675
one of its baseclasses. */
2676
look_ahead_type = parse_stab_type (dhandle, info,
2677
(const char *) NULL,
2679
(debug_type **) NULL);
2682
/* g++ version 1 overloaded methods. */
2683
context = DEBUG_TYPE_NULL;
2687
context = look_ahead_type;
2688
look_ahead_type = DEBUG_TYPE_NULL;
2700
/* static member function. */
2704
context = DEBUG_TYPE_NULL;
2705
if (strncmp (argtypes, name, strlen (name)) != 0)
2710
warn_stab (orig, "member function type missing");
2712
context = DEBUG_TYPE_NULL;
2718
context = DEBUG_TYPE_NULL;
2722
/* If the type is not a stub, then the argtypes string is
2723
the physical name of the function. Otherwise the
2724
argtypes string is the mangled form of the argument
2725
types, and the full type and the physical name must be
2726
extracted from them. */
2728
physname = argtypes;
2731
debug_type class_type, return_type;
2733
class_type = stab_find_type (dhandle, info, typenums);
2734
if (class_type == DEBUG_TYPE_NULL)
2736
return_type = debug_get_return_type (dhandle, type);
2737
if (return_type == DEBUG_TYPE_NULL)
2742
type = parse_stab_argtypes (dhandle, info, class_type, name,
2743
tagname, return_type, argtypes,
2744
constp, volatilep, &physname);
2745
if (type == DEBUG_TYPE_NULL)
2749
if (cvars + 1 >= allocvars)
2752
variants = ((debug_method_variant *)
2754
allocvars * sizeof *variants));
2758
variants[cvars] = debug_make_method_variant (dhandle, physname,
2763
variants[cvars] = debug_make_static_method_variant (dhandle,
2769
if (variants[cvars] == DEBUG_METHOD_VARIANT_NULL)
2774
while (**pp != ';' && **pp != '\0');
2776
variants[cvars] = DEBUG_METHOD_VARIANT_NULL;
2784
methods = ((debug_method *)
2785
xrealloc (methods, alloc * sizeof *methods));
2788
methods[c] = debug_make_method (dhandle, name, variants);
2793
if (methods != NULL)
2794
methods[c] = DEBUG_METHOD_NULL;
2801
/* Parse a string representing argument types for a method. Stabs
2802
tries to save space by packing argument types into a mangled
2803
string. This string should give us enough information to extract
2804
both argument types and the physical name of the function, given
2808
parse_stab_argtypes (void *dhandle, struct stab_handle *info,
2809
debug_type class_type, const char *fieldname,
2810
const char *tagname, debug_type return_type,
2811
const char *argtypes, bfd_boolean constp,
2812
bfd_boolean volatilep, const char **pphysname)
2814
bfd_boolean is_full_physname_constructor;
2815
bfd_boolean is_constructor;
2816
bfd_boolean is_destructor;
2818
bfd_boolean varargs;
2819
unsigned int physname_len = 0;
2821
/* Constructors are sometimes handled specially. */
2822
is_full_physname_constructor = ((argtypes[0] == '_'
2823
&& argtypes[1] == '_'
2824
&& (ISDIGIT (argtypes[2])
2825
|| argtypes[2] == 'Q'
2826
|| argtypes[2] == 't'))
2827
|| strncmp (argtypes, "__ct", 4) == 0);
2829
is_constructor = (is_full_physname_constructor
2831
&& strcmp (fieldname, tagname) == 0));
2832
is_destructor = ((argtypes[0] == '_'
2833
&& (argtypes[1] == '$' || argtypes[1] == '.')
2834
&& argtypes[2] == '_')
2835
|| strncmp (argtypes, "__dt", 4) == 0);
2837
if (is_destructor || is_full_physname_constructor)
2838
*pphysname = argtypes;
2842
const char *const_prefix;
2843
const char *volatile_prefix;
2845
unsigned int mangled_name_len;
2848
len = tagname == NULL ? 0 : strlen (tagname);
2849
const_prefix = constp ? "C" : "";
2850
volatile_prefix = volatilep ? "V" : "";
2853
sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
2854
else if (tagname != NULL && strchr (tagname, '<') != NULL)
2856
/* Template methods are fully mangled. */
2857
sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
2862
sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
2864
mangled_name_len = ((is_constructor ? 0 : strlen (fieldname))
2870
if (fieldname[0] == 'o'
2871
&& fieldname[1] == 'p'
2872
&& (fieldname[2] == '$' || fieldname[2] == '.'))
2876
opname = cplus_mangle_opname (fieldname + 3, 0);
2879
fprintf (stderr, _("No mangling for \"%s\"\n"), fieldname);
2880
return DEBUG_TYPE_NULL;
2882
mangled_name_len += strlen (opname);
2883
physname = (char *) xmalloc (mangled_name_len);
2884
strncpy (physname, fieldname, 3);
2885
strcpy (physname + 3, opname);
2889
physname = (char *) xmalloc (mangled_name_len);
2893
strcpy (physname, fieldname);
2896
physname_len = strlen (physname);
2897
strcat (physname, buf);
2898
if (tagname != NULL)
2899
strcat (physname, tagname);
2900
strcat (physname, argtypes);
2902
*pphysname = physname;
2905
if (*argtypes == '\0' || is_destructor)
2907
args = (debug_type *) xmalloc (sizeof *args);
2909
return debug_make_method_type (dhandle, return_type, class_type, args,
2913
args = stab_demangle_argtypes (dhandle, info, *pphysname, &varargs, physname_len);
2915
return DEBUG_TYPE_NULL;
2917
return debug_make_method_type (dhandle, return_type, class_type, args,
2921
/* The tail end of stabs for C++ classes that contain a virtual function
2922
pointer contains a tilde, a %, and a type number.
2923
The type number refers to the base class (possibly this class itself) which
2924
contains the vtable pointer for the current class.
2926
This function is called when we have parsed all the method declarations,
2927
so we can look for the vptr base class info. */
2930
parse_stab_tilde_field (void *dhandle, struct stab_handle *info,
2931
const char **pp, const int *typenums,
2932
debug_type *retvptrbase, bfd_boolean *retownvptr)
2938
*retvptrbase = DEBUG_TYPE_NULL;
2939
*retownvptr = FALSE;
2943
/* If we are positioned at a ';', then skip it. */
2952
if (**pp == '=' || **pp == '+' || **pp == '-')
2954
/* Obsolete flags that used to indicate the presence of
2955
constructors and/or destructors. */
2966
/* The next number is the type number of the base class (possibly
2967
our own class) which supplies the vtable for this class. */
2968
if (! parse_stab_type_number (pp, vtypenums))
2971
if (vtypenums[0] == typenums[0]
2972
&& vtypenums[1] == typenums[1])
2981
vtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2982
(debug_type **) NULL);
2983
for (p = *pp; *p != ';' && *p != '\0'; p++)
2991
*retvptrbase = vtype;
2999
/* Read a definition of an array type. */
3002
parse_stab_array_type (void *dhandle, struct stab_handle *info,
3003
const char **pp, bfd_boolean stringp)
3008
debug_type index_type;
3009
bfd_boolean adjustable;
3010
bfd_signed_vma lower, upper;
3011
debug_type element_type;
3013
/* Format of an array type:
3014
"ar<index type>;lower;upper;<array_contents_type>".
3015
OS9000: "arlower,upper;<array_contents_type>".
3017
Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3018
for these, produce a type like float[][]. */
3022
/* FIXME: gdb checks os9k_stabs here. */
3024
/* If the index type is type 0, we take it as int. */
3026
if (! parse_stab_type_number (&p, typenums))
3027
return DEBUG_TYPE_NULL;
3028
if (typenums[0] == 0 && typenums[1] == 0 && **pp != '=')
3030
index_type = debug_find_named_type (dhandle, "int");
3031
if (index_type == DEBUG_TYPE_NULL)
3033
index_type = debug_make_int_type (dhandle, 4, FALSE);
3034
if (index_type == DEBUG_TYPE_NULL)
3035
return DEBUG_TYPE_NULL;
3041
index_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3042
(debug_type **) NULL);
3048
return DEBUG_TYPE_NULL;
3054
if (! ISDIGIT (**pp) && **pp != '-')
3060
lower = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
3064
return DEBUG_TYPE_NULL;
3068
if (! ISDIGIT (**pp) && **pp != '-')
3074
upper = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
3078
return DEBUG_TYPE_NULL;
3082
element_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3083
(debug_type **) NULL);
3084
if (element_type == DEBUG_TYPE_NULL)
3085
return DEBUG_TYPE_NULL;
3093
return debug_make_array_type (dhandle, element_type, index_type, lower,
3097
/* This struct holds information about files we have seen using
3102
/* The next N_BINCL file. */
3103
struct bincl_file *next;
3104
/* The next N_BINCL on the stack. */
3105
struct bincl_file *next_stack;
3106
/* The file name. */
3108
/* The hash value. */
3110
/* The file index. */
3112
/* The list of types defined in this file. */
3113
struct stab_types *file_types;
3116
/* Start a new N_BINCL file, pushing it onto the stack. */
3119
push_bincl (struct stab_handle *info, const char *name, bfd_vma hash)
3121
struct bincl_file *n;
3123
n = (struct bincl_file *) xmalloc (sizeof *n);
3124
n->next = info->bincl_list;
3125
n->next_stack = info->bincl_stack;
3128
n->file = info->files;
3129
n->file_types = NULL;
3130
info->bincl_list = n;
3131
info->bincl_stack = n;
3134
info->file_types = ((struct stab_types **)
3135
xrealloc (info->file_types,
3137
* sizeof *info->file_types)));
3138
info->file_types[n->file] = NULL;
3141
/* Finish an N_BINCL file, at an N_EINCL, popping the name off the
3145
pop_bincl (struct stab_handle *info)
3147
struct bincl_file *o;
3149
o = info->bincl_stack;
3151
return info->main_filename;
3152
info->bincl_stack = o->next_stack;
3154
o->file_types = info->file_types[o->file];
3156
if (info->bincl_stack == NULL)
3157
return info->main_filename;
3158
return info->bincl_stack->name;
3161
/* Handle an N_EXCL: get the types from the corresponding N_BINCL. */
3164
find_excl (struct stab_handle *info, const char *name, bfd_vma hash)
3166
struct bincl_file *l;
3169
info->file_types = ((struct stab_types **)
3170
xrealloc (info->file_types,
3172
* sizeof *info->file_types)));
3174
for (l = info->bincl_list; l != NULL; l = l->next)
3175
if (l->hash == hash && strcmp (l->name, name) == 0)
3179
warn_stab (name, _("Undefined N_EXCL"));
3180
info->file_types[info->files - 1] = NULL;
3184
info->file_types[info->files - 1] = l->file_types;
3189
/* Handle a variable definition. gcc emits variable definitions for a
3190
block before the N_LBRAC, so we must hold onto them until we see
3191
it. The SunPRO compiler emits variable definitions after the
3192
N_LBRAC, so we can call debug_record_variable immediately. */
3195
stab_record_variable (void *dhandle, struct stab_handle *info,
3196
const char *name, debug_type type,
3197
enum debug_var_kind kind, bfd_vma val)
3199
struct stab_pending_var *v;
3201
if ((kind == DEBUG_GLOBAL || kind == DEBUG_STATIC)
3202
|| ! info->within_function
3203
|| (info->gcc_compiled == 0 && info->n_opt_found))
3204
return debug_record_variable (dhandle, name, type, kind, val);
3206
v = (struct stab_pending_var *) xmalloc (sizeof *v);
3207
memset (v, 0, sizeof *v);
3209
v->next = info->pending;
3219
/* Emit pending variable definitions. This is called after we see the
3220
N_LBRAC that starts the block. */
3223
stab_emit_pending_vars (void *dhandle, struct stab_handle *info)
3225
struct stab_pending_var *v;
3230
struct stab_pending_var *next;
3232
if (! debug_record_variable (dhandle, v->name, v->type, v->kind, v->val))
3240
info->pending = NULL;
3245
/* Find the slot for a type in the database. */
3248
stab_find_slot (struct stab_handle *info, const int *typenums)
3252
struct stab_types **ps;
3254
filenum = typenums[0];
3255
index = typenums[1];
3257
if (filenum < 0 || (unsigned int) filenum >= info->files)
3259
fprintf (stderr, _("Type file number %d out of range\n"), filenum);
3264
fprintf (stderr, _("Type index number %d out of range\n"), index);
3268
ps = info->file_types + filenum;
3270
while (index >= STAB_TYPES_SLOTS)
3274
*ps = (struct stab_types *) xmalloc (sizeof **ps);
3275
memset (*ps, 0, sizeof **ps);
3278
index -= STAB_TYPES_SLOTS;
3282
*ps = (struct stab_types *) xmalloc (sizeof **ps);
3283
memset (*ps, 0, sizeof **ps);
3286
return (*ps)->types + index;
3289
/* Find a type given a type number. If the type has not been
3290
allocated yet, create an indirect type. */
3293
stab_find_type (void *dhandle, struct stab_handle *info, const int *typenums)
3297
if (typenums[0] == 0 && typenums[1] < 0)
3299
/* A negative type number indicates an XCOFF builtin type. */
3300
return stab_xcoff_builtin_type (dhandle, info, typenums[1]);
3303
slot = stab_find_slot (info, typenums);
3305
return DEBUG_TYPE_NULL;
3307
if (*slot == DEBUG_TYPE_NULL)
3308
return debug_make_indirect_type (dhandle, slot, (const char *) NULL);
3313
/* Record that a given type number refers to a given type. */
3316
stab_record_type (void *dhandle ATTRIBUTE_UNUSED, struct stab_handle *info,
3317
const int *typenums, debug_type type)
3321
slot = stab_find_slot (info, typenums);
3325
/* gdb appears to ignore type redefinitions, so we do as well. */
3332
/* Return an XCOFF builtin type. */
3335
stab_xcoff_builtin_type (void *dhandle, struct stab_handle *info,
3341
if (typenum >= 0 || typenum < -XCOFF_TYPE_COUNT)
3343
fprintf (stderr, _("Unrecognized XCOFF type %d\n"), typenum);
3344
return DEBUG_TYPE_NULL;
3346
if (info->xcoff_types[-typenum] != NULL)
3347
return info->xcoff_types[-typenum];
3352
/* The size of this and all the other types are fixed, defined
3353
by the debugging format. */
3355
rettype = debug_make_int_type (dhandle, 4, FALSE);
3359
rettype = debug_make_int_type (dhandle, 1, FALSE);
3363
rettype = debug_make_int_type (dhandle, 2, FALSE);
3367
rettype = debug_make_int_type (dhandle, 4, FALSE);
3370
name = "unsigned char";
3371
rettype = debug_make_int_type (dhandle, 1, TRUE);
3374
name = "signed char";
3375
rettype = debug_make_int_type (dhandle, 1, FALSE);
3378
name = "unsigned short";
3379
rettype = debug_make_int_type (dhandle, 2, TRUE);
3382
name = "unsigned int";
3383
rettype = debug_make_int_type (dhandle, 4, TRUE);
3387
rettype = debug_make_int_type (dhandle, 4, TRUE);
3389
name = "unsigned long";
3390
rettype = debug_make_int_type (dhandle, 4, TRUE);
3394
rettype = debug_make_void_type (dhandle);
3397
/* IEEE single precision (32 bit). */
3399
rettype = debug_make_float_type (dhandle, 4);
3402
/* IEEE double precision (64 bit). */
3404
rettype = debug_make_float_type (dhandle, 8);
3407
/* This is an IEEE double on the RS/6000, and different machines
3408
with different sizes for "long double" should use different
3409
negative type numbers. See stabs.texinfo. */
3410
name = "long double";
3411
rettype = debug_make_float_type (dhandle, 8);
3415
rettype = debug_make_int_type (dhandle, 4, FALSE);
3419
rettype = debug_make_bool_type (dhandle, 4);
3422
name = "short real";
3423
rettype = debug_make_float_type (dhandle, 4);
3427
rettype = debug_make_float_type (dhandle, 8);
3437
rettype = debug_make_int_type (dhandle, 1, TRUE);
3441
rettype = debug_make_bool_type (dhandle, 1);
3445
rettype = debug_make_bool_type (dhandle, 2);
3449
rettype = debug_make_bool_type (dhandle, 4);
3453
rettype = debug_make_bool_type (dhandle, 4);
3456
/* Complex type consisting of two IEEE single precision values. */
3458
rettype = debug_make_complex_type (dhandle, 8);
3461
/* Complex type consisting of two IEEE double precision values. */
3462
name = "double complex";
3463
rettype = debug_make_complex_type (dhandle, 16);
3467
rettype = debug_make_int_type (dhandle, 1, FALSE);
3471
rettype = debug_make_int_type (dhandle, 2, FALSE);
3475
rettype = debug_make_int_type (dhandle, 4, FALSE);
3480
rettype = debug_make_int_type (dhandle, 2, FALSE);
3484
rettype = debug_make_int_type (dhandle, 8, FALSE);
3487
name = "unsigned long long";
3488
rettype = debug_make_int_type (dhandle, 8, TRUE);
3492
rettype = debug_make_bool_type (dhandle, 8);
3496
rettype = debug_make_int_type (dhandle, 8, FALSE);
3502
rettype = debug_name_type (dhandle, name, rettype);
3504
info->xcoff_types[-typenum] = rettype;
3509
/* Find or create a tagged type. */
3512
stab_find_tagged_type (void *dhandle, struct stab_handle *info,
3513
const char *p, int len, enum debug_type_kind kind)
3517
struct stab_tag *st;
3519
name = savestring (p, len);
3521
/* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same
3522
namespace. This is right for C, and I don't know how to handle
3523
other languages. FIXME. */
3524
dtype = debug_find_tagged_type (dhandle, name, DEBUG_KIND_ILLEGAL);
3525
if (dtype != DEBUG_TYPE_NULL)
3531
/* We need to allocate an entry on the undefined tag list. */
3532
for (st = info->tags; st != NULL; st = st->next)
3534
if (st->name[0] == name[0]
3535
&& strcmp (st->name, name) == 0)
3537
if (st->kind == DEBUG_KIND_ILLEGAL)
3545
st = (struct stab_tag *) xmalloc (sizeof *st);
3546
memset (st, 0, sizeof *st);
3548
st->next = info->tags;
3551
st->slot = DEBUG_TYPE_NULL;
3552
st->type = debug_make_indirect_type (dhandle, &st->slot, name);
3559
/* In order to get the correct argument types for a stubbed method, we
3560
need to extract the argument types from a C++ mangled string.
3561
Since the argument types can refer back to the return type, this
3562
means that we must demangle the entire physical name. In gdb this
3563
is done by calling cplus_demangle and running the results back
3564
through the C++ expression parser. Since we have no expression
3565
parser, we must duplicate much of the work of cplus_demangle here.
3567
We assume that GNU style demangling is used, since this is only
3568
done for method stubs, and only g++ should output that form of
3569
debugging information. */
3571
/* This structure is used to hold a pointer to type information which
3572
demangling a string. */
3574
struct stab_demangle_typestring
3576
/* The start of the type. This is not null terminated. */
3577
const char *typestring;
3578
/* The length of the type. */
3582
/* This structure is used to hold information while demangling a
3585
struct stab_demangle_info
3587
/* The debugging information handle. */
3589
/* The stab information handle. */
3590
struct stab_handle *info;
3591
/* The array of arguments we are building. */
3593
/* Whether the method takes a variable number of arguments. */
3594
bfd_boolean varargs;
3595
/* The array of types we have remembered. */
3596
struct stab_demangle_typestring *typestrings;
3597
/* The number of typestrings. */
3598
unsigned int typestring_count;
3599
/* The number of typestring slots we have allocated. */
3600
unsigned int typestring_alloc;
3603
static void stab_bad_demangle (const char *);
3604
static unsigned int stab_demangle_count (const char **);
3605
static bfd_boolean stab_demangle_get_count (const char **, unsigned int *);
3606
static bfd_boolean stab_demangle_prefix
3607
(struct stab_demangle_info *, const char **, unsigned int);
3608
static bfd_boolean stab_demangle_function_name
3609
(struct stab_demangle_info *, const char **, const char *);
3610
static bfd_boolean stab_demangle_signature
3611
(struct stab_demangle_info *, const char **);
3612
static bfd_boolean stab_demangle_qualified
3613
(struct stab_demangle_info *, const char **, debug_type *);
3614
static bfd_boolean stab_demangle_template
3615
(struct stab_demangle_info *, const char **, char **);
3616
static bfd_boolean stab_demangle_class
3617
(struct stab_demangle_info *, const char **, const char **);
3618
static bfd_boolean stab_demangle_args
3619
(struct stab_demangle_info *, const char **, debug_type **, bfd_boolean *);
3620
static bfd_boolean stab_demangle_arg
3621
(struct stab_demangle_info *, const char **, debug_type **,
3622
unsigned int *, unsigned int *);
3623
static bfd_boolean stab_demangle_type
3624
(struct stab_demangle_info *, const char **, debug_type *);
3625
static bfd_boolean stab_demangle_fund_type
3626
(struct stab_demangle_info *, const char **, debug_type *);
3627
static bfd_boolean stab_demangle_remember_type
3628
(struct stab_demangle_info *, const char *, int);
3630
/* Warn about a bad demangling. */
3633
stab_bad_demangle (const char *s)
3635
fprintf (stderr, _("bad mangled name `%s'\n"), s);
3638
/* Get a count from a stab string. */
3641
stab_demangle_count (const char **pp)
3646
while (ISDIGIT (**pp))
3649
count += **pp - '0';
3655
/* Require a count in a string. The count may be multiple digits, in
3656
which case it must end in an underscore. */
3659
stab_demangle_get_count (const char **pp, unsigned int *pi)
3661
if (! ISDIGIT (**pp))
3679
while (ISDIGIT (*p));
3690
/* This function demangles a physical name, returning a NULL
3691
terminated array of argument types. */
3694
stab_demangle_argtypes (void *dhandle, struct stab_handle *info,
3695
const char *physname, bfd_boolean *pvarargs,
3696
unsigned int physname_len)
3698
struct stab_demangle_info minfo;
3700
minfo.dhandle = dhandle;
3703
minfo.varargs = FALSE;
3704
minfo.typestring_alloc = 10;
3705
minfo.typestrings = ((struct stab_demangle_typestring *)
3706
xmalloc (minfo.typestring_alloc
3707
* sizeof *minfo.typestrings));
3708
minfo.typestring_count = 0;
3710
/* cplus_demangle checks for special GNU mangled forms, but we can't
3711
see any of them in mangled method argument types. */
3713
if (! stab_demangle_prefix (&minfo, &physname, physname_len))
3716
if (*physname != '\0')
3718
if (! stab_demangle_signature (&minfo, &physname))
3722
free (minfo.typestrings);
3723
minfo.typestrings = NULL;
3725
if (minfo.args == NULL)
3726
fprintf (stderr, _("no argument types in mangled string\n"));
3728
*pvarargs = minfo.varargs;
3732
if (minfo.typestrings != NULL)
3733
free (minfo.typestrings);
3737
/* Demangle the prefix of the mangled name. */
3740
stab_demangle_prefix (struct stab_demangle_info *minfo, const char **pp,
3741
unsigned int physname_len)
3746
/* cplus_demangle checks for global constructors and destructors,
3747
but we can't see them in mangled argument types. */
3750
scan = *pp + physname_len;
3753
/* Look for `__'. */
3756
scan = strchr (scan, '_');
3757
while (scan != NULL && *++scan != '_');
3761
stab_bad_demangle (*pp);
3767
/* We found `__'; move ahead to the last contiguous `__' pair. */
3768
i = strspn (scan, "_");
3774
&& (ISDIGIT (scan[2])
3778
/* This is a GNU style constructor name. */
3782
else if (scan == *pp
3783
&& ! ISDIGIT (scan[2])
3786
/* Look for the `__' that separates the prefix from the
3788
while (*scan == '_')
3790
scan = strstr (scan, "__");
3791
if (scan == NULL || scan[2] == '\0')
3793
stab_bad_demangle (*pp);
3797
return stab_demangle_function_name (minfo, pp, scan);
3799
else if (scan[2] != '\0')
3801
/* The name doesn't start with `__', but it does contain `__'. */
3802
return stab_demangle_function_name (minfo, pp, scan);
3806
stab_bad_demangle (*pp);
3812
/* Demangle a function name prefix. The scan argument points to the
3813
double underscore which separates the function name from the
3817
stab_demangle_function_name (struct stab_demangle_info *minfo,
3818
const char **pp, const char *scan)
3822
/* The string from *pp to scan is the name of the function. We
3823
don't care about the name, since we just looking for argument
3824
types. However, for conversion operators, the name may include a
3825
type which we must remember in order to handle backreferences. */
3831
&& strncmp (name, "type", 4) == 0
3832
&& (name[4] == '$' || name[4] == '.'))
3836
/* This is a type conversion operator. */
3838
if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
3841
else if (name[0] == '_'
3848
/* This is a type conversion operator. */
3850
if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
3857
/* Demangle the signature. This is where the argument types are
3861
stab_demangle_signature (struct stab_demangle_info *minfo, const char **pp)
3864
bfd_boolean expect_func, func_done;
3869
expect_func = FALSE;
3873
while (**pp != '\0')
3879
if (! stab_demangle_qualified (minfo, pp, (debug_type *) NULL)
3880
|| ! stab_demangle_remember_type (minfo, hold, *pp - hold))
3887
/* Static member function. FIXME: Can this happen? */
3894
/* Const member function. */
3900
case '0': case '1': case '2': case '3': case '4':
3901
case '5': case '6': case '7': case '8': case '9':
3904
if (! stab_demangle_class (minfo, pp, (const char **) NULL)
3905
|| ! stab_demangle_remember_type (minfo, hold, *pp - hold))
3912
/* Function. I don't know if this actually happens with g++
3917
if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3925
if (! stab_demangle_template (minfo, pp, (char **) NULL)
3926
|| ! stab_demangle_remember_type (minfo, hold, *pp - hold))
3933
/* At the outermost level, we cannot have a return type
3934
specified, so if we run into another '_' at this point we
3935
are dealing with a mangled name that is either bogus, or
3936
has been mangled by some algorithm we don't know how to
3937
deal with. So just reject the entire demangling. */
3938
stab_bad_demangle (orig);
3942
/* Assume we have stumbled onto the first outermost function
3943
argument token, and start processing args. */
3945
if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3953
if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3960
/* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
3961
bar__3fooi is 'foo::bar(int)'. We get here when we find the
3962
first case, and need to ensure that the '(void)' gets added
3963
to the current declp. */
3964
if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3971
/* Demangle a qualified name, such as "Q25Outer5Inner" which is the
3972
mangled form of "Outer::Inner". */
3975
stab_demangle_qualified (struct stab_demangle_info *minfo, const char **pp,
3980
unsigned int qualifiers;
3988
/* GNU mangled name with more than 9 classes. The count is
3989
preceded by an underscore (to distinguish it from the <= 9
3990
case) and followed by an underscore. */
3992
if (! ISDIGIT (*p) || *p == '0')
3994
stab_bad_demangle (orig);
3997
qualifiers = atoi (p);
3998
while (ISDIGIT (*p))
4002
stab_bad_demangle (orig);
4008
case '1': case '2': case '3': case '4': case '5':
4009
case '6': case '7': case '8': case '9':
4010
qualifiers = (*pp)[1] - '0';
4011
/* Skip an optional underscore after the count. */
4012
if ((*pp)[2] == '_')
4019
stab_bad_demangle (orig);
4023
context = DEBUG_TYPE_NULL;
4025
/* Pick off the names. */
4026
while (qualifiers-- > 0)
4034
if (! stab_demangle_template (minfo, pp,
4035
ptype != NULL ? &name : NULL))
4040
context = stab_find_tagged_type (minfo->dhandle, minfo->info,
4041
name, strlen (name),
4044
if (context == DEBUG_TYPE_NULL)
4052
len = stab_demangle_count (pp);
4053
if (strlen (*pp) < len)
4055
stab_bad_demangle (orig);
4061
const debug_field *fields;
4064
if (context != DEBUG_TYPE_NULL)
4065
fields = debug_get_fields (minfo->dhandle, context);
4067
context = DEBUG_TYPE_NULL;
4073
/* Try to find the type by looking through the
4074
fields of context until we find a field with the
4075
same type. This ought to work for a class
4076
defined within a class, but it won't work for,
4077
e.g., an enum defined within a class. stabs does
4078
not give us enough information to figure out the
4081
name = savestring (*pp, len);
4083
for (; *fields != DEBUG_FIELD_NULL; fields++)
4088
ft = debug_get_field_type (minfo->dhandle, *fields);
4091
dn = debug_get_type_name (minfo->dhandle, ft);
4092
if (dn != NULL && strcmp (dn, name) == 0)
4102
if (context == DEBUG_TYPE_NULL)
4104
/* We have to fall back on finding the type by name.
4105
If there are more types to come, then this must
4106
be a class. Otherwise, it could be anything. */
4108
if (qualifiers == 0)
4112
name = savestring (*pp, len);
4113
context = debug_find_named_type (minfo->dhandle,
4118
if (context == DEBUG_TYPE_NULL)
4120
context = stab_find_tagged_type (minfo->dhandle,
4124
? DEBUG_KIND_ILLEGAL
4125
: DEBUG_KIND_CLASS));
4126
if (context == DEBUG_TYPE_NULL)
4142
/* Demangle a template. If PNAME is not NULL, this sets *PNAME to a
4143
string representation of the template. */
4146
stab_demangle_template (struct stab_demangle_info *minfo, const char **pp,
4156
/* Skip the template name. */
4157
r = stab_demangle_count (pp);
4158
if (r == 0 || strlen (*pp) < r)
4160
stab_bad_demangle (orig);
4165
/* Get the size of the parameter list. */
4166
if (stab_demangle_get_count (pp, &r) == 0)
4168
stab_bad_demangle (orig);
4172
for (i = 0; i < r; i++)
4176
/* This is a type parameter. */
4178
if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
4184
bfd_boolean pointerp, realp, integralp, charp, boolp;
4195
/* This is a value parameter. */
4197
if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
4200
while (*old_p != '\0' && ! done)
4210
case 'C': /* Const. */
4211
case 'S': /* Signed. */
4212
case 'U': /* Unsigned. */
4213
case 'V': /* Volatile. */
4214
case 'F': /* Function. */
4215
case 'M': /* Member function. */
4219
case 'Q': /* Qualified name. */
4223
case 'T': /* Remembered type. */
4225
case 'v': /* Void. */
4227
case 'x': /* Long long. */
4228
case 'l': /* Long. */
4229
case 'i': /* Int. */
4230
case 's': /* Short. */
4231
case 'w': /* Wchar_t. */
4235
case 'b': /* Bool. */
4239
case 'c': /* Char. */
4243
case 'r': /* Long double. */
4244
case 'd': /* Double. */
4245
case 'f': /* Float. */
4250
/* Assume it's a user defined integral type. */
4261
while (ISDIGIT (**pp))
4270
val = stab_demangle_count (pp);
4273
stab_bad_demangle (orig);
4281
val = stab_demangle_count (pp);
4282
if (val != 0 && val != 1)
4284
stab_bad_demangle (orig);
4292
while (ISDIGIT (**pp))
4297
while (ISDIGIT (**pp))
4303
while (ISDIGIT (**pp))
4311
if (! stab_demangle_get_count (pp, &len))
4313
stab_bad_demangle (orig);
4321
/* We can translate this to a string fairly easily by invoking the
4322
regular demangling routine. */
4325
char *s1, *s2, *s3, *s4 = NULL;
4328
s1 = savestring (orig, *pp - orig);
4330
s2 = concat ("NoSuchStrinG__", s1, (const char *) NULL);
4334
s3 = cplus_demangle (s2, DMGL_ANSI);
4339
s4 = strstr (s3, "::NoSuchStrinG");
4340
if (s3 == NULL || s4 == NULL)
4342
stab_bad_demangle (orig);
4348
/* Eliminating all spaces, except those between > characters,
4349
makes it more likely that the demangled name will match the
4350
name which g++ used as the structure name. */
4351
for (from = to = s3; from != s4; ++from)
4353
|| (from[1] == '>' && from > s3 && from[-1] == '>'))
4356
*pname = savestring (s3, to - s3);
4364
/* Demangle a class name. */
4367
stab_demangle_class (struct stab_demangle_info *minfo ATTRIBUTE_UNUSED,
4368
const char **pp, const char **pstart)
4375
n = stab_demangle_count (pp);
4376
if (strlen (*pp) < n)
4378
stab_bad_demangle (orig);
4390
/* Demangle function arguments. If the pargs argument is not NULL, it
4391
is set to a NULL terminated array holding the arguments. */
4394
stab_demangle_args (struct stab_demangle_info *minfo, const char **pp,
4395
debug_type **pargs, bfd_boolean *pvarargs)
4398
unsigned int alloc, count;
4405
*pargs = (debug_type *) xmalloc (alloc * sizeof **pargs);
4410
while (**pp != '_' && **pp != '\0' && **pp != 'e')
4412
if (**pp == 'N' || **pp == 'T')
4420
if (temptype == 'T')
4424
if (! stab_demangle_get_count (pp, &r))
4426
stab_bad_demangle (orig);
4431
if (! stab_demangle_get_count (pp, &t))
4433
stab_bad_demangle (orig);
4437
if (t >= minfo->typestring_count)
4439
stab_bad_demangle (orig);
4446
tem = minfo->typestrings[t].typestring;
4447
if (! stab_demangle_arg (minfo, &tem, pargs, &count, &alloc))
4453
if (! stab_demangle_arg (minfo, pp, pargs, &count, &alloc))
4459
(*pargs)[count] = DEBUG_TYPE_NULL;
4471
/* Demangle a single argument. */
4474
stab_demangle_arg (struct stab_demangle_info *minfo, const char **pp,
4475
debug_type **pargs, unsigned int *pcount,
4476
unsigned int *palloc)
4482
if (! stab_demangle_type (minfo, pp,
4483
pargs == NULL ? (debug_type *) NULL : &type)
4484
|| ! stab_demangle_remember_type (minfo, start, *pp - start))
4489
if (type == DEBUG_TYPE_NULL)
4492
if (*pcount + 1 >= *palloc)
4495
*pargs = ((debug_type *)
4496
xrealloc (*pargs, *palloc * sizeof **pargs));
4498
(*pargs)[*pcount] = type;
4505
/* Demangle a type. If the ptype argument is not NULL, *ptype is set
4506
to the newly allocated type. */
4509
stab_demangle_type (struct stab_demangle_info *minfo, const char **pp,
4520
/* A pointer type. */
4522
if (! stab_demangle_type (minfo, pp, ptype))
4525
*ptype = debug_make_pointer_type (minfo->dhandle, *ptype);
4529
/* A reference type. */
4531
if (! stab_demangle_type (minfo, pp, ptype))
4534
*ptype = debug_make_reference_type (minfo->dhandle, *ptype);
4544
while (**pp != '\0' && **pp != '_')
4546
if (! ISDIGIT (**pp))
4548
stab_bad_demangle (orig);
4557
stab_bad_demangle (orig);
4562
if (! stab_demangle_type (minfo, pp, ptype))
4566
debug_type int_type;
4568
int_type = debug_find_named_type (minfo->dhandle, "int");
4569
if (int_type == NULL)
4570
int_type = debug_make_int_type (minfo->dhandle, 4, FALSE);
4571
*ptype = debug_make_array_type (minfo->dhandle, *ptype, int_type,
4578
/* A back reference to a remembered type. */
4584
if (! stab_demangle_get_count (pp, &i))
4586
stab_bad_demangle (orig);
4589
if (i >= minfo->typestring_count)
4591
stab_bad_demangle (orig);
4594
p = minfo->typestrings[i].typestring;
4595
if (! stab_demangle_type (minfo, &p, ptype))
4604
bfd_boolean varargs;
4607
if (! stab_demangle_args (minfo, pp,
4609
? (debug_type **) NULL
4612
? (bfd_boolean *) NULL
4617
/* cplus_demangle will accept a function without a return
4618
type, but I don't know when that will happen, or what
4619
to do if it does. */
4620
stab_bad_demangle (orig);
4624
if (! stab_demangle_type (minfo, pp, ptype))
4627
*ptype = debug_make_function_type (minfo->dhandle, *ptype, args,
4636
bfd_boolean memberp, constp, volatilep;
4637
debug_type class_type = DEBUG_TYPE_NULL;
4639
bfd_boolean varargs;
4643
memberp = **pp == 'M';
4652
n = stab_demangle_count (pp);
4653
if (strlen (*pp) < n)
4655
stab_bad_demangle (orig);
4663
class_type = stab_find_tagged_type (minfo->dhandle,
4667
if (class_type == DEBUG_TYPE_NULL)
4671
else if (**pp == 'Q')
4673
if (! stab_demangle_qualified (minfo, pp,
4675
? (debug_type *) NULL
4681
stab_bad_demangle (orig);
4692
else if (**pp == 'V')
4699
stab_bad_demangle (orig);
4703
if (! stab_demangle_args (minfo, pp,
4705
? (debug_type **) NULL
4708
? (bfd_boolean *) NULL
4715
stab_bad_demangle (orig);
4720
if (! stab_demangle_type (minfo, pp, ptype))
4726
*ptype = debug_make_offset_type (minfo->dhandle, class_type,
4730
/* FIXME: We have no way to record constp or
4732
*ptype = debug_make_method_type (minfo->dhandle, *ptype,
4733
class_type, args, varargs);
4741
if (! stab_demangle_type (minfo, pp, ptype))
4747
if (! stab_demangle_type (minfo, pp, ptype))
4750
*ptype = debug_make_const_type (minfo->dhandle, *ptype);
4758
if (! stab_demangle_qualified (minfo, pp, ptype))
4764
if (! stab_demangle_fund_type (minfo, pp, ptype))
4772
/* Demangle a fundamental type. If the ptype argument is not NULL,
4773
*ptype is set to the newly allocated type. */
4776
stab_demangle_fund_type (struct stab_demangle_info *minfo, const char **pp,
4780
bfd_boolean constp, volatilep, unsignedp, signedp;
4825
/* cplus_demangle permits this, but I don't know what it means. */
4826
stab_bad_demangle (orig);
4829
case 'v': /* void */
4832
*ptype = debug_find_named_type (minfo->dhandle, "void");
4833
if (*ptype == DEBUG_TYPE_NULL)
4834
*ptype = debug_make_void_type (minfo->dhandle);
4839
case 'x': /* long long */
4842
*ptype = debug_find_named_type (minfo->dhandle,
4844
? "long long unsigned int"
4845
: "long long int"));
4846
if (*ptype == DEBUG_TYPE_NULL)
4847
*ptype = debug_make_int_type (minfo->dhandle, 8, unsignedp);
4852
case 'l': /* long */
4855
*ptype = debug_find_named_type (minfo->dhandle,
4857
? "long unsigned int"
4859
if (*ptype == DEBUG_TYPE_NULL)
4860
*ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp);
4868
*ptype = debug_find_named_type (minfo->dhandle,
4872
if (*ptype == DEBUG_TYPE_NULL)
4873
*ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp);
4878
case 's': /* short */
4881
*ptype = debug_find_named_type (minfo->dhandle,
4883
? "short unsigned int"
4885
if (*ptype == DEBUG_TYPE_NULL)
4886
*ptype = debug_make_int_type (minfo->dhandle, 2, unsignedp);
4891
case 'b': /* bool */
4894
*ptype = debug_find_named_type (minfo->dhandle, "bool");
4895
if (*ptype == DEBUG_TYPE_NULL)
4896
*ptype = debug_make_bool_type (minfo->dhandle, 4);
4901
case 'c': /* char */
4904
*ptype = debug_find_named_type (minfo->dhandle,
4910
if (*ptype == DEBUG_TYPE_NULL)
4911
*ptype = debug_make_int_type (minfo->dhandle, 1, unsignedp);
4916
case 'w': /* wchar_t */
4919
*ptype = debug_find_named_type (minfo->dhandle, "__wchar_t");
4920
if (*ptype == DEBUG_TYPE_NULL)
4921
*ptype = debug_make_int_type (minfo->dhandle, 2, TRUE);
4926
case 'r': /* long double */
4929
*ptype = debug_find_named_type (minfo->dhandle, "long double");
4930
if (*ptype == DEBUG_TYPE_NULL)
4931
*ptype = debug_make_float_type (minfo->dhandle, 8);
4936
case 'd': /* double */
4939
*ptype = debug_find_named_type (minfo->dhandle, "double");
4940
if (*ptype == DEBUG_TYPE_NULL)
4941
*ptype = debug_make_float_type (minfo->dhandle, 8);
4946
case 'f': /* float */
4949
*ptype = debug_find_named_type (minfo->dhandle, "float");
4950
if (*ptype == DEBUG_TYPE_NULL)
4951
*ptype = debug_make_float_type (minfo->dhandle, 4);
4958
if (! ISDIGIT (**pp))
4960
stab_bad_demangle (orig);
4964
case '0': case '1': case '2': case '3': case '4':
4965
case '5': case '6': case '7': case '8': case '9':
4969
if (! stab_demangle_class (minfo, pp, &hold))
4975
name = savestring (hold, *pp - hold);
4976
*ptype = debug_find_named_type (minfo->dhandle, name);
4978
if (*ptype == DEBUG_TYPE_NULL)
4980
/* FIXME: It is probably incorrect to assume that
4981
undefined types are tagged types. */
4982
*ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
4984
DEBUG_KIND_ILLEGAL);
4985
if (*ptype == DEBUG_TYPE_NULL)
4996
if (! stab_demangle_template (minfo, pp,
4997
ptype != NULL ? &name : NULL))
5001
*ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
5002
name, strlen (name),
5005
if (*ptype == DEBUG_TYPE_NULL)
5012
stab_bad_demangle (orig);
5019
*ptype = debug_make_const_type (minfo->dhandle, *ptype);
5021
*ptype = debug_make_volatile_type (minfo->dhandle, *ptype);
5027
/* Remember a type string in a demangled string. */
5030
stab_demangle_remember_type (struct stab_demangle_info *minfo,
5031
const char *p, int len)
5033
if (minfo->typestring_count >= minfo->typestring_alloc)
5035
minfo->typestring_alloc += 10;
5036
minfo->typestrings = ((struct stab_demangle_typestring *)
5037
xrealloc (minfo->typestrings,
5038
(minfo->typestring_alloc
5039
* sizeof *minfo->typestrings)));
5042
minfo->typestrings[minfo->typestring_count].typestring = p;
5043
minfo->typestrings[minfo->typestring_count].len = (unsigned int) len;
5044
++minfo->typestring_count;
added
removed
binutils/stabs.c
